PeriodicECSharedComposite.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: euc-jp -*-



import string
import sys
import time

from omniORB import CORBA
import OpenRTM
import RTC
import OpenRTM_aist


periodicecsharedcomposite_spec = ["implementation_id", "PeriodicECSharedComposite",
                                  "type_name",         "PeriodicECSharedComposite",
                                  "description",       "PeriodicECSharedComposite",
                                  "version",           "1.0",
                                  "vendor",            "jp.go.aist",
                                  "category",          "composite.PeriodicECShared",
                                  "activity_type",     "DataFlowComponent",
                                  "max_instance",      "0",
                                  "language",          "Python",
                                  "lang_type",         "script",
                                  "exported_ports",    "",
                                  "conf.default.members", "",
                                  "conf.default.exported_ports", "",
                                  ""]
                                  

def stringToStrVec(v, _is):
  str = [_is]
  OpenRTM_aist.eraseBlank(str)
  v[0] = str[0].split(",")
  return True


class setCallback(OpenRTM_aist.ConfigurationSetListener):
  def __init__(self, org):
    self._org = org
    pass

  def __call__(self, config_set):
    self._org.updateDelegatedPorts()



class addCallback(OpenRTM_aist.ConfigurationSetListener):
  def __init__(self, org):
    self._org = org
    pass

  def __call__(self, config_set):
    self._org.updateDelegatedPorts()
    return



