ACE_Service_Gestalt Class Reference

Supplies common server operations for dynamic and static configuration of services. More...

#include <Service_Gestalt.h>

Inheritance diagram for ACE_Service_Gestalt:

[legend]Collaboration diagram for ACE_Service_Gestalt:

[legend]List of all members.

Public Types
enum	{ MAX_SERVICES = ACE_DEFAULT_SERVICE_REPOSITORY_SIZE }
Public Member Functions
	ACE_Service_Gestalt (size_t size, bool svc_repo_is_owned=true, bool no_static_svcs=true)
virtual	~ACE_Service_Gestalt (void)
void	dump (void) const
	Dump the state of an object.
int	open (const ACE_TCHAR program_name[], const ACE_TCHAR *logger_key=ACE_DEFAULT_LOGGER_KEY, int ignore_static_svcs=1, int ignore_default_svc_conf_file=0, int ignore_debug_flag=0)
int	open (int argc, ACE_TCHAR *argv[], const ACE_TCHAR *logger_key=ACE_DEFAULT_LOGGER_KEY, int ignore_static_svcs=1, int ignore_default_svc_conf_file=0, int ignore_debug_flag=0)
int	is_opened (void)
int	process_directive (const ACE_TCHAR directive[])
int	process_directive (const ACE_Static_Svc_Descriptor &ssd, int force_replace=0)
	Process one static service definition.
int	process_file (const ACE_TCHAR file[])
int	find (const ACE_TCHAR name[], const ACE_Service_Type **srp=0, int ignore_suspended=1) const
	Searches for a service object declaration in the local repo, only.
int	parse_args (int, ACE_TCHAR *argv[])
int	process_directives (void)
int	close (void)
int	insert (ACE_Static_Svc_Descriptor *stsd)
int	initialize (const ACE_Service_Type_Factory *, const ACE_TCHAR *parameters)
int	initialize (const ACE_Service_Type *, const ACE_TCHAR *parameters)
int	initialize (const ACE_TCHAR *svc_name, const ACE_TCHAR *parameters)
	Initialize and activate a statically svc_name service.
int	resume (const ACE_TCHAR svc_name[])
int	suspend (const ACE_TCHAR svc_name[])
int	remove (const ACE_TCHAR svc_name[])
int	find_static_svc_descriptor (const ACE_TCHAR *name, ACE_Static_Svc_Descriptor **ssd=0) const
	Find a static service descriptor by name.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Types
typedef ACE_Unbounded_Queue< ACE_TString >	ACE_SVC_QUEUE
typedef ACE_Unbounded_Queue_Iterator< ACE_TString >	ACE_SVC_QUEUE_ITERATOR
typedef ACE_Unbounded_Set< ACE_Static_Svc_Descriptor * >	ACE_STATIC_SVCS
typedef ACE_Unbounded_Set_Iterator< ACE_Static_Svc_Descriptor * >	ACE_STATIC_SVCS_ITERATOR
typedef ACE_Unbounded_Set< Processed_Static_Svc * >	ACE_PROCESSED_STATIC_SVCS
typedef ACE_Unbounded_Set_Iterator< Processed_Static_Svc * >	ACE_PROCESSED_STATIC_SVCS_ITERATOR
Protected Member Functions
virtual int	parse_args_i (int, ACE_TCHAR *argv[])
virtual int	open_i (const ACE_TCHAR program_name[], const ACE_TCHAR *logger_key=ACE_DEFAULT_LOGGER_KEY, bool ignore_static_svcs=true, bool ignore_default_svc_conf_file=false, bool ignore_debug_flag=false)
int	init_svc_conf_file_queue (void)
	Initialize the if necessary.
int	load_static_svcs (void)
int	process_commandline_directives (void)
int	process_directive_i (const ACE_Static_Svc_Descriptor &ssd, int force_replace=0)
int	process_directives_i (ACE_Svc_Conf_Param *param)
int	initialize_i (const ACE_Service_Type *sr, const ACE_TCHAR *parameters)
const ACE_Static_Svc_Descriptor *	find_processed_static_svc (const ACE_TCHAR *)
void	add_processed_static_svc (const ACE_Static_Svc_Descriptor *)
Protected Attributes
bool	svc_repo_is_owned_
int	is_opened_
const ACE_TCHAR *	logger_key_
int	no_static_svcs_
	Should we avoid loading the static services?
ACE_SVC_QUEUE *	svc_queue_
	Queue of services specified on the command-line.
ACE_SVC_QUEUE *	svc_conf_file_queue_
ACE_Service_Repository *	repo_
	The service repository to hold the services.
ACE_STATIC_SVCS *	static_svcs_
	Repository of statically linked services.
ACE_PROCESSED_STATIC_SVCS *	processed_static_svcs_
Private Member Functions
	ACE_Service_Gestalt (const ACE_Service_Gestalt &)
ACE_Service_Gestalt &	operator= (const ACE_Service_Gestalt &)
Friends
class	ACE_Dynamic_Service_Base
class	ACE_Service_Object
class	ACE_Service_Config_Guard

---

Detailed Description

Supplies common server operations for dynamic and static configuration of services.

Definition at line 47 of file Service_Gestalt.h.

---

Member Typedef Documentation

typedef ACE_Unbounded_Set<Processed_Static_Svc *> ACE_Service_Gestalt::ACE_PROCESSED_STATIC_SVCS [protected]

Definition at line 365 of file Service_Gestalt.h. Referenced by add_processed_static_svc().

typedef ACE_Unbounded_Set_Iterator<Processed_Static_Svc *> ACE_Service_Gestalt::ACE_PROCESSED_STATIC_SVCS_ITERATOR [protected]

Definition at line 368 of file Service_Gestalt.h. Referenced by add_processed_static_svc(), close(), find_processed_static_svc(), and ~ACE_Service_Gestalt().

typedef ACE_Unbounded_Set<ACE_Static_Svc_Descriptor *> ACE_Service_Gestalt::ACE_STATIC_SVCS [protected]

Definition at line 359 of file Service_Gestalt.h. Referenced by ACE_Service_Gestalt().

typedef ACE_Unbounded_Set_Iterator<ACE_Static_Svc_Descriptor *> ACE_Service_Gestalt::ACE_STATIC_SVCS_ITERATOR [protected]

Definition at line 362 of file Service_Gestalt.h. Referenced by find_static_svc_descriptor(), and load_static_svcs().

typedef ACE_Unbounded_Queue<ACE_TString> ACE_Service_Gestalt::ACE_SVC_QUEUE [protected]

