TAO/orbsvcs/ImplRepo_Service/tao_imr_i.h

   1 /* -*- C++ -*- */
   2
   3 //=============================================================================
   4 /**
   5  *  @file    tao_imr_i.h
   6  *
   7  *  This class implements the Implementation Repository helper application.
   8  *
   9  *  @author Darrell Brunsch <brunsch@cs.wustl.edu>
  10  */
  11 //=============================================================================
  12 #ifndef TAO_IMR_I_H
  13 #define TAO_IMR_I_H
  14
  15 #include "tao/ImR_Client/ImplRepoC.h"
  16 #include "tao/corba.h"
  17 #include "ace/SString.h"
  18 #include "ace/Auto_Ptr.h"
  19
  20 // Forward Declaration
  21 class TAO_IMR_Op;
  22
  23 /**
  24  * @class TAO_IMR_i
  25  *
  26  * @brief TAO's command line helper application
  27  *
  28  * This class talks to the IMR and registers/lists/etc.
  29  */
  30 class TAO_IMR_i
  31 {
  32 public:
  33
  34   // = Constructor and destructor.
  35   TAO_IMR_i (void);
  36   ~TAO_IMR_i (void);
  37
  38   /// Execute client code.
  39   int run (void);
  40
  41   /// Initialize the client communication endpoint with server.
  42   int init (int argc, ACE_TCHAR **argv);
  43
  44 private:
  45   /// Print out information about all operations.
  46   void print_usage (void);
  47
  48   /// Parses the arguments passed on the command line.
  49   int parse_args (void);
  50
  51   /// # of arguments on the command line.
  52   int argc_;
  53
  54   /// Arguments from command line.
  55   ACE_TCHAR **argv_;
  56
  57   /// Remember our orb.
  58   CORBA::ORB_var orb_;
  59
  60   /// Reference to our Locator interface of
  61   /// implementation repository.
  62   ImplementationRepository::Administration_var imr_;
  63
  64   /// What we need to do.
  65   ACE_Auto_Ptr<TAO_IMR_Op> op_;
  66 };
  67
  68
  69 /**
  70  * @class TAO_IMR_Op
  71  *
  72  * @brief IMR Operation Base Class
  73  *
  74  * Provides a base class with virtual methods for each operation strategy.
  75  */
  76 class TAO_IMR_Op
  77 {
  78 public:
  79   enum RETURN_CODES {
  80     NORMAL = 0,
  81     UNKNOWN,
  82     NO_PERMISSION,
  83     ALREADY_REGISTERED,
  84     CANNOT_ACTIVATE,
  85     NOT_FOUND,
  86     CANNOT_COMPLETE
  87   };
  88
  89   /// Factory.
  90   static TAO_IMR_Op *make_op (const ACE_TCHAR *op_name);
  91
  92   /// Destructor.
  93   virtual ~TAO_IMR_Op (void);
  94
  95   /// Parse arguments.
  96   virtual int parse (int argc, ACE_TCHAR **argv) = 0;
  97
  98   /// Do the work.
  99   virtual int run (void) = 0;
 100
 101   /// Sets the implrepo locator pointer
 102   void set_imr (ImplementationRepository::Administration_ptr imr);
 103
 104 protected:
 105   TAO_IMR_Op (void) : imr_ (0), quiet_ (false) {}
 106
 107   // = Helper methods
 108
 109   /// Prints out the information contained in a ServerInformation structure.
 110   void display_server_information (const ImplementationRepository::ServerInformation &info);
 111
 112   /// Reference to our implementation repository.
 113   ImplementationRepository::Administration_ptr imr_;
 114   bool quiet_;
 115 };
 116
 117
 118 /**
 119  * @class TAO_IMR_Op_Activate
 120  *
 121  * @brief Activation Operation
 122  *
 123  * Activation is used to start servers via the Implementation Repository
 124  */
 125 class TAO_IMR_Op_Activate : public TAO_IMR_Op
 126 {
 127 public:
 128   virtual int parse (int argc, ACE_TCHAR **argv);
 129   virtual int run (void);
 130
 131 protected:
 132   /// Prints a message about the usage
 133   void print_usage (void);
 134
 135   /// POA server name.
 136   ACE_CString server_name_;
 137 };
 138
 139 /**
 140  * @class TAO_IMR_Op_Autostart
 141  *
 142  * @brief Autostart Operation
 143  *
 144  * Autostart is used to activate all servers with the AUTO_START activation
 145  * mode.
 146  */
 147 class TAO_IMR_Op_Autostart : public TAO_IMR_Op
 148 {
 149 public:
 150   virtual int parse (int argc, ACE_TCHAR **argv);
 151   virtual int run (void);
 152
 153 protected:
 154   /// Prints a message about the usage
 155   void print_usage (void);
 156 };
 157
 158
 159 /**
 160  * @class TAO_IMR_Op_IOR
 161  *
 162  * @brief IOR Operation
 163  *
 164  * IOR is used to create a simple IOR for a server that uses the
 165  * IMR and the Interoperable Naming Service.
 166  */
 167 class TAO_IMR_Op_IOR : public TAO_IMR_Op
 168 {
 169 public:
 170   virtual int parse (int argc, ACE_TCHAR **argv);
 171   virtual int run (void);
 172
 173 protected:
 174   /// Prints a message about the usage
 175   void print_usage (void);
 176
 177   /// POA server name.
 178   ACE_CString server_name_;
 179
 180   /// Filename to output to.
 181   ACE_TString filename_;
 182 };
 183
 184
 185 /**
 186  * @class TAO_IMR_Op_Kill
 187  *
 188  * @brief Kill Operation
 189  *
 190  * Kill is used to unregister a server in the IMR.
 191  */
 192 class TAO_IMR_Op_Kill : public TAO_IMR_Op
 193 {
 194 public:
 195   virtual int parse (int argc, ACE_TCHAR **argv);
 196   virtual int run (void);
 197
 198 protected:
 199   /// Prints a message about the usage
 200   void print_usage (void);
 201
 202   ACE_CString server_name_;
 203   int signum_;
 204 };
 205
 206
 207 /**
 208  * @class TAO_IMR_Op_Link
 209  *
 210  * @brief Link Operation
 211  *
 212  * Link is used to unregister a server in the IMR.
 213  */
 214 class TAO_IMR_Op_Link : public TAO_IMR_Op
 215 {
 216 public:
 217   virtual int parse (int argc, ACE_TCHAR **argv);
 218   virtual int run (void);
 219
 220 protected:
 221   /// Prints a message about the usage
 222   void print_usage (void);
 223
 224   ACE_CString server_name_;
 225
 226   CORBA::StringSeq peers_;
 227 };
 228
 229
 230
 231 /**
 232  * @class TAO_IMR_Op_List
 233  *
 234  * @brief List Operation
 235  *
 236  * List is used to either list all the servers registered in the IMR or just
 237  * look at one of them.
 238  */
 239 class TAO_IMR_Op_List : public TAO_IMR_Op
 240 {
 241 public:
 242   TAO_IMR_Op_List (void);
 243
 244   virtual int parse (int argc, ACE_TCHAR **argv);
 245   virtual int run (void);
 246
 247 protected:
 248   /// Prints a message about the usage
 249   void print_usage (void);
 250
 251   /// POA server name.
 252   ACE_CString server_name_;
 253
 254   /// If true, more server information is displayed.
 255   int verbose_server_information_;
 256
 257   /// If true, only show servers that are currently active.
 258   int list_only_active_servers_;
 259
 260   /// retrieve no more than this number of entries at a time
 261   CORBA::ULong how_many_;
 262
 263   /// If true, use minimum formatting.
 264   int terse_;
 265
 266   /// Prints out the information contained in a ServerInformation structure.
 267   /// Specialized to only print server information
 268   void display_server_information (const ImplementationRepository::ServerInformation &info);
 269 };
 270
 271
 272 /**
 273  * @class TAO_IMR_Op_Remove
 274  *
 275  * @brief Remove Operation
 276  *
 277  * Remove is used to unregister a server in the IMR.
 278  */
 279 class TAO_IMR_Op_Remove : public TAO_IMR_Op
 280 {
 281 public:
 282   virtual int parse (int argc, ACE_TCHAR **argv);
 283   virtual int run (void);
 284
 285 protected:
 286   /// Prints a message about the usage
 287   void print_usage (void);
 288
 289   ACE_CString server_name_;
 290   bool force_;
 291   int signum_;
 292 };
 293
 294
 295 /**
 296  * @class TAO_IMR_Op_Shutdown
 297  *
 298  * @brief Shutdown Operation
 299  *
 300  * Shutdown is used to shutdown a server through the IMR.
 301  */
 302 class TAO_IMR_Op_Shutdown : public TAO_IMR_Op
 303 {
 304 public:
 305   virtual int parse (int argc, ACE_TCHAR **argv);
 306   virtual int run (void);
 307
 308 protected:
 309   /// Prints a message about the usage
 310   void print_usage (void);
 311
 312   ACE_CString server_name_;
 313 };
 314
 315 /**
 316  * Shutdown the ImR and optionally any registered activators.
 317  */
 318 class TAO_IMR_Op_ShutdownRepo : public TAO_IMR_Op
 319 {
 320 public:
 321   TAO_IMR_Op_ShutdownRepo();
 322   virtual int parse (int argc, ACE_TCHAR **argv);
 323   virtual int run (void);
 324
 325 protected:
 326   void print_usage (void);
 327
 328   bool activators_;
 329 };
 330
 331 /**
 332  * @class TAO_IMR_Op_Register
 333  *
 334  * @brief Register Operation
 335  *
 336  * Register is used to update/add information for a server
 337  * with the IMR.
 338  */
 339 class TAO_IMR_Op_Register : public TAO_IMR_Op
 340 {
 341 public:
 342   TAO_IMR_Op_Register(bool is_add);
 343
 344   virtual int parse (int argc, ACE_TCHAR **argv);
 345   virtual int run (void);
 346
 347 protected:
 348
 349   /// Enables pre-registration checks
 350   bool is_add_;
 351
 352   /// Sets one environment variable.
 353   void addenv (ACE_TCHAR *opt);
 354
 355   /// Prints a message about the usage.
 356   void print_usage (void);
 357
 358   /// POA server name.
 359   ACE_CString server_name_;
 360
 361   bool set_command_line_;
 362   ACE_CString command_line_;
 363
 364   bool set_environment_vars_;
 365   ImplementationRepository::EnvironmentList environment_vars_;
 366
 367   bool set_working_dir_;
 368   ACE_CString working_dir_;
 369
 370   bool set_activation_;
 371   ImplementationRepository::ActivationMode activation_;
 372
 373   bool set_retry_count_;
 374   int retry_count_;
 375
 376   bool set_activator_;
 377   ACE_CString activator_;
 378 };
 379
 380 #endif /* TAO_IMR_I_H */