Fri Mar 29 00:14:00 UTC 2013 Phil Mesnier <mesnier_p@ociweb.com>

13 files changed, 535 insertions, 882 deletions

diff --git a/TAO/ChangeLog_Asynch_ImR b/TAO/ChangeLog_Asynch_ImR
index f2fd175d59a..6648a472ee6 100644
--- a/TAO/ChangeLog_Asynch_ImR
+++ b/TAO/ChangeLog_Asynch_ImR
@@ -1,3 +1,25 @@
+Fri Mar 29 00:14:00 UTC 2013  Phil Mesnier  <mesnier_p@ociweb.com>
+
+        * orbsvcs/ImplRepo_Service/AsyncAccessManager.h:
+        * orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp:
+        * orbsvcs/ImplRepo_Service/Forwarder.h:
+        * orbsvcs/ImplRepo_Service/Forwarder.cpp:
+        * orbsvcs/ImplRepo_Service/ImR_Locator_i.h:
+        * orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp:
+        * orbsvcs/ImplRepo_Service/ImR_ResponseHandler.h:
+        * orbsvcs/ImplRepo_Service/ImR_ResponseHandler.cpp:
+        * orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc:
+
+          Completed the initial task of transitioning to an AMH Locator servant.
+          Still need to work on the INS_Locator which uses synch calls. Also need to
+          run through regression suite and debug.
+
+        * orbsvcs/ImplRepo_Service/AsyncStartupWaiter.idl:
+        * orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.h:
+        * orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.cpp:
+
+          Removed these files.
+
 Thu Mar 28 17:05:52 UTC 2013  Phil Mesnier  <mesnier_p@ociweb.com>
 
         * orbsvcs/ImplRepo_Service/AsyncAccessManager.h:
diff --git a/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp b/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp
index 1368c1bbdac..c2042ae97e5 100644
--- a/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.cpp
@@ -39,7 +39,7 @@ AsyncAccessManager::has_server (const char *s)
 }
 
 void
-AsyncAccessManager::add_interest (ImR_ReplyHandler *rh)
+AsyncAccessManager::add_interest (ImR_ResponseHandler *rh)
 {
   {
     ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
@@ -97,7 +97,7 @@ AsyncAccessManager::final_state (void)
 
   for (size_t i = 0; i < this->rh_list_.size(); i++)
     {
-      ImR_ReplyHandler *rh = this->rh_list_[i];
+      ImR_ResponseHandler *rh = this->rh_list_[i];
       if (rh != 0)
         {
           if (this->status_ == AAM_SERVER_READY)
@@ -106,7 +106,28 @@ AsyncAccessManager::final_state (void)
             }
           else
             {
-              rh->send_exception ();
+              try
+                {
+                  switch (this->status_)
+                    {
+                    case AAM_NO_ACTIVATOR:
+                      throw ImplementationRepository::CannotActivate
+                        ("No activator registered for server.");
+                    case AAM_NOT_MANUAL:
+                      throw ImplementationRepository::CannotActivate
+                        ("Cannot implicitly activate MANUAL server.");
+                    case AAM_NO_COMMANDLINE:
+                      throw ImplementationRepository::CannotActivate
+                        ("No command line registered for server.");
+                    default:
+                      throw ImplementationRepository::CannotActivate
+                        ("Unknown Failure");
+                    }
+                }
+              catch (CORBA::Exception &ex)
+                {
+                  rh->send_exception (&ex);
+                }
             }
         }
     }
@@ -215,6 +236,12 @@ AsyncAccessManager::send_start_request (void)
       return false;
     }
 
+  if (this->info_->cmdline.length () == 0)
+    {
+      this->status (AAM_NO_COMMANDLINE);
+      return false;
+    }
+
   Activator_Info_Ptr ainfo =
     this->locator_.get_activator (this->info_->activator);
 
diff --git a/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.h b/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.h
index e450440cb2d..4653d2159f1 100644
--- a/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.h
+++ b/TAO/orbsvcs/ImplRepo_Service/AsyncAccessManager.h
@@ -58,7 +58,8 @@ enum AAM_Status
     AAM_SERVER_READY,
     AAM_SERVER_DEAD,
     AAM_NOT_MANUAL,
-    AAM_NO_ACTIVATOR
+    AAM_NO_ACTIVATOR,
+    AAM_NO_COMMANDLINE
   };
 
 class AsyncAccessManager
@@ -72,7 +73,7 @@ class AsyncAccessManager
 
   bool has_server (const char *name);
 
-  void add_interest (ImR_ReplyHandler *rh);
+  void add_interest (ImR_ResponseHandler *rh);
   AAM_Status status (void) const;
 
   void activator_replied (bool success);
@@ -91,7 +92,7 @@ class AsyncAccessManager
   bool manual_start_;
   ImR_Locator_i &locator_;
   PortableServer::POA_var poa_;
-  ACE_Vector<ImR_ReplyHandler *> rh_list_;
+  ACE_Vector<ImR_ResponseHandler *> rh_list_;
 
   AAM_Status status_;
 
