Manager.h

[詳解]

#ifndef RTC_MANAGER_H
#define RTC_MANAGER_H

#include <rtm/RTC.h>

#include <iostream>
#include <string>
#include <vector>

#include <coil/Mutex.h>
#include <coil/Guard.h>
#include <coil/Task.h>

#include <rtm/Factory.h>
#include <rtm/ECFactory.h>
#include <rtm/ObjectManager.h>
#include <rtm/SystemLogger.h>
#include <rtm/ManagerActionListener.h>

namespace RTM
{
  class ManagerServant;
}

namespace coil
{
  class Timer;
};

namespace RTC
{
//  class Properties;
  class CorbaNaming;
  class ModuleManager;
  class NamingManager;
  class Manager;
  class RTObject_impl;
  typedef RTObject_impl RtcBase;

  typedef void (*ModuleInitProc)(Manager* manager);  
  
  class Manager
  {
    typedef coil::Mutex Mutex;
    typedef coil::Guard<Mutex> Guard;
  protected:
    Manager();
    
    Manager(const Manager& manager);
    //      Manager& operator=(const Manager& manager){return manager;};
    
  public:
    static Manager* init(int argc, char** argv);
    
    static Manager& instance();
    
    //============================================================
    // Manager
    //============================================================
    
    void terminate();
    
    void shutdown();
    
    void join();
    
    LogStreamBuf& getLogStreamBuf() {return m_logStreamBuf;}

    std::string& getLogLevel() {return m_config["logger.log_level"];}
    
    coil::Properties& getConfig() { return m_config;}
    
    void setModuleInitProc(ModuleInitProc proc);
    
    bool activateManager();
    
    void runManager(bool no_block = false);

    //============================================================
    // Module management
    //============================================================
    ReturnCode_t load(const std::string& fname, const std::string& initfunc);
    
    void unload(const char* fname);
    
    void unloadAll();
    
    std::vector<coil::Properties> getLoadedModules();
    
  std::vector<coil::Properties> getLoadableModules();
    
    //============================================================
    // Component Factory Management
    //============================================================
    bool registerFactory(coil::Properties& profile,
             RtcNewFunc new_func,
             RtcDeleteFunc delete_func);

    std::vector<coil::Properties> getFactoryProfiles();

    bool registerECFactory(const char* name,
               ECNewFunc new_func,
               ECDeleteFunc delete_func);
    
    std::vector<std::string> getModulesFactories();
    
    //============================================================
    // Component management
    //============================================================
    RTObject_impl* createComponent(const char* comp_args);
    ExecutionContextBase* createContext(const char* ec_args);
    
    void cleanupComponent(RTObject_impl* comp);

    void cleanupComponents();

    void notifyFinalized(RTObject_impl* comp);

    bool registerComponent(RTObject_impl* comp);
    
    bool unregisterComponent(RTObject_impl* comp);
    
    
    void deleteComponent(RTObject_impl* comp);
    
    void deleteComponent(const char* instance_name);

    
    RTObject_impl* getComponent(const char* instance_name);
    
    std::vector<RTObject_impl*> getComponents();


    void
    addManagerActionListener(RTM::ManagerActionListener* listener,
                             bool autoclean = true);
    void
    removeManagerActionListener(RTM::ManagerActionListener* listener);

    void
    addModuleActionListener(RTM::ModuleActionListener* listener,
                             bool autoclean = true);
    void
    removeModuleActionListener(RTM::ModuleActionListener* listener);

    void
    addRtcLifecycleActionListener(RTM::RtcLifecycleActionListener* listener,
                                  bool autoclean = true);
    void
    removeRtcLifecycleActionListener(RTM::RtcLifecycleActionListener* listener);
    
    void
    addNamingActionListener(RTM::NamingActionListener* listener,
                            bool autoclean = true);
    void
    removeNamingActionListener(RTM::NamingActionListener* listener);
    
    void
    addLocalServiceActionListener(RTM::LocalServiceActionListener* listener,
                                       bool autoclean = true);
    void
    removeLocalServiceActionListener(RTM::LocalServiceActionListener* listener);

    
    //============================================================
    // CORBA 関連
    //============================================================
    CORBA::ORB_ptr theORB();

    CORBA::ORB_ptr getORB();

    PortableServer::POA_ptr thePOA();
#ifdef ORB_IS_OMNIORB
    PortableServer::POA_ptr theShortCutPOA();
#endif

    PortableServer::POA_ptr getPOA();
#ifdef ORB_IS_OMNIORB
    PortableServer::POA_ptr getShortCutPOA();
#endif

