TAO/tao/Utils/ORB_Manager.cpp

   1 // = AUTHOR
   2 //    Sumedh Mungee <sumedh@cs.wustl.edu>
   3
   4 #include "tao/Utils/ORB_Manager.h"
   5 #include "tao/Utils/PolicyList_Destroyer.h"
   6
   7 #include "tao/PortableServer/POAManagerC.h"
   8 #include "tao/PortableServer/IdAssignmentPolicyC.h"
   9 #include "tao/PortableServer/LifespanPolicyC.h"
  10
  11
  12 #include "tao/ORBInitializer_Registry.h"
  13
  14 #include "ace/Log_Msg.h"
  15
  16 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 // constructor
  19 TAO_ORB_Manager::TAO_ORB_Manager (CORBA::ORB_ptr orb,
  20                                   PortableServer::POA_ptr poa,
  21                                   PortableServer::POAManager_ptr poa_manager)
  22   : orb_ (CORBA::ORB::_duplicate(orb)),
  23     poa_ (PortableServer::POA::_duplicate(poa)),
  24     poa_manager_ (PortableServer::POAManager::_duplicate(poa_manager))
  25 {
  26 }
  27
  28 int
  29 TAO_ORB_Manager::init (int &argc,
  30                        ACE_TCHAR *argv[],
  31                        const char *orb_name)
  32 {
  33   if (CORBA::is_nil (this->orb_.in ()))
  34     {
  35       this->orb_ = CORBA::ORB_init (argc, argv, orb_name);
  36     }
  37
  38   if (CORBA::is_nil (this->poa_.in ()))
  39     {
  40       // Get the POA from the ORB.
  41       CORBA::Object_var poa_object =
  42         this->orb_->resolve_initial_references (TAO_OBJID_ROOTPOA);
  43
  44       if (CORBA::is_nil (poa_object.in ()))
  45         TAOLIB_ERROR_RETURN ((LM_ERROR,
  46                            ACE_TEXT (" (%P|%t) Unable to initialize the POA.\n")),
  47                           -1);
  48
  49       // Get the POA object.
  50       this->poa_ = PortableServer::POA::_narrow (poa_object.in ());
  51     }
  52
  53   if (CORBA::is_nil (this->poa_manager_.in ()))
  54     {
  55       // Get the POA_Manager.
  56       this->poa_manager_ = this->poa_->the_POAManager ();
  57     }
  58
  59   return 0;
  60 }
  61
  62 #if !defined (CORBA_E_MICRO)
  63 int
  64 TAO_ORB_Manager::init_child_poa (int& argc,
  65                                  ACE_TCHAR **argv,
  66                                  const char *poa_name,
  67                                  const char *orb_name)
  68 {
  69   // Check to see if root poa has to be created.
  70   if (this->init (argc, argv, orb_name) == -1)
  71     TAOLIB_ERROR_RETURN ((LM_ERROR,
  72                        ACE_TEXT (" (%P|%t) Error in init.\n")),
  73                       -1);
  74
  75   // Create the default policies - user-supplied ID, and persistent
  76   // objects.
  77   TAO::Utils::PolicyList_Destroyer policies (2);
  78   policies.length (2);
  79
  80   // Id Assignment policy
  81   policies[0] =
  82     this->poa_->create_id_assignment_policy (PortableServer::USER_ID);
  83
  84   // Lifespan policy
  85   policies[1] =
  86     this->poa_->create_lifespan_policy (PortableServer::PERSISTENT);
  87
  88   // We use a different POA, otherwise the user would have to change
  89   // the object key each time it invokes the server.
  90   this->child_poa_ =
  91     this->poa_->create_POA (poa_name, this->poa_manager_.in (), policies);
  92
  93   return 0;
  94 }
  95 #endif /* CORBA_E_MICRO */
  96
  97 // Activate POA manager.
  98
  99 int
 100 TAO_ORB_Manager::activate_poa_manager ()
 101 {
 102   this->poa_manager_->activate ();
 103   return 0;
 104 }
 105
 106 // Activate servant in the POA.
 107
 108 char *
 109 TAO_ORB_Manager::activate (PortableServer::Servant servant)
 110 {
 111   PortableServer::ObjectId_var id = this->poa_->activate_object (servant);
 112
 113   CORBA::Object_var obj = this->poa_->id_to_reference (id.in ());
 114
 115   CORBA::String_var str = this->orb_->object_to_string (obj.in ());
 116
 117   return str._retn ();
 118 }
 119
 120 void
 121 TAO_ORB_Manager::deactivate (const char *id)
 122 {
 123   CORBA::Object_var object = this->orb_->string_to_object (id);
 124
 125   PortableServer::ObjectId_var object_id =
 126     this->poa_->reference_to_id (object.in ());
 127
 128   this->poa_->deactivate_object (object_id.in ());
 129 }
 130
 131 #if !defined (CORBA_E_MICRO)
 132 // Activate the object with the object_name under the child POA.
 133 char *
 134 TAO_ORB_Manager::activate_under_child_poa (const char *object_name,
 135                                            PortableServer::Servant servant)
 136 {
 137   if (object_name == 0)
 138     TAOLIB_ERROR_RETURN ((LM_ERROR,
 139                        ACE_TEXT ("\n(%P|%t) TAO_ORB_Manager::register: ")
 140                        ACE_TEXT ("object_name is null!")),
 141                       0);
 142
 143   PortableServer::ObjectId_var id =
 144     PortableServer::string_to_ObjectId (object_name);
 145
 146   this->child_poa_->activate_object_with_id (id.in (), servant);
 147
 148   CORBA::Object_var obj = this->child_poa_->id_to_reference (id.in ());
 149
 150   CORBA::String_var str = this->orb_->object_to_string (obj.in ());
 151
 152   return str._retn();
 153 }
 154
 155 void
 156 TAO_ORB_Manager::deactivate_under_child_poa (const char *id)
 157 {
 158   CORBA::Object_var object = this->orb_->string_to_object (id);
 159
 160   PortableServer::ObjectId_var object_id =
 161     this->child_poa_->reference_to_id (object.in ());
 162
 163   this->child_poa_->deactivate_object (object_id.in ());
 164 }
 165 #endif /* CORBA_E_MICRO */
 166
 167 // Enter the ORB event loop.
 168
 169 int
 170 TAO_ORB_Manager::run (ACE_Time_Value &tv)
 171 {
 172   this->poa_manager_->activate ();
 173
 174   this->orb_->run (tv);
 175
 176   return 0;
 177 }
 178
 179 int
 180 TAO_ORB_Manager::fini ()
 181 {
 182   this->poa_->destroy (1, 1);
 183
 184   this->child_poa_   = PortableServer::POA::_nil();
 185   this->poa_         = PortableServer::POA::_nil();
 186   this->poa_manager_ = PortableServer::POAManager::_nil();
 187
 188   this->orb_->destroy ();
 189
 190   this->orb_ = CORBA::ORB::_nil();
 191
 192   return 0;
 193 }
 194
 195 int
 196 TAO_ORB_Manager::run ()
 197 {
 198   this->poa_manager_->activate ();
 199
 200   this->orb_->run ();
 201
 202   return 0;
 203 }
 204
 205 // Return the corba orb reference.
 206
 207 CORBA::ORB_ptr
 208 TAO_ORB_Manager::orb ()
 209 {
 210   return CORBA::ORB::_duplicate (this->orb_.in ());
 211 }
 212
 213 // Return the root POA reference
 214 PortableServer::POA_ptr
 215 TAO_ORB_Manager::root_poa ()
 216 {
 217   return PortableServer::POA::_duplicate (this->poa_.in ());
 218 }
 219
 220 // Return the child POA reference
 221 PortableServer::POA_ptr
 222 TAO_ORB_Manager::child_poa ()
 223 {
 224   return PortableServer::POA::_duplicate (this->child_poa_.in ());
 225 }
 226
 227 PortableServer::POAManager_ptr
 228 TAO_ORB_Manager::poa_manager ()
 229 {
 230   return PortableServer::POAManager::_duplicate (this->poa_manager_.in ());
 231 }
 232
 233 // Destructor.
 234
 235 TAO_ORB_Manager::~TAO_ORB_Manager ()
 236 {
 237   try
 238     {
 239       if (!CORBA::is_nil (this->poa_.in ()))
 240         {
 241           this->poa_->destroy (1,1);
 242         }
 243       if (!CORBA::is_nil (this->orb_.in ()))
 244         {
 245           this->orb_->destroy ();
 246         }
 247     }
 248   catch (const ::CORBA::Exception&)
 249     {
 250       // ignore any exceptions..
 251     }
 252 }
 253
 254 TAO_END_VERSIONED_NAMESPACE_DECL