TAO/orbsvcs/ImplRepo_Service/ImR_Locator_i.cpp

   1 #include "orbsvcs/Log_Macros.h"
   2 #include "ImR_Locator_i.h"
   3 #include "utils.h"
   4 #include "Iterator.h"
   5 #include "INS_Locator.h"
   6 #include "UpdateableServerInfo.h"
   7
   8 #include "Locator_Repository.h"
   9 #include "Config_Backing_Store.h"
  10 #include "Shared_Backing_Store.h"
  11 #include "XML_Backing_Store.h"
  12
  13 #include "orbsvcs/Time_Utilities.h"
  14
  15 #include "tao/Messaging/Messaging.h"
  16 #include "tao/AnyTypeCode/Any.h"
  17 #include "tao/ORB_Core.h"
  18
  19 #include "ace/ARGV.h"
  20 #include "ace/OS_NS_sys_time.h"
  21 #include "ace/Vector_T.h"
  22 #include "ace/Task.h"
  23
  24 /// We want to give shutdown a little more time to work, so that we
  25 /// can guarantee to the tao_imr utility that it has shutdown. The tao_imr
  26 /// utility prints a different message depending on whether shutdown succeeds
  27 /// or times out.
  28 static const ACE_Time_Value DEFAULT_SHUTDOWN_TIMEOUT (0, 5000 * 1000);
  29
  30 static PortableServer::POA_ptr
  31 createPersistentPOA (PortableServer::POA_ptr root_poa, const char* poa_name) {
  32   PortableServer::LifespanPolicy_var life =
  33     root_poa->create_lifespan_policy (PortableServer::PERSISTENT);
  34
  35   PortableServer::IdAssignmentPolicy_var assign =
  36     root_poa->create_id_assignment_policy (PortableServer::USER_ID);
  37
  38   CORBA::PolicyList pols;
  39   pols.length (2);
  40   pols[0] = PortableServer::LifespanPolicy::_duplicate (life.in ());
  41   pols[1] = PortableServer::IdAssignmentPolicy::_duplicate (assign.in ());
  42
  43   PortableServer::POAManager_var mgr = root_poa->the_POAManager ();
  44   PortableServer::POA_var poa =
  45     root_poa->create_POA (poa_name, mgr.in (), pols);
  46
  47   life->destroy ();
  48   assign->destroy ();
  49
  50   return poa._retn ();
  51 }
  52
  53 int ImR_Locator_i::debug_ = 0;
  54
  55 ImR_Locator_i::ImR_Locator_i ()
  56   : dsi_forwarder_ (*this)
  57   , ins_locator_ (0)
  58   , aam_active_ ()
  59   , aam_terminating_ ()
  60   , opts_ (0)
  61   , lock_ ()
  62   , shutdown_handler_ (this)
  63 {
  64   // Visual C++ 6.0 is not smart enough to do a direct assignment
  65   // while allocating the INS_Locator.  So, we have to do it in
  66   // two steps.
  67   INS_Locator* locator;
  68   ACE_NEW (locator, INS_Locator (*this));
  69   ins_locator_ = locator;
  70 }
  71
  72 ImR_Locator_i::~ImR_Locator_i ()
  73 {
  74 }
  75
  76 int
  77 ImR_Locator_i::init_with_orb (CORBA::ORB_ptr orb)
  78 {
  79   this->orb_ = CORBA::ORB::_duplicate (orb);
  80   ImR_Locator_i::debug_ = this->opts_->debug ();
  81   CORBA::Object_var obj =
  82     this->orb_->resolve_initial_references ("RootPOA");
  83   this->root_poa_ = PortableServer::POA::_narrow (obj.in ());
  84   ACE_ASSERT (! CORBA::is_nil (this->root_poa_.in ()));
  85
  86   this->dsi_forwarder_.init (orb);
  87   this->adapter_.init (& this->dsi_forwarder_);
  88   this->pinger_.init (orb, this->opts_->ping_interval ());
  89
  90   this->opts_->pinger (&this->pinger_);
  91
  92   // Register the Adapter_Activator reference to be the RootPOA's
  93   // Adapter Activator.
  94   root_poa_->the_activator (&this->adapter_);
  95
  96   // Use a persistent POA so that any IOR
  97   this->imr_poa_ = createPersistentPOA (this->root_poa_.in (),
  98                                         "ImplRepo_Service");
  99   ACE_ASSERT (! CORBA::is_nil (this->imr_poa_.in ()));
 100
 101   PortableServer::ObjectId_var id =
 102     PortableServer::string_to_ObjectId ("ImplRepo_Service");
 103   this->imr_poa_->activate_object_with_id (id.in (), this);
 104
 105   obj = this->imr_poa_->id_to_reference (id.in ());
 106   ImplementationRepository::Locator_var locator =
 107     ImplementationRepository::Locator::_narrow (obj.in ());
 108   ACE_ASSERT(! CORBA::is_nil (locator.in ()));
 109   const CORBA::String_var ior = this->orb_->object_to_string (obj.in ());
 110
 111   // create the selected Locator_Repository with backing store
 112   switch (this->opts_->repository_mode ())
 113     {
 114     case Options::REPO_REGISTRY:
 115       {
 116         repository_.reset(new Registry_Backing_Store(*this->opts_, orb));
 117         break;
 118       }
 119     case Options::REPO_HEAP_FILE:
 120       {
 121         repository_.reset(new Heap_Backing_Store(*this->opts_, orb));
 122         break;
 123       }
 124     case Options::REPO_XML_FILE:
 125       {
 126         repository_.reset(new XML_Backing_Store(*this->opts_, orb));
 127         break;
 128       }
 129     case Options::REPO_SHARED_FILES:
 130       {
 131         repository_.reset(new Shared_Backing_Store(*this->opts_, orb, this));
 132         break;
 133       }
 134     case Options::REPO_NONE:
 135       {
 136         repository_.reset(new No_Backing_Store(*this->opts_, orb));
 137         break;
 138       }
 139     default:
 140       {
 141         bool invalid_rmode_specified = false;
 142         ACE_ASSERT (invalid_rmode_specified);
 143         ACE_UNUSED_ARG (invalid_rmode_specified);
 144         ORBSVCS_ERROR_RETURN ((
 145                                LM_ERROR, ACE_TEXT ("Repository failed to initialize\n")), -1);
 146       }
 147     }
 148
 149   // Register the ImR for use with INS
 150   obj = orb->resolve_initial_references ("AsyncIORTable");
 151   IORTable::Table_var ior_table = IORTable::Table::_narrow (obj.in ());
 152   ACE_ASSERT (! CORBA::is_nil (ior_table.in ()));
 153   ior_table->set_locator (this->ins_locator_.in ());
 154
 155   // Initialize the repository. This will load any values that
 156   // may have been persisted before.
 157   int result = this->repository_->init(this->root_poa_.in (),
 158                                        this->imr_poa_.in (),
 159                                        ior);
 160   if (result != 0)
 161     {
 162       return result;
 163     }
 164
 165   Locator_Repository::SIMap::ENTRY* entry = 0;
 166   Locator_Repository::SIMap::ITERATOR it (this->repository_->servers ());
 167
 168   for (;it.next (entry) != 0; it.advance ())
 169     {
 170       UpdateableServerInfo info (this->repository_, entry->int_id_);
 171       bool const is_alive = this->server_is_alive (info);
 172       Server_Info *active = info.edit()->active_info ();
 173       if (this->debug_ > 0)
 174         {
 175           ORBSVCS_DEBUG ((LM_DEBUG,
 176                           ACE_TEXT ("server <%C> is_alive = %d\n"),
 177                           active->ping_id(), is_alive));
 178         }
 179
 180       if (!is_alive)
 181         {
 182           // We have read an existing configuration from the repository
 183           // and when a server is not alive we reset it, it could have
 184           // been shutdown when we where offline. We don't know its process
 185           // id so pass zero
 186           this->pinger_.remove_server (active->ping_id(), 0);
 187           info.edit()->reset_runtime ();
 188           active->reset_runtime ();
 189           continue;
 190         }
 191
 192       active->death_notify = false;
 193       if (active->pid > 0)
 194         {
 195           Activator_Info_Ptr ainfo =
 196             this->get_activator (active->activator);
 197
 198           if (!(ainfo.null () || CORBA::is_nil (ainfo->activator.in ())))
 199             {
 200               ImplementationRepository::ActivatorExt_var actx =
 201                 ImplementationRepository::ActivatorExt::_narrow (ainfo->activator.in ());
 202               try
 203                 {
 204                   active->death_notify =
 205                     !CORBA::is_nil (actx.in ()) && actx->still_alive (active->pid);
 206                 }
 207               catch (const CORBA::Exception &)
 208                 {
 209                 }
 210               if (this->debug_ > 0)
 211                 {
 212                   ORBSVCS_DEBUG ((LM_DEBUG,
 213                                   ACE_TEXT ("activator says death_notify = %d\n"),
 214                                   active->death_notify));
 215                 }
 216             }
 217         }
 218     }
 219
 220   // Only after verifying do we report the IOR and become open for business
 221   return this->repository_->report_ior(this->imr_poa_.in ());
 222 }
 223
 224 int
 225 ImR_Locator_i::init (Options& opts)
 226 {
 227   this->opts_ = &opts;
 228   ACE_CString cmdline = opts.cmdline ();
 229   cmdline += " -orbuseimr 0";
 230   ACE_ARGV av (ACE_TEXT_CHAR_TO_TCHAR (cmdline.c_str ()));
 231   int argc = av.argc ();
 232   ACE_TCHAR** argv = av.argv ();
 233
 234   CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "TAO_ImR_Locator");
 235   int err = this->init_with_orb (orb.in ());
 236   return err;
 237 }
 238
 239 int
 240 ImR_Locator_i::run ()
 241 {
 242   if (debug_ > 0)
 243     {
 244       // This debug message was split into two calls to
 245       // work around yet another bug in Visual Studio 2005.
 246       // When this was a single debug message, the value for
 247       // debug () came out garbled and the read-only string
 248       // caused an ACCESS VIOLATION -- Chad Elliott 10/4/2006
 249       ORBSVCS_DEBUG ((LM_DEBUG,
 250                       ACE_TEXT ("Implementation Repository: Running\n")
 251                       ACE_TEXT ("\tPing Interval : %dms\n")
 252                       ACE_TEXT ("\tPing Timeout : %dms\n")
 253                       ACE_TEXT ("\tStartup Timeout : %ds\n")
 254                       ACE_TEXT ("\tPersistence : %s\n")
 255                       ACE_TEXT ("\tMulticast : %C\n"),
 256                       this->opts_->ping_interval ().msec (),
 257                       this->opts_->ping_timeout ().msec (),
 258                       this->opts_->startup_timeout ().sec (),
 259                       this->repository_->repo_mode (),
 260                       (this->repository_->multicast () != 0 ?
 261                        "Enabled" : "Disabled")));
 262       ORBSVCS_DEBUG ((LM_DEBUG,
 263                       ACE_TEXT ("\tDebug : %d\n")
 264                       ACE_TEXT ("\tReadOnly : %C\n\n"),
 265                       debug (),
 266                       (this->opts_->readonly () ? "True" : "False")));
 267     }
 268   this->auto_start_servers ();
 269
 270   this->orb_->run ();
 271
 272   return 0;
 273 }
 274
 275 void
 276 ImR_Locator_i::shutdown
 277 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
 278  CORBA::Boolean activators, CORBA::Boolean servers)
 279 {
 280   this->pinger_.shutdown ();
 281   this->aam_active_.reset ();
 282   this->aam_terminating_.reset ();
 283   if (servers != 0 && this->repository_->servers ().current_size () > 0)
 284     {
 285       // Note : shutdown is oneway, so we can't throw
 286       ORBSVCS_ERROR ((
 287                       LM_ERROR,
 288                       ACE_TEXT ("(%P|%t) ImR: Shutdown of all servers not implemented.\n")));
 289     }
 290   if (activators != 0 && this->repository_->activators ().current_size () > 0)
 291     {
 292       ACE_Vector<ImplementationRepository::Activator_var> acts;
 293       Locator_Repository::AIMap::ENTRY* entry = 0;
 294       Locator_Repository::AIMap::ITERATOR it (this->repository_->activators ());
 295       for (;it.next (entry) != 0; it.advance ())
 296         {
 297           Activator_Info_Ptr info = entry->int_id_;
 298           ACE_ASSERT (! info.null ());
 299           this->connect_activator (*info);
 300           if (! CORBA::is_nil (info->activator.in ()))
 301             acts.push_back (info->activator);
 302         }
 303
 304       int shutdown_errs = 0;
 305
 306       for (size_t i = 0; i < acts.size (); ++i)
 307         {
 308           try
 309             {
 310               acts[i]->shutdown ();
 311               acts[i] = ImplementationRepository::Activator::_nil ();
 312             }
 313           catch (const CORBA::Exception& ex)
 314             {
 315               ++shutdown_errs;
 316               if (debug_ > 1)
 317                 {
 318                   ex._tao_print_exception (ACE_TEXT ("(%P|%t) ImR: shutdown activator"));
 319                 }
 320             }
 321         }
 322       if (debug_ > 0 && shutdown_errs > 0)
 323         {
 324           ORBSVCS_DEBUG (( LM_DEBUG,
 325                            ACE_TEXT ("(%P|%t) ImR: Some activators could not be shut down.\n")));
 326         }
 327     }
 328   // Technically, we should wait for all the activators to unregister, but
 329   // ,for now at least, it doesn't seem worth it.
 330   this->shutdown (false);
 331
 332   _tao_rh->shutdown ();
 333 }
 334
 335 int
 336 ImR_Locator_i::Shutdown_Handler::handle_exception (ACE_HANDLE)
 337 {
 338   this->owner_->shutdown (false);
 339   return 0;
 340 }
 341
 342 void
 343 ImR_Locator_i::signal_shutdown ()
 344 {
 345   this->orb_->orb_core ()->reactor ()->notify (&this->shutdown_handler_);
 346 }
 347
 348 void
 349 ImR_Locator_i::shutdown (bool wait_for_completion)
 350 {
 351   this->repository_->shutdown ();
 352   this->orb_->shutdown (wait_for_completion);
 353 }
 354
 355 const Options *
 356 ImR_Locator_i::opts () const
 357 {
 358   return this->opts_;
 359 }
 360
 361 int
 362 ImR_Locator_i::fini ()
 363 {
 364   try
 365     {
 366       if (debug_ > 1)
 367         ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Shutting down...\n")));
 368
 369       this->root_poa_->destroy (1, 1);
 370
 371       this->orb_->destroy ();
 372
 373       if (debug_ > 0)
 374         ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Shut down successfully.\n")));
 375     }
 376   catch (const CORBA::Exception& ex)
 377     {
 378       ex._tao_print_exception (ACE_TEXT ("ImR_Locator_i::fini"));
 379       throw;
 380     }
 381   return 0;
 382 }
 383
 384 void
 385 ImR_Locator_i::register_activator
 386 (ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
 387  const char* aname,
 388  ImplementationRepository::Activator_ptr activator)
 389 {
 390   ACE_ASSERT (aname != 0);
 391   ACE_ASSERT (! CORBA::is_nil (activator));
 392
 393   // Before we can register the activator, we need to ensure that any existing
 394   // registration is purged.
 395   this->unregister_activator_i (aname);
 396
 397   CORBA::String_var ior =
 398     this->orb_->object_to_string (activator);
 399
 400   CORBA::Long token = ACE_OS::gettimeofday ().msec ();
 401
 402   int err = this->repository_->add_activator (aname, token, ior.in (), activator);
 403   ACE_ASSERT (err == 0);
 404   ACE_UNUSED_ARG (err);
 405
 406   if (debug_ > 0)
 407     ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Activator registered for %C.\n"),
 408                     aname));
 409
 410   _tao_rh->register_activator (token);
 411 }
 412
 413 void
 414 ImR_Locator_i::unregister_activator
 415 (ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
 416  const char* aname,
 417  CORBA::Long token)
 418 {
 419   ACE_ASSERT (aname != 0);
 420   Activator_Info_Ptr info = this->get_activator (aname);
 421
 422   if (! info.null ())
 423     {
 424       if (info->token != token && debug_ > 0)
 425         {
 426           ORBSVCS_DEBUG ((
 427                           LM_DEBUG,
 428                           ACE_TEXT ("(%P|%t) ImR: Ignoring unregister activator:%C. Wrong token.\n"),
 429                           aname));
 430           _tao_rh->unregister_activator ();
 431           return;
 432         }
 433
 434       this->unregister_activator_i (aname);
 435
 436       if (debug_ > 0)
 437         ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Activator %C unregistered.\n"),
 438                         aname));
 439     }
 440   else
 441     {
 442       if (debug_ > 0)
 443         ORBSVCS_DEBUG ((
 444                         LM_DEBUG,
 445                         ACE_TEXT ("(%P|%t) ImR: Ignoring unregister activator: %C. ")
 446                         ACE_TEXT ("Unknown activator.\n"),
 447                         aname));
 448     }
 449   _tao_rh->unregister_activator ();
 450 }
 451
 452 void
 453 ImR_Locator_i::unregister_activator_i (const char* aname)
 454 {
 455   int err = this->repository_->remove_activator (aname);
 456   ACE_UNUSED_ARG (err);
 457 }
 458
 459 void
 460 ImR_Locator_i::remote_access_update (const char *name,
 461                                      ImplementationRepository::AAM_Status state)
 462 {
 463   /*  ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_); */
 464   AsyncAccessManager_ptr aam (this->find_aam (name));
 465   if (aam.is_nil())
 466     {
 467       UpdateableServerInfo info (this->repository_, name);
 468       if (info.null ())
 469         {
 470           if (debug_ > 0)
 471             ORBSVCS_DEBUG ((LM_DEBUG,
 472                             ACE_TEXT ("(%P|%t) ImR: remote_acccess")
 473                             ACE_TEXT (" <%C> unregistered.\n"),
 474                             name));
 475           return;
 476         }
 477       aam = this->create_aam (info);
 478     }
 479   /* mon.release (); */
 480   aam->remote_state (state);
 481 }
 482
 483 void
 484 ImR_Locator_i::child_death_i (const char* name, int pid)
 485 {
 486   if (debug_ > 1)
 487     {
 488       ORBSVCS_DEBUG ((LM_DEBUG,
 489                       ACE_TEXT ("(%P|%t) ImR: Server <%C> has died with pid <%d>\n"),
 490                       name, pid));
 491     }
 492
 493   this->pinger_.remove_server (name, pid);
 494   AsyncAccessManager_ptr aam (this->find_aam (name, false));
 495   bool terminated = !aam.is_nil () && aam->notify_child_death (pid);
 496   aam = this->find_aam (name, true);
 497   if (!terminated && !aam.is_nil ())
 498     {
 499       terminated = aam->notify_child_death (pid);
 500     }
 501   UpdateableServerInfo info(this->repository_, name, pid);
 502   if (! info.null ())
 503     {
 504       info.edit ()->reset_runtime ();
 505     }
 506   else
 507     {
 508       if (debug_ > 1)
 509         {
 510           ORBSVCS_ERROR ((LM_ERROR,
 511                           ACE_TEXT ("(%P|%t) ImR: Failed to find server/pid in repository.\n")));
 512         }
 513     }
 514 }
 515
 516 void
 517 ImR_Locator_i::child_death_pid
 518 (ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
 519  const char* name, CORBA::Long pid)
 520 {
 521   this->child_death_i (name, pid);
 522   _tao_rh->child_death_pid ();
 523 }
 524
 525 void
 526 ImR_Locator_i::spawn_pid
 527 (ImplementationRepository::AMH_LocatorResponseHandler_ptr _tao_rh,
 528  const char* name, CORBA::Long pid)
 529 {
 530   if (debug_ > 1)
 531     {
 532       ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Server <%C> spawned with pid <%d>.\n"),
 533                       name, pid));
 534     }
 535
 536   UpdateableServerInfo info(this->repository_, name);
 537   if (!info.null ())
 538     {
 539       if (debug_ > 4)
 540         {
 541           ORBSVCS_DEBUG ((LM_DEBUG,
 542                           ACE_TEXT ("(%P|%t) ImR: Server <%C> spawn_pid prev pid was <%d> becoming <%d>\n"),
 543                           name, info.edit ()->active_info ()->pid, pid));
 544         }
 545
 546       AsyncAccessManager_ptr aam (this->find_aam (name, true));
 547       if (aam.is_nil ())
 548         {
 549           aam = this->find_aam (name, false);
 550         }
 551       else
 552         {
 553           aam->update_prev_pid ();
 554         }
 555       info.edit ()->active_info ()->pid = pid;
 556       info.edit ()->active_info ()->death_notify = true;
 557     }
 558   else
 559     {
 560       if (debug_ > 1)
 561         {
 562           ORBSVCS_ERROR ((LM_ERROR,
 563                           ACE_TEXT ("(%P|%t) ImR: Failed to find server <%C> in repository\n"),
 564                           name));
 565         }
 566     }
 567   this->pinger_.set_pid (name, pid);
 568
 569   _tao_rh->spawn_pid ();
 570 }
 571
 572 char*
 573 ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start)
 574 {
 575   ImR_SyncResponseHandler rh ("", this->orb_.in());
 576   this->activate_server_by_name (name, manual_start, &rh);
 577   return rh.wait_for_result ();
 578 }
 579
 580 char*
 581 ImR_Locator_i::activate_server_by_object (const char* object_name)
 582 {
 583   Server_Info_Ptr si;
 584   ACE_CString key;
 585   ACE_CString full (object_name);
 586   if (this->split_key (full, key, si))
 587     {
 588       ImR_SyncResponseHandler rh (key.c_str(), this->orb_.in());
 589       this->activate_server_by_info (si, &rh);
 590       return rh.wait_for_result ();
 591     }
 592   throw ImplementationRepository::NotFound();
 593 }
 594
 595 void
 596 ImR_Locator_i::activate_server
 597 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
 598  const char* server)
 599 {
 600   if (debug_ > 1)
 601     {
 602       ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Manually activating server <%C>\n"),
 603                       server));
 604     }
 605
 606   ImR_ResponseHandler *rh = 0;
 607   ACE_NEW (rh,
 608            ImR_Loc_ResponseHandler (ImR_Loc_ResponseHandler::LOC_ACTIVATE_SERVER,
 609                                     _tao_rh));
 610
 611   // This is the version called by tao_imr to activate the server, manually
 612   // starting it if necessary.
 613   activate_server_by_name (server, true, rh);
 614 }
 615
 616 bool
 617 ImR_Locator_i::get_info_for_name (const char* name, Server_Info_Ptr &si)
 618 {
 619   si = this->repository_->get_active_server (name);
 620   return !si.null();
 621 }
 622
 623 bool
 624 ImR_Locator_i::split_key (ACE_CString &full, ACE_CString &key, Server_Info_Ptr &si)
 625 {
 626   key = full;
 627   if (this->get_info_for_name (full.c_str(), si))
 628     {
 629       return true;
 630     }
 631
 632   ACE_CString::size_type pos = full.rfind ('/');
 633   while (pos != ACE_CString::npos)
 634     {
 635       ACE_CString server = full.substring (0, pos);
 636       if (this->get_info_for_name (server.c_str (), si))
 637         {
 638           return true;
 639         }
 640       pos = server.rfind ('/');
 641     }
 642
 643   return false;
 644 }
 645
 646 void
 647 ImR_Locator_i::activate_server_by_name (const char* name, bool manual_start,
 648                                         ImR_ResponseHandler *rh)
 649 {
 650   // Activate the server, starting it if necessary. Don't start MANUAL
 651   // servers unless manual_start=true
 652   UpdateableServerInfo info (this->repository_, name);
 653   if (info.null ())
 654     {
 655       rh->send_exception ( new ImplementationRepository::NotFound );
 656     }
 657   else
 658     {
 659       this->activate_server_i (info, manual_start, rh);
 660     }
 661 }
 662
 663 void
 664 ImR_Locator_i::activate_server_by_info (const Server_Info_Ptr &si,
 665                                         ImR_ResponseHandler *rh)
 666 {
 667   UpdateableServerInfo info (this->repository_, si, true);
 668   this->activate_server_i (info, false, rh);
 669 }
 670
 671 void
 672 ImR_Locator_i::activate_server_i (UpdateableServerInfo& info,
 673                                   bool manual_start,
 674                                   ImR_ResponseHandler *rh)
 675 {
 676   AsyncAccessManager_ptr aam;
 677   if (info->is_mode(ImplementationRepository::PER_CLIENT))
 678     {
 679       ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
 680       aam = this->create_aam (info);
 681     }
 682   else
 683     {
 684       aam = this->find_aam (info->ping_id ());
 685       if (aam.is_nil())
 686         {
 687           ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
 688           aam = this->create_aam (info);
 689         }
 690     }
 691   aam->add_interest (rh, manual_start);
 692 }
 693
 694 CORBA::Object_ptr
 695 ImR_Locator_i::set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value& to)
 696 {
 697   CORBA::Object_var ret (CORBA::Object::_duplicate (obj));
 698
 699   try
 700     {
 701       TimeBase::TimeT timeout;
 702       ORBSVCS_Time::Time_Value_to_TimeT (timeout, to);
 703       CORBA::Any tmp;
 704       tmp <<= timeout;
 705
 706       CORBA::PolicyList policies (1);
 707       policies.length (1);
 708       policies[0] = orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
 709                                          tmp);
 710
 711       ret = obj->_set_policy_overrides (policies, CORBA::ADD_OVERRIDE);
 712
 713       policies[0]->destroy ();
 714
 715       if (CORBA::is_nil (ret.in ()))
 716         {
 717           if (debug_ > 0)
 718             {
 719               ORBSVCS_DEBUG ((LM_DEBUG,
 720                               ACE_TEXT ("(%P|%t) ImR: Unable to set timeout policy.\n")));
 721             }
 722           ret = CORBA::Object::_duplicate (obj);
 723         }
 724     }
 725   catch (const CORBA::Exception& ex)
 726     {
 727       if (debug_ > 0)
 728         {
 729           ex._tao_print_exception (ACE_TEXT ("(%P|%t) ImR_Locator_i::set_timeout_policy ()"));
 730         }
 731     }
 732
 733   return ret._retn ();
 734 }
 735
 736 void
 737 ImR_Locator_i::add_or_update_server
 738 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
 739  const char* server,
 740  const ImplementationRepository::StartupOptions &options)
 741 {
 742   if (this->opts_->readonly ())
 743     {
 744       ORBSVCS_DEBUG ((LM_DEBUG,
 745                       ACE_TEXT ("(%P|%t) ImR: Cannot add/update server <%C> due to locked ")
 746                       ACE_TEXT ("database.\n"),
 747                       server));
 748       CORBA::Exception *ex =
 749         new CORBA::NO_PERMISSION (CORBA::SystemException::_tao_minor_code
 750                                   (TAO_IMPLREPO_MINOR_CODE,0),
 751                                   CORBA::COMPLETED_NO);
 752       ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
 753       _tao_rh->add_or_update_server_excep (&h);
 754       return;
 755     }
 756
 757   if (debug_ > 0)
 758     ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Add/Update server <%C>\n"), server));
 759
 760   UpdateableServerInfo info(this->repository_, server);
 761   if (info.null ())
 762     {
 763       if (debug_ > 1)
 764         ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Adding server <%C>\n"), server));
 765
 766       this->repository_->add_server (server, options);
 767     }
 768   else
 769     {
 770       if (debug_ > 1)
 771         ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Updating server <%C>\n"),
 772                         server));
 773
 774       info.edit ()->update_options (options);
 775       info.update_repo();
 776     }
 777
 778   if (debug_ > 1)
 779     {
 780       // Note : The info var may be null, so we use options.
 781       ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Server: <%C>\n")
 782                       ACE_TEXT ("\tActivator: <%C>\n")
 783                       ACE_TEXT ("\tCommand Line: <%C>\n")
 784                       ACE_TEXT ("\tWorking Directory: <%C>\n")
 785                       ACE_TEXT ("\tActivation: <%C>\n")
 786                       ACE_TEXT ("\tStart Limit: <%d>\n"),
 787                       server,
 788                       options.activator.in (),
 789                       options.command_line.in (),
 790                       options.working_directory.in (),
 791                       ImR_Utils::activationModeToString (options.activation),
 792                       options.start_limit
 793                       ));
 794
 795       for (CORBA::ULong i = 0; i < options.environment.length (); ++i)
 796         ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("Environment variable <%C>=<%C>\n"),
 797                         options.environment[i].name.in (),
 798                         options.environment[i].value.in ()));
 799     }
 800
 801   _tao_rh->add_or_update_server ();
 802 }
 803
 804 void
 805 ImR_Locator_i::link_servers
 806 (ImplementationRepository::AMH_AdministrationExtResponseHandler_ptr _tao_rh,
 807  const char * name,
 808  const CORBA::StringSeq & peers)
 809 {
 810   Server_Info_Ptr root_si = this->repository_->get_active_server (name);
 811   if (root_si.null())
 812     {
 813       CORBA::Exception *ex =
 814         new ImplementationRepository::NotFound;
 815       ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
 816       _tao_rh->link_servers_excep (&h);
 817       return;
 818     }
 819   else if (!root_si->alt_info_.null())
 820     {
 821       ACE_CString errstr = name;
 822       errstr += " is not a base POA";
 823       CORBA::Exception *ex =
 824         new ImplementationRepository::CannotComplete (errstr.c_str());
 825       ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
 826       _tao_rh->link_servers_excep (&h);
 827       return;
 828     }
 829
 830   for (CORBA::ULong i = 0; i < peers.length(); i++)
 831     {
 832       ACE_CString peer(peers[i]);
 833       Server_Info_Ptr si = this->repository_->get_active_server (peer);
 834       if (!si.null ())
 835         {
 836           ACE_CString errstr(peers[i]);
 837           errstr += " is already registered";
 838           CORBA::Exception *ex =
 839             new ImplementationRepository::CannotComplete (errstr.c_str());
 840           ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
 841           _tao_rh->link_servers_excep (&h);
 842           return;
 843         }
 844     }
 845
 846   this->repository_->link_peers (root_si, peers);
 847
 848   _tao_rh->link_servers ();
 849   return;
 850 }
 851
 852 bool
 853 ImR_Locator_i::kill_server_i (const Server_Info_Ptr &si,
 854                               CORBA::Short signum,
 855                               CORBA::Exception *& ex)
 856 {
 857   if (si->is_mode(ImplementationRepository::PER_CLIENT))
 858     {
 859       ex = new ImplementationRepository::CannotComplete ("per-client server");
 860       return false;
 861     }
 862
 863   Activator_Info_Ptr ainfo = this->get_activator (si->activator);
 864   if (ainfo.null ())
 865     {
 866       ex = new ImplementationRepository::CannotComplete ("no activator");
 867       return false;
 868     }
 869
 870   ImplementationRepository::ActivatorExt_var actext =
 871     ImplementationRepository::ActivatorExt::_narrow (ainfo->activator.in());
 872
 873   if (CORBA::is_nil (actext.in()))
 874     {
 875       ex = new ImplementationRepository::CannotComplete ("activator incompatible");
 876       return false;
 877     }
 878   return actext->kill_server (si->key_name_.c_str(), si->pid, signum);
 879 }
 880
 881 void
 882 ImR_Locator_i::kill_server
 883 (ImplementationRepository::AMH_AdministrationExtResponseHandler_ptr _tao_rh,
 884  const char * name, CORBA::Short signum)
 885 {
 886   CORBA::Exception *ex = 0;
 887   Server_Info_Ptr si;
 888   if (!this->get_info_for_name (name, si))
 889     {
 890       ex = new ImplementationRepository::NotFound;
 891     }
 892   else
 893     {
 894       if (!si->alt_info_.null ())
 895         {
 896           si = si->alt_info_;
 897         }
 898       if (!this->kill_server_i (si, signum, ex))
 899         {
 900           if (ex == 0)
 901             {
 902               ex = new ImplementationRepository::CannotComplete ("server not running");
 903             }
 904         }
 905     }
 906   if (ex != 0)
 907     {
 908       ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
 909       _tao_rh->kill_server_excep (&h);
 910       return;
 911     }
 912
 913   _tao_rh->kill_server ();
 914   AsyncAccessManager_ptr aam = this->find_aam (si->key_name_.c_str ());
 915   if (!aam.is_nil ())
 916     {
 917       aam->shutdown_initiated ();
 918     }
 919 }
 920
 921 void
 922 ImR_Locator_i::remove_server_i (const Server_Info_Ptr &info)
 923 {
 924   if (debug_ > 1)
 925   {
 926     ORBSVCS_DEBUG ((LM_DEBUG,
 927                     ACE_TEXT ("(%P|%t) ImR: Removing Server <%C>...\n"),
 928                     info->key_name_.c_str()));
 929   }
 930
 931   ACE_CString poa_name = info->poa_name;
 932   if (this->repository_->remove_server (info->key_name_, this) == 0)
 933     {
 934       this->destroy_poa (poa_name);
 935       if (debug_ > 0)
 936       {
 937         ORBSVCS_DEBUG ((LM_DEBUG,
 938                         ACE_TEXT ("(%P|%t) ImR: Removed Server <%C>.\n"),
 939                         info->key_name_.c_str()));
 940       }
 941     }
 942   else
 943     {
 944       if (debug_ > 0)
 945       {
 946         ORBSVCS_ERROR ((LM_ERROR,
 947                         ACE_TEXT ("(%P|%t) ImR: Cannot find server <%C>.\n"),
 948                         info->key_name_.c_str()));
 949       }
 950     }
 951 }
 952
 953 void
 954 ImR_Locator_i::remove_server
 955 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
 956  const char* id)
 957 {
 958   if (this->opts_->readonly ())
 959     {
 960       ORBSVCS_ERROR ((LM_ERROR,
 961                       ACE_TEXT ("(%P|%t) ImR: Can't remove server <%C> due to locked database.\n"),
 962                       id));
 963       CORBA::Exception *ex =
 964         new CORBA::NO_PERMISSION (CORBA::SystemException::_tao_minor_code
 965                                   (TAO_IMPLREPO_MINOR_CODE, 0),
 966                                   CORBA::COMPLETED_NO);
 967       ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
 968       _tao_rh->remove_server_excep (&h);
 969       return;
 970     }
 971
 972   Server_Info_Ptr info = this->repository_->get_active_server (id);
 973   if (! info.null ())
 974     {
 975       AsyncAccessManager_ptr aam(this->find_aam  (info->key_name_.c_str()));
 976       if (!aam.is_nil())
 977         {
 978           if (debug_ > 0)
 979             ORBSVCS_DEBUG ((LM_DEBUG,
 980                             ACE_TEXT ("(%P|%t) ImR: Can't remove active server <%C>.\n"),
 981                             info->key_name_.c_str()));
 982           CORBA::Exception *ex =
 983             new CORBA::NO_PERMISSION (CORBA::SystemException::_tao_minor_code
 984                                       (TAO_IMPLREPO_MINOR_CODE, EBUSY),
 985                                       CORBA::COMPLETED_NO);
 986           ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
 987           _tao_rh->remove_server_excep (&h);
 988           return;
 989         }
 990       this->remove_server_i (info);
 991     }
 992   else
 993     {
 994       ORBSVCS_ERROR ((LM_ERROR,
 995                       ACE_TEXT ("(%P|%t) ImR: Can't remove unknown server <%C>.\n"), id));
 996       CORBA::Exception *ex = new ImplementationRepository::NotFound;
 997       ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
 998       _tao_rh->remove_server_excep (&h);
 999       return;
1000     }
1001   _tao_rh->remove_server ();
1002 }
1003
1004 void
1005 ImR_Locator_i::force_remove_server
1006 (ImplementationRepository::AMH_AdministrationExtResponseHandler_ptr _tao_rh,
1007  const char *name, CORBA::Short signum)
1008 {
1009   CORBA::Exception *ex = 0;
1010   Server_Info_Ptr si;
1011   AsyncAccessManager_ptr aam;
1012   if (this->opts_->readonly ())
1013     {
1014       ORBSVCS_ERROR ((LM_ERROR,
1015                       ACE_TEXT ("(%P|%t) ImR: Can't remove server <%C> due to locked database.\n"),
1016                       name));
1017       ex =
1018         new CORBA::NO_PERMISSION (CORBA::SystemException::_tao_minor_code
1019                                   (TAO_IMPLREPO_MINOR_CODE, 0),
1020                                   CORBA::COMPLETED_NO);
1021       ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
1022       _tao_rh->force_remove_server_excep (&h);
1023       return;
1024     }
1025
1026
1027   if (!this->get_info_for_name (name, si))
1028     {
1029       ex = new ImplementationRepository::NotFound;
1030       ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
1031       _tao_rh->force_remove_server_excep (&h);
1032       return;
1033     }
1034
1035   if (!si->alt_info_.null ())
1036     {
1037       si = si->alt_info_;
1038     }
1039   aam = this->find_aam (si->key_name_.c_str ());
1040   if (aam.is_nil ())
1041     {
1042       this->remove_server_i (si);
1043       _tao_rh->force_remove_server ();
1044       return;
1045     }
1046
1047   ImR_ResponseHandler *aam_rh =
1048     new ImR_Loc_ResponseHandler (ImR_Loc_ResponseHandler::LOC_FORCE_REMOVE_SERVER,
1049                                  _tao_rh);
1050   if (aam->force_remove_rh (aam_rh))
1051     {
1052       delete aam_rh;
1053       _tao_rh->force_remove_server ();
1054       return;
1055     }
1056
1057   bool active = (signum > 0) ?
1058     this->kill_server_i (si, signum, ex) :
1059     this->shutdown_server_i (si, ex, true);
1060
1061   if (ex != 0)
1062     {
1063       ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
1064       _tao_rh->force_remove_server_excep (&h);
1065       aam->force_remove_rh (0);
1066       return;
1067     }
1068   if (active)
1069     {
1070       aam->shutdown_initiated ();
1071     }
1072   else
1073     {
1074       aam->force_remove_rh (0);
1075       remove_server_i (si);
1076       _tao_rh->force_remove_server ();
1077     }
1078 }
1079
1080 void
1081 ImR_Locator_i::destroy_poa (const ACE_CString &poa_name)
1082 {
1083   PortableServer::POA_var poa = findPOA (poa_name.c_str());
1084   if (! CORBA::is_nil (poa.in ()))
1085     {
1086       bool etherealize = true;
1087       bool wait = false;
1088       poa->destroy (etherealize, wait);
1089     }
1090 }
1091
1092
1093 PortableServer::POA_ptr
1094 ImR_Locator_i::findPOA (const char* name)
1095 {
1096   try
1097     {
1098       bool activate_it = false;
1099       return root_poa_->find_POA (name, activate_it);
1100     }
1101   catch (const CORBA::Exception&)
1102     {// Ignore
1103     }
1104   return PortableServer::POA::_nil ();
1105 }
1106
1107 bool
1108 ImR_Locator_i::shutdown_server_i (const Server_Info_Ptr &si,
1109                                   CORBA::Exception *&ex_ret,
1110                                   bool force)
1111 {
1112   const CORBA::ULong TAO_MINOR_MASK = 0x00000f80;
1113   const char *id = si->key_name_.c_str();
1114   if (debug_ > 0)
1115     ORBSVCS_DEBUG ((LM_DEBUG,
1116                     ACE_TEXT ("(%P|%t) ImR: Shutting down server <%C>.\n"),
1117                     id));
1118
1119   UpdateableServerInfo info (this->repository_, si);
1120   if (info.null ())
1121     {
1122       ORBSVCS_ERROR ((LM_ERROR,
1123                       ACE_TEXT ("(%P|%t) ImR: shutdown_server () ")
1124                       ACE_TEXT ("Cannot find info for server <%C>\n"),
1125                       id));
1126       ex_ret = new ImplementationRepository::NotFound;
1127       return false;
1128     }
1129
1130   this->connect_server (info);
1131
1132   if (CORBA::is_nil (info->active_info()->server.in ()))
1133     {
1134       ORBSVCS_ERROR ((LM_ERROR,
1135                       ACE_TEXT ("(%P|%t) ImR: shutdown_server ()")
1136                       ACE_TEXT (" Cannot connect to server <%C>\n"),
1137                       id));
1138       ex_ret = new ImplementationRepository::NotFound;
1139       return false;
1140     }
1141
1142   try
1143     {
1144       CORBA::Object_var obj = this->set_timeout_policy (info->active_info()->server.in (),
1145                                                         DEFAULT_SHUTDOWN_TIMEOUT);
1146       ImplementationRepository::ServerObject_var server =
1147         ImplementationRepository::ServerObject::_unchecked_narrow (obj.in ());
1148       if (CORBA::is_nil(server.in ()))
1149         {
1150           if (debug_ > 1)
1151             {
1152               ORBSVCS_DEBUG ((LM_DEBUG,
1153                               ACE_TEXT ("(%P|%t) ImR: ServerObject reference with timeout is nil.\n")));
1154               return false;
1155             }
1156         }
1157       else
1158         {
1159           server->shutdown ();
1160           return true;
1161         }
1162     }
1163   catch (const CORBA::TIMEOUT &ex)
1164     {
1165       info.edit ()->reset_runtime ();
1166       // Note : This is a good thing. It means we didn't waste our time waiting for
1167       // the server to finish shutting down.
1168       if (debug_ > 1)
1169         {
1170           ORBSVCS_DEBUG ((LM_DEBUG,
1171                           ACE_TEXT ("(%P|%t) ImR: Timeout while waiting for <%C> shutdown.\n"),
1172                           id));
1173         }
1174       if (!force && this->opts_->throw_shutdown_exceptions ())
1175         {
1176           ex_ret = ex._tao_duplicate();
1177         }
1178     }
1179   catch (const CORBA::COMM_FAILURE& ex)
1180     {
1181       info.edit ()->reset_runtime ();
1182       if (debug_ > 1)
1183         {
1184           ORBSVCS_DEBUG ((LM_DEBUG,
1185                           ACE_TEXT ("ImR: COMM_FAILURE while waiting for <%C> shutdown.\n"),
1186                           id));
1187         }
1188       if (!force && this->opts_->throw_shutdown_exceptions ())
1189         {
1190           ex_ret = ex._tao_duplicate();
1191         }
1192     }
1193   catch (const CORBA::TRANSIENT& ex)
1194     {
1195       CORBA::ULong const minor = ex.minor () & TAO_MINOR_MASK;
1196       if (minor != TAO_POA_DISCARDING && minor != TAO_POA_HOLDING)
1197         {
1198           info.edit ()->reset_runtime ();
1199         }
1200       if (debug_ > 1)
1201         {
1202           ORBSVCS_DEBUG ((LM_DEBUG,
1203                           ACE_TEXT ("ImR: TRANSIENT while waiting for <%C> shutdown.\n"),
1204                           id));
1205         }
1206       if (!force && this->opts_->throw_shutdown_exceptions ())
1207         {
1208           ex_ret = ex._tao_duplicate();
1209         }
1210     }
1211   catch (const CORBA::Exception &ex)
1212     {
1213       if (debug_ > 1)
1214         {
1215           ORBSVCS_DEBUG ((LM_DEBUG,
1216                           ACE_TEXT ("(%P|%t) ImR: Exception while shutting down <%C>\n"),
1217                           id));
1218         }
1219       if (!force && this->opts_->throw_shutdown_exceptions ())
1220         {
1221           ex_ret = ex._tao_duplicate();
1222         }
1223     }
1224   return false;
1225 }
1226
1227 void
1228 ImR_Locator_i::shutdown_server
1229 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
1230  const char* name)
1231 {
1232   CORBA::Exception *ex = 0;
1233   Server_Info_Ptr si;
1234
1235   if (!this->get_info_for_name (name, si))
1236     {
1237       ex = new ImplementationRepository::NotFound;
1238       ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
1239       _tao_rh->shutdown_server_excep (&h);
1240       return;
1241     }
1242
1243   if (this->shutdown_server_i (si, ex, false))
1244     {
1245       AsyncAccessManager_ptr aam = this->find_aam (si->ping_id ());
1246       if (!aam.is_nil())
1247         {
1248           aam->shutdown_initiated ();
1249         }
1250     }
1251   if (ex != 0)
1252     {
1253       ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
1254       _tao_rh->shutdown_server_excep (&h);
1255     }
1256   else
1257     {
1258       _tao_rh->shutdown_server ();
1259     }
1260 }
1261
1262 void
1263 ImR_Locator_i::server_is_running
1264 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
1265  const char* id,
1266  const char* partial_ior,
1267  ImplementationRepository::ServerObject_ptr server_object)
1268 {
1269   if (debug_ > 0)
1270     {
1271       ORBSVCS_DEBUG ((LM_DEBUG,
1272                       ACE_TEXT ("(%P|%t) ImR: Server <%C> is running at <%C>\n"),
1273                       id, partial_ior));
1274     }
1275   CORBA::String_var sior = orb_->object_to_string (server_object);
1276
1277   if (debug_ > 1)
1278     {
1279       ORBSVCS_DEBUG ((LM_DEBUG,
1280                       ACE_TEXT ("(%P|%t) ImR: Server <%C> callback at <%C>\n"),
1281                       id, sior.in ()));
1282     }
1283
1284   if (this->opts_->unregister_if_address_reused ())
1285     this->repository_->unregister_if_address_reused (id, partial_ior, this);
1286
1287   CORBA::Object_var obj = this->set_timeout_policy (server_object, this->opts_->ping_timeout ());
1288   ImplementationRepository::ServerObject_var srvobj =
1289     ImplementationRepository::ServerObject::_narrow (obj.in());
1290
1291   UpdateableServerInfo info (this->repository_, id);
1292   if (info.null ())
1293     {
1294       if (debug_ > 0)
1295         {
1296           ORBSVCS_DEBUG ((LM_DEBUG,
1297                           ACE_TEXT ("(%P|%t) ImR: Auto adding NORMAL server <%C>\n"),
1298                           id));
1299         }
1300
1301       Server_Info_Ptr si;
1302       if (this->repository_->add_server (id, partial_ior, sior.in (), srvobj.in ()) == 0)
1303         {
1304           si = this->repository_->get_active_server (id);
1305         }
1306
1307       if (si.null ())
1308         {
1309           if (debug_ > 0)
1310             {
1311               ORBSVCS_DEBUG ((LM_DEBUG,
1312                               ACE_TEXT ("(%P|%t) ImR: Auto adding failed, giving up <%C>\n"),
1313                               id));
1314             }
1315           CORBA::NO_MEMORY ex;
1316           ImplementationRepository::AMH_AdministrationExceptionHolder h (ex._tao_duplicate());
1317           _tao_rh->server_is_running_excep (&h);
1318           return;
1319         }
1320       info.server_info (si);
1321       this->pinger_.add_server (si->ping_id (), this->opts_->ping_external (), srvobj.in(), info->active_info ()->pid);
1322
1323       ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
1324       AsyncAccessManager_ptr aam (this->create_aam (info, true));
1325     }
1326   else
1327     {
1328       if (ImR_Locator_i::debug () > 4)
1329         {
1330           ORBSVCS_DEBUG ((LM_DEBUG,
1331                           ACE_TEXT ("(%P|%t) ImR_Locator_i::server_is_running <%C> has mode <%C>\n"),
1332                           id, ImR_Utils::activationModeToString(info->mode ())));
1333         }
1334
1335       AsyncAccessManager_ptr aam;
1336       if (!info->is_mode(ImplementationRepository::PER_CLIENT))
1337         {
1338           info.edit ()->set_contact (partial_ior, sior.in(), srvobj.in());
1339
1340           info.update_repo();
1341           // Add the server to our pinger list
1342           this->pinger_.add_server (info->ping_id(), true, srvobj.in(), info->pid);
1343
1344           aam = this->find_aam (info->ping_id ());
1345         }
1346       else
1347         {
1348           // In case of a per client activation there could be multiple AAM for a specific server (ping_id)
1349           // we need to make sure we take an AAM that is not running yet
1350           aam = this->find_not_running_aam  (info->ping_id ());
1351         }
1352
1353       if (!aam.is_nil())
1354         {
1355           if (ImR_Locator_i::debug () > 4)
1356             {
1357               ORBSVCS_DEBUG ((LM_DEBUG,
1358                               ACE_TEXT ("(%P|%t) ImR_Locator_i::server_is_running <%C> aam is not nil\n"),
1359                               id));
1360             }
1361           aam->server_is_running (partial_ior, srvobj.in());
1362         }
1363       else
1364         {
1365           if (ImR_Locator_i::debug () > 4)
1366             {
1367               ORBSVCS_DEBUG ((LM_DEBUG,
1368                               ACE_TEXT ("(%P|%t) ImR_Locator_i::server_is_running <%C> aam is nil\n"),
1369                               id));
1370             }
1371           if (!info->is_mode(ImplementationRepository::PER_CLIENT))
1372             {
1373               ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
1374               aam = this->create_aam (info, true);
1375             }
1376         }
1377     }
1378   _tao_rh->server_is_running ();
1379 }
1380
1381 void
1382 ImR_Locator_i::server_is_shutting_down
1383 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
1384  const char* fqname)
1385 {
1386   UpdateableServerInfo info (this->repository_, fqname);
1387   if (info.null ())
1388     {
1389       if (debug_ > 1)
1390         {
1391           ORBSVCS_DEBUG ((LM_DEBUG,
1392                           ACE_TEXT ("(%P|%t) ImR_Locator_i::server_is_shutting_down: ")
1393                           ACE_TEXT ("Unknown server <%C>\n"),
1394                           fqname));
1395         }
1396       _tao_rh->server_is_shutting_down ();
1397       return;
1398     }
1399
1400   if (debug_ > 0)
1401     {
1402       ORBSVCS_DEBUG ((LM_DEBUG,
1403                       ACE_TEXT ("(%P|%t) ImR: Server <%C> is shutting down\n"),
1404                       fqname));
1405     }
1406
1407   if (!info->is_mode(ImplementationRepository::PER_CLIENT))
1408     {
1409       this->pinger_.remove_server (info->ping_id(), info->pid);
1410       {
1411         AsyncAccessManager_ptr aam = this->find_aam (info->ping_id (), false);
1412         if (aam.is_nil())
1413           {
1414             aam = this->find_aam(info->ping_id(), true);
1415           }
1416         if (!aam.is_nil())
1417           {
1418             aam->server_is_shutting_down ();
1419           }
1420       }
1421     }
1422   info.edit ()->reset_runtime ();
1423   _tao_rh->server_is_shutting_down ();
1424 }
1425
1426 void
1427 ImR_Locator_i::find
1428 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
1429  const char* id)
1430 {
1431   Server_Info_Ptr si = this->repository_->get_active_server (id);
1432   ImplementationRepository::ServerInformation_var imr_info;
1433   try
1434     {
1435       if (! si.null ())
1436         {
1437           imr_info = si->createImRServerInfo ();
1438
1439           if (debug_ > 1)
1440             ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) ImR: Found server <%C>\n"), id));
1441         }
1442       else
1443         {
1444           ACE_NEW_THROW_EX (imr_info,
1445                             ImplementationRepository::ServerInformation,
1446                             CORBA::NO_MEMORY ());
1447           imr_info->startup.activation= ImplementationRepository::NORMAL;
1448           if (debug_ > 1)
1449             ORBSVCS_DEBUG ((LM_DEBUG,
1450                             ACE_TEXT ("(%P|%t) ImR: Cannot find server <%C>\n"),
1451                             id));
1452         }
1453     }
1454   catch (const CORBA::Exception &ex)
1455     {
1456       ImplementationRepository::AMH_AdministrationExceptionHolder h (ex._tao_duplicate());
1457       _tao_rh->find_excep (&h);
1458       return;
1459     }
1460   _tao_rh->find (imr_info.in());
1461 }
1462
1463 void
1464 ImR_Locator_i::list
1465 (ImplementationRepository::AMH_AdministrationResponseHandler_ptr _tao_rh,
1466  CORBA::ULong how_many,
1467  CORBA::Boolean active)
1468 {
1469   AsyncListManager *l = 0;
1470   try
1471     {
1472       ACE_NEW_THROW_EX (l,
1473                         AsyncListManager (this->repository_.get(),
1474                                           this->root_poa_.in(),
1475                                           active ? &this->pinger_ : 0),
1476                         CORBA::NO_MEMORY ());
1477       AsyncListManager_ptr lister (l);
1478       l->list (_tao_rh, how_many);
1479     }
1480   catch (const CORBA::Exception &ex)
1481     {
1482       ImplementationRepository::AMH_AdministrationExceptionHolder h (ex._tao_duplicate());
1483       _tao_rh->find_excep (&h);
1484       return;
1485     }
1486 }
1487
1488 Activator_Info_Ptr
1489 ImR_Locator_i::get_activator (const ACE_CString& aname)
1490 {
1491   Activator_Info_Ptr info = this->repository_->get_activator (aname);
1492   if (! info.null ())
1493     {
1494       this->connect_activator (*info);
1495     }
1496   return info;
1497 }
1498
1499 void
1500 ImR_Locator_i::connect_activator (Activator_Info& info)
1501 {
1502   if (! CORBA::is_nil (info.activator.in ()) || info.ior.length () == 0)
1503     return;
1504
1505   try
1506     {
1507       CORBA::Object_var obj =
1508         this->orb_->string_to_object (info.ior.c_str ());
1509
1510       if (CORBA::is_nil (obj.in ()))
1511         {
1512           info.reset_runtime ();
1513           return;
1514         }
1515
1516       if (this->opts_->startup_timeout () > ACE_Time_Value::zero)
1517         {
1518           obj = this->set_timeout_policy (obj.in (), this->opts_->startup_timeout ());
1519         }
1520
1521       info.activator =
1522         ImplementationRepository::Activator::_unchecked_narrow (obj.in ());
1523
1524       if (CORBA::is_nil (info.activator.in ()))
1525         {
1526           info.reset_runtime ();
1527           return;
1528         }
1529
1530       if (debug_ > 1)
1531         ORBSVCS_DEBUG ((LM_DEBUG,
1532                         ACE_TEXT ("(%P|%t) ImR: Connected to activator <%C>\n"),
1533                         info.name.c_str ()));
1534     }
1535   catch (const CORBA::Exception& )
1536     {
1537       info.reset_runtime ();
1538     }
1539 }
1540
1541 void
1542 ImR_Locator_i::auto_start_servers ()
1543 {
1544   if (this->repository_->servers ().current_size () == 0)
1545     return;
1546
1547   Locator_Repository::SIMap::ENTRY* server_entry;
1548   Locator_Repository::SIMap::ITERATOR server_iter (this->repository_->servers ());
1549
1550   // For each of the entries in the Locator_Repository, get the startup
1551   // information and activate the servers, if they are not already
1552   // running.
1553   for (;server_iter.next (server_entry) != 0; server_iter.advance ())
1554     {
1555       UpdateableServerInfo info(this->repository_, server_entry->int_id_);
1556       ACE_ASSERT (! info.null ());
1557
1558       try
1559         {
1560           if (info->is_mode (ImplementationRepository::AUTO_START)
1561               && info->active_info()->cmdline.length () > 0)
1562             {
1563               ImR_ResponseHandler rh;
1564               this->activate_server_i (info, true, &rh);
1565             }
1566         }
1567       catch (const CORBA::Exception& ex)
1568         {
1569           if (debug_ > 1)
1570             {
1571               ORBSVCS_DEBUG ((LM_DEBUG,
1572                               ACE_TEXT ("(%P|%t) ImR: AUTO_START Could not activate <%C>\n"),
1573                               server_entry->ext_id_.c_str ()));
1574               ex._tao_print_exception ("AUTO_START");
1575             }
1576           // Ignore exceptions
1577         }
1578     }
1579 }
1580
1581 void
1582 ImR_Locator_i::connect_server (UpdateableServerInfo& info)
1583 {
1584   Server_Info *sip = info.edit ()->active_info ();
1585   if (! CORBA::is_nil (sip->server.in ()))
1586     {
1587       if (!this->pinger_.has_server (sip->key_name_.c_str()))
1588         {
1589           this->pinger_.add_server (sip->key_name_.c_str(),
1590                                     this->opts_->ping_external (),
1591                                     sip->server.in(),
1592                                     sip->pid);
1593         }
1594       return; // already connected
1595     }
1596
1597   if (sip->ior.length () == 0)
1598     {
1599       sip->reset_runtime ();
1600       return; // can't connect
1601     }
1602
1603   try
1604     {
1605       CORBA::Object_var obj = orb_->string_to_object (sip->ior.c_str ());
1606
1607       if (CORBA::is_nil (obj.in ()))
1608         {
1609           sip->reset_runtime ();
1610           return;
1611         }
1612
1613       obj = this->set_timeout_policy (obj.in (), this->opts_->ping_timeout ());
1614
1615       sip->server =
1616         ImplementationRepository::ServerObject::_unchecked_narrow (obj.in ());
1617
1618       if (CORBA::is_nil (sip->server.in ()))
1619         {
1620           sip->reset_runtime ();
1621           return;
1622         }
1623
1624       if (debug_ > 1)
1625         ORBSVCS_DEBUG ((LM_DEBUG,
1626                         ACE_TEXT ("(%P|%t) ImR: Connected to server <%C>\n"),
1627                         sip->key_name_.c_str ()));
1628       this->pinger_.add_server (sip->key_name_.c_str(),
1629                                 this->opts_->ping_external (),
1630                                 sip->server.in(),
1631                                 sip->pid);
1632     }
1633   catch (const CORBA::Exception& )
1634     {
1635       sip->reset_runtime ();
1636     }
1637 }
1638
1639 bool
1640 ImR_Locator_i::server_is_alive (UpdateableServerInfo& info)
1641 {
1642   this->connect_server (info);
1643   SyncListener *listener = 0;
1644   ACE_NEW_RETURN (listener,
1645                   SyncListener (info->ping_id(),
1646                                 this->orb_.in(),
1647                                 this->pinger_),
1648                   false);
1649   LiveListener_ptr llp(listener);
1650   return listener->is_alive();
1651 }
1652
1653 int
1654 ImR_Locator_i::debug ()
1655 {
1656   return debug_;
1657 }
1658
1659 LiveCheck&
1660 ImR_Locator_i::pinger ()
1661 {
1662   return this->pinger_;
1663 }
1664
1665 PortableServer::POA_ptr
1666 ImR_Locator_i::root_poa ()
1667 {
1668   return PortableServer::POA::_duplicate (this->root_poa_.in());
1669 }
1670
1671 void
1672 ImR_Locator_i::remove_aam (AsyncAccessManager_ptr &aam)
1673 {
1674   if (this->aam_terminating_.remove (aam) == -1)
1675     {
1676       this->aam_active_.remove (aam);
1677     }
1678 }
1679
1680 void
1681 ImR_Locator_i::remove_aam_i (const char *name, bool active)
1682 {
1683   AAM_Set &set = active ? this->aam_active_ : this->aam_terminating_;
1684
1685   for (AAM_Set::ITERATOR i = set.begin(); i != set.end(); ++i)
1686     {
1687       if ((*i)->has_server (name))
1688         {
1689           ACE_GUARD (TAO_SYNCH_MUTEX, mon, this->lock_);
1690           set.remove (*i);
1691           return;
1692         }
1693     }
1694 }
1695
1696 void
1697 ImR_Locator_i::remove_aam (const char *name)
1698 {
1699   this->remove_aam_i (name,true);
1700   this->remove_aam_i (name,false);
1701 }
1702
1703 void
1704 ImR_Locator_i::make_terminating (AsyncAccessManager_ptr &aam,
1705                                  const char *name, int pid)
1706 {
1707   this->aam_active_.remove (aam);
1708   this->aam_terminating_.insert_tail (aam);
1709   this->pinger_.remove_server (name, pid);
1710 }
1711
1712 AsyncAccessManager *
1713 ImR_Locator_i::find_aam (const char *name, bool active)
1714 {
1715   AAM_Set &set = active ? this->aam_active_ : this->aam_terminating_;
1716   for (AAM_Set::ITERATOR i = set.begin(); i != set.end(); ++i)
1717     {
1718       if ((*i)->has_server (name))
1719         {
1720           return (*i)->_add_ref();
1721         }
1722     }
1723   return 0;
1724 }
1725
1726 AsyncAccessManager *
1727 ImR_Locator_i::find_not_running_aam (const char *name, bool active)
1728 {
1729   AAM_Set &set = active ? this->aam_active_ : this->aam_terminating_;
1730   for (AAM_Set::ITERATOR i = set.begin(); i != set.end(); ++i)
1731     {
1732       if ((*i)->has_server (name) && (!(*i)->is_running ()))
1733         {
1734           return (*i)->_add_ref();
1735         }
1736     }
1737   return 0;
1738 }
1739
1740 AsyncAccessManager *
1741 ImR_Locator_i::create_aam (UpdateableServerInfo &info, bool running)
1742 {
1743   AsyncAccessManager_ptr aam;
1744   ACE_NEW_RETURN (aam, AsyncAccessManager (info, *this), 0);
1745   if (running)
1746     {
1747       aam->started_running ();
1748     }
1749   this->aam_active_.insert_tail (aam);
1750   return aam._retn ();
1751 }
1752
1753 //-------------------------------------------------------------------------
1754
1755 SyncListener::SyncListener (const char *server,
1756                             CORBA::ORB_ptr orb,
1757                             LiveCheck &pinger)
1758   :LiveListener (server),
1759    orb_ (CORBA::ORB::_duplicate (orb)),
1760    pinger_ (pinger),
1761    status_ (LS_UNKNOWN),
1762    got_it_ (false),
1763    callback_ (false)
1764 {
1765 }
1766
1767 SyncListener::~SyncListener ()
1768 {
1769 }
1770
1771 bool
1772 SyncListener::is_alive ()
1773 {
1774   this->callback_ = true;
1775   while (!this->got_it_)
1776     {
1777       if (this->callback_)
1778         {
1779           if (!this->pinger_.add_poll_listener (this))
1780             {
1781               return false;
1782             }
1783         }
1784       this->callback_ = false;
1785       ACE_Time_Value delay (10,0);
1786       this->orb_->perform_work (delay);
1787     }
1788   this->got_it_ = false;
1789   return this->status_ != LS_DEAD;
1790 }
1791
1792 bool
1793 SyncListener::status_changed (LiveStatus status)
1794 {
1795   this->callback_ = true;
1796   this->status_ = status;
1797   this->got_it_ = (status != LS_TRANSIENT);
1798   return true;
1799 }
1800
1801 //---------------------------------------------------------------------------
1802
1803 ImR_SyncResponseHandler::ImR_SyncResponseHandler (const char *objkey, CORBA::ORB_ptr orb)
1804   :excep_ (0),
1805    key_ (objkey),
1806    orb_ (CORBA::ORB::_duplicate (orb))
1807 {
1808 }
1809
1810 ImR_SyncResponseHandler::~ImR_SyncResponseHandler ()
1811 {
1812 }
1813
1814 void
1815 ImR_SyncResponseHandler::send_ior (const char *pior)
1816 {
1817   ACE_CString full (pior);
1818   full += this->key_;
1819   this->result_ = full.c_str();
1820 }
1821
1822 void
1823 ImR_SyncResponseHandler::send_exception (CORBA::Exception *ex)
1824 {
1825   this->excep_ = ex->_tao_duplicate();
1826 }
1827
1828 char *
1829 ImR_SyncResponseHandler::wait_for_result ()
1830 {
1831   while (this->result_.in() == 0 && this->excep_ == 0)
1832     {
1833       this->orb_->perform_work ();
1834     }
1835   if (this->excep_ != 0)
1836     {
1837       TAO_AMH_DSI_Exception_Holder h(this->excep_);
1838       h.raise_invoke ();
1839     }
1840   return this->result_._retn();
1841 }
1842
1843 //---------------------------------------------------------------------------
1844
1845 ImR_Loc_ResponseHandler::ImR_Loc_ResponseHandler
1846 (Loc_Operation_Id opid,
1847  ImplementationRepository::AMH_AdministrationResponseHandler_ptr rh)
1848   :op_id_ (opid),
1849    resp_ (ImplementationRepository::AMH_AdministrationResponseHandler::_duplicate (rh))
1850 {
1851 }
1852
1853 ImR_Loc_ResponseHandler::ImR_Loc_ResponseHandler
1854 (Loc_Operation_Id opid,
1855  ImplementationRepository::AMH_AdministrationExtResponseHandler_ptr rh)
1856   :op_id_ (opid),
1857    ext_ (ImplementationRepository::AMH_AdministrationExtResponseHandler::_duplicate (rh))
1858 {
1859 }
1860
1861 ImR_Loc_ResponseHandler::~ImR_Loc_ResponseHandler ()
1862 {
1863 }
1864
1865 void
1866 ImR_Loc_ResponseHandler::send_ior (const char *)
1867 {
1868   if (CORBA::is_nil (this->resp_))
1869     {
1870       this->send_ior_ext ("");
1871       return;
1872     }
1873   switch (this->op_id_)
1874     {
1875     case LOC_ACTIVATE_SERVER:
1876       resp_->activate_server ();
1877       break;
1878     case LOC_ADD_OR_UPDATE_SERVER:
1879       resp_->add_or_update_server ();
1880       break;
1881     case LOC_REMOVE_SERVER:
1882       resp_->remove_server ();
1883       break;
1884     case LOC_SHUTDOWN_SERVER:
1885       resp_->shutdown_server ();
1886       break;
1887     case LOC_SERVER_IS_RUNNING:
1888       resp_->server_is_running ();
1889       break;
1890     case LOC_SERVER_IS_SHUTTING_DOWN:
1891       resp_->server_is_shutting_down ();
1892       break;
1893     default:
1894       break;
1895     };
1896
1897   delete this;
1898 }
1899
1900 void
1901 ImR_Loc_ResponseHandler::send_ior_ext (const char *)
1902 {
1903   switch (this->op_id_)
1904     {
1905     case LOC_FORCE_REMOVE_SERVER:
1906       ext_->force_remove_server ();
1907       break;
1908     default:
1909       break;
1910     };
1911
1912   delete this;
1913 }
1914
1915 void
1916 ImR_Loc_ResponseHandler::send_exception (CORBA::Exception *ex)
1917 {
1918   if (CORBA::is_nil (this->resp_))
1919     {
1920       this->send_exception_ext (ex);
1921       return;
1922     }
1923   ImplementationRepository::AMH_AdministrationExceptionHolder h (ex);
1924   switch (this->op_id_)
1925     {
1926     case LOC_ACTIVATE_SERVER:
1927       resp_->activate_server_excep (&h);
1928       break;
1929     case LOC_ADD_OR_UPDATE_SERVER:
1930       resp_->add_or_update_server_excep (&h);
1931       break;
1932     case LOC_REMOVE_SERVER:
1933       resp_->remove_server_excep (&h);
1934       break;
1935     case LOC_SHUTDOWN_SERVER:
1936       resp_->shutdown_server_excep (&h);
1937       break;
1938     case LOC_SERVER_IS_RUNNING:
1939       resp_->server_is_running_excep (&h);
1940       break;
1941     case LOC_SERVER_IS_SHUTTING_DOWN:
1942       resp_->server_is_shutting_down_excep (&h);
1943       break;
1944     default:
1945       break;
1946     };
1947   delete this;
1948 }
1949 void
1950 ImR_Loc_ResponseHandler::send_exception_ext (CORBA::Exception *ex)
1951 {
1952   ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex);
1953   switch (this->op_id_)
1954     {
1955     case LOC_FORCE_REMOVE_SERVER:
1956       ext_->force_remove_server_excep (&h);
1957       break;
1958     default:
1959       break;
1960     };
1961   delete this;
1962 }