Manager.h

Go to the documentation of this file.

 
#ifndef RTC_MANAGER_H
#define RTC_MANAGER_H
 
#include <rtm/RTC.h>
 
#ifdef ORB_IS_TAO
#include <tao/Strategies/advanced_resource.h>
#include <tao/IORTable/IORTable.h>
#endif
 
#include <rtm/Factory.h>
#include <rtm/ECFactory.h>
#include <rtm/ObjectManager.h>
#include <rtm/SystemLogger.h>
#include <rtm/ManagerActionListener.h>
 
#ifdef ORB_IS_ORBEXPRESS
#include <RTPortableServer.h>
#endif
 
#include <coil/Timer.h>
#include <coil/Signal.h>
 
#include <atomic>
#include <functional>
#include <mutex>
#include <list>
#include <thread>
#include <vector>
 
namespace RTM
{
  class ManagerServant;
} // namespace RTM
 
namespace coil
{
} // namespace coil
 
namespace RTC
{
  class CorbaNaming;
  class ModuleManager;
  class NamingManager;
  class Manager;
  class RTObject_impl;
  using RtcBase = RTObject_impl;
 
  using ModuleInitProc = void (*)(Manager*);
 
  class Manager
  {
  protected:
    Manager();
 
    Manager(const Manager&) = delete;
    Manager& operator=(const Manager&) = delete;
 
  public:
    static Manager* init(int argc, char** argv);
 
    static Manager& instance();
 
    //============================================================
    // Manager
    //============================================================
 
    static void terminate();
 
    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);
 
    using TaskId = coil::Timer<coil::PeriodicFunction>::TaskId;
 
    TaskId addTask(std::function<void(void)> fn,
                   std::chrono::nanoseconds period);
 
    static void removeTask(TaskId id) { id->stop(); }
 
    void invoke(std::function<void(void)> fn,
                std::chrono::nanoseconds delay
                = std::chrono::seconds::zero());
 
    //============================================================
    // Module management
    //============================================================
    ReturnCode_t load(const std::string& fname, const std::string& initfunc);
 
    ReturnCode_t load(coil::Properties &prop, 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 shutdown();
 
    // TAO will cause the build to fail, so don't use name "main".
    void mainThread();
 
    //============================================================
    // Logger initialize and terminator
    //============================================================
    void initLogstreamFile();
    void initLogstreamPlugins();
    void initLogstreamOthers();
    bool initLogger();
 
    void shutdownLogger();
 
    void shutdownManagerServant();
 
    //============================================================
    // ORB initialization and finalization
    //============================================================
    bool initORB();
 
    std::string createORBOptions();
 
    static bool isORBEndPoint(const std::string& endpoint);
 
    void createORBEndpoints(coil::vstring& endpoints);
 
    void createORBEndpointOption(std::string& opt, coil::vstring endpoints);
 
    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* getPortsOnNameServers(const std::string& nsname, const std::string& kind);
    void connectDataPorts(PortService_ptr port, PortServiceList_var& target_ports);
    void connectServicePorts(PortService_ptr port, PortServiceList_var& target_ports);
 
    bool initManagerServant();
 
 
 
    RTM::ManagerServant* m_mgrservant{nullptr};
 
    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 std::mutex mutex;
 
    static std::atomic_flag m_isRunning;
 
    //------------------------------------------------------------
    // 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;
 
    coil::Argv m_argv;
 
    int m_argvSize{0};
 
    //------------------------------------------------------------
    // Manager's variable
    //------------------------------------------------------------
    ModuleInitProc m_initProc{nullptr};
 
    coil::Properties m_config;
 
    ModuleManager* m_module{nullptr};
 
    NamingManager* m_namingManager{nullptr};
 
    coil::Timer<coil::DelayedFunction> m_invoker;
 
    coil::Timer<coil::PeriodicFunction> m_scheduler;
 
    std::thread m_threadOrb;
 
    std::thread m_threadMain;
 
    std::list<coil::SignalAction> m_signals;
 
    bool m_needsTimer{false};
 
    //------------------------------------------------------------
    // Logger
    //------------------------------------------------------------
    LogStreamBuf m_logStreamBuf;
 
    Logger rtclog{&m_logStreamBuf};
 
    std::vector<std::filebuf*> m_logfiles;
 
    //============================================================
    // コンポーネントマネージャ
    //============================================================
    // ObjectManager へ渡す述語クラス
    struct InstanceName
    {
      explicit InstanceName(RTObject_impl* comp);
      explicit InstanceName(const char* name);
      explicit InstanceName(std::string  name);
      bool operator()(RTObject_impl* comp);
      std::string m_name;
    };
 
    using ComponentManager = ObjectManager<std::string, RTObject_impl,
                                           InstanceName>;
 
    ComponentManager m_compManager;
 
    //============================================================
    // コンポーネントファクトリ
    //============================================================
    // コンポーネントファクトリへ渡す述語クラス
    class FactoryPredicate
    {
    public:
      explicit FactoryPredicate(const char* imple_id)
        : m_vendor(""), m_category(""), m_impleid(imple_id), m_version(""), m_language("")
      {
      }
      explicit FactoryPredicate(const coil::Properties& prop)
        : m_vendor(prop["vendor"]),
          m_category(prop["category"]),
          m_impleid(prop["implementation_id"]),
          m_version(prop["version"]),
          m_language(prop["language"])
      {
      }
      explicit FactoryPredicate(FactoryBase* factory)
        : m_vendor(factory->profile()["vendor"]),
          m_category(factory->profile()["category"]),
          m_impleid(factory->profile()["implementation_id"]),
          m_version(factory->profile()["version"]),
          m_language(factory->profile()["language"])
      {
      }
      ~FactoryPredicate();
      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;
        if (!m_language.empty()  && m_language != prop["language"])
          return false;
        
 
        return true;
      }
    private:
      std::string m_vendor;
      std::string m_category;
      std::string m_impleid;
      std::string m_version;
      std::string m_language;
    };
 
    class ModulePredicate
    {
      coil::Properties& m_prop;
    public:
      explicit 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;
      }
    };
 
    using FactoryManager = ObjectManager<const coil::Properties,
                                         FactoryBase, FactoryPredicate>;
 
    FactoryManager m_factory;
 
    //============================================================
    // ExecutionContextファクトリ
    //============================================================
    // ECファクトリへ渡す述語クラス
    struct ECFactoryPredicate
    {
      explicit ECFactoryPredicate(const char* name) : m_name(name) {}
      explicit ECFactoryPredicate(ECFactoryBase* factory)
        : m_name(factory->name()) {}
      bool operator()(ECFactoryBase* factory)
      {
        return m_name == factory->name();
      }
      std::string m_name;
    };
    using ECFactoryManager = ObjectManager<const char*, ECFactoryBase,
                                           ECFactoryPredicate>;
 
    ECFactoryManager m_ecfactory;
 
    std::vector<ExecutionContextBase*> m_ecs;
 
    // ファクトリ名をリストアップするためのファンクタ
    struct ModuleFactories
    {
      void operator()(FactoryBase* f)
      {
        modlist.emplace_back(f->profile().getProperty("implementation_id"));
      }
      std::vector<std::string> modlist;
    };
 
    struct Finalized
    {
      ~Finalized();
      std::mutex mutex;
      std::vector<RTObject_impl*> comps;
    };
    Finalized m_finalized;
 
    ::RTM::ManagerActionListeners m_listeners;
  };  // class Manager
} // namespace RTC
 
#endif  // RTC_MANAGER_H