TAO/tests/POA/Bug_2511_Regression/server.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file     server.cpp
   5  *
   6  *   This program tests that multiple calls to the Servant Locator
   7  *   can take place simultaneously.
   8  *
   9  *  @author  Irfan Pyarali
  10  */
  11 //=============================================================================
  12
  13
  14 #include "testS.h"
  15 #include "tao/PortableServer/ServantLocatorC.h"
  16 #include "tao/CDR.h"
  17
  18 int postCount = 0;
  19 int errorCount = 0;
  20
  21 class test_i :
  22   public virtual POA_test
  23 {
  24 public:
  25   test_i (PortableServer::POA_ptr poa);
  26
  27   void normal ();
  28
  29   void exceptional ();
  30
  31   void notexisting ();
  32
  33   PortableServer::POA_var poa_;
  34 };
  35
  36 test_i::test_i (PortableServer::POA_ptr poa)
  37   : poa_ (PortableServer::POA::_duplicate (poa))
  38 {
  39 }
  40
  41 void
  42 test_i::normal ()
  43 {
  44   ACE_DEBUG ((LM_DEBUG, "executing normal\n"));
  45 }
  46
  47 void
  48 test_i::exceptional ()
  49 {
  50   ACE_DEBUG ((LM_DEBUG, "executing exceptional\n"));
  51 }
  52
  53 void
  54 test_i::notexisting ()
  55 {
  56   ACE_DEBUG ((LM_DEBUG, "executing notexisting\n"));
  57 }
  58
  59 class Servant_Locator :
  60   public PortableServer::ServantLocator
  61 {
  62 public:
  63   Servant_Locator (PortableServer::POA_ptr poa);
  64
  65   ::PortableServer::Servant preinvoke (const PortableServer::ObjectId &,
  66                                        PortableServer::POA_ptr,
  67                                        const char *,
  68                                        PortableServer::ServantLocator::Cookie &);
  69
  70   void postinvoke (const PortableServer::ObjectId &,
  71                    PortableServer::POA_ptr,
  72                    const char *,
  73                    PortableServer::ServantLocator::Cookie,
  74                    PortableServer::Servant);
  75
  76   test_i servant_;
  77 };
  78
  79 Servant_Locator::Servant_Locator (PortableServer::POA_ptr poa)
  80   : servant_ (poa)
  81 {
  82 }
  83
  84 ::PortableServer::Servant
  85 Servant_Locator::preinvoke (const PortableServer::ObjectId &oid,
  86                             PortableServer::POA_ptr,
  87                             const char *op,
  88                             PortableServer::ServantLocator::Cookie &)
  89 {
  90   CORBA::String_var name =
  91     PortableServer::ObjectId_to_string (oid);
  92
  93   ACE_DEBUG ((LM_DEBUG,
  94               "Servant_Locator::preinvoke for %C.%C ",
  95               name.in (), op ));
  96
  97   if (ACE_OS::strcmp (op, "normal") == 0)
  98     {
  99       ACE_DEBUG ((LM_DEBUG, "returning servant\n"));
 100       return &this->servant_;
 101     }
 102   else if (ACE_OS::strcmp (op, "exceptional") == 0)
 103     {
 104       ACE_DEBUG ((LM_DEBUG, "throwing exception\n"));
 105         throw CORBA::INTERNAL();
 106     }
 107   else
 108     {
 109       ACE_DEBUG ((LM_DEBUG, "returning NULL\n"));
 110       return 0;
 111     }
 112 }
 113
 114 void
 115 Servant_Locator::postinvoke (const PortableServer::ObjectId &oid,
 116                              PortableServer::POA_ptr,
 117                              const char *op,
 118                              PortableServer::ServantLocator::Cookie,
 119                              PortableServer::Servant)
 120 {
 121   ++postCount;
 122   CORBA::String_var name =
 123     PortableServer::ObjectId_to_string (oid);
 124
 125   if (!op)
 126     {
 127       op = "NULL";
 128       ++errorCount;
 129     }
 130
 131   ACE_DEBUG ((LM_DEBUG,
 132               "Servant_Locator::postinvoke for %C.%C\n",
 133               name.in (), op ));
 134 }
 135
 136 int
 137 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 138 {
 139   try
 140     {
 141       CORBA::ORB_var orb =
 142         CORBA::ORB_init (argc, argv);
 143
 144       CORBA::Object_var obj =
 145         orb->resolve_initial_references ("RootPOA");
 146
 147       PortableServer::POA_var root_poa =
 148         PortableServer::POA::_narrow (obj.in ());
 149
 150       PortableServer::POAManager_var poa_manager =
 151         root_poa->the_POAManager ();
 152
 153       poa_manager->activate ();
 154
 155       CORBA::PolicyList policies;
 156       CORBA::ULong current_length = 0;
 157
 158       policies.length (current_length + 1);
 159       policies[current_length++] =
 160         root_poa->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER);
 161
 162       policies.length (current_length + 1);
 163       policies[current_length++] =
 164         root_poa->create_servant_retention_policy (PortableServer::NON_RETAIN);
 165
 166       policies.length (current_length + 1);
 167       policies[current_length++] =
 168         root_poa->create_id_assignment_policy (PortableServer::USER_ID);
 169
 170       PortableServer::POA_var child_poa =
 171         root_poa->create_POA ("child",
 172                               poa_manager.in (),
 173                               policies);
 174
 175       Servant_Locator servant_locator (child_poa.in ());
 176       child_poa->set_servant_manager (&servant_locator);
 177
 178       PortableServer::ObjectId_var objectID =
 179         PortableServer::string_to_ObjectId ("object");
 180
 181       CORBA::Object_var objectREF =
 182         child_poa->create_reference_with_id (objectID.in (),
 183                                              "IDL:test:1.0");
 184
 185       test_var testObject =
 186         test::_narrow (objectREF.in ());
 187
 188       testObject->normal();
 189
 190       bool caught = false;
 191       try
 192         {
 193           testObject->exceptional();
 194         }
 195       catch (const CORBA::Exception&)
 196         {
 197           ACE_DEBUG ((LM_DEBUG, "exceptional() yielded exception\n"));
 198           caught = true;
 199         }
 200       if (!caught) ++errorCount;
 201
 202       caught = false;
 203       try
 204         {
 205           testObject->notexisting();
 206         }
 207       catch (const CORBA::Exception&)
 208         {
 209           ACE_DEBUG ((LM_DEBUG, "notexisting() yielded exception\n"));
 210           caught = true;
 211         }
 212       if (!caught) ++errorCount;
 213
 214       orb->destroy ();
 215     }
 216   catch (const CORBA::Exception& ex)
 217     {
 218       ex._tao_print_exception ("Exception caught");
 219       ++errorCount;
 220     }
 221
 222   if (!errorCount)
 223     {
 224       ACE_DEBUG ((LM_DEBUG,"test successful\n"));
 225     }
 226   else
 227     {
 228       ACE_DEBUG ((LM_DEBUG,"unsuccessfull: %d errors\n", errorCount ));
 229     }
 230
 231   return errorCount;
 232 }