TAO/orbsvcs/tests/Bug_2925_Regression/client.cpp

   1
   2 #include "ace/Task.h"
   3 #include "ace/Mutex.h"
   4 #include "ace/Get_Opt.h"
   5 #include "orbsvcs/PortableGroup/GOA.h"
   6 #include "tao/Policy_Manager.h"
   7 #include "tao/DiffServPolicy/DiffServPolicy.h"
   8 #include "tao/DiffServPolicy/Client_Network_Priority_Policy.h"
   9 #include "HelloC.h"
  10
  11 #define CLIENT_SLEEP_TIME       1000     /* in microseconds */
  12 #define CLIENT_THREAD_NUMBER    32
  13 #define HELLO_CALL_NUMBER       100
  14
  15 #define IPDSFIELD_DSCP_DEFAULT  0x00
  16 #define IPDSFIELD_DSCP_CS1      0x08
  17 #define IPDSFIELD_DSCP_CS2      0x10
  18 #define IPDSFIELD_DSCP_CS3      0x18
  19 #define IPDSFIELD_DSCP_CS4      0x20
  20 #define IPDSFIELD_DSCP_CS5      0x28
  21 #define IPDSFIELD_DSCP_CS6      0x30
  22 #define IPDSFIELD_DSCP_CS7      0x38
  23 #define IPDSFIELD_DSCP_AF11     0x0A
  24 #define IPDSFIELD_DSCP_AF12     0x0C
  25 #define IPDSFIELD_DSCP_AF13     0x0E
  26 #define IPDSFIELD_DSCP_AF21     0x12
  27 #define IPDSFIELD_DSCP_AF22     0x14
  28 #define IPDSFIELD_DSCP_AF23     0x16
  29 #define IPDSFIELD_DSCP_AF31     0x1A
  30 #define IPDSFIELD_DSCP_AF32     0x1C
  31 #define IPDSFIELD_DSCP_AF33     0x1E
  32 #define IPDSFIELD_DSCP_AF41     0x22
  33 #define IPDSFIELD_DSCP_AF42     0x24
  34 #define IPDSFIELD_DSCP_AF43     0x26
  35 #define IPDSFIELD_ECT_MASK      0x02
  36 #define IPDSFIELD_CE_MASK       0x01
  37 #define IPDSFIELD_DSCP_EF       0x2E
  38
  39 static int const dscp[] =
  40 {
  41   IPDSFIELD_DSCP_DEFAULT ,
  42   IPDSFIELD_DSCP_CS1     ,
  43   IPDSFIELD_DSCP_CS2     ,
  44   IPDSFIELD_DSCP_CS3     ,
  45   IPDSFIELD_DSCP_CS4     ,
  46   IPDSFIELD_DSCP_CS5     ,
  47   IPDSFIELD_DSCP_CS6     ,
  48   IPDSFIELD_DSCP_CS7     ,
  49   IPDSFIELD_DSCP_AF11    ,
  50   IPDSFIELD_DSCP_AF12    ,
  51   IPDSFIELD_DSCP_AF13    ,
  52   IPDSFIELD_DSCP_AF21    ,
  53   IPDSFIELD_DSCP_AF22    ,
  54   IPDSFIELD_DSCP_AF23    ,
  55   IPDSFIELD_DSCP_AF31    ,
  56   IPDSFIELD_DSCP_AF32    ,
  57   IPDSFIELD_DSCP_AF33    ,
  58   IPDSFIELD_DSCP_AF41    ,
  59   IPDSFIELD_DSCP_AF42    ,
  60   IPDSFIELD_DSCP_AF43    ,
  61   IPDSFIELD_DSCP_EF
  62 };
  63
  64 const ACE_TCHAR *ior_file = 0;
  65
  66 void
  67 test_sleep (int microsec)
  68 {
  69   ACE_Time_Value tv (microsec / 1000000, microsec % 1000000);
  70
  71   ACE_OS::sleep ((const ACE_Time_Value &) tv);
  72 }
  73
  74 int
  75 parse_args (int argc, ACE_TCHAR *argv[])
  76 {
  77   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:"));
  78   const unsigned char full_success = 0x01;
  79   unsigned char success = 0;
  80
  81   do
  82     {
  83       int c = get_opts ();
  84       if (success == full_success && c == -1)
  85         break;
  86
  87       if (c == -1)
  88         ACE_ERROR_RETURN ((LM_ERROR,
  89                            "usage:  %s"
  90                            " -k <iorfile>"
  91                            "\n",
  92                            argv [0]),
  93                            -1);
  94
  95       switch (c)
  96         {
  97         case 'k':
  98           ior_file = get_opts.opt_arg ();
  99           success |= 0x01;
 100           break;
 101         }
 102     }
 103   while (true);
 104
 105   // Indicates successful parsing of the command line
 106   return 0;
 107 }
 108
 109
 110 class ClientThread
 111   : public ACE_Task_Base
 112 {
 113 public:
 114   ClientThread (Test::Hello_ptr hello, CORBA::Short calls)
 115     : hello_ (Test::Hello::_duplicate (hello))
 116     , call_count_ (calls)
 117     , count_ (0)
 118   {
 119   }
 120
 121   virtual int
 122   svc ()
 123   {
 124     try
 125       {
 126         while (true)
 127           {
 128             CORBA::Short c = 0;
 129             {
 130               ACE_GUARD_RETURN (ACE_Mutex, ace_mon, this->mutex_, 0);
 131               c = this->count_++;
 132             }
 133
 134             if (c >= this->call_count_)
 135               break;
 136
 137             this->hello_->say_hello (c);
 138
 139             ACE_DEBUG ((LM_DEBUG,
 140                         "%02d>>; ",
 141                         c));
 142
 143             test_sleep (CLIENT_SLEEP_TIME);
 144           }
 145       }
 146     catch (const CORBA::Exception& ex)
 147       {
 148         ex._tao_print_exception ("Exception caught in ClientThread:");
 149         return -1;
 150       }
 151
 152     return 0;
 153   }
 154
 155 private:
 156   ACE_Mutex mutex_;
 157   Test::Hello_var hello_;
 158   CORBA::Short call_count_;
 159   CORBA::Short count_;
 160 };
 161
 162
 163 int
 164 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 165 {
 166   try
 167     {
 168       CORBA::ORB_var orb =
 169         CORBA::ORB_init (argc, argv);
 170
 171       if (parse_args (argc, argv) != 0)
 172         return 2;
 173
 174       // create UIPMC reference
 175       CORBA::Object_var miop_ref =
 176         orb->string_to_object (ior_file);
 177
 178       // create Hello reference
 179       Test::Hello_var hello =
 180         Test::Hello::_unchecked_narrow (miop_ref.in ());
 181
 182       if (CORBA::is_nil (hello.in ()))
 183         return 5;
 184
 185       TAO::DiffservCodepoint request_dscp = dscp[12];
 186       TAO::DiffservCodepoint reply_dscp = dscp[13];
 187
 188       CORBA::PolicyList policy_list;
 189       policy_list.length (1);
 190
 191       CORBA::Policy_var client_network_policy =
 192         orb->_create_policy (TAO::CLIENT_NETWORK_PRIORITY_TYPE);
 193
 194       TAO::NetworkPriorityPolicy_var nw_priority =
 195         TAO::NetworkPriorityPolicy::_narrow (client_network_policy.in ());
 196
 197       nw_priority->request_diffserv_codepoint (
 198            request_dscp);
 199
 200       nw_priority->reply_diffserv_codepoint (
 201            reply_dscp);
 202
 203       nw_priority->network_priority_model (
 204         TAO::CLIENT_PROPAGATED_NETWORK_PRIORITY);
 205
 206       policy_list[0] = TAO::NetworkPriorityPolicy::_duplicate (nw_priority.in ());
 207
 208       CORBA::Object_var over_ridden_object = hello->_set_policy_overrides (
 209          policy_list, CORBA::SET_OVERRIDE);
 210
 211       policy_list[0]->destroy ();
 212
 213       hello = Test::Hello::_unchecked_narrow (over_ridden_object.in ());
 214
 215       {
 216         // start clients
 217         ClientThread cln_thr (hello.in (), HELLO_CALL_NUMBER);
 218         cln_thr.activate (THR_NEW_LWP | THR_JOINABLE, CLIENT_THREAD_NUMBER);
 219         cln_thr.wait ();
 220       }
 221
 222       // shutdown the server, after 10 invocations of shutdown() we can be
 223       // more or less sure that server actually received that call
 224       for (int i = 0; i < 10; i++)
 225         hello->shutdown ();
 226
 227       orb->destroy ();
 228     }
 229   catch (const CORBA::Exception& ex)
 230     {
 231       ex._tao_print_exception ("Exception caught in client main ():");
 232       return 4;
 233     }
 234
 235   ACE_DEBUG ((LM_DEBUG,
 236               "\n (%P|%t) client finished successfully..\n"));
 237   return 0;
 238 }