00001
00020 #ifndef RTC_MANAGER_H
00021 #define RTC_MANAGER_H
00022
00023 #include <rtm/RTC.h>
00024
00025 #include <iostream>
00026 #include <string>
00027 #include <vector>
00028
00029 #include <coil/Mutex.h>
00030 #include <coil/Guard.h>
00031 #include <coil/Task.h>
00032
00033 #include <rtm/Factory.h>
00034 #include <rtm/ECFactory.h>
00035 #include <rtm/ObjectManager.h>
00036 #include <rtm/SystemLogger.h>
00037 #include <rtm/ManagerActionListener.h>
00038
00039 namespace RTM
00040 {
00041 class ManagerServant;
00042 }
00043
00044 namespace coil
00045 {
00046 class Timer;
00047 };
00048
00049 namespace RTC
00050 {
00051
00052 class CorbaNaming;
00053 class ModuleManager;
00054 class NamingManager;
00055 class Manager;
00056 class RTObject_impl;
00057 typedef RTObject_impl RtcBase;
00058
00059 typedef void (*ModuleInitProc)(Manager* manager);
00060
00081 class Manager
00082 {
00083 typedef coil::Mutex Mutex;
00084 typedef coil::Guard<Mutex> Guard;
00085 protected:
00099 Manager();
00100
00118 Manager(const Manager& manager);
00119
00120
00121 public:
00174 static Manager* init(int argc, char** argv);
00175
00198 static Manager& instance();
00199
00200
00201
00202
00203
00217 void terminate();
00218
00234 void shutdown();
00235
00249 void join();
00250
00268 LogStreamBuf& getLogStreamBuf() {return m_logStreamBuf;}
00269
00287 std::string& getLogLevel() {return m_config["logger.log_level"];}
00288
00306 coil::Properties& getConfig() { return m_config;}
00307
00332 void setModuleInitProc(ModuleInitProc proc);
00333
00366 bool activateManager();
00367
00398 void runManager(bool no_block = false);
00399
00400
00401
00402
00425 void load(const char* fname, const char* initfunc);
00426
00446 void unload(const char* fname);
00447
00463 void unloadAll();
00464
00482 std::vector<coil::Properties> getLoadedModules();
00483
00503 std::vector<coil::Properties> getLoadableModules();
00504
00505
00506
00507
00534 bool registerFactory(coil::Properties& profile,
00535 RtcNewFunc new_func,
00536 RtcDeleteFunc delete_func);
00537
00555 std::vector<coil::Properties> getFactoryProfiles();
00556
00583 bool registerECFactory(const char* name,
00584 ECNewFunc new_func,
00585 ECDeleteFunc delete_func);
00586
00604 std::vector<std::string> getModulesFactories();
00605
00606
00607
00608
00667 RTObject_impl* createComponent(const char* comp_args);
00681 ExecutionContextBase* createContext(const char* ec_args);
00682
00701 void cleanupComponent(RTObject_impl* comp);
00702
00716 void cleanupComponents();
00717
00736 void notifyFinalized(RTObject_impl* comp);
00737
00761 bool registerComponent(RTObject_impl* comp);
00762
00784 bool unregisterComponent(RTObject_impl* comp);
00785
00786
00808 void deleteComponent(RTObject_impl* comp);
00809
00832 void deleteComponent(const char* instance_name);
00833
00834
00858 RTObject_impl* getComponent(const char* instance_name);
00859
00877 std::vector<RTObject_impl*> getComponents();
00878
00879
00880 void
00881 addManagerActionListener(RTM::ManagerActionListener* listener,
00882 bool autoclean = true);
00883 void
00884 removeManagerActionListener(RTM::ManagerActionListener* listener);
00885
00886 void
00887 addModuleActionListener(RTM::ModuleActionListener* listener,
00888 bool autoclean = true);
00889 void
00890 removeModuleActionListener(RTM::ModuleActionListener* listener);
00891
00892 void
00893 addRtcLifecycleActionListener(RTM::RtcLifecycleActionListener* listener,
00894 bool autoclean = true);
00895 void
00896 removeRtcLifecycleActionListener(RTM::RtcLifecycleActionListener* listener);
00897
00898 void
00899 addNamingActionListener(RTM::NamingActionListener* listener,
00900 bool autoclean = true);
00901 void
00902 removeNamingActionListener(RTM::NamingActionListener* listener);
00903
00904 void
00905 addLocalServiceActionListener(RTM::LocalServiceActionListener* listener,
00906 bool autoclean = true);
00907 void
00908 removeLocalServiceActionListener(RTM::LocalServiceActionListener* listener);
00909
00910
00911
00912
00913
00931 CORBA::ORB_ptr getORB();
00932
00950 PortableServer::POA_ptr getPOA();
00951
00969 PortableServer::POAManager_ptr getPOAManager();
00970
00971
00972
00973
00974 protected:
00975
00976
00977
00978
01006 void initManager(int argc, char** argv);
01007
01023 void shutdownManager();
01024
01041 void shutdownOnNoRtcs();
01042
01043
01044
01045
01067 bool initLogger();
01068
01086 void shutdownLogger();
01087
01088
01089
01090
01108 bool initORB();
01109
01129 std::string createORBOptions();
01130
01148 void createORBEndpoints(coil::vstring& endpoints);
01149
01163 void createORBEndpointOption(std::string& opt, coil::vstring& endpoint);
01164
01183 void shutdownORB();
01184
01185
01186
01187
01219 bool initNaming();
01220
01236 void shutdownNaming();
01237
01238
01239
01240
01256 void shutdownComponents();
01257
01258
01306 bool procComponentArgs(const char* comp_arg,
01307 coil::Properties& comp_id,
01308 coil::Properties& comp_conf);
01349 bool procContextArgs(const char* ec_args,
01350 std::string& ec_id,
01351 coil::Properties& ec_conf);
01352
01375 void configureComponent(RTObject_impl* comp, const coil::Properties& prop);
01376
01398 bool initExecContext();
01399
01415 bool initComposite();
01416
01438 bool initFactories();
01439
01459 bool initTimer();
01460
01474 bool initManagerServant();
01475
01489 bool initLocalService();
01490
01498 RTM::ManagerServant* m_mgrservant;
01499
01525 bool mergeProperty(coil::Properties& prop, const char* file_name);
01526
01575 std::string formatString(const char* naming_format,
01576 coil::Properties& prop);
01577
01578
01579
01580
01581
01582
01583
01584
01585
01586
01594 static Manager* manager;
01595
01603 static Mutex mutex;
01604
01605
01606
01607
01615 CORBA::ORB_var m_pORB;
01616
01624 PortableServer::POA_var m_pPOA;
01625
01633 PortableServer::POAManager_var m_pPOAManager;
01634
01635
01636
01637
01645 ModuleInitProc m_initProc;
01646
01654 coil::Properties m_config;
01655
01663 ModuleManager* m_module;
01664
01672 NamingManager* m_namingManager;
01673
01681 coil::Timer* m_timer;
01682
01683
01684
01685
01693 LogStreamBuf m_logStreamBuf;
01694
01702 Logger rtclog;
01703
01711 std::vector<std::filebuf*> m_logfiles;
01712
01713
01714
01715
01716
01717 struct InstanceName
01718 {
01719 InstanceName(RTObject_impl* comp);
01720 InstanceName(const char* name);
01721 InstanceName(const std::string name);
01722 bool operator()(RTObject_impl* comp);
01723 std::string m_name;
01724 };
01725
01726 typedef ObjectManager<std::string, RTObject_impl, InstanceName> ComponentManager;
01727
01735 ComponentManager m_compManager;
01736
01737
01738
01739
01740
01741 class FactoryPredicate
01742 {
01743 public:
01744 FactoryPredicate(const char* imple_id)
01745 : m_vendor(""), m_category(""), m_impleid(imple_id), m_version("")
01746 {
01747 }
01748 FactoryPredicate(const coil::Properties& prop)
01749 : m_vendor(prop["vendor"]),
01750 m_category(prop["category"]),
01751 m_impleid(prop["implementation_id"]),
01752 m_version(prop["version"])
01753 {
01754 }
01755 FactoryPredicate(FactoryBase* factory)
01756 : m_vendor(factory->profile()["vendor"]),
01757 m_category(factory->profile()["category"]),
01758 m_impleid(factory->profile()["implementation_id"]),
01759 m_version(factory->profile()["version"])
01760 {
01761 }
01762 bool operator()(FactoryBase* factory)
01763 {
01764
01765 if (m_impleid.empty()) return false;
01766
01767 const coil::Properties& prop(factory->profile());
01768
01769 if (m_impleid != prop["implementation_id"])
01770 return false;
01771 if (!m_vendor.empty() && m_vendor != prop["vendor"])
01772 return false;
01773 if (!m_category.empty() && m_category != prop["category"])
01774 return false;
01775 if (!m_version.empty() && m_version != prop["version"])
01776 return false;
01777
01778 return true;
01779 }
01780 private:
01781 std::string m_vendor;
01782 std::string m_category;
01783 std::string m_impleid;
01784 std::string m_version;
01785 };
01786
01787 class ModulePredicate
01788 {
01789 coil::Properties& m_prop;
01790 public:
01791 ModulePredicate(coil::Properties& prop)
01792 : m_prop(prop)
01793 {
01794 }
01795 bool operator()(coil::Properties& prop)
01796 {
01797 if (m_prop["implementation_id"] != prop["implementation_id"])
01798 {
01799 return false;
01800 }
01801 if (!m_prop["vendor"].empty() &&
01802 m_prop["vendor"] != prop["vendor"]) { return false; }
01803 if (!m_prop["category"].empty() &&
01804 m_prop["category"] != prop["category"]) { return false; }
01805 if (!m_prop["version"].empty() &&
01806 m_prop["version"] != prop["version"]) { return false; }
01807 return true;
01808 }
01809 };
01810
01818 typedef ObjectManager<const coil::Properties, FactoryBase,
01819 FactoryPredicate> FactoryManager;
01820
01828 FactoryManager m_factory;
01829
01830
01831
01832
01833
01834 struct ECFactoryPredicate
01835 {
01836 ECFactoryPredicate(const char* name) : m_name(name){};
01837 ECFactoryPredicate(ECFactoryBase* factory)
01838 : m_name(factory->name()) {};
01839 bool operator()(ECFactoryBase* factory)
01840 {
01841 return m_name == factory->name();
01842 }
01843 std::string m_name;
01844 };
01845 typedef ObjectManager<const char*,
01846 ECFactoryBase,
01847 ECFactoryPredicate> ECFactoryManager;
01848
01856 ECFactoryManager m_ecfactory;
01857
01865 std::vector<ExecutionContextBase*> m_ecs;
01866
01867
01868 struct ModuleFactories
01869 {
01870 void operator()(FactoryBase* f)
01871 {
01872 modlist.push_back(f->profile().getProperty("implementation_id"));
01873 }
01874 std::vector<std::string> modlist;
01875 };
01876
01877
01878
01879
01899 class OrbRunner
01900 : public coil::Task
01901 {
01902 public:
01916 OrbRunner(CORBA::ORB_ptr orb) : m_pORB(orb)
01917 {
01918 open(0);
01919 };
01920
01942 virtual int open(void *args)
01943 {
01944 activate();
01945 return 0;
01946 }
01947
01965 virtual int svc(void)
01966 {
01967 m_pORB->run();
01968
01969 return 0;
01970 }
01971
01993 virtual int close(unsigned long flags)
01994 {
01995 return 0;
01996 }
01997 private:
01998 CORBA::ORB_ptr m_pORB;
01999 };
02007 OrbRunner* m_runner;
02008
02009
02010
02011
02031 class Terminator
02032 : public coil::Task
02033 {
02034 public:
02052 Terminator(Manager* manager) : m_manager(manager) {};
02053
02067 void terminate()
02068 {
02069 open(0);
02070 }
02071
02093 virtual int open(void *args)
02094 {
02095 activate();
02096 return 0;
02097 }
02098
02116 virtual int svc(void)
02117 {
02118 Manager::instance().shutdown();
02119 return 0;
02120 }
02121 Manager* m_manager;
02122 };
02123
02131 Terminator* m_terminator;
02132
02133 struct Term
02134 {
02135 int waiting;
02136 Mutex mutex;
02137 };
02151 Term m_terminate;
02152
02153 struct Finalized
02154 {
02155 Mutex mutex;
02156 std::vector<RTObject_impl*> comps;
02157 };
02158 Finalized m_finalized;
02159
02160 ::RTM::ManagerActionListeners m_listeners;
02161 };
02162 };
02163
02164 #endif // RTC_MANAGER_H