TAO/tests/AMI/simple_client.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    simple_client.cpp
   5  *
   6  *  A very simple client which uses the AMI callback model.
   7  *
   8  *  @author Alexander Babu Arulanthu <alex@cs.wustl.edu>
   9  *  @author Michael Kircher <Michael.Kircher@mchp.siemens.de>
  10  */
  11 //=============================================================================
  12
  13
  14 #include "ace/Get_Opt.h"
  15 #include "ace/Task.h"
  16 #include "ami_testS.h"
  17
  18 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  19 int niterations = 5;
  20 int shutdown_flag = 0;
  21 int debug = 0;
  22 int result = 0;
  23
  24 int
  25 parse_args (int argc, ACE_TCHAR *argv[])
  26 {
  27   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("dk:i:x"));
  28   int c;
  29
  30   while ((c = get_opts ()) != -1)
  31     switch (c)
  32       {
  33       case 'd':
  34         debug = 1;
  35         break;
  36       case 'k':
  37         ior = get_opts.opt_arg ();
  38         break;
  39       case 'i':
  40         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  41         break;
  42       case 'x':
  43         shutdown_flag = 1;
  44         break;
  45       case '?':
  46       default:
  47         ACE_ERROR_RETURN ((LM_ERROR,
  48                            "usage:  %s "
  49                            "-k <ior> "
  50                            "-i <niterations> "
  51                            "-x "
  52                            "\n",
  53                            argv [0]),
  54                           -1);
  55       }
  56   // Indicates successful parsing of the command line
  57   return 0;
  58 }
  59
  60 class Handler : public POA_A::AMI_AMI_TestHandler
  61 {
  62 public:
  63   /// Constructor.
  64   Handler () = default;
  65
  66   /// Destructor.
  67   ~Handler () = default;
  68
  69   void foo (CORBA::Long ami_return_val,
  70             CORBA::Long out_l)
  71     {
  72       if (debug)
  73         {
  74           ACE_DEBUG ((LM_DEBUG,
  75                       "Callback method <foo> called: result <%d>, out_arg <%d>\n",
  76                       ami_return_val,
  77                       out_l));
  78         }
  79       if (out_l != 931233)
  80         {
  81           ACE_ERROR ((LM_ERROR,
  82                       "ERROR: out_l not 931233: %d\n",
  83                       out_l));
  84           result = 1;
  85         }
  86       if (ami_return_val != 931234)
  87         {
  88           ACE_ERROR ((LM_ERROR,
  89                       "ERROR: ami_return_val not 931234: %d\n",
  90                       ami_return_val));
  91           result = 1;
  92         }
  93     };
  94
  95   void foo_excep (::Messaging::ExceptionHolder * excep_holder)
  96     {
  97       ACE_DEBUG ((LM_DEBUG,
  98                   "Callback method <foo_excep> called:\n"
  99                   "Testing proper exception handling ...\n"));
 100       try
 101         {
 102           excep_holder->raise_exception ();
 103         }
 104       catch (const A::DidTheRightThing& ex)
 105         {
 106           ACE_DEBUG ((LM_DEBUG,
 107                       "... exception received successfully\n"));
 108           if (ex.id != 42)
 109             {
 110               ACE_ERROR ((LM_ERROR,
 111                           "ERROR: ex.id not 42: %d\n",
 112                           ex.id));
 113               result = 1;
 114             }
 115           if (ACE_OS::strcmp (ex.whatDidTheRightThing.in (), "Hello world") != 0)
 116             {
 117               ACE_ERROR ((LM_ERROR,
 118                           "ERROR: ex.whatDidTheRightThing not ok: <%C>\n",
 119                           ex.whatDidTheRightThing.in ()));
 120               result = 1;
 121             }
 122         }
 123       catch (const CORBA::Exception& ex)
 124         {
 125           ex._tao_print_exception ("ERROR");
 126           ACE_ERROR ((LM_ERROR,
 127                       "... caught the wrong exception -> ERROR\n"));
 128         }
 129     };
 130
 131
 132   void get_yadda (CORBA::Long result)
 133     {
 134       ACE_DEBUG ((LM_DEBUG,
 135                   "Callback method <get_yadda> called: result <%d>\n",
 136                   result));
 137     };
 138
 139   void get_yadda_excep (::Messaging::ExceptionHolder *)
 140     {
 141       ACE_DEBUG ((LM_DEBUG,
 142                   "Callback method <get_yadda_excep> called:\n"));
 143     };
 144
 145   void set_yadda ()
 146     {
 147       ACE_DEBUG ((LM_DEBUG,
 148                   "Callback method <set_yadda> called:\n"));
 149     };
 150
 151   void set_yadda_excep (::Messaging::ExceptionHolder *)
 152     {
 153       ACE_DEBUG ((LM_DEBUG,
 154                   "Callback method <set_yadda_excep> called:\n"));
 155     };
 156
 157   void inout_arg_test (const char *)
 158   {
 159     ACE_DEBUG ((LM_DEBUG,
 160                 "Callback method <set_yadda_excep> called:\n"));
 161   }
 162
 163   void inout_arg_test_excep (::Messaging::ExceptionHolder *)
 164   {
 165   }
 166 };
 167
 168 int
 169 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 170 {
 171   try
 172     {
 173       CORBA::ORB_var orb =
 174         CORBA::ORB_init (argc, argv);
 175
 176       CORBA::Object_var object_var =
 177         orb->resolve_initial_references ("RootPOA");
 178
 179       PortableServer::POA_var poa_var =
 180         PortableServer::POA::_narrow (object_var.in ());
 181
 182       PortableServer::POAManager_var poa_manager_var =
 183         poa_var->the_POAManager ();
 184
 185       poa_manager_var->activate ();
 186
 187       if (parse_args (argc, argv) != 0)
 188         return 1;
 189
 190       // We reuse the object_var smart pointer!
 191       object_var = orb->string_to_object (ior);
 192
 193       A::AMI_Test_var ami_test_var =
 194         A::AMI_Test::_narrow (object_var.in ());
 195
 196       if (CORBA::is_nil (ami_test_var.in ()))
 197         {
 198           ACE_ERROR_RETURN ((LM_ERROR,
 199                              "Object reference <%s> is nil.\n",
 200                              ior),
 201                             1);
 202         }
 203
 204       // Instantiate the ReplyHandler and register that with the POA.
 205       Handler handler;
 206       PortableServer::ObjectId_var id =
 207         poa_var->activate_object (&handler);
 208
 209       CORBA::Object_var object = poa_var->id_to_reference (id.in ());
 210
 211       A::AMI_AMI_TestHandler_var the_handler_var =
 212         A::AMI_AMI_TestHandler::_narrow (object.in ());
 213
 214       // Try out sending asynchronous messages without a reply handler
 215       // registered. Things fail if we get an exception.
 216       ami_test_var->sendc_foo (A::AMI_AMI_TestHandler::_nil (), 0, "");
 217
 218       // Trigger the DidTheRightThing exception on the server side
 219       // by sending 0 to it.
 220       ACE_DEBUG ((LM_DEBUG,
 221                   "Sending asynch message\n"));
 222
 223       ami_test_var->sendc_foo (the_handler_var.in (),
 224                                0,
 225                                "Let's talk AMI.");
 226
 227       CORBA::Long l = 931247;
 228
 229       for (ssize_t ni = 0; ni < niterations; ni++)
 230         {
 231           ACE_DEBUG ((LM_DEBUG,
 232                       "Sending asynch message: %d\n",
 233                       ni));
 234
 235           ami_test_var->sendc_foo (the_handler_var.in (),
 236                                    l,
 237                                    "Let's talk AMI.");
 238         }
 239
 240       // Begin test of attributes
 241       ami_test_var->sendc_get_yadda (the_handler_var.in ());
 242
 243       ami_test_var->sendc_set_yadda (the_handler_var.in (), 4711);
 244
 245       ami_test_var->sendc_get_yadda (the_handler_var.in ());
 246
 247       // End test of attributes
 248
 249       if (debug)
 250         {
 251           ACE_DEBUG ((LM_DEBUG,
 252                       "<%d> Asynchronous methods issued\n",
 253                       niterations));
 254         }
 255
 256       if (debug)
 257         {
 258           ACE_DEBUG ((LM_DEBUG,
 259                       "Issuing a synchronous method to collect the AMI replies\n"));
 260         }
 261
 262       CORBA::Long number = ami_test_var->foo (l,
 263                                               l,
 264                                               "Let's talk SMI.");
 265
 266       for (ssize_t ni = 0; ni < niterations; ni++)
 267         {
 268           ACE_DEBUG ((LM_DEBUG,
 269                       "Sending another asynch message: %d\n",
 270                       ni));
 271
 272           ami_test_var->sendc_foo (the_handler_var.in (),
 273                                    l,
 274                                    "Let's talk AMI.");
 275         }
 276
 277       if (debug)
 278         {
 279           ACE_DEBUG ((LM_DEBUG,
 280                       "<%d> more asynchronous methods issued\n",
 281                       niterations));
 282         }
 283
 284       if (debug)
 285         {
 286           ACE_DEBUG ((LM_DEBUG,
 287                       "Issuing a synchronous method to collect the AMI replies again\n"));
 288         }
 289
 290       number = ami_test_var->foo (l,
 291                                   l,
 292                                   "Let's talk SMI.");
 293
 294       if (debug)
 295         {
 296           ACE_DEBUG ((LM_DEBUG,
 297                       "Received the following number: %d\n",
 298                       number));
 299         }
 300
 301       if (shutdown_flag)
 302         {
 303           ami_test_var->shutdown ();
 304         }
 305
 306       poa_var->destroy (1,  // ethernalize objects
 307                         0); // wait for completion
 308
 309       orb->destroy ();
 310     }
 311   catch (const CORBA::Exception& ex)
 312     {
 313       ex._tao_print_exception ("Caught exception:");
 314       return 1;
 315     }
 316
 317   return result;
 318 }