ImR_Locator_i Class Reference

#include <ImR_Locator_i.h>

Collaboration diagram for ImR_Locator_i:

[legend]List of all members.

Public Member Functions
	ImR_Locator_i ()
	~ImR_Locator_i (void)
int	init (Options &opts)
	Initialize the service, creating its own orb, poa, etc.
int	init_with_orb (CORBA::ORB_ptr orb, Options &opts)
	Same as above, but use the given orb.
int	fini (void)
	Cleans up any state created by init*.
int	run (void)
	Run using the orb reference created during init().
void	shutdown (bool wait_for_completion)
	Shutdown the orb.
int	debug () const
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	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, ImplementationRepository::ServerInformationList_out server_list, ImplementationRepository::ServerInformationIterator_out server_iterator)
virtual void	shutdown (CORBA::Boolean activators, CORBA::Boolean servers)
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)
char *	activate_server_by_object (const char *object_name)
char *	activate_server_by_name (const char *name, bool manual_start)
Private Member Functions
char *	activate_server_i (Server_Info &info, bool manual_start)
char *	activate_perclient_server_i (Server_Info info, bool manual_start)
ImplementationRepository::StartupInfo *	start_server (Server_Info &info, bool manual_start, int &waiting_clients)
bool	is_alive (Server_Info &info)
int	is_alive_i (Server_Info &info)
int	setup_multicast (ACE_Reactor *reactor, const char *ior)
void	teardown_multicast ()
void	unregister_activator_i (const char *activator)
Activator_Info_Ptr	get_activator (const ACE_CString &name)
void	connect_activator (Activator_Info &info)
void	auto_start_servers (void)
CORBA::Object_ptr	set_timeout_policy (CORBA::Object_ptr obj, const ACE_Time_Value &to)
void	connect_server (Server_Info &info)
PortableServer::POA_ptr	findPOA (const char *name)
Private Attributes
ImR_Forwarder	forwarder_
ImR_Adapter	adapter_
IORTable::Locator_var	ins_locator_
	The locator interface for the IORTable.
CORBA::ORB_var	orb_
PortableServer::POA_var	root_poa_
PortableServer::POA_var	imr_poa_
int	debug_
TAO_IOR_Multicast	ior_multicast_
Locator_Repository	repository_
AsyncStartupWaiter_i	waiter_svt_
ImplementationRepository::AsyncStartupWaiter_var	waiter_
bool	read_only_
ACE_Time_Value	startup_timeout_
ACE_Time_Value	ping_interval_

---

Constructor & Destructor Documentation

ImR_Locator_i::ImR_Locator_i (   )

