maciContainerImpl.h

Go to the documentation of this file.

#ifndef maciContainerImpl_h
#define maciContainerImpl_h

/*******************************************************************************
* E.S.O. - ACS project
*
* "@(#) $Id: maciContainerImpl.h,v 1.68 2012/05/18 06:54:45 bjeram Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* bjeram 2003-10-27 template methods are supported on VxWorks too (since 2.96)
* msekoran 2003-09-12 ported to new maci DIL
* oat 2002-12-17 added get_object template method
* jib/blo 2002-04-02  get_object method added
* msekoran 2002-02-07 Added shutdown helpers.
* almamgr 2001-07-23 Added getManager() method
* almamgr 2001-07-19 Added forward class definitions for MACIServantManager and LibraryManager
* almamgr 2001-07-19 created
* msekoran  2001/05/19  redesigned
*/

#include <acsutil.h>
#include <maciExport.h>

#include <maciS.h>

#include <cdb.h>

#include <logging.h>

#include <AlarmSourceThread.h>

#include <ace/Synch.h>
#include <ace/Hash_Map_Manager.h>
#include <ace/Unbounded_Set.h>

#include <acsContainerServices.h>
#include "maciContainerThreadHook.h"
#ifndef MAKE_VXWORKS
#include "maciLogThrottleAlarmImpl.h"
#endif

#include <map>

#include <ace/Activation_Queue.h>
#include <ace/Method_Request.h>
#include <ace/Task.h>
#include <ace/Auto_Ptr.h>
#include <ACSErrTypeOK.h>

// #include <maciContainerServices.h> commented out: forward decl

#define CONTAINER_RELOAD 0

#define CONTAINER_REBOOT 1

#define CONTAINER_EXIT 2

namespace maci {


typedef PortableServer::Servant (*ConstructComponentFunc)(
                                                    maci::Handle h,
                                                    const char * name,
                                                    const char * type,
                            ContainerServices * containerServices
                                                    );

/*
 * Forward declarations
 */
class ContainerServices; // This is defined in maciContainerServics.h
class MACIServantManager;
class LibraryManager;

    
    
class MethodRequestThreadPool : public ACE_Task_Base, public Logging::Loggable
{
public:
    MethodRequestThreadPool (int n_threads = 1);
        
    virtual int svc (void);
        
    int enqueue (ACE_Method_Request *request);
        
    void shutdown();
        
private:
    ACE_Activation_Queue activation_queue_;

