TAO/orbsvcs/tests/Bug_2248_Regression/client.cpp

   1 #include "client.h"
   2 #include "Client_i.h"
   3 #include "testC.h"
   4 #include "ace/Get_Opt.h"
   5 #include "ace/Read_Buffer.h"
   6 #include "tao/IORManipulation/IORManip_Loader.h"
   7 #include "tao/PortableServer/PortableServer.h"
   8 // Ensure that the PI library is linked in when building statically
   9 #include "tao/PI/PI.h"
  10 #include "orbsvcs/FaultTolerance/FT_Service_Activate.h"
  11 #include "orbsvcs/FaultTolerance/FT_IOGR_Property.h"
  12 #include "ace/OS_NS_stdio.h"
  13 #include "ace/OS_NS_unistd.h"
  14
  15 // Files which have the IOR
  16 const ACE_TCHAR *first_ior = 0;
  17 const ACE_TCHAR *first_key = 0;
  18 const ACE_TCHAR *second_ior = 0;
  19 const ACE_TCHAR *second_key = 0;
  20 const ACE_TCHAR *first_iogr_file = 0;
  21 const ACE_TCHAR *second_iogr_file = 0;
  22
  23 int sleep_delay = 15; //seconds
  24
  25 // Objects
  26 CORBA::Object_var object_primary = 0;
  27 CORBA::Object_var object_secondary = 0;
  28
  29 // Reference to the IOR manipulator
  30
  31 int
  32 parse_args (int argc, ACE_TCHAR *argv[])
  33 {
  34   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("a:k:b:l:g:h:t:"));
  35   int c;
  36
  37   while ((c = get_opts ()) != -1)
  38     switch (c)
  39       {
  40       case 'a':
  41         first_ior = get_opts.opt_arg ();
  42         break;
  43       case 'k':
  44         first_key = get_opts.opt_arg ();
  45         break;
  46       case 'b':
  47         second_ior = get_opts.opt_arg ();
  48         break;
  49       case 'l':
  50         second_key = get_opts.opt_arg ();
  51         break;
  52       case 'g':
  53         first_iogr_file = get_opts.opt_arg ();
  54         break;
  55       case 'h':
  56         second_iogr_file = get_opts.opt_arg ();
  57         break;
  58       case 't':
  59         sleep_delay = ACE_OS::atoi(get_opts.opt_arg ());
  60         break;
  61       case '?':
  62       default:
  63         ACE_ERROR_RETURN ((LM_ERROR,
  64                            "usage:  %s "
  65                            "-a <iorfile1> -k <key1> "
  66                            "-b <iorfile2> -l <key2> "
  67                            "-g <iogr v10 output file> "
  68                            "-h <iogr v11 output file> "
  69                            "\n",
  70                            argv [0]),
  71                           -1);
  72       }
  73   // Indicates successful parsing of the command line
  74   return 0;
  75 }
  76
  77
  78 int
  79 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
  80 {
  81   Manager manager;
  82
  83   try
  84     {
  85       // Initilaize the ORB, POA etc.
  86       manager.init (argc, argv);
  87
  88       // the command line arguments
  89       if (parse_args (argc, argv) == -1)
  90         return -1;
  91
  92       // Merge the different IORS
  93       manager.make_merged_iors ();
  94
  95       // Write IOR to file
  96       if (manager.write_to_files ())
  97         return -1;
  98
  99       ACE_OS::sleep (sleep_delay);
 100
 101       // Client, who is going to use the merged IOR
 102       // Construct that with the managers ORB
 103       Client_i client_imp (manager.orb ());
 104       return client_imp.init ();
 105     }
 106   catch (const CORBA::Exception& ex)
 107     {
 108       ex._tao_print_exception ("Caught");
 109       return -1;
 110     }
 111
 112   return 0;
 113 }
 114
 115 Manager::Manager ()
 116 {
 117   //no-op
 118 }
 119
 120 void
 121 Manager::init (int& argc,
 122                ACE_TCHAR *argv[])
 123 {
 124   this->orb_ = CORBA::ORB_init (argc, argv);
 125
 126   // Obtain the RootPOA.
 127   CORBA::Object_var obj_var =
 128     this->orb_->resolve_initial_references ("RootPOA");
 129
 130   // Get the POA_var object from Object_var.
 131   PortableServer::POA_var root_poa_var =
 132     PortableServer::POA::_narrow (obj_var.in ());
 133
 134   // Get the POAManager of the RootPOA.
 135   PortableServer::POAManager_var poa_manager_var =
 136     root_poa_var->the_POAManager ();
 137
 138   poa_manager_var->activate ();
 139 }
 140
 141 int
 142 Manager::make_merged_iors ()
 143 {
 144   // Get an object reference for the ORBs IORManipultion object!
 145   CORBA::Object_var IORM =
 146     this->orb_->resolve_initial_references (TAO_OBJID_IORMANIPULATION, 0);
 147
 148   if (CORBA::is_nil (IORM.in()))
 149     return -1;
 150
 151   TAO_IOP::TAO_IOR_Manipulation_var iorm =
 152     TAO_IOP::TAO_IOR_Manipulation::_narrow (IORM.in());
 153
 154   if (CORBA::is_nil (iorm.in()))
 155     return -1;
 156
 157   CORBA::Object_var first = orb_->string_to_object (first_ior);
 158
 159   if (CORBA::is_nil (first.in()))
 160     return -1;
 161
 162   // Create the list
 163   TAO_IOP::TAO_IOR_Manipulation::IORList iors (1);
 164   iors.length(1);
 165   iors [0] = first;
 166
 167   merged_set_10_ = iorm->merge_iors (iors);
 168
 169   if (CORBA::is_nil (merged_set_10_.in()))
 170     {
 171       return -1;
 172     }
 173
 174   int result = set_properties (iorm.in(), merged_set_10_.in(),
 175                                first.in(), 10);
 176
 177   if (-1 == result)
 178     {
 179       return -1;
 180     }
 181
 182   first = orb_->string_to_object (first_ior);
 183   if (CORBA::is_nil (first.in()))
 184     {
 185       return -1;
 186     }
 187
 188   CORBA::Object_var second = orb_->string_to_object (second_ior);
 189
 190   if (CORBA::is_nil (second.in()))
 191     {
 192       return -1;
 193     }
 194
 195   // Create the list
 196
 197   iors.length(2);
 198   iors [0] = first;
 199   iors [1] = second;
 200
 201   merged_set_11_ = iorm->merge_iors (iors);
 202
 203   if (CORBA::is_nil (merged_set_11_.in()))
 204     {
 205       return -1;
 206     }
 207
 208   result = set_properties (iorm.in(), merged_set_11_.in(),
 209                            first.in(), 11);
 210
 211   if (-1 == result)
 212     {
 213       return -1;
 214     }
 215
 216   return 0;
 217 }
 218
 219 int
 220 Manager::set_properties (TAO_IOP::TAO_IOR_Manipulation_ptr iorm,
 221                          CORBA::Object_ptr merged_set,
 222                          CORBA::Object_ptr primary,
 223                          CORBA::ULong version)
 224 {
 225   FT::TagFTGroupTaggedComponent ft_tag_component;
 226
 227   // Property values
 228
 229   // Major and Minor revision numbers
 230   ft_tag_component.component_version.major = (CORBA::Octet) 1;
 231   ft_tag_component.component_version.minor = (CORBA::Octet) 0;
 232
 233   // Domain id
 234   const char *id = "iogr_testing";
 235   ft_tag_component.group_domain_id = id;
 236
 237   // Object group id
 238   ft_tag_component.object_group_id = 10;
 239
 240   // Version
 241   ft_tag_component.object_group_ref_version = version;
 242
 243   // Construct the IOGR Property class
 244   TAO_FT_IOGR_Property iogr_prop (ft_tag_component);
 245
 246   // Set the property
 247   CORBA::Boolean retval = iorm->set_primary (&iogr_prop,
 248                                              primary,
 249                                              merged_set);
 250
 251   // Set the primary
 252   // See we are setting the second ior as the primary
 253   if (retval != 0)
 254     {
 255       retval = iorm->set_property (&iogr_prop,
 256                                     merged_set);
 257     }
 258
 259   return 0;
 260 }
 261
 262 int
 263 Manager::run ()
 264 {
 265   try
 266     {
 267       this->orb_->run ();
 268     }
 269   catch (const CORBA::Exception&)
 270     {
 271       ACE_ERROR_RETURN ((LM_DEBUG,
 272                          "Error in run\n"),
 273                         -1);
 274     }
 275
 276   return 0;
 277 }
 278
 279 int Manager::write_to_files ()
 280 {
 281   if (write_to_file (merged_set_10_.in(), first_iogr_file) ||
 282       write_to_file (merged_set_11_.in(), second_iogr_file))
 283     {
 284       return -1;
 285     }
 286   return 0;
 287 }
 288
 289 int
 290 Manager::write_to_file (CORBA::Object_ptr ior, const ACE_TCHAR *ior_output_file)
 291 {
 292   CORBA::String_var iorref =
 293     this->orb_->object_to_string (ior);
 294
 295   if (ior_output_file != 0)
 296     {
 297       FILE *output_file= ACE_OS::fopen (ior_output_file, "w");
 298       if (output_file == 0)
 299         ACE_ERROR_RETURN ((LM_ERROR,
 300                            "Cannot open output file for writing IOR: %s",
 301                            ior_output_file),
 302                           1);
 303       ACE_OS::fprintf (output_file, "%s", iorref.in ());
 304       ACE_OS::fclose (output_file);
 305     }
 306
 307   return 0;
 308 }
 309
 310 CORBA::ORB_ptr
 311 Manager::orb ()
 312 {
 313   return this->orb_.in ();
 314 }
 315
 316 Client_i::Client_i (CORBA::ORB_ptr orb)
 317   :orb_ (CORBA::ORB::_duplicate (orb))
 318 {
 319 }
 320
 321 int run_remote_test (Simple_Server_ptr server, const ACE_TCHAR* execute_key)
 322 {
 323   char expected[1024], received[1024];
 324   if (execute_key)
 325     {
 326       ACE_OS::sprintf (expected,
 327                        "remote_call() completed by %s", ACE_TEXT_ALWAYS_CHAR (execute_key));
 328     }
 329   else
 330     {
 331       ACE_OS::strcpy (expected, "CORBA::TRANSIENT");
 332     }
 333
 334   try
 335     {
 336       // Make a remote call
 337       CORBA::String_var s =
 338         server->remote_call ();
 339
 340       if (!s.in())
 341         {
 342           ACE_OS::strcpy (received, "(null)");
 343         }
 344       else
 345         {
 346           ACE_OS::strcpy (received, s.in());
 347         }
 348     }
 349   catch (const CORBA::TRANSIENT&)
 350     {
 351       ACE_OS::strcpy (received, "CORBA::TRANSIENT");
 352     }
 353   catch (const CORBA::COMM_FAILURE&)
 354     {
 355       ACE_OS::strcpy (received, "CORBA::COMM_FAILURE");
 356     }
 357
 358   ACE_DEBUG ((LM_DEBUG,
 359               ACE_TEXT("CLIENT> REMOTE   expected: '%C'"),
 360               expected));
 361   if (ACE_OS::strcmp (expected, received))
 362     {
 363       ACE_DEBUG ((LM_DEBUG,
 364                   ACE_TEXT ("... FAIL\n")
 365                   ACE_TEXT ("CLIENT>          received: '%C'\n"),
 366                   received));
 367       return -1;
 368     }
 369
 370   ACE_DEBUG ((LM_DEBUG, ACE_TEXT("... OK\n")));
 371   return 0;
 372 }
 373
 374 int run_abort_test (Simple_Server_ptr server,
 375                     const ACE_TCHAR* request_key,
 376                     const ACE_TCHAR* execute_key)
 377 {
 378   char expected[1024], received[1024];
 379   if (execute_key)
 380     {
 381       ACE_OS::sprintf (expected,
 382                        "abort() completed by %s, still_alive=1",
 383                        ACE_TEXT_ALWAYS_CHAR (execute_key));
 384     }
 385   else
 386     {
 387       ACE_OS::strcpy (expected, "CORBA::TRANSIENT");
 388     }
 389
 390   try
 391     {
 392       CORBA::String_var s = server->abort (ACE_TEXT_ALWAYS_CHAR (request_key));
 393
 394       if (!s.in())
 395         {
 396           ACE_OS::strcpy (received, "(null)");
 397         }
 398       else
 399         {
 400           ACE_OS::strcpy (received, s.in());
 401         }
 402     }
 403   catch (const CORBA::TRANSIENT&)
 404     {
 405       ACE_OS::strcpy (received, "CORBA::TRANSIENT");
 406     }
 407   catch (const CORBA::COMM_FAILURE&)
 408     {
 409       ACE_OS::strcpy (received, "CORBA::COMM_FAILURE");
 410     }
 411
 412   ACE_DEBUG ((LM_DEBUG,
 413               ACE_TEXT("CLIENT> ABORT    expected: '%C'"),
 414               expected));
 415
 416   if (ACE_OS::strcmp (expected, received))
 417   {
 418     ACE_DEBUG ((LM_DEBUG,
 419                 ACE_TEXT ("... FAIL\n")
 420                 ACE_TEXT ("CLIENT>          received: '%C'\n"),
 421                 received));
 422     return -1;
 423   }
 424
 425   ACE_DEBUG ((LM_DEBUG, ACE_TEXT("... OK\n")));
 426   return 0;
 427 }
 428
 429 int run_test (Simple_Server_ptr server)
 430 {
 431   int rv = run_abort_test (server, first_key, second_key);
 432
 433   if (rv)
 434     {
 435       return rv;
 436     }
 437
 438   rv = run_remote_test (server, second_key);
 439
 440   if (rv)
 441     {
 442       return rv;
 443     }
 444
 445   rv = run_abort_test (server, second_key, 0);
 446
 447   return rv;
 448 }
 449
 450 int
 451 Client_i::init ()
 452 {
 453   char iogrstr[1024];
 454   ACE_OS::sprintf (iogrstr, "file://%s", ACE_TEXT_ALWAYS_CHAR (first_iogr_file));
 455
 456   int argc = 0;
 457   ACE_TCHAR **argv = 0;
 458   this->orb_ = CORBA::ORB_init (argc, argv);
 459
 460   CORBA::Object_var object =
 461     this->orb_->string_to_object (iogrstr);
 462
 463
 464   // Combined IOR stuff
 465   Simple_Server_var server =
 466     Simple_Server::_narrow (object.in ());
 467
 468   if (CORBA::is_nil (server.in ()))
 469   {
 470     ACE_ERROR ((LM_ERROR,
 471                 "Object reference <%C> is nil\n",
 472                 iogrstr));
 473   }
 474
 475   // run tests
 476   int result = run_test (server.in());
 477
 478   return result;
 479 }