int ImR_Locator_i::init_with_orb (CORBA::ORB_ptr orb) { this->orb_ = CORBA::ORB::_duplicate (orb); ImR_Locator_i::debug_ = this->opts_->debug (); CORBA::Object_var obj = this->orb_->resolve_initial_references ("RootPOA"); this->root_poa_ = PortableServer::POA::_narrow (obj.in ()); ACE_ASSERT (! CORBA::is_nil (this->root_poa_.in ())); this->dsi_forwarder_.init (orb); this->adapter_.init (& this->dsi_forwarder_); this->pinger_.init (orb, this->opts_->ping_interval ()); this->opts_->pinger (&this->pinger_); // Register the Adapter_Activator reference to be the RootPOA's // Adapter Activator. root_poa_->the_activator (&this->adapter_); // Use a persistent POA so that any IOR this->imr_poa_ = createPersistentPOA (this->root_poa_.in (), "ImplRepo_Service"); ACE_ASSERT (! CORBA::is_nil (this->imr_poa_.in ())); PortableServer::ObjectId_var id = 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 ()); ImplementationRepository::Locator_var locator = ImplementationRepository::Locator::_narrow (obj.in ()); ACE_ASSERT(! CORBA::is_nil (locator.in ())); const CORBA::String_var ior = this->orb_->object_to_string (obj.in ()); // create the selected Locator_Repository with backing store switch (this->opts_->repository_mode ()) { case Options::REPO_REGISTRY: { repository_.reset(new Registry_Backing_Store(*this->opts_, orb)); break; } case Options::REPO_HEAP_FILE: { repository_.reset(new Heap_Backing_Store(*this->opts_, orb)); break; } case Options::REPO_XML_FILE: { repository_.reset(new XML_Backing_Store(*this->opts_, orb)); break; } case Options::REPO_SHARED_FILES: { repository_.reset(new Shared_Backing_Store(*this->opts_, orb, this)); break; } case Options::REPO_NONE: { repository_.reset(new No_Backing_Store(*this->opts_, orb)); break; } default: { bool invalid_rmode_specified = false; ACE_ASSERT (invalid_rmode_specified); ACE_UNUSED_ARG (invalid_rmode_specified); ORBSVCS_ERROR_RETURN (( LM_ERROR, ACE_TEXT ("Repository failed to initialize\n")), -1); } } // Register the ImR for use with INS obj = orb->resolve_initial_references ("AsyncIORTable"); IORTable::Table_var ior_table = IORTable::Table::_narrow (obj.in ()); ACE_ASSERT (! CORBA::is_nil (ior_table.in ())); ior_table->set_locator (this->ins_locator_.in ()); // initialize the repository. This will load any values that // may have been persisted before. int result = this->repository_->init(this->root_poa_.in (), this->imr_poa_.in (), ior); if (result != 0) { return result; } Locator_Repository::SIMap::ENTRY* entry = 0; Locator_Repository::SIMap::ITERATOR it (this->repository_->servers ()); for (;it.next (entry) != 0; it.advance ()) { UpdateableServerInfo info (this->repository_, entry->int_id_); bool is_alive = this->server_is_alive (info); Server_Info *active = info.edit()->active_info (); if (this->debug_ > 0) { ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("server %C is_alive = %d\n"), active->ping_id(), is_alive)); } if (!is_alive) { info.edit()->reset_runtime (); active->reset_runtime (); continue; } active->death_notify = false; if (active->pid > 0) { Activator_Info_Ptr ainfo = this->get_activator (active->activator); if (!(ainfo.null () || CORBA::is_nil (ainfo->activator.in ()))) { ImplementationRepository::ActivatorExt_var actx = ImplementationRepository::ActivatorExt::_narrow (ainfo->activator.in ()); try { active->death_notify = !CORBA::is_nil (actx.in ()) && actx->still_alive (active->pid); } catch (const CORBA::Exception &) { } if (this->debug_ > 0) { ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT ("activator says death_notify = %d\n"), active->death_notify)); } } } } //only after verifying do we report the IOR and become open for business return this->repository_->report_ior(this->imr_poa_.in ()); }
int ImR_Activator_i::init_with_orb (CORBA::ORB_ptr orb, const Activator_Options& opts) { ACE_ASSERT(! CORBA::is_nil (orb)); orb_ = CORBA::ORB::_duplicate (orb); debug_ = opts.debug (); notify_imr_ = opts.notify_imr (); induce_delay_ = opts.induce_delay (); env_buf_len_ = opts.env_buf_len (); max_env_vars_ = opts.max_env_vars (); if (opts.name ().length () > 0) { name_ = opts.name(); } try { CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA"); ACE_ASSERT (! CORBA::is_nil (obj.in ())); this->root_poa_ = PortableServer::POA::_narrow (obj.in ()); ACE_ASSERT (! CORBA::is_nil(this->root_poa_.in ())); // The activator must use a persistent POA so that it can be started before the // locator in some scenarios, such as when the locator persists its database, and // wants to reconnect to running activators to auto_start some servers. this->imr_poa_ = createPersistentPOA (this->root_poa_.in (), "ImR_Activator"); ACE_ASSERT (! CORBA::is_nil(this->imr_poa_.in ())); // Activate ourself PortableServer::ObjectId_var id = PortableServer::string_to_ObjectId ("ImR_Activator"); this->imr_poa_->activate_object_with_id (id.in (), this); obj = this->imr_poa_->id_to_reference (id.in ()); ImplementationRepository::ActivatorExt_var activator = ImplementationRepository::ActivatorExt::_narrow (obj.in ()); ACE_ASSERT(! CORBA::is_nil (activator.in ())); CORBA::String_var ior = this->orb_->object_to_string (activator.in ()); if (this->debug_ > 0) ORBSVCS_DEBUG((LM_DEBUG, "ImR Activator: Starting %s\n", name_.c_str ())); // initialize our process manager. // This requires a reactor that has signal handling. ACE_Reactor *reactor = ACE_Reactor::instance (); if (reactor != 0) { if (this->process_mgr_.open (ACE_Process_Manager::DEFAULT_SIZE, reactor) == -1) { ORBSVCS_ERROR_RETURN ((LM_ERROR, "The ACE_Process_Manager didnt get initialized\n"), -1); } } this->register_with_imr (activator.in ()); // no throw PortableServer::POAManager_var poaman = this->root_poa_->the_POAManager (); poaman->activate (); if (this->debug_ > 1) { ORBSVCS_DEBUG ((LM_DEBUG, "ImR Activator: The Activator IOR is: <%s>\n", ior.in ())); } // The last thing we do is write out the ior so that a test program can assume // that the activator is ready to go as soon as the ior is written. if (opts.ior_filename ().length () > 0) { FILE* fp = ACE_OS::fopen (opts.ior_filename ().c_str (), "w"); if (fp == 0) { ORBSVCS_ERROR_RETURN ((LM_ERROR, "ImR Activator: Could not open file: %s\n", opts.ior_filename ().c_str ()), -1); } ACE_OS::fprintf (fp, "%s", ior.in ()); ACE_OS::fclose (fp); } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( "ImR_Activator_i::init_with_orb"); throw; } return 0; }
void ImR_Locator_i::kill_server (ImplementationRepository::AMH_AdministrationExtResponseHandler_ptr _tao_rh, const char * name, CORBA::Short signum) { Server_Info_Ptr si; if (!this->get_info_for_name (name, si)) { CORBA::Exception *ex = new ImplementationRepository::NotFound; ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex); _tao_rh->kill_server_excep (&h); return; } if (!si->alt_info_.null ()) { si = si->alt_info_; } UpdateableServerInfo info (this->repository_, si, true); if (info->is_mode(ImplementationRepository::PER_CLIENT)) { CORBA::Exception *ex = new ImplementationRepository::CannotComplete ("per-client server"); ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex); _tao_rh->kill_server_excep (&h); return; } Activator_Info_Ptr ainfo = this->get_activator (si->activator); if (ainfo.null ()) { CORBA::Exception *ex = new ImplementationRepository::CannotComplete ("no activator"); ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex); _tao_rh->kill_server_excep (&h); return; } ImplementationRepository::ActivatorExt_var actext = ImplementationRepository::ActivatorExt::_narrow (ainfo->activator.in()); if (CORBA::is_nil (actext.in())) { CORBA::Exception *ex = new ImplementationRepository::CannotComplete ("activator incompatible"); ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex); _tao_rh->kill_server_excep (&h); return; } if (!actext->kill_server (si->key_name_.c_str(), si->pid, signum)) { CORBA::Exception *ex = new ImplementationRepository::CannotComplete ("server not running"); ImplementationRepository::AMH_AdministrationExtExceptionHolder h (ex); _tao_rh->kill_server_excep (&h); } else { _tao_rh->kill_server (); AsyncAccessManager_ptr aam = this->find_aam (si->key_name_.c_str ()); if (!aam.is_nil ()) { aam->shutdown_initiated (); } } }