TAO/tests/Big_Oneways/server.cpp

   1 #include "Coordinator.h"
   2 #include "Session_Control.h"
   3 #include "ace/Get_Opt.h"
   4 #include "ace/OS_NS_stdio.h"
   5 #include "ace/OS_NS_unistd.h"
   6
   7 const ACE_TCHAR *ior_output_file = ACE_TEXT("test.ior");
   8 CORBA::ULong peer_count    = 4;
   9 CORBA::ULong payload_size  = 1024;
  10 CORBA::ULong message_count = 1000;
  11 CORBA::ULong thread_count  = 4;
  12
  13 int
  14 parse_args (int argc, ACE_TCHAR *argv[])
  15 {
  16   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:p:b:i:n:"));
  17   int c;
  18
  19   while ((c = get_opts ()) != -1)
  20     switch (c)
  21       {
  22       case 'o':
  23         ior_output_file = get_opts.opt_arg ();
  24         break;
  25
  26       case 'p':
  27         peer_count  = ACE_OS::atoi (get_opts.opt_arg ());
  28         break;
  29
  30       case 'b':
  31         payload_size  = ACE_OS::atoi (get_opts.opt_arg ());
  32         break;
  33
  34       case 'i':
  35         message_count = ACE_OS::atoi (get_opts.opt_arg ());
  36         break;
  37
  38       case 'n':
  39         thread_count = ACE_OS::atoi (get_opts.opt_arg ());
  40         break;
  41
  42       case '?':
  43       default:
  44         ACE_ERROR_RETURN ((LM_ERROR,
  45                            "usage:  %s "
  46                            "-o <iorfile> "
  47                            "-p <peer_count> "
  48                            "-b <payload_size> "
  49                            "-i <message_count> "
  50                            "-n <thread_count> "
  51                            "\n",
  52                            argv [0]),
  53                           -1);
  54       }
  55   // Indicates successful parsing of the command line
  56   return 0;
  57 }
  58
  59 int
  60 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
  61 {
  62   try
  63     {
  64       CORBA::ORB_var orb =
  65         CORBA::ORB_init (argc, argv);
  66
  67       CORBA::Object_var poa_object =
  68         orb->resolve_initial_references("RootPOA");
  69
  70       PortableServer::POA_var root_poa =
  71         PortableServer::POA::_narrow (poa_object.in ());
  72
  73       if (CORBA::is_nil (poa_object.in ()))
  74         ACE_ERROR_RETURN ((LM_ERROR,
  75                            " (%P|%t) Panic got a nil RootPOA\n"),
  76                           1);
  77
  78       PortableServer::POAManager_var poa_manager =
  79         root_poa->the_POAManager ();
  80
  81       if (parse_args (argc, argv) != 0)
  82         return 1;
  83
  84       Coordinator *coordinator_impl = 0;
  85       ACE_NEW_RETURN (coordinator_impl,
  86                       Coordinator (peer_count),
  87                       1);
  88       PortableServer::ServantBase_var coordinator_owner (coordinator_impl);
  89
  90       PortableServer::ObjectId_var id =
  91         root_poa->activate_object (coordinator_impl);
  92
  93       CORBA::Object_var object = root_poa->id_to_reference (id.in ());
  94
  95       Test::Coordinator_var coordinator =
  96         Test::Coordinator::_narrow (object.in ());
  97
  98       poa_manager->activate ();
  99
 100       CORBA::String_var ior =
 101         orb->object_to_string (coordinator.in ());
 102
 103       // If the ior_output_file exists, output the ior to it
 104       FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
 105       if (output_file == 0)
 106         ACE_ERROR_RETURN ((LM_ERROR,
 107                            "Cannot open output file for writing IOR: %s",
 108                            ior_output_file),
 109                               1);
 110       ACE_OS::fprintf (output_file, "%s", ior.in ());
 111       ACE_OS::fclose (output_file);
 112
 113       ACE_DEBUG ((LM_DEBUG, "Waiting for peers . . . "));
 114       for (int i = 0;
 115            i != 60 && !coordinator_impl->has_all_peers ();
 116            ++i)
 117         {
 118           ACE_Time_Value tv (1, 0);
 119           orb->run (tv);
 120         }
 121       ACE_DEBUG ((LM_DEBUG, "done.\n"));
 122
 123       if (!coordinator_impl->has_all_peers ())
 124         {
 125           ACE_ERROR ((LM_DEBUG,
 126                       "ERROR: timeout, some peers failed to register\n"));
 127           return 1;
 128         }
 129
 130       ACE_DEBUG ((LM_DEBUG, "Building session list . . . "));
 131
 132       Session_Control *session_control_impl = 0;
 133       ACE_NEW_RETURN (session_control_impl,
 134                       Session_Control (peer_count),
 135                       1);
 136       PortableServer::ServantBase_var session_control_owner (session_control_impl);
 137
 138       PortableServer::ObjectId_var idu =
 139         root_poa->activate_object (session_control_impl);
 140
 141       CORBA::Object_var objectu = root_poa->id_to_reference (idu.in ());
 142
 143       Test::Session_Control_var session_control =
 144         Test::Session_Control::_narrow (objectu.in ());
 145
 146       Test::Session_List session_list;
 147       coordinator_impl->create_session_list (session_control.in (),
 148                                              payload_size,
 149                                              thread_count,
 150                                              message_count,
 151                                              session_list);
 152
 153       ACE_ASSERT (session_list.length () == peer_count);
 154
 155       ACE_DEBUG ((LM_DEBUG, "done.\n"));
 156       ACE_DEBUG ((LM_DEBUG, "Giving start signal . . . "));
 157
 158       CORBA::ULong j;
 159       for (j = 0; j != peer_count; ++j)
 160         {
 161           // Make a copy of the sessions, excluding the j-th element
 162           Test::Session_List other_sessions (peer_count - 1);
 163           other_sessions.length (peer_count - 1);
 164           CORBA::ULong count = 0;
 165           for (CORBA::ULong k = 0; k != peer_count; ++k)
 166             {
 167               if (k == j)
 168                 continue;
 169               other_sessions[count++] =
 170                 Test::Session::_duplicate (session_list[k]);
 171             }
 172
 173           session_list[j]->start (other_sessions);
 174         }
 175
 176       ACE_DEBUG ((LM_DEBUG ,"done\n"));
 177       ACE_DEBUG ((LM_DEBUG, "Waiting for sessions to finish. . .\n"));
 178       for (int k = 0;
 179            k != 300 && !session_control_impl->all_sessions_finished ();
 180            ++k)
 181         {
 182           ACE_Time_Value tv (1, 0);
 183           orb->run (tv);
 184         }
 185
 186       if (!session_control_impl->all_sessions_finished ())
 187         {
 188           ACE_ERROR ((LM_ERROR,
 189                       "ERROR: timeout waiting for sessions\n"));
 190           return 1;
 191         }
 192
 193       ACE_DEBUG ((LM_DEBUG, "All sessions finished, destroy session list . . .\n"));
 194
 195       for (j = 0; j != peer_count; ++j)
 196         {
 197           session_list[j]->destroy ();
 198         }
 199
 200       ACE_DEBUG ((LM_DEBUG, "Shutdown all peers . . .\n"));
 201
 202       coordinator_impl->shutdown_all_peers ();
 203       ACE_OS::sleep (5); // Allow the shutdown message to be processed.
 204       ACE_DEBUG ((LM_DEBUG, "Shutdown poa and orb . . .\n"));
 205
 206       root_poa->destroy (true, true);
 207
 208       orb->destroy ();
 209     }
 210   catch (const CORBA::Exception& ex)
 211     {
 212       ex._tao_print_exception ("Exception caught:");
 213       return 1;
 214     }
 215
 216   return 0;
 217 }