ImR_Activator_i Class Reference

IMR Activator Interface. More...

#include <ImR_Activator_i.h>

Inheritance diagram for ImR_Activator_i:

[legend]Collaboration diagram for ImR_Activator_i:

[legend]List of all members.

Public Member Functions
	ImR_Activator_i (void)
void	start_server (const char *name, const char *cmdline, const char *dir, const ImplementationRepository::EnvironmentList &env)
void	shutdown (void)
int	init (Activator_Options &opts)
	Initialize the Server state - parsing arguments and waiting.
int	fini (void)
	Cleans up any state created by init*.
int	run (void)
	Runs the orb.
void	shutdown (bool wait_for_completion)
	Shutdown the orb.
Private Types
typedef ACE_Hash_Map_Manager_Ex< pid_t, ACE_CString, ACE_Hash_pid_t, ACE_Equal_To_pid_t, ACE_Null_Mutex >	ProcessMap
Private Member Functions
int	init_with_orb (CORBA::ORB_ptr orb, const Activator_Options &opts)
void	register_with_imr (ImplementationRepository::Activator_ptr activator)
int	handle_exit (ACE_Process *process)
Private Attributes
ACE_Process_Manager	process_mgr_
PortableServer::POA_var	root_poa_
PortableServer::POA_var	imr_poa_
ImplementationRepository::Locator_var	locator_
CORBA::Long	registration_token_
CORBA::ORB_var	orb_
unsigned int	debug_
bool	notify_imr_
ACE_CString	name_
ProcessMap	process_map_
int	env_buf_len_
	The default environment buffer length.

---

Detailed Description

IMR Activator Interface.

This class provides the interface for the various activities that can be done by the ImR_Activator.

Definition at line 60 of file ImR_Activator_i.h.

---

Member Typedef Documentation

typedef ACE_Hash_Map_Manager_Ex<pid_t, ACE_CString, ACE_Hash_pid_t, ACE_Equal_To_pid_t, ACE_Null_Mutex> ImR_Activator_i::ProcessMap [private]

Definition at line 102 of file ImR_Activator_i.h.

---

Constructor & Destructor Documentation

ImR_Activator_i::ImR_Activator_i (  void   )

Definition at line 22 of file ImR_Activator_i.cpp. References getHostName(). : registration_token_(0) , debug_(0) , notify_imr_ (false) , name_ (getHostName ()) , env_buf_len_ (Activator_Options::ENVIRONMENT_BUFFER) { }

---

Member Function Documentation

int ImR_Activator_i::fini (  void   )