Definition at line 56 of file ImR_Locator_i.cpp. References ACE_NEW, and ins_locator_. : forwarder_ (*this) , ins_locator_ (0) , debug_ (0) , read_only_ (false) { // Visual C++ 6.0 is not smart enough to do a direct assignment // while allocating the INS_Locator. So, we have to do it in // two steps. INS_Locator* locator; ACE_NEW (locator, INS_Locator (*this)); ins_locator_ = locator; }

ImR_Locator_i::~ImR_Locator_i (  void   )

Definition at line 71 of file ImR_Locator_i.cpp. { // For some reason g++ 4.0 needs this out-of-line destructor instead // of the default one generated by the compiler. Without this // destructor, we get a number of "undefined reference" link errors // related to the virtual tables of the INS_Locator, ImR_Adapter and // ImR_Forwarder members in this class. }

---

Member Function Documentation

char * ImR_Locator_i::activate_perclient_server_i (  Server_Info  info, bool  manual_start )  [private]

Definition at line 545 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, Locator_Repository::get_server(), Server_Info::ior, is_alive(), LM_DEBUG, Server_Info::name, Server_Info::partial_ior, Server_Info::reset(), Server_Info_Ptr, Server_Info::start_count, Server_Info::start_limit, start_server(), and CORBA::string_dup(). Referenced by activate_server_i(). { Server_Info_Ptr shared_info = this->repository_.get_server (info.name); do { ImplementationRepository::StartupInfo* psi = start_server (info, manual_start, shared_info->waiting_clients); if (psi != 0) { ImplementationRepository::StartupInfo_var si = psi; ACE_ASSERT (info.name == si->name.in ()); info.partial_ior = si->partial_ior.in (); info.ior = si->ior.in (); if (is_alive (info)) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: Successfully activated <%s> at \n\t%s\n", info.name.c_str (), info.partial_ior.c_str ())); } return CORBA::string_dup (info.partial_ior.c_str ()); } info.reset (); } } while (info.start_count < info.start_limit); if (this->debug_ > 0) { ACE_DEBUG ((LM_DEBUG, "ImR: Cannot Activate <%s>.\n", info.name.c_str ())); } throw ImplementationRepository::CannotActivate( CORBA::string_dup ( "Cannot start server.")); }

void ImR_Locator_i::activate_server (  const char *  name  )  [virtual]

Definition at line 455 of file ImR_Locator_i.cpp. References ACE_DEBUG, activate_server_by_name(), and LM_DEBUG. { if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Manually activating server <%s>\n", server)); // This is the version called by tao_imr to activate the server, manually // starting it if necessary. activate_server_by_name (server, true); }

char * ImR_Locator_i::activate_server_by_name (  const char *  name, bool  manual_start )

Definition at line 466 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_ERROR, activate_server_i(), Locator_Repository::get_server(), LM_ERROR, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), and Server_Info_Ptr. Referenced by activate_server(), activate_server_by_object(), and ImR_Forwarder::preinvoke(). { // Activate the server, starting it if necessary. Don't start MANUAL // servers unless manual_start=true ACE_ASSERT (name != 0); Server_Info_Ptr info = this->repository_.get_server (name); if (info.null ()) { ACE_ERROR ((LM_ERROR, "ImR: Cannot find info for server <%s>\n", name)); throw ImplementationRepository::NotFound (); } return activate_server_i (*info, manual_start); }

char * ImR_Locator_i::activate_server_by_object (  const char *  object_name  )

Definition at line 483 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_CString, and activate_server_by_name(). Referenced by INS_Locator::locate(). { ACE_ASSERT (object_name != 0); // We assume that the first part of the object name is the server name. // So a name of foo/bar means that the server name is foo. ACE_CString server_name (object_name); ACE_CString::size_type pos = server_name.find ('/'); if (pos != ACE_CString::npos) server_name = server_name.substr (pos + 1); return activate_server_by_name (server_name.c_str (), false); }

char * ImR_Locator_i::activate_server_i (  Server_Info &  info, bool  manual_start )  [private]

Definition at line 498 of file ImR_Locator_i.cpp. References ACE_DEBUG, activate_perclient_server_i(), Server_Info::activation_mode, is_alive(), LM_DEBUG, Server_Info::name, Server_Info::partial_ior, Server_Info::reset(), Server_Info::start_count, Server_Info::start_limit, start_server(), Server_Info::starting, CORBA::string_dup(), AsyncStartupWaiter_i::unblock_all(), waiter_svt_, and Server_Info::waiting_clients. Referenced by activate_server_by_name(), and auto_start_servers(). { if (info.activation_mode == ImplementationRepository::PER_CLIENT) { return activate_perclient_server_i (info, manual_start); } while (true) { if (is_alive (info)) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: Successfully activated <%s> at \n\t%s\n", info.name.c_str (), info.partial_ior.c_str ())); } info.start_count = 0; waiter_svt_.unblock_all (info.name.c_str ()); return CORBA::string_dup (info.partial_ior.c_str ()); } info.reset (); if (! info.starting && info.start_count >= info.start_limit) { if (this->debug_ > 0) { ACE_DEBUG ((LM_DEBUG, "ImR: Cannot Activate <%s>.\n", info.name.c_str ())); } waiter_svt_.unblock_all (info.name.c_str ()); throw ImplementationRepository::CannotActivate( CORBA::string_dup ( "Cannot start server.")); } // Note: We already updated info with StartupInfo in server_is_running () ImplementationRepository::StartupInfo_var si = start_server (info, manual_start, info.waiting_clients); } }

void ImR_Locator_i::add_or_update_server (  const char *  name, const ImplementationRepository::StartupOptions &  options )  [virtual]

Definition at line 759 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, ImR_Utils::activationModeToString(), Locator_Repository::add_server(), Locator_Repository::get_server(), LM_DEBUG, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), read_only_, Server_Info_Ptr, TAO_IMPLREPO_MINOR_CODE, and Locator_Repository::update_server(). { ACE_ASSERT (server != 0); if (this->read_only_) { ACE_DEBUG ((LM_DEBUG, "ImR: Cannot add/update server <%s> due to locked database.\n", server)); throw CORBA::NO_PERMISSION ( CORBA::SystemException::_tao_minor_code ( TAO_IMPLREPO_MINOR_CODE, 0), CORBA::COMPLETED_NO); } if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Add/Update server <%s>.\n", server)); int limit = options.start_limit; if (limit < 0) { limit = -limit; } else if (limit == 0) { limit = 1; } Server_Info_Ptr info = this->repository_.get_server (server); if (info.null ()) { if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Adding server <%s>.\n", server)); this->repository_.add_server (server, options.activator.in (), options.command_line.in (), options.environment, options.working_directory.in (), options.activation, limit); } else { if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Updating server <%s>.\n", server)); info->activator = options.activator.in (); info->cmdline = options.command_line.in (); info->env_vars = options.environment; info->dir = options.working_directory.in (); info->activation_mode = options.activation; info->start_limit = limit; info->start_count = 0; int err = this->repository_.update_server (*info); ACE_ASSERT (err == 0); ACE_UNUSED_ARG (err); } if (this->debug_ > 1) { // Note : The info var may be null, so we use options. ACE_DEBUG ((LM_DEBUG, "ImR: Server: %s\n" "\tActivator: %s\n" "\tCommand Line: %s\n" "\tWorking Directory: %s\n" "\tActivation: %s\n" "\tStart Limit: %d\n" "\n", server, options.activator.in (), options.command_line.in (), options.working_directory.in (), ImR_Utils::activationModeToString (options.activation).c_str (), limit )); for (CORBA::ULong i = 0; i < options.environment.length (); ++i) ACE_DEBUG ((LM_DEBUG, "Environment variable %s=%s\n", options.environment[i].name.in (), options.environment[i].value.in ())); } }

void ImR_Locator_i::auto_start_servers (  void   )  [private]

Definition at line 1199 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, activate_server_i(), LM_DEBUG, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), Server_Info_Ptr, and Locator_Repository::servers(). Referenced by run(). { if (this->repository_.servers ().current_size () == 0) return; Locator_Repository::SIMap::ENTRY* server_entry; Locator_Repository::SIMap::ITERATOR server_iter (this->repository_.servers ()); // For each of the entries in the Locator_Repository, get the startup // information and activate the servers, if they are not already // running. for (;server_iter.next (server_entry) != 0; server_iter.advance ()) { Server_Info_Ptr info = server_entry->int_id_; ACE_ASSERT (! info.null ()); try { if (info->activation_mode == ImplementationRepository::AUTO_START && info->cmdline.length () > 0) { this->activate_server_i (*info, true); } } catch (const CORBA::Exception& ex) { if (this->debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: AUTO_START Could not activate <%s>\n", server_entry->ext_id_.c_str ())); ex._tao_print_exception ("AUTO_START"); } // Ignore exceptions } } }

void ImR_Locator_i::connect_activator (  Activator_Info &  info  )  [private]

Definition at line 1159 of file ImR_Locator_i.cpp. References ACE_DEBUG, Activator_Info::activator, Activator_Info::ior, CORBA::is_nil(), LM_DEBUG, Activator_Info::name, Activator_Info::reset(), set_timeout_policy(), and startup_timeout_. Referenced by get_activator(), and shutdown(). { if (! CORBA::is_nil (info.activator.in ()) || info.ior.length () == 0) return; try { CORBA::Object_var obj = this->orb_->string_to_object (info.ior.c_str ()); if (CORBA::is_nil (obj.in ())) { info.reset (); return; } if (startup_timeout_ > ACE_Time_Value::zero) { obj = set_timeout_policy (obj.in (), startup_timeout_); } info.activator = ImplementationRepository::Activator::_unchecked_narrow (obj.in ()); if (CORBA::is_nil (info.activator.in ())) { info.reset (); return; } if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Connected to activator <%s>\n", info.name.c_str ())); } catch (const CORBA::Exception&) { info.reset (); } }

void ImR_Locator_i::connect_server (  Server_Info &  info  )  [private]

Definition at line 1238 of file ImR_Locator_i.cpp. References ACE_DEBUG, DEFAULT_SERVER_TIMEOUT, Server_Info::ior, CORBA::is_nil(), LM_DEBUG, Server_Info::name, Server_Info::reset(), Server_Info::server, and set_timeout_policy(). Referenced by is_alive_i(), and shutdown_server(). { if (! CORBA::is_nil (info.server.in ())) { return; // already connected } if (info.ior.length () == 0) { info.reset (); return; // can't connect } try { CORBA::Object_var obj = orb_->string_to_object (info.ior.c_str ()); if (CORBA::is_nil (obj.in ())) { info.reset (); return; } obj = set_timeout_policy (obj.in (), DEFAULT_SERVER_TIMEOUT); info.server = ImplementationRepository::ServerObject::_unchecked_narrow (obj.in ()); if (CORBA::is_nil (info.server.in ())) { info.reset (); return; } if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Connected to server <%s>\n", info.name.c_str ())); } catch (const CORBA::Exception&) { info.reset (); } }

int ImR_Locator_i::debug (   )  const

Definition at line 1468 of file ImR_Locator_i.cpp. Referenced by INS_Locator::locate(), and ImR_Forwarder::preinvoke(). { return debug_; }

void ImR_Locator_i::find (  const char *  name, ImplementationRepository::ServerInformation_out  info )  [virtual]

Definition at line 1057 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_NEW_THROW_EX, Locator_Repository::get_server(), LM_DEBUG, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), and Server_Info_Ptr. { ACE_ASSERT (server != 0); ACE_NEW_THROW_EX (imr_info, ImplementationRepository::ServerInformation, CORBA::NO_MEMORY ()); Server_Info_Ptr info = this->repository_.get_server (server); if (! info.null ()) { imr_info = info->createImRServerInfo (); if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Found server %s.\n", server)); } else { if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Cannot find server <%s>\n", server)); } }

PortableServer::POA_ptr ImR_Locator_i::findPOA (  const char *  name  )  [private]

Definition at line 890 of file ImR_Locator_i.cpp. Referenced by remove_server(). { try { bool activate_it = false; return root_poa_->find_POA (name, activate_it); } catch (const CORBA::Exception&) {// Ignore } return PortableServer::POA::_nil (); }

int ImR_Locator_i::fini (  void   )

Cleans up any state created by init*. Definition at line 276 of file ImR_Locator_i.cpp. References ACE_DEBUG, LM_DEBUG, and teardown_multicast(). Referenced by ImR_Locator_Loader::fini(), run_standalone(), and Locator_NT_Service::svc(). { try { if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Shutting down...\n")); teardown_multicast (); this->root_poa_->destroy (1, 1); this->orb_->destroy (); if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Shut down successfully.\n")); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("ImR_Locator_i::fini"); throw; } return 0; }

Activator_Info_Ptr ImR_Locator_i::get_activator (  const ACE_CString &  name  )  [private]

Definition at line 1148 of file ImR_Locator_i.cpp. References Activator_Info_Ptr, connect_activator(), Locator_Repository::get_activator(), and ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(). Referenced by start_server(), and unregister_activator(). { Activator_Info_Ptr info = this->repository_.get_activator (aname); if (! info.null ()) { this->connect_activator (*info); } return info; }

int ImR_Locator_i::init (  Options &  opts  )

Initialize the service, creating its own orb, poa, etc. Definition at line 173 of file ImR_Locator_i.cpp. References ACE_ARGV, ACE_CString, Options::cmdline(), init_with_orb(), and CORBA::ORB_init(). Referenced by ImR_Locator_Loader::init(), run_standalone(), and Locator_NT_Service::svc(). { ACE_CString cmdline = opts.cmdline (); cmdline += " -orbcollocation no -orbuseimr 0"; ACE_ARGV av (cmdline.c_str ()); int argc = av.argc (); char** argv = av.argv (); CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "TAO_ImR_Locator"); int err = this->init_with_orb (orb.in (), opts); return err; }

int ImR_Locator_i::init_with_orb (  CORBA::ORB_ptr  orb, Options &  opts )

Same as above, but use the given orb. Definition at line 81 of file ImR_Locator_i.cpp. References CORBA::ORB::_duplicate(), ACE_ASSERT, ACE_ERROR_RETURN, createPersistentPOA(), AsyncStartupWaiter_i::debug(), Options::debug(), ACE_OS::fclose(), ACE_OS::fopen(), forwarder_, ACE_OS::fprintf(), Locator_Repository::init(), ImR_Adapter::init(), ImR_Forwarder::init(), Options::ior_filename(), LM_ERROR, Options::multicast(), Options::ping_interval(), ping_interval_, read_only_, Options::readonly(), set_timeout_policy(), setup_multicast(), Options::startup_timeout(), startup_timeout_, PortableServer::string_to_ObjectId(), waiter_, and waiter_svt_. Referenced by init(). { orb_ = CORBA::ORB::_duplicate (orb); debug_ = opts.debug (); read_only_ = opts.readonly (); startup_timeout_ = opts.startup_timeout (); ping_interval_ = opts.ping_interval (); 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->forwarder_.init (orb); this->adapter_.init (& this->forwarder_); // 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 ())); 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 = set_timeout_policy (obj.in (), startup_timeout_); } waiter_ = ImplementationRepository::AsyncStartupWaiter::_narrow (obj.in ()); 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 ()); CORBA::String_var ior = this->orb_->object_to_string (obj.in ()); // Register the ImR for use with INS obj = orb->resolve_initial_references ("IORTable"); IORTable::Table_var ior_table = IORTable::Table::_narrow (obj.in ()); ACE_ASSERT (! CORBA::is_nil (ior_table.in ())); ior_table->bind ("ImplRepoService", ior.in ()); ior_table->bind ("ImR", ior.in ()); ior_table->set_locator (this->ins_locator_.in ()); // Set up multicast support (if enabled) if (opts.multicast ()) { ACE_Reactor* reactor = orb->orb_core ()->reactor (); if (this->setup_multicast (reactor, ior.in ()) != 0) return -1; } // Initialize the persistent storage. This will load any values that // may have been persisted before. // The init can return 1 if there is no persistent file yet. In // that case, we need not do anything for now. int init_result = this->repository_.init (opts); if (init_result == -1) { ACE_ERROR_RETURN ((LM_ERROR, "Repository failed to initialize\n"), -1); } // Activate the two poa managers PortableServer::POAManager_var poaman = this->root_poa_->the_POAManager (); poaman->activate (); poaman = this->imr_poa_->the_POAManager (); poaman->activate (); // We write the ior file last so that the tests can know we are ready. if (opts.ior_filename ().length () > 0) { FILE* fp = ACE_OS::fopen (opts.ior_filename ().c_str (), "w"); if (fp == 0) { ACE_ERROR_RETURN ((LM_ERROR, "ImR: Could not open file: %s\n", opts.ior_filename ().c_str ()), -1); } ACE_OS::fprintf (fp, "%s", ior.in ()); ACE_OS::fclose (fp); } return 0; }

bool ImR_Locator_i::is_alive (  Server_Info &  info  )  [private]

Definition at line 1282 of file ImR_Locator_i.cpp. References ACE_DEBUG, ACE_OS::gettimeofday(), is_alive_i(), Server_Info::last_ping, LM_DEBUG, Server_Info::name, and PING_RETRY_SCHEDULE. Referenced by activate_perclient_server_i(), and activate_server_i(). { const size_t table_size = sizeof (PING_RETRY_SCHEDULE) / sizeof (*PING_RETRY_SCHEDULE); for (size_t i = 0; i < table_size; ++i) { int status = this->is_alive_i (info); if (status == 0) return false; if (status == 1) return true; // This is evil, but there's not much else we can do for now. We // should never reach this code once the ImR Servers are fixed // so that they don't lie about server_is_running. Currently, // they send this notification during poa creation. We have to // run the orb, because the very thing that may be slowing the // aliveness of the servers is the fact that they're trying to // register more objects with us. In practical testing, we // never retried the ping more than once, because the second // ping always timed out, even if the servers poa manager had // not been activated. The only way we saw multiple retries was // if we ran the orb on the server before the poa manager was // activated. For this reason, the first retry is immediate, // and the orb->run () call is not required. The call will // likely timeout, and is_alive will return true. if (PING_RETRY_SCHEDULE[i] > 0) { ACE_Time_Value tv (0, PING_RETRY_SCHEDULE[i] * 1000); this->orb_->run (tv); } } if (debug_ > 0) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Ping retry count exceeded. alive=maybe.\n", info.name.c_str ())); } // We return true here, because the server *might* be alive, it's just not starting in a timely // manner. We can't return false, because then we'll just try to start another instance, and the // same thing will likely happen. info.last_ping = ACE_OS::gettimeofday (); return true; }

int ImR_Locator_i::is_alive_i (  Server_Info &  info  )  [private]

Definition at line 1328 of file ImR_Locator_i.cpp. References ACE_DEBUG, Server_Info::activator, Server_Info::cmdline, connect_server(), ACE_OS::gettimeofday(), Locator_Repository::has_activator(), Server_Info::ior, CORBA::is_nil(), Server_Info::last_ping, LM_DEBUG, Server_Info::name, Server_Info::partial_ior, ping_interval_, Server_Info::server, TAO_INVOCATION_SEND_REQUEST_MINOR_CODE, TAO_POA_DISCARDING, and TAO_POA_HOLDING. Referenced by is_alive(). { // This is used by the ACE_TRY below when exceptions are turned off. if (info.ior.length () == 0 || info.partial_ior.length () == 0) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> not running. alive=false.\n", info.name.c_str ())); } info.last_ping = ACE_Time_Value::zero; return 0; } if (ping_interval_ == ACE_Time_Value::zero) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Ping verification disabled. alive=true.\n", info.name.c_str ())); } return 1; } if ((ACE_OS::gettimeofday () - info.last_ping) < ping_interval_) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> within ping interval. alive=true.\n", info.name.c_str ())); } return 1; } // If we don't have enough information to start the server if it isn't already // then we might as well assume it is running. That way the client can get the // status directly from the server. if (info.cmdline.length () == 0 || ! repository_.has_activator (info.activator)) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: Ping verification skipped. <%s> not startable.\n", info.name.c_str ())); } return 1; } connect_server (info); if (CORBA::is_nil (info.server.in ())) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Could not connect. alive=false.\n", info.name.c_str ())); } return 0; } try { // Make a copy, in case the info is updated during the ping. ImplementationRepository::ServerObject_var server = info.server; // This will timeout if it takes too long server->ping (); if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Ping successful. alive=true\n", info.name.c_str ())); } info.last_ping = ACE_OS::gettimeofday (); } catch (const CORBA::TRANSIENT& ex) { const CORBA::ULong BITS_5_THRU_12_MASK = 0x00000f80; switch (ex.minor () & BITS_5_THRU_12_MASK) { case TAO_INVOCATION_SEND_REQUEST_MINOR_CODE: { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Local TRANSIENT. alive=false.\n", info.name.c_str ())); } } info.last_ping = ACE_Time_Value::zero; return 0; case TAO_POA_DISCARDING: case TAO_POA_HOLDING: { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Remote TRANSIENT. alive=maybe.\n", info.name.c_str ())); } } return -1; // We keep trying to ping, because returning 1 now, would just lead // to clients getting the same exception. If we can't ping after several // attempts, then we'll give up and return 1, letting the client worry about it. default: { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> TRANSIENT exception. alive=false.\n", info.name.c_str ())); } info.last_ping = ACE_Time_Value::zero; } return 0; } } catch (const CORBA::TIMEOUT&) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Ping timed out. alive=true.\n", info.name.c_str ())); } return 1; // This is "alive" as far as we're concerned. Presumably the client // will have a less stringent timeout policy, or will want to know // about the timeout. In any case, we're only guaranteeing that the // server is alive, not that it's responsive. } catch (const CORBA::Exception& ex) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: <%s> Unexpected Ping exception. alive=false\n", info.name.c_str ())); ex._tao_print_exception ("\n"); } info.last_ping = ACE_Time_Value::zero; return false; } return 1; }

void ImR_Locator_i::list (  CORBA::ULong  how_many, ImplementationRepository::ServerInformationList_out  server_list, ImplementationRepository::ServerInformationIterator_out  server_iterator )  [virtual]

Definition at line 1079 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_NEW_THROW_EX, LM_DEBUG, Server_Info_Ptr, and Locator_Repository::servers(). { if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: List servers.\n")); // Initialize the out variables, so if we return early, they will // not be dangling. server_iterator = ImplementationRepository::ServerInformationIterator::_nil (); ACE_NEW_THROW_EX (server_list, ImplementationRepository::ServerInformationList (0), CORBA::NO_MEMORY ()); Locator_Repository::SIMap::ENTRY* entry = 0; Locator_Repository::SIMap::ITERATOR it (this->repository_.servers ()); // Number of servers that will go into the server_list. CORBA::ULong n = this->repository_.servers ().current_size (); if (how_many > 0 && n > how_many) { n = how_many; } server_list->length (n); if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::list: Filling ServerList with %d servers\n", n)); for (CORBA::ULong i = 0; i < n; i++) { it.next (entry); it.advance (); ACE_ASSERT (entry != 0); Server_Info_Ptr info = entry->int_id_; ImplementationRepository::ServerInformation_var imr_info = info->createImRServerInfo (); server_list[i] = *imr_info; } if (this->repository_.servers ().current_size () > n) { if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::list: Creating ServerInformation 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); try { 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 ()); } catch (const CORBA::Exception&) { throw; } } }

void ImR_Locator_i::notify_child_death (  const char *  name  )  [virtual]

Definition at line 429 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, Locator_Repository::get_server(), LM_DEBUG, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), Server_Info_Ptr, and Locator_Repository::update_server(). { ACE_ASSERT (name != 0); if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Server has died <%s>.\n", name)); Server_Info_Ptr info = this->repository_.get_server (name); if (! info.null ()) { info->ior = ""; info->partial_ior = ""; int err = this->repository_.update_server (*info); ACE_ASSERT (err == 0); ACE_UNUSED_ARG (err); } else { if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Failed to find server in repository.\n")); } }

CORBA::Long ImR_Locator_i::register_activator (  const char *  name, ImplementationRepository::Activator_ptr  admin )  [virtual]

Definition at line 368 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, Locator_Repository::add_activator(), ACE_OS::gettimeofday(), LM_DEBUG, ACE_Time_Value::msec(), and unregister_activator_i(). { ACE_ASSERT (aname != 0); ACE_ASSERT (! CORBA::is_nil (activator)); // Before we can register the activator, we need to ensure that any existing // registration is purged. this->unregister_activator_i (aname); CORBA::String_var ior = this->orb_->object_to_string (activator); CORBA::Long token = ACE_OS::gettimeofday ().msec (); int err = this->repository_.add_activator (aname, token, ior.in (), activator); ACE_ASSERT (err == 0); ACE_UNUSED_ARG (err); if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Activator registered for %s.\n", aname)); return token; }

void ImR_Locator_i::remove_server (  const char *  name  )  [virtual]

Definition at line 844 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_ERROR, findPOA(), Locator_Repository::get_server(), CORBA::is_nil(), LM_DEBUG, LM_ERROR, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), read_only_, Locator_Repository::remove_server(), Server_Info_Ptr, and TAO_IMPLREPO_MINOR_CODE. { ACE_ASSERT (name != 0); if (this->read_only_) { ACE_ERROR ((LM_ERROR, "ImR: Can't remove server <%s> due to locked database.\n", name)); throw CORBA::NO_PERMISSION ( CORBA::SystemException::_tao_minor_code ( TAO_IMPLREPO_MINOR_CODE, 0), CORBA::COMPLETED_NO); } // Note : This will be safe, because any Server_Info_Ptr objects will still // be valid, and the actual Server_Info will be destroyed when the last // one goes out of scope. Server_Info_Ptr info = this->repository_.get_server (name); if (! info.null ()) { if (this->repository_.remove_server (name) == 0) { if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Removing Server <%s>...\n", name)); PortableServer::POA_var poa = findPOA (name); if (! CORBA::is_nil (poa.in ())) { bool etherealize = true; bool wait = false; poa->destroy (etherealize, wait); } if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Removed Server <%s>.\n", name)); } } else { ACE_ERROR ((LM_ERROR, "ImR: Can't remove unknown server <%s>.\n", name)); throw ImplementationRepository::NotFound (); } }

int ImR_Locator_i::run (  void   )

Run using the orb reference created during init(). Definition at line 187 of file ImR_Locator_i.cpp. References ACE_DEBUG, auto_start_servers(), ior_multicast_, LM_DEBUG, ACE_Time_Value::msec(), ping_interval_, read_only_, Locator_Repository::repo_mode(), ACE_Time_Value::sec(), and startup_timeout_. Referenced by ImR_Locator_Loader::run(), run_standalone(), and Locator_NT_Service::svc(). { if (debug_ > 0) { // This debug message was split into two calls to // work around yet another bug in Visual Studio 2005. // When this was a single debug message, the value for // debug () came out garbled and the read-only string // caused an ACCESS VIOLATION -- Chad Elliott 10/4/2006 ACE_DEBUG ((LM_DEBUG, "Implementation Repository: Running\n" "\tPing Interval : %dms\n" "\tStartup Timeout : %ds\n" "\tPersistence : %s\n" "\tMulticast : %s\n", ping_interval_.msec (), startup_timeout_.sec (), repository_.repo_mode (), ior_multicast_.reactor () != 0 ? "Enabled" : "Disabled")); ACE_DEBUG ((LM_DEBUG, "\tDebug : %d\n" "\tLocked : %s\n\n", debug (), read_only_ ? "True" : "False")); } this->auto_start_servers (); this->orb_->run (); return 0; }

void ImR_Locator_i::server_is_running (  const char *  name, const char *  partial_ior, ImplementationRepository::ServerObject_ptr  server_object )  [virtual]

Definition at line 967 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_TEXT(), Locator_Repository::add_server(), DEFAULT_START_LIMIT, Locator_Repository::get_server(), LM_DEBUG, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), Server_Info_Ptr, AsyncStartupWaiter_i::unblock_one(), Locator_Repository::update_server(), and waiter_svt_. { ACE_ASSERT (name != 0); ACE_ASSERT (partial_ior != 0); ACE_ASSERT (! CORBA::is_nil (server)); if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Server %s is running at %s.\n", name, partial_ior)); CORBA::String_var ior = orb_->object_to_string (server); if (this->debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR: Server %s callback at %s.\n", name, ior.in ())); Server_Info_Ptr info = this->repository_.get_server (name); if (info.null ()) { if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Auto adding NORMAL server <%s>.\n", name)); ImplementationRepository::EnvironmentList env (0); this->repository_.add_server (name, "", // no activator "", // no cmdline ImplementationRepository::EnvironmentList (), "", // no working dir ImplementationRepository::NORMAL, DEFAULT_START_LIMIT, partial_ior, ior.in (), ImplementationRepository::ServerObject::_nil () // Will connect at first access ); } else { if (info->activation_mode != ImplementationRepository::PER_CLIENT) { info->ior = ior.in (); info->partial_ior = partial_ior; info->server = ImplementationRepository::ServerObject::_nil (); // Will connect at first access int err = this->repository_.update_server (*info); ACE_ASSERT (err == 0); ACE_UNUSED_ARG (err); waiter_svt_.unblock_one (name, 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, 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"))); } } } }

