BoilerPlate: Reusable CORBA

CorbaServer.h

Go to the documentation of this file.

#ifndef _ORBINIT_GUARD
#define _ORBINIT_GUARD

#include <string> 
#include <exception>
#include <stdexcept>
#include <vector>
#include <map>

#include "BP_CORBA.h"
#include "BPExceptions.h"
#include "SysHook.h"
#include "SignalController.h"
#include "InitCommand.h"
#include "ServantFactory.h"
#include "OrbRunStrategy.h"

//#include "CommandLine.h"

#define _ORBINIT_CMDLINE_OPTIONS_PFX      "-BP"


class OrbInit : public virtual SysHook
{
   public:
      class InitializationError: public std::exception
      {
         public:
            InitializationError(std::string theMsg): msg(theMsg) {};

            InitializationError(const InitializationError& err); 
           
            virtual const char* what() const throw()
            {
               return(msg.c_str());
            };

            virtual ~InitializationError() throw() {};
         
         private:
            const std::string msg;
      };


      enum InitState
      {
         PRE_ORB_INIT,
         POST_ORB_INIT,
         POST_POA_INIT,
         RUNNING,
         SHUTTING_DOWN
      };
         

      OrbInit(int argc, char** argv);

      virtual ~OrbInit();


      void addServantFactory(ServantFactory* factory) 
         throw(BoilerPlate::IllegalStateException);

      void addPreORBInitCommand(PreInitCommand* command)
         throw(BoilerPlate::IllegalStateException);

      void addPostORBInitCommand(PostORBInitCommand* command)
         throw(BoilerPlate::IllegalStateException);

      void addPostPOAInitCommand(PostInitCommand* command)
         throw(BoilerPlate::IllegalStateException);

      void addPreShutdownCommand(PostInitCommand* command)
         throw(BoilerPlate::IllegalStateException);

      void setOrbRunStrategy(OrbRunStrategy* strategy)
         throw(BoilerPlate::IllegalStateException);

      void initialize(int argc, char** argv)
         throw(InitializationError); 


      void buildServants() 
         throw(InitializationError, 
               BoilerPlate::IllegalStateException,
               ServantFactory::ServantBuildException
               );

      void acceptMessages() 
         throw(CORBA::SystemException, std::runtime_error);

      virtual void shutDown() throw(CORBA::SystemException);

      virtual void run() throw(CORBA::SystemException);

      virtual void holdRequests(bool wait) 
         throw(PortableServer::POAManager::AdapterInactive);

      virtual void activate() 
         throw(PortableServer::POAManager::AdapterInactive);

      virtual void discardRequests(bool wait)
         throw(PortableServer::POAManager::AdapterInactive);


      SignalController& getSignalController()
      {
         return(*_sigcontroller);
      }

   private:
      void _initializeORB(int, char**)    throw(InitializationError);
      void _initializeRootPOA()           throw(InitializationError);
      void _buildServants() 
         throw(InitializationError, ServantFactory::ServantBuildException);

      void _initializeConfigMap(int, char**) 
         throw(InitializationError);    //gg

      void _runPreORBInitCommands()       throw(InitializationError);
      void _runPostORBInitCommands()      throw(InitializationError);
      void _runPostRootPOAInitCommands()  throw(InitializationError);
      void _runPostRunCommands()          throw(InitializationError);

      void _write_pid_file();


      CORBA::ORB_var _orb;
      PortableServer::POA_var _rootpoa;
      PortableServer::POAManager_var _manager;
      bool _hasBeenInitialized;
      std::vector<ServantFactory*> _factories;
      
      // Commands
      std::vector<PreInitCommand*> _preinitCommands;
      std::vector<PostORBInitCommand*> _postORBInitCommands;
      std::vector<PostInitCommand*> _postRootPOACommands;
      std::vector<PostInitCommand*> _postRunCommands;

      //gg
      ConfMap nsServantIdMap;
      //CCmdLine cmdLine;

      InitState _state;

      OrbRunStrategy *_runStrategy;
      SignalController *_sigcontroller;

};

#endif

---