TAO/tests/POA/EndpointPolicy/server.cpp

   1 #include "Hello.h"
   2 #include "tao/PolicyC.h"
   3 #include "tao/EndpointPolicy/EndpointPolicy.h"
   4 #include "tao/EndpointPolicy/IIOPEndpointValue_i.h"
   5 #include "tao/Strategies/advanced_resource.h"
   6 #include "tao/PI_Server/PI_Server.h"
   7 #include "tao/ORB_Constants.h"
   8 #include "ace/OS_NS_strings.h"
   9 #include "ace/OS_NS_stdio.h"
  10 #include "ace/OS_NS_unistd.h"
  11
  12 const ACE_TCHAR *good_ior_file = ACE_TEXT ("good.ior");
  13 const ACE_TCHAR *bad_ior_file = ACE_TEXT ("bad.ior");
  14 const ACE_TCHAR *root_ior_file = ACE_TEXT("root.ior");
  15 const ACE_TCHAR *svc_conf_file = ACE_TEXT("multi_prot.conf");
  16
  17 int load_advanced_resources =
  18 ACE_Service_Config::process_directive (ace_svc_desc_TAO_Advanced_Resource_Factory);
  19
  20 CORBA::Short endpoint_port = 12345;
  21 int verbose = 0;
  22
  23 enum HostNameForm
  24   {
  25     from_hostname,
  26     use_localhost,
  27     use_defaulted,
  28     multi_protocol
  29   };
  30
  31 const ACE_TCHAR *form_arg;
  32
  33 HostNameForm host_form = from_hostname;
  34
  35 int
  36 parse_args (int argc, ACE_TCHAR *argv[])
  37 {
  38   for (int c = 1; c < argc; c++) {
  39     if (ACE_OS::strcasecmp (argv[c], ACE_TEXT ("-g")) == 0)
  40       {
  41         good_ior_file = argv[++c];
  42       }
  43     else if (ACE_OS::strcasecmp (argv[c], ACE_TEXT ("-b")) == 0)
  44       {
  45         bad_ior_file = argv[++c];
  46       }
  47     else if (ACE_OS::strcasecmp (argv[c], ACE_TEXT ("-c")) == 0)
  48       {
  49         svc_conf_file = argv[++c];
  50       }
  51     else if (ACE_OS::strcasecmp (argv[c], ACE_TEXT ("-p")) == 0)
  52       {
  53         endpoint_port = ACE_OS::atoi (argv[++c]);
  54       }
  55     else if (ACE_OS::strcasecmp (argv[c], ACE_TEXT ("-v")) == 0)
  56       {
  57         verbose = 1;
  58       }
  59     else if (ACE_OS::strcasecmp (argv[c], ACE_TEXT ("-h")) == 0)
  60       {
  61         ++c;
  62         if (c == argc)
  63           ACE_ERROR_RETURN ((LM_ERROR,
  64                              "host form option requires an argument\n"),-1);
  65         form_arg = argv[c];
  66         if (ACE_OS::strcasecmp (form_arg, ACE_TEXT ("local")) == 0)
  67           host_form = use_localhost;
  68         else if (ACE_OS::strcasecmp (form_arg, ACE_TEXT ("default")) == 0)
  69           host_form = use_defaulted;
  70         else if (ACE_OS::strcasecmp (form_arg, ACE_TEXT ("multi")) == 0)
  71           host_form = multi_protocol;
  72         else
  73           ACE_ERROR_RETURN ((LM_ERROR,
  74                              "invalid host form arg, '%s'\n", form_arg), -1);
  75       }
  76     else if (ACE_OS::strstr (argv[c], ACE_TEXT ("-ORB")) == argv[c])
  77       {
  78         c++;
  79         continue;
  80       }
  81     else
  82       ACE_ERROR_RETURN ((LM_ERROR,
  83                          "usage:  %s "
  84                          "-g <goodiorfile> "
  85                          "-b <badiorfile> "
  86                          "-c <svc_conf_file>"
  87                          "-p <port> "
  88                          "-v "
  89                          "\n",
  90                          argv [0]),
  91                         -1);
  92   }
  93   // Indicates successful parsing of the command line
  94   return 0;
  95 }
  96
  97 int
  98 make_ior (CORBA::ORB_ptr orb,
  99           PortableServer::POA_ptr poa,
 100           Hello * servant,
 101           const ACE_TCHAR *ior_file)
 102 {
 103   CORBA::String_var poa_name = poa->the_name();
 104   ACE_DEBUG ((LM_DEBUG, "Creating IOR from %C\n", poa_name.in()));
 105
 106   PortableServer::ObjectId_var oid = poa->activate_object (servant);
 107   CORBA::Object_var o = poa->id_to_reference (oid.in ());
 108
 109
 110   if (host_form == from_hostname || host_form == use_localhost)
 111     {
 112       CORBA::String_var ior =
 113         orb->object_to_string (o.in ());
 114
 115       FILE *output_file= ACE_OS::fopen (ior_file, "w");
 116       if (output_file == 0)
 117         ACE_ERROR_RETURN ((LM_ERROR,
 118                            "Cannot open output file %s for writing IOR: %C",
 119                            ior_file,
 120                            ior.in ()),
 121                           1);
 122       ACE_OS::fprintf (output_file, "%s", ior.in ());
 123       ACE_OS::fclose (output_file);
 124     }
 125   return 0;
 126 }
 127
 128
 129 int
 130 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
 131 {
 132   CORBA::ORB_var orb;
 133   CORBA::Object_var obj;
 134   PortableServer::POA_var root_poa;
 135   PortableServer::POAManagerFactory_var poa_manager_factory;
 136
 137   if (parse_args (argc, argv) != 0)
 138     return 1;
 139
 140   const ACE_TCHAR *e1_format= ACE_TEXT ("iiop://%s:%d");
 141   const ACE_TCHAR *e2_format= ACE_TEXT ("iiop://%s:%d/hostname_in_ior=unreachable");
 142   ACE_TCHAR hostname[256];
 143   int num_extra = 4;
 144
 145   switch (host_form)
 146     {
 147     case from_hostname:
 148       ACE_OS::hostname (hostname, sizeof(hostname) / sizeof (ACE_TCHAR));
 149       break;
 150
 151     case use_localhost:
 152       ACE_OS::strcpy (hostname, ACE_TEXT ("localhost"));
 153       break;
 154
 155     case use_defaulted:
 156       hostname[0] = ACE_TEXT ('\0');
 157       break;
 158
 159     case multi_protocol:
 160       hostname[0] = ACE_TEXT ('\0');
 161       e2_format = ACE_TEXT ("diop://");
 162       num_extra = 6;
 163       break;
 164     }
 165
 166   size_t hostname_len = ACE_OS::strlen (hostname);
 167   size_t e1_len = ACE_OS::strlen (e1_format) + 5; // 5 for the port#
 168   size_t e2_len = ACE_OS::strlen (e2_format) + 5;
 169   ACE_TCHAR **extra = 0;
 170   ACE_NEW_RETURN (extra, ACE_TCHAR *[num_extra], -1);
 171
 172   extra[0] = ACE::strnew (ACE_TEXT ("-ORBEndpoint"));
 173   ACE_NEW_RETURN (extra[1],
 174                   ACE_TCHAR[e1_len + hostname_len + 1],
 175                   -1);
 176   ACE_OS::sprintf (extra[1], e1_format, hostname, endpoint_port);
 177   extra[2] = ACE::strnew (ACE_TEXT ("-ORBEndpoint"));
 178   ACE_NEW_RETURN (extra[3],
 179                   ACE_TCHAR[e2_len + hostname_len + 1],
 180                   -1);
 181   ACE_OS::sprintf (extra[3], e2_format, hostname, endpoint_port+1);
 182   if (host_form == multi_protocol)
 183     {
 184       extra[4] = ACE::strnew (ACE_TEXT ("-ORBSvcConf"));
 185       extra[5] = ACE::strnew (svc_conf_file);
 186     }
 187
 188   ACE_TCHAR **largv = new ACE_TCHAR *[argc+num_extra];
 189   int i = 0;
 190   for (i = 0; i < argc; i++)
 191     largv[i] = argv[i];
 192
 193   ACE_DEBUG ((LM_DEBUG,"server adding args: "));
 194   for (i = 0; i < num_extra; i++)
 195     {
 196       ACE_DEBUG ((LM_DEBUG, "%s ", extra[i]));
 197       largv[argc+i] = extra[i];
 198     }
 199   ACE_DEBUG ((LM_DEBUG, "\n"));
 200
 201   argc += num_extra;
 202
 203   try
 204     {
 205       orb =
 206         CORBA::ORB_init (argc, largv, "EndpointPolicy");
 207
 208       obj =
 209         orb->resolve_initial_references("RootPOA");
 210
 211       root_poa =
 212         PortableServer::POA::_narrow (obj.in ());
 213
 214       if (CORBA::is_nil (root_poa.in ()))
 215         ACE_ERROR_RETURN ((LM_ERROR,
 216                            " (%P|%t) Panic: nil RootPOA\n"),
 217                           1);
 218
 219       poa_manager_factory
 220         = root_poa->the_POAManagerFactory ();
 221     }
 222   catch (const CORBA::Exception &ex)
 223     {
 224       ex._tao_print_exception("initialization error ");
 225       return 1;
 226     }
 227
 228   for (i = 0; i < num_extra; i++)
 229     ACE::strdelete (extra[i]);
 230   delete [] extra;
 231   delete [] largv;
 232
 233   //-----------------------------------------------------------------------
 234
 235   // Create two valid endpoint policies. One to match each of the generated
 236   // endpoint arguments supplied to ORB_init().
 237   PortableServer::POAManager_var good_pm;
 238   PortableServer::POAManager_var bad_pm;
 239   CORBA::PolicyList policies;
 240   policies.length (1);
 241
 242   EndpointPolicy::EndpointList list;
 243   list.length (1);
 244   list[0] = new IIOPEndpointValue_i (ACE_TEXT_ALWAYS_CHAR (hostname), endpoint_port);
 245
 246   try
 247     {
 248       CORBA::Any policy_value;
 249       policy_value <<= list;
 250       policies[0] = orb->create_policy (EndpointPolicy::ENDPOINT_POLICY_TYPE,
 251                                         policy_value);
 252       good_pm = poa_manager_factory->create_POAManager ("goodPOAManager",
 253                                                         policies);
 254
 255       if (host_form == use_defaulted)
 256         {
 257           ACE_ERROR_RETURN ((LM_DEBUG,
 258                              "ERROR: Expected to catch policy error with "
 259                              "defaulted hostname, but didn't.\n"),1);
 260         }
 261     }
 262   catch (const CORBA::PolicyError &)
 263     {
 264       if (host_form == use_defaulted)
 265         {
 266           ACE_ERROR_RETURN ((LM_DEBUG,
 267                              "Defaulted hostname properly rejected\n"), 0);
 268         }
 269       ACE_ERROR_RETURN ((LM_DEBUG,
 270                          "ERROR: Unexpectedly caught PolicyError "
 271                          "exception host_form = %s\n", form_arg), 1);
 272     }
 273   catch (const CORBA::Exception &ex)
 274     {
 275       ex._tao_print_exception ("Failed to create reachable POA manager");
 276       return 1;
 277     }
 278
 279   list[0] = new IIOPEndpointValue_i("unreachable", endpoint_port+1);
 280   try
 281     {
 282       CORBA::Any policy_value;
 283       policy_value <<= list;
 284       policies[0] = orb->create_policy (EndpointPolicy::ENDPOINT_POLICY_TYPE,
 285                                         policy_value);
 286       bad_pm = poa_manager_factory->create_POAManager ("badPOAManager",
 287                                                         policies);
 288     }
 289   catch (const CORBA::Exception &ex)
 290     {
 291       ex._tao_print_exception ("Failed to create unreachable POA manager");
 292       return 1;
 293     }
 294
 295   try
 296     {
 297       Hello *hello_impl;
 298       ACE_NEW_RETURN (hello_impl,
 299                       Hello (orb.in ()),
 300                       1);
 301       PortableServer::ServantBase_var owner_transfer(hello_impl);
 302
 303       // Create poas assiciated with the each the good poa manager and the
 304       // bad poa manager.
 305       policies.length(0);
 306       PortableServer::POA_var good_poa =
 307         root_poa->create_POA ("goodPOA",
 308                               good_pm.in (),
 309                               policies);
 310
 311       int result = 0;
 312       result = make_ior (orb.in(), root_poa.in(), hello_impl, root_ior_file);
 313       if (result != 0)
 314         return result;
 315
 316       result = make_ior (orb.in(), good_poa.in(), hello_impl, good_ior_file);
 317       if (result != 0)
 318         return result;
 319
 320       good_pm->activate ();
 321
 322       PortableServer::POA_var bad_poa;
 323
 324       if (host_form != multi_protocol)
 325         {
 326           bad_poa =
 327           root_poa->create_POA ("badPOA",
 328                                 bad_pm.in (),
 329                                 policies);
 330           result = make_ior (orb.in(), bad_poa.in(), hello_impl, bad_ior_file);
 331           if (result != 0)
 332             return result;
 333
 334           bad_pm->activate ();
 335         }
 336
 337       if (host_form == from_hostname || host_form == use_localhost)
 338         {
 339           orb->run ();
 340           ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n"));
 341         }
 342     }
 343   catch (const CORBA::Exception &ex)
 344     {
 345       ex._tao_print_exception ("cannot run server");
 346     }
 347   try
 348     {
 349       root_poa->destroy (true, true);
 350
 351       orb->destroy ();
 352     }
 353   catch (const CORBA::Exception &ex)
 354     {
 355       ex._tao_print_exception ("CORBA exception during shutdown");
 356     }
 357   return 0;
 358 }