TAO/orbsvcs/Notify_Service/Notify_Service.cpp

   1 #include "orbsvcs/Log_Macros.h"
   2 #include "Notify_Service.h"
   3
   4 #include "orbsvcs/Daemon_Utilities.h"
   5
   6 #include "orbsvcs/Notify/Service.h"
   7 #include "orbsvcs/Notify/EventChannelFactory.h"
   8
   9 #include "tao/debug.h"
  10 #include "tao/IORTable/IORTable.h"
  11 #include "tao/ORB_Core.h"
  12
  13 #if defined (TAO_HAS_NOTIFICATION_MONITOR_CONTROL) && defined (TAO_AS_STATIC_LIBS)
  14 // for static builds, be sure the library is included
  15 #include "orbsvcs/orbsvcs/Notify/MonitorControlExt/MC_Notify_Service.h"
  16 #include "orbsvcs/orbsvcs/Notify/MonitorControl/MonitorManager.h"
  17 #endif
  18
  19 #if defined (TAO_EXPLICIT_NEGOTIATE_CODESETS)
  20 #include "tao/Codeset/Codeset.h"
  21 #endif /* TAO_EXPLICIT_NEGOTIATE_CODESETS */
  22
  23 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
  24 #include "tao/Messaging/Messaging.h"
  25 #endif /* TAO_HAS_CORBA_MESSAGING != 0 */
  26
  27 #include "ace/Arg_Shifter.h"
  28 #include "ace/Get_Opt.h"
  29 #include "ace/Sched_Params.h"
  30 #include "ace/Synch.h"
  31 #include "ace/Argv_Type_Converter.h"
  32 #include "ace/Logging_Strategy.h"
  33
  34 TAO_Notify_Service_Driver::TAO_Notify_Service_Driver (void)
  35 : notify_service_ (0)
  36 , bootstrap_ (false)
  37 , use_name_svc_ (true)
  38 , ior_output_file_name_ (0)
  39 , notify_factory_name_ (NOTIFY_KEY)
  40 , register_event_channel_ (false)
  41 , nthreads_ (1)
  42 , separate_dispatching_orb_ (false)
  43 , timeout_ (0)
  44 , logging_worker_(this)
  45 , shutdown_orb_ (true)
  46 , shutdown_dispatching_orb_ (true)
  47 {
  48 }
  49
  50 TAO_Notify_Service_Driver::~TAO_Notify_Service_Driver (void)
  51 {
  52 }
  53
  54 int
  55 TAO_Notify_Service_Driver::init_ORB (int& argc, ACE_TCHAR *argv [])
  56 {
  57   this->orb_ = CORBA::ORB_init (argc, argv);
  58
  59   ACE_LOG_MSG->open
  60     (argv[0], ACE_Log_Msg::SYSLOG, ACE_TEXT ("TAO Notify"));
  61
  62   this->apply_timeout (this->orb_.in ());
  63
  64   CORBA::Object_var object =
  65     this->orb_->resolve_initial_references("RootPOA");
  66
  67   if (CORBA::is_nil (object.in ()))
  68     ORBSVCS_ERROR_RETURN ((LM_ERROR,
  69                        " (%P|%t) Unable to resolve the RootPOA.\n"),
  70                       -1);
  71
  72   this->poa_ =
  73     PortableServer::POA::_narrow (object.in ());
  74
  75   PortableServer::POAManager_var poa_manager =
  76     this->poa_->the_POAManager ();
  77
  78   poa_manager->activate ();
  79
  80   return 0;
  81 }
  82
  83 int
  84 TAO_Notify_Service_Driver::init_dispatching_ORB (int& argc, ACE_TCHAR *argv [])
  85 {
  86   this->dispatching_orb_ = CORBA::ORB_init (argc, argv, "dispatcher");
  87
  88   this->apply_timeout (this->dispatching_orb_.in ());
  89
  90   return 0;
  91 }
  92
  93 void
  94 TAO_Notify_Service_Driver::apply_timeout (CORBA::ORB_ptr orb)
  95 {
  96 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
  97   if (this->timeout_ != 0)
  98     {
  99       // convert from msec to "TimeT"
 100       CORBA::Any timeout;
 101       TimeBase::TimeT value = 10000 * this->timeout_;
 102       timeout <<= value;
 103
 104       CORBA::Object_var object =
 105         orb->resolve_initial_references ("ORBPolicyManager");
 106       CORBA::PolicyManager_var policy_manager =
 107         CORBA::PolicyManager::_narrow (object.in ());
 108       if (CORBA::is_nil (policy_manager.in ()))
 109         throw CORBA::INTERNAL ();
 110
 111       CORBA::PolicyList policy_list (1);
 112       policy_list.length (1);
 113       policy_list[0] = orb->create_policy (
 114                               Messaging::RELATIVE_RT_TIMEOUT_POLICY_TYPE,
 115                               timeout);
 116       policy_manager->set_policy_overrides (policy_list, CORBA::SET_OVERRIDE);
 117       policy_list[0]->destroy ();
 118   }
 119 #else
 120   ACE_UNUSED_ARG (orb);
 121 #endif /* TAO_HAS_CORBA_MESSAGING != 0 */
 122 }
 123
 124 int
 125 TAO_Notify_Service_Driver::init (int argc, ACE_TCHAR *argv[])
 126 {
 127   // Check if -ORBDaemon is specified and if so, daemonize at this moment,
 128   // -ORBDaemon in the ORB core is faulty, see bugzilla 3335
 129   TAO_Daemon_Utility::check_for_daemon (argc, argv);
 130
 131   if (this->parse_args(argc, argv) != 0)
 132     return -1;
 133
 134   // initalize the ORB.
 135   if (this->init_ORB (argc, argv) != 0)
 136     return -1;
 137
 138   this->notify_service_ = TAO_Notify_Service::load_default ();
 139
 140   if (this->notify_service_ == 0)
 141     {
 142       if (TAO_debug_level > 0)
 143         {
 144           ORBSVCS_ERROR ((LM_ERROR,
 145                       ACE_TEXT ("Service not found. Check service ")
 146                       ACE_TEXT ("configurator file.\n")));
 147         }
 148       return -1;
 149     }
 150
 151   if (this->separate_dispatching_orb_)
 152     {
 153       if (this->init_dispatching_ORB (argc, argv) != 0)
 154         {
 155           return -1;
 156         }
 157
 158       this->notify_service_->init_service2 (this->orb_.in (), this->dispatching_orb_.in());
 159     }
 160   else
 161     {
 162       this->notify_service_->init_service (this->orb_.in ());
 163     }
 164
 165   this->logging_worker_.start();
 166
 167   if (this->nthreads_ > 0) // we have chosen to run in a thread pool.
 168     {
 169       if (TAO_debug_level > 0)
 170         {
 171           ORBSVCS_DEBUG ((LM_DEBUG,
 172                       ACE_TEXT("Running %d ORB threads\n"),
 173                       this->nthreads_));
 174         }
 175       worker_.orb (this->orb_.in ());
 176
 177       // Task activation flags.
 178       long const flags =
 179         THR_NEW_LWP |
 180         THR_JOINABLE |
 181         this->orb_->orb_core ()->orb_params ()->thread_creation_flags ();
 182
 183       int const priority =
 184         ACE_Sched_Params::priority_min (ACE_Utils::truncate_cast<ACE_Sched_Params::Policy> (this->orb_->orb_core ()->orb_params ()->sched_policy ()),
 185                                         ACE_Utils::truncate_cast<int> (this->orb_->orb_core ()->orb_params ()->scope_policy ()));
 186
 187       if (worker_.activate (flags,
 188                             this->nthreads_, 0, priority) != 0)
 189         {
 190           ORBSVCS_ERROR_RETURN ((LM_ERROR,
 191                              "Cannot activate client threads\n"), -1);
 192         }
 193     }
 194
 195   // Check first if the naming service
 196   if (this->use_name_svc_)
 197     {
 198       // Resolve the naming service.
 199       int const ns_ret = this->resolve_naming_service ();
 200
 201       if (ns_ret != 0)
 202         return -1;
 203     }
 204
 205   if (TAO_debug_level > 0)
 206     {
 207       ORBSVCS_DEBUG ((LM_DEBUG,
 208                   ACE_TEXT("\nStarting up the Notification Service...\n")));
 209     }
 210
 211   // Activate the factory
 212   this->notify_factory_ =
 213     notify_service_->create (this->poa_.in (),
 214                              this->notify_factory_name_.c_str ());
 215
 216   ACE_ASSERT (!CORBA::is_nil (this->notify_factory_.in ()));
 217
 218   if (this->bootstrap_) // Enable corbaloc usage
 219     {
 220       CORBA::Object_var table_object =
 221         this->orb_->resolve_initial_references ("IORTable");
 222
 223       IORTable::Table_var adapter =
 224         IORTable::Table::_narrow (table_object.in ());
 225
 226       if (CORBA::is_nil (adapter.in ()))
 227         {
 228           if (TAO_debug_level > 0)
 229             {
 230               ORBSVCS_ERROR ((LM_ERROR,
 231                           "Nil IORTable. corbaloc support not enabled.\n"));
 232             }
 233         }
 234       else
 235         {
 236           CORBA::String_var ior =
 237             this->orb_->object_to_string (this->notify_factory_.in ());
 238           adapter->bind (this->notify_factory_name_.c_str (), ior.in ());
 239         }
 240     }
 241
 242   // Register with the Name service, if asked
 243   if (this->use_name_svc_ && !CORBA::is_nil (this->naming_.in ()))
 244     {
 245       CosNaming::Name_var name =
 246         this->naming_->to_name (this->notify_factory_name_.c_str ());
 247
 248       this->naming_->rebind (name.in (),
 249                              this->notify_factory_.in ());
 250
 251       if (TAO_debug_level > 0)
 252         {
 253           ORBSVCS_DEBUG ((LM_DEBUG,
 254                       "Registered with the naming service as: %C\n",
 255                       this->notify_factory_name_.c_str()));
 256         }
 257
 258       if (this->register_event_channel_)
 259         {
 260           // If we don't have any name configured, default to the standard name
 261           if (this->notify_channel_name_.is_empty ())
 262             {
 263               notify_channel_name_.insert (NOTIFY_CHANNEL_NAME);
 264             }
 265
 266           for (ACE_Unbounded_Set<ACE_CString>::const_iterator ci (
 267                 this->notify_channel_name_); !ci.done(); ci++)
 268             {
 269               // create an event channel
 270               CosNotifyChannelAdmin::ChannelID id;
 271
 272               CosNotification::QoSProperties initial_qos;
 273               CosNotification::AdminProperties initial_admin;
 274
 275               CosNotifyChannelAdmin::EventChannel_var ec;
 276               TAO_Notify_EventChannelFactory* factory_impl =
 277                 dynamic_cast<TAO_Notify_EventChannelFactory*> (
 278                   this->notify_factory_->_servant ());
 279               if (factory_impl == 0)
 280                 {
 281                   ec = this->notify_factory_->create_channel (initial_qos,
 282                                                               initial_admin,
 283                                                               id);
 284                 }
 285               else
 286                 {
 287                   ec = factory_impl->create_named_channel (
 288                                        initial_qos, initial_admin,id,
 289                                        (*ci).c_str ());
 290                 }
 291
 292               name = this->naming_->to_name ((*ci).c_str ());
 293
 294               this->naming_->rebind (name.in (), ec.in ());
 295
 296               if (TAO_debug_level > 0)
 297                 {
 298                   ORBSVCS_DEBUG ((LM_DEBUG,
 299                               "Registered an Event Channel with the naming "
 300                               "service as: %C\n",
 301                               (*ci).c_str()));
 302                 }
 303             }
 304         }
 305     }
 306
 307   // Write IOR to a file, if asked.
 308   // Note: do this last to ensure that we're up and running before the file is written
 309   CORBA::String_var str =
 310     this->orb_->object_to_string (this->notify_factory_.in ());
 311
 312   if (this->ior_output_file_name_)
 313     {
 314        FILE* ior_output_file = ACE_OS::fopen (ior_output_file_name_,
 315                                               ACE_TEXT("w"));
 316        if (ior_output_file == 0)
 317         {
 318           ORBSVCS_ERROR_RETURN ((LM_ERROR,
 319                              "Unable to open %s for writing: %p\n",
 320                              this->ior_output_file_name_, "Notify_Service"),
 321                              -1);
 322         }
 323
 324       ACE_OS::fprintf (ior_output_file, "%s", str.in ());
 325       ACE_OS::fclose (ior_output_file);
 326     }
 327   else if (TAO_debug_level > 0)
 328     {
 329       ORBSVCS_DEBUG ((LM_DEBUG,
 330                   ACE_TEXT ("The Notification Event Channel Factory IOR is <%C>\n"),
 331                   str.in ()));
 332     }
 333
 334   return 0;
 335 }
 336
 337 int
 338 TAO_Notify_Service_Driver::resolve_naming_service (void)
 339 {
 340   try
 341     {
 342       CORBA::Object_var naming_obj =
 343         this->orb_->resolve_initial_references ("NameService");
 344
 345       // Need to check return value for errors.
 346       if (CORBA::is_nil (naming_obj.in ()))
 347         ORBSVCS_ERROR_RETURN ((LM_ERROR,
 348                            " (%P|%t) Unable to resolve the Naming Service.\n"),
 349                           -1);
 350
 351       this->naming_ = CosNaming::NamingContextExt::_narrow (naming_obj.in ());
 352     }
 353   catch (const CORBA::Exception &)
 354     {
 355         ORBSVCS_ERROR_RETURN ((LM_ERROR,
 356                            " (%P|%t) Unable to resolve the Naming Service.\n"),
 357                           -1);
 358     }
 359   catch (...)
 360     {
 361         ORBSVCS_ERROR_RETURN ((LM_ERROR,
 362                            " (%P|%t) Unable to resolve the Naming Service.\n"),
 363                           -1);
 364     }
 365   return 0;
 366 }
 367
 368 int
 369 TAO_Notify_Service_Driver::run (void)
 370 {
 371   if (TAO_debug_level > 0 )
 372     ORBSVCS_DEBUG ((LM_DEBUG,
 373                 ACE_TEXT ("%C: Running the Notification Service\n"),
 374                 __FILE__));
 375
 376   if (this->nthreads_ > 0)
 377     {
 378       this->worker_.wait ();
 379       return 0;
 380     }
 381   else
 382     {
 383       this->orb_->run ();
 384     }
 385
 386   this->logging_worker_.end();
 387   return 0;
 388 }
 389
 390 int
 391 TAO_Notify_Service_Driver::fini (void)
 392 {
 393   /// Release all the _vars as the ORB about to go away.
 394   CosNotifyChannelAdmin::EventChannelFactory_var factory =
 395     this->notify_factory_._retn ();
 396   CORBA::ORB_var orb = this->orb_._retn ();
 397   CORBA::ORB_var dispatching_orb = this->dispatching_orb_._retn ();
 398   PortableServer::POA_var poa = this->poa_._retn ();
 399   CosNaming::NamingContextExt_var naming = this->naming_._retn ();
 400
 401   // This must be called to ensure that all services shut down
 402   // correctly.  Depending upon the type of service loaded, it may
 403   // or may not actually perform any actions.
 404   this->notify_service_->finalize_service (factory.in ());
 405   factory = CosNotifyChannelAdmin::EventChannelFactory::_nil ();
 406
 407   this->notify_service_->fini ();
 408
 409   // Deactivate.
 410   if (this->use_name_svc_ && !CORBA::is_nil (naming.in ()))
 411     {
 412       // Unbind all event channels from the naming service
 413       if (this->register_event_channel_)
 414         {
 415           for (ACE_Unbounded_Set<ACE_CString>::const_iterator ci (
 416                this->notify_channel_name_); !ci.done(); ci++)
 417             {
 418               CosNaming::Name_var name = naming->to_name ((*ci).c_str ());
 419               naming->unbind (name.in ());
 420             }
 421         }
 422
 423       // Unbind from the naming service.
 424       CosNaming::Name_var name =
 425         naming->to_name (this->notify_factory_name_.c_str ());
 426
 427       naming->unbind (name.in ());
 428
 429       naming = CosNaming::NamingContextExt::_nil ();
 430     }
 431
 432   if (!CORBA::is_nil (poa.in ()))
 433     {
 434       poa->destroy (true, true);
 435       poa = PortableServer::POA::_nil ();
 436     }
 437
 438   if (this->shutdown_dispatching_orb_ && !CORBA::is_nil (dispatching_orb_.in ()))
 439     {
 440       dispatching_orb->shutdown ();
 441     }
 442
 443   // shutdown the ORB.
 444   if (this->shutdown_orb_ && !CORBA::is_nil (orb.in ()))
 445     {
 446       orb->shutdown ();
 447     }
 448
 449   // Make sure all worker threads are gone.
 450   this->worker_.wait ();
 451   this->logging_worker_.wait ();
 452
 453   // Destroy the ORB
 454   if (this->shutdown_dispatching_orb_ && !CORBA::is_nil (dispatching_orb_.in ()))
 455     {
 456       dispatching_orb->destroy ();
 457     }
 458
 459   // Destroy the ORB.
 460   if (this->shutdown_orb_ && !CORBA::is_nil (orb.in ()))
 461     {
 462       orb->destroy ();
 463     }
 464
 465   dispatching_orb_ = CORBA::ORB::_nil ();
 466
 467   worker_.orb (CORBA::ORB::_nil ());
 468
 469   orb = CORBA::ORB::_nil ();
 470
 471   return 0;
 472 }
 473
 474 int
 475 TAO_Notify_Service_Driver::parse_args (int argc, ACE_TCHAR *argv[])
 476 {
 477   ACE_Arg_Shifter arg_shifter (argc, argv);
 478
 479   const ACE_TCHAR* current_arg = 0;
 480   while (arg_shifter.is_anything_left ())
 481     {
 482       if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Factory"))))
 483         {
 484           this->notify_factory_name_.set (ACE_TEXT_ALWAYS_CHAR(current_arg));
 485           arg_shifter.consume_arg ();
 486         }
 487       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-ShutdownORB")) == 0)
 488         {
 489           current_arg = arg_shifter.get_the_parameter
 490                               (ACE_TEXT("-ShutdownORB"));
 491           if (current_arg != 0 &&
 492               (ACE_OS::strcmp(ACE_TEXT ("0"), current_arg) == 0 ||
 493                ACE_OS::strcmp(ACE_TEXT ("1"), current_arg) == 0))
 494             {
 495               this->shutdown_orb_ =
 496                             static_cast<bool> (ACE_OS::atoi(current_arg));
 497             }
 498           if (current_arg != 0)
 499             arg_shifter.consume_arg ();
 500         }
 501       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-ShutdownDispatchingORB")) == 0)
 502         {
 503           current_arg = arg_shifter.get_the_parameter
 504                               (ACE_TEXT("-ShutdownDispatchingORB"));
 505           if (current_arg != 0 &&
 506               (ACE_OS::strcmp(ACE_TEXT ("0"), current_arg) == 0 ||
 507                ACE_OS::strcmp(ACE_TEXT ("1"), current_arg) == 0))
 508             {
 509               this->shutdown_dispatching_orb_ =
 510                             static_cast<bool> (ACE_OS::atoi(current_arg));
 511             }
 512           if (current_arg != 0)
 513             arg_shifter.consume_arg ();
 514         }
 515       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-UseSeparateDispatchingORB")) == 0)
 516         {
 517           current_arg = arg_shifter.get_the_parameter
 518                               (ACE_TEXT("-UseSeparateDispatchingORB"));
 519           if (current_arg != 0 &&
 520               (ACE_OS::strcmp(ACE_TEXT ("0"), current_arg) == 0 ||
 521                ACE_OS::strcmp(ACE_TEXT ("1"), current_arg) == 0))
 522             {
 523               if (TAO_debug_level > 0)
 524                 {
 525                   ORBSVCS_DEBUG ((LM_DEBUG,
 526                               ACE_TEXT ("Using separate dispatching ORB\n")));
 527                 }
 528               this->separate_dispatching_orb_ =
 529                             static_cast<bool> (ACE_OS::atoi(current_arg));
 530             }
 531           else
 532             {
 533               if (TAO_debug_level > 0)
 534                 {
 535                   ORBSVCS_DEBUG ((LM_DEBUG,
 536                               ACE_TEXT ("WARNING: Unrecognized ")
 537                               ACE_TEXT ("argument (%s) to ")
 538                               ACE_TEXT ("-UseSeparateDispatchingORB.\n"),
 539                               (current_arg == 0 ? ACE_TEXT ("''") : current_arg)));
 540                 }
 541             }
 542           if (current_arg != 0)
 543             arg_shifter.consume_arg ();
 544         }
 545       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Boot")) == 0)
 546         {
 547           this->bootstrap_ = true;
 548           // Make it bootstrappable
 549
 550           arg_shifter.consume_arg ();
 551         }
 552       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-NameSvc")) == 0)
 553         {
 554           this->use_name_svc_ = true;
 555           // Register ref with the name service
 556
 557           arg_shifter.consume_arg ();
 558         }
 559       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-NoNameSvc")) == 0)
 560         {
 561           this->use_name_svc_ = false;
 562           // Don't Register ref with the name service
 563
 564           arg_shifter.consume_arg ();
 565         }
 566       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-IORoutput"))))
 567         {
 568           this->ior_output_file_name_ = current_arg;
 569           arg_shifter.consume_arg ();
 570         }
 571       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-ChannelName"))))
 572         {
 573           this->notify_channel_name_.insert(ACE_CString(ACE_TEXT_ALWAYS_CHAR(current_arg)));
 574           arg_shifter.consume_arg ();
 575         }
 576       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Channel")) == 0)
 577         {
 578           this->register_event_channel_ = true;
 579           // Register one EC with naming.
 580
 581           arg_shifter.consume_arg ();
 582         }
 583       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Notify_TPReactor"))))
 584         {
 585           if (TAO_debug_level > 0)
 586             {
 587               ORBSVCS_DEBUG((LM_DEBUG,
 588                          ACE_TEXT ("-Notify_TPReactor option is deprecated, ")
 589                          ACE_TEXT ("use -RunThreads option\n")));
 590             }
 591
 592           this->nthreads_ = ACE_OS::atoi (current_arg);
 593           arg_shifter.consume_arg ();
 594         }
 595       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-RunThreads"))))
 596         {
 597           this->nthreads_ = ACE_OS::atoi (current_arg);
 598           arg_shifter.consume_arg ();
 599         }
 600       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Timeout"))))
 601         {
 602 #if defined (TAO_HAS_CORBA_MESSAGING) && TAO_HAS_CORBA_MESSAGING != 0
 603           this->timeout_ = ACE_OS::atoi (current_arg);
 604           arg_shifter.consume_arg ();
 605 #else
 606           if (TAO_debug_level > 0)
 607             {
 608               ORBSVCS_DEBUG((LM_DEBUG,
 609                          ACE_TEXT ("WARNING: CORBA Messaging has been disabled.")
 610                          ACE_TExT ("The timeout will not be applied.\n")));
 611             }
 612 #endif /* TAO_HAS_CORBA_MESSAGING != 0 */
 613         }
 614       else if ((current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-LoggingInterval"))))
 615         {
 616           this->logging_interval_ = ACE_Time_Value (ACE_OS::atoi (current_arg));
 617           arg_shifter.consume_arg ();
 618         }
 619       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-?")) == 0)
 620         {
 621           ORBSVCS_DEBUG((LM_DEBUG,
 622                      ACE_TEXT ("usage: %s -Factory factory_name ")
 623                      ACE_TEXT ("-Boot -[No]NameSvc ")
 624                      ACE_TEXT ("-IORoutput file_name ")
 625                      ACE_TEXT ("-Channel -ChannelName channel_name ")
 626                      ACE_TEXT ("-RunThreads threads ")
 627                      ACE_TEXT ("-Timeout <msec>\n")
 628                      ACE_TEXT ("-ShutdownORB 1|0")
 629                      ACE_TEXT ("-ShutdownDispatchingORB 1|0")
 630                      ACE_TEXT ("default: %s -Factory NotifyEventChannelFactory ")
 631                      ACE_TEXT ("-NameSvc -Channel NotifyEventChannel -ORBRunThreads 1\n"),
 632                      argv[0], argv[0]));
 633
 634           arg_shifter.consume_arg ();
 635
 636           return -1;
 637         }
 638       else
 639         {
 640           arg_shifter.ignore_arg ();
 641         }
 642     }
 643   return 0;
 644 }
 645
 646 /*****************************************************************/
 647 LoggingWorker::LoggingWorker(TAO_Notify_Service_Driver* ns)
 648 : ns_ (ns),
 649   started_ (false),
 650   timer_id_ (-1)
 651 {
 652 }
 653
 654 void
 655 LoggingWorker::start ()
 656 {
 657   ACE_Logging_Strategy* logging_strategy =
 658     ACE_Dynamic_Service<ACE_Logging_Strategy>::instance ("Logging_Strategy");
 659   if (logging_strategy == 0)
 660     {
 661       ORBSVCS_ERROR ((LM_ERROR, ACE_TEXT ("(%P|%t) logging_strategy == 0\n")));
 662     }
 663   else
 664     {
 665       if (this->activate (THR_NEW_LWP | THR_JOINABLE, 1) == -1)
 666         {
 667           if (TAO_debug_level > 0)
 668             {
 669               ORBSVCS_ERROR ((LM_ERROR,
 670                          ACE_TEXT ("(%P|%t) Can not activate the ")
 671                          ACE_TEXT ("logging event thread\n")));
 672             }
 673         }
 674       else {
 675         if (this->ns_->logging_interval_ > ACE_Time_Value::zero)
 676         {
 677           timer_id_ = this->ns_->orb_->orb_core()->reactor()->
 678               schedule_timer (logging_strategy, 0, this->ns_->logging_interval_,
 679                               this->ns_->logging_interval_);
 680           if (timer_id_ == -1)
 681             {
 682               ORBSVCS_ERROR ((LM_ERROR,
 683                           ACE_TEXT("(%P|%t) Failed to schedule ")
 684                           ACE_TEXT("logging switch timer\n")));
 685             }
 686         }
 687       }
 688     }
 689 }
 690
 691 int
 692 LoggingWorker::svc (void)
 693 {
 694   if (TAO_debug_level > 0)
 695     {
 696       ORBSVCS_DEBUG ((LM_DEBUG,
 697                   ACE_TEXT ("(%P|%t) Running logging reactor \n")));
 698     }
 699   started_ = true;
 700   this->logging_reactor_.run_event_loop();
 701
 702   return 0;
 703 }
 704
 705 void
 706 LoggingWorker::end ()
 707 {
 708   if (started_)
 709   {
 710     this->logging_reactor_.end_event_loop();
 711     this->wait ();
 712   }
 713
 714   if (timer_id_ != -1)
 715     {
 716       this->ns_->orb_->orb_core()->reactor()->
 717         cancel_timer (timer_id_);
 718       timer_id_ = -1;
 719     }
 720 }
 721
 722 Worker::Worker (void)
 723 {
 724 }
 725
 726 void
 727 Worker::orb (CORBA::ORB_ptr orb)
 728 {
 729   orb_ = CORBA::ORB::_duplicate (orb);
 730 }
 731
 732 int
 733 Worker::svc (void)
 734 {
 735 #if 0
 736   // ACE_Thread::getprio() fails on systems that do not support thread
 737   // priorities.  While we could just treat the failure as benign, I'm
 738   // just disabling it altogether.  It doesn't provide much value, and
 739   // makes service startup needlessly more verbose.  See bugzilla 2477
 740   // for details.
 741
 742   ACE_hthread_t current;
 743   ACE_Thread::self (current);
 744
 745   int priority;
 746   if (ACE_Thread::getprio (current, priority) == -1)
 747     {
 748       if (TAO_debug_level > 0)
 749         {
 750           ORBSVCS_ERROR ((LM_ERROR,
 751                       ACE_TEXT ("TAO (%P|%t) - Failed to get ")
 752                       ACE_TEXT ("Worker thread priority\n")));
 753         }
 754       return -1;
 755     }
 756
 757   if (TAO_debug_level > 0)
 758     {
 759       ORBSVCS_DEBUG ((LM_DEBUG,
 760                   ACE_TEXT ("Activated Worker Thread to run ")
 761                   ACE_TEXT ("the ORB @ priority:%d\n", priority));
 762     }
 763 #endif
 764
 765   try
 766     {
 767       if (!CORBA::is_nil (this->orb_.in ()))
 768         {
 769           this->orb_->run ();
 770         }
 771     }
 772   catch (const CORBA::Exception&)
 773     {
 774     }
 775   return 0;
 776 }
 777
 778 ACE_STATIC_SVC_DEFINE (TAO_Notify_Service_Driver,
 779                        ACE_TEXT ("TAO_Notify_Service_Driver"),
 780                        ACE_SVC_OBJ_T,
 781                        &ACE_SVC_NAME (TAO_Notify_Service_Driver),
 782                        ACE_Service_Type::DELETE_THIS | ACE_Service_Type::DELETE_OBJ,
 783                        0)
 784
 785
 786 ACE_FACTORY_DEFINE (TAO_Notify_Service, TAO_Notify_Service_Driver)
 787
 788
 789 #if defined (TAO_HAS_NOTIFICATION_MONITOR_CONTROL) && defined (TAO_AS_STATIC_LIBS)
 790 ACE_STATIC_SVC_REQUIRE(TAO_MC_Notify_Service)
 791 ACE_STATIC_SVC_REQUIRE(TAO_MonitorAndControl)
 792 #endif
 793
 794
 795 #if defined (TAO_AS_STATIC_LIBS)
 796 ACE_STATIC_SVC_REQUIRE(ACE_Logging_Strategy)
 797 #endif
 798