        int m_threads;
};

    
class maci_EXPORT ContainerImpl :
  public virtual POA_maci::Container,
  public virtual PortableServer::RefCountServantBase
{
public:

  static ContainerImpl * getContainer()
  {
    return m_container;
  }

  maci::Container_ptr getContainerCORBAProxy()
  {
    return m_container_ref.ptr();
  }

  static LoggingProxy * getLoggerProxy()
  {
    return m_loggerProxy;
  }

  char * getProcessName()
  {
    return m_argv[0];
  }

  ContainerImpl();

  virtual ~ContainerImpl();


  maci::Manager_ptr getManager();

  bool init(int argc, char *argv[]);
  bool connect();
  bool run();
  bool done();

  int getStatus() { return m_status; }
  void setStatus(int status) { m_status = status; }

  static void initThread(const char * threadName = 0);

  static void doneThread();

  void etherealizeComponent(const char * id, PortableServer::Servant servant);

  int getShutdownAction() { return m_shutdownAction; }

  void setShutdownAction(int action) { m_shutdownAction=action; }

  maci::Handle getHandle() { return m_handle; }

  PortableServer::POA_var getContainerPOA() { return poaContainer; }

  PortableServer::POAManager_var getPOAManager() { return poaManager; }

  ContainerServices* getContainerServices() { return m_containerServices; }

    CORBA::ORB_var getContainerORB() { return orb; }

  /* ----------------------------------------------------------------*/
  /* --------------------- [ CORBA interface ] ----------------------*/
  /* ----------------------------------------------------------------*/

  virtual ::maci::Handle get_handle ();

  virtual maci::ComponentInfo * activate_component (maci::Handle h,
                                        maci::ExecutionId execution_id,
                                        const char * name,
                                        const char * exe,
                                        const char * type
                                        );

  // TODO
  virtual void activate_component_async(maci::Handle, maci::ExecutionId, const char*, const char*, const char*, maci::CBComponentInfo*, const ACS::CBDescIn&);
  
  virtual void deactivate_component (maci::Handle h
                                      );

  virtual CORBA::Object_ptr restart_component (maci::Handle h
                                               );

  virtual void shutdown (CORBA::ULong action
                         );
        
  virtual maci::ComponentInfoSeq * get_component_info (const maci::HandleSeq & h
                                           );

  virtual char * name ();

  virtual void disconnect ();
        
  virtual maci::AuthenticationData * authenticate (maci::ExecutionId execution_id, const char * question
                               );
        
  virtual void message (CORBA::Short type,
                        const char * message
                        );

  virtual void taggedmessage (CORBA::Short type,
                        CORBA::Short tag,
                        const char * message
                        );

  virtual void components_available (const maci::ComponentInfoSeq & components
                               );

  virtual void components_unavailable (const maci::stringSeq & component_names
                                 );

  virtual void set_component_shutdown_order(const maci::HandleSeq & h
                                           );

  virtual CORBA::Object_ptr get_object(const char *name, 
                                       const char *domain,
                                       bool activate
                                       );

    template<class T>
    T* get_object(const char *name, const char *domain, bool activate)
        {
            return getComponent<T>(name, domain, activate);
        }

    template<class T>
    T* getComponent(const char *name, const char *domain, bool activate);

    template<class T>
    T* getService(const char *name, const char *domain, bool activate);

  void releaseComponent(const char *name);
    
  virtual CORBA::Boolean ping ();

    virtual Logging::LoggingConfigurable::LogLevels get_default_logLevels();

    virtual void set_default_logLevels(const Logging::LoggingConfigurable::LogLevels&);

    virtual Logging::stringSeq* get_logger_names();

    /*
    * @throw maciErrType::LoggerDoesNotExistEx
    */
    virtual Logging::LoggingConfigurable::LogLevels get_logLevels(const char*);

    /* 
    * @throw maciErrType::LoggerDoesNotExistEx
    */
    virtual void set_logLevels(const char*, const Logging::LoggingConfigurable::LogLevels&);

    virtual void refresh_logging_config();

    static void configureLogger(const std::string& loggerName);

    void loadLoggerConfiguration(const std::string& loggerName);

  protected:
    Logging::Logger::LoggerSmartPtr
    getLogger() {return m_logger;}
    
    
  private:
    
  int parseArgs (int argc, char *argv[]);

  void showUsage(int argc, char *argv[]);
  
   ContainerServices* instantiateContainerServices(
        maci::Handle h, 
        ACE_CString& name, 
        ACE_CString& type, 
        PortableServer::POA_ptr poa);

  const char * m_pid_file_name;

  const char * m_manager_ref;

  // Container name;
  const char * m_container_name;

  // static pointer to the container
  static ContainerImpl * m_container;

  static LibraryManager * m_dllmgr;

  static LoggingProxy * m_loggerProxy;

#ifndef MAKE_VXWORKS
  // It is used by the logging proxy to clear/raise alarms
  LogThrottleAlarmImpl* m_logThrottleAlarm_p;
#endif

  static int m_logLevelRefresh;
  static int m_logLevelConfigure;

  MACIServantManager * m_servant_mgr; 

  cdb::Table * m_database;

  // CORBA reference to the Container.
  maci::Container_var m_container_ref;

  //
  // CORBA vars
  //
  CORBA::ORB_var orb;
  PortableServer::POAManager_var poaManager;
  PortableServer::POA_var poaRoot;
  PortableServer::POA_var poaContainer;
  PortableServer::POA_var poaPersistent;
  PortableServer::POA_var poaTransient;

  static CORBA::ULong m_invocationTimeout;

  maci::Manager_var m_manager;

  maci::Handle m_handle;

  int m_status;

  bool m_shutdown;

  struct ContainerComponentInfo
  {
    int lib;            
    maci::ComponentInfo info;
  };
        
  typedef ACE_Hash_Map_Manager <maci::Handle, ContainerComponentInfo, ACE_Recursive_Thread_Mutex> COMPONENT_HASH_MAP;
  typedef ACE_Hash_Map_Iterator <maci::Handle, ContainerComponentInfo, ACE_Recursive_Thread_Mutex> COMPONENT_HASH_MAP_ITER;
  typedef ACE_Hash_Map_Entry <maci::Handle, ContainerComponentInfo> COMPONENT_HASH_MAP_ENTRY;

  COMPONENT_HASH_MAP m_activeComponents;

  // NOTE: Preserves FIFO order.
  typedef ACE_Unbounded_Set <maci::Handle> COMPONENT_LIST;

  COMPONENT_LIST m_activeComponentList;

  maci::HandleSeq m_componentShutdownOrder;

  bool initializeCORBA(int &argc, char *argv[]);

  bool doneCORBA();
  public:
  CORBA::Object_ptr activateCORBAObject(PortableServer::Servant srvnt,
                                        const char * name);
 
  bool deactivateCORBAObject(PortableServer::Servant servant);

  bool deactivateCORBAObject(CORBA::Object_ptr servant);
  private:
  int loadDLL(const char * bame);

  maci::Manager_ptr resolveManager(int nSecTimeout);

  // Logout from Manager
  void logout ();

  // DB prefix (for container)
  ACE_CString m_dbPrefix;

  // DB prefix (for MACI)
  ACE_CString m_dbRootPrefix;

  // argc
  int m_argc;

  // argc w/o ORB, CDB decrement
  int m_fullargc;

  // argv
  char** m_argv;

  int m_shutdownAction;

  bool m_hasIFR;

  bool m_recovery;

  //
  // shutdown helpers
  //

  ACE_SYNCH_MUTEX m_shutdownMutex;

  ACE_SYNCH_CONDITION m_shutdownDone;

  bool m_shutdownDoneSignaled;

  int m_serverThreads;

  bool m_dynamicContainer;

  ContainerServices *m_containerServices;

  maci::ContainerThreadHook m_containerThreadHook;

  Logging::Logger::LoggerSmartPtr m_logger;

  // default logging levels
  Logging::LoggingConfigurable::LogLevels m_defaultLogLevels;
  
  // loggers configuration 
  std::map<std::string, Logging::LoggingConfigurable::LogLevels> m_logLevels;

  // executionId
  maci::ExecutionId m_executionId;

  // startup timestamp
  ACS::Time m_startTime;

  //Logging stuff
  unsigned long cacheSize;
  unsigned long minCachePriority;
  unsigned long maxCachePriority;
  unsigned int flushPeriodSeconds;
  int maxLogsPerSecond;
    
  // activation thread-pool
  MethodRequestThreadPool* m_methodRequestThreadPool;

  // The thread to update the AlarmSource's
  std::auto_ptr<acsalarm::AlarmSourceThread> m_alarmSourceThread_ap;

  const acsalarm::AlarmSourceThread* getAlarmSourceThread() {
          if (m_alarmSourceThread_ap.get()==NULL)
          {
                  m_alarmSourceThread_ap=std::auto_ptr<acsalarm::AlarmSourceThread>(new acsalarm::AlarmSourceThread());
          }
          return m_alarmSourceThread_ap.get();
  }
};


template<class T>
T* ContainerImpl::getComponent(const char *name, const char *domain, bool activate)
{   
    T* object = T::_nil();

    if(!name) // Check if <name> is null
        {
        ACS_SHORT_LOG((LM_DEBUG, "Name parameter is null."));
        return T::_nil();
        }
    
    ACE_CString curl = "curl://";
    if (domain)
        curl += domain;

    curl += ACE_CString("/");

    curl += name;

    ACS_SHORT_LOG((LM_DEBUG, "Getting component: '%s'.",  curl.c_str()));
    
    // wait that m_handle become !=0
    while (m_handle==0)
        {
        ACS_SHORT_LOG((LM_DEBUG, "Waiting for m_handle"));
        ACE_OS::sleep(1);
        }
    
    try
        {
        CORBA::Object_var obj = m_manager->get_component(m_handle, curl.c_str(), activate);
        
        if (CORBA::is_nil(obj.in()))
            {
            ACS_SHORT_LOG((LM_DEBUG, "Failed to create '%s'.",  curl.c_str()));
            maciErrType::CannotGetComponentExImpl ex(__FILE__, __LINE__, 
                                        "ContainerImpl::getComponent&lt;&gt;");
            ex.setCURL(name);
            ex.log();
            // @todo throw ex;
            return T::_nil();
            }
        object = T::_narrow(obj.in());
        
        return object;
        }
    catch(maciErrType::ComponentNotAlreadyActivatedEx &_ex)
        {
        maciErrType::CannotGetComponentExImpl ex(_ex, __FILE__, __LINE__, 
                                               "maci::ContainerImpl::getComponent&lt;&gt;");
        ex.setCURL(name);
        ex.log();
        return T::_nil();
        }
    catch(maciErrType::ComponentConfigurationNotFoundEx &_ex)
        {
        maciErrType::CannotGetComponentExImpl ex(_ex, __FILE__, __LINE__, 
                                               "maci::ContainerImpl::getComponent&lt;&gt;");
        ex.setCURL(name);
        ex.log();
        return T::_nil();
        }
    catch( CORBA::SystemException &_ex )
        {
        ACSErrTypeCommon::CORBAProblemExImpl corbaProblemEx(__FILE__, __LINE__,
                                                            "ContainerServices::getComponent&lt;&gt;");
        corbaProblemEx.setMinor(_ex.minor());
        corbaProblemEx.setCompletionStatus(_ex.completed());
        corbaProblemEx.setInfo(_ex._info().c_str());
        maciErrType::CannotGetComponentExImpl ex(corbaProblemEx, __FILE__, __LINE__,
                                               "ContainerImpl::getComponent&lt;&gt;");
        ex.setCURL(name);
        ex.log();
        return T::_nil();
        }
    catch(...)
        {
        ACSErrTypeCommon::UnexpectedExceptionExImpl uex(__FILE__, __LINE__, 
                                                        "ContainerImpl::getComponent&lt;&gt;");
        maciErrType::CannotGetComponentExImpl ex(uex, __FILE__, __LINE__,
                                               "ContainerImpl::getComponent&lt;&gt;");
        ex.setCURL(name);
        ex.log();
        return T::_nil();
        }
}//getComponent

template<class T>
T* ContainerImpl::getService(const char *name, const char *domain, bool activate) 
{   
    ACS_TRACE("ContainerImpl::getService&lt;&gt;");
    T* object = T::_nil();
   
    if(!name)  // Check if <name> is null
        {
        ACSErrTypeCommon::NullPointerExImpl nullEx(__FILE__, __LINE__,
                                                   "ContainerImpl::getService&lt;&gt;");
        nullEx.setVariable("(parameter) name");
        maciErrType::CannotGetServiceExImpl ex(nullEx, __FILE__, __LINE__,
                                               "ContainerImpl::getService&lt;&gt;");
        ex.setCURL("NULL");
        throw ex;
        }//if
    
//     First creates the CURL and query the Manager for the component
    ACE_CString curl = "curl://";
    if (domain)
        curl += domain;

    curl += ACE_CString("/");

    curl += name;

    ACS_SHORT_LOG((LM_DEBUG, "Getting service: '%s'.",  curl.c_str()));
    
    // wait that m_handle become !=0
    while (m_handle==0)
        {
        ACS_SHORT_LOG((LM_DEBUG, "Waiting for m_handle"));
        ACE_OS::sleep(1);
        }

    try
        {
        CORBA::Object_var obj = m_manager->get_service(m_handle, curl.c_str(), activate);
        
        if (CORBA::is_nil(obj.in()))
            {
            maciErrType::CannotGetServiceExImpl ex(__FILE__, __LINE__, 
                                                   "ContainerImpl::getService&lt;&gt;");
            ex.setCURL(name);
            throw ex;
            }//if
        object = T::_narrow(obj.in());
        
        return object;
        }
    catch(maciErrType::CannotGetComponentEx &_ex)
        {
         maciErrType::CannotGetServiceExImpl ex(_ex, __FILE__, __LINE__,
                                                "ContainerImpl::getService&lt;&gt;");
         ex.setCURL(name);
         throw ex;
        }
    catch(maciErrType::ComponentNotAlreadyActivatedEx &_ex)
        {
         maciErrType::CannotGetServiceExImpl ex(_ex, __FILE__, __LINE__, 
                                                "ContainerImpl::getService&lt;&gt;");
         ex.setCURL(name);
         throw ex;
        }
    catch(maciErrType::ComponentConfigurationNotFoundEx &_ex)
        {
        maciErrType::CannotGetServiceExImpl ex(_ex, __FILE__, __LINE__, 
                                               "ContainerImpl::getService&lt;&gt;");
        ex.setCURL(name);
        throw ex;
        }
    catch( CORBA::SystemException &_ex )
        {
        ACSErrTypeCommon::CORBAProblemExImpl corbaProblemEx(__FILE__, __LINE__,
                                                            "ContainerImpl::getService&lt;&gt;");
        corbaProblemEx.setMinor(_ex.minor());
        corbaProblemEx.setCompletionStatus(_ex.completed());
        corbaProblemEx.setInfo(_ex._info().c_str());
        maciErrType::CannotGetServiceExImpl ex(corbaProblemEx, __FILE__, __LINE__,
                                               "ContainerImpl::getService&lt;&gt;");
        ex.setCURL(name);
        throw ex;
        }
    catch(...)
        {
        ACSErrTypeCommon::UnexpectedExceptionExImpl uex(__FILE__, __LINE__, 
                                                        "ContainerImpl::getService&lt;&gt;");
        maciErrType::CannotGetServiceExImpl ex(uex, __FILE__, __LINE__,
                                               "ContainerImpl::getService&lt;&gt;");
        ex.setCURL(name);
        throw ex;
        }//try-catch
}//getService

}; 

#endif // maciContainerImpl_h