00001
00002
00003 #include "ace/Service_Config.h"
00004
00005 #if !defined (__ACE_INLINE__)
00006 #include "ace/Service_Config.inl"
00007 #endif
00008
00009 #include "ace/Service_Types.h"
00010 #include "ace/Reactor.h"
00011 #include "ace/Singleton.h"
00012 #include "ace/Service_Repository.h"
00013
00014 #ifndef ACE_LACKS_UNIX_SIGNALS
00015 # include "ace/Sig_Adapter.h"
00016 #endif
00017
00018 #include "ace/OS_NS_time.h"
00019 #include "ace/OS_NS_stdio.h"
00020 #include "ace/OS_NS_unistd.h"
00021 #include "ace/Thread.h"
00022 #include "ace/Get_Opt.h"
00023 #include "ace/ARGV.h"
00024 #include "ace/Log_Msg.h"
00025 #include "ace/ACE.h"
00026
00027 ACE_RCSID (ace,
00028 Service_Config,
00029 "$Id: Service_Config.cpp 84619 2009-02-26 12:26:16Z johnnyw $")
00030
00031 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00032
00033 ACE_Threading_Helper<ACE_Thread_Mutex>::~ACE_Threading_Helper ()
00034 {
00035 ACE_OS::thr_key_detach (this->key_, 0);
00036 ACE_OS::thr_keyfree (this->key_);
00037 }
00038
00039 ACE_Threading_Helper<ACE_Thread_Mutex>::ACE_Threading_Helper ()
00040 : key_ (ACE_OS::NULL_key)
00041 {
00042 # if defined (ACE_HAS_TSS_EMULATION)
00043 ACE_Object_Manager::init_tss ();
00044 # endif
00045
00046 if (ACE_Thread::keycreate (&key_, 0, 0) == -1)
00047 {
00048 ACE_ERROR ((LM_ERROR,
00049 ACE_TEXT ("(%P|%t) Failed to create thread key: %p\n"),
00050 ACE_TEXT ("")));
00051 }
00052 }
00053
00054 void
00055 ACE_Threading_Helper<ACE_Thread_Mutex>::set (void* p)
00056 {
00057 if (ACE_Thread::setspecific (key_, p) == -1)
00058 ACE_ERROR ((LM_ERROR,
00059 ACE_TEXT ("(%P|%t) Service Config failed to set thread key value: %p\n"),
00060 ACE_TEXT("")));
00061 }
00062
00063 void*
00064 ACE_Threading_Helper<ACE_Thread_Mutex>::get (void)
00065 {
00066 void* temp = 0;
00067 if (ACE_Thread::getspecific (key_, &temp) == -1)
00068 ACE_ERROR_RETURN ((LM_ERROR,
00069 ACE_TEXT ("(%P|%t) Service Config failed to get thread key value: %p\n"),
00070 ACE_TEXT("")),
00071 0);
00072 return temp;
00073 }
00074
00075 ACE_Threading_Helper<ACE_Null_Mutex>::~ACE_Threading_Helper ()
00076 {
00077 }
00078
00079 ACE_Threading_Helper<ACE_Null_Mutex>::ACE_Threading_Helper ()
00080 {
00081 }
00082
00083 void
00084 ACE_Threading_Helper<ACE_Null_Mutex>::set (void*)
00085 {
00086 }
00087
00088 void*
00089 ACE_Threading_Helper<ACE_Null_Mutex>::get (void)
00090 {
00091 return ACE_Service_Config::singleton()->instance_.get ();
00092 }
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103 typedef ACE_Unmanaged_Singleton<ACE_Service_Config,
00104 ACE_SYNCH_RECURSIVE_MUTEX> ACE_SERVICE_CONFIG_SINGLETON;
00105
00106
00107
00108 ACE_Service_Config_Guard::ACE_Service_Config_Guard (ACE_Service_Gestalt * psg)
00109 : saved_ (ACE_Service_Config::current ())
00110 {
00111 if (ACE::debug ())
00112 ACE_DEBUG ((LM_DEBUG,
00113 ACE_TEXT ("ACE (%P|%t) - SCG:<ctor=%@>")
00114 ACE_TEXT (" - config=%@ repo=%@ superceded by repo=%@\n"),
00115 this,
00116 this->saved_.get (),
00117 this->saved_->repo_,
00118 psg->repo_));
00119
00120
00121 ACE_Service_Config::current (psg);
00122 }
00123
00124 ACE_Service_Config_Guard::~ACE_Service_Config_Guard (void)
00125 {
00126 ACE_Service_Gestalt* s = this->saved_.get ();
00127 ACE_ASSERT (s != 0);
00128
00129 ACE_Service_Config::current (s);
00130
00131 if (ACE::debug ())
00132 ACE_DEBUG ((LM_DEBUG,
00133 ACE_TEXT ("ACE (%P|%t) SCG:<dtor=%@>")
00134 ACE_TEXT (" - new repo=%@\n"),
00135 this,
00136 this->saved_->repo_));
00137 }
00138
00139
00140 ACE_ALLOC_HOOK_DEFINE (ACE_Service_Config)
00141
00142
00143 ACE_Sig_Adapter *ACE_Service_Config::signal_handler_ = 0;
00144
00145
00146 sig_atomic_t ACE_Service_Config::reconfig_occurred_ = 0;
00147
00148
00149
00150
00151 ACE_TCHAR *ACE_Service_Config::pid_file_name_ = 0;
00152
00153
00154 bool ACE_Service_Config::be_a_daemon_ = false;
00155
00156
00157 int ACE_Service_Config::signum_ = SIGHUP;
00158
00159 void
00160 ACE_Service_Config::dump (void) const
00161 {
00162 #if defined (ACE_HAS_DUMP)
00163 ACE_TRACE ("ACE_Service_Config::dump");
00164 #endif
00165 }
00166
00167 int
00168 ACE_Service_Config::parse_args_i (int argc, ACE_TCHAR *argv[])
00169 {
00170 ACE_TRACE ("ACE_Service_Config::parse_args_i");
00171
00172
00173
00174
00175
00176
00177
00178 ACE_Get_Opt getopt (argc,
00179 argv,
00180 ACE_TEXT ("bs:p:"),
00181 1 ,
00182 0,
00183 ACE_Get_Opt::RETURN_IN_ORDER);
00184
00185
00186
00187 for (int c; (c = getopt ()) != -1; )
00188
00189 switch (c)
00190 {
00191 case 'p':
00192 ACE_Service_Config::pid_file_name_ = getopt.opt_arg ();
00193 break;
00194 case 'b':
00195 ACE_Service_Config::be_a_daemon_ = true;
00196 break;
00197 case 's':
00198 {
00199
00200
00201 #if !defined (ACE_LACKS_UNIX_SIGNALS)
00202 ACE_Service_Config::signum_ =
00203 ACE_OS::atoi (getopt.opt_arg ());
00204
00205 if (ACE_Reactor::instance ()->register_handler
00206 (ACE_Service_Config::signum_,
00207 ACE_Service_Config::signal_handler_) == -1)
00208 ACE_ERROR_RETURN ((LM_ERROR,
00209 ACE_TEXT ("cannot obtain signal handler\n")),
00210 -1);
00211 #endif
00212 break;
00213 }
00214 default:;
00215
00216 }
00217
00218 return 0;
00219 }
00220
00221
00222 int
00223 ACE_Service_Config::open_i (const ACE_TCHAR program_name[],
00224 const ACE_TCHAR *logger_key,
00225 bool ,
00226 bool ,
00227 bool )
00228 {
00229 ACE_TRACE ("ACE_Service_Config::open_i");
00230 ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1));
00231
00232 ACE_Log_Msg *log_msg = ACE_LOG_MSG;
00233
00234 if (ACE::debug ())
00235 ACE_DEBUG ((LM_DEBUG,
00236 ACE_TEXT ("ACE (%P|%t) SC::open_i - this=%@, opened=%d\n"),
00237 this, this->is_opened_));
00238
00239
00240 if (this->is_opened_)
00241 return 0;
00242
00243 this->is_opened_ = true;
00244
00245
00246
00247
00248
00249 if (ACE_Service_Config::be_a_daemon_)
00250 ACE::daemonize ();
00251
00252
00253 if (this->pid_file_name_ != 0)
00254 {
00255 FILE* pidf = ACE_OS::fopen (this->pid_file_name_,
00256 ACE_TEXT("w"));
00257
00258 if (pidf != 0)
00259 {
00260 ACE_OS::fprintf (pidf,
00261 "%ld\n",
00262 static_cast<long> (ACE_OS::getpid()));
00263 ACE_OS::fclose (pidf);
00264 }
00265 }
00266
00267 u_long flags = log_msg->flags ();
00268
00269
00270 if (flags == 0)
00271 flags = (u_long) ACE_Log_Msg::STDERR;
00272
00273 const ACE_TCHAR *key = logger_key;
00274
00275 if (key == 0 || ACE_OS::strcmp (key, ACE_DEFAULT_LOGGER_KEY) == 0)
00276 {
00277
00278
00279
00280 key = ACE_Service_Config::current()->logger_key_;
00281 }
00282 else
00283 {
00284 ACE_SET_BITS (flags, ACE_Log_Msg::LOGGER);
00285 }
00286
00287 if (log_msg->open (program_name,
00288 flags,
00289 key) == -1)
00290 return -1;
00291
00292 if (ACE::debug ())
00293 ACE_DEBUG ((LM_STARTUP,
00294 ACE_TEXT ("starting up daemon %n\n")));
00295
00296
00297
00298 ACE_Service_Repository::instance (ACE_Service_Gestalt::MAX_SERVICES);
00299
00300
00301
00302 ACE_Reactor::instance ();
00303
00304
00305
00306 #if !defined (ACE_LACKS_UNIX_SIGNALS)
00307
00308
00309 if (ACE_Service_Config::signum_ > 0)
00310 {
00311 ACE_Sig_Set ss;
00312 ss.sig_add (ACE_Service_Config::signum_);
00313 if ((ACE_Reactor::instance () != 0) &&
00314 (ACE_Reactor::instance ()->register_handler
00315 (ss, ACE_Service_Config::signal_handler_) == -1))
00316 ACE_ERROR ((LM_ERROR,
00317 ACE_TEXT ("can't register signal handler\n")));
00318 }
00319 #endif
00320
00321 return 0;
00322 }
00323
00324
00325
00326 ACE_Service_Config *
00327 ACE_Service_Config::singleton (void)
00328 {
00329 return ACE_SERVICE_CONFIG_SINGLETON::instance ();
00330 }
00331
00332 int
00333 ACE_Service_Config::insert (ACE_Static_Svc_Descriptor* stsd)
00334 {
00335 return ACE_Service_Config::instance ()->insert (stsd);
00336 }
00337
00338
00339
00340
00341 int
00342 ACE_Service_Config::remove (const ACE_TCHAR svc_name[])
00343 {
00344 ACE_TRACE ("ACE_Service_Config::remove");
00345 return ACE_Service_Repository::instance ()->remove (svc_name);
00346 }
00347
00348
00349
00350
00351
00352
00353
00354 int
00355 ACE_Service_Config::suspend (const ACE_TCHAR svc_name[])
00356 {
00357 ACE_TRACE ("ACE_Service_Config::suspend");
00358 return ACE_Service_Repository::instance ()->suspend (svc_name);
00359 }
00360
00361
00362
00363
00364 int
00365 ACE_Service_Config::resume (const ACE_TCHAR svc_name[])
00366 {
00367 ACE_TRACE ("ACE_Service_Config::resume");
00368 return ACE_Service_Repository::instance ()->resume (svc_name);
00369 }
00370
00371
00372 ACE_Service_Config::ACE_Service_Config (bool ignore_static_svcs,
00373 size_t size,
00374 int signum)
00375 {
00376 ACE_TRACE ("ACE_Service_Config::ACE_Service_Config");
00377
00378
00379
00380
00381 ACE_Service_Gestalt* tmp = 0;
00382 ACE_NEW_NORETURN (tmp,
00383 ACE_Service_Gestalt (size, false, ignore_static_svcs));
00384
00385 this->is_opened_ = false;
00386 this->instance_ = tmp;
00387 this->threadkey_.set (tmp);
00388
00389 ACE_Service_Config::signum_ = signum;
00390 }
00391
00392 ACE_Service_Config::ACE_Service_Config (const ACE_TCHAR program_name[],
00393 const ACE_TCHAR *logger_key)
00394 {
00395 ACE_TRACE ("ACE_Service_Config::ACE_Service_Config");
00396
00397
00398
00399
00400 ACE_Service_Gestalt* tmp = 0;
00401 ACE_NEW_NORETURN (tmp,
00402 ACE_Service_Gestalt (ACE_Service_Repository::DEFAULT_SIZE, false));
00403
00404 this->is_opened_ = false;
00405 this->instance_ = tmp;
00406 this->threadkey_.set (tmp);
00407
00408 if (this->open (program_name,
00409 logger_key) == -1 && errno != ENOENT)
00410 {
00411
00412
00413 ACE_ERROR ((LM_ERROR,
00414 ACE_TEXT ("(%P|%t) SC failed to open: %p\n"),
00415 program_name));
00416 }
00417 }
00418
00419
00420
00421
00422
00423
00424 ACE_Service_Gestalt*
00425 ACE_Service_Config::current (void)
00426 {
00427 void* temp = ACE_Service_Config::singleton()->threadkey_.get ();
00428 if (temp == 0) {
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439 temp = global();
00440 singleton()->threadkey_.set (temp);
00441 }
00442
00443 return static_cast<ACE_Service_Gestalt*> (temp);
00444 }
00445
00446
00447 void
00448 ACE_Service_Config::current (ACE_Service_Gestalt* newcurrent)
00449 {
00450 ACE_Service_Config::singleton()->threadkey_.set (newcurrent);
00451 }
00452
00453
00454
00455 #if (ACE_USES_CLASSIC_SVC_CONF == 0)
00456 ACE_Service_Type *
00457 ACE_Service_Config::create_service_type (const ACE_TCHAR *n,
00458 ACE_Service_Type_Impl *o,
00459 ACE_DLL &dll,
00460 int active)
00461 {
00462 ACE_Service_Type *sp = 0;
00463 ACE_NEW_RETURN (sp,
00464 ACE_Service_Type (n, o, dll, active),
00465 0);
00466 return sp;
00467 }
00468 #endif
00469
00470 ACE_Service_Type_Impl *
00471 ACE_Service_Config::create_service_type_impl (const ACE_TCHAR *name,
00472 int type,
00473 void *symbol,
00474 u_int flags,
00475 ACE_Service_Object_Exterminator gobbler)
00476 {
00477 ACE_Service_Type_Impl *stp = 0;
00478
00479
00480
00481
00482
00483 switch (type)
00484 {
00485 case ACE_Service_Type::SERVICE_OBJECT:
00486 ACE_NEW_RETURN (stp,
00487 ACE_Service_Object_Type ((ACE_Service_Object *) symbol,
00488 name, flags,
00489 gobbler),
00490 0);
00491 break;
00492 case ACE_Service_Type::MODULE:
00493 ACE_NEW_RETURN (stp,
00494 ACE_Module_Type (symbol, name, flags),
00495 0);
00496 break;
00497 case ACE_Service_Type::STREAM:
00498 ACE_NEW_RETURN (stp,
00499 ACE_Stream_Type (symbol, name, flags),
00500 0);
00501 break;
00502 default:
00503 ACE_ERROR ((LM_ERROR,
00504 ACE_TEXT ("unknown case\n")));
00505 break;
00506 }
00507 return stp;
00508
00509 }
00510
00511
00512
00513 void
00514 ACE_Service_Config::handle_signal (int sig,
00515 siginfo_t *,
00516 ucontext_t *)
00517 {
00518 #if defined (ACE_NDEBUG)
00519 ACE_UNUSED_ARG (sig);
00520 #else
00521 ACE_ASSERT (ACE_Service_Config::signum_ == sig);
00522 #endif
00523
00524 ACE_Service_Config::reconfig_occurred_ = 1;
00525 }
00526
00527
00528 void
00529 ACE_Service_Config::reconfigure (void)
00530 {
00531 ACE_TRACE ("ACE_Service_Config::reconfigure");
00532
00533 ACE_Service_Config::reconfig_occurred_ = 0;
00534
00535 if (ACE::debug ())
00536 {
00537 #if !defined (ACE_NLOGGING)
00538 time_t t = ACE_OS::time (0);
00539 #endif
00540 if (ACE::debug ())
00541 ACE_DEBUG ((LM_DEBUG,
00542 ACE_TEXT ("beginning reconfiguration at %s"),
00543 ACE_OS::ctime (&t)));
00544 }
00545 if (ACE_Service_Config::process_directives () == -1)
00546 ACE_ERROR ((LM_ERROR,
00547 ACE_TEXT ("%p\n"),
00548 ACE_TEXT ("process_directives")));
00549 }
00550
00551
00552 int
00553 ACE_Service_Config::close (void)
00554 {
00555 ACE_Service_Config::singleton ()->instance_->close ();
00556
00557
00558
00559 ACE_Service_Repository::close_singleton ();
00560
00561
00562 ACE_SERVICE_CONFIG_SINGLETON::close ();
00563
00564 return 0;
00565 }
00566
00567
00568 int
00569 ACE_Service_Config::fini_svcs (void)
00570 {
00571 ACE_TRACE ("ACE_Service_Config::fini_svcs");
00572
00573
00574 if (ACE::debug ())
00575 ACE_Log_Msg::disable_debug_messages ();
00576
00577 int result = 0;
00578 if (ACE_Service_Repository::instance () != 0)
00579 result = ACE_Service_Repository::instance ()->fini ();
00580
00581 if (ACE::debug ())
00582 ACE_Log_Msg::enable_debug_messages ();
00583
00584 return result;
00585 }
00586
00587
00588 ACE_Service_Config::~ACE_Service_Config (void)
00589 {
00590 ACE_TRACE ("ACE_Service_Config::~ACE_Service_Config");
00591 }
00592
00593
00594
00595
00596 int
00597 ACE_Service_Config::reconfig_occurred (void)
00598 {
00599 ACE_TRACE ("ACE_Service_Config::reconfig_occurred");
00600 return ACE_Service_Config::reconfig_occurred_ != 0;
00601 }
00602
00603 void
00604 ACE_Service_Config::reconfig_occurred (int config_occurred)
00605 {
00606 ACE_TRACE ("ACE_Service_Config::reconfig_occurred");
00607 ACE_Service_Config::reconfig_occurred_ = config_occurred;
00608 }
00609
00610 ACE_END_VERSIONED_NAMESPACE_DECL