class PeriodicECOrganization(OpenRTM_aist.Organization_impl):


  
  def __init__(self, rtobj):
    OpenRTM_aist.Organization_impl.__init__(self,rtobj.getObjRef())
    self._rtobj      = rtobj
    self._ec         = None
    self._rtcMembers = []
    self._rtcout = OpenRTM_aist.Manager.instance().getLogbuf("rtobject.PeriodicECOrganization")
    self._expPorts = []
    return


  
  def add_members(self, sdo_list):
    self._rtcout.RTC_DEBUG("add_members()")
    self.updateExportedPortsList()
    for sdo in sdo_list:
      dfc = [None]
      if not self.sdoToDFC(sdo, dfc):
        continue
      member = self.Member(dfc[0])
      self.stopOwnedEC(member)
      self.addOrganizationToTarget(member)
      self.addParticipantToEC(member)
      self.addPort(member, self._expPorts)
      self._rtcMembers.append(member)

    result = OpenRTM_aist.Organization_impl.add_members(self,sdo_list)

    return result


  
  def set_members(self, sdo_list):
    self._rtcout.RTC_DEBUG("set_members()")
    # self._rtcMembers = []
    self.removeAllMembers()
    self.updateExportedPortsList()

    for sdo in sdo_list:
      dfc = [None]
      if not self.sdoToDFC(sdo, dfc):
        continue
      
      member = self.Member(dfc[0])
      self.stopOwnedEC(member)
      self.addOrganizationToTarget(member)
      self.addParticipantToEC(member)
      self.addPort(member, self._expPorts)
      self._rtcMembers.append(member)
      
    result = OpenRTM_aist.Organization_impl.set_members(self, sdo_list)

    return result


  
  def remove_member(self, id):
    self._rtcout.RTC_DEBUG("remove_member(id = %s)", id)
    rm_rtc = []
    for member in self._rtcMembers:
      if str(id) != str(member._profile.instance_name):
        continue
      self.removePort(member, self._expPorts)
      self._rtobj.getProperties().setProperty("conf.default.exported_ports", OpenRTM_aist.flatten(self._expPorts))
      self.removeParticipantFromEC(member)
      self.removeOrganizationFromTarget(member)
      self.startOwnedEC(member)
      rm_rtc.append(member)

    for m in rm_rtc:
      self._rtcMembers.remove(m)
            
    result = OpenRTM_aist.Organization_impl.remove_member(self, id)
    return result


  
  def removeAllMembers(self):
    self._rtcout.RTC_DEBUG("removeAllMembers()")
    self.updateExportedPortsList()
    for member in self._rtcMembers:
      self.removePort(member, self._expPorts)
      self.removeParticipantFromEC(member)
      self.removeOrganizationFromTarget(member)
      self.startOwnedEC(member)
      OpenRTM_aist.Organization_impl.remove_member(self, member._profile.instance_name)

    self._rtcMembers = []
    self._expPorts   = []
    return

        
  
  def sdoToDFC(self, sdo, dfc):
    if CORBA.is_nil(sdo):
      return False

    dfc[0] = sdo._narrow(OpenRTM.DataFlowComponent)
    if CORBA.is_nil(dfc[0]):
      return False

    return True


  
  def stopOwnedEC(self, member):
    ecs = member._eclist
    for ec in ecs:
      ret = ec.stop()

    return


  
  def startOwnedEC(self, member):
    ecs = member._eclist
    for ec in ecs:
      ret = ec.start()

    return


  
  def addOrganizationToTarget(self, member):
    conf = member._config
    if CORBA.is_nil(conf):
      return

    conf.add_organization(self._objref)
    return


  
  def removeOrganizationFromTarget(self, member):
    # get given RTC's configuration object
    if CORBA.is_nil(member._config):
      return
    
    # set organization to target RTC's conf
    ret = member._config.remove_organization(self._pId)
    return


  
  def addParticipantToEC(self, member):
    if CORBA.is_nil(self._ec) or self._ec is None:
      ecs = self._rtobj.get_owned_contexts()
      if len(ecs) > 0:
        self._ec = ecs[0]
      else:
        return
    # set ec to target RTC
    ret = self._ec.add_component(member._rtobj)

    orglist = member._rtobj.get_organizations()
    for org in orglist:
      sdos = org.get_members()
      for sdo in sdos:
        dfc = [None]
        if not self.sdoToDFC(sdo, dfc):
          continue
        self._ec.add_component(dfc[0])
    return


  
  def removeParticipantFromEC(self, member):
    if CORBA.is_nil(self._ec) or self._ec is None:
      ecs = self._rtobj.get_owned_contexts()
      if len(ecs) > 0:
        self._ec = ecs[0]
      else:
        self._rtcout.RTC_FATAL("no owned EC")
        return
    self._ec.remove_component(member._rtobj)

    orglist = member._rtobj.get_organizations()

    for org in orglist:
      sdos = org.get_members()
      for sdo in sdos:
        dfc = [None]
        if not self.sdoToDFC(sdo, dfc):
          continue
        self._ec.remove_component(dfc[0])
    return


  

  
  def addPort(self, member, portlist):
    self._rtcout.RTC_TRACE("addPort(%s)", OpenRTM_aist.flatten(portlist))
    if len(portlist) == 0:
      return
        
    comp_name = member._profile.instance_name
    plist = member._profile.port_profiles
      
    # port delegation
    for prof in plist:
      # port name -> comp_name.port_name
      port_name = prof.name

      self._rtcout.RTC_DEBUG("port_name: %s is in %s?", (port_name,OpenRTM_aist.flatten(portlist)))
      if not port_name in portlist:
        self._rtcout.RTC_DEBUG("Not found: %s is in %s?", (port_name,OpenRTM_aist.flatten(portlist)))
        continue

      self._rtcout.RTC_DEBUG("Found: %s is in %s", (port_name,OpenRTM_aist.flatten(portlist)))
      self._rtobj.addPort(prof.port_ref)
      self._rtcout.RTC_DEBUG("Port %s was delegated.", port_name)

    return


  
  def removePort(self, member, portlist):
    self._rtcout.RTC_DEBUG("removePort()")
    if len(portlist) == 0:
      return

    comp_name = member._profile.instance_name
    plist = member._profile.port_profiles
    
    # port delegation
    for prof in plist:
      # port name -> comp_name.port_name
      port_name = prof.name
        
      self._rtcout.RTC_DEBUG("port_name: %s is in %s?", (port_name,OpenRTM_aist.flatten(portlist)))
      if not port_name in portlist:
        self._rtcout.RTC_DEBUG("Not found: %s is in %s?", (port_name,OpenRTM_aist.flatten(portlist)))
        continue

      self._rtcout.RTC_DEBUG("Found: %s is in %s", (port_name,OpenRTM_aist.flatten(portlist)))
      self._rtobj.removePort(prof.port_ref)
      portlist.remove(port_name)
      self._rtcout.RTC_DEBUG("Port %s was deleted.", port_name)

    return


  
  def updateExportedPortsList(self):
    plist = self._rtobj.getProperties().getProperty("conf.default.exported_ports")
    if plist:
      p = [plist]
      OpenRTM_aist.eraseBlank(p)
      self._expPorts = p[0].split(",")

    return

  
  def updateDelegatedPorts(self):
    oldPorts = self._expPorts
    ports = self._rtobj.getProperties().getProperty("conf.default.exported_ports")
    newPorts = ports.split(",")

    
    removedPorts = list(set(oldPorts).difference(set(newPorts)))
    createdPorts = list(set(newPorts).difference(set(oldPorts)))
    
    self._rtcout.RTC_VERBOSE("old    ports: %s", OpenRTM_aist.flatten(oldPorts))
    self._rtcout.RTC_VERBOSE("new    ports: %s", OpenRTM_aist.flatten(newPorts))
    self._rtcout.RTC_VERBOSE("remove ports: %s", OpenRTM_aist.flatten(removedPorts))
    self._rtcout.RTC_VERBOSE("add    ports: %s", OpenRTM_aist.flatten(createdPorts))

    for member in self._rtcMembers:
      self.removePort(member, removedPorts)
      self.addPort(member, createdPorts)

    self._expPorts = newPorts
    return


  class Member:
    def __init__(self, rtobj):
      self._rtobj   = rtobj
      self._profile = rtobj.get_component_profile()
      self._eclist  = rtobj.get_owned_contexts()
      self._config  = rtobj.get_configuration()
      return
            
    def __call__(self, x):
      tmp = x
      tmp.swap(self)
      return self

        
    def swap(self, x):
      rtobj   = x._rtobj
      profile = x._profile
      eclist  = x._eclist
      config  = x._config
      
      x._rtobj   = self._rtobj
      x._profile = self._profile
      x._eclist  = self._eclist
      x._config  = self._config

      self._rtobj   = rtobj
      self._profile = profile
      self._eclist  = eclist
      self._config  = config
      return
            