    PortableServer::POAManager_ptr thePOAManager();
    PortableServer::POAManager_ptr getPOAManager();
    RTM::ManagerServant& getManagerServant();

    bool initLocalService();
    NamingManager* getNaming();

    
    //============================================================
    // Protected functions
    //============================================================
  protected:
    
    //============================================================
    // Manager initialize and finalization
    //============================================================
    void initManager(int argc, char** argv);
    
    void shutdownManager();

    void shutdownOnNoRtcs();

    //============================================================
    // Logger initialize and terminator
    //============================================================
    void initLogstreamFile();
    void initLogstreamPlugins();
    void initLogstreamOthers();
    bool initLogger();
    
    void shutdownLogger();
    
    //============================================================
    // ORB initialization and finalization
    //============================================================
    bool initORB();
    
    std::string createORBOptions();

    void createORBEndpoints(coil::vstring& endpoints);
    
    void createORBEndpointOption(std::string& opt, coil::vstring& endpoint);

    void shutdownORB();
    
    //============================================================
    // NamingService initialization and finalization
    //============================================================
    bool initNaming();
    
    void shutdownNaming();

     NamingManager& getNamingManager();
    
    //============================================================
    // Component management
    //============================================================
    void shutdownComponents();


    bool procComponentArgs(const char* comp_arg,
                           coil::Properties& comp_id,
                           coil::Properties& comp_conf);
    bool procContextArgs(const char* ec_args,
                         std::string& ec_id,
                         coil::Properties& ec_conf);

    void configureComponent(RTObject_impl* comp, const coil::Properties& prop);
    
    bool initExecContext();

    bool initComposite();

    bool initFactories();

    void initCpuAffinity();

    void initPreConnection();
    void initPreActivation();
    void initPreCreation();
    void invokeInitProc();
    void publishPorts(RTObject_impl* comp);
    void subscribePorts(RTObject_impl* comp);
    PortServiceList_var getPortsOnNameServers(std::string nsname, std::string kind);
    void connectDataPorts(PortService_ptr port, PortServiceList_var& target_ports);
    void connectServicePorts(PortService_ptr port, PortServiceList_var& target_ports);
    
    bool initTimer();

    bool initManagerServant();

    RTM::ManagerServant* m_mgrservant;

    bool mergeProperty(coil::Properties& prop, const char* file_name);
    
    std::string formatString(const char* naming_format,
                 coil::Properties& prop);


    void setEndpointProperty(CORBA::Object_ptr objref);

    void endpointPropertySwitch(const std::string& ipver,
                                bool& ip, std::vector<int>& ip_list);

    
    //============================================================
    // protected 変数
    //============================================================
    
    //------------------------------------------------------------
    // static var
    //------------------------------------------------------------
    static Manager* manager;
    
    static Mutex mutex;
    
    //------------------------------------------------------------
    // CORBA var
    //------------------------------------------------------------
    CORBA::ORB_var m_pORB;
    
    PortableServer::POA_var m_pPOA;
#ifdef ORB_IS_OMNIORB
    PortableServer::POA_var m_pShortCutPOA;
#endif
    
    PortableServer::POAManager_var m_pPOAManager;
    
    //------------------------------------------------------------
    // Manager's variable
    //------------------------------------------------------------
    ModuleInitProc m_initProc;
    
    coil::Properties m_config;
    
    ModuleManager* m_module;
    
    NamingManager* m_namingManager;
    
    coil::Timer* m_timer;
    
    //------------------------------------------------------------
    // Logger
    //------------------------------------------------------------
    LogStreamBuf m_logStreamBuf;
    
    Logger rtclog;

    std::vector<std::filebuf*> m_logfiles;
    
    //============================================================
    // コンポーネントマネージャ
    //============================================================
    // ObjectManager へ渡す述語クラス
    struct InstanceName
    {
      InstanceName(RTObject_impl* comp);
      InstanceName(const char* name);
      InstanceName(const std::string name);
      bool operator()(RTObject_impl* comp);
      std::string m_name;
    };
    
    typedef ObjectManager<std::string, RTObject_impl, InstanceName> ComponentManager;

    ComponentManager m_compManager;
    