Definition at line 354 of file Service_Gestalt.h. Referenced by init_svc_conf_file_queue(), and parse_args_i().

typedef ACE_Unbounded_Queue_Iterator<ACE_TString> ACE_Service_Gestalt::ACE_SVC_QUEUE_ITERATOR [protected]

Definition at line 355 of file Service_Gestalt.h. Referenced by process_commandline_directives(), and process_directives().

---

Member Enumeration Documentation

anonymous enum

Enumeration values: MAX_SERVICES  Definition at line 57 of file Service_Gestalt.h. { MAX_SERVICES = ACE_DEFAULT_SERVICE_REPOSITORY_SIZE };

---

Constructor & Destructor Documentation

ACE_Service_Gestalt::ACE_Service_Gestalt (  const ACE_Service_Gestalt &   )  [private]

Not implemented to enforce no copying

ACE_Service_Gestalt::ACE_Service_Gestalt (  size_t  size, bool  svc_repo_is_owned = true, bool  no_static_svcs = true )

Constructor either associates the instance with the process-wide singleton instance of ACE_Service_Repository, or creates and manages its own instance of the specified size. Definition at line 229 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_DEFAULT_LOGGER_KEY, ACE_LIB_TEXT, ACE_NEW_NORETURN, ACE_STATIC_SVCS, ACE::debug(), ACE_Service_Repository::instance(), LM_DEBUG, and processed_static_svcs_. : svc_repo_is_owned_ (svc_repo_is_owned) , is_opened_ (0) , logger_key_ (ACE_DEFAULT_LOGGER_KEY) , no_static_svcs_ (no_static_svcs) , svc_queue_ (0) , svc_conf_file_queue_ (0) { if (svc_repo_is_owned) ACE_NEW_NORETURN (this->repo_, ACE_Service_Repository (size)); else this->repo_ = ACE_Service_Repository::instance (size); ACE_NEW_NORETURN (this->static_svcs_, ACE_STATIC_SVCS); this->processed_static_svcs_ = 0; if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::ctor - this = %@, pss = %@\n"), this, this->processed_static_svcs_)); }

ACE_Service_Gestalt::~ACE_Service_Gestalt (  void   )  [virtual]

Perform user-specified close activities and remove dynamic memory. Definition at line 202 of file Service_Gestalt.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_LIB_TEXT, ACE_PROCESSED_STATIC_SVCS_ITERATOR, ACE_Unbounded_Set_Iterator< T >::advance(), ACE::debug(), ACE_Unbounded_Set< T >::is_empty(), LM_DEBUG, ACE_Unbounded_Set_Iterator< T >::next(), processed_static_svcs_, static_svcs_, and svc_repo_is_owned_. { ACE_ASSERT (this->repo_ != 0); if (this->svc_repo_is_owned_) delete this->repo_; delete this->static_svcs_; // Delete the dynamically allocated static_svcs instance. if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::dtor - this=%@, pss = %@\n"), this, this->processed_static_svcs_)); if (this->processed_static_svcs_ && !this->processed_static_svcs_->is_empty()) { Processed_Static_Svc **pss = 0; for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); iter.next (pss) != 0; iter.advance ()) { delete *pss; } } delete this->processed_static_svcs_; }

---

Member Function Documentation

void ACE_Service_Gestalt::add_processed_static_svc (  const ACE_Static_Svc_Descriptor *   )  [protected]

Definition at line 328 of file Service_Gestalt.cpp. References ACE_NEW, ACE_PROCESSED_STATIC_SVCS, ACE_PROCESSED_STATIC_SVCS_ITERATOR, ACE_Unbounded_Set_Iterator< T >::advance(), ACE_Unbounded_Set_Iterator< T >::next(), and ACE_OS::strcmp(). Referenced by process_directive(). { if (this->processed_static_svcs_ == 0) ACE_NEW (this->processed_static_svcs_, ACE_PROCESSED_STATIC_SVCS); Processed_Static_Svc **pss = 0; for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); iter.next (pss) != 0; iter.advance ()) { if (ACE_OS::strcmp ((*pss)->name_, assd->name_) == 0) { (*pss)->assd_ = assd; return; } } Processed_Static_Svc *tmp = 0; ACE_NEW (tmp,Processed_Static_Svc(assd)); this->processed_static_svcs_->insert(tmp); }

int ACE_Service_Gestalt::close (  void   )

Tidy up and perform last rites when ACE_Service_Config is shut down. This method calls . Returns 0. Reimplemented in ACE_Service_Config. Definition at line 1211 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_LIB_TEXT, ACE_PROCESSED_STATIC_SVCS_ITERATOR, ACE_TRACE, ACE_Unbounded_Set_Iterator< T >::advance(), ACE::debug(), ACE_Unbounded_Set< T >::is_empty(), is_opened_, LM_DEBUG, ACE_Unbounded_Set_Iterator< T >::next(), processed_static_svcs_, static_svcs_, and svc_conf_file_queue_. Referenced by ACE_Service_Config::close(). { ACE_TRACE ("ACE_Service_Gestalt::close"); this->is_opened_--; if (this->is_opened_ > 0) return 0; // Delete the service repository. All the objects inside the // service repository should already have been finalized. // ACE_Service_Config::close_svcs (); // Delete the list fo svc.conf files delete this->svc_conf_file_queue_; this->svc_conf_file_queue_ = 0; // Delete the dynamically allocated static_svcs instance. if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::close - this=%@, repo=%@, pss = %@\n"), this, this->repo_, this->processed_static_svcs_)); delete this->static_svcs_; this->static_svcs_ = 0; if (this->processed_static_svcs_ && !this->processed_static_svcs_->is_empty()) { Processed_Static_Svc **pss = 0; for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); iter.next (pss) != 0; iter.advance ()) { delete *pss; } } delete this->processed_static_svcs_; this->processed_static_svcs_ = 0; if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::close - complete this=%@, repo=%@\n"), this, this->repo_)); return 0; } /* close () */

void ACE_Service_Gestalt::dump (  void   )  const

Dump the state of an object. Reimplemented in ACE_Service_Config. Definition at line 380 of file Service_Gestalt.cpp. References ACE_TRACE. { #if defined (ACE_HAS_DUMP) ACE_TRACE ("ACE_Service_Gestalt::dump"); #endif /* ACE_HAS_DUMP */ }

ACE_INLINE int ACE_Service_Gestalt::find (  const ACE_TCHAR  name[], const ACE_Service_Type **  srp = 0, int  ignore_suspended = 1 )  const

Searches for a service object declaration in the local repo, only. Locate an entry with in the table. If is set then only consider services marked as resumed. If the caller wants the located entry, pass back a pointer to the located entry via . If is not found, -1 is returned. If is found, but it is suspended and the caller wants to ignore suspended services a -2 is returned. Definition at line 54 of file Service_Gestalt.inl. References ACE_ASSERT, ACE_TCHAR, and ACE_Service_Repository::find(). Referenced by ACE_Dynamic_Service_Base::find_i(), and ACE_Static_Node::record(). { ACE_ASSERT (this->repo_ != 0); return this->repo_->find (name, srp, ignore_suspended); }

const ACE_Static_Svc_Descriptor * ACE_Service_Gestalt::find_processed_static_svc (  const ACE_TCHAR *   )  [protected]

Definition at line 313 of file Service_Gestalt.cpp. References ACE_PROCESSED_STATIC_SVCS_ITERATOR, ACE_TCHAR, ACE_Unbounded_Set_Iterator< T >::advance(), ACE_Unbounded_Set_Iterator< T >::next(), and ACE_OS::strcmp(). Referenced by initialize(). { Processed_Static_Svc **pss = 0; for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); iter.next (pss) != 0; iter.advance ()) { if (ACE_OS::strcmp ((*pss)->name_, name) == 0) return (*pss)->assd_; } return 0; }