void ImR_Locator_i::server_is_shutting_down (  const char *  name  )  [virtual]

Definition at line 1032 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, Locator_Repository::get_server(), LM_DEBUG, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), ACE_Strong_Bound_Ptr< X, ACE_LOCK >::reset(), Server_Info_Ptr, and Locator_Repository::update_server(). { ACE_ASSERT (server != 0); Server_Info_Ptr info = this->repository_.get_server (server); if (info.null ()) { if (this->debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR_Locator_i::server_is_shutting_down: Unknown server:%s\n", server)); } return; } if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Server <%s> is shutting down.\n", server)); info->reset (); int err = this->repository_.update_server (*info); ACE_ASSERT (err == 0); ACE_UNUSED_ARG (err); }

CORBA::Object_ptr ImR_Locator_i::set_timeout_policy (  CORBA::Object_ptr  obj, const ACE_Time_Value &  to )  [private]

Definition at line 721 of file ImR_Locator_i.cpp. References CORBA::Object::_duplicate(), ACE_DEBUG, CORBA::is_nil(), and LM_DEBUG. Referenced by connect_activator(), connect_server(), init_with_orb(), and shutdown_server(). { CORBA::Object_var ret (CORBA::Object::_duplicate (obj)); try { TimeBase::TimeT timeout; ORBSVCS_Time::Time_Value_to_TimeT (timeout, to); CORBA::Any tmp; tmp <<= timeout; CORBA::PolicyList policies (1); policies.length (1); policies[0] = orb_->create_policy (Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE, tmp); ret = obj->_set_policy_overrides (policies, CORBA::ADD_OVERRIDE); policies[0]->destroy (); if (CORBA::is_nil (ret.in ())) { if (this->debug_ > 0) { ACE_DEBUG ((LM_DEBUG, "ImR: Unable to set timeout policy.\n")); } ret = CORBA::Object::_duplicate (obj); } } catch (const CORBA::Exception& ex) { ex._tao_print_exception ( "ImR_Locator_i::set_timeout_policy ()"); } return ret._retn (); }

