Manager.py

説明を見る。
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 sys
00021 import traceback
00022 import time
00023 from omniORB import CORBA
00024 
00025 import OpenRTM
00026 import RTC
00027 import SDOPackage
00028 
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.Manager.instance()
00066   mgr.terminate()
00067 
00068 
00069 
00070 ##
00071 # @if jp
00072 # @class ScopedLock
00073 # @brief ScopedLock クラス
00074 #
00075 # 排他処理用ロッククラス。
00076 #
00077 # @since 0.4.0
00078 #
00079 # @else
00080 #
00081 # @endif
00082 class ScopedLock:
00083 
00084 
00085 
00086   ##
00087   # @if jp
00088   # @brief コンストラクタ
00089   #
00090   # コンストラクタ
00091   #
00092   # @param self
00093   # @param mutex ロック用ミューテックス
00094   #
00095   # @else
00096   #
00097   # @endif
00098   def __init__(self, mutex):
00099     self.mutex = mutex
00100     self.mutex.acquire()
00101 
00102 
00103   ##
00104   # @if jp
00105   # @brief デストラクタ
00106   #
00107   # デストラクタ
00108   #
00109   # @param self
00110   #
00111   # @else
00112   #
00113   # @endif
00114   def __del__(self):
00115     self.mutex.release()
00116 
00117 
00118 
00119 ##
00120 # @if jp
00121 # @class Manager
00122 # @brief Manager クラス
00123 #
00124 # コンポーネントなど各種の情報管理を行うマネージャクラス。
00125 #
00126 # @since 0.2.0
00127 #
00128 # @else
00129 # @class Manager
00130 # @brief Manager class
00131 # @endif
00132 class Manager:
00133   """
00134   """
00135 
00136 
00137 
00138   ##
00139   # @if jp
00140   # @brief コピーコンストラクタ
00141   #
00142   # コピーコンストラクタ
00143   #
00144   # @param self
00145   # @param _manager コピー元マネージャオブジェクト(デフォルト値:None)
00146   #
00147   # @else
00148   # @brief Protected Copy Constructor
00149   #
00150   # @endif
00151   def __init__(self, _manager=None):
00152     self._initProc   = None
00153     self._runner     = None
00154     self._terminator = None
00155     self._compManager = OpenRTM.ObjectManager(self.InstanceName)
00156     self._factory = OpenRTM.ObjectManager(self.FactoryPredicate)
00157     self._ecfactory = OpenRTM.ObjectManager(self.ECFactoryPredicate)
00158     self._terminate = self.Term()
00159     self._ecs = []
00160     self._timer = None
00161     signal.signal(signal.SIGINT, handler)
00162     
00163     return
00164 
00165 
00166   ##
00167   # @if jp
00168   # @brief マネージャの初期化
00169   #
00170   # マネージャを初期化する static 関数。
00171   # マネージャをコマンドライン引数を与えて初期化する。
00172   # マネージャを使用する場合は、必ずこの初期化メンバ関数 init() を
00173   # 呼ばなければならない。
00174   # マネージャのインスタンスを取得する方法として、init(), instance() の
00175   # 2つの static 関数が用意されているが、初期化はinit()でしか行われないため、
00176   # Manager の生存期間の一番最初にはinit()を呼ぶ必要がある。
00177   #
00178   # ※マネージャの初期化処理
00179   # - initManager: 引数処理、configファイルの読み込み、サブシステム初期化
00180   # - initLogger: Logger初期化
00181   # - initORB: ORB 初期化
00182   # - initNaming: NamingService 初期化
00183   # - initExecutionContext: ExecutionContext factory 初期化
00184   # - initTimer: Timer 初期化
00185   #
00186   # @param argv コマンドライン引数
00187   # 
00188   # @return Manager の唯一のインスタンスの参照
00189   #
00190   # @else
00191   # @brief Initializa manager
00192   #
00193   # This is the static function to tintialize the Manager.
00194   # The Manager is initialized by given arguments.
00195   # At the starting the manager, this static function "must" be called from
00196   # application program. The manager has two static functions to get 
00197   # the instance, "init()" and "instance()". Since initializing
00198   # process is only performed by the "init()" function, the "init()" has
00199   # to be called at the beginning of the lifecycle of the Manager.
00200   # function.
00201   #
00202   # @param argv The array of the command line arguments.
00203   #
00204   # @endif
00205   def init(argv):
00206     global manager
00207     global mutex
00208     
00209     if manager is None:
00210       guard = ScopedLock(mutex)
00211       if manager is None:
00212         manager = Manager()
00213         manager.initManager(argv)
00214         manager.initLogger()
00215         manager.initORB()
00216         manager.initNaming()
00217         manager.initExecContext()
00218         manager.initTimer()
00219 
00220     return manager
00221   
00222   init = staticmethod(init)
00223 
00224 
00225   ##
00226   # @if jp
00227   # @brief マネージャのインスタンスの取得
00228   #
00229   # マネージャのインスタンスを取得する static 関数。
00230   # この関数を呼ぶ前に、必ずこの初期化関数 init() が呼ばれている必要がある。
00231   #
00232   # @return Manager の唯一のインスタンスの参照
00233   # 
00234   # @else
00235   #
00236   # @brief Get instance of the manager
00237   #
00238   # This is the static function to get the instance of the Manager.
00239   # Before calling this function, ensure that the initialization function
00240   # "init()" is called.
00241   #
00242   # @return The only instance reference of the manager
00243   #
00244   # @endif
00245   def instance():
00246     global manager
00247     global mutex
00248     
00249     if manager is None:
00250       guard = ScopedLock(mutex)
00251       if manager is None:
00252         manager = Manager()
00253         manager.initManager(None)
00254         manager.initLogger()
00255         manager.initORB()
00256         manager.initNaming()
00257         manager.initExecContext()
00258         manager.initTimer()
00259 
00260     return manager
00261 
00262   instance = staticmethod(instance)
00263 
00264 
00265   ##
00266   # @if jp
00267   # @brief マネージャ終了処理
00268   #
00269   # マネージャの終了処理を実行する。
00270   #
00271   # @param self
00272   #
00273   # @else
00274   #
00275   # @endif
00276   def terminate(self):
00277     if self._terminator:
00278       self._terminator.terminate()
00279 
00280 
00281   ##
00282   # @if jp
00283   # @brief マネージャ・シャットダウン
00284   #
00285   # マネージャの終了処理を実行する。
00286   # ORB終了後、同期を取って終了する。
00287   #
00288   # @param self
00289   #
00290   # @else
00291   #
00292   # @endif
00293   def shutdown(self):
00294     self._rtcout.RTC_DEBUG("Manager::shutdown()")
00295     self.shutdownComponents()
00296     self.shutdownNaming()
00297     self.shutdownORB()
00298     self.shutdownManager()
00299 
00300     if self._runner:
00301       self._runner.wait()
00302     else:
00303       self.join()
00304 
00305     self.shutdownLogger()
00306 
00307 
00308   ##
00309   # @if jp
00310   # @brief マネージャ終了処理の待ち合わせ
00311   #
00312   # 同期を取るため、マネージャ終了処理の待ち合わせを行う。
00313   #
00314   # @param self
00315   #
00316   # @else
00317   #
00318   # @endif
00319   def join(self):
00320     self._rtcout.RTC_DEBUG("Manager::wait()")
00321     guard = ScopedLock(self._terminate.mutex)
00322     self._terminate.waiting += 1
00323     del guard
00324     while 1:
00325       guard = ScopedLock(self._terminate.mutex)
00326       #if self._terminate.waiting > 1:
00327       if self._terminate.waiting > 0:
00328         break
00329       del guard
00330       time.sleep(0.001)
00331 
00332 
00333   ##
00334   # @if jp
00335   #
00336   # @brief 初期化プロシージャのセット
00337   #
00338   # このオペレーションはユーザが行うモジュール等の初期化プロシージャ
00339   # を設定する。ここで設定されたプロシージャは、マネージャが初期化され、
00340   # アクティブ化された後、適切なタイミングで実行される。
00341   #
00342   # @param self
00343   # @param proc 初期化プロシージャの関数ポインタ
00344   #
00345   # @else
00346   #
00347   # @brief Run the Manager
00348   #
00349   # This operation sets the initial procedure call to process module
00350   # initialization, other user defined initialization and so on.
00351   # The given procedure will be called at the proper timing after the 
00352   # manager initialization, activation and run.
00353   #
00354   # @param proc A function pointer to the initial procedure call
00355   #
00356   # @endif
00357   def setModuleInitProc(self, proc):
00358     self._initProc = proc
00359     return
00360 
00361 
00362   ##
00363   # @if jp
00364   #
00365   # @brief Managerのアクティブ化
00366   #
00367   # このオペレーションは以下の処理を行う
00368   # - CORBA POAManager のアクティブ化
00369   # - マネージャCORBAオブジェクトのアクティブ化
00370   # - Manager オブジェクトへの初期化プロシージャの実行
00371   #
00372   # このオペレーションは、マネージャの初期化後、runManager()
00373   # の前に呼ぶ必要がある。
00374   #
00375   # @param self
00376   #
00377   # @return 処理結果(アクティブ化成功:true、失敗:false)
00378   #
00379   # @else
00380   #
00381   # @brief Activate Manager
00382   #
00383   # This operation do the following,
00384   # - Activate CORBA POAManager
00385   # - Activate Manager CORBA object
00386   # - Execute the initial procedure call of the Manager
00387   #
00388   # This operationo should be invoked after Manager:init(),
00389   # and before tunManager().
00390   #
00391   # @endif
00392   def activateManager(self):
00393     self._rtcout.RTC_DEBUG("Manager::activateManager()")
00394 
00395     try:
00396       self.getPOAManager().activate()
00397       if self._initProc:
00398         self._initProc(self)
00399     except:
00400       print "Exception: Manager.activateManager()"
00401       return False
00402 
00403     return True
00404 
00405 
00406   ##
00407   # @if jp
00408   #
00409   # @brief Managerの実行
00410   #
00411   # このオペレーションはマネージャのメインループを実行する。
00412   # このメインループ内では、CORBA ORBのイベントループ等が
00413   # 処理される。デフォルトでは、このオペレーションはブロックし、
00414   # Manager::destroy() が呼ばれるまで処理を戻さない。
00415   # 引数 no_block が true に設定されている場合は、内部でイベントループ
00416   # を処理するスレッドを起動し、ブロックせずに処理を戻す。
00417   #
00418   # @param self
00419   # @param no_block false: ブロッキングモード, true: ノンブロッキングモード
00420   #
00421   # @else
00422   #
00423   # @brief Run the Manager
00424   #
00425   # This operation processes the main event loop of the Manager.
00426   # In this main loop, CORBA's ORB event loop or other processes
00427   # are performed. As the default behavior, this operation is going to
00428   # blocking mode and never returns until manager::destroy() is called.
00429   # When the given argument "no_block" is set to "true", this operation
00430   # creates a thread to process the event loop internally, and it doesn't
00431   # block and returns.
00432   #
00433   # @param no_block false: Blocking mode, true: non-blocking mode.
00434   #
00435   # @endif
00436   def runManager(self, no_block=None):
00437     if no_block:
00438       no_block = False
00439 
00440     if no_block:
00441       self._rtcout.RTC_DEBUG("Manager::runManager(): non-blocking mode")
00442       self._runner = self.OrbRunner(self._orb)
00443       # self._runnner.open()
00444     else:
00445       self._rtcout.RTC_DEBUG("Manager::runManager(): blocking mode")
00446       self._orb.run()
00447       self._rtcout.RTC_DEBUG("Manager::runManager(): ORB was terminated")
00448       self.join()
00449     return
00450 
00451 
00452   ##
00453   # @if jp
00454   # @brief [CORBA interface] モジュールのロード
00455   #
00456   # 指定したコンポーネントのモジュールをロードするとともに、
00457   # 指定した初期化関数を実行する。
00458   #
00459   # @param self
00460   # @param fname   モジュールファイル名
00461   # @param initfunc 初期化関数名
00462   # 
00463   # @else
00464   #
00465   # @brief [CORBA interface] Load module
00466   #
00467   # Load module (shared library, DLL etc..) by file name,
00468   # and invoke initialize function.
00469   #
00470   # @param fname    The module file name
00471   # @param initfunc The initialize function name
00472   #
00473   # @endif
00474   def load(self, fname, initfunc):
00475     self._rtcout.RTC_DEBUG("Manager::load()")
00476     self._module.load(fname, initfunc)
00477     return
00478 
00479 
00480   ##
00481   # @if jp
00482   #
00483   # @brief モジュールのアンロード
00484   #
00485   # モジュールをアンロードする
00486   #
00487   # @param self
00488   # @param fname モジュールのファイル名
00489   # 
00490   # @else
00491   #
00492   # @brief Unload module
00493   #
00494   # Unload shared library.
00495   #
00496   # @param pathname Module file name
00497   #
00498   # @endif
00499   def unload(self, fname):
00500     self._rtcout.RTC_DEBUG("Manager::unload()")
00501     self._module.unload(fname)
00502     return
00503 
00504 
00505   ##
00506   # @if jp
00507   #
00508   # @brief 全モジュールのアンロード
00509   #
00510   # モジュールをすべてアンロードする
00511   #
00512   # @param self
00513   #
00514   # @else
00515   #
00516   # @brief Unload module
00517   #
00518   # Unload all loaded shared library.
00519   #
00520   # @endif
00521   def unloadAll(self):
00522     self._rtcout.RTC_DEBUG("Manager::unloadAll()")
00523     self._module.unloadAll()
00524     return
00525 
00526 
00527   ##
00528   # @if jp
00529   # @brief ロード済みのモジュールリストを取得する
00530   #
00531   # 現在マネージャにロードされているモジュールのリストを取得する。
00532   #
00533   # @param self
00534   #
00535   # @return ロード済みモジュールリスト
00536   #
00537   # @else
00538   # @brief Get loaded module names
00539   # @endif
00540   def getLoadedModules(self):
00541     self._rtcout.RTC_DEBUG("Manager::getLoadedModules()")
00542     return self._module.getLoadedModules()
00543 
00544 
00545   ##
00546   # @if jp
00547   # @brief ロード可能なモジュールリストを取得する
00548   #
00549   # ロード可能モジュールのリストを取得する。
00550   # (現在はModuleManager側で未実装)
00551   #
00552   # @param self
00553   #
00554   # @return ロード可能モジュール リスト
00555   #
00556   # @else
00557   # @brief Get loadable module names
00558   # @endif
00559   def getLoadableModules(self):
00560     self._rtcout.RTC_DEBUG("Manager::getLoadableModules()")
00561     return self._module.getLoadableModules()
00562 
00563 
00564   #============================================================
00565   # Component Factory Management
00566   #============================================================
00567 
00568   ##
00569   # @if jp
00570   # @brief RTコンポーネント用ファクトリを登録する
00571   #
00572   # RTコンポーネントのインスタンスを生成するための
00573   # Factoryを登録する。
00574   #
00575   # @param self
00576   # @param profile RTコンポーネント プロファイル
00577   # @param new_func RTコンポーネント生成用関数
00578   # @param delete_func RTコンポーネント破棄用関数
00579   #
00580   # @return 登録処理結果(登録成功:true、失敗:false)
00581   #
00582   # @else
00583   # @brief Register RT-Component Factory
00584   # @endif
00585   def registerFactory(self, profile, new_func, delete_func):
00586     self._rtcout.RTC_DEBUG("Manager::registerFactory(%s)", profile.getProperty("type_name"))
00587     try:
00588       factory = OpenRTM.FactoryPython(profile, new_func, delete_func)
00589       self._factory.registerObject(factory)
00590       return True
00591     except:
00592       return False
00593 
00594 
00595   ##
00596   # @if jp
00597   # @brief ExecutionContext用ファクトリを登録する
00598   #
00599   # ExecutionContextのインスタンスを生成するためのFactoryを登録する。
00600   #
00601   # @param self
00602   # @param name 生成対象ExecutionContext名称
00603   # @param new_func ExecutionContext生成用関数
00604   # @param delete_func ExecutionContext破棄用関数
00605   #
00606   # @return 登録処理結果(登録成功:true、失敗:false)
00607   #
00608   # @else
00609   # @brief Register ExecutionContext Factory
00610   # @endif
00611   def registerECFactory(self, name, new_func, delete_func):
00612     self._rtcout.RTC_DEBUG("Manager::registerECFactory(%s)", name)
00613     try:
00614       self._ecfactory.registerObject(OpenRTM.ECFactoryPython(name, new_func, delete_func))
00615       return True
00616     except:
00617       return False
00618 
00619     return False
00620 
00621 
00622   ##
00623   # @if jp
00624   # @brief ファクトリ全リストを取得する
00625   #
00626   # 登録されているファクトリの全リストを取得する。
00627   #
00628   # @param self
00629   #
00630   # @return 登録ファクトリ リスト
00631   #
00632   # @else
00633   # @brief Get the list of all RT-Component Factory
00634   # @endif
00635   def getModulesFactories(self):
00636     self._rtcout.RTC_DEBUG("Manager::getModulesFactories()")
00637 
00638     self._modlist = []
00639     for _obj in self._factory._objects._obj:
00640       self._modlist.append(_obj.profile().getProperty("implementation_id"))
00641     return self._modlist
00642 
00643 
00644   #============================================================
00645   # Component management
00646   #============================================================
00647 
00648   ##
00649   # @if jp
00650   # @brief RTコンポーネントを生成する
00651   #
00652   # 指定したRTコンポーネントのインスタンスを登録されたFactory経由で生成する。
00653   # インスタンス生成が成功した場合、併せて以下の処理を実行する。
00654   #  - 外部ファイルで設定したコンフィギュレーション情報の読み込み,設定
00655   #  - ExecutionContextのバインド,動作開始
00656   #  - ネーミングサービスへの登録
00657   #
00658   # @param self
00659   # @param module_name 生成対象RTコンポーネント名称
00660   #
00661   # @return 生成したRTコンポーネントのインスタンス
00662   #
00663   # @else
00664   # @brief Create RT-Component
00665   # @endif
00666   def createComponent(self, module_name):
00667     self._rtcout.RTC_DEBUG("Manager::createComponent(%s)", module_name)
00668 
00669     obj = self._factory.find(module_name)
00670     comp = obj.create(self)
00671     if comp is None:
00672       return None
00673     self._rtcout.RTC_DEBUG("RTC Created: %s", module_name)
00674 
00675     self.configureComponent(comp)
00676 
00677     if comp.initialize() != RTC.RTC_OK:
00678       self._rtcout.RTC_DEBUG("RTC initialization failed: %s", module_name)
00679       comp.exit()
00680       self._rtcout.RTC_DEBUG("%s was finalized", module_name)
00681       return None
00682 
00683     self._rtcout.RTC_DEBUG("RTC initialization succeeded: %s", module_name)
00684     self.bindExecutionContext(comp)
00685     self.registerComponent(comp)
00686     return comp
00687 
00688 
00689   ##
00690   # @if jp
00691   # @brief RTコンポーネントを直接 Manager に登録する
00692   #
00693   # 指定したRTコンポーネントのインスタンスをファクトリ経由ではなく
00694   # 直接マネージャに登録する。
00695   #
00696   # @param self
00697   # @param comp 登録対象RTコンポーネントのインスタンス
00698   #
00699   # @return 登録処理結果(登録成功:true、失敗:false)
00700   #
00701   # @else
00702   # @brief Register RT-Component directly without Factory
00703   # @endif
00704   def registerComponent(self, comp):
00705     self._rtcout.RTC_DEBUG("Manager::registerComponent(%s)", comp.getInstanceName())
00706 
00707     self._compManager.registerObject(comp)
00708     names = comp.getNamingNames()
00709 
00710     for name in names:
00711       self._rtcout.RTC_DEBUG("Bind name: %s", name)
00712       self._namingManager.bindObject(name, comp)
00713 
00714     return True
00715 
00716   
00717   ##
00718   # @if jp
00719   # @brief RTコンポーネントの登録を解除する
00720   #
00721   # 指定したRTコンポーネントの登録を解除する。
00722   #
00723   # @param self
00724   # @param comp 登録解除対象RTコンポーネントのインスタンス
00725   #
00726   # @return 登録解除処理結果(解除成功:true、解除失敗:false)
00727   #
00728   # @else
00729   # @brief Register RT-Component directly without Factory
00730   # @endif
00731   def unregisterComponent(self, comp):
00732     self._rtcout.RTC_DEBUG("Manager::unregisterComponent(%s)", comp.getInstanceName())
00733     self._compManager.unregisterObject(comp.getInstanceName())
00734     names = comp.getNamingNames()
00735     
00736     for name in names:
00737       self._rtcout.RTC_DEBUG("Unbind name: %s", name)
00738       self._namingManager.unbindObject(name)
00739 
00740     return True
00741 
00742 
00743   ##
00744   # @if jp
00745   # @brief RTコンポーネントにExecutionContextをバインドする
00746   #
00747   # 指定したRTコンポーネントにExecutionContextをバインドする。
00748   # バインドするExecutionContextの型はプロパティ・ファイルの
00749   # "exec_cxt.periodic.type"属性によって指定する。
00750   #
00751   # @param self
00752   # @param comp バインド対象RTコンポーネントのインスタンス
00753   #
00754   # @return バインド処理結果(バインド成功:true、失敗:false)
00755   #
00756   # @else
00757   # @brief Register RT-Component directly without Factory
00758   # @endif
00759   def bindExecutionContext(self, comp):
00760     self._rtcout.RTC_DEBUG("Manager::bindExecutionContext()")
00761     self._rtcout.RTC_DEBUG("ExecutionContext type: %s",
00762                  self._config.getProperty("exec_cxt.periodic.type"))
00763 
00764     rtobj = comp.getObjRef()
00765 
00766     exec_cxt = None
00767 
00768     if OpenRTM.isDataFlowParticipant(rtobj):
00769       ectype = self._config.getProperty("exec_cxt.periodic.type")
00770       exec_cxt = self._ecfactory.find(ectype).create()
00771       rate = self._config.getProperty("exec_cxt.periodic.rate")
00772       exec_cxt.set_rate(float(rate))
00773     else:
00774       ectype = self._config.getProperty("exec_cxt.evdriven.type")
00775       exec_cxt = self._ecfactory.find(ectype).create()
00776     exec_cxt.add(rtobj)
00777     exec_cxt.start()
00778     self._ecs.append(exec_cxt)
00779     return True
00780 
00781 
00782   ##
00783   # @if jp
00784   # @brief Manager に登録されているRTコンポーネントを削除する(未実装)
00785   #
00786   # マネージャに登録されているRTコンポーネントを削除する。
00787   #
00788   # @param self
00789   # @param instance_name 削除対象RTコンポーネントのインスタンス名
00790   #
00791   # @else
00792   # @brief Unregister RT-Component that is registered in the Manager
00793   # @endif
00794   def deleteComponent(self, instance_name):
00795     self._rtcout.RTC_DEBUG("Manager::deleteComponent(%s)", instance_name)
00796 
00797 
00798   ##
00799   # @if jp
00800   # @brief Manager に登録されているRTコンポーネントを検索する
00801   #
00802   # Manager に登録されているRTコンポーネントを指定した名称で検索し、
00803   # 合致するコンポーネントを取得する。
00804   #
00805   # @param self
00806   # @param instance_name 検索対象RTコンポーネントの名称
00807   #
00808   # @return 名称が一致するRTコンポーネントのインスタンス
00809   #
00810   # @else
00811   # @brief Get RT-Component's pointer
00812   # @endif
00813   def getComponent(self, instance_name):
00814     self._rtcout.RTC_DEBUG("Manager::getComponent(%s)", instance_name)
00815     return self._compManager.find(instance_name)
00816 
00817 
00818   ##
00819   # @if jp
00820   # @brief Manager に登録されている全RTコンポーネントを取得する
00821   #
00822   # Manager に登録されているRTコンポーネントの全インスタンスを取得する。
00823   #
00824   # @param self
00825   #
00826   # @return 全RTコンポーネントのインスタンスリスト
00827   #
00828   # @else
00829   # @brief Get all RT-Component's pointer
00830   # @endif
00831   def getComponents(self):
00832     self._rtcout.RTC_DEBUG("Manager::getComponents()")
00833     return self._compManager.getObjects()
00834 
00835 
00836   #============================================================
00837   # CORBA 関連
00838   #============================================================
00839 
00840   ##
00841   # @if jp
00842   # @brief ORB のポインタを取得する
00843   #
00844   # Manager に設定された ORB のポインタを取得する。
00845   #
00846   # @param self
00847   #
00848   # @return ORB オブジェクト
00849   #
00850   # @else
00851   # @brief Get the pointer to the ORB
00852   # @endif
00853   def getORB(self):
00854     self._rtcout.RTC_DEBUG("Manager::getORB()")
00855     return self._orb
00856 
00857 
00858   ##
00859   # @if jp
00860   # @brief Manager が持つ RootPOA のポインタを取得する
00861   #
00862   # Manager に設定された RootPOA へのポインタを取得する。
00863   #
00864   # @param self
00865   #
00866   # @return RootPOAオブジェクト
00867   #
00868   # @else
00869   # @brief Get the pointer to the RootPOA 
00870   # @endif
00871   def getPOA(self):
00872     self._rtcout.RTC_DEBUG("Manager::getPOA()")
00873     return self._poa
00874 
00875 
00876   ##
00877   # @if jp
00878   # @brief Manager が持つ POAManager を取得する
00879   #
00880   # Manager に設定された POAMAnager を取得する。
00881   #
00882   # @param self
00883   #
00884   # @return POAマネージャ
00885   #
00886   # @else
00887   #
00888   # @endif
00889   def getPOAManager(self):
00890     self._rtcout.RTC_DEBUG("Manager::getPOAManager()")
00891     return self._poaManager
00892 
00893 
00894 
00895   #============================================================
00896   # Manager initialize and finalization
00897   #============================================================
00898 
00899   ##
00900   # @if jp
00901   # @brief Manager の内部初期化処理
00902   # 
00903   # Manager の内部初期化処理を実行する。
00904   #  - Manager コンフィギュレーションの設定
00905   #  - ログ出力ファイルの設定
00906   #  - 終了処理用スレッドの生成
00907   #  - タイマ用スレッドの生成(タイマ使用時)
00908   #
00909   # @param self
00910   # @param argv コマンドライン引数
00911   # 
00912   # @else
00913   # @brief Manager internal initialization
00914   # @endif
00915   def initManager(self, argv):
00916     config = OpenRTM.ManagerConfig(argv)
00917     self._config = config.configure(OpenRTM.Properties())
00918     self._config.setProperty("logger.file_name",self.formatString(self._config.getProperty("logger.file_name"), self._config))
00919 
00920     self._module = OpenRTM.ModuleManager(self._config)
00921     self._terminator = self.Terminator(self)
00922     guard = ScopedLock(self._terminate.mutex)
00923     self._terminate.waiting = 0
00924     del guard
00925 
00926     if OpenRTM.toBool(self._config.getProperty("timer.enable"), "YES", "NO", True):
00927       tm = OpenRTM.TimeValue(0, 100000)
00928       tick = self._config.getProperty("timer.tick")
00929       if tick != "":
00930         tm = tm.set_time(float(tick))
00931         self._timer = OpenRTM.Timer(tm)
00932         self._timer.start()
00933 
00934 
00935   ##
00936   # @if jp
00937   # @brief Manager の終了処理(未実装)
00938   #
00939   # Manager を終了する
00940   # (ただし,現在は未実装)
00941   #
00942   # @param self
00943   #
00944   # @else
00945   #
00946   # @endif
00947   def shutdownManager(self):
00948     self._rtcout.RTC_DEBUG("Manager::shutdownManager()")
00949     if self._timer:
00950       self._timer.stop()
00951 
00952 
00953   #============================================================
00954   # Logger initialize and terminator
00955   #============================================================
00956 
00957   ##
00958   # @if jp
00959   # @brief System logger の初期化
00960   #
00961   # System logger の初期化を実行する。
00962   # コンフィギュレーションファイルに設定された情報に基づき、
00963   # ロガーの初期化,設定を実行する。
00964   #
00965   # @param self
00966   #
00967   # @return 初期化実行結果(初期化成功:true、初期化失敗:false)
00968   #
00969   # @else
00970   # @brief System logger initialization
00971   # @endif
00972   def initLogger(self):
00973     logfile = self._config.getProperty("logger.file_name")
00974     if logfile == "":
00975       logfile = "./rtc.log"
00976 
00977     if OpenRTM.toBool(self._config.getProperty("logger.enable"), "YES", "NO", True):
00978       self._Logbuf = OpenRTM.Logbuf(fileName = logfile)
00979       self._rtcout = OpenRTM.LogStream(self._Logbuf)
00980       self._rtcout.setLogLevel(self._config.getProperty("logger.log_level"))
00981       self._rtcout.setLogLock(OpenRTM.toBool(self._config.getProperty("logger.stream_lock"),
00982                           "enable", "disable", False))
00983 
00984       self._rtcout.RTC_INFO("%s", self._config.getProperty("openrtm.version"))
00985       self._rtcout.RTC_INFO("Copyright (C) 2003-2007")
00986       self._rtcout.RTC_INFO("  Noriaki Ando")
00987       self._rtcout.RTC_INFO("  Task-intelligence Research Group,")
00988       self._rtcout.RTC_INFO("  Intelligent Systems Research Institute, AIST")
00989       self._rtcout.RTC_INFO("Manager starting.")
00990       self._rtcout.RTC_INFO("Starting local logging.")
00991     else:
00992       self._rtcout = OpenRTM.LogStream()
00993 
00994     return True
00995 
00996 
00997   ##
00998   # @if jp
00999   # @brief System Logger の終了処理(未実装)
01000   #
01001   # System Loggerの終了処理を実行する。
01002   # (現在は未実装)
01003   #
01004   # @param self
01005   #
01006   # @else
01007   # @brief System Logger finalization
01008   # @endif
01009   def shutdownLogger(self):
01010     self._rtcout.RTC_DEBUG("Manager::shutdownLogger()")
01011 
01012 
01013   #============================================================
01014   # ORB initialization and finalization
01015   #============================================================
01016 
01017   ##
01018   # @if jp
01019   # @brief CORBA ORB の初期化処理
01020   #
01021   # 設定情報を元にORBを初期化する。
01022   #
01023   # @param self
01024   #
01025   # @return ORB 初期化処理結果(初期化成功:true、初期化失敗:false)
01026   #
01027   # @else
01028   # @brief CORBA ORB initialization
01029   # @endif
01030   def initORB(self):
01031     self._rtcout.RTC_DEBUG("Manager::initORB()")
01032 
01033     try:
01034       args = OpenRTM.split(self.createORBOptions(), " ")
01035       argv = OpenRTM.toArgv(args)
01036       self._orb = CORBA.ORB_init(argv)
01037 
01038       self._poa = self._orb.resolve_initial_references("RootPOA")
01039 
01040       if CORBA.is_nil(self._poa):
01041         self._rtcout.RTC_ERROR("Could not resolve RootPOA")
01042         return False
01043 
01044       self._poaManager = self._poa._get_the_POAManager()
01045       self._objManager = OpenRTM.CorbaObjectManager(self._orb, self._poa)
01046     except:
01047       self._rtcout.RTC_ERROR("Exception: Caught unknown exception in initORB().")
01048       return False
01049 
01050     return True
01051 
01052 
01053   ##
01054   # @if jp
01055   # @brief ORB のコマンドラインオプション作成
01056   #
01057   # コンフィギュレーション情報に設定された内容から
01058   # ORB の起動時オプションを作成する。
01059   #
01060   # @param self
01061   #
01062   # @return ORB 起動時オプション
01063   #
01064   # @else
01065   # @brief ORB command option creation
01066   # @endif
01067   def createORBOptions(self):
01068     opt      = self._config.getProperty("corba.args")
01069     corba    = self._config.getProperty("corba.id")
01070     endpoint = self._config.getProperty("corba.endpoint")
01071 
01072     if endpoint != "":
01073       if opt != "":
01074         opt += " "
01075       if corba == "omniORB":
01076         opt = "-ORBendPoint giop:tcp:" + endpoint
01077       elif corba == "TAO":
01078         opt = "-ORBEndPoint iiop://" + endpoint
01079       elif corba == "MICO":
01080         opt = "-ORBIIOPAddr inet:" + endpoint
01081     return opt
01082 
01083 
01084   ##
01085   # @if jp
01086   # @brief ORB の終了処理
01087   #
01088   # ORB の終了処理を実行する。
01089   # 実行待ちの処理が存在する場合には、その処理が終了するまで待つ。
01090   # 実際の終了処理では、POA Managerを非活性化し、 ORB のシャットダウンを実行
01091   # する。
01092   #
01093   # @param self
01094   #
01095   # @else
01096   # @brief ORB finalization
01097   # @endif
01098   def shutdownORB(self):
01099     self._rtcout.RTC_DEBUG("Manager::shutdownORB()")
01100     try:
01101       while self._orb.work_pending():
01102         self._rtcout.RTC_PARANOID("Pending work still exists.")
01103         if self._orb.work_pending():
01104           self._orb.perform_work()
01105     except:
01106       traceback.print_exception(*sys.exc_info())
01107       pass
01108 
01109     self._rtcout.RTC_DEBUG("No pending works of ORB. Shutting down POA and ORB.")
01110 
01111     if not CORBA.is_nil(self._poa):
01112       try:
01113         if not CORBA.is_nil(self._poaManager):
01114           self._poaManager.deactivate(False, True)
01115         self._rtcout.RTC_DEBUG("POA Manager was deactivated.")
01116         self._poa.destroy(False, True)
01117         self._poa = PortableServer.POA._nil
01118         self._rtcout.RTC_DEBUG("POA was destroid.")
01119       except CORBA.SystemException, ex:
01120         self._rtcout.RTC_ERROR("Caught SystemException during root POA destruction")
01121       except:
01122         self._rtcout.RTC_ERROR("Caught unknown exception during destruction")
01123 
01124     if self._orb:
01125       try:
01126         self._orb.shutdown(True)
01127         self._rtcout.RTC_DEBUG("ORB was shutdown.")
01128         self._orb = CORBA.Object._nil
01129       except CORBA.SystemException, ex:
01130         self._rtcout.RTC_ERROR("Caught CORBA::SystemException during ORB shutdown.")
01131       except:
01132         self._rtcout.RTC_ERROR("Caught unknown exception during ORB shutdown.")
01133 
01134 
01135   #============================================================
01136   # NamingService initialization and finalization
01137   #============================================================
01138 
01139   ##
01140   # @if jp
01141   # @brief NamingManager の初期化
01142   #
01143   # NamingManager の初期化処理を実行する。
01144   # ただし、 NamingManager を使用しないようにプロパティ情報に設定されている
01145   # 場合には何もしない。
01146   # NamingManager を使用する場合、プロパティ情報に設定されている
01147   # デフォルト NamingServer を登録する。
01148   # また、定期的に情報を更新するように設定されている場合には、指定された周期
01149   # で自動更新を行うためのタイマを起動するとともに、更新用メソッドをタイマに
01150   # 登録する。
01151   #
01152   # @param self
01153   #
01154   # @return 初期化処理結果(初期化成功:true、初期化失敗:false)
01155   #
01156   # @else
01157   #
01158   # @endif
01159   def initNaming(self):
01160     self._rtcout.RTC_DEBUG("Manager::initNaming()")
01161     self._namingManager = OpenRTM.NamingManager(self)
01162 
01163     if not OpenRTM.toBool(self._config.getProperty("naming.enable"), "YES", "NO", True):
01164       return True
01165 
01166     meths = OpenRTM.split(self._config.getProperty("naming.type"),",")
01167     
01168     for meth in meths:
01169       names = OpenRTM.split(self._config.getProperty(meth+".nameservers"), ",")
01170       for name in names:
01171         self._rtcout.RTC_DEBUG("Register Naming Server: %s/%s", (meth, name))
01172         self._namingManager.registerNameServer(meth,name)
01173 
01174     if OpenRTM.toBool(self._config.getProperty("naming.update.enable"), "YES", "NO", True):
01175       tm = OpenRTM.TimeValue(10,0)
01176       intr = self._config.getProperty("naming.update.interval")
01177       if intr != "":
01178         tm = OpenRTM.TimeValue(intr)
01179 
01180       if self._timer:
01181         self._timer.registerListenerObj(self._namingManager,OpenRTM.NamingManager.update,tm)
01182   
01183     return True
01184 
01185 
01186   ##
01187   # @if jp
01188   # @brief NamingManager の終了処理
01189   #
01190   # NamingManager を終了する。
01191   # 登録されている全要素をアンバインドし、終了する。
01192   #
01193   # @param self
01194   #
01195   # @else
01196   #
01197   # @endif
01198   def shutdownNaming(self):
01199     self._rtcout.RTC_DEBUG("Manager::shutdownNaming()")
01200     self._namingManager.unbindAll()
01201 
01202 
01203   ##
01204   # @if jp
01205   # @brief ExecutionContextManager の初期化
01206   #
01207   # 使用する各 ExecutionContext の初期化処理を実行し、各 ExecutionContext 
01208   # 生成用 Factory を ExecutionContextManager に登録する。
01209   #
01210   # @param self
01211   #
01212   # @return ExecutionContextManager 初期化処理実行結果
01213   #         (初期化成功:true、初期化失敗:false)
01214   #
01215   # @else
01216   #
01217   # @endif
01218   def initExecContext(self):
01219     self._rtcout.RTC_DEBUG("Manager::initExecContext()")
01220     OpenRTM.PeriodicExecutionContextInit(self)
01221     OpenRTM.ExtTrigExecutionContextInit(self)
01222     return True
01223 
01224 
01225   ##
01226   # @if jp
01227   # @brief Timer の初期化
01228   #
01229   # 使用する各 Timer の初期化処理を実行する。
01230   # (現状の実装では何もしない)
01231   #
01232   # @param self
01233   #
01234   # @return Timer 初期化処理実行結果(初期化成功:true、初期化失敗:false)
01235   #
01236   # @else
01237   #
01238   # @endif
01239   def initTimer(self):
01240     return True
01241 
01242 
01243   ##
01244   # @if jp
01245   # @brief NamingManager に登録されている全コンポーネントの終了処理
01246   #
01247   # NamingManager に登録されているRTコンポーネントおよび ExecutionContext の
01248   # リストを取得し、全コンポーネントを終了する。
01249   #
01250   # @param self
01251   #
01252   # @else
01253   #
01254   # @endif
01255   def shutdownComponents(self):
01256     self._rtcout.RTC_DEBUG("Manager::shutdownComponents()")
01257     comps = self._namingManager.getObjects()
01258     for comp in comps:
01259       try:
01260         comp.exit()
01261         p = OpenRTM.Properties(key=comp.getInstanceName())
01262         p.mergeProperties(comp.getProperties())
01263       except:
01264         traceback.print_exception(*sys.exc_info())
01265         pass
01266 
01267     for ec in self._ecs:
01268       try:
01269         self._poa.deactivate_object(self._poa.servant_to_id(ec))
01270       except:
01271         traceback.print_exception(*sys.exc_info())
01272         pass
01273 
01274 
01275   ##
01276   # @if jp
01277   # @brief RTコンポーネントの登録解除
01278   #
01279   # 指定したRTコンポーネントのインスタンスをネーミングサービスから
01280   # 登録解除する。
01281   #
01282   # @param self
01283   # @param comp 登録解除対象RTコンポーネント
01284   #
01285   # @else
01286   #
01287   # @endif
01288   def cleanupComponent(self, comp):
01289     self._rtcout.RTC_DEBUG("Manager::cleanupComponents")
01290     self.unregisterComponent(comp)
01291 
01292 
01293   ##
01294   # @if jp
01295   # @brief RTコンポーネントのコンフィギュレーション処理
01296   #
01297   # RTコンポーネントの型およびインスタンス毎に記載されたプロパティファイルの
01298   # 情報を読み込み、コンポーネントに設定する。
01299   # また、各コンポーネントの NamingService 登録時の名称を取得し、設定する。
01300   #
01301   # @param self
01302   # @param comp コンフィギュレーション対象RTコンポーネント
01303   #
01304   # @else
01305   #
01306   # @endif
01307   def configureComponent(self, comp):
01308     category  = comp.getCategory()
01309     type_name = comp.getTypeName()
01310     inst_name = comp.getInstanceName()
01311 
01312     type_conf = category + "." + type_name + ".config_file"
01313     name_conf = category + "." + inst_name + ".config_file"
01314 
01315     type_prop = OpenRTM.Properties()
01316 
01317     name_prop = OpenRTM.Properties()
01318 
01319     if self._config.getProperty(name_conf) != "":
01320       try:
01321         conff = open(self._config.getProperty(name_conf))
01322       except:
01323         print "Not found. : %s" % self._config.getProperty(name_conf)
01324       else:
01325         name_prop.load(conff)
01326 
01327     if self._config.getProperty(type_conf) != "":
01328       try:
01329         conff = open(self._config.getProperty(type_conf))
01330       except:
01331         print "Not found. : %s" % self._config.getProperty(type_conf)
01332       else:
01333         type_prop.load(conff)
01334 
01335     type_prop = type_prop.mergeProperties(name_prop)
01336     comp.getProperties().mergeProperties(type_prop)
01337 
01338     naming_formats = ""
01339     comp_prop = OpenRTM.Properties(prop=comp.getProperties())
01340 
01341     naming_formats += self._config.getProperty("naming.formats")
01342     naming_formats += ", " + comp_prop.getProperty("naming.formats")
01343 
01344     naming_formats = OpenRTM.flatten(OpenRTM.unique_sv(OpenRTM.split(naming_formats, ",")))
01345 
01346     naming_names = self.formatString(naming_formats, comp.getProperties())
01347     comp.getProperties().setProperty("naming.formats",naming_formats)
01348     comp.getProperties().setProperty("naming.names",naming_names)
01349 
01350 
01351   ##
01352   # @if jp
01353   # @brief プロパティ情報のマージ
01354   #
01355   # 指定されたファイル内に設定されているプロパティ情報をロードし、
01356   # 既存の設定済みプロパティとマージする。
01357   #
01358   # @param self
01359   # @param prop マージ対象プロパティ
01360   # @param file_name プロパティ情報が記述されているファイル名
01361   #
01362   # @return マージ処理実行結果(マージ成功:true、マージ失敗:false)
01363   #
01364   # @else
01365   #
01366   # @endif
01367   def mergeProperty(self, prop, file_name):
01368     if file_name == "":
01369       self._rtcout.RTC_ERROR("Invalid configuration file name.")
01370       return False
01371 
01372     if file_name[0] != '\0':
01373       
01374       try:
01375         conff = open(file_name)
01376       except:
01377         print "Not found. : %s" % file_name
01378       else:
01379         prop.load(conff)
01380         conff.close()
01381         return True
01382 
01383     return False
01384 
01385   ##
01386   # @if jp
01387   # @brief NamingServer に登録する際の登録情報を組み立てる
01388   #
01389   # 指定された書式とプロパティ情報を基に NameServer に登録する際の情報を
01390   # 組み立てる。
01391   # 各書式指定用文字の意味は以下のとおり
01392   # - % : コンテキストの区切り
01393   # - n : インスタンス名称
01394   # - t : 型名
01395   # - m : 型名
01396   # - v : バージョン
01397   # - V : ベンダー
01398   # - c : カテゴリ
01399   # - h : ホスト名
01400   # - M : マネージャ名
01401   # - p : プロセスID
01402   #
01403   # @param self
01404   # @param naming_format NamingService 登録情報書式指定
01405   # @param prop 使用するプロパティ情報
01406   #
01407   # @return 指定書式変換結果
01408   #
01409   # @else
01410   #
01411   # @endif
01412   def formatString(self, naming_format, prop):
01413     name_ = naming_format
01414     str_  = ""
01415     count = 0
01416 
01417     for n in name_:
01418       if n == '%':
01419         count+=1
01420         if not (count % 2):
01421           str_ += n
01422       else:
01423         if  count > 0 and (count % 2):
01424           count = 0
01425           if   n == "n": str_ += prop.getProperty("instance_name")
01426           elif n == "t": str_ += prop.getProperty("type_name")
01427           elif n == "m": str_ += prop.getProperty("type_name")
01428           elif n == "v": str_ += prop.getProperty("version")
01429           elif n == "V": str_ += prop.getProperty("vendor")
01430           elif n == "c": str_ += prop.getProperty("category")
01431           elif n == "h": str_ += self._config.getProperty("manager.os.hostname")
01432           elif n == "M": str_ += self._config.getProperty("manager.name")
01433           elif n == "p": str_ += str(self._config.getProperty("manager.pid"))
01434           else: str_ += n
01435         else:
01436           count = 0
01437           str_ += n
01438 
01439     return str_
01440 
01441 
01442   ##
01443   # @if jp
01444   # @brief ログバッファの取得
01445   #
01446   # マネージャに設定したログバッファを取得する。
01447   #
01448   # @param self
01449   #
01450   # @return マネージャに設定したログバッファ
01451   #
01452   # @else
01453   #
01454   # @endif
01455   def getLogbuf(self):
01456     return self._rtcout
01457 
01458 
01459   ##
01460   # @if jp
01461   # @brief マネージャコンフィギュレーションの取得
01462   #
01463   # マネージャに設定したコンフィギュレーションを取得する。
01464   #
01465   # @param self
01466   #
01467   # @return マネージャのコンフィギュレーション
01468   #
01469   # @else
01470   #
01471   # @endif
01472   def getConfig(self):
01473     return self._config
01474 
01475 
01476   #============================================================
01477   # コンポーネントマネージャ
01478   #============================================================
01479   ##
01480   # @if jp
01481   # @class InstanceName
01482   # @brief ObjectManager 検索用ファンクタ
01483   #
01484   # @else
01485   #
01486   # @endif
01487   class InstanceName:
01488 
01489 
01490 
01491     ##
01492     # @if jp
01493     # @brief コンストラクタ
01494     #
01495     # コンストラクタ
01496     #
01497     # @param self
01498     # @param name 検索対象コンポーネント名称(デフォルト値:None)
01499     # @param factory 検索対象ファクトリ名称(デフォルト値:None)
01500     #
01501     # @else
01502     #
01503     # @endif
01504     def __init__(self, name=None, factory=None):
01505       if factory:
01506         self._name = factory.getInstanceName()
01507       elif name:
01508         self._name = name
01509 
01510     def __call__(self, factory):
01511       return self._name == factory.getInstanceName()
01512 
01513 
01514 
01515   #============================================================
01516   # コンポーネントファクトリ
01517   #============================================================
01518   ##
01519   # @if jp
01520   # @class FactoryPredicate
01521   # @brief コンポーネントファクトリ検索用ファンクタ
01522   #
01523   # @else
01524   #
01525   # @endif
01526   class FactoryPredicate:
01527 
01528 
01529 
01530     def __init__(self, name=None, factory=None):
01531       if name:
01532         self._name = name
01533       elif factory:
01534         self._name = factory.profile().getProperty("implementation_id")
01535 
01536     def __call__(self, factory):
01537       return self._name == factory.profile().getProperty("implementation_id")
01538 
01539 
01540 
01541   #============================================================
01542   # ExecutionContextファクトリ
01543   #============================================================
01544   ##
01545   # @if jp
01546   # @class FactoryPredicate
01547   # @brief ExecutionContextファクトリ検索用ファンクタ
01548   #
01549   # @else
01550   #
01551   # @endif
01552   class ECFactoryPredicate:
01553 
01554 
01555 
01556     def __init__(self, name=None, factory=None):
01557       if name:
01558         self._name = name
01559       elif factory:
01560         self._name = factory.name()
01561 
01562     def __call__(self, factory):
01563       return self._name == factory.name()
01564 
01565 
01566   #------------------------------------------------------------
01567   # ORB runner
01568   #------------------------------------------------------------
01569   ##
01570   # @if jp
01571   # @class OrbRunner
01572   # @brief OrbRunner クラス
01573   #
01574   # ORB 実行用ヘルパークラス。
01575   #
01576   # @since 0.4.0
01577   #
01578   # @else
01579   # @class OrbRunner
01580   # @brief OrbRunner class
01581   # @endif
01582   class OrbRunner:
01583 
01584 
01585 
01586     ##
01587     # @if jp
01588     # @brief コンストラクタ
01589     #
01590     # コンストラクタ
01591     #
01592     # @param self
01593     # @param orb ORB
01594     #
01595     # @else
01596     # @brief Constructor
01597     #
01598     # @endif
01599     def __init__(self, orb):
01600       self._orb = orb
01601       self._th = threading.Thread(target=self.run)
01602       self._th.start()
01603       self._evt = threading.Event()
01604 
01605 
01606     ##
01607     # @if jp
01608     # @brief ORB 実行処理
01609     #
01610     # ORB 実行
01611     #
01612     # @param self
01613     #
01614     # @else
01615     #
01616     # @endif
01617     def run(self):
01618       try:
01619         self._orb.run()
01620         #Manager.instance().shutdown()
01621         self._evt.set()
01622       except:
01623         traceback.print_exception(*sys.exc_info())
01624         pass
01625       self._evt.set()
01626       return
01627 
01628 
01629     ##
01630     # @if jp
01631     # @brief ORB wait処理
01632     #
01633     # ORB wait
01634     #
01635     # @param self
01636     #
01637     # @else
01638     #
01639     # @endif
01640     def wait(self):
01641       self._evt.wait()
01642 
01643     ##
01644     # @if jp
01645     # @brief ORB 終了処理(未実装)
01646     #
01647     # ORB 終了処理
01648     #
01649     # @param self
01650     # @param flags 終了処理フラグ
01651     #
01652     # @return 終了処理結果
01653     #
01654     # @else
01655     #
01656     # @endif
01657     def close(self, flags):
01658       return 0
01659 
01660 
01661   #------------------------------------------------------------
01662   # Manager Terminator
01663   #------------------------------------------------------------
01664   ##
01665   # @if jp
01666   # @class Terminator
01667   # @brief Terminator クラス
01668   #
01669   # ORB 終了用ヘルパークラス。
01670   #
01671   # @since 0.4.0
01672   #
01673   # @else
01674   #
01675   # @endif
01676   class Terminator:
01677 
01678 
01679 
01680     ##
01681     # @if jp
01682     # @brief コンストラクタ
01683     #
01684     # コンストラクタ
01685     #
01686     # @param self
01687     # @param manager マネージャ・オブジェクト
01688     #
01689     # @else
01690     # @brief Constructor
01691     #
01692     # @endif
01693     def __init__(self, manager):
01694       self._manager = manager
01695 
01696 
01697     ##
01698     # @if jp
01699     # @brief 終了処理
01700     #
01701     # ORB,マネージャ終了処理を開始する。
01702     #
01703     # @param self
01704     #
01705     # @else
01706     #
01707     # @endif
01708     def terminate(self):
01709       self._manager.shutdown()
01710 
01711 
01712 
01713   ##
01714   # @if jp
01715   # @class Term
01716   # @brief Term クラス
01717   #
01718   # 終了用ヘルパークラス。
01719   #
01720   # @since 0.4.0
01721   #
01722   # @else
01723   #
01724   # @endif
01725   class Term:
01726 
01727 
01728 
01729     def __init__(self):
01730       self.waiting = 0
01731       self.mutex   = threading.RLock()

OpenRTMに対してMon Mar 17 15:11:05 2008に生成されました。  doxygen 1.5.4