From 088fc29fae367c1eecc6726feab0d7a1edee4845 Mon Sep 17 00:00:00 2001 From: wolff1 Date: Sun, 22 Feb 2009 00:14:14 +0000 Subject: Added FT_Session_Container --- CIAO/MPC/config/ciao_ft_componentserver_svnt.mpb | 2 +- CIAO/MPC/config/ciao_ft_session_container.mpb | 8 + .../Containers/FTSession/FT_Session_Container.cpp | 953 +++++++++++++++++++++ .../Containers/FTSession/FT_Session_Container.h | 238 +++++ .../Containers/FTSession/FT_Session_Container.idl | 19 + .../Containers/FTSession/FT_Session_Container.inl | 13 + .../Containers/FTSession/FT_Session_Container.mpc | 22 + .../FTSession/FT_Session_Container_export.h | 58 ++ .../FTComponentServer/CIAO_ComponentServer.mpc | 4 +- .../ciao/FTComponentServer/CIAO_Container_Impl.cpp | 4 +- CIAO/ciao/FTComponentServer/CIAO_Container_Impl.h | 2 +- CIAO/ciao/FTComponentServer/CIAO_Properties.idl | 1 + 12 files changed, 1318 insertions(+), 6 deletions(-) create mode 100644 CIAO/MPC/config/ciao_ft_session_container.mpb create mode 100644 CIAO/ciao/Containers/FTSession/FT_Session_Container.cpp create mode 100644 CIAO/ciao/Containers/FTSession/FT_Session_Container.h create mode 100644 CIAO/ciao/Containers/FTSession/FT_Session_Container.idl create mode 100644 CIAO/ciao/Containers/FTSession/FT_Session_Container.inl create mode 100644 CIAO/ciao/Containers/FTSession/FT_Session_Container.mpc create mode 100644 CIAO/ciao/Containers/FTSession/FT_Session_Container_export.h diff --git a/CIAO/MPC/config/ciao_ft_componentserver_svnt.mpb b/CIAO/MPC/config/ciao_ft_componentserver_svnt.mpb index 89a45d7c324..e0227df2eaa 100644 --- a/CIAO/MPC/config/ciao_ft_componentserver_svnt.mpb +++ b/CIAO/MPC/config/ciao_ft_componentserver_svnt.mpb @@ -1,7 +1,7 @@ // -*- MPC -*- // $Id$ -project : ciao_ft_componentserver_stub, ciao_session_container { +project : ciao_ft_componentserver_stub, ciao_ft_session_container { after += CIAO_FTComponentServer_svnt libs += CIAO_FTComponentServer_svnt } diff --git a/CIAO/MPC/config/ciao_ft_session_container.mpb b/CIAO/MPC/config/ciao_ft_session_container.mpb new file mode 100644 index 00000000000..69028742033 --- /dev/null +++ b/CIAO/MPC/config/ciao_ft_session_container.mpb @@ -0,0 +1,8 @@ +// -*- MPC -*- +// $Id$ + +project : utils, \ + ccm_componentserver_stub, ciao_port_activator_stub, ciao_servant_activator, ciao_container_base { + libs += CIAO_FT_Session_Container + after += CIAO_FT_Session_Container +} diff --git a/CIAO/ciao/Containers/FTSession/FT_Session_Container.cpp b/CIAO/ciao/Containers/FTSession/FT_Session_Container.cpp new file mode 100644 index 00000000000..418ff2b1ccd --- /dev/null +++ b/CIAO/ciao/Containers/FTSession/FT_Session_Container.cpp @@ -0,0 +1,953 @@ +// $Id$ + +#include "FT_Session_Container.h" + +#include "tao/Utils/PolicyList_Destroyer.h" +#include "ciao/CIAO_common.h" +#include "ciao/Containers/Servant_Activator.h" +#include "ccm/ComponentServer/ComponentServer_BaseC.h" +#include "ciao/ComponentServer/CIAO_ComponentServerC.h" +#include "ciao/Servants/Servant_Impl_Base.h" +#include "orbsvcs/orbsvcs/LWFT/ReplicatedApplicationS.h" + +#if !defined (__ACE_INLINE__) +# include "FT_Session_Container.inl" +#endif /* __ACE_INLINE__ */ + +namespace CIAO +{ + /////////////////////////////////////////////////////////////// + + ACE_Atomic_Op + FT_Session_Container::serial_number_ (0); + + FT_Session_Container::FT_Session_Container (CORBA::ORB_ptr o, + Deployment::CIAO_Container_i *container_impl, + bool static_config_flag, + const Static_Config_EntryPoints_Maps* maps, + const char *name, + const CORBA::PolicyList *more_policies) + : Container_i (o, container_impl), + number_ (0), + static_config_flag_ (static_config_flag), + static_entrypts_maps_ (maps), + sa_ (0) + { + this->init (name, more_policies); + } + + FT_Session_Container::~FT_Session_Container (void) + { + if (! CORBA::is_nil (this->component_poa_.in ())) + { + this->component_poa_->destroy (1, 1); + } + + if (! CORBA::is_nil (this->facet_cons_poa_.in ())) + { + this->facet_cons_poa_->destroy (1, 1); + } + + if (! CORBA::is_nil (this->home_servant_poa_.in ())) + { + this->home_servant_poa_->destroy (1, 1); + } + + // delete this->sa_; + } + + void + FT_Session_Container::init (const char *name, + const CORBA::PolicyList *more_policies) + { + CIAO_TRACE ("FT_Session_Container::init"); + + char buffer[MAXPATHLEN]; + + if (name == 0) + { + this->number_ = ++FT_Session_Container::serial_number_; + CIAO_DEBUG ((LM_TRACE, CLINFO "FT_Session_Container::init - " + "Constructing container name from serial number %u\n", + this->number_)); + ACE_OS::sprintf (buffer, + "CIAO::FT_Session_Container-%ld", + this->number_); + name = buffer; + } + + CIAO_DEBUG ((LM_TRACE, CLINFO "FT_Session_Container::init - " + "Initializing a container with name %s\n", + name)); + + CORBA::Object_var poa_object = + this->orb_->resolve_initial_references ("RootPOA"); + + if (CORBA::is_nil (poa_object.in ())) + { + CIAO_ERROR ((LM_ERROR, CLINFO + "CIAO::FT_Session_Container: Unable to initialize the POA.\n")); + throw Components::CreateFailure (); + } + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in ()); + + this->create_component_POA (name, + more_policies, + root_poa.in ()); + + ACE_CString port_poa_name (name); + port_poa_name += ":Port_POA"; + this->create_facet_consumer_POA (port_poa_name.c_str (), + more_policies, + root_poa.in ()); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (); + + poa_manager->activate (); + } + + void + FT_Session_Container::create_component_POA (const char *name, + const CORBA::PolicyList *p, + PortableServer::POA_ptr root) + { + CIAO_TRACE ("FT_Session_Container::create_component_POA"); + + // Set up proper poa policies here. Default policies seems to be + // fine for session container. If you add some other default + // policies here, then you need to "add" more_policies below + // instead of simply assigning more_policies to the init policy + // list. + + CORBA::PolicyList policies (0); + + if (p != 0) + { + policies = *p; + } + + PortableServer::POAManager_var poa_manager = + root->the_POAManager (); + + try + { + this->component_poa_ = + root->create_POA (name, + poa_manager.in (), + policies); + } + catch (CORBA::Exception & ex) + { + CIAO_DEBUG ((LM_ERROR, + "FT_Session_Container::create_Component_POA () : %s\n", + ex._info ().c_str ())); + } + + if (CORBA::is_nil (component_poa_.in ())) + { + CIAO_DEBUG ((LM_ERROR, + "FT_Session_Container::create_Component_POA () : component POA is nil.\n")); + } + } + + void + FT_Session_Container::create_facet_consumer_POA (const char *name, + const CORBA::PolicyList *p, + PortableServer::POA_ptr root) + { + CIAO_TRACE ("FT_Session_Container::create_facet_consumer_POA"); + + PortableServer::POAManager_var poa_manager = root->the_POAManager (); + CORBA::ULong p_length = 0; + + if (p != 0) + { + p_length = p->length (); + } + + TAO::Utils::PolicyList_Destroyer policies (p_length + 3); + policies.length (p_length + 3); + + policies[0] = + root->create_id_assignment_policy (PortableServer::USER_ID); + + // Servant Manager Policy + policies[1] = + root->create_request_processing_policy (PortableServer::USE_SERVANT_MANAGER); + + // Servant Retention Policy + policies[2] = + root->create_servant_retention_policy (PortableServer::RETAIN); + + for (CORBA::ULong i = 0; i < p_length; ++i) + { + policies[i+3] = (*p)[i]; + } + + this->facet_cons_poa_ = + root->create_POA (name, + poa_manager.in (), + policies); + + Servant_Activator_i *sa; + ACE_NEW_THROW_EX (sa, + Servant_Activator_i (this->orb_.in ()), + CORBA::NO_MEMORY ()); + this->sa_ = sa; + + this->facet_cons_poa_->set_servant_manager (this->sa_.in ()); + } + + CORBA::Object_ptr + FT_Session_Container::install_servant (PortableServer::Servant p, + Container_Types::OA_Type t, + PortableServer::ObjectId_out oid) + { + CIAO_TRACE ("FT_Session_Container::install_servant"); + + PortableServer::POA_ptr tmp = 0; + + if (t == Container_Types::COMPONENT_t || + t == Container_Types::HOME_t) + { + tmp = this->component_poa_.in (); + } + else + { + tmp = this->facet_cons_poa_.in (); + } + + PortableServer::ObjectId_var tmp_id = tmp->activate_object (p); + + CORBA::Object_var objref = tmp->id_to_reference (tmp_id.in ()); + oid = tmp_id._retn (); + + CIAO_DEBUG ((LM_DEBUG, CLINFO "FT_Session_Container::install_servant () : servant activated\n")); + + return objref._retn (); + } + + CORBA::Object_ptr + FT_Session_Container::install_servant_with_id (PortableServer::Servant p, + Container_Types::OA_Type t, + const PortableServer::ObjectId & oid) + { + CIAO_TRACE ("FT_Session_Container::install_servant_with_id"); + + PortableServer::POA_ptr tmp = 0; + + if (t == Container_Types::COMPONENT_t || + t == Container_Types::HOME_t) + { + tmp = this->component_poa_.in (); + } + else + { + tmp = this->facet_cons_poa_.in (); + } + + CORBA::String_var name = PortableServer::ObjectId_to_string (oid); + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_servant_with_id (%s)", + name.in ())); + + tmp->activate_object_with_id (oid, + p); + + CORBA::Object_var objref = tmp->id_to_reference (oid); + + CIAO_DEBUG ((LM_DEBUG, + CLINFO "FT_Session_Container::install_servant_with_id () : " + "servant activated\n")); + + return objref._retn (); + } + + + //@@ Apparently we need to be cautious when handling the exception + // thrown here. We should make sure that new DnC interfaces + // NodeApplication/NodeApplicationManager etc will cache the new + // exceptions--> rethrow of new exceptions is needed. + // --Tao + Components::CCMHome_ptr + FT_Session_Container::install_home (const char *primary_artifact, + const char *entry_point, + const char *servant_artifact, + const char *servant_entrypoint, + const char *name) + { + CIAO_TRACE ("FT_Session_Container::install_home"); + + HomeFactory hcreator = 0; + HomeServantFactory screator = 0; + + if (this->static_config_flag_ == false) + { + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_home - " + "Loading home [%s] from shared libraries\n", + name)); + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_home - " + "Executor library [%s] with entrypoint [%s]\n", + primary_artifact, entry_point)); + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_home - " + "Servant library [%s] with entrypoint [%s]\n", + servant_artifact, servant_entrypoint)); + + ACE_DLL executor_dll, servant_dll; + + if (primary_artifact == 0 || servant_artifact == 0) + { + ACE_CString exception; + + if (primary_artifact == 0) + { + exception = "Null component executor DLL name"; + } + + if (servant_artifact == 0) + { + exception = "Null component servant DLL name"; + } + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_home -" + "ERROR: %s\n", + exception.c_str ())); + + throw Components::Deployment::UnknownImplId (); + } + + if (executor_dll.open (primary_artifact, + ACE_DEFAULT_SHLIB_MODE, + 0) != 0) + { + ACE_CString error ("Failed to open executor DLL: "); + error += primary_artifact; + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_home -" + "ERROR in opening the executor DLL [%s] \n", + primary_artifact)); + + throw Components::Deployment::UnknownImplId (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_home - Executor DLL successfully opened\n")); + + if (servant_dll.open (servant_artifact, + ACE_DEFAULT_SHLIB_MODE, + 0) != 0) + { + ACE_CString error ("Failed to open executor DLL: "); + error += servant_artifact; + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_home -" + "ERROR in opening the servant DLL [%s] \n", + servant_artifact)); + + throw Components::Deployment::UnknownImplId (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_home - Servant DLL successfully openend.\n")); + + if (entry_point == 0 || servant_entrypoint == 0) + { + ACE_CString error ("Entry point is null for "); + + if (entry_point == 0) + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_home -" + "ERROR in opening the executor entry point " + "for executor DLL [%s] \n", + primary_artifact)); + error += primary_artifact; + } + else + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_home -" + "ERROR in opening the servant entry point " + "for servant DLL [%s] \n", + servant_artifact)); + error += servant_artifact; + } + + throw Components::Deployment::ImplEntryPointNotFound (); + } + + // We have to do this casting in two steps because the C++ + // standard forbids casting a pointer-to-object (including + // void*) directly to a pointer-to-function. + void *void_ptr = executor_dll.symbol (entry_point); + ptrdiff_t tmp_ptr = reinterpret_cast (void_ptr); + hcreator = reinterpret_cast (tmp_ptr); + + void_ptr = servant_dll.symbol (servant_entrypoint); + tmp_ptr = reinterpret_cast (void_ptr); + screator = reinterpret_cast (tmp_ptr); + } + else + { + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_home - Loading statically linked home [%s]\n", + name)); + + if (static_entrypts_maps_ == 0 + || static_entrypts_maps_->home_creator_funcptr_map_ == 0 + || static_entrypts_maps_->home_servant_creator_funcptr_map_ == 0) + { + CIAO_DEBUG ((LM_ERROR, CLINFO + "FT_Session_Container::install_home - ERROR: Static entrypoint " + "maps are null or imcomplete.\n")); + throw Components::Deployment::ImplEntryPointNotFound (); + } + + ACE_CString entry_point_str (entry_point); + static_entrypts_maps_->home_creator_funcptr_map_->find (entry_point_str, + hcreator); + + ACE_CString servant_entrypoint_str (servant_entrypoint); + static_entrypts_maps_->home_servant_creator_funcptr_map_->find (servant_entrypoint_str, + screator); + } + + if (hcreator == 0 || screator == 0) + { + ACE_CString error ("Entry point "); + + if (hcreator == 0) + { + error += entry_point; + error += " invalid in dll "; + error += primary_artifact; + } + else + { + error += servant_entrypoint; + error += " invalid in dll "; + error += servant_artifact; + } + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container::ciao_install_home - Error:%s\n", + error.c_str ())); + + throw Components::Deployment::ImplEntryPointNotFound (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_home - Loading home executor\n")); + Components::HomeExecutorBase_var home_executor = hcreator (); + + if (CORBA::is_nil (home_executor.in ())) + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container::Ciao_install_hoe - Home executor factory failed. \n")); + throw Components::Deployment::InstallationFailure (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_home - Loading home servant\n")); + PortableServer::Servant home_servant = screator (home_executor.in (), + this, + name); + + if (home_servant == 0) + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container::ciao_install_home - Home servant factory failed.\n")); + throw Components::Deployment::InstallationFailure (); + } + + PortableServer::ServantBase_var safe (home_servant); + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_home - Installing home servant\n")); + + PortableServer::ObjectId_var oid; + + CORBA::Object_var objref = + this->install_servant (home_servant, Container_Types::HOME_t, oid.out ()); + + Components::CCMHome_var homeref = + Components::CCMHome::_narrow (objref.in ()); + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_home - Home successfully created with name\n")); + + return homeref._retn (); + } + + Components::CCMObject_ptr + FT_Session_Container::install_component (const char *primary_artifact, + const char *entry_point, + const char *servant_artifact, + const char *servant_entrypoint, + const char *name) + { + CIAO_TRACE ("FT_Session_Container::install_component"); + + ComponentFactory ccreator = 0; + ComponentServantFactory screator = 0; + + if (this->static_config_flag_ == false) + { + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_component - " + "Loading component [%s] from shared libraries\n", + name)); + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_component - " + "Executor library [%s] with entrypoint [%s]\n", + primary_artifact, entry_point)); + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_component - " + "Servant library [%s] with entrypoint [%s]\n", + servant_artifact, servant_entrypoint)); + + ACE_DLL executor_dll, servant_dll; + + if (primary_artifact == 0 || servant_artifact == 0) + { + ACE_CString exception; + + if (primary_artifact == 0) + { + exception = "Null component executor DLL name"; + } + + if (servant_artifact == 0) + { + exception = "Null component servant DLL name"; + } + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_component -" + "ERROR: %s\n", + exception.c_str ())); + + throw Components::Deployment::UnknownImplId (); + } + + if (executor_dll.open (primary_artifact, + ACE_DEFAULT_SHLIB_MODE, + 0) != 0) + { + ACE_CString error ("Failed to open executor DLL: "); + error += primary_artifact; + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_component -" + "ERROR in opening the executor DLL [%s] \n", + primary_artifact)); + + throw Components::Deployment::UnknownImplId (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_component - Executor DLL successfully opened\n")); + + if (servant_dll.open (servant_artifact, + ACE_DEFAULT_SHLIB_MODE, + 0) != 0) + { + ACE_CString error ("Failed to open executor DLL: "); + error += servant_artifact; + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_component -" + "ERROR in opening the servant DLL [%s] \n", + servant_artifact)); + + throw Components::Deployment::UnknownImplId (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_component - Servant DLL successfully openend.\n")); + + if (entry_point == 0 || servant_entrypoint == 0) + { + ACE_CString error ("Entry point is null for "); + + if (entry_point == 0) + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_component -" + "ERROR in opening the executor entry point " + "for executor DLL [%s] \n", + primary_artifact)); + error += primary_artifact; + } + else + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container.cpp -" + "FT_Session_Container::ciao_install_component -" + "ERROR in opening the servant entry point " + "for servant DLL [%s] \n", + servant_artifact)); + error += servant_artifact; + } + + throw Components::Deployment::ImplEntryPointNotFound (); + } + + // We have to do this casting in two steps because the C++ + // standard forbids casting a pointer-to-object (including + // void*) directly to a pointer-to-function. + void *void_ptr = executor_dll.symbol (entry_point); + ptrdiff_t tmp_ptr = reinterpret_cast (void_ptr); + ccreator = reinterpret_cast (tmp_ptr); + + void_ptr = servant_dll.symbol (servant_entrypoint); + tmp_ptr = reinterpret_cast (void_ptr); + screator = reinterpret_cast (tmp_ptr); + } + else + { + CIAO_DEBUG ((LM_DEBUG, CLINFO + "FT_Session_Container::install_component - Loading statically linked component [%s]\n", + name)); + + if (static_entrypts_maps_ == 0 + || static_entrypts_maps_->component_creator_funcptr_map_ == 0 + || static_entrypts_maps_->component_servant_creator_funcptr_map_ == 0) + { + CIAO_DEBUG ((LM_ERROR, CLINFO + "FT_Session_Container::install_component - ERROR: Static entrypoint " + "maps are null or imcomplete.\n")); + throw Components::Deployment::ImplEntryPointNotFound (); + } + + ACE_CString entry_point_str (entry_point); + static_entrypts_maps_->component_creator_funcptr_map_->find (entry_point_str, + ccreator); + + ACE_CString servant_entrypoint_str (servant_entrypoint); + static_entrypts_maps_->component_servant_creator_funcptr_map_->find (servant_entrypoint_str, + screator); + } + + if (ccreator == 0 || screator == 0) + { + ACE_CString error ("Entry point "); + + if (ccreator == 0) + { + error += entry_point; + error += " invalid in dll "; + error += primary_artifact; + } + else + { + error += servant_entrypoint; + error += " invalid in dll "; + error += servant_artifact; + } + + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container::ciao_install_component - Error:%s\n", + error.c_str ())); + + throw Components::Deployment::ImplEntryPointNotFound (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_component - Loading component executor\n")); + Components::EnterpriseComponent_var component_executor = ccreator (); + + if (CORBA::is_nil (component_executor.in ())) + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container::Ciao_install_hoe - Component executor factory failed. \n")); + throw Components::Deployment::InstallationFailure (); + } + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_component - Loading component servant\n")); + PortableServer::Servant component_servant = screator (component_executor.in (), + name, + this); + + if (component_servant == 0) + { + CIAO_ERROR ((LM_ERROR, CLINFO + "FT_Session_Container::ciao_install_component - Component servant factory failed.\n")); + throw Components::Deployment::InstallationFailure (); + } + + PortableServer::ServantBase_var safe (component_servant); + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_component - Installing component servant\n")); + + PortableServer::ObjectId_var oid = PortableServer::string_to_ObjectId (name); + + CORBA::Object_var objref = + this->install_servant_with_id (component_servant, Container_Types::COMPONENT_t, oid); + + Components::CCMObject_var componentref = + Components::CCMObject::_narrow (objref.in ()); + + CIAO_DEBUG ((LM_TRACE, CLINFO + "FT_Session_Container::install_component - Component successfully created\n")); + + return componentref._retn (); + } + + void + FT_Session_Container::activate_component (Components::CCMObject_ptr compref) + { + CIAO_TRACE("FT_Session_Container::activate_component"); + + try + { + + PortableServer::Servant svt; + + try + { + svt = this->component_poa_->reference_to_servant (compref); + } + catch (...) + { + throw InvalidComponent (); + } + + CIAO::Servant_Impl_Base *sess = dynamic_cast (svt); + + if (sess == 0) + throw CIAO::InvalidComponent (); + + CIAO_DEBUG ((LM_TRACE, CLINFO "FT_Session_Container::activate_component - " + "Invoking CCM activate on provided component object reference.")); + sess->activate_component (); + } + catch (CIAO::InvalidComponent &ex) + { + CIAO_ERROR ((LM_ERROR, CLINFO "FT_Session_Container::activate_component - " + "Failed to retrieve servant and/or cast to servant pointer.\n")); + throw; + } + catch (CORBA::Exception &ex) + { + CIAO_ERROR ((LM_ERROR, CLINFO "FT_Session_Container::activate_component - " + "Caught CORBA exception while activating a component: %s\n", + ex._info ().c_str ())); + throw; + } + catch (...) + { + CIAO_ERROR ((LM_ERROR, CLINFO "FT_Session_Container::activate_component - " + "Caught unknown C++ eception while activating a component.\n")); + throw; + } + } + + void + FT_Session_Container::passivate_component (Components::CCMObject_ptr compref) + { + CIAO_TRACE ("FT_Session_Container::passivate_component"); + + try + { + PortableServer::Servant svt; + + try + { + svt = this->component_poa_->reference_to_servant (compref); + } + catch (...) + { + throw InvalidComponent (); + } + + CIAO::Servant_Impl_Base *sess = dynamic_cast (svt); + + if (sess == 0) + throw CIAO::InvalidComponent (); + + CIAO_DEBUG ((LM_TRACE, CLINFO "FT_Session_Container::passivate_component - " + "Invoking CCM activate on provided component object reference.")); + sess->passivate_component (); + } + catch (CIAO::InvalidComponent &ex) + { + throw; + } + catch (CORBA::Exception &ex) + { + CIAO_ERROR ((LM_ERROR, CLINFO "FT_Session_Container::passivate_component - " + "Caught CORBA exception while passivating a component: %s\n", + ex._info ().c_str ())); + throw; + } + catch (...) + { + CIAO_ERROR ((LM_ERROR, CLINFO "FT_Session_Container::passivate_component - " + "Caught unknown C++ eception while passivating a component.\n")); + throw; + } + } + + void + FT_Session_Container::uninstall (CORBA::Object_ptr objref, Container_Types::OA_Type y) + { + CIAO_TRACE ("FT_Session_Container::uninstall"); + + PortableServer::Servant svnt; + + switch (y) + { + case Container_Types::COMPONENT_t: + case Container_Types::HOME_t: + svnt = this->component_poa_->reference_to_servant (objref); + break; + default: + svnt = this->facet_cons_poa_->reference_to_servant (objref); + break; + } + + PortableServer::ObjectId_var oid; + this->uninstall_servant (svnt, y, oid.out ()); + } + + void + FT_Session_Container::uninstall_home (Components::CCMHome_ptr homeref) + { + CIAO_TRACE ("FT_Session_Container::uninstall_home"); + + this->uninstall (homeref, Container_Types::HOME_t); + } + + void + FT_Session_Container::uninstall_component (Components::CCMObject_ptr homeref) + { + CIAO_TRACE ("FT_Session_Container::uninstall_component"); + + this->uninstall (homeref, Container_Types::COMPONENT_t); + } + + void + FT_Session_Container::uninstall_servant (PortableServer::Servant svnt, + Container_Types::OA_Type t, + PortableServer::ObjectId_out oid) + { + CIAO_TRACE ("FT_Session_Container::uninstall_servant"); + + PortableServer::POA_ptr tmp = 0; + + if ((t == Container_Types::COMPONENT_t) || + (t == Container_Types::HOME_t)) + { + CIAO_DEBUG ((LM_TRACE, CLINFO "FT_Session_Container::uninstall_servant - " + "Removing component or home servant\n")); + tmp = this->component_poa_.in (); + } + else + { + CIAO_DEBUG ((LM_TRACE, CLINFO "FT_Session_Container::uninstall_servant - " + "Removing facet or consumer servant\n")); + tmp = this->facet_cons_poa_.in (); + } + + try + { + PortableServer::ObjectId_var tmp_id; + tmp_id = tmp->servant_to_id (svnt); + tmp->deactivate_object (tmp_id); + svnt->_remove_ref (); + + CIAO_DEBUG ((LM_TRACE, CLINFO "FT_Session_Container::uninstall_servant - " + "Servant successfully removed, reference count is %u\n", + svnt->_refcount_value ())); + + oid = tmp_id._retn (); + } + catch (CORBA::Exception &ex) + { + CIAO_ERROR ((LM_ERROR, CLINFO "FT_Session_Container::uninstall_servant - " + "Caught CORBA exception while uninstalling servant: %s\n", + ex._info ().c_str ())); + throw Components::RemoveFailure (); + } + + } + + void + FT_Session_Container::add_servant_to_map (PortableServer::ObjectId &, + Dynamic_Component_Servant_Base*) + { + CIAO_TRACE ("FT_Session_Container::add_servant_to_map"); + throw CORBA::NO_IMPLEMENT (); + } + + void + FT_Session_Container::delete_servant_from_map (PortableServer::ObjectId &) + { + CIAO_TRACE ("FT_Session_Container::delete_servant_from_map"); + throw CORBA::NO_IMPLEMENT (); + } + + void + FT_Session_Container::deactivate_facet (const PortableServer::ObjectId &) + { + CIAO_TRACE ("FT_Session_Container::deactivate_facet"); + } + + CORBA::Object_ptr + FT_Session_Container::get_home_objref (PortableServer::Servant) + { + CIAO_TRACE ("FT_Session_Container::get_home_objref"); + throw CORBA::NO_IMPLEMENT (); + } + + CORBA::Object_ptr + FT_Session_Container::generate_reference (const char *obj_id, + const char *repo_id, + Container_Types::OA_Type t) + { + CIAO_TRACE ("FT_Session_Container::generate_reference"); + + PortableServer::POA_ptr tmp = 0; + + if (t == Container_Types::COMPONENT_t || + t == Container_Types::HOME_t) + { + tmp = this->component_poa_.in (); + } + else + { + tmp = this->facet_cons_poa_.in (); + } + + PortableServer::ObjectId_var oid = + PortableServer::string_to_ObjectId (obj_id); + + CORBA::String_var str = PortableServer::ObjectId_to_string (oid.in ()); + + CORBA::Object_var objref = + tmp->create_reference_with_id (oid.in (), repo_id); + + return objref._retn (); + } +} diff --git a/CIAO/ciao/Containers/FTSession/FT_Session_Container.h b/CIAO/ciao/Containers/FTSession/FT_Session_Container.h new file mode 100644 index 00000000000..05fc39256d2 --- /dev/null +++ b/CIAO/ciao/Containers/FTSession/FT_Session_Container.h @@ -0,0 +1,238 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file FT_Session_Container.h + * + * $Id$ + * + * Header file for CIAO's container implementations + * + * @author Nanbor Wang + * @author Gan Deng + */ +//============================================================================= + +#ifndef CIAO_SESSION_CONTAINER_H +#define CIAO_SESSION_CONTAINER_H + +#include /**/ "ace/pre.h" + +#include "ciao/Containers/FTSession/FT_Session_Container_export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PortableServer/Servant_Base.h" +#include "ciao/Containers/Container_Base.h" + +namespace CIAO +{ + class FT_Session_Container; + class Servant_Activator; + class Home_Servant_Impl_Base; + + namespace Deployment + { + class CIAO_Container_i; + } + + typedef ::Components::HomeExecutorBase_ptr (*HomeFactory) (void); + typedef ::PortableServer::Servant (*HomeServantFactory) (::Components::HomeExecutorBase_ptr p, + ::CIAO::Container_ptr c, + const char *ins_name); + typedef ::Components::EnterpriseComponent_ptr (*ComponentFactory) (void); + typedef ::PortableServer::Servant (*ComponentServantFactory) (::Components::EnterpriseComponent_ptr, + const char *, + ::CIAO::Container_ptr ); + + typedef ACE_Hash_Map_Manager_Ex, + ACE_Equal_To, + ACE_Null_Mutex> + HOMECREATOR_FUNCPTR_MAP; + + typedef ACE_Hash_Map_Manager_Ex, + ACE_Equal_To, + ACE_Null_Mutex> + HOMESERVANTCREATOR_FUNCPTR_MAP; + + + typedef ACE_Hash_Map_Manager_Ex, + ACE_Equal_To, + ACE_Null_Mutex> + COMPONENTCREATOR_FUNCPTR_MAP; + + typedef ACE_Hash_Map_Manager_Ex, + ACE_Equal_To, + ACE_Null_Mutex> + COMPONENTSERVANTCREATOR_FUNCPTR_MAP; + + + struct FT_Session_Container_Export Static_Config_EntryPoints_Maps + { + /// Map of home creator entry point name and func ptr + HOMECREATOR_FUNCPTR_MAP* home_creator_funcptr_map_; + + /// Map of home servant creator entry point name and func ptr + HOMESERVANTCREATOR_FUNCPTR_MAP* home_servant_creator_funcptr_map_; + + /// Map of home creator entry point name and func ptr + COMPONENTCREATOR_FUNCPTR_MAP* component_creator_funcptr_map_; + + /// Map of home servant creator entry point name and func ptr + COMPONENTSERVANTCREATOR_FUNCPTR_MAP* component_servant_creator_funcptr_map_; + }; + + class FT_Session_Container_Export FT_Session_Container : public Container_i + { + public: + FT_Session_Container (CORBA::ORB_ptr o, + Deployment::CIAO_Container_i *container_impl, + bool static_config_flag = false, + const Static_Config_EntryPoints_Maps* static_entrypts_maps =0, + const char *name = 0, + const CORBA::PolicyList *more_policies = 0); + + virtual ~FT_Session_Container (void); + + + /** + * @brief Simply installing a home executor into the component. + * + * This operation install a home executor into the component. It + * requires the name of the DLLs to executor and the servant glue + * code, and the entry points to the respective DLLs. Currently, + * we don't try to manage the lifetime of DLL objects, but we + * should at some later point. + * + * @retval Home objref of the installed home. + */ + /// Install a new home + virtual Components::CCMHome_ptr install_home (const char *primary_artifact, + const char *entry_point, + const char *servant_artifact, + const char *servant_entrypoint, + const char *name); + + virtual void uninstall_home (Components::CCMHome_ptr homeref); + + virtual Components::CCMObject_ptr install_component (const char *primary_artifact, + const char *entry_point, + const char *servant_artifact, + const char *servant_entrypoint, + const char *name); + + virtual void activate_component (Components::CCMObject_ptr compref); + + virtual void passivate_component (Components::CCMObject_ptr compref); + + virtual void uninstall_component (Components::CCMObject_ptr compref); + + + /// Uninstall a servant + virtual void uninstall_servant (PortableServer::Servant objref, + Container_Types::OA_Type type, + PortableServer::ObjectId_out oid); + + /// Install a servant for component or home. + virtual CORBA::Object_ptr install_servant (PortableServer::Servant p, + Container_Types::OA_Type type, + PortableServer::ObjectId_out oid); + + /// Install a servant for component or home. + virtual CORBA::Object_ptr install_servant_with_id (PortableServer::Servant p, + Container_Types::OA_Type type, + const PortableServer::ObjectId & oid); + + /// Get an object reference to a component or home from the servant. + virtual CORBA::Object_ptr get_objref (PortableServer::Servant p); + + /// Uninstall a servant for component or home. + void uninstall (CORBA::Object_ptr objref, Container_Types::OA_Type t); + + /// Uninstall a servant for component or home. + void uninstall (PortableServer::Servant svt, Container_Types::OA_Type t); + + virtual void add_servant_to_map (PortableServer::ObjectId &oid, + Dynamic_Component_Servant_Base* servant); + + virtual void delete_servant_from_map (PortableServer::ObjectId &oid); + + // @@Jai, could yo please add documentation? + /* + * @@Jai, you may want to consider moving these away from the + * container interface. I know what you are going to say + * :-). Consider using dynamic_cast <> to access + * add_servant_to_map, delete_servant_from_map and + * deactivate_facet from the Swapping_Conatiner's interface. It + * would make the base container interface much cleaner. + */ + virtual void deactivate_facet (const PortableServer::ObjectId &oid); + + virtual CORBA::Object_ptr get_home_objref (PortableServer::Servant p); + + /// Analog of the POA method that creates an object reference from + /// an object id string. + CORBA::Object_ptr generate_reference (const char *obj_id, + const char *repo_id, + Container_Types::OA_Type t); + + /// Return the servant activator factory that activates the + /// servants for facets and consumers. + ::CIAO::Servant_Activator_ptr ports_servant_activator (void); + + private: + + /// Initialize the container with a name. + virtual void init (const char *name = 0, + const CORBA::PolicyList *more_policies = 0); + + /// Create POA for the component. + /** + * This is the POA that is returned to the component applications + * if they need one. + */ + void create_component_POA (const char *name, + const CORBA::PolicyList *p, + PortableServer::POA_ptr root); + + /// Create POA for the facets and consumers alone. + void create_facet_consumer_POA (const char *name, + const CORBA::PolicyList *p, + PortableServer::POA_ptr root); + + /// Not allowed to be + FT_Session_Container (void); + + protected: + unsigned long number_; + + /// Static variable to store the highest number we have given out until + /// now + static ACE_Atomic_Op serial_number_; + + const bool static_config_flag_; + const Static_Config_EntryPoints_Maps* static_entrypts_maps_; + + /// The servant activator factory used to activate facets and + /// consumer servants. + Servant_Activator_var sa_; + }; +} + +#if defined (__ACE_INLINE__) +# include "FT_Session_Container.inl" +#endif /* __ACE_INLINE__ */ + +#include /**/ "ace/post.h" + +#endif /* CIAO_SESSION_CONTAINER_H */ diff --git a/CIAO/ciao/Containers/FTSession/FT_Session_Container.idl b/CIAO/ciao/Containers/FTSession/FT_Session_Container.idl new file mode 100644 index 00000000000..f8112201371 --- /dev/null +++ b/CIAO/ciao/Containers/FTSession/FT_Session_Container.idl @@ -0,0 +1,19 @@ +/** + * @file Session_Container.idl + * @author William R. Otte + * + * Extends the basic container interface for session capabilities. + */ + +#include "ciao/Containers/Container_Base.idl" + +module CIAO +{ + local interface FT_Session_Container : Container + { + // *** Methods used by component specific container portions + Object install_servant (in PortableServer::Servant svnt, + in Container_Types::OA_Type type, + in PortableServer::ObjectId oid); + }; +}; diff --git a/CIAO/ciao/Containers/FTSession/FT_Session_Container.inl b/CIAO/ciao/Containers/FTSession/FT_Session_Container.inl new file mode 100644 index 00000000000..83d8dafe530 --- /dev/null +++ b/CIAO/ciao/Containers/FTSession/FT_Session_Container.inl @@ -0,0 +1,13 @@ +// $Id$ -*- C++ -*- + +ACE_INLINE CORBA::Object_ptr +CIAO::FT_Session_Container::get_objref (PortableServer::Servant p) +{ + return this->the_POA ()->servant_to_reference (p); +} + +ACE_INLINE CIAO::Servant_Activator_ptr +CIAO::FT_Session_Container::ports_servant_activator (void) +{ + return Servant_Activator::_duplicate(this->sa_.in ()); +} diff --git a/CIAO/ciao/Containers/FTSession/FT_Session_Container.mpc b/CIAO/ciao/Containers/FTSession/FT_Session_Container.mpc new file mode 100644 index 00000000000..d305209c7ae --- /dev/null +++ b/CIAO/ciao/Containers/FTSession/FT_Session_Container.mpc @@ -0,0 +1,22 @@ +// -*- MPC -*- +// $Id$ + +project(CIAO_FT_Session_Container) : ccm_svnt, ciao_lib, ciao_container_base, utils, \ + ccm_componentserver_stub, ciao_servant_activator, ciao_servant { + dynamicflags += FT_SESSION_CONTAINER_BUILD_DLL + idlflags += -Wb,export_include=FT_Session_Container_export.h + idlflags += -Wb,export_macro=FT_Session_Container_Export + libs += LWFT_StateSyncAgent + + IDL_Files { + } + Source_Files { + FT_Session_Container.cpp + } + Inline_Files { + FT_Session_Container.inl + } + Header_Files { + FT_Session_Container.h + } +} diff --git a/CIAO/ciao/Containers/FTSession/FT_Session_Container_export.h b/CIAO/ciao/Containers/FTSession/FT_Session_Container_export.h new file mode 100644 index 00000000000..16f1c128d99 --- /dev/null +++ b/CIAO/ciao/Containers/FTSession/FT_Session_Container_export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl FT_Session_Container +// ------------------------------ +#ifndef FT_SESSION_CONTAINER_EXPORT_H +#define FT_SESSION_CONTAINER_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (FT_SESSION_CONTAINER_HAS_DLL) +# define FT_SESSION_CONTAINER_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && FT_SESSION_CONTAINER_HAS_DLL */ + +#if !defined (FT_SESSION_CONTAINER_HAS_DLL) +# define FT_SESSION_CONTAINER_HAS_DLL 1 +#endif /* ! FT_SESSION_CONTAINER_HAS_DLL */ + +#if defined (FT_SESSION_CONTAINER_HAS_DLL) && (FT_SESSION_CONTAINER_HAS_DLL == 1) +# if defined (FT_SESSION_CONTAINER_BUILD_DLL) +# define FT_Session_Container_Export ACE_Proper_Export_Flag +# define FT_SESSION_CONTAINER_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define FT_SESSION_CONTAINER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* FT_SESSION_CONTAINER_BUILD_DLL */ +# define FT_Session_Container_Export ACE_Proper_Import_Flag +# define FT_SESSION_CONTAINER_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define FT_SESSION_CONTAINER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* FT_SESSION_CONTAINER_BUILD_DLL */ +#else /* FT_SESSION_CONTAINER_HAS_DLL == 1 */ +# define FT_Session_Container_Export +# define FT_SESSION_CONTAINER_SINGLETON_DECLARATION(T) +# define FT_SESSION_CONTAINER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* FT_SESSION_CONTAINER_HAS_DLL == 1 */ + +// Set FT_SESSION_CONTAINER_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (FT_SESSION_CONTAINER_NTRACE) +# if (ACE_NTRACE == 1) +# define FT_SESSION_CONTAINER_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define FT_SESSION_CONTAINER_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !FT_SESSION_CONTAINER_NTRACE */ + +#if (FT_SESSION_CONTAINER_NTRACE == 1) +# define FT_SESSION_CONTAINER_TRACE(X) +#else /* (FT_SESSION_CONTAINER_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define FT_SESSION_CONTAINER_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (FT_SESSION_CONTAINER_NTRACE == 1) */ + +#endif /* FT_SESSION_CONTAINER_EXPORT_H */ + +// End of auto generated file. diff --git a/CIAO/ciao/FTComponentServer/CIAO_ComponentServer.mpc b/CIAO/ciao/FTComponentServer/CIAO_ComponentServer.mpc index bc3fc300825..a94c69e67d1 100644 --- a/CIAO/ciao/FTComponentServer/CIAO_ComponentServer.mpc +++ b/CIAO/ciao/FTComponentServer/CIAO_ComponentServer.mpc @@ -60,7 +60,7 @@ project(CIAO_FTCS_Client_svnt) : ccm_svnt, ccm_componentserver_svnt, ciao_ft_com } } -project(CIAO_FTComponentServer_svnt) : ccm_componentserver_svnt, ciao_ft_componentserver_stub, portableserver, ciao_ft_componentserver_configurator, ciao_session_container, naming, ciao_server { +project(CIAO_FTComponentServer_svnt) : ccm_componentserver_svnt, ciao_ft_componentserver_stub, portableserver, ciao_ft_componentserver_configurator, ciao_ft_session_container, naming, ciao_server { dynamicflags = CIAO_FTCOMPONENTSERVER_SVNT_BUILD_DLL @@ -75,7 +75,7 @@ project(CIAO_FTComponentServer_svnt) : ccm_componentserver_svnt, ciao_ft_compone } } -project(CIAO_FTComponentServer_exe) : ccm_componentserver_svnt, portableserver, ciao_ft_componentserver_svnt, messaging, anytypecode, ciao_server, ciaoexe, ciao_session_container, ciao_ft_componentserver_configurator, rtcorba { +project(CIAO_FTComponentServer_exe) : ccm_componentserver_svnt, portableserver, ciao_ft_componentserver_svnt, messaging, anytypecode, ciao_server, ciaoexe, ciao_ft_session_container, ciao_ft_componentserver_configurator, pi_server, iorinterceptor {// , rtcorba exename = ciao_ft_componentserver libs += CIAO_Logger LWFT_StateSyncAgent LWFT_ReplicationManager LWFT_Client LWFT_Server macros += CIAO_BUILD_COMPONENTSERVER_EXE diff --git a/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.cpp b/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.cpp index 4d2b4e760eb..270e2faca0c 100644 --- a/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.cpp +++ b/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.cpp @@ -39,13 +39,13 @@ namespace CIAO if (this->static_entrypts_maps_ == 0) { CIAO_DEBUG((LM_DEBUG, CLINFO "CIAO_Container_i: creating Session container with dynamic linkage\n")); - this->container_ = new CIAO::Session_Container (this->orb_.in (), this, false, + this->container_ = new CIAO::FT_Session_Container (this->orb_.in (), this, false, 0, name, policies); } else { CIAO_DEBUG((LM_DEBUG, CLINFO "CIAO_Container_i: creating Session container with static linkage\n")); - this->container_ = new CIAO::Session_Container (this->orb_.in (), this, true, + this->container_ = new CIAO::FT_Session_Container (this->orb_.in (), this, true, this->static_entrypts_maps_, name, policies); } diff --git a/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.h b/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.h index 5811c5992f9..c12026b2a6f 100644 --- a/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.h +++ b/CIAO/ciao/FTComponentServer/CIAO_Container_Impl.h @@ -12,7 +12,7 @@ #pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -#include "ciao/Containers/Session/Session_Container.h" +#include "ciao/Containers/FTSession/FT_Session_Container.h" #include "CIAO_FTComponentServer_svnt_export.h" diff --git a/CIAO/ciao/FTComponentServer/CIAO_Properties.idl b/CIAO/ciao/FTComponentServer/CIAO_Properties.idl index d77b5c8b09b..17e79c7471d 100644 --- a/CIAO/ciao/FTComponentServer/CIAO_Properties.idl +++ b/CIAO/ciao/FTComponentServer/CIAO_Properties.idl @@ -22,6 +22,7 @@ module CIAO const string SERVER_TIMEOUT = "edu.vanderbilt.dre.CIAO.ServerTimeout"; const string SERVER_MULTITHREAD = "edu.vanderbilt.dre.CIAO.Multithreaded"; const string REGISTER_NAMING = "edu.vanderbilt.dre.CIAO.RegisterNaming"; + const string OBJECT_ID = "edu.vanderbilt.dre.CIAO.ObjectId"; }; }; -- cgit v1.2.1