TAO/orbsvcs/Scheduling_Service/Scheduling_Service.cpp

   1 #include "Scheduling_Service.h"
   2
   3 #include "ace/Get_Opt.h"
   4 #include <memory>
   5 #include "ace/Argv_Type_Converter.h"
   6 #include "orbsvcs/CosNamingC.h"
   7 #include "ace/OS_main.h"
   8 #include "ace/OS_NS_stdio.h"
   9 #include "ace/OS_NS_strings.h"
  10 #include "ace/OS_NS_unistd.h"
  11
  12 TAO_Scheduling_Service::TAO_Scheduling_Service ()
  13   : scheduler_impl_ (0),
  14     service_name_ ("ScheduleService"),
  15     scheduler_type_ (CONFIG)
  16 {
  17 }
  18
  19 // Constructor taking the command-line arguments.
  20 TAO_Scheduling_Service::TAO_Scheduling_Service (int argc, ACE_TCHAR* argv[])
  21   : scheduler_impl_ (0),
  22     service_name_ ("ScheduleService"),
  23     scheduler_type_ (CONFIG)
  24 {
  25   this->init (argc, argv);
  26 }
  27
  28 TAO_Scheduling_Service::~TAO_Scheduling_Service ()
  29 {
  30 }
  31
  32 // Initialize the Scheduling Service with the arguments.
  33 int
  34 TAO_Scheduling_Service::init (int argc, ACE_TCHAR* argv[])
  35 {
  36   int result;
  37   CORBA::ORB_var orb;
  38   PortableServer::POAManager_ptr poa_manager;
  39
  40   try
  41     {
  42       // Copy command line parameter.
  43       ACE_Argv_Type_Converter command_line(argc, argv);
  44
  45       // Initialize ORB manager.
  46       this->orb_manager_.init (command_line.get_argc(), command_line.get_TCHAR_argv());
  47
  48       orb = this->orb_manager_.orb ();
  49
  50       poa_manager = this->orb_manager_.poa_manager ();
  51
  52       poa_manager->activate ();
  53
  54       // Check the non-ORB arguments.  this needs to come before we
  55       // initialize the scheduler implementation so that we know which
  56       // type of scheduler to use.
  57
  58       result = this->parse_args (command_line.get_argc(), command_line.get_TCHAR_argv());
  59       if (result < 0)
  60         return result;
  61
  62       // Construct a scheduler implementation of the specified type.
  63       switch (this->scheduler_type_)
  64         {
  65           case RECONFIG:
  66             ACE_NEW_THROW_EX (scheduler_impl_,
  67                               RECONFIG_SCHED_TYPE,
  68                               CORBA::NO_MEMORY ());
  69             break;
  70
  71           case CONFIG:
  72             ACE_NEW_THROW_EX (scheduler_impl_,
  73                               CONFIG_SCHED_TYPE,
  74                               CORBA::NO_MEMORY ());
  75             break;
  76
  77           default:
  78             ORBSVCS_ERROR_RETURN ((LM_ERROR,
  79                                "TAO_Scheduling_Service::init: "
  80                                "unrecognized Scheduler_Type"), -1);
  81         }
  82
  83       // Locate the naming service.
  84       CORBA::Object_var naming_obj =
  85         orb->resolve_initial_references ("NameService");
  86
  87       if (CORBA::is_nil (naming_obj.in ()))
  88         ORBSVCS_ERROR_RETURN ((LM_ERROR,
  89                            " (%P|%t) Unable to locate the Naming Service.\n"),
  90                           -1);
  91       CosNaming::NamingContext_var naming_context =
  92         CosNaming::NamingContext::_narrow (naming_obj.in ());
  93
  94       RtecScheduler::Scheduler_var scheduler =
  95         this->scheduler_impl_->_this ();
  96
  97       CORBA::String_var scheduler_ior_string =
  98         orb->object_to_string (scheduler.in ());
  99
 100       ORBSVCS_DEBUG ((LM_DEBUG, ACE_TEXT("The scheduler IOR is <%C>\n"),
 101                             scheduler_ior_string.in ()));
 102
 103       // Register the servant with the Naming Context....
 104       CosNaming::Name schedule_name (1);
 105       schedule_name.length (1);
 106       schedule_name[0].id = CORBA::string_dup (this->service_name_.rep());
 107       naming_context->rebind (schedule_name, scheduler.in ());
 108
 109       if (this->ior_file_name_.rep() != 0)
 110         {
 111           FILE *iorf = ACE_OS::fopen (this->ior_file_name_.rep(), "w");
 112           if (iorf != 0)
 113             {
 114               ACE_OS::fprintf (iorf,
 115                                "%s\n",
 116                                scheduler_ior_string.in ());
 117               ACE_OS::fclose (iorf);
 118             }
 119         }
 120
 121       if (this->pid_file_name_.rep() != 0)
 122         {
 123           FILE *pidf = ACE_OS::fopen (this->pid_file_name_.rep(), "w");
 124           if (pidf != 0)
 125             {
 126               ACE_OS::fprintf (pidf,
 127                                ACE_TEXT("%ld\n"),
 128                                static_cast<long> (ACE_OS::getpid ()));
 129               ACE_OS::fclose (pidf);
 130             }
 131         }
 132     }
 133   catch (const CORBA::Exception& ex)
 134     {
 135       ex._tao_print_exception ("TAO_Scheduling_Service::init");
 136       return -1;
 137     }
 138
 139   return 0;
 140 }
 141
 142
 143 // Runs the TAO_Scheduling_Service.
 144
 145 int
 146 TAO_Scheduling_Service::run ()
 147 {
 148   // Run the ORB manager.
 149   return this->orb_manager_.run ();
 150 }
 151
 152
 153 // Parses the command line arguments.
 154
 155 int
 156 TAO_Scheduling_Service::parse_args (int argc, ACE_TCHAR* argv[])
 157 {
 158   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("n:p:o:s:"));
 159   int opt;
 160
 161   while ((opt = get_opt ()) != EOF)
 162     {
 163       switch (opt)
 164         {
 165         case 'n':
 166           this->service_name_ = ACE_TEXT_ALWAYS_CHAR(get_opt.opt_arg ());
 167           break;
 168
 169         case 'p':
 170           this->pid_file_name_ = ACE_TEXT_ALWAYS_CHAR(get_opt.opt_arg ());
 171           break;
 172
 173         case 'o':
 174           this->ior_file_name_ = ACE_TEXT_ALWAYS_CHAR(get_opt.opt_arg ());
 175           break;
 176
 177         case 's':
 178           if (ACE_OS::strcasecmp (ACE_TEXT("CONFIG"), get_opt.optarg) == 0)
 179             {
 180               this->scheduler_type_ = CONFIG;
 181             }
 182           else if (ACE_OS::strcasecmp (ACE_TEXT("RECONFIG"), get_opt.optarg) == 0)
 183             {
 184               this->scheduler_type_ = RECONFIG;
 185             }
 186           else
 187             {
 188               ORBSVCS_DEBUG ((LM_DEBUG,
 189                           "Usage: %s "
 190                           "[-n service_name] "
 191                           "[-p pid_file_name] "
 192                           "[-o ior_file_name] "
 193                           "[-s <CONFIG | reconfig>]"
 194                           "\n",
 195                           argv[0]));
 196
 197               return -1;
 198             }
 199           break;
 200
 201         case '?':
 202         default:
 203
 204           ORBSVCS_DEBUG ((LM_DEBUG,
 205                       "Usage: %s "
 206                       "[-n service_name] "
 207                       "[-p pid_file_name] "
 208                       "[-o ior_file_name] "
 209                       "[-s <CONFIG | reconfig>]"
 210                       "\n",
 211                       argv[0]));
 212
 213           return -1;
 214         }
 215     }
 216
 217   return 0;
 218 }
 219
 220 int ACE_TMAIN (int argc, ACE_TCHAR* argv[])
 221 {
 222   try
 223     {
 224       TAO_Scheduling_Service scheduling_service;
 225
 226       ORBSVCS_DEBUG ((LM_DEBUG,
 227                   "%s; initializing scheduling service\n", __FILE__));
 228
 229       if (scheduling_service.init (argc, argv) < 0)
 230         ORBSVCS_ERROR_RETURN ((LM_ERROR, "%p\n", "init"), 1);
 231
 232       ORBSVCS_DEBUG ((LM_DEBUG,
 233                   "%s; running scheduling service\n", __FILE__));
 234
 235       scheduling_service.run ();
 236     }
 237   catch (const CORBA::Exception& ex)
 238     {
 239       ex._tao_print_exception ("schedule_service");
 240           return 1;
 241     }
 242
 243   return 0;
 244 }