TAO/tests/Bug_2319_Regression/server.cpp

   1
   2 #include "ace/Thread_Manager.h"
   3 #include "ace/OS_NS_stdio.h"
   4 #include "ace/OS_NS_unistd.h"
   5 #include "ace/Get_Opt.h"
   6
   7 #include "TestS.h"
   8 #include "TestC.h"
   9
  10 int num_calls = 10; // total calls client is going to make
  11 const int sleep_time = 1; // sleep for  1 sec on each call
  12
  13 // This should equal num_calls within 'sleep * num_calls' seconds
  14 int calls_received = 0;
  15
  16 const ACE_TCHAR *ior      = ACE_TEXT("file://test.ior");
  17 const ACE_TCHAR *ior_file = ACE_TEXT("test.ior");
  18
  19 /***************************/
  20 /*** Servant Declaration ***/
  21 /***************************/
  22
  23 class ST_AMH_Servant : public virtual POA_Test::AMH_Roundtrip
  24 {
  25 public:
  26   ST_AMH_Servant (CORBA::ORB_ptr orb);
  27
  28   void test_method (Test::AMH_RoundtripResponseHandler_ptr _tao_rh,
  29                     Test::Timestamp send_time);
  30
  31 protected:
  32   CORBA::ORB_ptr orb_;
  33 };
  34
  35 /****************************/
  36 /**** Server Declaration ****/
  37 /****************************/
  38
  39 /**
  40  Class that performs all 'dirty' initialisation work that is common to
  41  all the AMH servers and 'hides' all the common ORB functions.
  42  */
  43 class ST_AMH_Server
  44 {
  45 public:
  46   ST_AMH_Server (void);
  47   virtual ~ST_AMH_Server ();
  48
  49   /// ORB inititalisation stuff
  50   int start_orb_and_poa (const CORBA::ORB_var &_orb);
  51
  52   /// register the servant with the poa
  53   virtual void register_servant (ST_AMH_Servant *servant);
  54
  55   /// orb-perform_work () abstraction
  56   virtual void run_event_loop ();
  57
  58 public:
  59
  60 protected:
  61   CORBA::ORB_ptr orb_;
  62   PortableServer::POA_var root_poa_;
  63
  64 private:
  65   /// Write servant IOR to file specified with the '-o' option
  66   int write_ior_to_file (CORBA::String_var ior);
  67 };
  68
  69 // ------------------------------------------------------------------------
  70 // ------------------------------------------------------------------------
  71 // ------------------------------------------------------------------------
  72
  73 // ------------------------------------------------------------------------
  74 //
  75 int parse_args (int argc, ACE_TCHAR *argv[])
  76 {
  77   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("n:o:k:"));
  78   int c;
  79
  80   while ((c = get_opts ()) != -1)
  81     switch (c)
  82       {
  83       case 'n':
  84         num_calls = ACE_OS::atoi (get_opts.opt_arg ());
  85         break;
  86       case 'o':
  87         ior_file = get_opts.opt_arg ();
  88         break;
  89       case 'k':
  90         ior = get_opts.opt_arg ();
  91         break;
  92       default:
  93         break;
  94       }
  95   return 0;
  96 }
  97
  98 /***************************/
  99 /*** Servant Definition ***/
 100 /***************************/
 101
 102 // ------------------------------------------------------------------------
 103 //
 104 ST_AMH_Servant::ST_AMH_Servant (CORBA::ORB_ptr orb)
 105   : orb_(CORBA::ORB::_duplicate(orb))
 106 {
 107 }
 108
 109 // ------------------------------------------------------------------------
 110 //
 111 void
 112 ST_AMH_Servant::test_method (Test::AMH_RoundtripResponseHandler_ptr,
 113                              Test::Timestamp)
 114 {
 115   ACE_OS::printf("Received Timestamp # %d\n", calls_received);
 116   ACE_OS::sleep(1);
 117   ++calls_received;
 118
 119   // When _tao_rh destructor is called, it shouldn't send anything to
 120   // the client as well
 121 }
 122
 123 /*** Server Declaration ***/
 124
 125 // ------------------------------------------------------------------------
 126 //
 127 ST_AMH_Server::ST_AMH_Server (void)
 128 {
 129 }
 130
 131 // ------------------------------------------------------------------------
 132 //
 133 ST_AMH_Server::~ST_AMH_Server ()
 134 {
 135   try
 136     {
 137       this->root_poa_->destroy (1, 1);
 138     }
 139   catch (const CORBA::Exception& ex)
 140     {
 141       ex._tao_print_exception ("Exception caught:");
 142     }
 143 }
 144
 145 // ------------------------------------------------------------------------
 146 //
 147 int ST_AMH_Server::start_orb_and_poa (const CORBA::ORB_var &_orb)
 148 {
 149   try
 150     {
 151       this->orb_ = CORBA::ORB::_duplicate(_orb.in ());
 152
 153       CORBA::Object_var poa_object =
 154         this->orb_->resolve_initial_references("RootPOA");
 155
 156       if (CORBA::is_nil (poa_object.in ()))
 157         ACE_ERROR_RETURN ((LM_ERROR,
 158                            " (%P|%t) Unable to initialize the POA.\n"),
 159                           1);
 160
 161       this->root_poa_ = PortableServer::POA::_narrow (poa_object.in ());
 162
 163       PortableServer::POAManager_var poa_manager =
 164         this->root_poa_->the_POAManager ();
 165
 166       poa_manager->activate ();
 167     }
 168   catch (const CORBA::Exception& ex)
 169     {
 170       ex._tao_print_exception ("Exception caught:");
 171       return -1;
 172     }
 173
 174   return 0;
 175 }
 176
 177 // ------------------------------------------------------------------------
 178 //
 179 void ST_AMH_Server::register_servant (ST_AMH_Servant *servant)
 180 {
 181   try
 182     {
 183       CORBA::Object_var poa_object =
 184         this->orb_->resolve_initial_references("RootPOA");
 185
 186       PortableServer::POA_var root_poa =
 187         PortableServer::POA::_narrow (poa_object.in ());
 188
 189       PortableServer::ObjectId_var id =
 190         root_poa->activate_object (servant);
 191
 192       CORBA::Object_var object = root_poa->id_to_reference (id.in ());
 193
 194       Test::Roundtrip_var roundtrip = Test::Roundtrip::_narrow (object.in ());
 195
 196       CORBA::String_var iorstr = this->orb_->object_to_string(roundtrip.in ());
 197
 198       (void) this->write_ior_to_file(iorstr);
 199     }
 200   catch (const CORBA::Exception& ex)
 201     {
 202       ex._tao_print_exception ("Exception caught:");
 203     }
 204 }
 205
 206 // ------------------------------------------------------------------------
 207 //
 208 void ST_AMH_Server::run_event_loop ()
 209 {
 210   try
 211     {
 212       ACE_Time_Value period (1, 0);
 213       while (1)
 214         {
 215           this->orb_->perform_work (&period);
 216
 217           // when all calls from client have been received, exit
 218           if (calls_received == num_calls )
 219             return;
 220         }
 221     }
 222   catch (const CORBA::Exception&)
 223     {
 224     }
 225 }
 226
 227 // ------------------------------------------------------------------------
 228 //
 229 int
 230 ST_AMH_Server::write_ior_to_file (CORBA::String_var iorstr)
 231 {
 232   // If the ior_output_file exists, output the ior to it
 233   FILE *output_file= ACE_OS::fopen (ior_file, "w");
 234   if (output_file == 0)
 235     {
 236       ACE_ERROR ((LM_ERROR,
 237                   "Cannot open output file for writing IOR: %s",
 238                   ior_file));
 239       return -1;
 240     }
 241
 242   ACE_OS::fprintf (output_file, "%s", iorstr.in ());
 243   ACE_OS::fclose (output_file);
 244   return 0;
 245 }
 246
 247
 248 // ------------------------------------------------------------------------
 249 //
 250 static ACE_THR_FUNC_RETURN start_server(void* _arg)
 251 {
 252   ST_AMH_Server *amh_server = static_cast<ST_AMH_Server*>(_arg);
 253   amh_server->run_event_loop();
 254   return 0;
 255 }
 256
 257 // ------------------------------------------------------------------------
 258 //
 259 static ACE_THR_FUNC_RETURN start_client(void* _arg)
 260 {
 261   Test::Roundtrip_var roundtrip(static_cast<Test::Roundtrip_ptr>(_arg));
 262
 263   // Do a couple of calls on the server. If the sever is trying to
 264   // do something stupid like sending an exception to us, then it
 265   // won't be able to handle more than 1 request from us.
 266   Test::Timestamp time = 10;
 267
 268   for (int i = 0; i < num_calls; i++)
 269     {
 270       roundtrip->test_method(time);
 271       ACE_DEBUG ((LM_DEBUG, "Sent call # %d\n", i));
 272     }
 273
 274   return 0;
 275 }
 276
 277
 278 // ------------------------------------------------------------------------
 279 //
 280 int ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 281 {
 282   if (parse_args (argc, argv) != 0)
 283     return 1;
 284
 285   ST_AMH_Server amh_server;
 286   CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
 287
 288   amh_server.start_orb_and_poa(orb);
 289
 290   ST_AMH_Servant servant(orb.in());
 291
 292   amh_server.register_servant(&servant);
 293
 294   CORBA::Object_var object =  orb->string_to_object(ior);
 295
 296   Test::Roundtrip_var roundtrip = Test::Roundtrip::_narrow(object.in ());
 297
 298   if (CORBA::is_nil(roundtrip.in()))
 299     {
 300       ACE_ERROR_RETURN ((LM_ERROR,
 301                          "Nil Test::Roundtrip reference <%s>\n",
 302                          ior),
 303                         1);
 304     }
 305
 306   ACE_thread_t serverThr;
 307   ACE_thread_t clientThr;
 308
 309   ACE_Thread_Manager::instance()->spawn(start_server,
 310                                         (void*)&amh_server,
 311                                         THR_NEW_LWP | THR_JOINABLE,
 312                                         &serverThr);
 313
 314   ACE_Thread_Manager::instance()->spawn(start_client,
 315                                         (void*)roundtrip.in (),
 316                                         THR_NEW_LWP | THR_JOINABLE,
 317                                         &clientThr);
 318
 319   ACE_Thread_Manager::instance()->join(clientThr);
 320   ACE_OS::printf("End client\n");
 321   ACE_Thread_Manager::instance()->join(serverThr);
 322   ACE_OS::printf("End server\n");
 323
 324   orb->destroy();
 325
 326   return 0;
 327 }