Cleans up any state created by init*. Definition at line 204 of file ImR_Activator_i.cpp. References ACE_DEBUG, ACE_Process_Manager::close(), CORBA::is_nil(), LM_DEBUG, process_mgr_, and registration_token_. Referenced by ImR_Activator_Loader::fini(), run_standalone(), and Activator_NT_Service::svc(). { try { if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR Activator: Shutting down...\n")); this->process_mgr_.close (); this->root_poa_->destroy (1, 1); if (! CORBA::is_nil (this->locator_.in ()) && this->registration_token_ != 0) { this->locator_->unregister_activator (name_.c_str(), this->registration_token_); } } catch (const CORBA::COMM_FAILURE&) { if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR Activator: Unable to unregister from ImR.\n")); } catch (const CORBA::TRANSIENT&) { if (debug_ > 1) ACE_DEBUG ((LM_DEBUG, "ImR Activator: Unable to unregister from ImR.\n")); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("ImR Activator: fini"); throw; } try { this->orb_->destroy (); if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR Activator: Shut down successfully.\n")); } catch (const CORBA::Exception& ex) { ex._tao_print_exception ("ImR Activator: fini 2"); throw; } return 0; }

int ImR_Activator_i::handle_exit (  ACE_Process *  process  )  [private, virtual]

Reimplemented from ACE_Event_Handler. Definition at line 341 of file ImR_Activator_i.cpp. References ACE_CString, ACE_DEBUG, ACE_TEXT, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::find(), ACE_Process::getpid(), CORBA::is_nil(), LM_DEBUG, process_map_, ACE_Process::return_value(), and ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::unbind(). { // We use the process_manager so that we're notified when // any of our launched processes die. We notify the locator // when this happens. if (debug_ > 0) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Process %d exited with exit code %d\n"), process->getpid (), process->return_value ())); } ACE_CString name; if (this->process_map_.find (process->getpid (), name) == 0) { this->process_map_.unbind (process->getpid ()); if (!CORBA::is_nil (this->locator_.in ())) { if (debug_ > 1) { ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ImR Activator: Notifying ImR that %s has exited.\n"), name.c_str())); } this->locator_->notify_child_death (name.c_str()); } } return 0; }

int ImR_Activator_i::init (  Activator_Options &  opts  )

Initialize the Server state - parsing arguments and waiting. Definition at line 186 of file ImR_Activator_i.cpp. References ACE_ARGV, ACE_CString, Activator_Options::cmdline(), init_with_orb(), and CORBA::ORB_init(). Referenced by ImR_Activator_Loader::init(), run_standalone(), and Activator_NT_Service::svc(). { ACE_CString cmdline = opts.cmdline(); // Must use IOR style objrefs, because URLs sometimes get mangled when passed // to ACE_Process::spawn(). cmdline += "-ORBUseImR 0 -ORBObjRefStyle IOR "; ACE_ARGV av (cmdline.c_str ()); int argc = av.argc (); CORBA::ORB_var orb = CORBA::ORB_init (argc, av.argv (), "TAO_ImR_Activator"); int ret = this->init_with_orb(orb.in (), opts); return ret; }

int ImR_Activator_i::init_with_orb (  CORBA::ORB_ptr  orb, const Activator_Options &  opts )  [private]

Definition at line 99 of file ImR_Activator_i.cpp. References CORBA::ORB::_duplicate(), ACE_ASSERT, ACE_DEBUG, ACE_ERROR_RETURN, createPersistentPOA(), Activator_Options::debug(), Activator_Options::env_buf_len(), ACE_OS::fclose(), ACE_OS::fopen(), ACE_OS::fprintf(), imr_poa_, ACE_Reactor::instance(), Activator_Options::ior_filename(), LM_DEBUG, LM_ERROR, Activator_Options::name(), Activator_Options::notify_imr(), ACE_Process_Manager::open(), process_mgr_, register_with_imr(), and PortableServer::string_to_ObjectId(). Referenced by init(). { ACE_ASSERT(! CORBA::is_nil (orb)); orb_ = CORBA::ORB::_duplicate (orb); debug_ = opts.debug (); notify_imr_ = opts.notify_imr (); env_buf_len_ = opts.env_buf_len (); 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::Activator_var activator = ImplementationRepository::Activator::_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) ACE_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) { ACE_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) { ACE_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) { ACE_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_Activator_i::register_with_imr (  ImplementationRepository::Activator_ptr  activator  )  [private]

Definition at line 60 of file ImR_Activator_i.cpp. References ACE_DEBUG, CORBA::is_nil(), LM_DEBUG, ACE_Process_Manager::open(), process_mgr_, and registration_token_. Referenced by init_with_orb(). { try { if (this->debug_ > 1) ACE_DEBUG( (LM_DEBUG, "ImR Activator: Contacting ImplRepoService...\n")); // First, resolve the ImR, without this we can go no further CORBA::Object_var obj = orb_->resolve_initial_references ("ImplRepoService"); this->process_mgr_.open (ACE_Process_Manager::DEFAULT_SIZE, this->orb_->orb_core ()->reactor ()); locator_ = ImplementationRepository::Locator::_narrow (obj.in ()); if (!CORBA::is_nil (locator_.in ())) { this->registration_token_ = locator_->register_activator (name_.c_str (), activator); if (debug_ > 0) ACE_DEBUG((LM_DEBUG, "ImR Activator: Registered with ImR.\n")); return; } } catch (const CORBA::Exception& ex) { if (debug_ > 1) ex._tao_print_exception ( "ImR Activator: Can't register with ImR."); } if (debug_ > 0) ACE_DEBUG ((LM_DEBUG, "ImR Activator: Not registered with ImR.\n")); }

int ImR_Activator_i::run (  void   )

Runs the orb. Definition at line 253 of file ImR_Activator_i.cpp. Referenced by ImR_Activator_Loader::run(), run_standalone(), and Activator_NT_Service::svc(). { this->orb_->run (); return 0; }

void ImR_Activator_i::shutdown (  bool  wait_for_completion  )

Shutdown the orb. Definition at line 266 of file ImR_Activator_i.cpp. { this->orb_->shutdown (wait_for_completion); }

void ImR_Activator_i::shutdown (  void   )

Definition at line 260 of file ImR_Activator_i.cpp. Referenced by ImR_Activator_Shutdown::operator()(). { this->shutdown (false); }

void ImR_Activator_i::start_server (  const char *  name, const char *  cmdline, const char *  dir, const ImplementationRepository::EnvironmentList &  env )

Definition at line 272 of file ImR_Activator_i.cpp. References ACE_DEBUG, ACE_ERROR, ACE_INVALID_PID, ACE_Process_Options::command_line(), ACE_Process_Options::handle_inheritence(), CORBA::is_nil(), LM_DEBUG, LM_ERROR, process_map_, process_mgr_, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::rebind(), ACE_Process_Manager::register_handler(), ACE_Process_Options::setenv(), ACE_Process_Manager::spawn(), and ACE_Process_Options::working_directory(). { if (debug_ > 1) ACE_DEBUG((LM_DEBUG, "ImR Activator: Starting server <%s>...\n", name)); if (debug_ > 1) ACE_DEBUG((LM_DEBUG, "\tcommand line : <%s>\n\tdirectory : <%s>\n", cmdline, dir)); ACE_Process_Options proc_opts ( 1, ACE_Process_Options::DEFAULT_COMMAND_LINE_BUF_LEN, this->env_buf_len_); proc_opts.command_line (cmdline); proc_opts.working_directory (dir); // Win32 does not support the CLOSE_ON_EXEC semantics for sockets // the way unix does, so in order to avoid having the child process // hold the listen socket open, we force the child to inherit no // handles. This includes stdin, stdout, logs, etc. proc_opts.handle_inheritence (0); proc_opts.setenv ("TAO_USE_IMR", "1"); if (!CORBA::is_nil (this->locator_.in ())) { CORBA::String_var ior = orb_->object_to_string (locator_.in ()); proc_opts.setenv ("ImplRepoServiceIOR", ior.in()); } for (CORBA::ULong i = 0; i < env.length (); ++i) { proc_opts.setenv (env[i].name.in (), env[i].value.in ()); } int pid = this->process_mgr_.spawn (proc_opts); if (pid == ACE_INVALID_PID) { ACE_ERROR ((LM_ERROR, "ImR Activator: Cannot start server <%s> using <%s>\n", name, cmdline)); throw ImplementationRepository::CannotActivate( CORBA::string_dup ( "Process Creation Failed")); return; } else { if (debug_ > 1) { ACE_DEBUG((LM_DEBUG, "ImR Activator: register death handler for process %d\n", pid)); } this->process_mgr_.register_handler (this, pid); // We only bind to the process_map_ if we want to notify // the locator of a process' death. if (notify_imr_) { this->process_map_.rebind (pid, name); } } if (debug_ > 0) { ACE_DEBUG ((LM_DEBUG, "ImR Activator: Successfully started <%s>. \n", name)); } }

---

Member Data Documentation

unsigned int ImR_Activator_i::debug_ [private]

Definition at line 117 of file ImR_Activator_i.h.

int ImR_Activator_i::env_buf_len_ [private]

The default environment buffer length. Definition at line 126 of file ImR_Activator_i.h.

PortableServer::POA_var ImR_Activator_i::imr_poa_ [private]

Definition at line 107 of file ImR_Activator_i.h. Referenced by init_with_orb().

ImplementationRepository::Locator_var ImR_Activator_i::locator_ [private]

Definition at line 109 of file ImR_Activator_i.h.

ACE_CString ImR_Activator_i::name_ [private]

Definition at line 121 of file ImR_Activator_i.h.

bool ImR_Activator_i::notify_imr_ [private]

Definition at line 119 of file ImR_Activator_i.h.

CORBA::ORB_var ImR_Activator_i::orb_ [private]

Definition at line 115 of file ImR_Activator_i.h.

ProcessMap ImR_Activator_i::process_map_ [private]

Definition at line 123 of file ImR_Activator_i.h. Referenced by handle_exit(), and start_server().

ACE_Process_Manager ImR_Activator_i::process_mgr_ [private]

Definition at line 104 of file ImR_Activator_i.h. Referenced by fini(), init_with_orb(), register_with_imr(), and start_server().

CORBA::Long ImR_Activator_i::registration_token_ [private]

We're given a token when registering with the locator, which we must use when unregistering. Definition at line 113 of file ImR_Activator_i.h. Referenced by fini(), and register_with_imr().

PortableServer::POA_var ImR_Activator_i::root_poa_ [private]

Definition at line 106 of file ImR_Activator_i.h.

---

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

• ImR_Activator_i.h
• ImR_Activator_i.cpp

---