TAO/tests/Bug_3543_Regression/master.cpp

   1 #include "ace/Synch.h"
   2 #include "ace/Task.h"
   3 #include "masterS.h"
   4 #include "tao/ORB.h"
   5 #include "ace/Get_Opt.h"
   6 #include "ace/OS_NS_unistd.h"
   7 #include "ace/Barrier.h"
   8 #include <list>
   9
  10 const ACE_TCHAR *ior_output_file = ACE_TEXT ("test.ior");
  11 size_t number_of_servers = 300;
  12 size_t steps = 10;
  13 int n_threads = 10;
  14 ACE_Barrier *barrier = 0;
  15 CORBA::ORB_var orb;
  16
  17 int
  18 parse_args (int argc, ACE_TCHAR *argv[])
  19 {
  20   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("o:c:s:"));
  21   int c;
  22
  23   while ((c = get_opts ()) != -1)
  24     switch (c)
  25       {
  26       case 'o':
  27         ior_output_file = get_opts.opt_arg ();
  28         break;
  29       case 'c':
  30         number_of_servers = ACE_OS::atoi(get_opts.opt_arg ());
  31         break;
  32       case 's':
  33         steps = ACE_OS::atoi(get_opts.opt_arg ());
  34         break;
  35
  36       case '?':
  37       default:
  38         ACE_ERROR_RETURN ((LM_ERROR,
  39                            "usage:  %s "
  40                            "-o <ior> "
  41                            "-c <number of servers> "
  42                            "-s <steps> "
  43                            "\n",
  44                            argv [0]),
  45                           -1);
  46       }
  47   // Indicates successful parsing of the command line
  48   return 0;
  49 }
  50
  51 static TAO_SYNCH_MUTEX mutex;
  52 std::list<MasterClient::Server_var> servers;
  53 bool started = false;
  54
  55 class MasterImpl : public POA_MasterClient::Master
  56 {
  57 public:
  58   MasterImpl()
  59   {
  60   }
  61
  62   virtual void registerServer(MasterClient::Server_ptr c)
  63   {
  64     ACE_GUARD(TAO_SYNCH_MUTEX, mon, mutex);
  65     servers.push_back(MasterClient::Server::_duplicate(c));
  66     if (servers.size () == number_of_servers)
  67     {
  68       started = true;
  69     }
  70     else
  71     {
  72       ACE_DEBUG ((LM_DEBUG, "%d server registered with master\n", servers.size()));
  73     }
  74   }
  75 };
  76
  77 void Dispatcher_shutdown()
  78 {
  79     std::list<MasterClient::Server_var> copiedlist;
  80     {
  81       ACE_GUARD(TAO_SYNCH_MUTEX, mon, mutex);
  82       copiedlist = servers;
  83     }
  84     std::list<MasterClient::Server_var>::iterator it;
  85     for(it = copiedlist.begin(); it != copiedlist.end(); ++it)
  86     {
  87       try
  88       {
  89         (*it)->shutdown();
  90       }
  91       catch(...)
  92       {
  93       }
  94     }
  95 }
  96
  97 void Dispatcher_step(int id, int i)
  98 {
  99     std::list<MasterClient::Server_var> copiedlist;
 100     {
 101       ACE_GUARD(TAO_SYNCH_MUTEX, mon, mutex);
 102       copiedlist = servers;
 103     }
 104
 105     ACE_DEBUG ((LM_DEBUG, "Id %d Sending %d pings in iteration %d\n", id, copiedlist.size(), i));
 106     int ok = 0;
 107     int timeout = 0;
 108     int transient = 0;
 109     int corba = 0;
 110     int unknown = 0;
 111
 112     std::list<MasterClient::Server_var>::iterator it;
 113     for(it = copiedlist.begin(); it != copiedlist.end(); ++it)
 114     {
 115       try
 116       {
 117         (*it)->ping();
 118         ++ok;
 119       }
 120       catch(CORBA::TIMEOUT &)
 121       {
 122           ++timeout;
 123       }
 124       catch(CORBA::TRANSIENT &)
 125       {
 126           ++transient;
 127       }
 128       catch(CORBA::Exception &e)
 129       {
 130         ACE_ERROR ((LM_ERROR, "ERROR: Caught CORBA exception %C", e._info ().c_str()));
 131           ++corba;
 132       }
 133       catch(...)
 134       {
 135           ++unknown;
 136       }
 137     }
 138     if(ok)
 139       {
 140         ACE_ERROR ((LM_ERROR, "Ok: %d\n", ok));
 141       }
 142     if(timeout)
 143       {
 144         ACE_ERROR ((LM_ERROR, "TIMEOUT: %d\n", timeout));
 145       }
 146     if(transient)
 147       {
 148         ACE_ERROR ((LM_ERROR, "TRANSIENT: %d\n", transient));
 149       }
 150     if(corba)
 151       {
 152         ACE_ERROR ((LM_ERROR, "CORBA: %d\n", corba));
 153       }
 154     if(unknown)
 155       {
 156         ACE_ERROR ((LM_ERROR, "UNKNOWN: %d\n", unknown));
 157       }
 158 }
 159
 160 void Dispatcher_run(int id)
 161 {
 162   size_t i = 0;
 163   while(1)
 164     {
 165       if(started)
 166         {
 167           Dispatcher_step (id, i);
 168           ++i;
 169         }
 170       if (i >= steps)
 171       {
 172         ACE_DEBUG ((LM_DEBUG, "Id %d ready\n", id));
 173         break;
 174       }
 175       ACE_OS::sleep(1);
 176     }
 177   ACE_DEBUG ((LM_DEBUG, "Waiting for barrier\n"));
 178   barrier->wait ();
 179   if (id == 0)
 180   {
 181     ACE_DEBUG ((LM_DEBUG, "Shutting down ORB\n"));
 182     orb->shutdown (true);
 183   }
 184 }
 185
 186 int
 187 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 188 {
 189   try
 190     {
 191       orb = CORBA::ORB_init (argc, argv);
 192
 193       if (parse_args (argc, argv) != 0)
 194         return 1;
 195
 196       CORBA::Object_var poa_object =
 197         orb->resolve_initial_references("RootPOA");
 198
 199       PortableServer::POA_var root_poa =
 200         PortableServer::POA::_narrow (poa_object.in ());
 201
 202       if (CORBA::is_nil (root_poa.in ()))
 203         ACE_ERROR_RETURN ((LM_ERROR,
 204                            " (%P|%t) Panic: nil RootPOA\n"),
 205                           1);
 206
 207       PortableServer::POAManager_var poa_manager = root_poa->the_POAManager ();
 208
 209       MasterImpl *hello_impl = 0;
 210       ACE_NEW_RETURN (hello_impl,
 211                       MasterImpl,
 212                       1);
 213       PortableServer::ServantBase_var owner_transfer(hello_impl);
 214
 215       PortableServer::ObjectId_var id =
 216         root_poa->activate_object (hello_impl);
 217
 218       CORBA::Object_var object = root_poa->id_to_reference (id.in ());
 219
 220       MasterClient::Master_var hello = MasterClient::Master::_narrow (object.in ());
 221
 222       poa_manager->activate ();
 223
 224       CORBA::String_var ior = orb->object_to_string (hello.in ());
 225
 226       // Output the IOR to the <ior_output_file>
 227       FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
 228       if (output_file == 0)
 229         ACE_ERROR_RETURN ((LM_ERROR,
 230                            "Cannot open output file for writing IOR: %s\n",
 231                            ior_output_file),
 232                            1);
 233       ACE_OS::fprintf (output_file, "%s", ior.in ());
 234       ACE_OS::fclose (output_file);
 235
 236       barrier = new ACE_Barrier (n_threads);
 237
 238       ACE_Thread_Manager *thr_mgr = ACE_Thread_Manager::instance ();
 239
 240       for(int i = 0; i < n_threads; ++i)
 241         {
 242           thr_mgr->spawn_n (1, ACE_THR_FUNC (Dispatcher_run), reinterpret_cast<void *> (i), THR_NEW_LWP | THR_DETACHED);
 243         }
 244
 245       orb->run();
 246
 247       ACE_DEBUG ((LM_DEBUG, "Orb shutdown\n"));
 248
 249       thr_mgr->wait ();
 250
 251       ACE_DEBUG ((LM_DEBUG, "Worker threads ready\n"));
 252
 253       Dispatcher_shutdown ();
 254
 255       servers.clear ();
 256
 257       root_poa->destroy (true, true);
 258
 259       orb->destroy ();
 260
 261       orb = CORBA::ORB::_nil ();
 262
 263       delete barrier;
 264     }
 265   catch (const CORBA::Exception& ex)
 266     {
 267       ex._tao_print_exception ("Exception caught:");
 268       return 1;
 269     }
 270
 271   return 0;
 272 }
 273