TAO/tests/RTCORBA/Diffserv/client.cpp

   1 #include "testC.h"
   2 #include "tao/RTCORBA/RTCORBA.h"
   3 #include "tao/RTCORBA/Network_Priority_Mapping_Manager.h"
   4 #include "tao/RTCORBA/Network_Priority_Mapping.h"
   5 #include "Custom_Network_Priority_Mapping.h"
   6 #include "ace/Get_Opt.h"
   7 #include "tao/Policy_ManagerC.h"
   8 #include "tao/Policy_CurrentC.h"
   9
  10 static const ACE_TCHAR *ior = ACE_TEXT("file://simple_servant.ior");
  11 static int iterations = 1;
  12 static int corba_priority = RTCORBA::minPriority;
  13 static int shutdown_server = 0;
  14
  15 enum Priority_Level
  16 {
  17   OBJECT,
  18   THREAD,
  19   ORB
  20 };
  21
  22 void
  23 change_network_priority (int enable_network_priority,
  24                          Priority_Level level,
  25                          Test_var &server,
  26                          CORBA::ORB_ptr orb)
  27 {
  28   try
  29     {
  30       CORBA::Object_var object =
  31         orb->resolve_initial_references ("RTORB");
  32
  33       RTCORBA::RTORB_var rt_orb =
  34         RTCORBA::RTORB::_narrow (object.in ());
  35
  36       // Set the tcp protocol properties
  37       RTCORBA::TCPProtocolProperties_var tcp_properties =
  38         rt_orb->create_tcp_protocol_properties (ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
  39                                                 ACE_DEFAULT_MAX_SOCKET_BUFSIZ,
  40                                                 1,
  41                                                 0,
  42                                                 1,
  43                                                 enable_network_priority);
  44
  45       RTCORBA::ProtocolList protocols;
  46       protocols.length (1);
  47       protocols[0].protocol_type = 0;
  48       protocols[0].transport_protocol_properties =
  49         RTCORBA::ProtocolProperties::_duplicate (tcp_properties.in ());
  50       protocols[0].orb_protocol_properties =
  51         RTCORBA::ProtocolProperties::_nil ();
  52
  53       CORBA::PolicyList policy_list;
  54       policy_list.length (1);
  55       policy_list[0] =
  56         rt_orb->create_client_protocol_policy (protocols);
  57
  58       switch (level)
  59         {
  60           // Change policy at ORB level
  61         case ORB:
  62           {
  63             object = orb->resolve_initial_references ("ORBPolicyManager");
  64
  65             CORBA::PolicyManager_var policy_manager =
  66               CORBA::PolicyManager::_narrow (object.in ());
  67
  68             policy_manager->set_policy_overrides (policy_list,
  69                                                   CORBA::SET_OVERRIDE);
  70
  71             break;
  72           }
  73
  74           // Change policy at THREAD level
  75         case THREAD:
  76           {
  77             object =
  78               orb->resolve_initial_references ("PolicyCurrent");
  79
  80             CORBA::PolicyCurrent_var policy_current =
  81               CORBA::PolicyCurrent::_narrow (object.in ());
  82
  83             policy_current->set_policy_overrides (policy_list,
  84                                                   CORBA::SET_OVERRIDE);
  85
  86             break;
  87           }
  88
  89           // Change policy at OBJECT level
  90         case OBJECT:
  91           {
  92             CORBA::Object_var object = server->_set_policy_overrides (policy_list,
  93                                                                       CORBA::SET_OVERRIDE);
  94
  95             server = Test::_narrow (object.in ());
  96
  97             break;
  98           }
  99         }
 100     }
 101   catch (const CORBA::Exception& ex)
 102     {
 103       ex._tao_print_exception ("Caught exception:");
 104     }
 105 }
 106
 107 int
 108 parse_args (int argc, ACE_TCHAR *argv[])
 109 {
 110   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("k:n:p:x:"));
 111   int c;
 112
 113   while ((c = get_opts ()) != -1)
 114     switch (c)
 115       {
 116       case 'k':
 117         ior = get_opts.opt_arg ();
 118         break;
 119
 120         // number of itarations
 121       case 'n':
 122         iterations = ACE_OS::atoi (get_opts.opt_arg ());
 123         break;
 124
 125         // corba priority
 126       case 'p':
 127         corba_priority = ACE_OS::atoi (get_opts.opt_arg ());
 128         break;
 129
 130         // shutdown server
 131       case 'x':
 132         shutdown_server = ACE_OS::atoi (get_opts.opt_arg ());
 133         break;
 134
 135       default:
 136         ACE_ERROR_RETURN ((LM_ERROR,
 137                            "usage:  %s\n"
 138                            "\t-k <ior> [default is %s]\n"
 139                            "\t-n <number of invocations> [defaults to %d]\n"
 140                            "\t-p <corba priority> [defaults to %d]\n"
 141                            "\t-x <shutdown server> [defaults to %d]\n"
 142                            "\n",
 143                            argv [0],
 144                            ior,
 145                            iterations,
 146                            corba_priority,
 147                            shutdown_server),
 148                           -1);
 149       }
 150
 151   return 0;
 152 }
 153
 154 void
 155 toggle (int &i)
 156 {
 157   if (i == 0)
 158     i = 1;
 159   else i = 0;
 160 }
 161
 162 int
 163 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 164 {
 165   try
 166     {
 167       CORBA::ORB_var orb =
 168         CORBA::ORB_init (argc, argv);
 169
 170       if (parse_args (argc, argv) != 0)
 171         return -1;
 172
 173       // Initialize and obtain reference to the Test object.
 174       CORBA::Object_var client_object =
 175         orb->string_to_object (ior);
 176
 177       Test_var server =
 178         Test::_narrow (client_object.in ());
 179
 180       // Resolve the Network priority Mapping Manager
 181       CORBA::Object_var object =
 182         orb->resolve_initial_references ("NetworkPriorityMappingManager");
 183
 184       RTCORBA::NetworkPriorityMappingManager_var mapping_manager =
 185         RTCORBA::NetworkPriorityMappingManager::_narrow (object.in ());
 186
 187       // Initialize the custom priority mapping
 188       Custom_Network_Priority_Mapping *cnpm = 0;
 189       ACE_NEW_RETURN  (cnpm,
 190                        Custom_Network_Priority_Mapping,
 191                        -1);
 192
 193       // Set the desired corba priority on the network mapping manager
 194       cnpm->corba_priority (corba_priority);
 195
 196       // Load the custom network priority mapping object in the
 197       // network priority mapping manager. The user can thus add his
 198       // own priority mapping.
 199       mapping_manager->mapping (cnpm);
 200
 201       int enable_network_priority = 1;
 202
 203       // Make several invocation,
 204       for (int i = 0; i < iterations; ++i)
 205         {
 206           toggle (enable_network_priority);
 207
 208           switch (i)
 209             {
 210             case 0:
 211             case 1:
 212               change_network_priority (enable_network_priority, ORB, server, orb.in ());
 213               break;
 214             case 2:
 215             case 3:
 216               change_network_priority (enable_network_priority, THREAD, server, orb.in ());
 217               break;
 218             default:
 219               change_network_priority (enable_network_priority, OBJECT, server, orb.in ());
 220               break;
 221             }
 222
 223           server->test_method ();
 224         }
 225
 226       // Shut down Server ORB.
 227       if (shutdown_server)
 228         {
 229           server->shutdown ();
 230         }
 231     }
 232   catch (const CORBA::Exception& ex)
 233     {
 234       ex._tao_print_exception ("Caught exception:");
 235       return -1;
 236     }
 237
 238   return 0;
 239 }