TAO/examples/Buffered_Oneways/client.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file     client.cpp
   5  *
   6  *   This is a client that uses buffered oneways.
   7  *
   8  *  @author  Irfan Pyarali
   9  */
  10 //=============================================================================
  11
  12
  13 #include "testC.h"
  14 #include "tao/Messaging/Messaging.h"
  15 #include "tao/AnyTypeCode/Any.h"
  16 #include "tao/AnyTypeCode/TAOA.h"
  17 #include "ace/Get_Opt.h"
  18 #include "ace/Read_Buffer.h"
  19
  20
  21 // Name of file contains ior.
  22 static const ACE_TCHAR *IOR = ACE_TEXT ("file://ior");
  23
  24 // Default iterations.
  25 static CORBA::ULong iterations = 20;
  26
  27 // Default number of bytes to buffer before flushing.
  28 static CORBA::Long message_bytes = -1;
  29
  30 // Default number of invocations to buffer before flushing.
  31 static CORBA::Long message_count = iterations / 4;
  32
  33 // Default number of iterations before explicit flushing.
  34 static CORBA::Long flush_count = -1;
  35
  36 // Time interval for implicit flushing (in milli seconds).
  37 static long timeout = -1;
  38
  39 // Time interval between invocation (in milli seconds).
  40 static long interval = 1000;
  41
  42 // Flag indicates whether to shutdown remote server or not upon client
  43 // shutdown.
  44 static int shutdown_server = 0;
  45
  46 static int
  47 parse_args (int argc, ACE_TCHAR **argv)
  48 {
  49   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:f:c:b:i:z:t:x"));
  50   int c;
  51
  52   while ((c = get_opts ()) != -1)
  53     switch (c)
  54       {
  55       case 'k':
  56         IOR = get_opts.opt_arg ();
  57         break;
  58
  59       case 'f':
  60         flush_count = ACE_OS::atoi (get_opts.opt_arg ());
  61         break;
  62
  63       case 'c':
  64         message_count = ACE_OS::atoi (get_opts.opt_arg ());
  65         break;
  66
  67       case 'b':
  68         message_bytes = ACE_OS::atoi (get_opts.opt_arg ());
  69         break;
  70
  71       case 'i':
  72         iterations = ACE_OS::atoi (get_opts.opt_arg ());
  73         break;
  74
  75       case 'z':
  76         interval = ACE_OS::atoi (get_opts.opt_arg ());
  77         break;
  78
  79       case 't':
  80         timeout = ACE_OS::atoi (get_opts.opt_arg ());
  81         break;
  82
  83       case 'x':
  84         shutdown_server = 1;
  85         break;
  86
  87       case '?':
  88       default:
  89         ACE_ERROR_RETURN ((LM_ERROR,
  90                            "usage:  %s "
  91                            "-k IOR "
  92                            "-f flush count "
  93                            "-c message count "
  94                            "-b message bytes "
  95                            "-i iterations "
  96                            "-z interval between calls "
  97                            "-t implicit flush timeout "
  98                            "-x shutdown server "
  99                            "\n",
 100                            argv [0]),
 101                           -1);
 102       }
 103
 104   if (IOR == 0)
 105     ACE_ERROR_RETURN ((LM_ERROR,
 106                        "Please specify the IOR for the servant\n"), -1);
 107
 108   // Indicates successful parsing of command line.
 109   return 0;
 110 }
 111
 112 int
 113 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 114 {
 115   try
 116     {
 117       // Initialize the ORB.
 118       CORBA::ORB_var orb =
 119         CORBA::ORB_init (argc, argv);
 120
 121       // Initialize options based on command-line arguments.
 122       int parse_args_result = parse_args (argc, argv);
 123       if (parse_args_result != 0)
 124         return parse_args_result;
 125
 126       // Get an object reference from the argument string.
 127       CORBA::Object_var base =
 128         orb->string_to_object (IOR);
 129
 130       // Try to narrow the object reference to a <test> reference.
 131       test_var test_object = test::_narrow (base.in ());
 132
 133       // Obtain PolicyCurrent.
 134       base = orb->resolve_initial_references ("PolicyCurrent");
 135
 136       // Narrow down to correct type.
 137       CORBA::PolicyCurrent_var policy_current =
 138         CORBA::PolicyCurrent::_narrow (base.in ());
 139
 140       // Setup the none sync scope policy, i.e., the ORB will buffer
 141       // oneways.
 142       Messaging::SyncScope sync_none = Messaging::SYNC_NONE;
 143
 144       // Setup the none sync scope any.
 145       CORBA::Any sync_none_any;
 146       sync_none_any <<= sync_none;
 147
 148       // Setup the none sync scope policy list.
 149       CORBA::PolicyList sync_none_policy_list (1);
 150       sync_none_policy_list.length (1);
 151
 152       // Setup the none sync scope policy.
 153       sync_none_policy_list[0] =
 154         orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE,
 155                             sync_none_any);
 156
 157       // Setup the none sync scope.
 158       policy_current->set_policy_overrides (sync_none_policy_list,
 159                                             CORBA::ADD_OVERRIDE);
 160
 161       // We are now done with this policy.
 162       sync_none_policy_list[0]->destroy ();
 163
 164       // Start off with no constraints.
 165       TAO::BufferingConstraint buffering_constraint;
 166       buffering_constraint.mode = TAO::BUFFER_FLUSH;
 167       buffering_constraint.message_count = 0;
 168       buffering_constraint.message_bytes = 0;
 169       buffering_constraint.timeout = 0;
 170
 171       // If valid <message_count>, set the implicit flushing to
 172       // account for queued messages.
 173       if (message_count != -1)
 174         {
 175           buffering_constraint.mode |= TAO::BUFFER_MESSAGE_COUNT;
 176           buffering_constraint.message_count = message_count;
 177         }
 178
 179       // If valid <message_bytes>, set the implicit flushing to
 180       // account for queued bytes.
 181       if (message_bytes != -1)
 182         {
 183           buffering_constraint.mode |= TAO::BUFFER_MESSAGE_BYTES;
 184           buffering_constraint.message_bytes = message_bytes;
 185         }
 186
 187       // If valid <timeout>, set the implicit flushing to account for
 188       // timeouts.
 189       if (timeout != -1)
 190         {
 191           buffering_constraint.mode |= TAO::BUFFER_TIMEOUT;
 192           buffering_constraint.timeout = timeout * 10000;
 193         }
 194
 195       // Setup the buffering constraint any.
 196       CORBA::Any buffering_constraint_any;
 197       buffering_constraint_any <<= buffering_constraint;
 198
 199       // Setup the buffering constraint policy list.
 200       CORBA::PolicyList buffering_constraint_policy_list (1);
 201       buffering_constraint_policy_list.length (1);
 202
 203       // Setup the buffering constraint policy.
 204       buffering_constraint_policy_list[0] =
 205         orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE,
 206                             buffering_constraint_any);
 207
 208       if (buffering_constraint.mode == TAO::BUFFER_FLUSH)
 209         {
 210           ACE_ERROR((LM_ERROR, "Error : Must specify a timeout, message"
 211             " count, or message bytes constraint.\n"));
 212           return 1;
 213         }
 214
 215       // Setup the constraints.
 216       policy_current->set_policy_overrides (buffering_constraint_policy_list,
 217                                             CORBA::ADD_OVERRIDE);
 218
 219       //
 220       // We use this policy again later. Therefore, we don't destroy
 221       // it right away.
 222       //
 223
 224       // Setup the explicit flushing policy.
 225       TAO::BufferingConstraint buffering_flush;
 226       buffering_flush.mode = TAO::BUFFER_FLUSH;
 227       buffering_flush.message_count = 0;
 228       buffering_flush.message_bytes = 0;
 229       buffering_flush.timeout = 0;
 230
 231       // Setup the buffering flush any.
 232       CORBA::Any buffering_flush_any;
 233       buffering_flush_any <<= buffering_flush;
 234
 235       // Setup the buffering flush policy list.
 236       CORBA::PolicyList buffering_flush_policy_list (1);
 237       buffering_flush_policy_list.length (1);
 238
 239       // Setup the buffering flush policy.
 240       buffering_flush_policy_list[0] =
 241         orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE,
 242                             buffering_flush_any);
 243
 244       //
 245       // Explicit flushing policy will be used later.
 246       //
 247
 248       for (CORBA::ULong i = 1; i <= iterations; ++i)
 249         {
 250           // Explicit flushing (is specified).
 251           if (flush_count != -1 &&
 252               i % flush_count == 0)
 253             {
 254               // Setup explicit flushing.
 255               policy_current->set_policy_overrides (buffering_flush_policy_list,
 256                                                     CORBA::ADD_OVERRIDE);
 257
 258               ACE_DEBUG ((LM_DEBUG,
 259                           "client: Iteration %d @ %T\n",
 260                           i));
 261
 262               // Invoke the oneway method.
 263               test_object->method (i);
 264
 265               // Reset buffering policy.
 266               policy_current->set_policy_overrides (buffering_constraint_policy_list,
 267                                                     CORBA::ADD_OVERRIDE);
 268             }
 269           else
 270             {
 271               ACE_DEBUG ((LM_DEBUG,
 272                           "client: Iteration %d @ %T\n",
 273                           i));
 274
 275               // Invoke the oneway method.
 276               test_object->method (i);
 277             }
 278
 279           // Interval between successive calls.
 280           ACE_Time_Value sleep_interval (0,
 281                                          interval * 1000);
 282
 283           orb->run (sleep_interval);
 284         }
 285
 286       // Shutdown server.
 287       if (shutdown_server)
 288         {
 289           test_object->shutdown ();
 290         }
 291
 292       // We are done with the policy.
 293       buffering_constraint_policy_list[0]->destroy ();
 294
 295       // We are done with the policy.
 296       buffering_flush_policy_list[0]->destroy ();
 297
 298       // Destroy the ORB.  On some platforms, e.g., Win32, the socket
 299       // library is closed at the end of main().  This means that any
 300       // socket calls made after main() fail. Hence if we wait for
 301       // static destructors to flush the queues, it will be too late.
 302       // Therefore, we use explicit destruction here and flush the
 303       // queues before main() ends.
 304       orb->destroy ();
 305     }
 306   catch (const CORBA::Exception& ex)
 307     {
 308       ex._tao_print_exception ("Exception caught:");
 309       return -1;
 310     }
 311
 312   return 0;
 313 }