ACE_Service_Config Class Reference

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

#include <Service_Config.h>

Inheritance diagram for ACE_Service_Config:

[legend]Collaboration diagram for ACE_Service_Config:

[legend]List of all members.

Public Member Functions
	ACE_Service_Config (int ignore_static_svcs=1, size_t size=ACE_Service_Gestalt::MAX_SERVICES, int signum=SIGHUP)
	ACE_Service_Config (const ACE_TCHAR program_name[], const ACE_TCHAR *logger_key=ACE_DEFAULT_LOGGER_KEY)
virtual	~ACE_Service_Config (void)
void	dump (void) const
	Dump the state of an object.
Static Public Member Functions
ACE_Service_Gestalt *	current (ACE_Service_Gestalt *)
	= Static interfaces
ACE_Service_Config *	global (void)
ACE_Service_Gestalt *	current (void)
	Accessor for the "current" service gestalt.
ACE_Service_Gestalt *	instance (void)
int	open (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	open (int argc, ACE_TCHAR *argv[], 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	close (void)
int	fini_svcs (void)
int	close_svcs (void)
int	reconfig_occurred (void)
	True if reconfiguration occurred.
void	reconfig_occurred (int)
	Indicate that reconfiguration occurred.
void	reconfigure (void)
	Perform the reconfiguration process.
ACE_Service_Gestalt *	static_svcs (void)
int	insert (ACE_Static_Svc_Descriptor *svc)
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[])
ACE_INLINE void	signal_handler (ACE_Sig_Adapter *)
	Set the signal_handler;for internal use by ACE_Object_Manager only.
int	process_file (const ACE_TCHAR file[])
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_directives (void)
void	handle_signal (int sig, siginfo_t *, ucontext_t *)
	Handles signals to trigger reconfigurations.
int	parse_args (int, ACE_TCHAR *argv[])
ACE_Service_Type_Impl *	create_service_type_impl (const ACE_TCHAR *name, int type, void *symbol, u_int flags, ACE_Service_Object_Exterminator gobbler)
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Member Functions
virtual int	open_i (const ACE_TCHAR program_name[], const ACE_TCHAR *logger_key, bool ignore_static_svcs, bool ignore_default_svc_conf_file, bool ignore_debug_flag)
virtual int	parse_args_i (int argc, ACE_TCHAR *argv[])
Static Protected Member Functions
int	process_commandline_directives (void)
int	process_directives_i (ACE_Svc_Conf_Param *param)
int	start_daemon (void)
	Become a daemon.
int	load_static_svcs (void)
Protected Attributes
ACE_TSS< ACE_Service_Gestalt >	tss_
Static Private Attributes
sig_atomic_t	reconfig_occurred_ = 0
	True if reconfiguration occurred.
int	be_a_daemon_ = 0
	Shall we become a daemon process?
ACE_TCHAR *	pid_file_name_ = 0
	Pathname of file to write process id.
int	signum_ = SIGHUP
	Number of the signal used to trigger reconfiguration.
ACE_Sig_Adapter *	signal_handler_ = 0
	Handles the reconfiguration signals.
Friends
class	ACE_Service_Config_Guard

---

Detailed Description

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

The ACE_Service_Config uses the Monostate pattern. Therefore, you can only have one of these instantiated per-process. It represents the process-wide collection of services, which is typicaly shared among all other configurable entities. The only ACE_Service_Config instance is registered with and owned by the ACE_Object_Manager.

By contrast, the ACE_Service_Gestalt represents the collection of services, pertaining to a configurable entity. Typicaly, a "configurable entity" is an instance, which owns an instance of ACE_Service_Gestalt in order to ensure full controll over the services it needs.

Another facet of ACE_Service_Config is that for a given thread, it provides access to its current, process-global ACE_Service_Gestalt instance through its curent() method.

Note:

The signal_handler_ static member is allocated by the ACE_Object_Manager. The ACE_Service_Config constructor uses signal_handler_. Therefore, if the program has any static ACE_Service_Config objects, there might be initialization order problems. They can be minimized, but not eliminated, by _not_ #defining ACE_HAS_NONSTATIC_OBJECT_MANAGER.

Definition at line 203 of file Service_Config.h.

---

Constructor & Destructor Documentation

ACE_Service_Config::ACE_Service_Config (  int  ignore_static_svcs = 1, size_t  size = ACE_Service_Gestalt::MAX_SERVICES, int  signum = SIGHUP )

Initialize the Service Repository. Note that initialising signum to a negative number will prevent a signal handler being registered when the repository is opened. Definition at line 377 of file Service_Config.cpp. References ACE_TRACE, and signum_. : ACE_Service_Gestalt (size, false, ignore_static_svcs) , tss_ (this) { ACE_TRACE ("ACE_Service_Config::ACE_Service_Config"); ACE_Service_Config::signum_ = signum; }

ACE_Service_Config::ACE_Service_Config (  const ACE_TCHAR  program_name[], const ACE_TCHAR *  logger_key = ACE_DEFAULT_LOGGER_KEY )

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. Definition at line 445 of file Service_Config.cpp. References ACE_ERROR, ACE_TCHAR, ACE_TEXT, ACE_TRACE, LM_ERROR, and open(). : ACE_Service_Gestalt (ACE_Service_Repository::DEFAULT_SIZE, false) , tss_ (this) { ACE_TRACE ("ACE_Service_Config::ACE_Service_Config"); if (this->open (program_name, logger_key) == -1 && errno != ENOENT) { // Only print out an error if it wasn't the svc.conf file that was // missing. ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) SC failed to open: %p\n"), program_name)); } }

ACE_Service_Config::~ACE_Service_Config (  void   )  [virtual]

Perform user-specified close activities and remove dynamic memory. Definition at line 552 of file Service_Config.cpp. References ACE_TRACE. { ACE_TRACE ("ACE_Service_Config::~ACE_Service_Config"); }

---

Member Function Documentation

int ACE_Service_Config::close (  void   )  [static]

Tidy up and perform last rites when ACE_Service_Config is shut down. This method calls . Returns 0. Reimplemented from ACE_Service_Gestalt. Definition at line 507 of file Service_Config.cpp. References ACE_Service_Gestalt::close(), close_svcs(), and instance(). Referenced by ACE_Object_Manager::fini(). { int result1 = ACE_Service_Config::instance ()->close (); // Delete the service repository. All the objects inside the // service repository should already have been finalized. int result2 = ACE_Service_Config::close_svcs (); // Do away with the Singleton ACE_SERVICE_CONFIG_SINGLETON::close (); return (result1 | result2); }

int ACE_Service_Config::close_svcs (  void   )  [static]

Perform user-specified close hooks on all of the configured services in the Service_Repository, then delete the Service_Repository itself. Returns 0. Definition at line 522 of file Service_Config.cpp. References ACE_TRACE, ACE_Service_Repository::close_singleton(), current(), and global(). Referenced by close(). { ACE_TRACE ("ACE_Service_Config::close_svcs"); ACE_Service_Repository::close_singleton (); ACE_Service_Config::current (global ()); return 0; }

ACE_Service_Type_Impl * ACE_Service_Config::create_service_type_impl (  const ACE_TCHAR *  name, int  type, void *  symbol, u_int  flags, ACE_Service_Object_Exterminator  gobbler )  [static]

Definition at line 404 of file Service_Config.cpp. References ACE_ERROR, ACE_NEW_RETURN, ACE_Service_Object_Exterminator, ACE_TCHAR, ACE_TEXT, and LM_ERROR. Referenced by ACE_Service_Gestalt::process_directive_i(). { ACE_Service_Type_Impl *stp = 0; // Note, the only place we need to put a case statement. This is // also the place where we'd put the RTTI tests, if the compiler // actually supported them! switch (type) { case ACE_Service_Type::SERVICE_OBJECT: ACE_NEW_RETURN (stp, ACE_Service_Object_Type ((ACE_Service_Object *) symbol, name, flags, gobbler), 0); break; case ACE_Service_Type::MODULE: ACE_NEW_RETURN (stp, ACE_Module_Type (symbol, name, flags), 0); break; case ACE_Service_Type::STREAM: ACE_NEW_RETURN (stp, ACE_Stream_Type (symbol, name, flags), 0); break; default: ACE_ERROR ((LM_ERROR, ACE_TEXT ("unknown case\n"))); break; } return stp; }

ACE_INLINE ACE_Service_Gestalt * ACE_Service_Config::current (  void   )  [static]

Accessor for the "current" service gestalt. Return the configuration instance, considered "global" in the current thread. This may be the same as instance(), but on some occasions, it may be a different one. For example, ACE_Service_Config_Guard provides a way of temporarily replacing the "current" configuration instance in the context of a thread. Definition at line 73 of file Service_Config.inl. References global(), and tss_. Referenced by ACE_Service_Config_Guard::ACE_Service_Config_Guard(), close_svcs(), initialize(), open(), parse_args(), process_directive(), process_directives(), process_file(), and ACE_Service_Config_Guard::~ACE_Service_Config_Guard(). { return ACE_Service_Config::global ()->tss_; }

ACE_INLINE ACE_Service_Gestalt * ACE_Service_Config::current (  ACE_Service_Gestalt *   )  [static]

= Static interfaces Mutator to set the (TSS) global instance. Intended for use by helper classes like See also: ACE_Service_Config_Guard. Stack-based instances of it can temporarily change which Gestalt is considered global by any static initializer (especially those in DLLs, loaded at run-time). Definition at line 80 of file Service_Config.inl. References global(), ACE_TSS< ACE_Service_Gestalt >::ts_object(), and tss_. { return ACE_Service_Config::global ()->tss_.ts_object (newcurrent); }

void ACE_Service_Config::dump (  void   )  const

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

int ACE_Service_Config::fini_svcs (  void   )  [static]

Perform user-specified close hooks and possibly delete all of the configured services in the . Definition at line 532 of file Service_Config.cpp. References ACE_TRACE, ACE::debug(), ACE_Log_Msg::disable_debug_messages(), ACE_Log_Msg::enable_debug_messages(), ACE_Service_Repository::fini(), and ACE_Service_Repository::instance(). Referenced by ACE_Object_Manager::fini(). { ACE_TRACE ("ACE_Service_Config::fini_svcs"); // Clear the LM_DEBUG bit from log messages if appropriate if (ACE::debug ()) ACE_Log_Msg::disable_debug_messages (); int result = 0; if (ACE_Service_Repository::instance () != 0) result = ACE_Service_Repository::instance ()->fini (); if (ACE::debug ()) ACE_Log_Msg::enable_debug_messages (); return result; }

ACE_Service_Config * ACE_Service_Config::global (  void   )  [static]

Returns a process-wide global singleton instance in contrast with current (), which may return a different instance at different times, dependent on the context. Use of this method is discouraged as it allows circumvention of the mechanism for dynamically loading services. Use with extreme caution! Definition at line 332 of file Service_Config.cpp. Referenced by close_svcs(), current(), ACE_Dynamic_Service_Base::find_i(), ACE_Service_Gestalt::initialize(), and instance(). { return ACE_SERVICE_CONFIG_SINGLETON::instance (); }

void ACE_Service_Config::handle_signal (  int  sig, siginfo_t *  , ucontext_t *  )  [static]

Handles signals to trigger reconfigurations. Definition at line 467 of file Service_Config.cpp. References ACE_ASSERT, reconfig_occurred_, signum_, and ucontext_t. { #if defined (ACE_NDEBUG) ACE_UNUSED_ARG (sig); #else /* ! ACE_NDEBUG */ ACE_ASSERT (ACE_Service_Config::signum_ == sig); #endif /* ! ACE_NDEBUG */ ACE_Service_Config::reconfig_occurred_ = 1; }

ACE_INLINE int ACE_Service_Config::initialize (  const ACE_TCHAR *  svc_name, const ACE_TCHAR *  parameters )  [static]

Initialize and activate a statically svc_name service. Reimplemented from ACE_Service_Gestalt. Definition at line 111 of file Service_Config.inl. References ACE_TCHAR, ACE_TRACE, current(), and ACE_Service_Gestalt::initialize(). { ACE_TRACE ("ACE_Service_Config::initialize"); return ACE_Service_Config::current ()->initialize (svc_name, parameters); }

ACE_INLINE int ACE_Service_Config::initialize (  const ACE_Service_Type *  , const ACE_TCHAR *  parameters )  [static]

Dynamically link the shared object file and retrieve a pointer to the designated shared object in this file. Reimplemented from ACE_Service_Gestalt. Definition at line 123 of file Service_Config.inl. References ACE_TCHAR, ACE_TRACE, current(), and ACE_Service_Gestalt::initialize(). { ACE_TRACE ("ACE_Service_Config::initialize"); return ACE_Service_Config::current ()->initialize (sr, parameters); }

int ACE_Service_Config::insert (  ACE_Static_Svc_Descriptor *  svc  )  [static]

Insert a static service descriptor for processing on open_i(). The corresponding ACE_STATIC_SVC_* macros were chaged to use this method instead of obtaining a ptr to a container. See the note on static_svcs(). Added to prevent exposing the internal storage representation of the services repository and provide a better way of debugging service loading and registration problems. Reimplemented from ACE_Service_Gestalt. Definition at line 338 of file Service_Config.cpp. References ACE_Service_Gestalt::insert(), and instance(). { return ACE_Service_Config::instance ()->insert (stsd); }

ACE_INLINE ACE_Service_Gestalt * ACE_Service_Config::instance (  void   )  [static]

This is what the static service initializators are hard-wired to use, so in order to avoid interface changes this method merely forwards to ACE_Service_Config::current. This enables us to enforce which Service Gestalt is used for services registering through static initializers. Especially important for DLL-based dynamic services, which can contain their own static services and static initializers. Definition at line 61 of file Service_Config.inl. References global(), and tss_. Referenced by close(), insert(), and static_svcs(). { return ACE_Service_Config::global ()->tss_; }

int ACE_Service_Config::load_static_svcs (  void   )  [static, protected]

Add the default statically-linked services to the ACE_Service_Repository. Reimplemented from ACE_Service_Gestalt.

ACE_INLINE int ACE_Service_Config::open (  int  argc, ACE_TCHAR *  argv[], 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 )  [static]

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 from ACE_Service_Gestalt. Definition at line 29 of file Service_Config.inl. References ACE_TCHAR, ACE_TRACE, current(), and ACE_Service_Gestalt::open(). { ACE_TRACE ("ACE_Service_Config::open"); return ACE_Service_Config::current()->open (argc, argv, logger_key, ignore_static_svcs, ignore_default_svc_conf, ignore_debug_flag); }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE_Service_Config::open (  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 )  [static]

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 from ACE_Service_Gestalt. Definition at line 13 of file Service_Config.inl. References ACE_TCHAR, ACE_TRACE, current(), and ACE_Service_Gestalt::open(). Referenced by ACE_Service_Config(). { ACE_TRACE ("ACE_Service_Config::open"); return ACE_Service_Config::current()->open (program_name, logger_key, ignore_static_svcs, ignore_default_svc_conf, ignore_debug_flag); }

int ACE_Service_Config::open_i (  const ACE_TCHAR  program_name[], const ACE_TCHAR *  logger_key, bool  ignore_static_svcs, bool  ignore_default_svc_conf_file, bool  ignore_debug_flag )  [protected, virtual]

Performs an open without parsing command-line arguments. Implements whats different in the opening sequence for this class, as opposed to the base class. 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 from ACE_Service_Gestalt. Definition at line 170 of file Service_Config.cpp. References ACE_DEBUG, ACE_DEFAULT_LOGGER_KEY, ACE_DEFAULT_SVC_CONF, ACE_ERROR, ACE_ERROR_RETURN, ACE_LOG_MSG, ACE_SET_BITS, ACE_TCHAR, ACE_TEXT, ACE_TRACE, ACE_TString, be_a_daemon_, ACE::daemonize(), ACE::debug(), ACE_OS::fclose(), ACE_Log_Msg::flags(), ACE_OS::fopen(), ACE_OS::fprintf(), ACE_Service_Gestalt::init_svc_conf_file_queue(), ACE_Reactor::instance(), ACE_Service_Repository::instance(), LM_DEBUG, LM_ERROR, LM_STARTUP, ACE_Log_Msg::open(), ACE_Service_Gestalt::open_i(), pid_file_name_, ACE_Reactor::register_handler(), ACE_Sig_Set::sig_add(), signal_handler_, signum_, and ACE_OS::strcmp(). { int result = 0; ACE_TRACE ("ACE_Service_Config::open_i"); ACE_Log_Msg *log_msg = ACE_LOG_MSG; if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) SC::open_i - this=%@, opened=%d, ") ACE_TEXT ("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... // The base class open_i increments this and we are // forwarding to it, so we don't have to increment here. if (this->is_opened_ != 0) return ACE_Service_Gestalt::open_i (program_name, logger_key, ignore_static_svcs, ignore_default_svc_conf_file, ignore_debug_flag); // Check for things we need to do on a per-process basis and which // may not be safe, or wise to do an a per instance basis // Override any defaults, if required this->no_static_svcs_ = ignore_static_svcs; // Become a daemon before doing anything else. if (this->be_a_daemon_) ACE::daemonize (); // Write process id to file. if (this->pid_file_name_ != 0) { FILE* pidf = ACE_OS::fopen (this->pid_file_name_, ACE_TEXT("w")); if (pidf != 0) { ACE_OS::fprintf (pidf, "%ld\n", static_cast<long> (ACE_OS::getpid())); ACE_OS::fclose (pidf); } } u_long flags = log_msg->flags (); // Only use STDERR if the caller hasn't already set the flags. if (flags == 0) flags = (u_long) ACE_Log_Msg::STDERR; const ACE_TCHAR *key = logger_key; if (key == 0 || ACE_OS::strcmp (key, ACE_DEFAULT_LOGGER_KEY) == 0) // Only use the static <logger_key_> if the caller doesn't // override it in the parameter list or if the key supplied is // equal to the default static logger key. key = this->logger_key_; else ACE_SET_BITS (flags, ACE_Log_Msg::LOGGER); if (log_msg->open (program_name, flags, key) == -1) result = -1; else { if (ACE::debug ()) ACE_DEBUG ((LM_STARTUP, ACE_TEXT ("starting up daemon %n\n"))); // Initialize the Service Repository (this will still work if // user forgets to define an object of type ACE_Service_Config). ACE_Service_Repository::instance (ACE_Service_Config::MAX_SERVICES); // Initialize the ACE_Reactor (the ACE_Reactor should be the // same size as the ACE_Service_Repository). ACE_Reactor::instance (); // There's no point in dealing with this on NT since it doesn't // really support signals very well... #if !defined (ACE_LACKS_UNIX_SIGNALS) // Only attempt to register a signal handler for positive // signal numbers. if (ACE_Service_Config::signum_ > 0) { ACE_Sig_Set ss; ss.sig_add (ACE_Service_Config::signum_); if (ACE_Reactor::instance ()->register_handler (ss, ACE_Service_Config::signal_handler_) == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("can't register signal handler\n"))); } #endif /* ACE_LACKS_UNIX_SIGNALS */ } if (result == -1) return -1; if (this->init_svc_conf_file_queue () == -1) return -1; // Check if the default file exists before attempting to queue it // for processing if (!ignore_default_svc_conf_file) { FILE *fp = ACE_OS::fopen (ACE_DEFAULT_SVC_CONF, ACE_TEXT ("r")); ignore_default_svc_conf_file = (fp == 0); if (fp != 0) ACE_OS::fclose (fp); } if (!ignore_default_svc_conf_file && this->svc_conf_file_queue_->is_empty ()) { // Load the default "svc.conf" entry here if there weren't // overriding -f arguments in <parse_args>. if (this->svc_conf_file_queue_->enqueue_tail (ACE_TString (ACE_DEFAULT_SVC_CONF)) == -1) { ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("enqueuing ") ACE_DEFAULT_SVC_CONF ACE_TEXT(" file")), -1); } } return ACE_Service_Gestalt::open_i (program_name, logger_key, ignore_static_svcs, ignore_default_svc_conf_file, ignore_debug_flag); }

ACE_INLINE int ACE_Service_Config::parse_args (  int  , ACE_TCHAR *  argv[] )  [static]

Handle the command-line options intended for the ACE_Service_Config. 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 from ACE_Service_Gestalt. Definition at line 49 of file Service_Config.inl. References ACE_TCHAR, current(), and ACE_Service_Gestalt::parse_args(). { return ACE_Service_Config::current ()->parse_args (argc, argv); }

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

Implements whats different in the command line parameter processing for this class, as opposed to the base class. Reimplemented from ACE_Service_Gestalt. Definition at line 104 of file Service_Config.cpp. References ACE_ARGV, ACE_ERROR_RETURN, ACE_TCHAR, ACE_TEXT, ACE_TRACE, ACE_ARGV_T< CHAR_TYPE >::add(), ACE_ARGV_T< CHAR_TYPE >::argc(), ACE_ARGV_T< CHAR_TYPE >::argv(), ACE_OS::atoi(), be_a_daemon_, ACE_Reactor::instance(), LM_ERROR, ACE_Service_Gestalt::parse_args_i(), pid_file_name_, ACE_Reactor::register_handler(), signal_handler_, and signum_. { ACE_TRACE ("ACE_Service_Config::parse_args_i"); // Using PERMUTE_ARGS (default) in order to have all // unrecognized options and their value arguments moved // to the end of the argument vector. We'll pick them up // after processing our options and pass them on to the // base class for further parsing. //FUZZ: disable check_for_lack_ACE_OS ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("bs:p:"), 1 , // Start at argv[1]. 0, // Do not report errors ACE_Get_Opt::RETURN_IN_ORDER); //FUZZ: enable check_for_lack_ACE_OS // Keep a list of all unknown arguments, begin with the // executable's name ACE_ARGV superargv; superargv.add (argv[0]); //FUZZ: disable check_for_lack_ACE_OS for (int c; (c = getopt ()) != -1; ) //FUZZ: enable check_for_lack_ACE_OS switch (c) { case 'p': ACE_Service_Config::pid_file_name_ = getopt.opt_arg (); break; case 'b': ACE_Service_Config::be_a_daemon_ = 1; break; case 's': { // There's no point in dealing with this on NT since it // doesn't really support signals very well... #if !defined (ACE_LACKS_UNIX_SIGNALS) ACE_Service_Config::signum_ = ACE_OS::atoi (getopt.opt_arg ()); if (ACE_Reactor::instance ()->register_handler (ACE_Service_Config::signum_, ACE_Service_Config::signal_handler_) == -1) ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("cannot obtain signal handler\n")), -1); #endif /* ACE_LACKS_UNIX_SIGNALS */ break; } default: superargv.add ( argv[getopt.opt_ind () - 1],true); } // Collect any argumets that were left for (int c = getopt.opt_ind (); c < argc; c++) superargv.add (argv[c-1],true); return ACE_Service_Gestalt::parse_args_i (superargv.argc (), superargv.argv ()); } /* parse_args_i () */

int ACE_Service_Config::process_commandline_directives (  void   )  [static, protected]

Process service configuration requests that were provided on the command-line. Returns the number of errors that occurred. Reimplemented from ACE_Service_Gestalt.

ACE_INLINE int ACE_Service_Config::process_directive (  const ACE_Static_Svc_Descriptor &  ssd, int  force_replace = 0 )  [static]

Process one static service definition. Load a new static service into the ACE_Service_Repository. 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 ACE_Service_Repository. Returns: Returns -1 if the service cannot be 'loaded'. Reimplemented from ACE_Service_Gestalt. Definition at line 154 of file Service_Config.inl. References current(), and ACE_Service_Gestalt::process_directive(). { return ACE_Service_Config::current ()->process_directive (ssd, force_replace); }

ACE_INLINE int ACE_Service_Config::process_directive (  const ACE_TCHAR  directive[]  )  [static]

Process one service configuration directive, which is passed as a string. Returns the number of errors that occurred. Reimplemented from ACE_Service_Gestalt. Definition at line 140 of file Service_Config.inl. References ACE_TCHAR, current(), and ACE_Service_Gestalt::process_directive(). Referenced by ACE_Service_Manager::process_request(). { return ACE_Service_Config::current ()->process_directive (directive); }

ACE_INLINE int ACE_Service_Config::process_directives (  void   )  [static]

Process (or re-process) service configuration requests that are provided in the svc.conf file(s). Returns the number of errors that occurred. Reimplemented from ACE_Service_Gestalt. Definition at line 148 of file Service_Config.inl. References current(), and ACE_Service_Gestalt::process_directives(). Referenced by reconfigure(). { return ACE_Service_Config::current ()->process_directives (); }

int ACE_Service_Config::process_directives_i (  ACE_Svc_Conf_Param *  param  )  [static, protected]

This is the implementation function that process_directives() and process_directive() both call. Returns the number of errors that occurred. Reimplemented from ACE_Service_Gestalt.

ACE_INLINE int ACE_Service_Config::process_file (  const ACE_TCHAR  file[]  )  [static]

Process a file containing a list of service configuration directives. Reimplemented from ACE_Service_Gestalt. Definition at line 133 of file Service_Config.inl. References ACE_INLINE, ACE_TCHAR, current(), and ACE_Service_Gestalt::process_file(). { return ACE_Service_Config::current ()->process_file (file); }

void ACE_Service_Config::reconfig_occurred (  int   )  [static]

Indicate that reconfiguration occurred. Definition at line 568 of file Service_Config.cpp. References ACE_TRACE, and reconfig_occurred_. { ACE_TRACE ("ACE_Service_Config::reconfig_occurred"); ACE_Service_Config::reconfig_occurred_ = config_occurred; }

int ACE_Service_Config::reconfig_occurred (  void   )  [static]

True if reconfiguration occurred. Definition at line 561 of file Service_Config.cpp. References ACE_TRACE, and reconfig_occurred_. Referenced by ACE_Reactor::check_reconfiguration(), and ACE_Service_Manager::reconfigure_services(). { ACE_TRACE ("ACE_Service_Config::reconfig_occurred"); return ACE_Service_Config::reconfig_occurred_ != 0; }

void ACE_Service_Config::reconfigure (  void   )  [static]

Perform the reconfiguration process. Definition at line 483 of file Service_Config.cpp. References ACE_DEBUG, ACE_ERROR, ACE_TEXT, ACE_TRACE, ACE::debug(), LM_DEBUG, LM_ERROR, process_directives(), reconfig_occurred_, and ACE_OS::time(). Referenced by ACE_Reactor::check_reconfiguration(). { ACE_TRACE ("ACE_Service_Config::reconfigure"); ACE_Service_Config::reconfig_occurred_ = 0; if (ACE::debug ()) { #if !defined (ACE_NLOGGING) time_t t = ACE_OS::time (0); #endif /* ! ACE_NLOGGING */ if (ACE::debug ()) ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("beginning reconfiguration at %s"), ACE_OS::ctime (&t))); } if (ACE_Service_Config::process_directives () == -1) ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("process_directives"))); }

int ACE_Service_Config::remove (  const ACE_TCHAR  svc_name[]  )  [static]

Totally remove svc_name from the daemon by removing it from the ACE_Reactor, and unlinking it if necessary. Reimplemented from ACE_Service_Gestalt. Definition at line 347 of file Service_Config.cpp. References ACE_TCHAR, ACE_TRACE, ACE_Service_Repository::instance(), and ACE_Service_Repository::remove(). { ACE_TRACE ("ACE_Service_Config::remove"); return ACE_Service_Repository::instance ()->remove (svc_name); }

int ACE_Service_Config::resume (  const ACE_TCHAR  svc_name[]  )  [static]

Resume a svc_name that was previously suspended or has not yet been resumed (e.g., a static service). Reimplemented from ACE_Service_Gestalt. Definition at line 370 of file Service_Config.cpp. References ACE_TCHAR, ACE_TRACE, ACE_Service_Repository::instance(), and ACE_Service_Repository::resume(). { ACE_TRACE ("ACE_Service_Config::resume"); return ACE_Service_Repository::instance ()->resume (svc_name); }

ACE_INLINE void ACE_Service_Config::signal_handler (  ACE_Sig_Adapter *   )  [static]

Set the signal_handler;for internal use by ACE_Object_Manager only. Definition at line 103 of file Service_Config.inl. References signal_handler_. Referenced by ACE_Object_Manager::init(). { signal_handler_ = signal_handler; }

int ACE_Service_Config::start_daemon (  void   )  [static, protected]

Become a daemon.

ACE_Service_Gestalt * ACE_Service_Config::static_svcs (  void   )  [static]

Returns a pointer to the list of statically linked services. Deprecated: Same as instance(), but still useful in legacy code, (notably, one that can not be easily modified) which uses the following idiom for registering static services: ACE_Service_Config::static_svcs ()->insert (...); Definition at line 324 of file Service_Config.cpp. References instance(). Referenced by ACE_Object_Manager_Preallocations::ACE_Object_Manager_Preallocations(). { return ACE_Service_Config::instance (); }

int ACE_Service_Config::suspend (  const ACE_TCHAR  svc_name[]  )  [static]

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 ACE_Service_Object. A service can be resumed later on by calling the member function... Reimplemented from ACE_Service_Gestalt. Definition at line 360 of file Service_Config.cpp. References ACE_TCHAR, ACE_TRACE, ACE_Service_Repository::instance(), and ACE_Service_Repository::suspend(). { ACE_TRACE ("ACE_Service_Config::suspend"); return ACE_Service_Repository::instance ()->suspend (svc_name); }

---

Friends And Related Function Documentation

friend class ACE_Service_Config_Guard [friend]

This class needs the intimate access to be able to swap the current TSS pointer for the global Gestalt. Reimplemented from ACE_Service_Gestalt. Definition at line 605 of file Service_Config.h.

---

Member Data Documentation

ACE_Service_Config::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks. Reimplemented from ACE_Service_Gestalt. Definition at line 480 of file Service_Config.h.

int ACE_Service_Config::be_a_daemon_ = 0 [static, private]

Shall we become a daemon process? Definition at line 89 of file Service_Config.cpp. Referenced by open_i(), and parse_args_i().

ACE_TCHAR * ACE_Service_Config::pid_file_name_ = 0 [static, private]

Pathname of file to write process id. Definition at line 86 of file Service_Config.cpp. Referenced by open_i(), and parse_args_i().

sig_atomic_t ACE_Service_Config::reconfig_occurred_ = 0 [static, private]

True if reconfiguration occurred. Definition at line 81 of file Service_Config.cpp. Referenced by handle_signal(), reconfig_occurred(), and reconfigure().

ACE_Sig_Adapter * ACE_Service_Config::signal_handler_ = 0 [static, private]

Handles the reconfiguration signals. Definition at line 78 of file Service_Config.cpp. Referenced by open_i(), parse_args_i(), and signal_handler().

int ACE_Service_Config::signum_ = SIGHUP [static, private]

Number of the signal used to trigger reconfiguration. Definition at line 92 of file Service_Config.cpp. Referenced by ACE_Service_Config(), handle_signal(), open_i(), and parse_args_i().

ACE_TSS<ACE_Service_Gestalt> ACE_Service_Config::tss_ [protected]

A Wrapper for the TSS-stored pointer to the "current" configuration Gestalt. Static initializers from any DLL loaded through the SC will find the SC instance through the TSS pointer, instead of the global singleton. This makes it possible to ensure that the new services are loaded in the correct Gestalt, independent of which thread is actually using the SC at the time to do so. Definition at line 267 of file Service_Config.h. Referenced by current(), and instance().

---

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

• Service_Config.h
• Service_Config.cpp
• Service_Config.inl

---