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)))