int ImR_Locator_i::setup_multicast (  ACE_Reactor *  reactor, const char *  ior )  [private]

Definition at line 311 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_CString, ACE_DEBUG, ACE_DEFAULT_MULTICAST_ADDR, ACE_OS::atoi(), ACE_OS::getenv(), ior_multicast_, LM_DEBUG, TAO_ORB_Parameters::mcast_discovery_endpoint(), TAO_ORB_Core::orb_params(), ACE_Reactor::register_handler(), TAO_ORB_Parameters::service_port(), TAO_DEFAULT_IMPLREPO_SERVER_REQUEST_PORT, TAO_ORB_Core_instance(), and TAO_SERVICEID_IMPLREPOSERVICE. Referenced by init_with_orb(). { ACE_ASSERT (reactor != 0); ACE_ASSERT (ior != 0); #if defined (ACE_HAS_IP_MULTICAST) TAO_ORB_Core* core = TAO_ORB_Core_instance (); // See if the -ORBMulticastDiscoveryEndpoint option was specified. ACE_CString mde (core->orb_params ()->mcast_discovery_endpoint ()); if (mde.length () != 0) { if (this->ior_multicast_.init (ior, mde.c_str (), TAO_SERVICEID_IMPLREPOSERVICE) == -1) { return -1; } } else { // Port can be specified as param, env var, or default CORBA::UShort port = core->orb_params ()->service_port (TAO::MCAST_IMPLREPOSERVICE); if (port == 0) { // Check environment var. for multicast port. const char* port_number = ACE_OS::getenv ("ImplRepoServicePort"); if (port_number != 0) port = static_cast<CORBA::UShort> (ACE_OS::atoi (port_number)); } if (port == 0) port = TAO_DEFAULT_IMPLREPO_SERVER_REQUEST_PORT; if (this->ior_multicast_.init (ior, port, ACE_DEFAULT_MULTICAST_ADDR, TAO_SERVICEID_IMPLREPOSERVICE) == -1) { return -1; } } // Register event handler for the ior multicast. if (reactor->register_handler (&this->ior_multicast_, ACE_Event_Handler::READ_MASK) == -1) { if (debug_ >= 1) ACE_DEBUG ((LM_DEBUG, "ImR: cannot register Event handler\n")); return -1; } #else /* ACE_HAS_IP_MULTICAST*/ ACE_UNUSED_ARG (reactor); ACE_UNUSED_ARG (ior); #endif /* ACE_HAS_IP_MULTICAST*/ return 0; }

void ImR_Locator_i::shutdown (  CORBA::Boolean  activators, CORBA::Boolean  servers )  [virtual]

Definition at line 219 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_ERROR, Activator_Info_Ptr, Locator_Repository::activators(), connect_activator(), CORBA::is_nil(), LM_DEBUG, LM_ERROR, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), ACE_Vector< T, DEFAULT_SIZE >::push_back(), Locator_Repository::servers(), shutdown(), and ACE_Vector< T, DEFAULT_SIZE >::size(). { if (servers != 0 && this->repository_.servers ().current_size () > 0) { // Note : shutdown is oneway, so we can't throw ACE_ERROR ((LM_ERROR, "ImR: Shutdown of all servers not implemented.\n")); } if (activators != 0 && this->repository_.activators ().current_size () > 0) { ACE_Vector<ImplementationRepository::Activator_var> acts; Locator_Repository::AIMap::ENTRY* entry = 0; Locator_Repository::AIMap::ITERATOR it (this->repository_.activators ()); for (;it.next (entry) != 0; it.advance ()) { Activator_Info_Ptr info = entry->int_id_; ACE_ASSERT (! info.null ()); connect_activator (*info); if (! CORBA::is_nil (info->activator.in ())) acts.push_back (info->activator); } int shutdown_errs = 0; for (size_t i = 0; i < acts.size (); ++i) { try { acts[i]->shutdown (); acts[i] = ImplementationRepository::Activator::_nil (); } catch (const CORBA::Exception& ex) { ++shutdown_errs; if (debug_ > 1) { ex._tao_print_exception ( "ImR: shutdown activator"); } } } if (debug_ > 0 && shutdown_errs > 0) { ACE_DEBUG ((LM_DEBUG, "ImR: Some activators could not be shut down.\n")); } } // Technically, we should wait for all the activators to unregister, but // ,for now at least, it doesn't seem worth it. this->shutdown (false); }

void ImR_Locator_i::shutdown (  bool  wait_for_completion  )

Shutdown the orb. Definition at line 270 of file ImR_Locator_i.cpp. Referenced by ImR_Locator_Shutdown::operator()(), and shutdown(). { this->orb_->shutdown (wait_for_completion); }

void ImR_Locator_i::shutdown_server (  const char *  name  )  [virtual]

Definition at line 904 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_ERROR, connect_server(), DEFAULT_SHUTDOWN_TIMEOUT, Locator_Repository::get_server(), CORBA::is_nil(), LM_DEBUG, LM_ERROR, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), ACE_Strong_Bound_Ptr< X, ACE_LOCK >::reset(), Server_Info_Ptr, set_timeout_policy(), and Locator_Repository::update_server(). { ACE_ASSERT (server != 0); if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Shutting down server <%s>.\n", server)); Server_Info_Ptr info = this->repository_.get_server (server); if (info.null ()) { ACE_ERROR ((LM_ERROR, "ImR: shutdown_server () Cannot find info for server <%s>\n", server)); throw ImplementationRepository::NotFound (); } connect_server (*info); if (CORBA::is_nil (info->server.in ())) { ACE_ERROR ((LM_ERROR, "ImR: shutdown_server () Cannot connect to server <%s>\n", server)); throw ImplementationRepository::NotFound (); } try { CORBA::Object_var obj = set_timeout_policy (info->server.in (), DEFAULT_SHUTDOWN_TIMEOUT); ImplementationRepository::ServerObject_var server = ImplementationRepository::ServerObject::_unchecked_narrow (obj.in ()); server->shutdown (); } catch (const CORBA::TIMEOUT&) { info->reset (); int err = this->repository_.update_server (*info); ACE_ASSERT (err == 0); ACE_UNUSED_ARG (err); // 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, "ImR: Timeout while waiting for <%s> shutdown.\n", server)); } throw; } catch (const CORBA::Exception&) { if (this->debug_ > 1) { ACE_DEBUG ((LM_DEBUG, "ImR: Exception ignored while shutting down <%s>\n", 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->reset (); int err = this->repository_.update_server (*info); ACE_ASSERT (err == 0); ACE_UNUSED_ARG (err); }

ImplementationRepository::StartupInfo * ImR_Locator_i::start_server (  Server_Info &  info, bool  manual_start, int &  waiting_clients )  [private]

Definition at line 584 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, Server_Info::activation_mode, Server_Info::activator, Activator_Info_Ptr, Server_Info::cmdline, Server_Info::dir, Server_Info::env_vars, get_activator(), CORBA::is_nil(), LM_DEBUG, Server_Info::name, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), Server_Info::partial_ior, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::reset(), Server_Info::reset(), Server_Info::start_count, Server_Info::start_limit, Server_Info::starting, and waiter_. Referenced by activate_perclient_server_i(), and activate_server_i(). { if (info.activation_mode == ImplementationRepository::MANUAL && ! manual_start) { if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Cannot start server <%s>. ActivationMode=MANUAL\n", info.name.c_str ())); throw ImplementationRepository::CannotActivate( CORBA::string_dup ( "Cannot implicitly activate MANUAL server.")); } if (info.cmdline.length () == 0) { if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Cannot start server <%s>." " No command line.\n", info.name.c_str ())); throw ImplementationRepository::CannotActivate( CORBA::string_dup ( "No command line registered for server.")); } Activator_Info_Ptr ainfo = get_activator (info.activator); if (ainfo.null () || CORBA::is_nil (ainfo->activator.in ())) { if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Cannot start server <%s>. " "Activator <%s> not found.\n", info.name.c_str (), info.activator.c_str ())); throw ImplementationRepository::CannotActivate( CORBA::string_dup ( "No activator registered for server.")); } try { ++waiting_clients; if (waiting_clients <= 1 || info.activation_mode == ImplementationRepository::PER_CLIENT) { info.starting = true; ++info.start_count; ACE_ASSERT (info.start_count <= info.start_limit); if (this->debug_ > 0) { ACE_DEBUG ((LM_DEBUG, "ImR: Starting server <%s>. 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, "ImR: Waiting for <%s> to start...\n", info.name.c_str ())); } ImplementationRepository::StartupInfo_var si = waiter_->wait_for_startup (info.name.c_str ()); --waiting_clients; info.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, "ImR: <%s> Skipping wait. Already started.\n", info.name.c_str ())); } --waiting_clients; info.starting = false; } } catch (const CORBA::TIMEOUT&) { --waiting_clients; info.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, "ImR : Timeout waiting for <%s> to start.\n", info.name.c_str ())); info.reset (); } } catch (const ImplementationRepository::CannotActivate&) { --waiting_clients; info.starting = false; info.reset (); if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Activator cannot start <%s>.\n", info.name.c_str ())); } catch (const CORBA::Exception& ex) { --waiting_clients; info.starting = false; if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Unexpected exception while starting <%s>.\n", info.name.c_str ())); if (debug_ > 1) ex._tao_print_exception (""); info.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 }

