def getEndpoints(ior):
global endian
addr = []
for p in ior.profiles:
# TAG_INTERNET_IOP
if p.tag == IOP.TAG_INTERNET_IOP:
if sys.version_info[0] == 2:
pbody = cdrUnmarshal(_0__GlobalIDL._tc_ProfileBody,
"".join(p.profile_data), endian)
else:
pbody = cdrUnmarshal(_0__GlobalIDL._tc_ProfileBody,
p.profile_data, endian)
addr.append(pbody.address_)
addr += extractAddrs(pbody.components)
# TAG_MULTIPLE_COMPONENTS
elif p.tag == IOP.TAG_MULTIPLE_COMPONENTS:
if sys.version_info[0] == 2:
profiles = cdrUnmarshal(_0__GlobalIDL._tc_MultipleComponentProfile,
"".join(p.profile_data), endian)
else:
profiles = cdrUnmarshal(_0__GlobalIDL._tc_MultipleComponentProfile,
p.profile_data, endian)
addr += extractAddrs(profiles)
else:
print("Other Profile")
return addr
def toIOR(iorstr):
global endian
if len(iorstr) < 4:
return
if iorstr[0:4] != 'IOR:':
return
pos = len("IOR:")
if sys.version_info[0] == 2:
iorvalue = [chr(int(i + j, 16))
for (i, j) in zip(iorstr[pos::2], iorstr[(pos + 1)::2])]
else:
iorvalue = [int(i + j, 16)
for (i, j) in zip(iorstr[pos::2], iorstr[(pos + 1)::2])]
# Endian flag
pos = 0
endian = (iorvalue[pos] != 0)
pos += 4
if sys.version_info[0] == 2:
ior = cdrUnmarshal(_0__GlobalIDL._tc_IOR,
"".join(iorvalue[pos:]), endian)
else:
ior = cdrUnmarshal(_0__GlobalIDL._tc_IOR,
bytes(iorvalue[pos:]), endian)
return ior
def extractAddrs(comps):
global endian
addr = []
for c in comps:
# print("TAG component type: ", IOP.ComponentID[c.tag])
if c.tag == IOP.TAG_ALTERNATE_IIOP_ADDRESS:
if sys.version_info[0] == 2:
size = cdrUnmarshal(CORBA.TC_ulong,
"".join(c.component_data[0:4]), endian)
address = cdrUnmarshal(_0__GlobalIDL._tc_Address,
"".join(c.component_data[4:]), endian)
else:
size = cdrUnmarshal(CORBA.TC_ulong,
c.component_data[0:4], endian)
address = cdrUnmarshal(_0__GlobalIDL._tc_Address,
c.component_data[4:], endian)
addr.append(address)
elif c.tag == IOP.TAG_ORB_TYPE:
if sys.version_info[0] == 2:
size = cdrUnmarshal(CORBA.TC_ulong,
"".join(c.component_data[0:4]), endian)
orb_type = cdrUnmarshal(CORBA.TC_ulong,
"".join(c.component_data[4:8]), endian)
else:
size = cdrUnmarshal(CORBA.TC_ulong,
c.component_data[0:4], endian)
orb_type = cdrUnmarshal(CORBA.TC_ulong,
c.component_data[4:8], endian)
return addr
def test_SharedMemory(self):
sh_read = OpenRTM_aist.SharedMemory()
sh_read_var = sh_read._this()
sh_write = OpenRTM_aist.SharedMemory()
sh_write_var = sh_write._this()
sh_write.setInterface(sh_read_var)
memsize = sh_write.string_to_MemorySize("1")
self.assertEqual(memsize, 1)
memsize = sh_write.string_to_MemorySize("1k")
self.assertEqual(memsize, 1024)
memsize = sh_write.string_to_MemorySize("1M")
self.assertEqual(memsize, 1024 * 1024)
sh_write.create_memory(1000, "test")
sh_write.setEndian(True)
data_cdr = cdrMarshal(CORBA.TC_ulong, 100, True)
sh_write.write(data_cdr)
data_cdr = sh_read.read()
data = cdrUnmarshal(CORBA.TC_ulong, data_cdr, True)
self.assertEqual(data, 100)
if platform.system() == "Windows":
pass
else:
self.assertTrue(os.path.exists("/dev/shm/test"))
sh_write.close_memory(True)
if platform.system() == "Windows":
pass
else:
self.assertFalse(os.path.exists("/dev/shm/test"))
def get(self, data):
try:
outportcdr = self.getObject()._narrow(OpenRTM.OutPortCdr)
ret,cdr_data = outportcdr.get()
if ret == OpenRTM.PORT_OK:
file_path = cdrUnmarshal(CORBA.TC_string, cdr_data)
with open(file_path, "rb") as fin:
data[0] = fin.read()
self._buffer.put(data[0])
self._buffer.advanceWptr()
self._buffer.advanceRptr()
return self.PORT_OK
return self.convertReturn(ret,data[0])
except:
return self.CONNECTION_LOST
return self.UNKNOWN_ERROR
def deserialize(self, cdr, data_type):
if self._endian is not None:
try:
data = cdrUnmarshal(
any.to_any(data_type).typecode(), cdr, self._endian)
return OpenRTM_aist.ByteDataStreamBase.SERIALIZE_OK, data
except:
return OpenRTM_aist.ByteDataStreamBase.SERIALIZE_ERROR, data_type
else:
return OpenRTM_aist.ByteDataStreamBase.SERIALIZE_NOT_SUPPORT_ENDIAN, data_type
def read(self) :
if self.ref :
try :
tmp1=self.ref.get()
tmp2= cdrUnmarshal(self.data_tc,tmp1[1], 1)
# return tmp2.data
return tmp2
except :
return None
else :
print "not supported"
return None
def read(self):
if self.ref:
try:
tmp1 = self.ref.get()
tmp2 = cdrUnmarshal(self.data_tc, tmp1[1], 1)
# return tmp2.data
return tmp2
except:
return None
else:
print("not supported")
return None
def read(self):
self._rtcout.RTC_TRACE("read()")
if self._shmem:
self._shmem.seek(os.SEEK_SET)
data_size_cdr = self._shmem.read(SharedMemory.default_size)
data_size = cdrUnmarshal(CORBA.TC_ulonglong, data_size_cdr,
self._endian)
shm_data = self._shmem.read(data_size)
return shm_data
return ""
def __call__(self, info, cdrdata, data):
endian = info.properties.getProperty("serializer.cdr.endian","little")
if endian is not "little" and endian is not None:
endian = OpenRTM_aist.split(endian, ",") # Maybe endian is ["little","big"]
endian = OpenRTM_aist.normalize(endian) # Maybe self._endian is "little" or "big"
if endian == "little":
endian = True
elif endian == "big":
endian = False
else:
endian = True
_data = cdrUnmarshal(any.to_any(data).typecode(), cdrdata, endian)
return _data
def replaceEndpoint(iorstr, endpoint):
global endian
ior = toIOR(iorstr)
for p in ior.profiles:
# TAG_INTERNET_IOP
if p.tag == IOP.TAG_INTERNET_IOP:
if sys.version_info[0] == 2:
pbody = cdrUnmarshal(_0__GlobalIDL._tc_ProfileBody,
"".join(p.profile_data), endian)
else:
pbody = cdrUnmarshal(_0__GlobalIDL._tc_ProfileBody,
p.profile_data, endian)
pbody.address_.host = endpoint
p.profile_data = cdrMarshal(
any.to_any(pbody).typecode(), pbody, endian)
# TAG_MULTIPLE_COMPONENTS
elif p.tag == IOP.TAG_MULTIPLE_COMPONENTS:
pass
else:
print("Other Profile")
iorstr = toString(ior)
return iorstr
def read(self, data):
self._rtcout.RTC_TRACE("InPortPullConnector.read()")
if self._directOutPort is not None:
if self._directOutPort.isEmpty():
self._listeners.connector_[OpenRTM_aist.ConnectorListenerType.ON_BUFFER_EMPTY].notify(self._profile)
self._outPortListeners.connector_[OpenRTM_aist.ConnectorListenerType.ON_SENDER_EMPTY].notify(self._profile)
self._rtcout.RTC_TRACE("ON_BUFFER_EMPTY(InPort,OutPort), ")
self._rtcout.RTC_TRACE("ON_SENDER_EMPTY(InPort,OutPort) ")
self._rtcout.RTC_TRACE("callback called in direct mode.")
self._directOutPort.read(data)
#self._outPortListeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_BUFFER_READ].notify(self._profile, data[0])
self._rtcout.RTC_TRACE("ON_BUFFER_READ(OutPort), ")
self._rtcout.RTC_TRACE("callback called in direct mode.")
#self._outPortListeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_SEND].notify(self._profile, data[0])
self._rtcout.RTC_TRACE("ON_SEND(OutPort), ")
self._rtcout.RTC_TRACE("callback called in direct mode.")
#self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_RECEIVED].notify(self._profile, data[0])
self._rtcout.RTC_TRACE("ON_RECEIVED(InPort), ")
self._rtcout.RTC_TRACE("callback called in direct mode.")
#self._listeners.connectorData_[OpenRTM_aist.ConnectorDataListenerType.ON_SEND].notify(self._profile, data[0])
self._rtcout.RTC_TRACE("ON_BUFFER_WRITE(InPort), ")
self._rtcout.RTC_TRACE("callback called in direct mode.")
return self.PORT_OK
if not self._consumer:
return self.PORT_ERROR
cdr_data = [None]
ret = self._consumer.get(cdr_data)
if ret == self.PORT_OK:
# CDR -> (conversion) -> data
if self._endian is not None:
data[0] = cdrUnmarshal(any.to_any(data[0]).typecode(),cdr_data[0],self._endian)
else:
self._rtcout.RTC_ERROR("unknown endian from connector")
return OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET
return ret
def put(self, cdr):
guard = OpenRTM_aist.ScopedLock(self._mutex)
data = cdrUnmarshal(any.to_any(RTC.CameraImage).typecode(), cdr, True)
try:
if data and self._datasize != len(data.pixels):
self.save(len(data.pixels))
start = OpenRTM_aist.TimeValue(data.tm.sec, data.tm.nsec / 1000)
end = OpenRTM_aist.Time().getTime()
diff = (end - start).toDouble()
self._data.append(diff)
self._datasize = len(data.pixels)
except:
import traceback
print(traceback.format_exc())
return OpenRTM.PORT_OK
def put(self, data):
try:
if not self._connector:
return OpenRTM.PORT_ERROR
file_path = cdrUnmarshal(CORBA.TC_string, data)
if file_path:
with open(file_path, "rb") as fin:
d = fin.read()
ret = self._connector.write(d)
return self.convertReturn(ret, d)
except:
self._rtcout.RTC_TRACE(OpenRTM_aist.Logger.print_exception())
return OpenRTM.UNKNOWN_ERROR
return OpenRTM.UNKNOWN_ERROR
def read(self, data):
self._rtcout.RTC_TRACE("read()")
##
# buffer returns
# BUFFER_OK
# BUFFER_EMPTY
# TIMEOUT
# PRECONDITION_NOT_MET
#
if not self._buffer:
return self.PRECONDITION_NOT_MET
cdr = [""]
if self._sync_readwrite:
self._readcompleted_worker._completed = False
self._readready_worker._completed = True
self._readready_worker._cond.acquire()
self._readready_worker._cond.notify()
self._readready_worker._cond.release()
self._writecompleted_worker._cond.acquire()
while not self._writecompleted_worker._completed:
self._writecompleted_worker._cond.wait()
self._writecompleted_worker._cond.release()
ret = self._buffer.read(cdr)
if self._sync_readwrite:
self._readcompleted_worker._completed = True
self._readcompleted_worker._cond.acquire()
self._readcompleted_worker._cond.notify()
self._readcompleted_worker._cond.release()
self._readready_worker._completed = False
if not self._dataType:
return self.PRECONDITION_NOT_MET
if self._endian is not None:
if ret == OpenRTM_aist.BufferStatus.BUFFER_OK:
_data = cdrUnmarshal(any.to_any(self._dataType).typecode(),cdr[0],self._endian)
if type(data) == list:
data[0] = _data
else:
self._rtcout.RTC_ERROR("unknown endian from connector")
return self.PRECONDITION_NOT_MET
if ret == OpenRTM_aist.BufferStatus.BUFFER_OK:
self.onBufferRead(cdr[0])
return self.PORT_OK
elif ret == OpenRTM_aist.BufferStatus.BUFFER_EMPTY:
self.onBufferEmpty(cdr[0])
return self.BUFFER_EMPTY
elif ret == OpenRTM_aist.BufferStatus.TIMEOUT:
self.onBufferReadTimeout(cdr[0])
return self.BUFFER_TIMEOUT
elif ret == OpenRTM_aist.BufferStatus.PRECONDITION_NOT_MET:
return self.PRECONDITION_NOT_MET
return self.PORT_ERROR
def cdr2data(cdr, classname):
return cdrUnmarshal(any.to_any(classFromString(classname)).typecode(), cdr, True)
def cdr2data(cdr, classname):
return cdrUnmarshal(
any.to_any(classFromString(classname)).typecode(), cdr, True)
def unmarshalBoolean(cdr):
cdrUnmarshal(CORBA.TC_boolean, "".join(cdr.data(2)))
