Added FT_Session_ContainerCIAO_FLARE

12 files changed, 1318 insertions, 6 deletions

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 <TAO_SYNCH_MUTEX, unsigned long>
+  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<ptrdiff_t> (void_ptr);
+        hcreator = reinterpret_cast<HomeFactory> (tmp_ptr);
+
+        void_ptr = servant_dll.symbol (servant_entrypoint);
+        tmp_ptr = reinterpret_cast<ptrdiff_t> (void_ptr);
+        screator = reinterpret_cast<HomeServantFactory> (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<ptrdiff_t> (void_ptr);
+        ccreator = reinterpret_cast<ComponentFactory> (tmp_ptr);
+
+        void_ptr = servant_dll.symbol (servant_entrypoint);
+        tmp_ptr = reinterpret_cast<ptrdiff_t> (void_ptr);
+        screator = reinterpret_cast<ComponentServantFactory> (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<CIAO::Servant_Impl_Base *> (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<CIAO::Servant_Impl_Base *> (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 <nanbor@cs.wustl.edu>
+ *  @author Gan Deng <dengg@dre.vanderbilt.edu>
+ */
+//=============================================================================
+
+#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_CString,
+                                  HomeFactory,
+                                  ACE_Hash<ACE_CString>,
+                                  ACE_Equal_To<ACE_CString>,
+                                  ACE_Null_Mutex>
+    HOMECREATOR_FUNCPTR_MAP;
+
+  typedef ACE_Hash_Map_Manager_Ex<ACE_CString,
+                                  HomeServantFactory,
+                                  ACE_Hash<ACE_CString>,
+                                  ACE_Equal_To<ACE_CString>,
+                                  ACE_Null_Mutex>
+  HOMESERVANTCREATOR_FUNCPTR_MAP;
+
+
+  typedef ACE_Hash_Map_Manager_Ex<ACE_CString,
+                                  ComponentFactory,
+                                  ACE_Hash<ACE_CString>,
+                                  ACE_Equal_To<ACE_CString>,
+                                  ACE_Null_Mutex>
+    COMPONENTCREATOR_FUNCPTR_MAP;
+
+  typedef ACE_Hash_Map_Manager_Ex<ACE_CString,
+                                  ComponentServantFactory,
+                                  ACE_Hash<ACE_CString>,
+                                  ACE_Equal_To<ACE_CString>,
+                                  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 <TAO_SYNCH_MUTEX, unsigned long> 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 <wotte@dre.vanderbilt.edu>
+ *
+ * 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";
     
   };
 };