void ImR_Locator_i::teardown_multicast (   )  [private]

Definition at line 301 of file ImR_Locator_i.cpp. References ior_multicast_, and ACE_Reactor::remove_handler(). Referenced by fini(). { ACE_Reactor* r = ior_multicast_.reactor (); if (r != 0) { r->remove_handler (&ior_multicast_, ACE_Event_Handler::READ_MASK); ior_multicast_.reactor (0); } }

void ImR_Locator_i::unregister_activator (  const char *  name, CORBA::Long  token )  [virtual]

Definition at line 394 of file ImR_Locator_i.cpp. References ACE_ASSERT, ACE_DEBUG, Activator_Info_Ptr, get_activator(), LM_DEBUG, ACE_Strong_Bound_Ptr< X, ACE_LOCK >::null(), and unregister_activator_i(). { ACE_ASSERT (aname != 0); Activator_Info_Ptr info = this->get_activator (aname); if (! info.null ()) { if (info->token != token && this->debug_ > 0) { ACE_DEBUG ((LM_DEBUG, "ImR: Ignoring unregister activator:%s. Wrong token.\n", aname)); return; } this->unregister_activator_i (aname); if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Activator %s unregistered.\n", aname)); } else { if (this->debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR: Ignoring unregister activator:%s. Unknown activator.\n", aname)); } }