int ACE_Service_Gestalt::find_static_svc_descriptor (  const ACE_TCHAR *  name, ACE_Static_Svc_Descriptor **  ssd = 0 )  const

Find a static service descriptor by name. Using the supplied name, finds and (if needed) returns a pointer to a static service descriptor. Returns 0 for success and -1 for failure Definition at line 287 of file Service_Gestalt.cpp. References ACE_STATIC_SVCS_ITERATOR, ACE_TCHAR, ACE_TRACE, ACE_Unbounded_Set_Iterator< T >::advance(), ACE_Unbounded_Set_Iterator< T >::next(), static_svcs_, and ACE_OS::strcmp(). Referenced by ACE_Static_Function_Node::symbol(). { ACE_TRACE ("ACE_Service_Gestalt::find_static_svc_descriptor"); if (this->static_svcs_ == 0) return -1; ACE_Static_Svc_Descriptor **ssdp = 0; for (ACE_STATIC_SVCS_ITERATOR iter ( *this->static_svcs_); iter.next (ssdp) != 0; iter.advance ()) { if (ACE_OS::strcmp ((*ssdp)->name_, name) == 0) { if (ssd != 0) *ssd = *ssdp; return 0; } } return -1; }

int ACE_Service_Gestalt::init_svc_conf_file_queue (  void   )  [protected]

