def createConnector(self, cprof, prop, provider_=None, consumer_=None):
profile = OpenRTM_aist.ConnectorInfo(
cprof.name, cprof.connector_id,
OpenRTM_aist.CORBA_SeqUtil.refToVstring(cprof.ports), prop)
connector = None
try:
if provider_ is not None:
if self._singlebuffer:
connector = OpenRTM_aist.InPortPushConnector(
profile, provider_, self._listeners, self._thebuffer)
else:
connector = OpenRTM_aist.InPortPushConnector(
profile, provider_, self._listeners)
elif consumer_ is not None:
if self._singlebuffer:
connector = OpenRTM_aist.InPortPullConnector(
profile, consumer_, self._listeners, self._thebuffer)
else:
connector = OpenRTM_aist.InPortPullConnector(
profile, consumer_, self._listeners)
else:
self._rtcout.RTC_ERROR(
"provider or consumer is not passed. returned 0;")
return None
# if connector is None:
# self._rtcout.RTC_ERROR("InPortConnector creation failed")
# return 0
if provider_ is not None:
self._rtcout.RTC_TRACE("InPortPushConnector created")
elif consumer_ is not None:
self._rtcout.RTC_TRACE("InPortPullConnector created")
if OpenRTM_aist.StringUtil.normalize(
prop.getProperty("interface_type")) == "direct":
if consumer_ is not None:
outport = self.getLocalOutPort(profile)
if outport is None:
self._rtcout.RTC_TRACE("interface_type is direct, ")
self._rtcout.RTC_TRACE(
"but a peer OutPort servant could not be obtained."
)
del connector
return None
connector.setOutPort(outport)
# guard = OpenRTM_aist.ScopedLock(self._connector_mutex)
self._connectors.append(connector)
self._rtcout.RTC_PARANOID("connector push backed: %d",
len(self._connectors))
return connector
except BaseException:
self._rtcout.RTC_ERROR("InPortPushConnector creation failed")
self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
return None
def test_pushSkip(self):
_pn = PublisherPeriodic()
prop = OpenRTM_aist.Properties()
cinfo = OpenRTM_aist.ConnectorInfo("",
"",
[],
prop)
self.assertEqual(_pn.setListener(cinfo,OpenRTM_aist.ConnectorListeners()),
OpenRTM_aist.DataPortStatus.PORT_OK)
prop = OpenRTM_aist.Properties()
prop.setProperty("publisher.push_policy","skip")
prop.setProperty("publisher.skip_count","0")
prop.setProperty("thread_type","default")
prop.setProperty("measurement.exec_time","enable")
prop.setProperty("measurement.exec_count","0")
prop.setProperty("measurement.period_time","enable")
prop.setProperty("measurement.period_count","0")
retcode = _pn.init(prop)
cons = ConsumerMock()
self.assertEqual(_pn.setConsumer(cons),OpenRTM_aist.DataPortStatus.PORT_OK)
_pn.setBuffer(OpenRTM_aist.CdrRingBuffer())
_pn.activate()
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(_pn.write(123,0,0),OpenRTM_aist.DataPortStatus.PORT_OK)
_pn.deactivate()
_pn.__del__()
return
def createDuplexConnector(self, cprof, prop, provider_):
profile = OpenRTM_aist.ConnectorInfo(cprof.name,
cprof.connector_id,
OpenRTM_aist.CORBA_SeqUtil.refToVstring(cprof.ports),
prop)
connector = None
try:
if self._singlebuffer:
connector = OpenRTM_aist.InPortDuplexConnector(profile, provider_,
self._listeners,
self._thebuffer)
else:
connector = OpenRTM_aist.InPortDuplexConnector(profile, provider_,
self._listeners)
self._rtcout.RTC_TRACE("InPortDuplexConnector created")
# guard = OpenRTM_aist.ScopedLock(self._connector_mutex)
self._connectors.append(connector)
self._rtcout.RTC_PARANOID("connector duplex backed: %d", len(self._connectors))
return connector
except:
self._rtcout.RTC_ERROR("InPortDuplexConnector creation failed")
self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
return None
def setUp(self):
self._buffer = MyBuffer()
self._profile = OpenRTM_aist.ConnectorInfo("test", "id", ["in", "out"],
OpenRTM_aist.Properties())
self._oc = OutPortPullConnector(self._profile, OutPortProviderMock(),
OpenRTM_aist.ConnectorListeners(),
self._buffer)
return
def createConnector(self, cprof, prop, provider_=None, consumer_=None):
profile = OpenRTM_aist.ConnectorInfo(cprof.name,
cprof.connector_id,
OpenRTM_aist.CORBA_SeqUtil.refToVstring(cprof.ports),
prop)
connector = None
try:
if provider_ is not None:
if self._singlebuffer:
connector = OpenRTM_aist.InPortPushConnector(profile, provider_,
self._listeners,
self._thebuffer)
else:
connector = OpenRTM_aist.InPortPushConnector(profile, provider_,
self._listeners)
elif consumer_ is not None:
if self._singlebuffer:
connector = OpenRTM_aist.InPortPullConnector(profile, consumer_,
self._listeners,
self._thebuffer)
else:
connector = OpenRTM_aist.InPortPullConnector(profile, consumer_,
self._listeners)
else:
self._rtcout.RTC_ERROR("provider or consumer is not passed. returned 0;")
return 0
if connector is None:
self._rtcout.RTC_ERROR("InPortConnector creation failed")
return 0
if provider_ is not None:
self._rtcout.RTC_TRACE("InPortPushConnector created")
elif consumer_ is not None:
self._rtcout.RTC_TRACE("InPortPullConnector created")
# guard = OpenRTM_aist.ScopedLock(self._connector_mutex)
self._connectors.append(connector)
self._rtcout.RTC_PARANOID("connector push backed: %d", len(self._connectors))
return connector
except:
self._rtcout.RTC_ERROR("InPortPushConnector creation failed")
self._rtcout.RTC_ERROR(OpenRTM_aist.Logger.print_exception())
return 0
self._rtcout.RTC_FATAL("never comes here: createConnector()")
return 0
def test_write(self):
prop = OpenRTM_aist.Properties()
cinfo = OpenRTM_aist.ConnectorInfo("", "", [], prop)
self.assertEqual(self._pf.write(123, 0, 0),
OpenRTM_aist.DataPortStatus.PRECONDITION_NOT_MET)
self.assertEqual(
self._pf.setConsumer(OpenRTM_aist.InPortCorbaCdrConsumer()),
OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(
self._pf.setListener(cinfo, OpenRTM_aist.ConnectorListeners()),
OpenRTM_aist.DataPortStatus.PORT_OK)
self.assertEqual(self._pf.write(123, 0, 0),
OpenRTM_aist.DataPortStatus.CONNECTION_LOST)
return
def test_get(self):
ret, data = self._opp.get()
self.assertEqual(ret, OpenRTM.UNKNOWN_ERROR)
prop = OpenRTM_aist.Properties()
cinfo = OpenRTM_aist.ConnectorInfo("", "", [], prop)
self._opp.setListener(cinfo, OpenRTM_aist.ConnectorListeners())
buff = DummyBuffer()
self._opp.setBuffer(buff)
ret, data = self._opp.get()
self.assertEqual(ret, OpenRTM.BUFFER_EMPTY)
buff.write(123)
ret, data = self._opp.get()
self.assertEqual(data, 123)
return
def test_ConnectorDataListenerT(self):
# add DataListener.
for i in range(OpenRTM_aist.ConnectorDataListenerType.
CONNECTOR_DATA_LISTENER_NUM):
self._connectorListeners.connectorData_[i].addListener(
self._datalisteners[i], True)
# test for ConnectorDataListenerT.__call__() with little endian data.
for i in range(OpenRTM_aist.ConnectorDataListenerType.
CONNECTOR_DATA_LISTENER_NUM):
data = RTC.TimedLong(RTC.Time(0, 0), i)
cdr_data = cdrMarshal(any.to_any(data).typecode(), data,
True) # little endian
self._connectorListeners.connectorData_[i].notify(
self._info, cdr_data)
self.assertEqual(self._datalisteners[i].get_data().data, i)
# test for ConnectorDataListenerT.__call__() with big endian data.
info = OpenRTM_aist.ConnectorInfo("name", "id", [],
OpenRTM_aist.Properties())
info.properties.setProperty("serializer.cdr.endian", "big")
for i in range(OpenRTM_aist.ConnectorDataListenerType.
CONNECTOR_DATA_LISTENER_NUM):
data = RTC.TimedLong(RTC.Time(0, 0), i)
cdr_data = cdrMarshal(any.to_any(data).typecode(), data,
False) # big endian
self._connectorListeners.connectorData_[i].notify(info, cdr_data)
self.assertEqual(self._datalisteners[i].get_data().data, i)
# remove DataListener.
for i in range(OpenRTM_aist.ConnectorDataListenerType.
CONNECTOR_DATA_LISTENER_NUM):
self._connectorListeners.connectorData_[i].removeListener(
self._datalisteners[i])
for i in range(OpenRTM_aist.ConnectorDataListenerType.
CONNECTOR_DATA_LISTENER_NUM):
data = RTC.TimedLong(RTC.Time(0, 0), i)
cdr_data = cdrMarshal(any.to_any(data).typecode(), data, True)
self._connectorListeners.connectorData_[i].notify(
self._info, cdr_data)
# get_data() return None, because removeListener was called.
self.assertEqual(self._datalisteners[i].get_data(), None)
return
def setUp(self):
self._connectorListeners = ConnectorListeners()
self._info = OpenRTM_aist.ConnectorInfo("name", "id", [],
OpenRTM_aist.Properties())
self._datalisteners = []
self._listeners = []
for i in range(OpenRTM_aist.ConnectorDataListenerType.
CONNECTOR_DATA_LISTENER_NUM):
self._datalisteners.append(
DataListener(typeToStringDataListener(i)))
for i in range(
OpenRTM_aist.ConnectorListenerType.CONNECTOR_LISTENER_NUM):
self._listeners.append(Listener(typeToStringListener(i)))
return
def test_get(self):
prop = OpenRTM_aist.Properties()
self._opp.init(prop)
ret = self._opp.get()
self.assertEqual(ret, OpenRTM.UNKNOWN_ERROR)
prop = OpenRTM_aist.Properties()
cinfo = OpenRTM_aist.ConnectorInfo("", "", [], prop)
self._opp.setListener(cinfo, OpenRTM_aist.ConnectorListeners())
buff = DummyBuffer()
self._opp.setBuffer(buff)
ret = self._opp.get()
self.assertEqual(ret, OpenRTM.BUFFER_EMPTY)
#self._opp.setInterface(self._shm_var)
buff.write("abcde")
ret = self._opp.get()
self.assertEqual(ret, OpenRTM.PORT_OK)
data = self._opp.read()
self.assertEqual(data, "abcde")
return
def subscribeInterfaces(self, cprof):
self._rtcout.RTC_TRACE("subscribeInterfaces()")
# prop: [port.outport].
prop = copy.deepcopy(self._properties)
conn_prop = OpenRTM_aist.Properties()
OpenRTM_aist.NVUtil.copyToProperties(conn_prop, cprof.properties)
prop.mergeProperties(conn_prop.getNode("dataport")) # marge ConnectorProfile
prop.mergeProperties(conn_prop.getNode("dataport.inport")) # marge ConnectorProfile for buffer property.
#
# ここで, ConnectorProfile からの properties がマージされたため、
# prop["dataflow_type"]: データフロータイプ
# prop["interface_type"]: インターフェースタイプ
# などがアクセス可能になる。
#
dflow_type = prop.getProperty("dataflow_type")
dtype = [dflow_type]
OpenRTM_aist.normalize(dtype)
dflow_type = dtype[0]
profile = OpenRTM_aist.ConnectorInfo(cprof.name,
cprof.connector_id,
OpenRTM_aist.CORBA_SeqUtil.refToVstring(cprof.ports),
prop)
if dflow_type == "push":
self._rtcout.RTC_DEBUG("dataflow_type = push .... do nothing")
conn = self.getConnectorById(cprof.connector_id)
if not conn:
self._rtcout.RTC_ERROR("specified connector not found: %s",
cprof.connector_id)
return RTC.RTC_ERROR
ret = conn.setConnectorInfo(profile)
if ret == RTC.RTC_OK:
self._rtcout.RTC_DEBUG("subscribeInterfaces() successfully finished.")
return ret
elif dflow_type == "pull":
self._rtcout.RTC_DEBUG("dataflow_type = pull .... create PullConnector")
# create OutPortConsumer
consumer = self.createConsumer(cprof, prop)
if not consumer:
return RTC.BAD_PARAMETER
# create InPortPullConnector
connector = self.createConnector(cprof, prop, consumer_=consumer)
if not connector:
return RTC.RTC_ERROR
ret = connector.setConnectorInfo(profile)
if ret == RTC.RTC_OK:
self._rtcout.RTC_DEBUG("publishInterface() successfully finished.")
return ret
self._rtcout.RTC_ERROR("unsupported dataflow_type")
return RTC.BAD_PARAMETER
def subscribeInterfaces(self, cprof):
self._rtcout.RTC_TRACE("subscribeInterfaces()")
# prop: [port.outport].
prop = copy.deepcopy(self._properties)
conn_prop = OpenRTM_aist.Properties()
OpenRTM_aist.NVUtil.copyToProperties(conn_prop, cprof.properties)
prop.mergeProperties(conn_prop.getNode("dataport")
) # marge ConnectorProfile
"""
# marge ConnectorProfile for buffer property.
# e.g.
# prof[buffer.write.full_policy]
# << cprof[dataport.outport.buffer.write.full_policy]
"""
prop.mergeProperties(conn_prop.getNode("dataport.outport"))
if self._value is not None and not self.isExistingMarshalingType(prop):
return RTC.RTC_ERROR
#
# ここで, ConnectorProfile からの properties がマージされたため、
# prop["dataflow_type"]: データフロータイプ
# prop["interface_type"]: インターフェースタイプ
# などがアクセス可能になる。
#
dflow_type = OpenRTM_aist.normalize(prop.getProperty("dataflow_type"))
profile = OpenRTM_aist.ConnectorInfo(cprof.name,
cprof.connector_id,
OpenRTM_aist.CORBA_SeqUtil.refToVstring(
cprof.ports),
prop)
if dflow_type == "push":
self._rtcout.RTC_PARANOID(
"dataflow_type = push .... create PushConnector")
# interface
consumer = self.createConsumer(cprof, prop)
if not consumer:
return RTC.BAD_PARAMETER
# create OutPortPushConnector
connector = self.createConnector(cprof, prop, consumer_=consumer)
if not connector:
return RTC.RTC_ERROR
connector.setDataType(self._value)
ret = connector.setConnectorInfo(profile)
if ret == RTC.RTC_OK:
self._rtcout.RTC_DEBUG(
"subscribeInterfaces() successfully finished.")
return ret
elif dflow_type == "pull":
self._rtcout.RTC_PARANOID("dataflow_type = pull.")
conn = self.getConnectorById(cprof.connector_id)
if not conn:
self._rtcout.RTC_ERROR("specified connector not found: %s",
cprof.connector_id)
return RTC.RTC_ERROR
ret = conn.setConnectorInfo(profile)
if ret == RTC.RTC_OK:
self._rtcout.RTC_DEBUG(
"subscribeInterfaces() successfully finished.")
return ret
elif dflow_type == "duplex":
self._rtcout.RTC_DEBUG(
"dataflow_type = duplex .... set Consumer Object")
# create OutPortConsumer
consumer = self.createConsumer(cprof, prop)
if not consumer:
return RTC.BAD_PARAMETER
connector = self.getConnectorById(cprof.connector_id)
if not connector:
return RTC.RTC_ERROR
connector.setDataType(self._value)
connector.setConsumer(consumer)
ret = connector.setConnectorInfo(profile)
if ret == RTC.RTC_OK:
self._rtcout.RTC_DEBUG(
"publishInterface() successfully finished.")
return ret
self._rtcout.RTC_ERROR("unsupported dataflow_type")
return RTC.BAD_PARAMETER
def test_createBuffer(self):
self._con.createBuffer(OpenRTM_aist.ConnectorInfo("name","id",[],OpenRTM_aist.Properties()))
return
def setUp(self):
OpenRTM_aist.Manager.instance()
self._con = InPortPullConnector(OpenRTM_aist.ConnectorInfo("name","id",[],OpenRTM_aist.Properties()),InPortConsumerMock(),OpenRTM_aist.ConnectorListeners())
def profile(self):
return OpenRTM_aist.ConnectorInfo(self._name, self._id, self._ports,
self._properties)