class PeriodicECSharedComposite(OpenRTM_aist.RTObject_impl):


  
  def __init__(self, manager):
    OpenRTM_aist.RTObject_impl.__init__(self,manager)
    self._ref = self._this()
    self._objref = self._ref
    self._org = OpenRTM_aist.PeriodicECOrganization(self)
    OpenRTM_aist.CORBA_SeqUtil.push_back(self._sdoOwnedOrganizations,
                                         self._org.getObjRef())

    self._members = [[]]
    self.bindParameter("members", self._members, "", stringToStrVec)
    self._rtcout = OpenRTM_aist.Manager.instance().getLogbuf("rtobject.periodic_ec_shared")
    self._configsets.addConfigurationSetListener(\
      OpenRTM_aist.ConfigurationSetListenerType.ON_SET_CONFIG_SET,
      setCallback(self._org))

    self._configsets.addConfigurationSetListener(\
      OpenRTM_aist.ConfigurationSetListenerType.ON_ADD_CONFIG_SET,
      addCallback(self._org))

    return


  
  def __del__(self):
    self._rtcout.RTC_TRACE("destructor of PeriodicECSharedComposite")
    pass

    
  
  def onInitialize(self):
    self._rtcout.RTC_TRACE("onInitialize()")

    active_set = self._properties.getProperty("configuration.active_config",
                                              "default")
    if self._configsets.haveConfig(active_set):
      self._configsets.update(active_set)
    else:
      self._configsets.update("default")

    mgr = OpenRTM_aist.Manager.instance()
    sdos = []
    for member in self._members[0]:
      if member == "":
        continue

      rtc = mgr.getComponent(member)

      if rtc is None:
        print "no RTC found: ", member
        continue

      sdo = rtc.getObjRef()
      if CORBA.is_nil(sdo):
        continue

      OpenRTM_aist.CORBA_SeqUtil.push_back(sdos, sdo)
    
    try:
      self._org.set_members(sdos)
    except:
      self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())

    return RTC.RTC_OK


  
  def onActivated(self, exec_handle):
    self._rtcout.RTC_TRACE("onActivated(%d)", exec_handle)
    ecs = self.get_owned_contexts()
    sdos = self._org.get_members()

    for sdo in sdos:
      rtc = sdo._narrow(RTC.RTObject)
      ecs[0].activate_component(rtc)

    len_ = len(self._members[0])

    # since Python 2.5
    # self._rtcout.RTC_DEBUG("%d member RTC%s activated.", (len_,(lambda x:  if x > 1 else "was")(len_)))
    if len_ > 1:
      str_ = "s were"
    else:
      str_ = "was"

    self._rtcout.RTC_DEBUG("%d member RTC%s activated.", (len_, str_))

    return RTC.RTC_OK


  
  def onDeactivated(self, exec_handle):
    self._rtcout.RTC_TRACE("onDeactivated(%d)", exec_handle)
    ecs = self.get_owned_contexts()
    sdos = self._org.get_members()

    for sdo in sdos:
      rtc = sdo._narrow(RTC.RTObject)
      ecs[0].deactivate_component(rtc)

    return RTC.RTC_OK


  
  def onReset(self, exec_handle):
    self._rtcout.RTC_TRACE("onReset(%d)", exec_handle)
    ecs = self.get_owned_contexts()
    sdos = self._org.get_members()

    for sdo in sdos:
      rtc = sdo._narrow(RTC.RTObject)
      ecs[0].reset_component(rtc)

    return RTC.RTC_OK


  
  def onFinalize(self):
    self._rtcout.RTC_TRACE("onFinalize()")
    self._org.removeAllMembers()
    self._rtcout.RTC_PARANOID("onFinalize() done")
    return RTC.RTC_OK


    
def PeriodicECSharedCompositeInit(manager):
  profile = OpenRTM_aist.Properties(defaults_str=periodicecsharedcomposite_spec)
  manager.registerFactory(profile,
                          OpenRTM_aist.PeriodicECSharedComposite,
                          OpenRTM_aist.Delete)