Manager.h

Go to the documentation of this file.

// -*- C++ -*-
#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>

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
    //============================================================
    void load(const char* fname, const char* 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();
    
    //============================================================
    // CORBA ´ØÏ¢
    //============================================================
    CORBA::ORB_ptr getORB();
    
    PortableServer::POA_ptr getPOA();
    
    PortableServer::POAManager_ptr getPOAManager();
    
    //============================================================
    // Protected functions
    //============================================================
  protected:
    
    //============================================================
    // Manager initialize and finalization
    //============================================================
    void initManager(int argc, char** argv);
    
    void shutdownManager();

    void shutdownOnNoRtcs();

    //============================================================
    // Logger initialize and terminator
    //============================================================
    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();
    
    //============================================================
    // 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();

    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);


    
    //============================================================
    // protected ÊÑ¿ô
    //============================================================
    
    //------------------------------------------------------------
    // static var
    //------------------------------------------------------------
    static Manager* manager;
    
    static Mutex mutex;
    
    //------------------------------------------------------------
    // CORBA var
    //------------------------------------------------------------
    CORBA::ORB_var m_pORB;
    
    PortableServer::POA_var m_pPOA;
    
    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) : m_manager(manager) {};
      
      void terminate()
      {
        open(0);
      }
      
      virtual int open(void *args)
      {
        activate();
        return 0;
      }
      
      virtual int svc(void)
      {
        Manager::instance().shutdown();
        return 0;
      }
      Manager* m_manager;
    };
    
    Terminator* m_terminator;
    
    struct Term
    {
      int waiting;
      Mutex mutex;
    };
    Term m_terminate;

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


  }; // class Manager
}; // namespace RTC

#endif // RTC_MANAGER_H