void ImR_Locator_i::unregister_activator_i (  const char *  activator  )  [private]

Definition at line 421 of file ImR_Locator_i.cpp. References ACE_ASSERT, and Locator_Repository::remove_activator(). Referenced by register_activator(), and unregister_activator(). { ACE_ASSERT (aname != 0); int err = this->repository_.remove_activator (aname); ACE_UNUSED_ARG (err); }

---

Member Data Documentation

ImR_Adapter ImR_Locator_i::adapter_ [private]

Definition at line 132 of file ImR_Locator_i.h.

int ImR_Locator_i::debug_ [private]

Definition at line 141 of file ImR_Locator_i.h.

ImR_Forwarder ImR_Locator_i::forwarder_ [private]

Definition at line 129 of file ImR_Locator_i.h. Referenced by init_with_orb().

PortableServer::POA_var ImR_Locator_i::imr_poa_ [private]

Definition at line 139 of file ImR_Locator_i.h.

IORTable::Locator_var ImR_Locator_i::ins_locator_ [private]

The locator interface for the IORTable. Definition at line 135 of file ImR_Locator_i.h. Referenced by ImR_Locator_i().

TAO_IOR_Multicast ImR_Locator_i::ior_multicast_ [private]

Definition at line 143 of file ImR_Locator_i.h. Referenced by run(), setup_multicast(), and teardown_multicast().

