TAO/orbsvcs/tests/HTIOP/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 "../test_config.h"
  15
  16 #include "ace/OS_NS_sys_socket.h"
  17 #include "ace/Get_Opt.h"
  18 #include "ace/Task.h"
  19
  20 #include "ami_testC.h"
  21 #include "ami_testS.h"
  22
  23
  24
  25 const ACE_TCHAR *ior = ACE_TEXT("file://test.ior");
  26 int niterations = 5;
  27 int shutdown_flag = 0;
  28 int debug = 0;
  29
  30 int
  31 parse_args (int argc, ACE_TCHAR *argv[])
  32 {
  33   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("dk:i:x"));
  34   int c;
  35
  36   while ((c = get_opts ()) != -1)
  37     switch (c)
  38       {
  39       case 'd':
  40         debug = 1;
  41         break;
  42       case 'k':
  43         ior = get_opts.opt_arg ();
  44         break;
  45       case 'i':
  46         niterations = ACE_OS::atoi (get_opts.opt_arg ());
  47         break;
  48       case 'x':
  49         shutdown_flag = 1;
  50         break;
  51       case '?':
  52       default:
  53         ACE_ERROR_RETURN ((LM_ERROR,
  54                            "usage:  %s "
  55                            "-k <ior> "
  56                            "-i <niterations> "
  57                            "-x "
  58                            "\n",
  59                            argv [0]),
  60                           -1);
  61       }
  62   // Indicates successful parsing of the command line
  63   return 0;
  64 }
  65
  66 class Handler : public POA_A::AMI_AMI_TestHandler
  67 {
  68 public:
  69   /// Constructor.
  70   Handler (void) {};
  71
  72   /// Destructor.
  73     ~Handler (void) {};
  74
  75   void foo (CORBA::Long ami_return_val,
  76             CORBA::Long out_l)
  77     {
  78       if (debug)
  79         {
  80           ACE_DEBUG ((LM_DEBUG,
  81                       "Callback method <foo> called: result <%d>, out_arg <%d>\n",
  82                       ami_return_val,
  83                       out_l));
  84         }
  85     };
  86
  87   void foo_excep (::Messaging::ExceptionHolder * excep_holder)
  88     {
  89
  90       ACE_DEBUG ((LM_DEBUG,
  91                   "Callback method <foo_excep> called:\n"
  92                                   "Testing proper exception handling ...\n"));
  93       try
  94         {
  95           excep_holder->raise_exception ();
  96         }
  97       catch (const A::DidTheRightThing&)
  98         {
  99           ACE_DEBUG ((LM_DEBUG,
 100                       "... exception received successfully\n"));
 101                     }
 102       catch (const CORBA::Exception&)
 103         {
 104           ACE_DEBUG ((LM_DEBUG,
 105                       "... caught the wrong exception -> ERROR\n"));
 106         }
 107     };
 108
 109
 110   void get_yadda (CORBA::Long result)
 111     {
 112       ACE_DEBUG ((LM_DEBUG,
 113                   "Callback method <get_yadda> called: result <%d>\n",
 114                   result));
 115     };
 116
 117   void get_yadda_excep (::Messaging::ExceptionHolder *)
 118     {
 119       ACE_DEBUG ((LM_DEBUG,
 120                   "Callback method <get_yadda_excep> called:\n"));
 121     };
 122
 123   void set_yadda (void)
 124     {
 125       ACE_DEBUG ((LM_DEBUG,
 126                   "Callback method <set_yadda> called:\n"));
 127     };
 128
 129   void set_yadda_excep (::Messaging::ExceptionHolder *)
 130     {
 131       ACE_DEBUG ((LM_DEBUG,
 132                   "Callback method <set_yadda_excep> called:\n"));
 133     };
 134
 135 };
 136
 137 int
 138 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 139 {
 140   ACE_START_TEST (ACE_TEXT ("HTIOP_AMI_simple_client"));
 141
 142
 143   try
 144     {
 145       CORBA::ORB_var orb =
 146         CORBA::ORB_init (argc, argv);
 147
 148       CORBA::Object_var object_var =
 149         orb->resolve_initial_references ("RootPOA");
 150
 151       PortableServer::POA_var poa_var =
 152         PortableServer::POA::_narrow (object_var.in ());
 153
 154       PortableServer::POAManager_var poa_manager_var =
 155         poa_var->the_POAManager ();
 156
 157       poa_manager_var->activate ();
 158
 159       if (parse_args (argc, argv) != 0)
 160         return 1;
 161
 162       // We reuse the object_var smart pointer!
 163       object_var = orb->string_to_object (ior);
 164
 165       A::AMI_Test_var ami_test_var =
 166         A::AMI_Test::_narrow (object_var.in ());
 167
 168       if (CORBA::is_nil (ami_test_var.in ()))
 169         {
 170           ACE_ERROR_RETURN ((LM_ERROR,
 171                              "Object reference <%s> is nil\n",
 172                              ior),
 173                             1);
 174         }
 175
 176       ACE_OS::socket_init ();
 177
 178       // Instantiate the ReplyHandler and register that with the POA.
 179       Handler handler;
 180       A::AMI_AMI_TestHandler_var the_handler_var =
 181         handler._this ();
 182
 183       // Try out sending asynchronous messages without a reply handler
 184       // registered. Things fail if we get an exception.
 185
 186       ami_test_var->sendc_foo (A::AMI_AMI_TestHandler::_nil (),
 187                                0,
 188                                "");
 189
 190
 191       // Trigger the DidTheRightThing exception on the server side
 192       // by sending 0 to it.
 193       ACE_DEBUG ((LM_DEBUG,
 194                   "Sending asynch message\n"));
 195
 196       ami_test_var->sendc_foo (the_handler_var.in (),
 197                                0,
 198                                "Let's talk AMI.");
 199
 200       CORBA::Long l = 931247;
 201
 202       for (ssize_t ni = 0; ni < niterations; ni++)
 203         {
 204           ACE_DEBUG ((LM_DEBUG,
 205                       "Sending asynch message: %d\n",
 206                       ni));
 207
 208           ami_test_var->sendc_foo (the_handler_var.in (),
 209                                    l,
 210                                    "Let's talk AMI.");
 211         }
 212
 213       // Begin test of attributes
 214       ami_test_var->sendc_get_yadda (the_handler_var.in ());
 215
 216       ami_test_var->sendc_set_yadda (the_handler_var.in (),
 217                                      4711);
 218
 219       ami_test_var->sendc_get_yadda (the_handler_var.in ());
 220
 221       // End test of attributes
 222
 223       if (debug)
 224         {
 225           ACE_DEBUG ((LM_DEBUG,
 226                       "<%d> Asynchronous methods issued\n",
 227                       niterations));
 228         }
 229
 230       if (debug)
 231         {
 232           ACE_DEBUG ((LM_DEBUG,
 233                       "Issuing a synchronous method to collect the AMI replies\n"));
 234         }
 235
 236       //while (orb->work_pending())
 237       //  orb->perform_work ();
 238
 239
 240       CORBA::Long number = ami_test_var->foo (l,
 241                                               l,
 242                                               "Let's talk SMI.");
 243
 244       if (debug)
 245         {
 246           ACE_DEBUG ((LM_DEBUG,
 247                       "Received the following number: %d\n",
 248                       number));
 249         }
 250
 251       if (shutdown_flag)
 252         {
 253           ACE_DEBUG ((LM_DEBUG, "invoking shutdown\n"));
 254           ami_test_var->shutdown ();
 255         }
 256
 257       poa_var->destroy (1,  // ethernalize objects
 258                         0  // wait for completion
 259                         );
 260
 261       orb->destroy ();
 262     }
 263   catch (const CORBA::Exception& ex)
 264     {
 265       ex._tao_print_exception ("Caught exception:");
 266       return 1;
 267     }
 268
 269   ACE_END_TEST;
 270   return 0;
 271 }