openrtm_aist_python: Manager.py Source File

Go to the documentation of this file.
00001 #!/usr/bin/env python
00002 # -*- coding: euc-jp -*-
00003 
00004 ##
00005 # @file Manager.py
00006 # @brief RTComponent manager class
00007 # @date $Date: $
00008 # @author Noriaki Ando <n-ando@aist.go.jp> and Shinji Kurihara
00009 #
00010 # Copyright (C) 2006-2008
00011 #     Task-intelligence Research Group,
00012 #     Intelligent Systems Research Institute,
00013 #     National Institute of
00014 #         Advanced Industrial Science and Technology (AIST), Japan
00015 #     All rights reserved.
00016 
00017 import threading
00018 import string
00019 import signal, os
00020 import traceback
00021 import sys
00022 import time
00023 from omniORB import CORBA, PortableServer
00024 from types import IntType, ListType
00025 
00026 import OpenRTM_aist
00027 import RTC
00028 import SDOPackage
00029 
00030 
00031 #------------------------------------------------------------
00032 # static var
00033 #------------------------------------------------------------
00034 
00035 ##
00036 # @if jp
00037 # @brief 唯一の Manager へのポインタ
00038 # @else
00039 # @brief The pointer to the Manager
00040 # @endif
00041 manager = None
00042 
00043 ##
00044 # @if jp
00045 # @brief 唯一の Manager へのポインタに対する mutex
00046 # @else
00047 # @brief The mutex of the pointer to the Manager 
00048 # @endif
00049 mutex = threading.RLock()
00050 
00051 
00052 ##
00053 # @if jp
00054 # @brief 終了処理
00055 #
00056 # マネージャを終了させる
00057 #
00058 # @param signum シグナル番号
00059 # @param frame 現在のスタックフレーム
00060 #
00061 # @else
00062 #
00063 # @endif
00064 def handler(signum, frame):
00065   mgr = OpenRTM_aist.Manager.instance()
00066   mgr.terminate()
00067 
00068 
00069 
00070 ##
00071 # @if jp
00072 # @class Manager
00073 # @brief Manager クラス
00074 #
00075 # コンポーネントなど各種の情報管理を行うマネージャクラス。
00076 #
00077 # @since 0.2.0
00078 #
00079 # @else
00080 # @class Manager
00081 # @brief Manager class
00082 # @endif
00083 class Manager:
00084   """
00085   """
00086 
00087 
00088 
00089   ##
00090   # @if jp
00091   # @brief コピーコンストラクタ
00092   #
00093   # コピーコンストラクタ
00094   #
00095   # @param self
00096   # @param _manager コピー元マネージャオブジェクト(デフォルト値:None)
00097   #
00098   # @else
00099   # @brief Protected Copy Constructor
00100   #
00101   # @endif
00102   def __init__(self, _manager=None):
00103     self._initProc   = None
00104     self._runner     = None
00105     self._terminator = None
00106     self._compManager = OpenRTM_aist.ObjectManager(self.InstanceName)
00107     self._factory = OpenRTM_aist.ObjectManager(self.FactoryPredicate)
00108     self._ecfactory = OpenRTM_aist.ObjectManager(self.ECFactoryPredicate)
00109     self._terminate = self.Term()
00110     self._ecs = []
00111     self._timer = None
00112     self._orb = None
00113     self._poa = None
00114     self._poaManager = None 
00115     self._finalized = self.Finalized()
00116     signal.signal(signal.SIGINT, handler)
00117     
00118     return
00119 
00120 
00121   ##
00122   # @if jp
00123   # @brief マネージャの初期化
00124   #
00125   # マネージャを初期化する static 関数。
00126   # マネージャをコマンドライン引数を与えて初期化する。
00127   # マネージャを使用する場合は、必ずこの初期化メンバ関数 init() を
00128   # 呼ばなければならない。
00129   # マネージャのインスタンスを取得する方法として、init(), instance() の
00130   # 2つの static 関数が用意されているが、初期化はinit()でしか行われないため、
00131   # Manager の生存期間の一番最初にはinit()を呼ぶ必要がある。
00132   #
00133   # ※マネージャの初期化処理
00134   # - initManager: 引数処理、configファイルの読み込み、サブシステム初期化
00135   # - initLogger: Logger初期化
00136   # - initORB: ORB 初期化
00137   # - initNaming: NamingService 初期化
00138   # - initExecutionContext: ExecutionContext factory 初期化
00139   # - initTimer: Timer 初期化
00140   #
00141   # @param argv コマンドライン引数
00142   # 
00143   # @return Manager の唯一のインスタンスの参照
00144   #
00145   # @else
00146   # @brief Initializa manager
00147   #
00148   # This is the static function to tintialize the Manager.
00149   # The Manager is initialized by given arguments.
00150   # At the starting the manager, this static function "must" be called from
00151   # application program. The manager has two static functions to get 
00152   # the instance, "init()" and "instance()". Since initializing
00153   # process is only performed by the "init()" function, the "init()" has
00154   # to be called at the beginning of the lifecycle of the Manager.
00155   # function.
00156   #
00157   # @param argv The array of the command line arguments.
00158   #
00159   # @endif
00160   def init(*arg):
00161     global manager
00162     global mutex
00163     
00164     if len(arg) == 1:
00165       argv = arg[0]
00166     elif len(arg) == 2 and \
00167              isinstance(arg[0], IntType) and \
00168              isinstance(arg[1], ListType):
00169       # for 0.4.x
00170       argv = arg[1]
00171     else:
00172       print "Invalid arguments for init()"
00173       print "init(argc,argv) or init(argv)"
00174         
00175     if manager is None:
00176       guard = OpenRTM_aist.ScopedLock(mutex)
00177       if manager is None:
00178         manager = Manager()
00179         manager.initManager(argv)
00180         manager.initLogger()
00181         manager.initORB()
00182         manager.initNaming()
00183         manager.initFactories()
00184         manager.initExecContext()
00185         manager.initComposite()
00186         manager.initTimer()
00187         manager.initManagerServant()
00188 
00189     return manager
00190   
00191   init = staticmethod(init)
00192 
00193 
00194   ##
00195   # @if jp
00196   # @brief マネージャのインスタンスの取得
00197   #
00198   # マネージャのインスタンスを取得する static 関数。
00199   # この関数を呼ぶ前に、必ずこの初期化関数 init() が呼ばれている必要がある。
00200   #
00201   # @return Manager の唯一のインスタンスの参照
00202   # 
00203   # @else
00204   #
00205   # @brief Get instance of the manager
00206   #
00207   # This is the static function to get the instance of the Manager.
00208   # Before calling this function, ensure that the initialization function
00209   # "init()" is called.
00210   #
00211   # @return The only instance reference of the manager
00212   #
00213   # @endif
00214   def instance():
00215     global manager
00216     global mutex
00217     
00218     if manager is None:
00219       guard = OpenRTM_aist.ScopedLock(mutex)
00220       if manager is None:
00221         manager = Manager()
00222         manager.initManager(None)
00223         manager.initLogger()
00224         manager.initORB()
00225         manager.initNaming()
00226         manager.initFactories()
00227         manager.initExecContext()
00228         manager.initComposite()
00229         manager.initTimer()
00230         #manager.initManagerServant()
00231 
00232     return manager
00233 
00234   instance = staticmethod(instance)
00235 
00236 
00237   ##
00238   # @if jp
00239   # @brief マネージャ終了処理
00240   #
00241   # マネージャの終了処理を実行する。
00242   #
00243   # @param self
00244   #
00245   # @else
00246   #
00247   # @endif
00248   def terminate(self):
00249     if self._terminator:
00250       self._terminator.terminate()
00251 
00252 
00253   ##
00254   # @if jp
00255   # @brief マネージャ・シャットダウン
00256   #
00257   # マネージャの終了処理を実行する。
00258   # ORB終了後、同期を取って終了する。
00259   #
00260   # @param self
00261   #
00262   # @else
00263   #
00264   # @endif
00265   def shutdown(self):
00266     self._rtcout.RTC_TRACE("Manager.shutdown()")
00267     self.shutdownComponents()
00268     self.shutdownNaming()
00269     self.shutdownORB()
00270     self.shutdownManager()
00271 
00272     if self._runner:
00273       self._runner.wait()
00274     else:
00275       self.join()
00276 
00277     self.shutdownLogger()
00278     global manager
00279     if manager:
00280       manager = None
00281 
00282 
00283   ##
00284   # @if jp
00285   # @brief マネージャ終了処理の待ち合わせ
00286   #
00287   # 同期を取るため、マネージャ終了処理の待ち合わせを行う。
00288   #
00289   # @param self
00290   #
00291   # @else
00292   #
00293   # @endif
00294   def join(self):
00295     self._rtcout.RTC_TRACE("Manager.wait()")
00296     guard = OpenRTM_aist.ScopedLock(self._terminate.mutex)
00297     self._terminate.waiting += 1
00298     del guard
00299     while 1:
00300       guard = OpenRTM_aist.ScopedLock(self._terminate.mutex)
00301       #if self._terminate.waiting > 1:
00302       if self._terminate.waiting > 0:
00303         break
00304       del guard
00305       time.sleep(0.001)
00306 
00307 
00308   ##
00309   # @if jp
00310   #
00311   # @brief 初期化プロシージャのセット
00312   #
00313   # このオペレーションはユーザが行うモジュール等の初期化プロシージャ
00314   # を設定する。ここで設定されたプロシージャは、マネージャが初期化され、
00315   # アクティブ化された後、適切なタイミングで実行される。
00316   #
00317   # @param self
00318   # @param proc 初期化プロシージャの関数ポインタ
00319   #
00320   # @else
00321   #
00322   # @brief Run the Manager
00323   #
00324   # This operation sets the initial procedure call to process module
00325   # initialization, other user defined initialization and so on.
00326   # The given procedure will be called at the proper timing after the 
00327   # manager initialization, activation and run.
00328   #
00329   # @param proc A function pointer to the initial procedure call
00330   #
00331   # @endif
00332   def setModuleInitProc(self, proc):
00333     self._initProc = proc
00334     return
00335 
00336 
00337   ##
00338   # @if jp
00339   #
00340   # @brief Managerのアクティブ化
00341   #
00342   # このオペレーションは以下の処理を行う
00343   # - CORBA POAManager のアクティブ化
00344   # - マネージャCORBAオブジェクトのアクティブ化
00345   # - Manager オブジェクトへの初期化プロシージャの実行
00346   #
00347   # このオペレーションは、マネージャの初期化後、runManager()
00348   # の前に呼ぶ必要がある。
00349   #
00350   # @param self
00351   #
00352   # @return 処理結果(アクティブ化成功:true、失敗:false)
00353   #
00354   # @else
00355   #
00356   # @brief Activate Manager
00357   #
00358   # This operation do the following,
00359   # - Activate CORBA POAManager
00360   # - Activate Manager CORBA object
00361   # - Execute the initial procedure call of the Manager
00362   #
00363   # This operationo should be invoked after Manager:init(),
00364   # and before tunManager().
00365   #
00366   # @endif
00367   def activateManager(self):
00368     self._rtcout.RTC_TRACE("Manager.activateManager()")
00369 
00370     try:
00371       self.getPOAManager().activate()
00372       self._rtcout.RTC_TRACE("POA Manager activated.")
00373     except:
00374       self._rtcout.RTC_ERROR("Exception: POA Manager activation failed.")
00375       self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
00376       return False
00377 
00378     mods = [s.strip() for s in self._config.getProperty("manager.modules.preload").split(",")]
00379 
00380     for i in range(len(mods)):
00381       if mods[i] is None or mods[i] == "":
00382         continue
00383       tmp = [mods[i]]
00384       OpenRTM_aist.eraseHeadBlank(tmp)
00385       OpenRTM_aist.eraseTailBlank(tmp)
00386       mods[i] = tmp[0]
00387 
00388       basename = os.path.basename(mods[i]).split(".")[0]
00389       basename += "Init"
00390 
00391       try:
00392         self._module.load(mods[i], basename)
00393       except:
00394         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
00395         self.__try_direct_load(basename)
00396 
00397     if self._initProc:
00398       self._initProc(self)
00399 
00400     comps = [s.strip() for s in self._config.getProperty("manager.components.precreate").split(",")]
00401     for i in range(len(comps)):
00402       if comps[i] is None or comps[i] == "":
00403         continue
00404       tmp = [comps[i]]
00405       OpenRTM_aist.eraseHeadBlank(tmp)
00406       OpenRTM_aist.eraseTailBlank(tmp)
00407       comps[i] = tmp[0]
00408 
00409       self.createComponent(comps[i])
00410 
00411     return True
00412 
00413 
00414   ##
00415   # @if jp
00416   #
00417   # @brief Managerの実行
00418   #
00419   # このオペレーションはマネージャのメインループを実行する。
00420   # このメインループ内では、CORBA ORBのイベントループ等が
00421   # 処理される。デフォルトでは、このオペレーションはブロックし、
00422   # Manager::destroy() が呼ばれるまで処理を戻さない。
00423   # 引数 no_block が true に設定されている場合は、内部でイベントループ
00424   # を処理するスレッドを起動し、ブロックせずに処理を戻す。
00425   #
00426   # @param self
00427   # @param no_block false: ブロッキングモード, true: ノンブロッキングモード
00428   #
00429   # @else
00430   #
00431   # @brief Run the Manager
00432   #
00433   # This operation processes the main event loop of the Manager.
00434   # In this main loop, CORBA's ORB event loop or other processes
00435   # are performed. As the default behavior, this operation is going to
00436   # blocking mode and never returns until manager::destroy() is called.
00437   # When the given argument "no_block" is set to "true", this operation
00438   # creates a thread to process the event loop internally, and it doesn't
00439   # block and returns.
00440   #
00441   # @param no_block false: Blocking mode, true: non-blocking mode.
00442   #
00443   # @endif
00444   def runManager(self, no_block=None):
00445     if no_block is None:
00446       no_block = False
00447       
00448     if no_block:
00449       self._rtcout.RTC_TRACE("Manager.runManager(): non-blocking mode")
00450       self._runner = self.OrbRunner(self._orb)
00451     else:
00452       self._rtcout.RTC_TRACE("Manager.runManager(): blocking mode")
00453       try:
00454         self._orb.run()
00455         self._rtcout.RTC_TRACE("Manager.runManager(): ORB was terminated")
00456         self.join()
00457       except:
00458         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
00459 
00460     return
00461 
00462 
00463   ##
00464   # @if jp
00465   # @brief [CORBA interface] モジュールのロード
00466   #
00467   # 指定したコンポーネントのモジュールをロードするとともに、
00468   # 指定した初期化関数を実行する。
00469   #
00470   # @param self
00471   # @param fname   モジュールファイル名
00472   # @param initfunc 初期化関数名
00473   # 
00474   # @else
00475   #
00476   # @brief [CORBA interface] Load module
00477   #
00478   # Load module (shared library, DLL etc..) by file name,
00479   # and invoke initialize function.
00480   #
00481   # @param fname    The module file name
00482   # @param initfunc The initialize function name
00483   #
00484   # @endif
00485   def load(self, fname, initfunc):
00486     self._rtcout.RTC_TRACE("Manager.load(fname = %s, initfunc = %s)",
00487                            (fname, initfunc))
00488     try:
00489       fname_ = fname.split(os.sep)
00490       if len(fname_) > 1:
00491         fname_ = fname_[-1]
00492       else:
00493         fname_ = fname_[0]
00494 
00495       if not initfunc:
00496         mod = [s.strip() for s in fname_.split(".")]
00497         initfunc = mod[0]+"Init"
00498       path = self._module.load(fname, initfunc)
00499       self._rtcout.RTC_DEBUG("module path: %s", path)
00500     except:
00501       self.__try_direct_load(fname)
00502 
00503     return
00504 
00505 
00506   ##
00507   # @if jp
00508   #
00509   # @brief モジュールのアンロード
00510   #
00511   # モジュールをアンロードする
00512   #
00513   # @param self
00514   # @param fname モジュールのファイル名
00515   # 
00516   # @else
00517   #
00518   # @brief Unload module
00519   #
00520   # Unload shared library.
00521   #
00522   # @param pathname Module file name
00523   #
00524   # @endif
00525   def unload(self, fname):
00526     self._rtcout.RTC_TRACE("Manager.unload()")
00527     self._module.unload(fname)
00528     return
00529 
00530 
00531   ##
00532   # @if jp
00533   #
00534   # @brief 全モジュールのアンロード
00535   #
00536   # モジュールをすべてアンロードする
00537   #
00538   # @param self
00539   #
00540   # @else
00541   #
00542   # @brief Unload module
00543   #
00544   # Unload all loaded shared library.
00545   #
00546   # @endif
00547   def unloadAll(self):
00548     self._rtcout.RTC_TRACE("Manager.unloadAll()")
00549     self._module.unloadAll()
00550     return
00551 
00552 
00553   ##
00554   # @if jp
00555   # @brief ロード済みのモジュールリストを取得する
00556   #
00557   # 現在マネージャにロードされているモジュールのリストを取得する。
00558   #
00559   # @param self
00560   #
00561   # @return ロード済みモジュールリスト
00562   #
00563   # @else
00564   # @brief Get loaded module names
00565   # @endif
00566   #  std::vector<coil::Properties> getLoadedModules();
00567   def getLoadedModules(self):
00568     self._rtcout.RTC_TRACE("Manager.getLoadedModules()")
00569     return self._module.getLoadedModules()
00570 
00571 
00572   ##
00573   # @if jp
00574   # @brief ロード可能なモジュールリストを取得する
00575   #
00576   # ロード可能モジュールのリストを取得する。
00577   # (現在はModuleManager側で未実装)
00578   #
00579   # @param self
00580   #
00581   # @return ロード可能モジュール　リスト
00582   #
00583   # @else
00584   # @brief Get loadable module names
00585   # @endif
00586   def getLoadableModules(self):
00587     self._rtcout.RTC_TRACE("Manager.getLoadableModules()")
00588     return self._module.getLoadableModules()
00589 
00590 
00591   #============================================================
00592   # Component Factory Management
00593   #============================================================
00594 
00595   ##
00596   # @if jp
00597   # @brief RTコンポーネント用ファクトリを登録する
00598   #
00599   # RTコンポーネントのインスタンスを生成するための
00600   # Factoryを登録する。
00601   #
00602   # @param self
00603   # @param profile RTコンポーネント プロファイル
00604   # @param new_func RTコンポーネント生成用関数
00605   # @param delete_func RTコンポーネント破棄用関数
00606   #
00607   # @return 登録処理結果(登録成功:true、失敗:false)
00608   #
00609   # @else
00610   # @brief Register RT-Component Factory
00611   # @endif
00612   def registerFactory(self, profile, new_func, delete_func):
00613     self._rtcout.RTC_TRACE("Manager.registerFactory(%s)", profile.getProperty("type_name"))
00614     try:
00615       factory = OpenRTM_aist.FactoryPython(profile, new_func, delete_func)
00616       self._factory.registerObject(factory)
00617       return True
00618     except:
00619       self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
00620       return False
00621 
00622     return
00623 
00624 
00625   ##
00626   # @if jp
00627   # @brief ファクトリのプロファイルを取得
00628   #
00629   # ファクトリのプロファイルを取得する。
00630   #
00631   # @return ファクトリのプロファイル
00632   #
00633   # @else
00634   # @brief Get profiles of factories. 
00635   #
00636   # Get profiles of factories. 
00637   #
00638   # @return profiles of factories
00639   #
00640   # @endif
00641   #
00642   def getFactoryProfiles(self):
00643     factories = self._factory.getObjects()
00644 
00645     if not factories:
00646       return []
00647       
00648     props = []
00649     for factory in factories:
00650       props.append(factory.profile())
00651 
00652     return props
00653 
00654 
00655   ##
00656   # @if jp
00657   # @brief ExecutionContext用ファクトリを登録する
00658   #
00659   # ExecutionContextのインスタンスを生成するためのFactoryを登録する。
00660   #
00661   # @param self
00662   # @param name 生成対象ExecutionContext名称
00663   # @param new_func ExecutionContext生成用関数
00664   # @param delete_func ExecutionContext破棄用関数
00665   #
00666   # @return 登録処理結果(登録成功:true、失敗:false)
00667   #
00668   # @else
00669   # @brief Register ExecutionContext Factory
00670   # @endif
00671   def registerECFactory(self, name, new_func, delete_func):
00672     self._rtcout.RTC_TRACE("Manager.registerECFactory(%s)", name)
00673     try:
00674       self._ecfactory.registerObject(OpenRTM_aist.ECFactoryPython(name, new_func, delete_func))
00675       return True
00676     except:
00677       self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
00678       return False
00679 
00680     return False
00681 
00682 
00683   ##
00684   # @if jp
00685   # @brief ファクトリ全リストを取得する
00686   #
00687   # 登録されているファクトリの全リストを取得する。
00688   #
00689   # @param self
00690   #
00691   # @return 登録ファクトリ リスト
00692   #
00693   # @else
00694   # @brief Get the list of all RT-Component Factory
00695   # @endif
00696   def getModulesFactories(self):
00697     self._rtcout.RTC_TRACE("Manager.getModulesFactories()")
00698 
00699     self._modlist = []
00700     for _obj in self._factory._objects._obj:
00701       self._modlist.append(_obj.profile().getProperty("implementation_id"))
00702     return self._modlist
00703 
00704 
00705   #============================================================
00706   # Component management
00707   #============================================================
00708 
00709   ##
00710   # @if jp
00711   # @brief RTコンポーネントを生成する
00712   #
00713   # 指定したRTコンポーネントのインスタンスを登録されたFactory経由
00714   # で生成する。
00715   #
00716   # 生成されるコンポーネントの各種プロファイルは以下の優先順位で
00717   # 設定される。
00718   #
00719   # -# createComponent() の引数で与えられたプロファイル
00720   # -# rtc.confで指定された外部ファイルで与えられたプロファイル
00721   # --# category.instance_name.config_file
00722   # --# category.component_type.config_file
00723   # -# コードに埋め込まれたプロファイル 
00724   #
00725   # インスタンス生成が成功した場合、併せて以下の処理を実行する。
00726   #  - 外部ファイルで設定したコンフィギュレーション情報の読み込み，設定
00727   #  - ExecutionContextのバインド，動作開始
00728   #  - ネーミングサービスへの登録
00729   #
00730   # @param comp_args 生成対象RTコンポーネントIDおよびコンフィギュレー
00731   # ション引数。フォーマットは大きく分けて "id" と "configuration" 
00732   # 部分が存在する。
00733   #
00734   # comp_args:     [id]?[configuration]
00735   #                id は必須、configurationはオプション
00736   # id:            RTC:[vendor]:[category]:[implementation_id]:[version]
00737   #                RTC は固定かつ必須
00738   #                vendor, category, version はオプション
00739   #                implementation_id は必須
00740   #                オプションを省略する場合でも ":" は省略不可
00741   # configuration: [key0]=[value0]&[key1]=[value1]&[key2]=[value2].....
00742   #                RTCが持つPropertiesの値をすべて上書きすることができる。
00743   #                key=value の形式で記述し、"&" で区切る
00744   #
00745   # 例えば、
00746   # RTC:jp.go.aist:example:ConfigSample:1.0?conf.default.str_param0=munya
00747   # RTC::example:ConfigSample:?conf.default.int_param0=100
00748   #
00749   # @return 生成したRTコンポーネントのインスタンス
00750   #
00751   # @else
00752   # @brief Create RT-Components
00753   #
00754   # Create specified RT-Component's instances via registered Factory.
00755   # When its instances have been created successfully, the following
00756   # processings are also executed.
00757   #  - Read and set configuration information that was set by external file.
00758   #  - Bind ExecutionContext and start operation.
00759   #  - Register to naming service.
00760   #
00761   # @param module_name Target RT-Component names for the creation
00762   #
00763   # @return Created RT-Component's instances
00764   #
00765   # @endif
00766   #
00767   def createComponent(self, comp_args):
00768     self._rtcout.RTC_TRACE("Manager.createComponent(%s)", comp_args)
00769     comp_prop = OpenRTM_aist.Properties()
00770     comp_id   = OpenRTM_aist.Properties()
00771 
00772     print "comp_args:", comp_args
00773     if not self.procComponentArgs(comp_args, comp_id, comp_prop):
00774       return None
00775 
00776     if comp_prop.findNode("exported_ports"):
00777       exported_ports = OpenRTM_aist.split(comp_prop.getProperty("exported_ports"),
00778                                           ",")
00779       exported_ports_str = ""
00780       for i in range(len(exported_ports)):
00781         keyval = OpenRTM_aist.split(exported_ports[i], ".")
00782         if len(keyval) > 2:
00783           exported_ports_str += (keyval[0] + "." + keyval[-1])
00784         else:
00785           exported_ports_str += exported_ports[i]
00786 
00787         if i != (len(exported_ports) - 1) :
00788           exported_ports_str += ","
00789 
00790       comp_prop.setProperty("exported_ports", exported_ports_str)
00791       comp_prop.setProperty("conf.default.exported_ports", exported_ports_str)
00792 
00793     factory = self._factory.find(comp_id)
00794     if factory is None:
00795       self._rtcout.RTC_ERROR("createComponent: Factory not found: %s",
00796                              comp_id.getProperty("implementation_id"))
00797 
00798       # automatic module loading
00799       mp = self._module.getLoadableModules()
00800       self._rtcout.RTC_INFO("%d loadable modules found", len(mp))
00801 
00802       found_obj = None
00803       predicate = self.ModulePredicate(comp_id)
00804       for _obj in mp:
00805         if predicate(_obj):
00806           found_obj = _obj
00807           break
00808 
00809       if not found_obj:
00810         self._rtcout.RTC_ERROR("No module for %s in loadable modules list",
00811                                comp_id.getProperty("implementation_id"))
00812         return None
00813 
00814       if not found_obj.findNode("module_file_name"):
00815         self._rtcout.RTC_ERROR("Hmm...module_file_name key not found.")
00816         return 0
00817 
00818       # module loading
00819       self._rtcout.RTC_INFO("Loading module: %s", found_obj.getProperty("module_file_name"))
00820       self.load(found_obj.getProperty("module_file_name"), "")
00821       factory = self._factory.find(comp_id)
00822       if not factory:
00823         self._rtcout.RTC_ERROR("Factory not found for loaded module: %s",
00824                                comp_id.getProperty("implementation_id"))
00825         return 0
00826 
00827 
00828     # get default configuration of component.
00829     prop = factory.profile()
00830 
00831     inherit_prop = ["config.version",
00832                     "openrtm.name",
00833                     "openrtm.version",
00834                     "os.name",
00835                     "os.release",
00836                     "os.version",
00837                     "os.arch",
00838                     "os.hostname",
00839                     "corba.endpoint",
00840                     "corba.id",
00841                     "exec_cxt.periodic.type",
00842                     "exec_cxt.periodic.rate",
00843                     "exec_cxt.evdriven.type",
00844                     "logger.enable",
00845                     "logger.log_level",
00846                     "naming.enable",
00847                     "naming.type",
00848                     "naming.formats"]
00849 
00850     for i in range(len(inherit_prop)):
00851       prop.setProperty(inherit_prop[i],self._config.getProperty(inherit_prop[i]))
00852 
00853     comp = factory.create(self)
00854 
00855     if comp is None:
00856       self._rtcout.RTC_ERROR("createComponent: RTC creation failed: %s",
00857                              comp_id.getProperty("implementation_id"))
00858       return None
00859     self._rtcout.RTC_TRACE("RTC Created: %s", comp_id.getProperty("implementation_id"))
00860 
00861     # The property specified by the parameter of createComponent() is merged.
00862     # The property("instance_name") specified by the parameter of createComponent()
00863     # must be merged here.
00864     prop.mergeProperties(comp_prop)
00865 
00866     #------------------------------------------------------------
00867     # Load configuration file specified in "rtc.conf"
00868     #
00869     # rtc.conf:
00870     #   [category].[type_name].config_file = file_name
00871     #   [category].[instance_name].config_file = file_name
00872     self.configureComponent(comp,prop)
00873 
00874     # The property specified by the parameter of createComponent() is set.
00875     # The property("exported_ports") specified by the parameter of createComponent()
00876     # must be set here.
00877     #comp.setProperties(comp_prop)
00878 
00879     # Component initialization
00880     if comp.initialize() != RTC.RTC_OK:
00881       self._rtcout.RTC_TRACE("RTC initialization failed: %s",
00882                              comp_id.getProperty("implementation_id"))
00883       comp.exit()
00884       self._rtcout.RTC_TRACE("%s was finalized", comp_id.getProperty("implementation_id"))
00885       return None
00886       
00887     self._rtcout.RTC_TRACE("RTC initialization succeeded: %s",
00888                            comp_id.getProperty("implementation_id"))
00889     self.registerComponent(comp)
00890     return comp
00891 
00892 
00893 
00894   ##
00895   # @if jp
00896   # @brief RTコンポーネントを直接 Manager に登録する
00897   #
00898   # 指定したRTコンポーネントのインスタンスをファクトリ経由ではなく
00899   # 直接マネージャに登録する。
00900   #
00901   # @param self
00902   # @param comp 登録対象RTコンポーネントのインスタンス
00903   #
00904   # @return 登録処理結果(登録成功:true、失敗:false)
00905   #
00906   # @else
00907   # @brief Register RT-Component directly without Factory
00908   # @endif
00909   def registerComponent(self, comp):
00910     self._rtcout.RTC_TRACE("Manager.registerComponent(%s)", comp.getInstanceName())
00911 
00912     self._compManager.registerObject(comp)
00913     names = comp.getNamingNames()
00914 
00915     for name in names:
00916       self._rtcout.RTC_TRACE("Bind name: %s", name)
00917       self._namingManager.bindObject(name, comp)
00918 
00919     return True
00920 
00921   
00922   ##
00923   # @if jp
00924   # @brief RTコンポーネントの登録を解除する
00925   #
00926   # 指定したRTコンポーネントの登録を解除する。
00927   #
00928   # @param self
00929   # @param comp 登録解除対象RTコンポーネントのインスタンス
00930   #
00931   # @return 登録解除処理結果(解除成功:true、解除失敗:false)
00932   #
00933   # @else
00934   # @brief Register RT-Component directly without Factory
00935   # @endif
00936   def unregisterComponent(self, comp):
00937     self._rtcout.RTC_TRACE("Manager.unregisterComponent(%s)", comp.getInstanceName())
00938     self._compManager.unregisterObject(comp.getInstanceName())
00939     names = comp.getNamingNames()
00940     
00941     for name in names:
00942       self._rtcout.RTC_TRACE("Unbind name: %s", name)
00943       self._namingManager.unbindObject(name)
00944 
00945     return True
00946 
00947 
00948   ##
00949   # @if jp
00950   # @brief Contextを生成する
00951   #
00952   # @return 生成したConetextのインスタンス
00953   #
00954   # @else
00955   # @brief Create Context
00956   #
00957   # @return Created Context's instances
00958   #
00959   # @endif
00960   #
00961   # ExecutionContextBase* createContext(const char* ec_args);
00962   def createContext(self, ec_args):
00963     self._rtcout.RTC_TRACE("Manager.createContext()")
00964     self._rtcout.RTC_TRACE("ExecutionContext type: %s",
00965                            self._config.getProperty("exec_cxt.periodic.type"))
00966     ec_id = [""]
00967     ec_prop = OpenRTM_aist.Properties()
00968 
00969     if not self.procContextArgs(ec_args, ec_id, ec_prop):
00970       return None
00971 
00972     factory = self._ecfactory.find(ec_id[0])
00973 
00974     if factory == None:
00975       self._rtcout.RTC_ERROR("Factory not found: %s", ec_id[0])
00976       return None
00977 
00978     ec = factory.create()
00979     return ec
00980     
00981 
00982   ##
00983   # @if jp
00984   # @brief Manager に登録されているRTコンポーネントを削除する(未実装)
00985   #
00986   # マネージャに登録されているRTコンポーネントを削除する。
00987   #
00988   # @param self
00989   # @param instance_name 削除対象RTコンポーネントのインスタンス名
00990   #
00991   # @else
00992   # @brief Unregister RT-Component that is registered in the Manager
00993   # @endif
00994   def deleteComponent(self, instance_name=None, comp=None):
00995     if instance_name:
00996       self._rtcout.RTC_TRACE("Manager.deleteComponent(%s)", instance_name)
00997       _comp = self._compManager.find(instance_name)
00998       if _comp is None:
00999         self._rtcout.RTC_WARN("RTC %s was not found in manager.", instance_name)
01000         return
01001       self.deleteComponent(comp=_comp)
01002 
01003     elif comp:
01004       self._rtcout.RTC_TRACE("Manager.deleteComponent(RTObject_impl)")
01005       # cleanup from manager's table, and naming serivce
01006       self.unregisterComponent(comp)
01007       
01008       comp_id = comp.getProperties()
01009       factory = self._factory.find(comp_id)
01010 
01011       if not factory:
01012         self._rtcout.RTC_DEBUG("Factory not found: %s",
01013                                comp_id.getProperty("implementation_id"))
01014         return
01015       else:
01016         self._rtcout.RTC_DEBUG("Factory found: %s",
01017                                comp_id.getProperty("implementation_id"))
01018         factory.destroy(comp)
01019         
01020 
01021       if OpenRTM_aist.toBool(self._config.getProperty("manager.shutdown_on_nortcs"),
01022                              "YES","NO",True) and \
01023                              not OpenRTM_aist.toBool(self._config.getProperty("manager.is_master"),
01024                                                      "YES","NO",False):
01025         comps = self.getComponents()
01026         if len(comps) == 0:
01027           self.shutdown()
01028 
01029     return
01030 
01031 
01032   ##
01033   # @if jp
01034   # @brief Manager に登録されているRTコンポーネントを検索する
01035   #
01036   # Manager に登録されているRTコンポーネントを指定した名称で検索し、
01037   # 合致するコンポーネントを取得する。
01038   #
01039   # @param self
01040   # @param instance_name 検索対象RTコンポーネントの名称
01041   #
01042   # @return 名称が一致するRTコンポーネントのインスタンス
01043   #
01044   # @else
01045   # @brief Get RT-Component's pointer
01046   # @endif
01047   def getComponent(self, instance_name):
01048     self._rtcout.RTC_TRACE("Manager.getComponent(%s)", instance_name)
01049     return self._compManager.find(instance_name)
01050 
01051 
01052   ##
01053   # @if jp
01054   # @brief Manager に登録されている全RTコンポーネントを取得する
01055   #
01056   # Manager に登録されているRTコンポーネントの全インスタンスを取得する。
01057   #
01058   # @param self
01059   #
01060   # @return 全RTコンポーネントのインスタンスリスト
01061   #
01062   # @else
01063   # @brief Get all RT-Component's pointer
01064   # @endif
01065   def getComponents(self):
01066     self._rtcout.RTC_TRACE("Manager.getComponents()")
01067     return self._compManager.getObjects()
01068 
01069 
01070   #============================================================
01071   # CORBA 関連
01072   #============================================================
01073 
01074   ##
01075   # @if jp
01076   # @brief ORB のポインタを取得する
01077   #
01078   # Manager に設定された ORB のポインタを取得する。
01079   #
01080   # @param self
01081   #
01082   # @return ORB オブジェクト
01083   #
01084   # @else
01085   # @brief Get the pointer to the ORB
01086   # @endif
01087   def getORB(self):
01088     self._rtcout.RTC_TRACE("Manager.getORB()")
01089     return self._orb
01090 
01091 
01092   ##
01093   # @if jp
01094   # @brief Manager が持つ RootPOA のポインタを取得する
01095   #
01096   # Manager に設定された RootPOA へのポインタを取得する。
01097   #
01098   # @param self
01099   #
01100   # @return RootPOAオブジェクト
01101   #
01102   # @else
01103   # @brief Get the pointer to the RootPOA 
01104   # @endif
01105   def getPOA(self):
01106     self._rtcout.RTC_TRACE("Manager.getPOA()")
01107     return self._poa
01108 
01109 
01110   ##
01111   # @if jp
01112   # @brief Manager が持つ POAManager を取得する
01113   #
01114   # Manager に設定された POAMAnager を取得する。
01115   #
01116   # @param self
01117   #
01118   # @return POAマネージャ
01119   #
01120   # @else
01121   #
01122   # @endif
01123   def getPOAManager(self):
01124     self._rtcout.RTC_TRACE("Manager.getPOAManager()")
01125     return self._poaManager
01126 
01127 
01128 
01129   #============================================================
01130   # Manager initialize and finalization
01131   #============================================================
01132 
01133   ##
01134   # @if jp
01135   # @brief Manager の内部初期化処理
01136   # 
01137   # Manager の内部初期化処理を実行する。
01138   #  - Manager コンフィギュレーションの設定
01139   #  - ログ出力ファイルの設定
01140   #  - 終了処理用スレッドの生成
01141   #  - タイマ用スレッドの生成(タイマ使用時)
01142   #
01143   # @param self
01144   # @param argv コマンドライン引数
01145   # 
01146   # @else
01147   # @brief Manager internal initialization
01148   # @endif
01149   def initManager(self, argv):
01150     config = OpenRTM_aist.ManagerConfig(argv)
01151     self._config = OpenRTM_aist.Properties()
01152     config.configure(self._config)
01153     self._config.setProperty("logger.file_name",self.formatString(self._config.getProperty("logger.file_name"), 
01154                                                                   self._config))
01155     self._module = OpenRTM_aist.ModuleManager(self._config)
01156     self._terminator = self.Terminator(self)
01157     guard = OpenRTM_aist.ScopedLock(self._terminate.mutex)
01158     self._terminate.waiting = 0
01159     del guard
01160 
01161     if OpenRTM_aist.toBool(self._config.getProperty("timer.enable"), "YES", "NO", True):
01162       tm = OpenRTM_aist.TimeValue(0, 100000)
01163       tick = self._config.getProperty("timer.tick")
01164       if tick != "":
01165         tm = tm.set_time(float(tick))
01166         if self._timer:
01167           self._timer.stop()
01168           self._timer.join()
01169         self._timer = OpenRTM_aist.Timer(tm)
01170         self._timer.start()
01171 
01172     if OpenRTM_aist.toBool(self._config.getProperty("manager.shutdown_auto"),
01173                            "YES", "NO", True) and \
01174                            not OpenRTM_aist.toBool(self._config.getProperty("manager.is_master"),
01175                                                    "YES", "NO", False):
01176       tm = OpenRTM_aist.TimeValue(10, 0)
01177       if self._config.findNode("manager.auto_shutdown_duration"):
01178         duration = float(self._config.getProperty("manager.auto_shutdown_duration"))
01179         if duration:
01180           tm.set_time(duration)
01181 
01182       if self._timer:
01183         self._timer.registerListenerObj(self,
01184                                         OpenRTM_aist.Manager.shutdownOnNoRtcs,
01185                                         tm)
01186     
01187     if self._timer:
01188       tm = OpenRTM_aist.TimeValue(1, 0)
01189       self._timer.registerListenerObj(self,
01190                                       OpenRTM_aist.Manager.cleanupComponents,
01191                                       tm)
01192 
01193     return
01194 
01195 
01196   ##
01197   # @if jp
01198   # @brief Manager の終了処理(未実装)
01199   #
01200   # Manager を終了する
01201   # (ただし，現在は未実装)
01202   #
01203   # @param self
01204   #
01205   # @else
01206   #
01207   # @endif
01208   def shutdownManager(self):
01209     self._rtcout.RTC_TRACE("Manager.shutdownManager()")
01210     if self._timer:
01211       self._timer.stop()
01212       self._timer.join()
01213       self._timer = None
01214 
01215     return
01216 
01217 
01218   ##
01219   # @if jp
01220   # @brief Manager の終了処理
01221   #
01222   # configuration の "manager.shutdown_on_nortcs" YES で、
01223   # コンポーネントが登録されていない場合 Manager を終了する。
01224   #
01225   # @else
01226   # @brief Shutdown Manager
01227   #
01228   # This method shutdowns Manager as follows.
01229   # - "Manager.shutdown_on_nortcs" of configuration is YES. 
01230   # - The component is not registered. 
01231   #
01232   # @endif
01233   #
01234   # void shutdownOnNoRtcs();
01235   def shutdownOnNoRtcs(self):
01236     self._rtcout.RTC_TRACE("Manager::shutdownOnNoRtcs()")
01237     if OpenRTM_aist.toBool(self._config.getProperty("manager.shutdown_on_nortcs"),
01238                            "YES", "NO", True):
01239 
01240       comps = self.getComponents()
01241       
01242       if len(comps) == 0:
01243         self.shutdown()
01244 
01245     return
01246 
01247 
01248   #============================================================
01249   # Logger initialize and terminator
01250   #============================================================
01251 
01252   ##
01253   # @if jp
01254   # @brief System logger の初期化
01255   #
01256   # System logger の初期化を実行する。
01257   # コンフィギュレーションファイルに設定された情報に基づき、
01258   # ロガーの初期化，設定を実行する。
01259   #
01260   # @param self
01261   #
01262   # @return 初期化実行結果(初期化成功:true、初期化失敗:false)
01263   #
01264   # @else
01265   # @brief System logger initialization
01266   # @endif
01267   def initLogger(self):
01268 
01269     if not OpenRTM_aist.toBool(self._config.getProperty("logger.enable"), "YES", "NO", True):
01270       self._rtcout = OpenRTM_aist.LogStream()
01271       return True
01272 
01273     logfile = "./rtc.log"
01274 
01275     logouts = self._config.getProperty("logger.file_name")
01276     logouts = [s.strip() for s in logouts.split(",")]
01277     
01278     self._rtcout = None
01279 
01280     for i in range(len(logouts)):
01281       tmp = [logouts[i]]
01282       OpenRTM_aist.eraseHeadBlank(tmp)
01283       OpenRTM_aist.eraseTailBlank(tmp)
01284       logouts[i] = tmp[0]
01285       if logouts[i].lower() == "stdout":
01286         if self._rtcout is None:
01287           self._rtcout = OpenRTM_aist.LogStream("manager","STDOUT")
01288         else:
01289           self._rtcout.addHandler(logouts[i])
01290       else:
01291         if logouts[i] == "":
01292           logfile = "./rtc.log"
01293         else:
01294           logfile = logouts[i]
01295           
01296         if self._rtcout is None:
01297           self._rtcout = OpenRTM_aist.LogStream("manager","FILE", logfile)
01298         else:
01299           self._rtcout.addHandler("FILE",logfile)
01300 
01301     self._rtcout.setLogLevel(self._config.getProperty("logger.log_level"))
01302     self._rtcout.setLogLock(OpenRTM_aist.toBool(self._config.getProperty("logger.stream_lock"),
01303                                                 "enable", "disable", False))
01304 
01305     self._rtcout.RTC_INFO("%s", self._config.getProperty("openrtm.version"))
01306     self._rtcout.RTC_INFO("Copyright (C) 2003-2010")
01307     self._rtcout.RTC_INFO("  Noriaki Ando")
01308     self._rtcout.RTC_INFO("  Intelligent Systems Research Institute, AIST")
01309     self._rtcout.RTC_INFO("Manager starting.")
01310     self._rtcout.RTC_INFO("Starting local logging.")
01311 
01312     return True
01313 
01314 
01315   ##
01316   # @if jp
01317   # @brief System Logger の終了処理(未実装)
01318   #
01319   # System Loggerの終了処理を実行する。
01320   # (現在は未実装)
01321   #
01322   # @param self
01323   #
01324   # @else
01325   # @brief System Logger finalization
01326   # @endif
01327   def shutdownLogger(self):
01328     self._rtcout.RTC_TRACE("Manager.shutdownLogger()")
01329     self._rtcout.shutdown()
01330     return
01331 
01332 
01333   #============================================================
01334   # ORB initialization and finalization
01335   #============================================================
01336 
01337   ##
01338   # @if jp
01339   # @brief CORBA ORB の初期化処理
01340   #
01341   # 設定情報を元にORBを初期化する。
01342   #
01343   # @param self
01344   #
01345   # @return ORB 初期化処理結果(初期化成功:true、初期化失敗:false)
01346   #
01347   # @else
01348   # @brief CORBA ORB initialization
01349   # @endif
01350   def initORB(self):
01351     self._rtcout.RTC_TRACE("Manager.initORB()")
01352     try:
01353       args = OpenRTM_aist.split(self.createORBOptions(), " ")
01354       args.insert(0,"manager")
01355       argv = OpenRTM_aist.toArgv(args)
01356       self._orb = CORBA.ORB_init(argv)
01357 
01358       self._poa = self._orb.resolve_initial_references("RootPOA")
01359       if CORBA.is_nil(self._poa):
01360         self._rtcout.RTC_ERROR("Could not resolve RootPOA")
01361         return False
01362 
01363       self._poaManager = self._poa._get_the_POAManager()
01364 
01365     except:
01366       self._rtcout.RTC_ERROR("Exception: Caught unknown exception in initORB().")
01367       self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01368       return False
01369 
01370     return True
01371 
01372 
01373   ##
01374   # @if jp
01375   # @brief ORB のコマンドラインオプション作成
01376   #
01377   # コンフィギュレーション情報に設定された内容から
01378   # ORB の起動時オプションを作成する。
01379   #
01380   # @param self
01381   #
01382   # @return ORB 起動時オプション
01383   #
01384   # @else
01385   # @brief ORB command option creation
01386   # @endif
01387   def createORBOptions(self):
01388     opt      = self._config.getProperty("corba.args")
01389     self._rtcout.RTC_DEBUG("corba.args: %s",opt)
01390 
01391     endpoints = []
01392     self.createORBEndpoints(endpoints)
01393     opt = [opt]
01394     self.createORBEndpointOption(opt,endpoints)
01395 
01396     self._rtcout.RTC_PARANOID("ORB options: %s", opt[0])
01397 
01398     return opt[0]
01399 
01400 
01401   ##
01402   # @if jp
01403   # @brief エンドポイントの生成
01404   #
01405   # コンフィグレーションからエンドポイントを生成する。
01406   #
01407   # @param endpoints エンドポイントリスト
01408   #
01409   # @else
01410   # @brief Create Endpoints
01411   #
01412   # Create Endpoints from the configuration.
01413   # 
01414   # @param endpoints Endpoints list
01415   #
01416   # @endif
01417   #
01418   # void createORBEndpoints(coil::vstring& endpoints);
01419   def createORBEndpoints(self, endpoints):
01420 
01421     # corba.endpoint is obsolete
01422     # corba.endpoints with comma separated values are acceptable
01423     if self._config.findNode("corba.endpoints"):
01424       endpoints_ = [s.strip() for s in self._config.getProperty("corba.endpoints").split(",")]
01425       for ep in endpoints_:
01426         endpoints.append(ep)
01427 
01428       self._rtcout.RTC_DEBUG("corba.endpoints: %s", self._config.getProperty("corba.endpoints"))
01429 
01430     if self._config.findNode("corba.endpoint"):
01431       endpoints_ = [s.strip() for s in self._config.getProperty("corba.endpoint").split(",")]
01432       for ep in endpoints_:
01433         endpoints.append(ep)
01434       self._rtcout.RTC_DEBUG("corba.endpoint: %s", self._config.getProperty("corba.endpoint"))
01435 
01436     # If this process has master manager,
01437     # master manager's endpoint inserted at the top of endpoints
01438     self._rtcout.RTC_DEBUG("manager.is_master: %s",
01439                            self._config.getProperty("manager.is_master"))
01440 
01441     if OpenRTM_aist.toBool(self._config.getProperty("manager.is_master"), "YES", "NO", False):
01442       mm = self._config.getProperty("corba.master_manager", ":2810")
01443       mmm = [s.strip() for s in mm.split(":")]
01444       if len(mmm) == 2:
01445         endpoints.insert(0, ":" + mmm[1])
01446       else:
01447         endpoints.insert(0, ":2810")
01448 
01449     endpoints = OpenRTM_aist.unique_sv(endpoints)
01450     
01451     return
01452 
01453     
01454   ##
01455   # @if jp
01456   # @brief ORB の Endpoint のコマンドラインオプション作成
01457   # @param opt コマンドラインオプション
01458   # @param endpoints エンドポイントリスト
01459   #
01460   # @else
01461   # @brief Create a command optional line of Endpoint of ORB.
01462   # @param opt ORB options
01463   # @param endpoints Endpoints list
01464   #
01465   # @endif
01466   # void createORBEndpointOption(std::string& opt, coil::vstring& endpoints);
01467   def createORBEndpointOption(self, opt, endpoints):
01468     corba = self._config.getProperty("corba.id")
01469     self._rtcout.RTC_DEBUG("corba.id: %s", corba)
01470 
01471     for i in range(len(endpoints)):
01472       if endpoints[i]:
01473         endpoint = endpoints[i]
01474       else:
01475         continue
01476 
01477       self._rtcout.RTC_DEBUG("Endpoint is : %s", endpoint)
01478       if endpoint.find(":") == -1:
01479         endpoint += ":"
01480 
01481       if corba == "omniORB":
01482         endpoint = OpenRTM_aist.normalize([endpoint])
01483         if OpenRTM_aist.normalize([endpoint]) == "all:":
01484           opt[0] += " -ORBendPointPublishAllIFs 1"
01485         else:
01486           opt[0] += " -ORBendPoint giop:tcp:" + endpoint
01487 
01488       elif corba == "TAO":
01489         opt[0] += "-ORBEndPoint iiop://" + endpoint
01490       elif corba == "MICO":
01491         opt[0] += "-ORBIIOPAddr inet:" + endpoint
01492 
01493       endpoints[i] = endpoint
01494 
01495     return
01496 
01497 
01498   ##
01499   # @if jp
01500   # @brief ORB の終了処理
01501   #
01502   # ORB の終了処理を実行する。
01503   # 実行待ちの処理が存在する場合には、その処理が終了するまで待つ。
01504   # 実際の終了処理では、POA Managerを非活性化し、 ORB のシャットダウンを実行
01505   # する。
01506   #
01507   # @param self
01508   #
01509   # @else
01510   # @brief ORB finalization
01511   # @endif
01512   def shutdownORB(self):
01513     self._rtcout.RTC_TRACE("Manager.shutdownORB()")
01514     if not self._orb:
01515       return
01516 
01517     try:
01518       while self._orb.work_pending():
01519         self._rtcout.RTC_PARANOID("Pending work still exists.")
01520         if self._orb.work_pending():
01521             self._orb.perform_work()
01522             pass
01523 
01524       self._rtcout.RTC_DEBUG("No pending works of ORB. Shutting down POA and ORB.")
01525     except:
01526       self._rtcout.RTC_TRACE(OpenRTM_aist.Logger.print_exception())
01527       pass
01528 
01529     if not CORBA.is_nil(self._poa):
01530       try:
01531         if not CORBA.is_nil(self._poaManager):
01532           self._poaManager.deactivate(False, True)
01533         self._rtcout.RTC_DEBUG("POA Manager was deactivated.")
01534         self._poa.destroy(False, True)
01535         self._poa = PortableServer.POA._nil
01536         self._rtcout.RTC_DEBUG("POA was destroyed.")
01537       except CORBA.SystemException, ex:
01538         self._rtcout.RTC_ERROR("Caught SystemException during root POA destruction")
01539         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01540       except:
01541         self._rtcout.RTC_ERROR("Caught unknown exception during destruction")
01542         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01543 
01544     if self._orb:
01545       try:
01546         self._orb.shutdown(True)
01547         self._rtcout.RTC_DEBUG("ORB was shutdown.")
01548         self._orb = CORBA.Object._nil
01549       except CORBA.SystemException, ex:
01550         self._rtcout.RTC_ERROR("Caught CORBA::SystemException during ORB shutdown.")
01551         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01552       except:
01553         self._rtcout.RTC_ERROR("Caught unknown exception during ORB shutdown.")
01554         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01555 
01556 
01557   #============================================================
01558   # NamingService initialization and finalization
01559   #============================================================
01560 
01561   ##
01562   # @if jp
01563   # @brief NamingManager の初期化
01564   #
01565   # NamingManager の初期化処理を実行する。
01566   # ただし、 NamingManager を使用しないようにプロパティ情報に設定されている
01567   # 場合には何もしない。
01568   # NamingManager を使用する場合、プロパティ情報に設定されている
01569   # デフォルト NamingServer を登録する。
01570   # また、定期的に情報を更新するように設定されている場合には、指定された周期
01571   # で自動更新を行うためのタイマを起動するとともに、更新用メソッドをタイマに
01572   # 登録する。
01573   #
01574   # @param self
01575   #
01576   # @return 初期化処理結果(初期化成功:true、初期化失敗:false)
01577   #
01578   # @else
01579   #
01580   # @endif
01581   def initNaming(self):
01582     self._rtcout.RTC_TRACE("Manager.initNaming()")
01583     self._namingManager = OpenRTM_aist.NamingManager(self)
01584 
01585     if not OpenRTM_aist.toBool(self._config.getProperty("naming.enable"), "YES", "NO", True):
01586       return True
01587 
01588     meths = OpenRTM_aist.split(self._config.getProperty("naming.type"),",")
01589     
01590     for meth in meths:
01591       names = OpenRTM_aist.split(self._config.getProperty(meth+".nameservers"), ",")
01592       for name in names:
01593         self._rtcout.RTC_TRACE("Register Naming Server: %s/%s", (meth, name))
01594         self._namingManager.registerNameServer(meth,name)
01595 
01596     if OpenRTM_aist.toBool(self._config.getProperty("naming.update.enable"), "YES", "NO", True):
01597       tm = OpenRTM_aist.TimeValue(10,0)
01598       intr = self._config.getProperty("naming.update.interval")
01599       if intr != "":
01600         tm = OpenRTM_aist.TimeValue(intr)
01601 
01602       if self._timer:
01603         self._timer.registerListenerObj(self._namingManager,OpenRTM_aist.NamingManager.update,tm)
01604   
01605     return True
01606 
01607 
01608   ##
01609   # @if jp
01610   # @brief NamingManager の終了処理
01611   #
01612   # NamingManager を終了する。
01613   # 登録されている全要素をアンバインドし、終了する。
01614   #
01615   # @param self
01616   #
01617   # @else
01618   #
01619   # @endif
01620   def shutdownNaming(self):
01621     self._rtcout.RTC_TRACE("Manager.shutdownNaming()")
01622     self._namingManager.unbindAll()
01623 
01624 
01625   ##
01626   # @if jp
01627   # @brief ExecutionContextManager の初期化
01628   #
01629   # 使用する各 ExecutionContext の初期化処理を実行し、各 ExecutionContext 
01630   # 生成用 Factory を ExecutionContextManager に登録する。
01631   #
01632   # @param self
01633   #
01634   # @return ExecutionContextManager 初期化処理実行結果
01635   #         (初期化成功:true、初期化失敗:false)
01636   #
01637   # @else
01638   #
01639   # @endif
01640   def initExecContext(self):
01641     self._rtcout.RTC_TRACE("Manager.initExecContext()")
01642     OpenRTM_aist.PeriodicExecutionContextInit(self)
01643     OpenRTM_aist.ExtTrigExecutionContextInit(self)
01644     OpenRTM_aist.OpenHRPExecutionContextInit(self)
01645     return True
01646 
01647 
01648   ##
01649   # @if jp
01650   # @brief PeriodicECSharedComposite の初期化
01651   #
01652   # @return PeriodicECSharedComposite 初期化処理実行結果
01653   #         (初期化成功:true、初期化失敗:false)
01654   #
01655   # @else
01656   # @brief PeriodicECSharedComposite initialization
01657   #
01658   # @return PeriodicECSharedComposite initialization result
01659   #          (Successful:true, Failed:false)
01660   #
01661   # @endif
01662   #
01663   def initComposite(self):
01664     self._rtcout.RTC_TRACE("Manager.initComposite()")
01665     OpenRTM_aist.PeriodicECSharedCompositeInit(self)
01666     return True
01667 
01668   
01669   ##
01670   # @if jp
01671   # @brief ファクトリの初期化
01672   #
01673   # バッファ、スレッド、パブリッシャ、プロバイダ、コンシューマの
01674   # ファクトリを初期化する。
01675   #
01676   # @return ファクトリ初期化処理実行結果
01677   #         (初期化成功:true、初期化失敗:false)
01678   #
01679   # @else
01680   # @brief Factories initialization
01681   #
01682   # Initialize buffer factories, thread factories, publisher factories, 
01683   # provider factories, and consumer factories. 
01684   #
01685   # @return PeriodicECSharedComposite initialization result
01686   #          (Successful:true, Failed:false)
01687   #
01688   # @endif
01689   #
01690   def initFactories(self):
01691     self._rtcout.RTC_TRACE("Manager.initFactories()")
01692     OpenRTM_aist.FactoryInit()
01693     return True
01694 
01695   
01696   ##
01697   # @if jp
01698   # @brief Timer の初期化
01699   #
01700   # 使用する各 Timer の初期化処理を実行する。
01701   # (現状の実装では何もしない)
01702   #
01703   # @param self
01704   #
01705   # @return Timer 初期化処理実行結果(初期化成功:true、初期化失敗:false)
01706   #
01707   # @else
01708   #
01709   # @endif
01710   def initTimer(self):
01711     return True
01712 
01713 
01714   ##
01715   # @if jp
01716   # @brief ManagerServant の初期化
01717   #
01718   # @return Timer 初期化処理実行結果(初期化成功:true、初期化失敗:false)
01719   #
01720   # @else
01721   # @brief ManagerServant initialization
01722   #
01723   # @return Timer Initialization result (Successful:true, Failed:false)
01724   #
01725   # @endif
01726   #
01727   def initManagerServant(self):
01728     self._rtcout.RTC_TRACE("Manager.initManagerServant()")
01729     if not OpenRTM_aist.toBool(self._config.getProperty("manager.corba_servant"),
01730                                "YES","NO",True):
01731       return True
01732 
01733     self._mgrservant = OpenRTM_aist.ManagerServant()
01734     prop = self._config.getNode("manager")
01735     names = OpenRTM_aist.split(prop.getProperty("naming_formats"),",")
01736 
01737     if OpenRTM_aist.toBool(prop.getProperty("is_master"),
01738                            "YES","NO",True):
01739       for name in names:
01740         mgr_name = self.formatString(name, prop)
01741         self._namingManager.bindManagerObject(mgr_name, self._mgrservant)
01742 
01743     otherref = None
01744 
01745     try:
01746       otherref = file(self._config.getProperty("manager.refstring_path"),'r')
01747       refstring = otherref.readline()
01748       otherref.close()
01749     except:
01750       try:
01751         reffile = file(self._config.getProperty("manager.refstring_path"),'w')
01752       except:
01753         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01754         return False
01755       else:
01756         reffile.write(self._orb.object_to_string(self._mgrservant.getObjRef()))
01757         reffile.close()
01758     return True
01759 
01760   
01761   ##
01762   # @if jp
01763   # @brief NamingManager に登録されている全コンポーネントの終了処理
01764   #
01765   # NamingManager に登録されているRTコンポーネントおよび ExecutionContext の
01766   # リストを取得し、全コンポーネントを終了する。
01767   #
01768   # @param self
01769   #
01770   # @else
01771   #
01772   # @endif
01773   def shutdownComponents(self):
01774     self._rtcout.RTC_TRACE("Manager.shutdownComponents()")
01775     comps = self._namingManager.getObjects()
01776     for comp in comps:
01777       try:
01778         comp.exit()
01779         p = OpenRTM_aist.Properties(key=comp.getInstanceName())
01780         p.mergeProperties(comp.getProperties())
01781       except:
01782         self._rtcout.RTC_TRACE(OpenRTM_aist.Logger.print_exception())
01783         pass
01784 
01785     for ec in self._ecs:
01786       try:
01787         self._poa.deactivate_object(self._poa.servant_to_id(ec))
01788       except:
01789         self._rtcout.RTC_TRACE(OpenRTM_aist.Logger.print_exception())
01790         pass
01791 
01792 
01793   ##
01794   # @if jp
01795   # @brief RTコンポーネントの登録解除
01796   #
01797   # 指定したRTコンポーネントのインスタンスをネーミングサービスから
01798   # 登録解除する。
01799   #
01800   # @param self
01801   # @param comp 登録解除対象RTコンポーネント
01802   #
01803   # @else
01804   #
01805   # @endif
01806   def cleanupComponent(self, comp):
01807     self._rtcout.RTC_TRACE("Manager.cleanupComponent()")
01808     self.unregisterComponent(comp)
01809 
01810     return
01811 
01812 
01813   ##
01814   # @if jp
01815   # @brief RTコンポーネントの削除する
01816   #
01817   # notifyFinalized()によって登録されたRTコンポーネントを削除する。
01818   #
01819   # @else
01820   # @brief This method deletes RT-Components. 
01821   #
01822   # This method deletes RT-Components registered by notifyFinalized(). 
01823   #
01824   # @endif
01825   #
01826   # void cleanupComponents();
01827   def cleanupComponents(self):
01828     self._rtcout.RTC_VERBOSE("Manager.cleanupComponents()")
01829     guard = OpenRTM_aist.ScopedLock(self._finalized.mutex)
01830     self._rtcout.RTC_VERBOSE("%d components are marked as finalized.",
01831                              len(self._finalized.comps))
01832     for _comp in self._finalized.comps:
01833       self.deleteComponent(comp=_comp)
01834 
01835     self._finalized.comps = []
01836     del guard
01837     return
01838 
01839 
01840   ##
01841   # @if jp
01842   # @brief RTコンポーネントの削除する
01843   #
01844   # 削除するRTコンポーネントを登録する。
01845   # 登録されたRTコンポーネントは cleanupComponents() で削除される。
01846   #
01847   # @param 削除するRTコンポーネント
01848   #
01849   # @else
01850   # @brief This method deletes RT-Components. 
01851   #
01852   # The deleted RT-Component is registered. The registered RT-Components 
01853   # are deleted by cleanupComponents(). 
01854   #
01855   # @param Deleted RT component
01856   # @endif
01857   #
01858   # void notifyFinalized(RTObject_impl* comp);
01859   def notifyFinalized(self, comp):
01860     self._rtcout.RTC_TRACE("Manager.notifyFinalized()")
01861     guard = OpenRTM_aist.ScopedLock(self._finalized.mutex)
01862     self._finalized.comps.append(comp)
01863     del guard
01864     return
01865 
01866 
01867   ##
01868   # @if jp
01869   # @brief createComponentの引数を処理する
01870   # @ param self
01871   # @ param comp_arg(str)
01872   # @ param comp_id(Properties object)
01873   # @ param comp_conf(Properties object)
01874   # @ return True or False
01875   # @else
01876   #
01877   # @endif
01878   #
01879   # bool procComponentArgs(const char* comp_arg,
01880   #                        coil::Properties& comp_id,
01881   #                        coil::Properties& comp_conf)
01882   def procComponentArgs(self, comp_arg, comp_id, comp_conf):
01883     id_and_conf = [s.strip() for s in comp_arg.split("?")]
01884     if len(id_and_conf) != 1 and len(id_and_conf) != 2:
01885       self._rtcout.RTC_ERROR("Invalid arguments. Two or more '?'")
01886       return False
01887 
01888     if id_and_conf[0].find(":") == -1:
01889       id_and_conf[0] = "RTC:::" + id_and_conf[0] + ":"
01890 
01891     id = [s.strip() for s in id_and_conf[0].split(":")]
01892 
01893     if len(id) != 5:
01894       self._rtcout.RTC_ERROR("Invalid RTC id format.")
01895       return False
01896 
01897     prof = ["RTC", "vendor", "category", "implementation_id", "version"]
01898 
01899     if id[0] != prof[0]:
01900       self._rtcout.RTC_ERROR("Invalid id type.")
01901       return False
01902 
01903     for i in [1,2,3,4]:
01904       comp_id.setProperty(prof[i], id[i])
01905       self._rtcout.RTC_TRACE("RTC basic profile %s: %s", (prof[i], id[i]))
01906 
01907     if len(id_and_conf) == 2:
01908       conf = [s.strip() for s in id_and_conf[1].split("&")]
01909       for i in range(len(conf)):
01910         keyval = [s.strip() for s in conf[i].split("=")]
01911         if len(keyval) > 1:
01912           comp_conf.setProperty(keyval[0],keyval[1])
01913           self._rtcout.RTC_TRACE("RTC property %s: %s", (keyval[0], keyval[1]))
01914 
01915     return True
01916 
01917 
01918   # bool procContextArgs(const char* ec_args,
01919   #                      std::string& ec_id,
01920   #                      coil::Properties& ec_conf);
01921   def procContextArgs(self, ec_args, ec_id, ec_conf):
01922     id_and_conf = [s.strip() for s in ec_args.split("?")]
01923 
01924     if len(id_and_conf) != 1 and len(id_and_conf) != 2:
01925       self._rtcout.RTC_ERROR("Invalid arguments. Two or more '?'")
01926       return False
01927 
01928     if (id_and_conf[0] == "") or id_and_conf[0] is None:
01929       self._rtcout.RTC_ERROR("Empty ExecutionContext's name")
01930       return False
01931 
01932     ec_id[0] = id_and_conf[0]
01933 
01934     if len(id_and_conf) == 2:
01935       conf = [s.strip() for s in id_and_conf[1].split("&")]
01936       for i in range(len(conf)):
01937         k = [s.strip() for s in conf[i].split("=")]
01938         ec_conf.setProperty(k[0],k[1])
01939         self._rtcout.RTC_TRACE("EC property %s: %s",(k[0],k[1]))
01940         
01941     return True
01942 
01943 
01944   ##
01945   # @if jp
01946   # @brief RTコンポーネントのコンフィギュレーション処理
01947   #
01948   # RTコンポーネントの型およびインスタンス毎に記載されたプロパティファイルの
01949   # 情報を読み込み、コンポーネントに設定する。
01950   # また、各コンポーネントの NamingService 登録時の名称を取得し、設定する。
01951   #
01952   # @param self
01953   # @param comp コンフィギュレーション対象RTコンポーネント
01954   #
01955   # @else
01956   #
01957   # @endif
01958   # void configureComponent(RTObject_impl* comp, const coil::Properties& prop);
01959   def configureComponent(self, comp, prop):
01960     category  = comp.getCategory()
01961     type_name = comp.getTypeName()
01962     inst_name = comp.getInstanceName()
01963 
01964     type_conf = category + "." + type_name + ".config_file"
01965     name_conf = category + "." + inst_name + ".config_file"
01966 
01967     type_prop = OpenRTM_aist.Properties()
01968 
01969     name_prop = OpenRTM_aist.Properties()
01970 
01971     if self._config.getProperty(name_conf) != "":
01972       try:
01973         conff = open(self._config.getProperty(name_conf))
01974       except:
01975         print "Not found. : %s" % self._config.getProperty(name_conf)
01976         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01977       else:
01978         name_prop.load(conff)
01979 
01980     if self._config.findNode(category + "." + inst_name):
01981       name_prop.mergeProperties(self._config.getNode(category + "." + inst_name))
01982 
01983     if self._config.getProperty(type_conf) != "":
01984       try:
01985         conff = open(self._config.getProperty(type_conf))
01986       except:
01987         print "Not found. : %s" % self._config.getProperty(type_conf)
01988         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
01989       else:
01990         type_prop.load(conff)
01991 
01992     if self._config.findNode(category + "." + type_name):
01993       type_prop.mergeProperties(self._config.getNode(category + "." + type_name))
01994 
01995     comp.setProperties(prop)
01996     type_prop.mergeProperties(name_prop)
01997     comp.setProperties(type_prop)
01998 
01999     comp_prop = OpenRTM_aist.Properties(prop=comp.getProperties())
02000 
02001     naming_formats = self._config.getProperty("naming.formats")
02002     if comp_prop.findNode("naming.formats"):
02003       naming_formats = comp_prop.getProperty("naming.formats")
02004     naming_formats = OpenRTM_aist.flatten(OpenRTM_aist.unique_sv(OpenRTM_aist.split(naming_formats, ",")))
02005 
02006     naming_names = self.formatString(naming_formats, comp.getProperties())
02007     comp.getProperties().setProperty("naming.formats",naming_formats)
02008     comp.getProperties().setProperty("naming.names",naming_names)
02009     return
02010 
02011 
02012   ##
02013   # @if jp
02014   # @brief プロパティ情報のマージ
02015   #
02016   # 指定されたファイル内に設定されているプロパティ情報をロードし、
02017   # 既存の設定済みプロパティとマージする。
02018   #
02019   # @param self
02020   # @param prop マージ対象プロパティ
02021   # @param file_name プロパティ情報が記述されているファイル名
02022   #
02023   # @return マージ処理実行結果(マージ成功:true、マージ失敗:false)
02024   #
02025   # @else
02026   #
02027   # @endif
02028   def mergeProperty(self, prop, file_name):
02029     if file_name == "":
02030       self._rtcout.RTC_ERROR("Invalid configuration file name.")
02031       return False
02032   
02033     if file_name[0] != '\0':
02034       
02035       try:
02036         conff = open(file_name)
02037       except:
02038         print "Not found. : %s" % file_name
02039         self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
02040       else:
02041         prop.load(conff)
02042         conff.close()
02043         return True
02044   
02045     return False
02046 
02047 
02048   ##
02049   # @if jp
02050   # @brief NamingServer に登録する際の登録情報を組み立てる
02051   #
02052   # 指定された書式とプロパティ情報を基に NameServer に登録する際の情報を
02053   # 組み立てる。
02054   # 各書式指定用文字の意味は以下のとおり
02055   # - % : コンテキストの区切り
02056   # - n : インスタンス名称
02057   # - t : 型名
02058   # - m : 型名
02059   # - v : バージョン
02060   # - V : ベンダー
02061   # - c : カテゴリ
02062   # - h : ホスト名
02063   # - M : マネージャ名
02064   # - p : プロセスID
02065   #
02066   # @param self
02067   # @param naming_format NamingService 登録情報書式指定
02068   # @param prop 使用するプロパティ情報
02069   #
02070   # @return 指定書式変換結果
02071   #
02072   # @else
02073   #
02074   # @endif
02075   def formatString(self, naming_format, prop):
02076     name_ = naming_format
02077     str_  = ""
02078     count = 0
02079     len_  = len(name_)
02080     it = iter(name_)
02081 
02082     try:
02083       while 1:
02084         n = it.next()
02085         if n == '%':
02086           count+=1
02087           if not (count % 2):
02088             str_ += n
02089         elif n == '$':
02090           count = 0
02091           n = it.next()
02092           if n == '{' or n == '(':
02093             n = it.next()
02094             env = ""
02095             for i in xrange(len_):
02096               if n == '}' or n == ')':
02097                 break
02098               env += n
02099               n = it.next()
02100             envval = os.getenv(env)
02101             if envval:
02102               str_ += envval
02103           else:
02104             str_ += n
02105         else:
02106           if  count > 0 and (count % 2):
02107             count = 0
02108             if   n == "n": str_ += prop.getProperty("instance_name")
02109             elif n == "t": str_ += prop.getProperty("type_name")
02110             elif n == "m": str_ += prop.getProperty("type_name")
02111             elif n == "v": str_ += prop.getProperty("version")
02112             elif n == "V": str_ += prop.getProperty("vendor")
02113             elif n == "c": str_ += prop.getProperty("category")
02114             elif n == "h": str_ += self._config.getProperty("manager.os.hostname")
02115             elif n == "M": str_ += self._config.getProperty("manager.name")
02116             elif n == "p": str_ += str(self._config.getProperty("manager.pid"))
02117             else: str_ += n
02118           else:
02119             count = 0
02120             str_ += n
02121     except:
02122       # Caught StopIteration exception.
02123       return str_
02124 
02125     return str_
02126 
02127 
02128   ##
02129   # @if jp
02130   # @brief ログバッファの取得
02131   #
02132   # マネージャに設定したログバッファを取得する。
02133   #
02134   # @param self
02135   #
02136   # @return マネージャに設定したログバッファ
02137   #
02138   # @else
02139   #
02140   # @endif
02141   def getLogbuf(self,name="manager"):
02142     if not OpenRTM_aist.toBool(self._config.getProperty("logger.enable"), "YES", "NO", True):
02143       return OpenRTM_aist.LogStream()
02144 
02145     logbuf = OpenRTM_aist.LogStream(name)
02146     logbuf.setLogLevel(self._config.getProperty("logger.log_level"))
02147     return logbuf
02148 
02149 
02150   ##
02151   # @if jp
02152   # @brief マネージャコンフィギュレーションの取得
02153   #
02154   # マネージャに設定したコンフィギュレーションを取得する。
02155   #
02156   # @param self
02157   #
02158   # @return マネージャのコンフィギュレーション
02159   #
02160   # @else
02161   #
02162   # @endif
02163   def getConfig(self):
02164     return self._config
02165 
02166 
02167   ##
02168   # @if jp
02169   # @brief コンポーネントファイル(.py)から
02170   #
02171   # マネージャに設定したコンフィギュレーションを取得する。
02172   #
02173   # @param self
02174   #
02175   # @return マネージャのコンフィギュレーション
02176   #
02177   # @else
02178   #
02179   # @endif
02180   def __try_direct_load(self, file_name):
02181     try:
02182       pathChanged=False
02183       splitted_name = os.path.split(file_name)
02184       save_path = sys.path[:]
02185       sys.path.append(splitted_name[0])
02186       import_name = splitted_name[-1].split(".py")[0]
02187       mo = __import__(import_name)
02188       sys.path = save_path
02189       _spec = getattr(mo,import_name.lower()+"_spec",None)
02190       _klass = getattr(mo,import_name,None)
02191       if _spec and _klass:
02192         prof = OpenRTM_aist.Properties(defaults_str=_spec)
02193         self.registerFactory(prof,
02194                              _klass,
02195                              OpenRTM_aist.Delete)
02196     except:
02197       self._rtcout.RTC_ERROR("Module load error: %s", file_name)
02198       self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
02199       
02200     return
02201 
02202 
02203 
02204   #============================================================
02205   # コンポーネントマネージャ
02206   #============================================================
02207   ##
02208   # @if jp
02209   # @class InstanceName
02210   # @brief ObjectManager 検索用ファンクタ
02211   #
02212   # @else
02213   #
02214   # @endif
02215   class InstanceName:
02216     """
02217     """
02218 
02219     ##
02220     # @if jp
02221     # @brief コンストラクタ
02222     #
02223     # コンストラクタ
02224     #
02225     # @param self
02226     # @param name 検索対象コンポーネント名称(デフォルト値:None)
02227     # @param factory 検索対象ファクトリ名称(デフォルト値:None)
02228     #
02229     # @else
02230     #
02231     # @endif
02232     def __init__(self, name=None, factory=None, prop=None):
02233       if prop:
02234         self._name = prop.getInstanceName()
02235       if factory:
02236         self._name = factory.getInstanceName()
02237       elif name:
02238         self._name = name
02239 
02240     def __call__(self, factory):
02241       return self._name == factory.getInstanceName()
02242 
02243 
02244 
02245   #============================================================
02246   # コンポーネントファクトリ
02247   #============================================================
02248   ##
02249   # @if jp
02250   # @class FactoryPredicate
02251   # @brief コンポーネントファクトリ検索用ファンクタ
02252   #
02253   # @else
02254   #
02255   # @endif
02256   class FactoryPredicate:
02257 
02258     def __init__(self, name=None, prop=None, factory=None):
02259       if name:
02260         self._vendor   = ""
02261         self._category = ""
02262         self._impleid  = name
02263         self._version  = ""
02264       elif prop:
02265         self._vendor   = prop.getProperty("vendor")
02266         self._category = prop.getProperty("category")
02267         self._impleid  = prop.getProperty("implementation_id")
02268         self._version  = prop.getProperty("version")
02269       elif factory:
02270         self._vendor   = factory.profile().getProperty("vendor")
02271         self._category = factory.profile().getProperty("category")
02272         self._impleid  = factory.profile().getProperty("implementation_id")
02273         self._version  = factory.profile().getProperty("version")
02274 
02275 
02276     def __call__(self, factory):
02277       if self._impleid == "":
02278         return False
02279 
02280       _prop = OpenRTM_aist.Properties(prop=factory.profile())
02281 
02282       if self._impleid != _prop.getProperty("implementation_id"):
02283         return False
02284 
02285       if self._vendor != "" and self._vendor != _prop.getProperty("vendor"):
02286         return False
02287 
02288       if self._category != "" and self._category != _prop.getProperty("category"):
02289         return False
02290 
02291       if self._version != "" and self._version != _prop.getProperty("version"):
02292         return False
02293 
02294       return True
02295 
02296 
02297 
02298   #============================================================
02299   # ExecutionContextファクトリ
02300   #============================================================
02301   ##
02302   # @if jp
02303   # @class ECFactoryPredicate
02304   # @brief ExecutionContextファクトリ検索用ファンクタ
02305   #
02306   # @else
02307   #
02308   # @endif
02309   class ECFactoryPredicate:
02310 
02311 
02312 
02313     def __init__(self, name=None, factory=None):
02314       if name:
02315         self._name = name
02316       elif factory:
02317         self._name = factory.name()
02318 
02319     def __call__(self, factory):
02320       return self._name == factory.name()
02321 
02322 
02323   #============================================================
02324   # Module Fanctor
02325   #============================================================
02326   ##
02327   # @if jp
02328   # @class ModulePredicate
02329   # @brief Module検索用ファンクタ
02330   #
02331   # @else
02332   #
02333   # @endif
02334   class ModulePredicate:
02335 
02336       # ModulePredicate(coil::Properties& prop)
02337       def __init__(self, prop):
02338         self._prop = prop
02339         return
02340 
02341       # bool operator()(coil::Properties& prop)
02342       def __call__(self, prop):
02343 
02344         if self._prop.getProperty("implementation_id") != prop.getProperty("implementation_id"):
02345           return False
02346 
02347         if self._prop.getProperty("vendor") and \
02348               self._prop.getProperty("vendor") != prop.getProperty("vendor"):
02349           return False
02350         
02351         if self._prop.getProperty("category") and \
02352               self._prop.getProperty("category") != prop.getProperty("category"):
02353           return False
02354 
02355         if self._prop.getProperty("version") and \
02356               self._prop.getProperty("version") != prop.getProperty("version"):
02357           return False
02358 
02359         return True
02360 
02361 
02362   #------------------------------------------------------------
02363   # ORB runner
02364   #------------------------------------------------------------
02365   ##
02366   # @if jp
02367   # @class OrbRunner
02368   # @brief OrbRunner クラス
02369   #
02370   # ORB 実行用ヘルパークラス。
02371   #
02372   # @since 0.4.0
02373   #
02374   # @else
02375   # @class OrbRunner
02376   # @brief OrbRunner class
02377   # @endif
02378   class OrbRunner:
02379     """
02380     """
02381 
02382     ##
02383     # @if jp
02384     # @brief コンストラクタ
02385     #
02386     # コンストラクタ
02387     #
02388     # @param self
02389     # @param orb ORB
02390     #
02391     # @else
02392     # @brief Constructor
02393     #
02394     # @endif
02395     def __init__(self, orb):
02396       self._orb = orb
02397       self._th = threading.Thread(target=self.run)
02398       self._th.start()
02399 
02400 
02401     def __del__(self):
02402       self._th.join()
02403       self._th = None
02404       return
02405 
02406 
02407     ##
02408     # @if jp
02409     # @brief ORB 実行処理
02410     #
02411     # ORB 実行
02412     #
02413     # @param self
02414     #
02415     # @else
02416     #
02417     # @endif
02418     def run(self):
02419       try:
02420         self._orb.run()
02421         #Manager.instance().shutdown()
02422       except:
02423         print OpenRTM_aist.Logger.print_exception()
02424         pass
02425       return
02426 
02427 
02428     ##
02429     # @if jp
02430     # @brief ORB wait処理
02431     #
02432     # ORB wait
02433     #
02434     # @param self
02435     #
02436     # @else
02437     #
02438     # @endif
02439     def wait(self):
02440       return
02441 
02442     ##
02443     # @if jp
02444     # @brief ORB 終了処理(未実装)
02445     #
02446     # ORB 終了処理
02447     #
02448     # @param self
02449     # @param flags 終了処理フラグ
02450     #
02451     # @return 終了処理結果
02452     #
02453     # @else
02454     #
02455     # @endif
02456     def close(self, flags):
02457       return 0
02458 
02459 
02460   #------------------------------------------------------------
02461   # Manager Terminator
02462   #------------------------------------------------------------
02463   ##
02464   # @if jp
02465   # @class Terminator
02466   # @brief Terminator クラス
02467   #
02468   # ORB 終了用ヘルパークラス。
02469   #
02470   # @since 0.4.0
02471   #
02472   # @else
02473   #
02474   # @endif
02475   class Terminator:
02476     """
02477     """
02478 
02479     ##
02480     # @if jp
02481     # @brief コンストラクタ
02482     #
02483     # コンストラクタ
02484     #
02485     # @param self
02486     # @param manager マネージャ・オブジェクト
02487     #
02488     # @else
02489     # @brief Constructor
02490     #
02491     # @endif
02492     def __init__(self, manager):
02493       self._manager = manager
02494 
02495 
02496     ##
02497     # @if jp
02498     # @brief 終了処理
02499     #
02500     # ORB，マネージャ終了処理を開始する。
02501     #
02502     # @param self
02503     #
02504     # @else
02505     #
02506     # @endif
02507     def terminate(self):
02508       self._manager.shutdown()
02509 
02510 
02511 
02512   ##
02513   # @if jp
02514   # @class Term
02515   # @brief Term クラス
02516   #
02517   # 終了用ヘルパークラス。
02518   #
02519   # @since 0.4.0
02520   #
02521   # @else
02522   #
02523   # @endif
02524   class Term:
02525     def __init__(self):
02526       self.waiting = 0
02527       self.mutex   = threading.RLock()
02528 
02529 
02530   class Finalized:
02531     def __init__(self):
02532       self.mutex = threading.RLock()
02533       self.comps = []