CORBA::ORB_var ImR_Locator_i::orb_ [private]

Definition at line 137 of file ImR_Locator_i.h.

ACE_Time_Value ImR_Locator_i::ping_interval_ [private]

Definition at line 152 of file ImR_Locator_i.h. Referenced by init_with_orb(), is_alive_i(), and run().

bool ImR_Locator_i::read_only_ [private]

Definition at line 150 of file ImR_Locator_i.h. Referenced by add_or_update_server(), init_with_orb(), remove_server(), and run().

Locator_Repository ImR_Locator_i::repository_ [private]

Definition at line 145 of file ImR_Locator_i.h.

PortableServer::POA_var ImR_Locator_i::root_poa_ [private]

Definition at line 138 of file ImR_Locator_i.h.

ACE_Time_Value ImR_Locator_i::startup_timeout_ [private]

Definition at line 151 of file ImR_Locator_i.h. Referenced by connect_activator(), init_with_orb(), and run().

ImplementationRepository::AsyncStartupWaiter_var ImR_Locator_i::waiter_ [private]

Definition at line 148 of file ImR_Locator_i.h. Referenced by init_with_orb(), and start_server().

AsyncStartupWaiter_i ImR_Locator_i::waiter_svt_ [private]

Definition at line 147 of file ImR_Locator_i.h. Referenced by activate_server_i(), init_with_orb(), and server_is_running().

---

The documentation for this class was generated from the following files:

• ImR_Locator_i.h
• ImR_Locator_i.cpp

---