TAO/orbsvcs/FT_Naming_Service/FT_Naming_Service.cpp

   1 #include "FT_Naming_Service.h"
   2 #include "orbsvcs/Naming/FaultTolerant/FT_Naming_Server.h"
   3 #include "orbsvcs/Naming/Persistent_Naming_Context_Factory.h"
   4 #include "orbsvcs/Daemon_Utilities.h"
   5 #include "orbsvcs/Log_Macros.h"
   6
   7 #include "ace/Get_Opt.h"
   8 #include "ace/Argv_Type_Converter.h"
   9 #include "ace/Task.h"
  10
  11 // Default Constructor.
  12 TAO_FT_Naming_Service::TAO_FT_Naming_Service (void)
  13   : time_ (0),
  14     num_threads_ (1)
  15 {
  16 }
  17
  18 // Constructor taking command-line arguments.
  19 TAO_FT_Naming_Service::TAO_FT_Naming_Service (int argc, ACE_TCHAR* argv[])
  20   : time_ (0),
  21     num_threads_ (1)
  22 {
  23   this->init (argc, argv);
  24 }
  25
  26
  27 // Initialize the state of the TAO_FT_Naming_Service object
  28 int
  29 TAO_FT_Naming_Service::init (int argc, ACE_TCHAR* argv[])
  30 {
  31   try
  32     {
  33       // Check if -ORBDaemon is specified and if so, daemonize at this moment,
  34       // -ORBDaemon in the ORB core is faulty, see bugzilla 3335
  35       TAO_Daemon_Utility::check_for_daemon (argc, argv);
  36
  37       // Initialize the ORB
  38       this->orb_ = CORBA::ORB_init (argc, argv);
  39
  40       // Parse the args for '-t' option. If '-t' option is passed, do
  41       // the needful and then remove the option from the list of
  42       // arguments.
  43       this->parse_args (argc, argv);
  44
  45       // This function call initializes the naming service and returns
  46       // '-1' in case of an exception.
  47       int const result = this->my_naming_server_.init_with_orb (argc,
  48                                                                 argv,
  49                                                                 this->orb_.in ());
  50
  51       if (result == -1)
  52         return result;
  53
  54     }
  55   catch (const CORBA::Exception& ex)
  56     {
  57       ex._tao_print_exception ("TAO_FT_Naming_Service::init");
  58       return -1;
  59     }
  60
  61   return 0;
  62 }
  63
  64 int
  65 TAO_FT_Naming_Service::parse_args (int &argc, ACE_TCHAR* argv[])
  66 {
  67   ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("-t:n:"));
  68   int c;
  69
  70   while ((c = get_opts ()) != -1)
  71     {
  72       switch (c)
  73         {
  74         case 't':
  75           {
  76             int const time = ACE_OS::atoi (get_opts.opt_arg ());
  77             if (time >= 0)
  78               this->time_ = time;
  79
  80             // Remove the option '-t' from argv []
  81             // to avoid any confusion that might result.
  82             for (int i = get_opts.opt_ind (); i != argc; ++i)
  83               argv [i-2 ] = argv [i];
  84
  85             // Decrement the value of argc to reflect the removal
  86             // of '-t' option.
  87             argc = argc - 2;
  88             break;
  89           }
  90         case 'n':
  91           {
  92             int const nt = ACE_OS::atoi (get_opts.opt_arg ());
  93             if (nt >= 1)
  94               this->num_threads_ = nt;
  95
  96             // Remove the option '-n' from argv []
  97             // to avoid any confusion that might result.
  98             for (int i = get_opts.opt_ind (); i != argc; ++i)
  99               argv [i-2 ] = argv [i];
 100
 101             // Decrement the value of argc to reflect the removal
 102             // of '-n' option.
 103             argc = argc - 2;
 104             break;
 105           }
 106
 107         case '?':
 108         default:
 109           // Don't do anything. The TAO_Naming_Server::parse_args ()
 110           // takes care of indicating an error in case of error.
 111           break;
 112         }
 113     }
 114   return 0;
 115 }
 116
 117 // Run the ORB event loop.
 118
 119 class ORB_Runner : public ACE_Task_Base
 120 {
 121 public:
 122   ORB_Runner (CORBA::ORB_ptr o, long t)
 123     : orb_(CORBA::ORB::_duplicate (o)),
 124       time_(t)
 125   {}
 126
 127   int svc (void)
 128   {
 129   if (!CORBA::is_nil (orb_.in ()))
 130     {
 131       if (time_ == 0)
 132         {
 133           this->orb_->run ();
 134         }
 135       else
 136         {
 137           ACE_Time_Value tv (time_);
 138           this->orb_->run (tv);
 139         }
 140     }
 141
 142   return 0;
 143   }
 144
 145 private:
 146   CORBA::ORB_var orb_;
 147   long time_;
 148 };
 149
 150 int
 151 TAO_FT_Naming_Service::run (void)
 152 {
 153   ORB_Runner runner (this->orb_.in(), time_);
 154   if (this->num_threads_ == 1)
 155     return runner.svc();
 156   else
 157     {
 158       int grpid = runner.activate ( THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED,
 159                                     this->num_threads_);
 160       if (grpid == -1)
 161         {
 162           ORBSVCS_ERROR ((LM_ERROR,
 163                           ACE_TEXT ("FT_Naming_Service(%P)::run %p\n"),
 164                           ACE_TEXT ("thread acitvation")));
 165           return -1;
 166         }
 167       runner.wait();
 168     }
 169   return 0;
 170 }
 171
 172 void
 173 TAO_FT_Naming_Service::shutdown (void)
 174 {
 175   if (!CORBA::is_nil (orb_.in ()))
 176     {
 177       this->orb_->shutdown (0);
 178     }
 179 }
 180
 181 int
 182 TAO_FT_Naming_Service::fini (void)
 183 {
 184   this->my_naming_server_.fini();
 185
 186   try
 187   {
 188     // destroy implies shutdown
 189     if (!CORBA::is_nil (orb_.in ()))
 190       {
 191         this->orb_->destroy ();
 192       }
 193   }
 194   catch (const CORBA::Exception& ex)
 195   {
 196     ex._tao_print_exception ("TAO_FT_Naming_Service::fini");
 197     return -1;
 198   }
 199   return 0;
 200 }
 201
 202 // Destructor.
 203 TAO_FT_Naming_Service::~TAO_FT_Naming_Service (void)
 204 {
 205 }