    //============================================================
    // コンポーネントファクトリ
    //============================================================
    // コンポーネントファクトリへ渡す述語クラス
    class FactoryPredicate
    {
    public:
      FactoryPredicate(const char* imple_id)
        : m_vendor(""), m_category(""), m_impleid(imple_id), m_version("")
      {
      }
      FactoryPredicate(const coil::Properties& prop)
        : m_vendor(prop["vendor"]),
          m_category(prop["category"]),
          m_impleid(prop["implementation_id"]),
          m_version(prop["version"])
      {
      }
      FactoryPredicate(FactoryBase* factory)
    : m_vendor(factory->profile()["vendor"]),
          m_category(factory->profile()["category"]),
          m_impleid(factory->profile()["implementation_id"]),
          m_version(factory->profile()["version"])
      {
      }
      bool operator()(FactoryBase* factory)
      {
        // implementation_id must not be empty
        if (m_impleid.empty()) return false;

        const coil::Properties& prop(factory->profile());

        if (m_impleid != prop["implementation_id"])
          return false;
        if (!m_vendor.empty()   && m_vendor != prop["vendor"])
          return false;
        if (!m_category.empty() && m_category != prop["category"])
          return false;
        if (!m_version.empty()  && m_version != prop["version"])
          return false;
          
        return true;
      }
    private:
      std::string m_vendor;
      std::string m_category;
      std::string m_impleid;
      std::string m_version;
    };
    
    class ModulePredicate
    {
      coil::Properties& m_prop;
    public:
      ModulePredicate(coil::Properties& prop)
      : m_prop(prop)
      {
      }
      bool operator()(coil::Properties& prop)
      {
        if (m_prop["implementation_id"] != prop["implementation_id"])
          {
            return false;
          }
        if (!m_prop["vendor"].empty() &&
            m_prop["vendor"] != prop["vendor"])     { return false; }
        if (!m_prop["category"].empty() &&
            m_prop["category"] != prop["category"]) { return false; }
        if (!m_prop["version"].empty() && 
            m_prop["version"] != prop["version"])   { return false; }
        return true;
      }
    };

    typedef ObjectManager<const coil::Properties, FactoryBase,
              FactoryPredicate> FactoryManager;

    FactoryManager m_factory;
    
    //============================================================
    // ExecutionContextファクトリ
    //============================================================
    // ECファクトリへ渡す述語クラス
    struct ECFactoryPredicate
    {
      ECFactoryPredicate(const char* name) : m_name(name){};
      ECFactoryPredicate(ECFactoryBase* factory)
    : m_name(factory->name()) {};
      bool operator()(ECFactoryBase* factory)
      {
    return m_name == factory->name();
      }
      std::string m_name;
    };
    typedef ObjectManager<const char*,
              ECFactoryBase,
              ECFactoryPredicate> ECFactoryManager;
    
    ECFactoryManager m_ecfactory;
    
    std::vector<ExecutionContextBase*> m_ecs;
    
    // ファクトリ名をリストアップするためのファンクタ
    struct ModuleFactories
    {
      void operator()(FactoryBase* f)
      {
    modlist.push_back(f->profile().getProperty("implementation_id"));
      }
      std::vector<std::string> modlist;
    };
    
    //------------------------------------------------------------
    // ORB runner
    //------------------------------------------------------------
    class OrbRunner
      : public coil::Task
    {
    public:
      OrbRunner(CORBA::ORB_ptr orb) : m_pORB(orb)
      {
    open(0);
      };
      
      virtual int open(void *args)
      {
    activate();
    return 0;
      }
      
      virtual int svc(void)
      {
    m_pORB->run();
//  Manager::instance().shutdown();
    return 0;
      }
      
      virtual int close(unsigned long flags)
      {
    return 0;
      }
    private:
      CORBA::ORB_ptr m_pORB;
    };
    OrbRunner* m_runner;

    //------------------------------------------------------------
    // Manager Terminator
    //------------------------------------------------------------
    class Terminator
      : public coil::Task
    {
    public:
      Terminator(Manager* manager, double waittime = 0)
    : m_manager(manager), m_waittime(waittime) {};
      
      void terminate()
      {
    open(0);
      }
      
      virtual int open(void *args)
      {
    activate();
    return 0;
      }
      
      virtual int svc(void)
      {
    coil::sleep(m_waittime);
    Manager::instance().shutdown();
    return 0;
      }
      Manager* m_manager;
      coil::TimeValue m_waittime;
    };
    
    Terminator* m_terminator;
    
    struct Term
    {
      int waiting;
      Mutex mutex;
    };
    Term m_terminate;

    struct Finalized
    {
      Mutex mutex;
      std::vector<RTObject_impl*> comps;
    };
    Finalized m_finalized;

    ::RTM::ManagerActionListeners m_listeners;
  }; // class Manager
}; // namespace RTC

#endif // RTC_MANAGER_H