Initialize the if necessary. Definition at line 975 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_SVC_QUEUE, ACE::debug(), LM_DEBUG, and svc_conf_file_queue_. Referenced by ACE_Service_Config::open_i(), and parse_args_i(). { if (this->svc_conf_file_queue_ == 0) { ACE_SVC_QUEUE *tmp = 0; ACE_NEW_RETURN (tmp, ACE_SVC_QUEUE, -1); delete this->svc_conf_file_queue_; this->svc_conf_file_queue_ = tmp; } if (ACE::debug () > 1) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::init_svc_conf_file_queue ") ACE_LIB_TEXT ("- this=%@, repo=%@\n"), this, this->repo_)); return 0; } /* init_svc_conf_file_queue () */

int ACE_Service_Gestalt::initialize (  const ACE_TCHAR *  svc_name, const ACE_TCHAR *  parameters )

Initialize and activate a statically svc_name service. If initialization fails ... Reimplemented in ACE_Service_Config. Definition at line 463 of file Service_Gestalt.cpp. References ACE_ARGV, ACE_DEBUG, ACE_ERROR, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::argc(), ACE_ARGV_T< CHAR_TYPE >::argv(), ACE::debug(), ACE_Service_Repository::find(), find_processed_static_svc(), ACE_Service_Config::global(), ACE_Service_Type_Impl::init(), LM_DEBUG, LM_ERROR, process_directive_i(), ACE_Service_Repository::remove(), and ACE_Service_Type::type(). { ACE_TRACE ("ACE_Service_Gestalt_Base::initialize (repo)"); ACE_ARGV args (parameters); #ifndef ACE_NLOGGING if (ACE::debug () > 1) { ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::initialize - () repo=%@, ") ACE_LIB_TEXT ("looking up static ") ACE_LIB_TEXT ("service \'%s\' to initialize\n"), this->repo_, svc_name)); } #endif const ACE_Service_Type *srp = 0; for (int i = 0; this->repo_->find (svc_name, &srp) == -1 && i < 2; i++) // if (this->repo_->find (svc_name, &srp) == -1) { const ACE_Static_Svc_Descriptor *assd = ACE_Service_Config::global()->find_processed_static_svc(svc_name); if (assd != 0) { this->process_directive_i(*assd,0); } else { ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("(%P|%t) SG::initialize - service \'%s\'") ACE_LIB_TEXT (" was not located.\n"), svc_name), -1); } } if (srp == 0) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("(%P|%t) SG::initialize - service \'%s\'") ACE_LIB_TEXT (" was not located.\n"), svc_name), -1); /// If initialization fails ... if (srp->type ()->init (args.argc (), args.argv ()) == -1) { // ... report and remove this entry. ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("(%P|%t) SG::initialize - static init of \'%s\'") ACE_LIB_TEXT (" failed (%p)\n"), svc_name)); this->repo_->remove (svc_name); return -1; } // If everything is ok, activate it const_cast<ACE_Service_Type *>(srp)->active (1); return 0; }

int ACE_Service_Gestalt::initialize (  const ACE_Service_Type *  , const ACE_TCHAR *  parameters )

Reimplemented in ACE_Service_Config. Definition at line 627 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, ACE::debug(), ACE_Service_Repository::find(), initialize_i(), LM_DEBUG, LM_WARNING, and ACE_Service_Type::name(). { ACE_TRACE ("ACE_Service_Gestalt::initialize"); if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::initialize - looking up dynamic ") ACE_LIB_TEXT (" service \'%s\' to initialize\n"), sr->name ())); ACE_Service_Type *srp = 0; if (this->repo_->find (sr->name (), (const ACE_Service_Type **) &srp) >= 0) ACE_ERROR_RETURN ((LM_WARNING, ACE_LIB_TEXT ("(%P|%t) SG::initialize - \'%s\' ") ACE_LIB_TEXT ("has already been installed. ") ACE_LIB_TEXT ("Remove before reinstalling\n"), sr->name ()), 0); return this->initialize_i (sr, parameters); }

int ACE_Service_Gestalt::initialize (  const ACE_Service_Type_Factory *  , const ACE_TCHAR *  parameters )

Dynamically link the shared object file and retrieve a pointer to the designated shared object in this file. Also account for the possiblity to have static services registered when loading the DLL, by ensuring that the dynamic sevice is registered before any of its subordibnate static services. Thus avoiding any finalization order problems. Definition at line 527 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, ACE::debug(), ACE_Service_Repository::find(), ACE_Auto_Basic_Ptr< X >::get(), initialize_i(), LM_DEBUG, LM_ERROR, LM_WARNING, ACE_Service_Type_Factory::make_service_type(), ACE_Service_Type_Factory::name(), ACE_Auto_Basic_Ptr< X >::release(), and ACE_Service_Type::type(). Referenced by ACE_Static_Node::apply(), ACE_Dynamic_Node::apply(), ACE_Stream_Node::apply(), and ACE_Service_Config::initialize(). { ACE_TRACE ("ACE_Service_Gestalt::initialize"); #ifndef ACE_NLOGGING if (ACE::debug () > 1) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::initialize - repo=%@, looking up dynamic ") ACE_LIB_TEXT ("service \'%s\' to initialize\n"), this->repo_, stf->name ())); #endif ACE_Service_Type *srp = 0; int const retv = this->repo_->find (stf->name (), (const ACE_Service_Type **) &srp); // If there is an active service already, it must first be removed, // before it could be re-installed. if (retv >= 0) { #ifndef ACE_NLOGGING if (ACE::debug ()) ACE_ERROR_RETURN ((LM_WARNING, ACE_LIB_TEXT ("(%P|%t) \'%s\' already installed.") ACE_LIB_TEXT (" Must be removed before re-installing\n"), stf->name ()), 0); #endif return 0; } // There is an inactive service by that name, so it may have been // either inactivated, or just a forward declaration for a service, // that is in the process of being loaded. If the latter, then we // have detected an attempt to initialize the same dynamic service // while still processing previous attempt. This can lock up the // process, because the ACE_DLL_Manager::open () is not re-entrant - // it uses a Singleton lock to serialize concurent invocations. This // use case must be handled here, because if the DLL_Manager was // re-entrant we would have entered an infinite recursion here. if (retv == -2 && srp->type () == 0) ACE_ERROR_RETURN ((LM_WARNING, ACE_LIB_TEXT ("(%P|%t) \'%s\' has not been ") ACE_LIB_TEXT ("completely defined. Recursive ") ACE_LIB_TEXT ("initialization request while ") ACE_LIB_TEXT ("already performing one.\n"), stf->name ()), -1); // Reserve a spot for the dynamic service by inserting an incomplete // service declaration, i.e. one that can not produce a service // object if asked. Having this incomplete declaration works // similar to C++'s forward declaration to allow, in this case // proper partial ordering of the loaded services in respect to // their finalization. I.e. dependent static services must be // registered *after* the dynamic service that loads them, so that // their finalization is complete *before* finalizing the dynamic // service. ACE_Service_Type_Forward_Declaration_Guard dummy (this->repo_, stf->name ()); // make_service_type() is doing the dynamic loading and also runs // any static initializers ACE_Auto_Ptr<ACE_Service_Type> tmp (stf->make_service_type (this)); if (tmp.get () != 0 && this->initialize_i (tmp.get (), parameters) == 0) { // All good the ACE_Service_Type instance is now owned by the repository // and we should make sure it is not destroyed upon exit from this method. (void)tmp.release (); return 0; } // Something went wrong ... #ifndef ACE_NLOGGING if (ACE::debug ()) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("(%P|%t) Error initializing %s: %m\n"), stf->name()), -1); #endif return -1; }

int ACE_Service_Gestalt::initialize_i (  const ACE_Service_Type *  sr, const ACE_TCHAR *  parameters )  [protected]

Definition at line 655 of file Service_Gestalt.cpp. References ACE_ARGV, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::argc(), ACE_ARGV_T< CHAR_TYPE >::argv(), ACE::debug(), ACE_Service_Type_Impl::init(), ACE_Service_Repository::insert(), LM_ERROR, ACE_Service_Type::name(), ACE_Service_Repository::remove(), and ACE_Service_Type::type(). Referenced by initialize(). { ACE_TRACE ("ACE_Service_Gestalt::initialize_i"); ACE_ARGV args (parameters); if (sr->type ()->init (args.argc (), args.argv ()) == -1) { // We just get ps to avoid having remove() delete it. ACE_Service_Type *ps = 0; this->repo_->remove (sr->name (), &ps); #ifndef ACE_NLOGGING if (ACE::debug ()) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("(%P|%t) SG - initialize_i ") ACE_LIB_TEXT ("failed for %s: %m\n"), sr->name ()), -1); #endif return -1; } if (this->repo_->insert (sr) == -1) { #ifndef ACE_NLOGGING if (ACE::debug ()) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("(%P|%t) SG - repository insert ") ACE_LIB_TEXT ("failed for %s: %m\n"), sr->name ()), -1); #endif return -1; } return 0; }

int ACE_Service_Gestalt::insert (  ACE_Static_Svc_Descriptor *  stsd  )

Reimplemented in ACE_Service_Config. Definition at line 351 of file Service_Gestalt.cpp. References ACE_Static_Svc_Descriptor::active_, ACE::debug(), ACE_OS::fprintf(), ACE_Unbounded_Set< T >::insert(), ACE_Static_Svc_Descriptor::name_, and static_svcs_. Referenced by ACE_Service_Config::insert(). { if (ACE::debug () > 1) { // If called during static initialization ACE_Log_Msg may not have // been initialized yet, so use printf intead. ACE_OS::fprintf (stderr, "// (%d|0) SG::insert" " repo=%p, name=%s - queuing a Static_Svc_Descriptor:" " active=%d, repo opened=%d.\n", ACE_OS::getpid (), this->repo_, stsd->name_, stsd->active_, this->is_opened_); } // Inserting a service after teh Gestalt has been opened makes it // impossible to activate it later. Perhaps open came too soon? //ACE_ASSERT (this->is_opened_ == 0); return this->static_svcs_->insert (stsd); }

int ACE_Service_Gestalt::is_opened (  void   )

Has it been opened? Returns the difference between the times open and close have been called on this instance Definition at line 1069 of file Service_Gestalt.cpp. References is_opened_. { return this->is_opened_; }

int ACE_Service_Gestalt::load_static_svcs (  void   )  [protected]

Add the default statically-linked services to the ACE_Service_Repository. Reimplemented in ACE_Service_Config. Definition at line 261 of file Service_Gestalt.cpp. References ACE_STATIC_SVCS_ITERATOR, ACE_TRACE, ACE_Unbounded_Set_Iterator< T >::advance(), ACE_Unbounded_Set_Iterator< T >::next(), process_directive(), and static_svcs_. Referenced by open_i(). { ACE_TRACE ("ACE_Service_Gestalt::load_static_svcs"); if (this->static_svcs_ == 0) return 0; // Nothing to do ACE_Static_Svc_Descriptor **ssdp = 0; for (ACE_STATIC_SVCS_ITERATOR iter (*this->static_svcs_); iter.next (ssdp) != 0; iter.advance ()) { ACE_Static_Svc_Descriptor *ssd = *ssdp; if (this->process_directive (*ssd, 1) == -1) return -1; } return 0; } /* load_static_svcs () */

ACE_INLINE int ACE_Service_Gestalt::open (  int  argc, ACE_TCHAR *  argv[], const ACE_TCHAR *  logger_key = ACE_DEFAULT_LOGGER_KEY, int  ignore_static_svcs = 1, int  ignore_default_svc_conf_file = 0, int  ignore_debug_flag = 0 )

This is the primary entry point into the ACE_Service_Config (the constructor just handles simple initializations). It parses arguments passed in from argc and argv parameters. The arguments that are valid in a call to this method include: '-b' Option to indicate that we should be a daemon. Note that when this option is used, the process will be daemonized before the service configuration file(s) are read. During daemonization, (on POSIX systems) the current directory will be changed to "/" so the caller should either fully specify the file names, or execute a chroot() to the appropriate directory. See also: ACE::daemonize(). '-d' Turn on debugging mode '-f' Specifies a configuration file name other than the default svc.conf. Can be specified multiple times to use multiple files. '-k' Specifies the rendezvous point to use for the ACE distributed logger. '-y' Explicitly enables the use of static services. This flag overrides the ignore_static_svcs parameter value. '-n' Explicitly disables the use of static services. This flag overrides the ignore_static_svcs parameter value. '-p' Specifies a pathname which is used to store the process id. '-s' Specifies a signal number other than SIGHUP to trigger reprocessing of the configuration file(s). Ignored for platforms that do not have POSIX signals, such as Windows. '-S' Specifies a service directive string. Enclose the string in quotes and escape any embedded quotes with a backslash. This option specifies service directives without the need for a configuration file. Parameters: argc  The number of commandline arguments. argv  The array with commandline arguments logger_key  Indicates where to write the logging output, which is typically either a STREAM pipe or a socket address. ignore_static_svcs  If 1 then static services are not loaded, otherwise, they are loaded. ignore_default_svc_conf_file  If non-0 then the svc.conf configuration file will be ignored. ignore_debug_flag  If non-0 then the application is responsible for setting the ACE_Log_Msg::priority_mask appropriately. Return values: -1  The configuration file is not found or cannot be opened (errno is set accordingly). 0  Success. >0  The number of errors encountered while processing the service configuration file(s). Reimplemented in ACE_Service_Config. Definition at line 30 of file Service_Gestalt.inl. References ACE_TCHAR, ACE_TRACE, no_static_svcs_, open_i(), and parse_args_i(). { ACE_TRACE ("ACE_Service_Gestalt::open"); this->no_static_svcs_ = ignore_static_svcs; if (this->parse_args_i (argc, argv) == -1) return -1; else return this->open_i (argv == 0 ? 0 : argv[0], logger_key, ignore_static_svcs, ignore_default_svc_conf, ignore_debug_flag); }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_Service_Gestalt::open (  const ACE_TCHAR  program_name[], const ACE_TCHAR *  logger_key = ACE_DEFAULT_LOGGER_KEY, int  ignore_static_svcs = 1, int  ignore_default_svc_conf_file = 0, int  ignore_debug_flag = 0 )

Performs an open without parsing command-line arguments. The logger_key indicates where to write the logging output, which is typically either a STREAM pipe or a socket address. If ignore_static_svcs is 1 then static services are not loaded, otherwise, they are loaded. If ignore_default_svc_conf_file is non-0 then the <svc.conf> configuration file will be ignored. Returns zero upon success, -1 if the file is not found or cannot be opened (errno is set accordingly), otherwise returns the number of errors encountered loading the services in the specified svc.conf configuration file. If ignore_debug_flag is non-0 then the application is responsible for setting the <ACE_Log_Msg::priority_mask> appropriately. Reimplemented in ACE_Service_Config. Definition at line 13 of file Service_Gestalt.inl. References ACE_TCHAR, ACE_TRACE, no_static_svcs_, and open_i(). Referenced by ACE_Service_Config::open(). { ACE_TRACE ("ACE_Service_Gestalt::open"); this->no_static_svcs_ = ignore_static_svcs; return this->open_i (program_name, logger_key, ignore_static_svcs, ignore_default_svc_conf, ignore_debug_flag); }

int ACE_Service_Gestalt::open_i (  const ACE_TCHAR  program_name[], const ACE_TCHAR *  logger_key = ACE_DEFAULT_LOGGER_KEY, bool  ignore_static_svcs = true, bool  ignore_default_svc_conf_file = false, bool  ignore_debug_flag = false )  [protected, virtual]

Performs an open without parsing command-line arguments. The logger_key indicates where to write the logging output, which is typically either a STREAM pipe or a socket address. If ignore_default_svc_conf_file is non-0 then the "svc.conf" file will be ignored. If ignore_debug_flag is non-0 then the application is responsible for setting the ACE_Log_Msg::priority_mask() appropriately. Returns number of errors that occurred on failure and 0 otherwise. Reimplemented in ACE_Service_Config. Definition at line 998 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_LOG_MSG, ACE_TCHAR, ACE_TEXT, ACE_TRACE, ACE::debug(), ACE_Log_Msg::disable_debug_messages(), ACE_Log_Msg::enable_debug_messages(), is_opened_, LM_DEBUG, load_static_svcs(), no_static_svcs_, ACE_Log_Msg::priority_mask(), process_commandline_directives(), and process_directives(). Referenced by open(), and ACE_Service_Config::open_i(). { ACE_TRACE ("ACE_Service_Gestalt::open_i"); int result = 0; ACE_Log_Msg *log_msg = ACE_LOG_MSG; // Record the current log setting upon entering this thread. u_long old_process_mask = log_msg->priority_mask (ACE_Log_Msg::PROCESS); u_long old_thread_mask = log_msg->priority_mask (ACE_Log_Msg::THREAD); if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) SG::open_i - this=%@, ") ACE_TEXT ("opened=%d, loadstatics=%d\n"), this, this->is_opened_, this->no_static_svcs_)); // Guard against reentrant processing. For example, // if the singleton gestalt (ubergestalt) was already open, // do not open it again... if (this->is_opened_++ != 0) return 0; if (ignore_debug_flag == 0) { // If -d was included as a startup parameter, the user wants debug // information printed during service initialization. if (ACE::debug ()) ACE_Log_Msg::enable_debug_messages (); else // The user has requested no debugging info. ACE_Log_Msg::disable_debug_messages (); } // See if we need to load the static services. if (this->no_static_svcs_ == 0 && this->load_static_svcs () == -1) result = -1; else { if (this->process_commandline_directives () == -1) result = -1; else result = this->process_directives (); } // Reset debugging back to the way it was when we came into // into <open_i>. { // Make sure to save/restore errno properly. ACE_Errno_Guard error (errno); if (ignore_debug_flag == 0) { log_msg->priority_mask (old_process_mask, ACE_Log_Msg::PROCESS); log_msg->priority_mask (old_thread_mask, ACE_Log_Msg::THREAD); } } return result; } /* open_i () */

ACE_Service_Gestalt& ACE_Service_Gestalt::operator= (  const ACE_Service_Gestalt &   )  [private]

int ACE_Service_Gestalt::parse_args (  int  , ACE_TCHAR *  argv[] )

Handle the command-line options intended for the . Note that <argv[0]> is assumed to be the program name. The arguments that are valid in a call to this method are '-b' Option to indicate that we should be a daemon '-d' Turn on debugging mode '-f' Option to read in the list of svc.conf file names '-k' Option to read a wide string where in the logger output can be written '-y' Turn on the flag for a repository of statically linked services '-n' Need not have a repository of statically linked services '-S' Option to read in the list of services on the command-line Please observe the difference between options '-f' that looks for a list of files and here a list of services. Reimplemented in ACE_Service_Config. Definition at line 1105 of file Service_Gestalt.cpp. References ACE_TCHAR, ACE_TRACE, and parse_args_i(). Referenced by ACE_Service_Config::parse_args(). { ACE_TRACE ("ACE_Service_Gestalt::parse_args"); return parse_args_i (argc, argv); }

int ACE_Service_Gestalt::parse_args_i (  int  , ACE_TCHAR *  argv[] )  [protected, virtual]

Reimplemented in ACE_Service_Config. Definition at line 1112 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_ERROR_RETURN, ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_SVC_QUEUE, ACE_TCHAR, ACE_TRACE, ACE_TString, ACE::debug(), ACE_Unbounded_Queue< T >::enqueue_tail(), init_svc_conf_file_queue(), LM_DEBUG, LM_ERROR, no_static_svcs_, svc_conf_file_queue_, and svc_queue_. Referenced by open(), parse_args(), and ACE_Service_Config::parse_args_i(). { ACE_TRACE ("ACE_Service_Gestalt::parse_args_i"); ACE_Get_Opt getopt (argc, argv, ACE_LIB_TEXT ("df:k:nyp:s:S:"), 1); // Start at argv[1]. if (this->init_svc_conf_file_queue () == -1) return -1; for (int c; (c = getopt ()) != -1; ) switch (c) { case 'd': ACE::debug (1); break; case 'f': if (this->svc_conf_file_queue_->enqueue_tail (ACE_TString (getopt.opt_arg ())) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_tail")), -1); break; case 'k': /* * @TODO: Is this always a static storage? Shouldn't we copy * & gain ownership of the value? */ this->logger_key_ = getopt.opt_arg (); break; case 'n': this->no_static_svcs_ = 1; break; case 'y': this->no_static_svcs_ = 0; break; case 'S': if (this->svc_queue_ == 0) { ACE_NEW_RETURN (this->svc_queue_, ACE_SVC_QUEUE, -1); } if (this->svc_queue_->enqueue_tail (ACE_TString (getopt.opt_arg ())) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("enqueue_tail")), -1); break; default: if (ACE::debug () > 0) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("%c is not a ACE_Service_Config option\n"), c)); } return 0; } /* parse_args_i () */

int ACE_Service_Gestalt::process_commandline_directives (  void   )  [protected]

Process service configuration requests that were provided on the command-line. Returns the number of errors that occurred. Reimplemented in ACE_Service_Config. Definition at line 1075 of file Service_Gestalt.cpp. References ACE_ERROR, ACE_LIB_TEXT, ACE_SVC_QUEUE_ITERATOR, ACE_TString, ACE_Unbounded_Queue_Iterator< T >::advance(), ACE_String_Base< CHAR >::fast_rep(), LM_ERROR, ACE_Unbounded_Queue_Iterator< T >::next(), process_directive(), and svc_queue_. Referenced by open_i(). { int result = 0; if (this->svc_queue_ != 0) { ACE_TString *sptr = 0; for (ACE_SVC_QUEUE_ITERATOR iter (*this->svc_queue_); iter.next (sptr) != 0; iter.advance ()) { // Process just a single directive. if (this->process_directive ((sptr->fast_rep ())) != 0) { ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("process_directive"))); result = -1; } } delete this->svc_queue_; this->svc_queue_ = 0; } return result; } /* process_commandline_directives () */

int ACE_Service_Gestalt::process_directive (  const ACE_Static_Svc_Descriptor &  ssd, int  force_replace = 0 )

Process one static service definition. Load a new static service. Parameters: ssd  Service descriptor, see the document of ACE_Static_Svc_Descriptor for more details. force_replace  If set the new service descriptor replaces any previous instance in the repository. Returns: Returns -1 if the service cannot be 'loaded'. Reimplemented in ACE_Service_Config. Definition at line 729 of file Service_Gestalt.cpp. References add_processed_static_svc(), and process_directive_i(). { int result = process_directive_i(ssd,force_replace); if (result == 0) { this->add_processed_static_svc(&ssd); } return result; }

int ACE_Service_Gestalt::process_directive (  const ACE_TCHAR  directive[]  )

Process one service configuration directive, which is passed as a string. Returns the number of errors that occurred. Reimplemented in ACE_Service_Config. Definition at line 941 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_LIB_TEXT, ACE_TCHAR, ACE_TRACE, ACE::debug(), ACE_Auto_Basic_Ptr< X >::get(), LM_DEBUG, and process_directives_i(). Referenced by load_static_svcs(), process_commandline_directives(), and ACE_Service_Config::process_directive(). { ACE_TRACE ("ACE_Service_Gestalt::process_directive"); if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::process_directive, repo=%@ - %s\n"), this->repo_, directive)); #if (ACE_USES_CLASSIC_SVC_CONF == 1) ACE_UNUSED_ARG (directive); ACE_Svc_Conf_Param d (this, directive); int result = this->process_directives_i (&d); return result; #else ACE_DLL dll; auto_ptr<ACE_XML_Svc_Conf> xml_svc_conf (this->get_xml_svc_conf (dll)); if (xml_svc_conf.get () == 0) return -1; return xml_svc_conf->parse_string (directive); #endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ } /* process_directive () */

int ACE_Service_Gestalt::process_directive_i (  const ACE_Static_Svc_Descriptor &  ssd, int  force_replace = 0 )  [protected]

Process a static directive without also inserting its descriptor the global table. This avoids multiple additions when processing directives in non-global gestalts. Definition at line 741 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_LIB_TEXT, ACE_NEW_RETURN, ACE_Service_Object_Exterminator, ACE_Static_Svc_Descriptor::active_, ACE_Static_Svc_Descriptor::alloc_, ACE_Service_Config::create_service_type_impl(), ACE::debug(), ACE_Service_Repository::find(), ACE_Static_Svc_Descriptor::flags_, ACE_Service_Repository::insert(), LM_DEBUG, ACE_Static_Svc_Descriptor::name_, and ACE_Static_Svc_Descriptor::type_. Referenced by initialize(), and process_directive(). { #ifndef ACE_NLOGGING if (ACE::debug () > 2) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::process_directive, ") ACE_LIB_TEXT ("repo=%@, replace=%d - %s\n"), this->repo_, force_replace, ssd.name_)); #endif if (!force_replace) { if (this->repo_->find (ssd.name_, 0, 0) >= 0) { // The service is already there, just return return 0; } } ACE_Service_Object_Exterminator gobbler; void *sym = (ssd.alloc_)(&gobbler); ACE_Service_Type_Impl *stp = ACE_Service_Config::create_service_type_impl (ssd.name_, ssd.type_, sym, ssd.flags_, gobbler); if (stp == 0) return 0; ACE_Service_Type *service_type; // This is just a temporary to force the compiler to use the right // constructor in ACE_Service_Type ACE_DLL tmp_dll; ACE_NEW_RETURN (service_type, ACE_Service_Type (ssd.name_, stp, tmp_dll, ssd.active_), -1); return this->repo_->insert (service_type); }

int ACE_Service_Gestalt::process_directives (  void   )

Process (or re-process) service configuration requests that are provided in the svc.conf file(s). Returns the number of errors that occurred. Reimplemented in ACE_Service_Config. Definition at line 1178 of file Service_Gestalt.cpp. References ACE_SVC_QUEUE_ITERATOR, ACE_TRACE, ACE_TString, ACE_Unbounded_Queue_Iterator< T >::advance(), ACE_String_Base< CHAR >::fast_rep(), ACE_Unbounded_Queue_Iterator< T >::next(), process_file(), and svc_conf_file_queue_. Referenced by open_i(), and ACE_Service_Config::process_directives(). { ACE_TRACE ("ACE_Service_Gestalt::process_directives"); int result = 0; if (this->svc_conf_file_queue_ != 0) { ACE_TString *sptr = 0; // Iterate through all the svc.conf files. for (ACE_SVC_QUEUE_ITERATOR iter (*this->svc_conf_file_queue_); iter.next (sptr) != 0; iter.advance ()) { int r = this->process_file (sptr->fast_rep ()); if (r < 0) { result = r; break; } result += r; } } return result; } /* process_directives () */

int ACE_Service_Gestalt::process_directives_i (  ACE_Svc_Conf_Param *  param  )  [protected]

This is the implementation function that process_directives() and process_directive() both call. Returns the number of errors that occurred. Reimplemented in ACE_Service_Config. Definition at line 795 of file Service_Gestalt.cpp. References ACE_ASSERT, ACE_DEBUG, ACE_LIB_TEXT, ACE_NO_HEAP_CHECK, ACE_TEXT, ACE_Svc_Conf_Param::config, ACE::debug(), ACE_OS::last_error(), LM_DEBUG, ACE_Svc_Conf_Param::source, ACE_Svc_Conf_Param::type, and ACE_Svc_Conf_Param::yyerrno. Referenced by process_directive(), and process_file(). { // AC 970827 Skip the heap check because yacc allocates a buffer // here which will be reported as a memory leak for some reason. ACE_NO_HEAP_CHECK // Were we called in the context of the current instance? ACE_ASSERT (this == param->config); // Temporarily (for the duration of this call) make sure that *any* static // service registrations will happen with this instance. Such registrations // are possible as a side-effect of dynamically loading a DLL, which has // other static services registered. Thus this instance will own both the // DLL and those static services, which implies that their finalization // will be performed in the correct order, i.e. prior to finalizing the DLL ACE_Service_Config_Guard guard (this); #ifndef ACE_NLOGGING if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("(%P|%t) SG::process_directives_i, ") ACE_LIB_TEXT ("repo=%@ - %s\n"), this->repo_, (param->type == ACE_Svc_Conf_Param::SVC_CONF_FILE) ? ACE_TEXT ("<from file>") : param->source.directive)); #endif ::ace_yyparse (param); // This is a hack, better errors should be provided... if (param->yyerrno > 0) { if (ACE_OS::last_error () == 0) ACE_OS::last_error (EINVAL); return param->yyerrno; } else return 0; }

int ACE_Service_Gestalt::process_file (  const ACE_TCHAR  file[]  )

Process a file containing a list of service configuration directives. Reimplemented in ACE_Service_Config. Definition at line 866 of file Service_Gestalt.cpp. References ACE_DEBUG, ACE_LIB_TEXT, ACE_stat, ACE_TCHAR, ACE_TEXT, ACE_TRACE, ACE::debug(), EPERM, ACE_OS::fclose(), ACE_Service_Repository::find(), ACE_OS::fopen(), ACE_Auto_Basic_Ptr< X >::get(), LM_ERROR, LM_WARNING, process_directives_i(), and ACE_OS::stat(). Referenced by process_directives(). { ACE_TRACE ("ACE_Service_Gestalt::process_file"); // To avoid recursive processing of the same file and the same repository // we maintain an implicit stack of dummy "services" named after the file // being processed. Anytime we have to open a new file, we then can check // to see if it is not already being processed by searching for a dummy // service with a matching name. if (this->repo_->find (file, 0, 0) >=0) { ACE_DEBUG ((LM_WARNING, ACE_TEXT ("(%P|%t) Configuration file %s has not finished") ACE_TEXT (" processing yet. Ignoring.\n"), file)); return 0; } // Register a dummy service as a forward decl, using the file name as name. // The entry will be automaticaly removed once the thread exits this block. ACE_Service_Type_Forward_Declaration_Guard recursion_guard (this->repo_, file); /* * @TODO: Test with ACE_USES_CLASSIC_SVC_CONF turned off! */ #if (ACE_USES_CLASSIC_SVC_CONF == 1) int result = 0; FILE *fp = ACE_OS::fopen (file, ACE_LIB_TEXT ("r")); if (fp == 0) { // Invalid svc.conf file. We'll report it here and break out of // the method. if (ACE::debug ()) ACE_DEBUG ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), file)); // Use stat to find out if the file exists. I didn't use access() // because stat is better supported on most non-unix platforms. ACE_stat exists; if (ACE_OS::stat (file, &exists) == 0) // If it exists, but we couldn't open it for reading then we // must not have permission to read it. errno = EPERM; else errno = ENOENT; result = -1; } else { ACE_Svc_Conf_Param f (this, fp); // Keep track of the number of errors. result = this->process_directives_i (&f); (void) ACE_OS::fclose (fp); } return result; #else ACE_DLL dll; auto_ptr<ACE_XML_Svc_Conf> xml_svc_conf (ACE_Service_Config::get_xml_svc_conf (dll)); if (xml_svc_conf.get () == 0) return -1; return xml_svc_conf->parse_file (file); #endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ }

int ACE_Service_Gestalt::remove (  const ACE_TCHAR  svc_name[]  )

Totally remove svc_name from the daemon by removing it from the ACE_Reactor, and unlinking it if necessary. Reimplemented in ACE_Service_Config. Definition at line 698 of file Service_Gestalt.cpp. References ACE_TCHAR, ACE_TRACE, and ACE_Service_Repository::remove(). Referenced by ACE_Remove_Node::apply(). { ACE_TRACE ("ACE_Service_Gestalt::remove"); return this->repo_->remove (svc_name); }

int ACE_Service_Gestalt::resume (  const ACE_TCHAR  svc_name[]  )

Resume a svc_name that was previously suspended or has not yet been resumed (e.g., a static service). Reimplemented in ACE_Service_Config. Definition at line 721 of file Service_Gestalt.cpp. References ACE_TCHAR, ACE_TRACE, and ACE_Service_Repository::resume(). Referenced by ACE_Resume_Node::apply(). { ACE_TRACE ("ACE_Service_Gestalt::resume"); return this->repo_->resume (svc_name); }

int ACE_Service_Gestalt::suspend (  const ACE_TCHAR  svc_name[]  )

Suspend svc_name. Note that this will not unlink the service from the daemon if it was dynamically linked, it will mark it as being suspended in the Service Repository and call the member function on the appropriate . A service can be resumed later on by calling the member function... Reimplemented in ACE_Service_Config. Definition at line 711 of file Service_Gestalt.cpp. References ACE_TCHAR, ACE_TRACE, and ACE_Service_Repository::suspend(). Referenced by ACE_Suspend_Node::apply(). { ACE_TRACE ("ACE_Service_Gestalt::suspend"); return this->repo_->suspend (svc_name); }

---

Friends And Related Function Documentation

friend class ACE_Dynamic_Service_Base [friend]

Definition at line 370 of file Service_Gestalt.h.

friend class ACE_Service_Config_Guard [friend]

Reimplemented in ACE_Service_Config. Definition at line 372 of file Service_Gestalt.h.

friend class ACE_Service_Object [friend]

Definition at line 371 of file Service_Gestalt.h.

---

Member Data Documentation

ACE_Service_Gestalt::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Reimplemented in ACE_Service_Config. Definition at line 158 of file Service_Gestalt.h.

int ACE_Service_Gestalt::is_opened_ [protected]

Keep track of the number of times the instance has been initialized (opened). "If so, we can't allow to be called since it's not reentrant" is the original motivation, but that does not seem to be the case anymore. This variable is incremented by the <ACE_Service_Gestalt::open> method and decremented by the <ACE_Service_Gestalt::close> method. Definition at line 386 of file Service_Gestalt.h. Referenced by close(), is_opened(), and open_i().

const ACE_TCHAR* ACE_Service_Gestalt::logger_key_ [protected]

Indicates where to write the logging output. This is typically either a STREAM pipe or a socket Definition at line 390 of file Service_Gestalt.h.

int ACE_Service_Gestalt::no_static_svcs_ [protected]

Should we avoid loading the static services? Definition at line 393 of file Service_Gestalt.h. Referenced by open(), open_i(), and parse_args_i().

ACE_PROCESSED_STATIC_SVCS* ACE_Service_Gestalt::processed_static_svcs_ [protected]

Repository of statically linked services for which process directive was called, but the service is not already a member of the static_svcs_ list. Definition at line 412 of file Service_Gestalt.h. Referenced by ACE_Service_Gestalt(), close(), and ~ACE_Service_Gestalt().

ACE_Service_Repository* ACE_Service_Gestalt::repo_ [protected]

The service repository to hold the services. Definition at line 404 of file Service_Gestalt.h. Referenced by ACE_Service_Config_Guard::ACE_Service_Config_Guard(), and ACE_Dynamic_Service_Base::instance().

ACE_STATIC_SVCS* ACE_Service_Gestalt::static_svcs_ [protected]

Repository of statically linked services. Definition at line 407 of file Service_Gestalt.h. Referenced by close(), find_static_svc_descriptor(), insert(), load_static_svcs(), and ~ACE_Service_Gestalt().

ACE_SVC_QUEUE* ACE_Service_Gestalt::svc_conf_file_queue_ [protected]

Queue of svc.conf files specified on the command-line. @ This should probably be made to handle unicode filenames... Definition at line 401 of file Service_Gestalt.h. Referenced by close(), init_svc_conf_file_queue(), parse_args_i(), and process_directives().

ACE_SVC_QUEUE* ACE_Service_Gestalt::svc_queue_ [protected]

Queue of services specified on the command-line. Definition at line 396 of file Service_Gestalt.h. Referenced by parse_args_i(), and process_commandline_directives().

bool ACE_Service_Gestalt::svc_repo_is_owned_ [protected]

Do we own the service repository instance or have only been given a ptr to the singleton one? Definition at line 378 of file Service_Gestalt.h. Referenced by ~ACE_Service_Gestalt().

---

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

• Service_Gestalt.h
• Service_Gestalt.cpp
• Service_Gestalt.inl

---