diff --git a/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter.idl b/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter.idl
deleted file mode 100644
index 92a908888d9..00000000000
--- a/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter.idl
+++ /dev/null
@@ -1,18 +0,0 @@
-// -*- IDL -*-
-
-// $Id$
-
-module ImplementationRepository
-{
-  struct StartupInfo {
-    string name;
-    string partial_ior;
-    string ior;
-  };
-
-  interface AsyncStartupWaiter
-  {
-    StartupInfo wait_for_startup(in string name);
-  };
-};
-
diff --git a/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.cpp b/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.cpp
deleted file mode 100644
index 19bc12e4162..00000000000
--- a/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-// -*- C++ -*-
-//
-// $Id$
-
-#include "AsyncStartupWaiter_i.h"
-#include "ImR_Locator_i.h"
-
-using namespace ImplementationRepository;
-
-AsyncStartupWaiter_i::PendingData::PendingData (const char* p, const char* i)
-: partial_ior (p)
-, ior( i)
-{
-}
-
-AsyncStartupWaiter_i::PendingData::PendingData ()
-{
-}
-
-
-void AsyncStartupWaiter_i::debug (bool dbg)
-{
-  debug_ = dbg;
-}
-
-void AsyncStartupWaiter_i::wait_for_startup (AMH_AsyncStartupWaiterResponseHandler_ptr rh,
-   const char* name)
-{
-  PendingListPtr plst;
-  pending_.find(name, plst);
-  if (! plst.null () && plst->size () > 0)
-    {
-      PendingList& tmp = *plst;
-      PendingData& pd = tmp[tmp.size () - 1];
-      tmp.pop_back ();
-
-      if (debug_)
-        ACE_DEBUG ((LM_DEBUG, "ImR: Skipping wait due to queued startup info for <%s>.\n", name));
-
-      send_response (*rh, name, pd.partial_ior.c_str(), pd.ior.c_str());
-
-    }
-  else
-    {
-      RHListPtr lst;
-      waiting_.find (name, lst);
-      if (lst.null ())
-      {
-        lst = RHListPtr (new RHList);
-        int err = waiting_.bind (name, lst);
-        ACE_ASSERT (err == 0);
-        ACE_UNUSED_ARG (err);
-      }
-      lst->push_back (AMH_AsyncStartupWaiterResponseHandler::_duplicate (rh));
-    }
-}
-
-void
-AsyncStartupWaiter_i::send_response (ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler& rh,
-                                    const char* name, const char* partial_ior, const char* ior)
-{
-  StartupInfo_var si = new StartupInfo();
-  si->name = name;
-  si->partial_ior = partial_ior;
-  si->ior = ior;
-
-  try
-    {
-      rh.wait_for_startup (si.in ());
-    }
-  catch (const CORBA::Exception& ex)
-    {
-      if (debug_)
-        ex._tao_print_exception (
-          "AsyncStartupWaiter_i::send_response ()");
-    }
-}
-
-void
-AsyncStartupWaiter_i::unblock_one (const char* name, const char* partial_ior, const char* ior, bool queue)
-{
-  ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_var rh = get_one_waiter(name);
-  if (! CORBA::is_nil(rh.in ()))
-    {
-      send_response (*rh.in (), name, partial_ior, ior);
-    }
-  else if (queue)
-    {
-      if (debug_)
-        ACE_DEBUG((LM_DEBUG, "ImR: Queuing startup info.\n"));
-
-      PendingListPtr lst;
-      pending_.find (name, lst);
-      if (lst.null ())
-        {
-          lst = PendingListPtr (new PendingList);
-          int err = pending_.bind (name, lst);
-          ACE_ASSERT (err == 0);
-          ACE_UNUSED_ARG (err);
-        }
-      lst->push_back (PendingData (partial_ior, ior));
-    }
-}
-
-void
-AsyncStartupWaiter_i::unblock_all (const char* name)
-{
-  RHList tmp;
-
-  get_all_waiters (name, tmp);
-
-  // This startup info should be ignored when unblocking all, because we
-  // don't know the ior or partial_ior at this point.
-  StartupInfo_var si = new StartupInfo ();
-  si->name = name;
-
-  // Note : This method may be called when there are no waiters.
-
-  for (size_t i = 0; i < tmp.size(); ++i)
-  {
-    try
-      {
-        ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_var& rh = tmp[i];
-
-        rh->wait_for_startup (si.in ());
-      }
-    catch (const CORBA::Exception& ex)
-      {
-        if (debug_)
-          ex._tao_print_exception (
-            "AsyncStartupWaiter_i::unblock_all ()");
-      }
-  }
-}
-
-ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_ptr
-AsyncStartupWaiter_i::get_one_waiter (const char* name)
-{
-  RHListPtr lst;
-  waiting_.find (name, lst);
-  if (! lst.null() && lst->size () > 0)
-    {
-      RHList& rhlst = *lst;
-      ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_var& tmp = rhlst[rhlst.size () - 1];
-      ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_ptr ret = tmp._retn ();
-      rhlst.pop_back ();
-      return ret;
-    }
-  return ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler::_nil ();
-}
-
-void
-AsyncStartupWaiter_i::get_all_waiters (const char* name, RHList& ret)
-{
-  RHListPtr lst;
-  waiting_.find (name, lst);
-  if (! lst.null ()) {
-    for (size_t i = 0; i < lst->size (); ++i)
-      {
-        RHList& tmp = *lst;
-        ret.push_back (tmp[i]);
-        // The ACE_Vector will not destruct the elements when cleared, so we must
-        // make sure to do so here.
-        tmp[i] = ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler::_nil ();
-      }
-    lst->clear ();
-  }
-}
-
diff --git a/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.h b/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.h
deleted file mode 100644
index 59ee659344d..00000000000
--- a/TAO/orbsvcs/ImplRepo_Service/AsyncStartupWaiter_i.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// -*- C++ -*-
-//
-// $Id$
-
-#ifndef IMR_AsyncStartupWaiterI_H_
-#define IMR_AsyncStartupWaiterI_H_
-
-#include "locator_export.h"
-#include "AsyncStartupWaiterS.h"
-
-#include "ace/Vector_T.h"
-#include "ace/Hash_Map_Manager.h"
-#include "ace/Bound_Ptr.h"
-#include "ace/SString.h"
-
-#if !defined (ACE_LACKS_PRAGMA_ONCE)
-#pragma once
-#endif /* ACE_LACKS_PRAGMA_ONCE */
-
-
-class ImR_Locator_i;
-
-class Locator_Export AsyncStartupWaiter_i : public virtual POA_ImplementationRepository::AMH_AsyncStartupWaiter
-{
-  struct PendingData {
-    PendingData();
-    PendingData(const char* partial_ior, const char* ior);
-    ACE_CString partial_ior;
-    ACE_CString ior;
-  };
-  typedef ACE_Vector<PendingData> PendingList;
-  typedef ACE_Strong_Bound_Ptr<PendingList, ACE_Null_Mutex> PendingListPtr;
-  typedef ACE_Hash_Map_Manager_Ex<ACE_CString,
-    PendingListPtr,
-    ACE_Hash<ACE_CString>,
-    ACE_Equal_To<ACE_CString>,
-    ACE_Null_Mutex> PendingMap;
-
-  typedef ACE_Vector<ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_var> RHList;
-  typedef ACE_Strong_Bound_Ptr<RHList, ACE_Null_Mutex> RHListPtr;
-  typedef ACE_Hash_Map_Manager_Ex<ACE_CString,
-    RHListPtr,
-    ACE_Hash<ACE_CString>,
-    ACE_Equal_To<ACE_CString>,
-    ACE_Null_Mutex> WaitingMap;
-
-public:
-
-  void wait_for_startup (
-   ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_ptr rh,
-   const char* name);
-
-  void unblock_one(const char* name, const char* partial_ior, const char* ior, bool queue);
-  void unblock_all(const char* name);
-
-  void debug(bool dbg);
-
-private:
-
-ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler_ptr
-  get_one_waiter(const char* name);
-
-void get_all_waiters(const char* name, RHList& ret);
-
-void send_response(ImplementationRepository::AMH_AsyncStartupWaiterResponseHandler& rh,
-                   const char* name, const char* partial_ior, const char* ior);
-private:
-  WaitingMap waiting_;
-  PendingMap pending_;
-  bool debug_;
-};
-
-#endif /* AsyncStartupWaiterI_H_  */
-
diff --git a/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp b/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
index 6eed13839b0..da0db01ddba 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/Forwarder.cpp
@@ -147,8 +147,8 @@ ImR_DSI_Forwarder::invoke (CORBA::ServerRequest_ptr request,
   TAO::Portable_Server::POA_Current_Impl* impl = tao_current->implementation ();
   TAO::ObjectKey::encode_sequence_to_string (key_str.out (), impl->object_key ());
 
-  ImR_DSI_ReplyHandler * rh = 0;
-  ACE_NEW (rh, ImR_DSI_ReplyHandler(key_str.in(),
+  ImR_DSI_ResponseHandler * rh = 0;
+  ACE_NEW (rh, ImR_DSI_ResponseHandler(key_str.in(),
                                     this->locator_.debug() > 0 ?
                                     server_name.in() : "",
                                     this->orb_, resp));
@@ -170,17 +170,7 @@ ImR_DSI_Forwarder::invoke_primary_interface(CORBA::ServerRequest_ptr )
 
 //--------------------------------------------------------------------
 
-ImR_ReplyHandler::ImR_ReplyHandler ()
-{
-}
-
-ImR_ReplyHandler::~ImR_ReplyHandler (void)
-{
-}
-
-//--------------------------------------------------------------------
-
-ImR_DSI_ReplyHandler::ImR_DSI_ReplyHandler (const char *key,
+ImR_DSI_ResponseHandler::ImR_DSI_ResponseHandler (const char *key,
                                             const char *server_name,
                                             CORBA::ORB_ptr orb,
                                             TAO_AMH_DSI_Response_Handler_ptr resp)
@@ -191,12 +181,12 @@ ImR_DSI_ReplyHandler::ImR_DSI_ReplyHandler (const char *key,
 {
 }
 
-ImR_DSI_ReplyHandler::~ImR_DSI_ReplyHandler (void)
+ImR_DSI_ResponseHandler::~ImR_DSI_ResponseHandler (void)
 {
 }
 
 void
-ImR_DSI_ReplyHandler::send_ior (const char *pior)
+ImR_DSI_ResponseHandler::send_ior (const char *pior)
 {
   ACE_CString ior = pior;
 
@@ -205,7 +195,7 @@ ImR_DSI_ReplyHandler::send_ior (const char *pior)
   if (ior.find ("corbaloc:") != 0 || ior[ior.length () - 1] != '/')
     {
       ACE_ERROR ((LM_ERROR,
-                  ACE_TEXT ("ImR_ReplyHandler::send_ior (): Invalid corbaloc ior.\n")
+                  ACE_TEXT ("ImR_ResponseHandler::send_ior (): Invalid corbaloc ior.\n")
                   ACE_TEXT ("\t<%s>\n"),
                   ior.c_str()));
 
@@ -222,8 +212,8 @@ ImR_DSI_ReplyHandler::send_ior (const char *pior)
 
   if (this->server_name_[0] != 0)
     ACE_DEBUG ((LM_DEBUG,
-                ACE_TEXT ("ImR_ReplyHandler::send_ior(): Forwarding invocation on <%s> ")
-                ACE_TEXT ("to <%s>\n"),
+                ACE_TEXT ("ImR_DSI_ResponseHandler::send_ior(): Forwarding invocation ")
+                ACE_TEXT ("on <%s> to <%s>\n"),
                 this->server_name_.in(), ior.c_str()));
 
   CORBA::Object_var forward_obj =
@@ -239,7 +229,7 @@ ImR_DSI_ReplyHandler::send_ior (const char *pior)
   else
     {
       ACE_ERROR ((LM_ERROR,
-                  ACE_TEXT ("ImR_ReplyHandler::send_ior (): Forward_to ")
+                  ACE_TEXT ("ImR_DSI_ResponseHandler::send_ior (): Forward_to ")
                   ACE_TEXT ("reference is nil.\n")));
 
       CORBA::OBJECT_NOT_EXIST ex (CORBA::SystemException::_tao_minor_code
@@ -252,7 +242,7 @@ ImR_DSI_ReplyHandler::send_ior (const char *pior)
 }
 
 void
-ImR_DSI_ReplyHandler::send_exception (void)
+ImR_DSI_ResponseHandler::send_exception (CORBA::Exception *)
 {
   CORBA::TRANSIENT ex (CORBA::SystemException::_tao_minor_code
                        ( TAO_IMPLREPO_MINOR_CODE, 0),
diff --git a/TAO/orbsvcs/ImplRepo_Service/Forwarder.h b/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
index e83271b31c4..6a1bf51f838 100644
--- a/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
+++ b/TAO/orbsvcs/ImplRepo_Service/Forwarder.h
@@ -26,31 +26,12 @@
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
 #include "tao/LocalObject.h"
-
+#include "ImR_ResponseHandler.h"
 
 class ImR_Locator_i;
 
 //----------------------------------------------------------------------------
 /**
- * @class ImR_ReplyHandler
- *
- * @brief interface serving as the basis for different strategies of activating
- * servers on demand
- *
- */
-
-class ImR_ReplyHandler
-{
-public:
-  ImR_ReplyHandler (void);
-  virtual ~ImR_ReplyHandler (void);
-
-  virtual void send_ior (const char *pior) = 0;
-  virtual void send_exception (void) = 0;
-};
-
-//----------------------------------------------------------------------------
-/**
  * @class ImR_DSI_ReplyHandler
  *
  * @brief specialized reply handler for forward requests that need to send an
@@ -65,18 +46,18 @@ class TAO_AMH_DSI_Response_Handler;
 typedef TAO_AMH_DSI_Response_Handler * TAO_AMH_DSI_Response_Handler_ptr;
 class TAO_AMH_DSI_Response_Handler_var;
 
-class ImR_DSI_ReplyHandler : public ImR_ReplyHandler
+class ImR_DSI_ResponseHandler : public ImR_ResponseHandler
 {
 public:
-  ImR_DSI_ReplyHandler (const char *key,
+  ImR_DSI_ResponseHandler (const char *key,
                         const char *server_name,
                         CORBA::ORB_ptr orb,
                         TAO_AMH_DSI_Response_Handler_ptr resp);
 
-  ~ImR_DSI_ReplyHandler (void);
+  ~ImR_DSI_ResponseHandler (void);
 
   void send_ior (const char *pior);
-  void send_exception (void);
+  void send_exception (CORBA::Exception *ex);
 
 private:
   CORBA::String_var key_str_;
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp
index f1ad8da100f..5e863f16afc 100644
--- a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp
+++ b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp
@@ -106,18 +106,8 @@ ImR_Locator_i::init_with_orb (CORBA::ORB_ptr orb, Options& opts)
                                         "ImplRepo_Service");
   ACE_ASSERT (! CORBA::is_nil (this->imr_poa_.in ()));
 
-  waiter_svt_.debug (debug_ > 1);
   PortableServer::ObjectId_var id =
-    PortableServer::string_to_ObjectId ("ImR_AsyncStartupWaiter");
-  this->imr_poa_->activate_object_with_id (id.in (), &waiter_svt_);
-  obj = this->imr_poa_->id_to_reference (id.in ());
-  if (startup_timeout_ > ACE_Time_Value::zero)
-    {
-      obj = this->set_timeout_policy (obj.in (), startup_timeout_);
-    }
-  waiter_ = ImplementationRepository::AsyncStartupWaiter::_narrow (obj.in ());
-
-  id = PortableServer::string_to_ObjectId ("ImplRepo_Service");
+    PortableServer::string_to_ObjectId ("ImplRepo_Service");
   this->imr_poa_->activate_object_with_id (id.in (), this);
 
   obj = this->imr_poa_->id_to_reference (id.in ());
@@ -225,7 +215,9 @@ ImR_Locator_i::run (void)
 }
 
 void
-ImR_Locator_i::shutdown (CORBA::Boolean activators, CORBA::Boolean servers)
+ImR_Locator_i::shutdown
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ CORBA::Boolean activators, CORBA::Boolean servers)
 {
   if (servers != 0 && this->repository_->servers ().current_size () > 0)
     {
@@ -257,7 +249,7 @@ ImR_Locator_i::shutdown (CORBA::Boolean activators, CORBA::Boolean servers)
               acts[i]->shutdown ();
               acts[i] = ImplementationRepository::Activator::_nil ();
             }
-          catch (const CORBA::Exception& ex)
+          catch (CORBA::Exception& ex)
             {
               ++shutdown_errs;
               if (debug_ > 1)
@@ -277,6 +269,8 @@ ImR_Locator_i::shutdown (CORBA::Boolean activators, CORBA::Boolean servers)
   // Technically, we should wait for all the activators to unregister, but
   // ,for now at least, it doesn't seem worth it.
   this->shutdown (false);
+
+  _tao_rh->shutdown ();
 }
 
 void
@@ -300,7 +294,7 @@ ImR_Locator_i::fini (void)
       if (debug_ > 0)
         ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Shut down successfully.\n")));
     }
-  catch (const CORBA::Exception& ex)
+  catch (CORBA::Exception& ex)
     {
       ex._tao_print_exception (ACE_TEXT ("ImR_Locator_i::fini"));
       throw;
@@ -308,9 +302,11 @@ ImR_Locator_i::fini (void)
   return 0;
 }
 
-CORBA::Long
-ImR_Locator_i::register_activator (const char* aname,
-                                   ImplementationRepository::Activator_ptr activator)
+void
+ImR_Locator_i::register_activator
+(ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
+ const char* aname,
+ ImplementationRepository::Activator_ptr activator)
 {
   ACE_ASSERT (aname != 0);
   ACE_ASSERT (! CORBA::is_nil (activator));
@@ -332,12 +328,14 @@ ImR_Locator_i::register_activator (const char* aname,
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Activator registered for %C.\n"),
                 aname));
 
-  return token;
+  _tao_rh->register_activator (token);
 }
 
 void
-ImR_Locator_i::unregister_activator (const char* aname,
-                                     CORBA::Long token)
+ImR_Locator_i::unregister_activator
+(ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
+ const char* aname,
+ CORBA::Long token)
 {
   ACE_ASSERT (aname != 0);
   Activator_Info_Ptr info = this->get_activator (aname);
@@ -350,6 +348,7 @@ ImR_Locator_i::unregister_activator (const char* aname,
             LM_DEBUG,
             ACE_TEXT ("ImR: Ignoring unregister activator:%C. Wrong token.\n"),
             aname));
+          _tao_rh->unregister_activator ();
           return;
         }
 
@@ -368,6 +367,7 @@ ImR_Locator_i::unregister_activator (const char* aname,
           ACE_TEXT ("Unknown activator.\n"),
           aname));
     }
+  _tao_rh->unregister_activator ();
 }
 
 void
@@ -379,7 +379,9 @@ ImR_Locator_i::unregister_activator_i (const char* aname)
 }
 
 void
-ImR_Locator_i::notify_child_death (const char* name)
+ImR_Locator_i::notify_child_death
+(ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
+ const char* name)
 {
   ACE_ASSERT (name != 0);
 
@@ -398,10 +400,13 @@ ImR_Locator_i::notify_child_death (const char* name)
         ACE_DEBUG ((LM_DEBUG,
                     ACE_TEXT ("ImR: Failed to find server in repository.\n")));
     }
+  _tao_rh->notify_child_death ();
 }
 
 void
-ImR_Locator_i::activate_server (const char* server)
+ImR_Locator_i::activate_server
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ const char* server)
 {
   if (debug_ > 1)
     {
@@ -409,42 +414,17 @@ ImR_Locator_i::activate_server (const char* server)
                   server));
     }
 
+  ImR_ResponseHandler *rh = 0;
+  ACE_NEW (rh, ImR_Loc_ResponseHandler (ImR_Loc_ResponseHandler::LOC_ACTIVATE_SERVER, _tao_rh));
+
   // This is the version called by tao_imr to activate the server, manually
   // starting it if necessary.
-  CORBA::String_var cleanup =
-    activate_server_by_name (server, true);
-}
-
-char*
-ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start)
-{
-  // Activate the server, starting it if necessary. Don't start MANUAL
-  // servers unless manual_start=true
-  ACE_ASSERT (name != 0);
-
-  ACE_CString serverKey;
-  ACE_CString server_id;
-  bool jacorb_server = false;
-  this->parse_id (name, server_id, serverKey, jacorb_server);
-  UpdateableServerInfo info (this->repository_.get(), serverKey);
-  if (info.null ())
-    {
-      ACE_ERROR ((
-        LM_ERROR,
-        ACE_TEXT ("ImR: Cannot find info for server <%C>\n"),
-        name));
-      throw ImplementationRepository::NotFound ();
-    }
-
-  //MDM
-  info.edit()->start_count = 0;
-
-  return this->activate_server_i (info, manual_start);
+  activate_server_by_name (server, true, rh);
 }
 
 void
 ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start,
-                                        ImR_ReplyHandler *rh)
+                                        ImR_ResponseHandler *rh)
 {
   // Activate the server, starting it if necessary. Don't start MANUAL
   // servers unless manual_start=true
@@ -471,6 +451,14 @@ ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start,
 }
 
 char*
+ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start)
+{
+  ImR_SyncResponseHandler rh (this->orb_.in());
+  this->activate_server_by_name (name, manual_start, &rh);
+  return rh.wait_for_result ();
+}
+
+char*
 ImR_Locator_i::activate_server_by_object (const char* object_name)
 {
   ACE_ASSERT (object_name != 0);
@@ -485,7 +473,7 @@ ImR_Locator_i::activate_server_by_object (const char* object_name)
         {
           return activate_server_by_name (object_name, false);
         }
-      catch (const ImplementationRepository::NotFound&)
+      catch (ImplementationRepository::NotFound&)
         {
           server_name = server_name.substr (pos + 1);
           return activate_server_by_name (server_name.c_str (), false);
@@ -497,11 +485,10 @@ ImR_Locator_i::activate_server_by_object (const char* object_name)
     }
 }
 
-
 void
 ImR_Locator_i::activate_server_i (UpdateableServerInfo& info,
                                   bool manual_start,
-                                  ImR_ReplyHandler *rh)
+                                  ImR_ResponseHandler *rh)
 {
   AsyncAccessManager *aam = 0;
   if (info->activation_mode == ImplementationRepository::PER_CLIENT)
@@ -521,296 +508,6 @@ ImR_Locator_i::activate_server_i (UpdateableServerInfo& info,
   aam->add_interest (rh);
 }
 
-
-#if 0
-void
-ImR_Locator_i::activate_server_i (UpdateableServerInfo& info,
-                                  bool manual_start,
-                                  ImR_ReplyHandler *rh)
-{
-  if (info->activation_mode == ImplementationRepository::PER_CLIENT)
-    {
-      activate_perclient_server_i (info, manual_start,rh);
-      return;
-    }
-
-  try
-    {
-      CORBA::String_var ior = this->activate_server_i (info, manual_start);
-      rh->send_ior (ior.in());
-    }
-  catch (CORBA::Exception &)
-    {
-      rh->send_exception ();
-    }
-}
-#endif
-
-char*
-ImR_Locator_i::activate_server_i (UpdateableServerInfo& info,
-                                  bool manual_start)
-{
-  if (info->activation_mode == ImplementationRepository::PER_CLIENT)
-    {
-      return activate_perclient_server_i (info, manual_start);
-    }
-
-  while (true)
-    {
-      if (this->is_alive (info))
-        {
-          if (debug_ > 1)
-            {
-              ACE_DEBUG ((
-                LM_DEBUG,
-                ACE_TEXT ("ImR: Successfully activated <%C> at \n\t%C\n"),
-                info->name.c_str (), info->partial_ior.c_str ()));
-            }
-          info.edit ()->start_count = 0;
-
-          waiter_svt_.unblock_all (info->name.c_str ());
-
-          return CORBA::string_dup (info->partial_ior.c_str ());
-        }
-
-      info.edit()->reset ();
-
-      if (! info->starting && info->start_count >= info->start_limit)
-        {
-          if (this->debug_ > 0)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          ACE_TEXT ("ImR: Cannot Activate <%C>.\n"),
-                          info->name.c_str ()));
-            }
-
-          waiter_svt_.unblock_all (info->name.c_str ());
-
-          throw ImplementationRepository::CannotActivate(
-              "Cannot start server.");
-        }
-
-      // Note: We already updated info with StartupInfo in server_is_running ()
-      ImplementationRepository::StartupInfo_var si =
-        this->start_server (info, manual_start, info.edit()->waiting_clients);
-    }
-}
-
-void
-ImR_Locator_i::activate_perclient_server_i (UpdateableServerInfo& info,
-                                            bool manual_start,
-                                            ImR_ReplyHandler *rh)
-{
-  try
-    {
-      CORBA::String_var ior = this->activate_perclient_server_i (info, manual_start);
-      rh->send_ior (ior.in());
-    }
-  catch (CORBA::Exception &)
-    {
-      rh->send_exception ();
-    }
-}
-
-char*
-ImR_Locator_i::activate_perclient_server_i (UpdateableServerInfo& shared_info,
-                                            bool manual_start)
-{
-  // create a copy of shared_info that can be edited without affecting memory
-  // in the repository
-  UpdateableServerInfo info (*shared_info);
-  do
-    {
-      ImplementationRepository::StartupInfo* psi =
-        this->start_server (info, manual_start, shared_info.edit()->waiting_clients);
-
-      // waiting_clients will be updated by each call to start_server
-      shared_info.update_repo ();
-      if (psi != 0)
-        {
-          ImplementationRepository::StartupInfo_var si = psi;
-          ACE_ASSERT (info->name == si->name.in ());
-          info.edit ()->partial_ior = si->partial_ior.in ();
-          info.edit ()->ior = si->ior.in ();
-
-          if (this->is_alive (info))
-            {
-              if (debug_ > 1)
-                {
-                  ACE_DEBUG ((
-                    LM_DEBUG,
-                    ACE_TEXT ("ImR: Successfully activated <%C> at \n\t%C\n"),
-                    info->name.c_str (), info->partial_ior.c_str ()));
-                }
-              return CORBA::string_dup (info->partial_ior.c_str ());
-            }
-          info.edit()->reset ();
-        }
-    }
-  while (info->start_count < info->start_limit);
-
-  if (this->debug_ > 0)
-    {
-      ACE_DEBUG ((
-        LM_DEBUG,
-        ACE_TEXT ("ImR: Cannot Activate <%C>.\n"),
-        info->name.c_str ()));
-    }
-  throw ImplementationRepository::CannotActivate("Cannot start server.");
-}
-
-ImplementationRepository::StartupInfo*
-ImR_Locator_i::start_server (UpdateableServerInfo& info, bool manual_start,
-                             int& waiting_clients)
-{
-  if (info->activation_mode == ImplementationRepository::MANUAL && ! manual_start)
-    {
-      if (debug_ > 0)
-        ACE_DEBUG ((
-          LM_DEBUG,
-          ACE_TEXT ("ImR: Cannot start server <%C>. ActivationMode=MANUAL\n"),
-          info->name.c_str ()));
-
-      throw ImplementationRepository::CannotActivate(
-        "Cannot implicitly activate MANUAL server.");
-    }
-  if (info->cmdline.length () == 0)
-    {
-      if (debug_ > 0)
-        ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Cannot start server <%C>.")
-                    ACE_TEXT (" No command line.\n"), info->name.c_str ()));
-      throw ImplementationRepository::CannotActivate(
-        "No command line registered for server.");
-    }
-
-  Activator_Info_Ptr ainfo = this->get_activator (info->activator);
-
-  if (ainfo.null () || CORBA::is_nil (ainfo->activator.in ()))
-    {
-      if (debug_ > 0)
-        ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Cannot start server <%C>. ")
-                    ACE_TEXT ("Activator <%C> not found.\n"),
-                    info->name.c_str (), info->activator.c_str ()));
-      throw ImplementationRepository::CannotActivate(
-        "No activator registered for server.");
-    }
-
-  try
-    {
-      ++waiting_clients;
-
-      if (waiting_clients <= 1 ||
-          info->activation_mode == ImplementationRepository::PER_CLIENT)
-        {
-          info.edit()->starting = true;
-          ++(info.edit()->start_count);
-          ACE_ASSERT (info->start_count <= info->start_limit);
-          if (this->debug_ > 0)
-            {
-              ACE_DEBUG ((
-                LM_DEBUG,
-                ACE_TEXT ("ImR: Starting server <%C>. Attempt %d/%d.\n"),
-                info->name.c_str (), info->start_count, info->start_limit));
-            }
-          ainfo->activator->start_server (info->name.c_str (),
-                                          info->cmdline.c_str (),
-                                          info->dir.c_str (),
-                                          info->env_vars);
-        }
-
-      if (info->partial_ior.length () == 0)
-        {
-          if (this->debug_ > 0)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          ACE_TEXT ("ImR: Waiting for <%C> to start...\n"),
-                          info->name.c_str ()));
-            }
-
-          ImplementationRepository::StartupInfo_var si =
-            waiter_->wait_for_startup (info->name.c_str ());
-
-          --waiting_clients;
-          info.edit()->starting = false;
-
-          return si._retn ();
-        }
-      else // The server_is_running () came in before the wait_for_startup ()
-        {
-          if (this->debug_ > 0)
-            {
-              ACE_DEBUG ((
-                LM_DEBUG,
-                ACE_TEXT ("ImR: <%C> Skipping wait. Already started.\n"),
-                info->name.c_str ()));
-            }
-          --waiting_clients;
-          info.edit()->starting = false;
-        }
-    }
-  catch (const CORBA::TIMEOUT&)
-    {
-      --waiting_clients;
-      info.edit()->starting = false;
-      // We may have connected successfully, because the timeout could occur before
-      // the AsyncStartupWaiter manages to return. In fact, when the ImR is very busy
-      // this is the most likely code path.
-      if (info->partial_ior.length () == 0)
-        {
-          if (debug_ > 0)
-            ACE_DEBUG ((LM_DEBUG,
-                        ACE_TEXT ("ImR : Timeout waiting for <%C> to start.\n"),
-                        info->name.c_str ()));
-          info.edit()->reset ();
-        }
-    }
-  catch (const ImplementationRepository::CannotActivate&)
-    {
-      --waiting_clients;
-      info.edit()->starting = false;
-      info.edit()->reset ();
-      if (debug_ > 0)
-        ACE_DEBUG ((LM_DEBUG,
-                    ACE_TEXT ("ImR: Activator cannot start <%C>.\n"),
-                    info->name.c_str ()));
-    }
-  catch (const CORBA::Exception& ex)
-    {
-      --waiting_clients;
-      info.edit()->starting = false;
-      if (debug_ > 0)
-        ACE_DEBUG ((
-          LM_DEBUG,
-          ACE_TEXT ("ImR: Unexpected exception while starting <%C>.\n"),
-          info->name.c_str ()));
-      if (debug_ > 1)
-        ex._tao_print_exception ("");
-      info.edit()->reset ();
-
-      // Before we reset the activator info, let's see if it's still
-      // there then let's keep it around for a while.
-      bool dead_activator = false;
-      try
-        {
-          dead_activator = ainfo->activator->_non_existent ();
-        }
-      catch (const CORBA::Exception&)
-        {
-          dead_activator = true;
-        }
-
-      if (dead_activator)
-        {
-          // Activator is damaged - reset our info.
-          // Client's trying to restart a server on this host will
-          // subsequently be told "no activator found for host ..." or
-          // some such.
-          ainfo->reset ();
-        }
-    }
-  return 0; // This is not a corba call, so a zero should be ok
-}
-
 CORBA::Object_ptr
 ImR_Locator_i::set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value& to)
 {
@@ -842,7 +539,7 @@ ImR_Locator_i::set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value&
           ret = CORBA::Object::_duplicate (obj);
         }
     }
-  catch (const CORBA::Exception& ex)
+  catch (CORBA::Exception& ex)
     {
       ex._tao_print_exception (
         ACE_TEXT ("ImR_Locator_i::set_timeout_policy ()"));
@@ -852,24 +549,26 @@ ImR_Locator_i::set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value&
 }
 
 void
-ImR_Locator_i::add_or_update_server (
-    const char* server,
-    const ImplementationRepository::StartupOptions &options)
+ImR_Locator_i::add_or_update_server
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ const char* server,
+ const ImplementationRepository::StartupOptions &options)
 {
   ACE_ASSERT (server != 0);
 
   if (this->read_only_)
     {
-      ACE_DEBUG ((
-        LM_DEBUG,
-        ACE_TEXT ("ImR: Cannot add/update server <%C> due to locked ")
-        ACE_TEXT ("database.\n"),
-        server));
-      throw CORBA::NO_PERMISSION (
-        CORBA::SystemException::_tao_minor_code (
-          TAO_IMPLREPO_MINOR_CODE,
-          0),
-        CORBA::COMPLETED_NO);
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("ImR: Cannot add/update server <%C> due to locked ")
+                  ACE_TEXT ("database.\n"),
+                  server));
+      CORBA::NO_PERMISSION ex
+        (CORBA::SystemException::_tao_minor_code
+         (TAO_IMPLREPO_MINOR_CODE,0),
+         CORBA::COMPLETED_NO);
+      ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+      _tao_rh->add_or_update_server_excep (&h);
+      return;
     }
 
   if (debug_ > 0)
@@ -945,6 +644,8 @@ ImR_Locator_i::add_or_update_server (
                     options.environment[i].name.in (),
                     options.environment[i].value.in ()));
     }
+
+  _tao_rh->add_or_update_server ();
 }
 
 void
@@ -973,20 +674,23 @@ ImR_Locator_i::parse_id(const char* id,
 }
 
 void
-ImR_Locator_i::remove_server (const char* name)
+ImR_Locator_i::remove_server
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ const char* name)
 {
   ACE_ASSERT (name != 0);
   if (this->read_only_)
     {
-      ACE_ERROR ((
-        LM_ERROR,
-        ACE_TEXT ("ImR: Can't remove server <%C> due to locked database.\n"),
-        name));
-      throw CORBA::NO_PERMISSION (
-        CORBA::SystemException::_tao_minor_code (
-          TAO_IMPLREPO_MINOR_CODE,
-          0),
-        CORBA::COMPLETED_NO);
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("ImR: Can't remove server <%C> due to locked database.\n"),
+                  name));
+      CORBA::NO_PERMISSION ex
+        (CORBA::SystemException::_tao_minor_code
+         (TAO_IMPLREPO_MINOR_CODE, 0),
+         CORBA::COMPLETED_NO);
+      ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+      _tao_rh->remove_server_excep (&h);
+      return;
     }
 
   // Note : This will be safe, because any Server_Info_Ptr objects will still
@@ -1015,7 +719,8 @@ ImR_Locator_i::remove_server (const char* name)
               poa->destroy (etherealize, wait);
             }
           if (this->debug_ > 0)
-            ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Removed Server <%C>.\n"),
+            ACE_DEBUG ((LM_DEBUG,
+                        ACE_TEXT ("ImR: Removed Server <%C>.\n"),
                         name));
         }
     }
@@ -1023,8 +728,12 @@ ImR_Locator_i::remove_server (const char* name)
     {
       ACE_ERROR ((LM_ERROR,
                   ACE_TEXT ("ImR: Can't remove unknown server <%C>.\n"), name));
-      throw ImplementationRepository::NotFound ();
+      ImplementationRepository::NotFound ex;
+      ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+      _tao_rh->remove_server_excep (&h);
+      return;
     }
+  _tao_rh->remove_server ();
 }
 
 PortableServer::POA_ptr
@@ -1035,19 +744,22 @@ ImR_Locator_i::findPOA (const char* name)
       bool activate_it = false;
       return root_poa_->find_POA (name, activate_it);
     }
-  catch (const CORBA::Exception&)
+  catch (CORBA::Exception&)
     {// Ignore
     }
   return PortableServer::POA::_nil ();
 }
 
 void
-ImR_Locator_i::shutdown_server (const char* server)
+ImR_Locator_i::shutdown_server
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ const char* server)
 {
   ACE_ASSERT (server != 0);
 
   if (this->debug_ > 0)
-    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Shutting down server <%C>.\n"),
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("ImR: Shutting down server <%C>.\n"),
                 server));
 
   ACE_CString name;
@@ -1058,22 +770,26 @@ ImR_Locator_i::shutdown_server (const char* server)
   UpdateableServerInfo info(this->repository_.get(), name);
   if (info.null ())
     {
-      ACE_ERROR ((
-        LM_ERROR,
-        ACE_TEXT ("ImR: shutdown_server () Cannot find info for server <%C>\n"),
-        server));
-      throw ImplementationRepository::NotFound ();
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("ImR: shutdown_server () Cannot find info for server <%C>\n"),
+                  server));
+      ImplementationRepository::NotFound ex;
+      ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+      _tao_rh->shutdown_server_excep (&h);
+      return;
     }
 
   this->connect_server (info);
 
   if (CORBA::is_nil (info->server.in ()))
     {
-      ACE_ERROR ((
-        LM_ERROR,
-        ACE_TEXT ("ImR: shutdown_server () Cannot connect to server <%C>\n"),
-        server));
-      throw ImplementationRepository::NotFound ();
+      ACE_ERROR ((LM_ERROR,
+                  ACE_TEXT ("ImR: shutdown_server () Cannot connect to server <%C>\n"),
+                  server));
+      ImplementationRepository::NotFound ex;
+      ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+      _tao_rh->shutdown_server_excep (&h);
+      return;
     }
 
   try
@@ -1084,26 +800,26 @@ ImR_Locator_i::shutdown_server (const char* server)
         ImplementationRepository::ServerObject::_unchecked_narrow (obj.in ());
       server->shutdown ();
     }
-  catch (const CORBA::TIMEOUT&)
+  catch (CORBA::TIMEOUT &ex)
     {
       info.edit ()->reset ();
       // Note : This is a good thing. It means we didn't waste our time waiting for
       // the server to finish shutting down.
       if (this->debug_ > 1)
         {
-          ACE_DEBUG ((
-            LM_DEBUG,
-            ACE_TEXT ("ImR: Timeout while waiting for <%C> shutdown.\n"),
-            server));
+          ACE_DEBUG ((LM_DEBUG,
+                      ACE_TEXT ("ImR: Timeout while waiting for <%C> shutdown.\n"),
+                      server));
         }
-      throw;
+      ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+      _tao_rh->shutdown_server_excep (&h);
+      return;
     }
-  catch (const CORBA::Exception&)
+  catch (CORBA::Exception&)
     {
       if (this->debug_ > 1)
         {
-          ACE_DEBUG ((
-            LM_DEBUG,
+          ACE_DEBUG ((LM_DEBUG,
             ACE_TEXT ("ImR: Exception ignored while shutting down <%C>\n"),
             server));
         }
@@ -1112,12 +828,15 @@ ImR_Locator_i::shutdown_server (const char* server)
   // Note : In most cases this has already been done in the server_is_shutting_down ()
   // operation, but it doesn't hurt to update it again.
   info.edit ()->reset ();
+  _tao_rh->shutdown_server ();
 }
 
 void
-ImR_Locator_i::server_is_running (const char* id,
-                                  const char* partial_ior,
-                                  ImplementationRepository::ServerObject_ptr server)
+ImR_Locator_i::server_is_running
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ const char* id,
+ const char* partial_ior,
+ ImplementationRepository::ServerObject_ptr server)
 {
   ACE_ASSERT (id != 0);
   ACE_ASSERT (partial_ior != 0);
@@ -1129,15 +848,17 @@ ImR_Locator_i::server_is_running (const char* id,
   this->parse_id(id, server_id, name, jacorb_server);
 
   if (this->debug_ > 0)
-    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Server %C is running at %C.\n"),
-      name.c_str (), partial_ior));
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("ImR: Server %C is running at %C.\n"),
+                name.c_str (), partial_ior));
 
 
   CORBA::String_var ior = orb_->object_to_string (server);
 
   if (this->debug_ > 1)
-    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Server %C callback at %C.\n"),
-      name.c_str (), ior.in ()));
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("ImR: Server %C callback at %C.\n"),
+                name.c_str (), ior.in ()));
 
   if (this->unregister_if_address_reused_)
     this->repository_->unregister_if_address_reused (server_id, name, partial_ior);
@@ -1175,52 +896,13 @@ ImR_Locator_i::server_is_running (const char* id,
     }
   else
     {
-#if 0
-      if (info->server_id != server_id)
-      {
-        if (! info->server_id.empty())
-          ACE_DEBUG ((LM_DEBUG,
-            ACE_TEXT ("ImR - WARNING: server \"%C\" changed server id from ")
-            ACE_TEXT ("\"%C\" to \"%C\" waiting PER_CLIENT clients.\n"),
-            name.c_str (), info->server_id.c_str (), server_id.c_str ()));
-        info.edit ()->server_id = server_id;
-      }
-
-      if (info->activation_mode != ImplementationRepository::PER_CLIENT)
-        {
-          info.edit ()->ior = ior.in ();
-          info.edit ()->partial_ior = partial_ior;
-          // Will connect at first access
-          info.edit ()->server = ImplementationRepository::ServerObject::_nil ();
-
-          info.update_repo();
-
-          waiter_svt_.unblock_one (name.c_str (), partial_ior, ior.in (), false);
-        }
-      else
-        {
-          // Note : There's no need to unblock all the waiting request until
-          // we know the final status of the server.
-          if (info->waiting_clients > 0)
-            {
-              waiter_svt_.unblock_one (name.c_str (), partial_ior, ior.in (), true);
-            }
-          else if (this->debug_ > 1)
-            {
-              ACE_DEBUG ((LM_DEBUG,
-                          ACE_TEXT ("ImR - Ignoring server_is_running due to no ")
-                          ACE_TEXT ("waiting PER_CLIENT clients.\n")));
-            }
-        }
-#else
-
       if (info->server_id != server_id)
       {
         if (! info->server_id.empty())
           ACE_DEBUG ((LM_DEBUG,
-            ACE_TEXT ("ImR - WARNING: server \"%C\" changed server id from ")
-            ACE_TEXT ("\"%C\" to \"%C\" waiting PER_CLIENT clients.\n"),
-            name.c_str (), info->server_id.c_str (), server_id.c_str ()));
+                      ACE_TEXT ("ImR - WARNING: server \"%C\" changed server id from ")
+                      ACE_TEXT ("\"%C\" to \"%C\" waiting PER_CLIENT clients.\n"),
+                      name.c_str (), info->server_id.c_str (), server_id.c_str ()));
         info.edit ()->server_id = server_id;
       }
 
@@ -1231,36 +913,38 @@ ImR_Locator_i::server_is_running (const char* id,
           info.edit ()->server = s;
 
           info.update_repo();
-
         }
 
       AsyncAccessManager *aam = this->find_aam (name.c_str());
       if (aam != 0)
         aam->server_is_running (partial_ior);
-#endif
     }
+  _tao_rh->server_is_running ();
 }
 
 void
-ImR_Locator_i::server_is_shutting_down (const char* server)
+ImR_Locator_i::server_is_shutting_down
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ const char* server)
 {
   ACE_ASSERT (server != 0);
-  UpdateableServerInfo info(this->repository_.get(), server);
+  UpdateableServerInfo info (this->repository_.get(), server);
   if (info.null ())
     {
       if (this->debug_ > 1)
         {
-          ACE_DEBUG ((
-            LM_DEBUG,
-            ACE_TEXT ("ImR_Locator_i::server_is_shutting_down: ")
-            ACE_TEXT ("Unknown server:%C\n"),
-            server));
+          ACE_DEBUG ((LM_DEBUG,
+                      ACE_TEXT ("ImR_Locator_i::server_is_shutting_down: ")
+                      ACE_TEXT ("Unknown server:%C\n"),
+                      server));
         }
+      _tao_rh->server_is_shutting_down ();
       return;
     }
 
   if (this->debug_ > 0)
-    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Server <%C> is shutting down.\n"),
+    ACE_DEBUG ((LM_DEBUG,
+                ACE_TEXT ("ImR: Server <%C> is shutting down.\n"),
                 server));
 
   this->pinger_.remove_server (server);
@@ -1271,11 +955,13 @@ ImR_Locator_i::server_is_shutting_down (const char* server)
     }
 
   info.edit ()->reset ();
+  _tao_rh->server_is_shutting_down ();
 }
 
 void
-ImR_Locator_i::find (const char* server,
-                     ImplementationRepository::ServerInformation_out imr_info)
+ImR_Locator_i::find
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ const char* server)
 {
   ACE_ASSERT (server != 0);
 
@@ -1284,30 +970,46 @@ ImR_Locator_i::find (const char* server,
   bool jacorb_server = false;
   this->parse_id(server, server_id, serverKey, jacorb_server);
   UpdateableServerInfo info(this->repository_.get(), serverKey);
-  if (! info.null ())
+  ImplementationRepository::ServerInformation_var imr_info;
+  try
     {
-      imr_info = info->createImRServerInfo ();
+      if (! info.null ())
+        {
+          imr_info = info->createImRServerInfo ();
 
-      if (this->debug_ > 1)
-        ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Found server %C.\n"), server));
+          if (this->debug_ > 1)
+            ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Found server %C.\n"), server));
+        }
+      else
+        {
+          ACE_NEW_THROW_EX (imr_info, ImplementationRepository::ServerInformation,
+                            CORBA::NO_MEMORY ());
+          imr_info->startup.activation= ImplementationRepository::NORMAL;
+          if (this->debug_ > 1)
+            ACE_DEBUG ((LM_DEBUG,
+                        ACE_TEXT ("ImR: Cannot find server <%C>\n"),
+                        server));
+        }
     }
-  else
+  catch (CORBA::Exception &ex)
     {
-      ACE_NEW_THROW_EX (imr_info, ImplementationRepository::ServerInformation,
-                        CORBA::NO_MEMORY ());
-      imr_info->startup.activation= ImplementationRepository::NORMAL;
-      if (this->debug_ > 1)
-        ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: Cannot find server <%C>\n"),
-                    server));
+      ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+      _tao_rh->find_excep (&h);
+      return;
     }
+  _tao_rh->find (imr_info.in());
+  //  delete imr_info;
 }
 
 void
-ImR_Locator_i::list (CORBA::ULong how_many,
-   CORBA::Boolean determine_active_status,
-   ImplementationRepository::ServerInformationList_out server_list,
-   ImplementationRepository::ServerInformationIterator_out server_iterator)
+ImR_Locator_i::list
+(ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+ CORBA::ULong how_many,
+ CORBA::Boolean determine_active_status)
 {
+  ImplementationRepository::ServerInformationList_var server_list;
+  ImplementationRepository::ServerInformationIterator_var server_iterator;
+
   if (this->debug_ > 1)
     ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR: List servers.\n")));
 
@@ -1331,10 +1033,11 @@ ImR_Locator_i::list (CORBA::ULong how_many,
   server_list->length (n);
 
   if (this->debug_ > 1)
-    ACE_DEBUG ((
-      LM_DEBUG,
-      ACE_TEXT ("ImR_Locator_i::list: Filling ServerList with %d servers\n"),
-      n));
+    {
+      ACE_DEBUG ((LM_DEBUG,
+                  ACE_TEXT ("ImR_Locator_i::list: Filling ServerList with %d servers\n"),
+                  n));
+    }
 
   for (CORBA::ULong i = 0; i < n; i++)
     {
@@ -1370,31 +1073,31 @@ ImR_Locator_i::list (CORBA::ULong how_many,
   if (this->repository_->servers ().current_size () > n)
     {
       if (this->debug_ > 1)
-        ACE_DEBUG ((
-          LM_DEBUG,
-          ACE_TEXT ("ImR_Locator_i::list: Creating ServerInformation ")
-          ACE_TEXT ("Iterator\n")));
-
-      ImR_Iterator* imr_iter = 0;
-
-      ACE_NEW_THROW_EX (
-        imr_iter,
-        ImR_Iterator (n, *this->repository_, this->imr_poa_.in ()),
-        CORBA::NO_MEMORY ());
-
-      PortableServer::ServantBase_var tmp (imr_iter);
+        ACE_DEBUG ((LM_DEBUG,
+                    ACE_TEXT ("ImR_Locator_i::list: Creating ServerInformation ")
+                    ACE_TEXT ("Iterator\n")));
 
       try
         {
+          ImR_Iterator* imr_iter = 0;
+          ACE_NEW_THROW_EX (imr_iter,
+                            ImR_Iterator (n, *this->repository_, this->imr_poa_.in ()),
+                            CORBA::NO_MEMORY ());
+
+          PortableServer::ServantBase_var tmp (imr_iter);
+
           PortableServer::ObjectId_var id =
             this->imr_poa_->activate_object (imr_iter);
           CORBA::Object_var obj = this->imr_poa_->id_to_reference (id.in ());
           server_iterator = ImplementationRepository::
             ServerInformationIterator::_unchecked_narrow (obj.in ());
+
+          _tao_rh->list (server_list.in(), server_iterator.in());
         }
-      catch (const CORBA::Exception&)
+      catch (CORBA::Exception& ex)
         {
-          throw;
+          ImplementationRepository::AMH_AdministrationExceptionHolder h (&ex);
+          _tao_rh->list_excep (&h);
         }
     }
 }
@@ -1447,7 +1150,7 @@ ImR_Locator_i::connect_activator (Activator_Info& info)
           ACE_TEXT ("ImR: Connected to activator <%C>\n"),
           info.name.c_str ()));
     }
-  catch (const CORBA::Exception&)
+  catch (CORBA::Exception&)
     {
       info.reset ();
     }
@@ -1475,18 +1178,17 @@ ImR_Locator_i::auto_start_servers (void)
           if (info->activation_mode == ImplementationRepository::AUTO_START
               && info->cmdline.length () > 0)
             {
-              CORBA::String_var cleanup =
-                this->activate_server_i (info, true);
+              ImR_ResponseHandler rh;
+              this->activate_server_i (info, true, &rh);
             }
         }
-      catch (const CORBA::Exception& ex)
+      catch (CORBA::Exception& ex)
         {
           if (this->debug_ > 1)
             {
-              ACE_DEBUG ((
-                LM_DEBUG,
-                ACE_TEXT ("ImR: AUTO_START Could not activate <%C>\n"),
-                server_entry->ext_id_.c_str ()));
+              ACE_DEBUG ((LM_DEBUG,
+                          ACE_TEXT ("ImR: AUTO_START Could not activate <%C>\n"),
+                          server_entry->ext_id_.c_str ()));
               ex._tao_print_exception ("AUTO_START");
             }
           // Ignore exceptions
@@ -1534,7 +1236,7 @@ ImR_Locator_i::connect_server (UpdateableServerInfo& info)
                     ACE_TEXT ("ImR: Connected to server <%C>\n"),
                     info->name.c_str ()));
     }
-  catch (const CORBA::Exception&)
+  catch (CORBA::Exception&)
     {
       info.edit ()->reset ();
     }
@@ -1657,34 +1359,108 @@ SyncListener::status_changed (LiveStatus status, bool may_retry)
 }
 
 //---------------------------------------------------------------------------
+
+ImR_SyncResponseHandler::ImR_SyncResponseHandler (CORBA::ORB_ptr orb)
+  :excep_ (0),
+   orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+ImR_SyncResponseHandler::~ImR_SyncResponseHandler (void)
+{
+  delete excep_;
+}
+
+void
+ImR_SyncResponseHandler::send_ior (const char *pior)
+{
+  this->result_ = pior;
+}
+
+void
+ImR_SyncResponseHandler::send_exception (CORBA::Exception *ex)
+{
+  this->excep_ = ex;
+}
+
+char *
+ImR_SyncResponseHandler::wait_for_result (void)
+{
+  while (this->result_.in() == 0 && this->excep_ == 0)
+    {
+      this->orb_->perform_work ();
+    }
+  if (this->excep_ != 0)
+    throw this->excep_;
+  return this->result_._retn();
+}
+
 //---------------------------------------------------------------------------
-#if 0
-ImR_Loc_ReplyHandler::ImR_Loc_ReplyHandler (AMH_ImplementationRepository::LocatorResponseHandler_ptr rh)
-  :rh_ (AMH_ImplementationRepository::LocatorResponseHandler::_duplicate(rh))
+
+ImR_Loc_ResponseHandler::ImR_Loc_ResponseHandler (Loc_Operation_Id opid,
+                                            ImplementationRepository::AMH_AdministrationResponseHandler_ptr rh)
+  :op_id_ (opid),
+   resp_ (ImplementationRepository::AMH_AdministrationResponseHandler::_duplicate (rh))
 {
 }
 
-ImR_Loc_ReplyHandler::~ImR_Loc_ReplyHandler (void)
+ImR_Loc_ResponseHandler::~ImR_Loc_ResponseHandler (void)
 {
 }
 
 void
-ImR_Loc_ReplyHandler::send_ior (const char *)
+ImR_Loc_ResponseHandler::send_ior (const char *)
 {
-  rh_->activate_server (); // void return
-  delete this;
+  switch (this->op_id_)
+    {
+    case LOC_ACTIVATE_SERVER:
+      resp_->activate_server ();
+      break;
+    case LOC_ADD_OR_UPDATE_SERVER:
+      resp_->add_or_update_server ();
+      break;
+    case LOC_REMOVE_SERVER:
+      resp_->remove_server ();
+      break;
+    case LOC_SHUTDOWN_SERVER:
+      resp_->shutdown_server ();
+      break;
+    case LOC_SERVER_IS_RUNNING:
+      resp_->server_is_running ();
+      break;
+    case LOC_SERVER_IS_SHUTTING_DOWN:
+      resp_->server_is_shutting_down ();
+      break;
+    };
 
+  delete this;
 }
 
 void
-ImR_Loc_ReplyHandler::send_exception (void)
+ImR_Loc_ResponseHandler::send_exception (CORBA::Exception *ex)
 {
-  CORBA::TRANSIENT ex (CORBA::SystemException::_tao_minor_code
-                       ( TAO_IMPLREPO_MINOR_CODE, 0),
-                       CORBA::COMPLETED_NO);
-  TAO_AMH_DSI_Exception_Holder h(&ex);
-  resp_->invoke_excep(&h);
+  ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
+  switch (this->op_id_)
+    {
+    case LOC_ACTIVATE_SERVER:
+      resp_->activate_server_excep (&h);
+      break;
+    case LOC_ADD_OR_UPDATE_SERVER:
+      resp_->add_or_update_server_excep (&h);
+      break;
+    case LOC_REMOVE_SERVER:
+      resp_->remove_server_excep (&h);
+      break;
+    case LOC_SHUTDOWN_SERVER:
+      resp_->shutdown_server_excep (&h);
+      break;
+    case LOC_SERVER_IS_RUNNING:
+      resp_->server_is_running_excep (&h);
+      break;
+    case LOC_SERVER_IS_SHUTTING_DOWN:
+      resp_->server_is_shutting_down_excep (&h);
+      break;
+    };
   delete this;
 }
 
-#endif
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h
index 132a9459abc..119684c5083 100644
--- a/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h
+++ b/TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.h
@@ -11,16 +11,14 @@
 #include "Activator_Info.h"
 #include "Forwarder.h"
 #include "LiveCheck.h"
+#include "ImR_ResponseHandler.h"
 #include "Locator_Options.h"
 #include "Server_Info.h"
 #include "ace/Auto_Ptr.h"
-#include "AsyncStartupWaiter_i.h"
 #include "AsyncAccessManager.h"
 #include "tao/IORTable/IORTable.h"
 
 #include "ImR_LocatorS.h"
-#include "AsyncStartupWaiterS.h"
-#include "LiveCheck.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
@@ -38,7 +36,8 @@ class UpdateableServerInfo;
 /// requests an activator to take care of activating the
 /// corresponding server and raises a forward exception to the
 /// client pointing to the correct server.
-class Locator_Export ImR_Locator_i : public virtual POA_ImplementationRepository::Locator
+class Locator_Export ImR_Locator_i :
+  public virtual POA_ImplementationRepository::AMH_Locator
 {
 public:
   ImR_Locator_i();
@@ -65,40 +64,76 @@ public:
 
   // Activator->Locator
 
-  virtual CORBA::Long register_activator (const char* name,
-    ImplementationRepository::Activator_ptr admin);
-  virtual void unregister_activator (const char* name,
-    CORBA::Long token);
-  virtual void notify_child_death (const char* name);
+  virtual void register_activator
+    (ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
+     const char* name,
+     ImplementationRepository::Activator_ptr admin);
+
+  virtual void unregister_activator
+    (ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
+     const char* name,
+     CORBA::Long token);
+
+  virtual void notify_child_death
+    (ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
+     const char* name);
 
   // tao_imr->Locator
 
-  virtual void activate_server (const char * name);
-  virtual void add_or_update_server (const char * name,
-               const ImplementationRepository::StartupOptions &options);
-  virtual void remove_server (const char * name);
-  virtual void shutdown_server (const char * name);
-  virtual void find (const char * name,
-                     ImplementationRepository::ServerInformation_out info);
-  virtual void list (CORBA::ULong how_many,
-    CORBA::Boolean determine_active_status,
-    ImplementationRepository::ServerInformationList_out server_list,
-    ImplementationRepository::ServerInformationIterator_out server_iterator);
-  virtual void shutdown(CORBA::Boolean activators, CORBA::Boolean servers);
+  virtual void activate_server
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     const char * name);
+
+  virtual void add_or_update_server
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     const char * name,
+     const ImplementationRepository::StartupOptions &options);
+
+  virtual void remove_server
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     const char * name);
+
+  virtual void shutdown_server
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     const char * name);
+
+  virtual void find
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     const char * name);
+
+  virtual void list
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     CORBA::ULong how_many,
+     CORBA::Boolean determine_active_status);
+
+  virtual void shutdown
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     CORBA::Boolean activators,
+     CORBA::Boolean servers);
 
   // Server->Locator
 
-  virtual void server_is_running (const char* name,
-                                  const char* partial_ior,
-               ImplementationRepository::ServerObject_ptr server_object);
-  virtual void server_is_shutting_down (const char * name);
+  virtual void server_is_running
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     const char* name,
+     const char* partial_ior,
+     ImplementationRepository::ServerObject_ptr server_object);
+
+  virtual void server_is_shutting_down
+    (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
+     const char * name);
 
   // Used by the INS_Locator to start a sever given an object name
   char* activate_server_by_object (const char* object_name);
   char* activate_server_by_name (const char * name, bool manual_start);
+
+  // Helper function also used by the Forwarder
+
   void  activate_server_by_name (const char * name,
                                  bool manual_start,
-                                 ImR_ReplyHandler *rh);
+                                 ImR_ResponseHandler *rh);
+
+  // interfaces to aid with collaboration
 
   LiveCheck &pinger (void);
   PortableServer::POA_ptr root_poa (void);
@@ -109,27 +144,15 @@ public:
 
 private:
 
-  char* activate_server_i (UpdateableServerInfo& info,
-                           bool manual_start);
-
   void  activate_server_i (UpdateableServerInfo& info,
                            bool manual_start,
-                           ImR_ReplyHandler *rh);
-
-  char* activate_perclient_server_i (UpdateableServerInfo& info,
-                                     bool manual_start);
-
-  void  activate_perclient_server_i (UpdateableServerInfo& info,
-                                     bool manual_start,
-                                     ImR_ReplyHandler *rh);
-
-  ImplementationRepository::StartupInfo*
-    start_server(UpdateableServerInfo& info,
-                 bool manual_start,
-                 int& waiting_clients);
+                           ImR_ResponseHandler *rh);
 
   bool is_alive(UpdateableServerInfo& info);
+
+#if 0
   int is_alive_i(UpdateableServerInfo& info);
+#endif
 
   void unregister_activator_i(const char* activator);
 
@@ -152,7 +175,6 @@ private:
 private:
 
   // The class that handles the forwarding.
-
   ImR_DSI_Forwarder dsi_forwarder_;
 
   // Used for the forwarding of any type of POA.
@@ -176,9 +198,6 @@ private:
 
   auto_ptr<Locator_Repository> repository_;
 
-  AsyncStartupWaiter_i waiter_svt_;
-  ImplementationRepository::AsyncStartupWaiter_var waiter_;
-
   bool read_only_;
   ACE_Time_Value startup_timeout_;
   ACE_Time_Value ping_interval_;
@@ -208,22 +227,58 @@ class SyncListener : public LiveListener
 
 //----------------------------------------------------------------------------
 /*
- * @class ImR_Loc_ReplyHandler
+ * @class ImR_Loc_ResponseHandler
+ *
+ * @brief specialized reply handler for Locator interface calls which have a
+ * void return.
+ */
+class ImR_SyncResponseHandler : public ImR_ResponseHandler
+{
+public:
+  ImR_SyncResponseHandler (CORBA::ORB_ptr orb);
+  virtual ~ImR_SyncResponseHandler (void);
+
+  virtual void send_ior (const char *pior);
+  virtual void send_exception (CORBA::Exception *ex);
+
+  char *wait_for_result (void);
+
+private:
+  CORBA::String_var result_;
+  CORBA::Exception *excep_;
+  CORBA::ORB_var orb_;
+};
+
+//----------------------------------------------------------------------------
+/*
+ * @class ImR_Loc_ResponseHandler
  *
  * @brief specialized reply handler for Locator interface calls which have a
  * void return.
  */
-class ImR_Loc_ReplyHandler : public ImR_ReplyHandler
+class ImR_Loc_ResponseHandler : public ImR_ResponseHandler
 {
 public:
-  ImR_Loc_ReplyHandler (ImplementationRepository::AMH_LocatorResponseHandler_ptr rh);
-  virtual ~ImR_Loc_ReplyHandler (void);
+  enum Loc_Operation_Id
+    {
+      LOC_ACTIVATE_SERVER,
+      LOC_ADD_OR_UPDATE_SERVER,
+      LOC_REMOVE_SERVER,
+      LOC_SHUTDOWN_SERVER,
+      LOC_SERVER_IS_RUNNING,
+      LOC_SERVER_IS_SHUTTING_DOWN,
+    };
+
+  ImR_Loc_ResponseHandler (Loc_Operation_Id opid,
+                           ImplementationRepository::AMH_AdministrationResponseHandler_ptr rh);
+  virtual ~ImR_Loc_ResponseHandler (void);
 
   virtual void send_ior (const char *pior);
-  virtual void send_exception (void);
+  virtual void send_exception (CORBA::Exception *ex);
 
 private:
-  ImplementationRepository::AMH_LocatorResponseHandler_var rh_;
+  Loc_Operation_Id op_id_;
+  ImplementationRepository::AMH_AdministrationResponseHandler_var resp_;
 
 };
 
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImR_ResponseHandler.cpp b/TAO/orbsvcs/ImplRepo_Service/ImR_ResponseHandler.cpp
new file mode 100644
index 00000000000..a77398ee72b
--- /dev/null
+++ b/TAO/orbsvcs/ImplRepo_Service/ImR_ResponseHandler.cpp
@@ -0,0 +1,27 @@
+//=============================================================================
+/**
+*  @file   ImR_ResponseHandler.cpp
+*
+*  $Id$
+*/
+//=============================================================================
+
+#include "ImR_ResponseHandler.h"
+
+ImR_ResponseHandler::ImR_ResponseHandler ()
+{
+}
+
+ImR_ResponseHandler::~ImR_ResponseHandler (void)
+{
+}
+
+void
+ImR_ResponseHandler::send_ior (const char *)
+{
+}
+
+void
+ImR_ResponseHandler::send_exception (CORBA::Exception *)
+{
+}
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImR_ResponseHandler.h b/TAO/orbsvcs/ImplRepo_Service/ImR_ResponseHandler.h
new file mode 100644
index 00000000000..c9c0fe7b9ff
--- /dev/null
+++ b/TAO/orbsvcs/ImplRepo_Service/ImR_ResponseHandler.h
@@ -0,0 +1,42 @@
+// -*- C++ -*-
+//=============================================================================
+/**
+ *  @file   ImR_ResponseHandler.h
+ *
+ *  $Id$
+ *
+ */
+//=============================================================================
+
+#ifndef IMR_RESPONSE_HANDLER_H
+#define IMR_RESPONSE_HANDLER_H
+
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/LocalObject.h"
+
+
+//----------------------------------------------------------------------------
+/**
+ * @class ImR_ResponseHandler
+ *
+ * @brief interface serving as the basis for different strategies of activating
+ * servers on demand
+ *
+ */
+
+class ImR_ResponseHandler
+{
+public:
+  ImR_ResponseHandler (void);
+  virtual ~ImR_ResponseHandler (void);
+
+  // dummy implementations used for internal operations
+  virtual void send_ior (const char *pior);
+  virtual void send_exception (CORBA::Exception *ex);
+};
+
+#endif /* IMR_RESPONSE_HANDLER_H */
diff --git a/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc b/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc
index 2c12b0b3d85..b752844467c 100644
--- a/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc
+++ b/TAO/orbsvcs/ImplRepo_Service/ImplRepo_Service.mpc
@@ -30,16 +30,9 @@ project(ImR_Locator_IDL) : orbsvcslib, orbsvcs_output, conv_lib, valuetype, port
     ImR_Locator.idl
   }
 
-  idl_files {
-    idlflags    += -GH -GC
-    AsyncStartupWaiter.idl
-  }
-
   source_files {
     ImR_LocatorS.cpp
     ImR_LocatorC.cpp
-    AsyncStartupWaiterS.cpp
-    AsyncStartupWaiterC.cpp
   }
   header_files {
     locator_idl_export.h
@@ -75,10 +68,10 @@ project(ImR_Locator) : orbsvcslib, orbsvcs_output, conv_lib, avoids_minimum_corb
   Source_Files {
     Activator_Info.cpp
     Adapter_Activator.cpp
-    AsyncStartupWaiter_i.cpp
     AsyncAccessManager.cpp
     Forwarder.cpp
     ImR_Locator_i.cpp
+    ImR_ResponseHandler.cpp
     INS_Locator.cpp
     LiveCheck.cpp
     Locator_XMLHandler.cpp