class ticket_cf_1066_comp_base(CF__POA.Resource, Resource): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatability # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False def initialize(self): Resource.initialize(self) # Instantiate the default implementations for all ports on this component def start(self): self.threadControlLock.acquire() try: Resource.start(self) if self.process_thread == None: self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE) self.process_thread.start() finally: self.threadControlLock.release() def process(self): """The process method should process a single "chunk" of data and then return. This method will be called from the processing thread again, and again, and again until it returns FINISH or stop() is called on the component. If no work is performed, then return NOOP""" raise NotImplementedError def stop(self): self.threadControlLock.acquire() try: process_thread = self.process_thread self.process_thread = None if process_thread != None: process_thread.stop() process_thread.join(self.TIMEOUT) if process_thread.isAlive(): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) finally: self.threadControlLock.release() def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") self.threadControlLock.acquire() try: Resource.releaseObject(self) finally: self.threadControlLock.release() ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. simple_prop = simple_property(id_="simple_prop", type_="string", defvalue="default_value", mode="readwrite", action="external", kinds=("configure",) ) seq_prop = simpleseq_property(id_="seq_prop", type_="short", defvalue=(111,222,333), mode="readwrite", action="external", kinds=("configure",) ) class StructProp(object): prop_one = simple_property(id_="prop_one", type_="boolean", defvalue=True, ) prop_two = simple_property(id_="prop_two", type_="string", defvalue="This is another default value", ) prop_three = simple_property(id_="prop_three", type_="float", defvalue=555, ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k,v in kw.items(): setattr(self,k,v) def __str__(self): """Return a string representation of this structure""" d = {} d["prop_one"] = self.prop_one d["prop_two"] = self.prop_two d["prop_three"] = self.prop_three return str(d) def getId(self): return "struct_prop" def isStruct(self): return True def getMembers(self): return [("prop_one",self.prop_one),("prop_two",self.prop_two),("prop_three",self.prop_three)] struct_prop = struct_property(id_="struct_prop", structdef=StructProp, configurationkind=("configure",), mode="readwrite" ) class TmpStruct(object): prop_four = simple_property(id_="prop_four", type_="string", defvalue="yet another default", ) prop_five = simple_property(id_="prop_five", type_="long", defvalue=246, ) prop_six = simple_property(id_="prop_six", type_="double", defvalue=135, ) def __init__(self, prop_four="", prop_five=0, prop_six=0): self.prop_four = prop_four self.prop_five = prop_five self.prop_six = prop_six def __str__(self): """Return a string representation of this structure""" d = {} d["prop_four"] = self.prop_four d["prop_five"] = self.prop_five d["prop_six"] = self.prop_six return str(d) def getId(self): return "tmp_struct" def isStruct(self): return True def getMembers(self): return [("prop_four",self.prop_four),("prop_five",self.prop_five),("prop_six",self.prop_six)] struct_seq_prop = structseq_property(id_="struct_seq_prop", structdef=TmpStruct, defvalue=[], configurationkind=("configure",), mode="readwrite" )
class TestPythonPropsRange_base(CF__POA.Resource, Component, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Component.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component def start(self): Component.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): Component.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Component.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. my_octet_name = simple_property(id_="my_octet", name="my_octet_name", type_="octet", defvalue=1, mode="readwrite", action="external", kinds=("configure", )) my_short_name = simple_property(id_="my_short", name="my_short_name", type_="short", defvalue=2, mode="readwrite", action="external", kinds=("configure", )) my_ushort_name = simple_property(id_="my_ushort", name="my_ushort_name", type_="ushort", defvalue=3, mode="readwrite", action="external", kinds=("configure", )) my_long_name = simple_property(id_="my_long", name="my_long_name", type_="long", defvalue=4, mode="readwrite", action="external", kinds=("configure", )) my_ulong_name = simple_property(id_="my_ulong", name="my_ulong_name", type_="ulong", defvalue=5, mode="readwrite", action="external", kinds=("configure", )) my_longlong_name = simple_property(id_="my_longlong", name="my_longlong_name", type_="longlong", defvalue=6, mode="readwrite", action="external", kinds=("configure", )) my_ulonglong_name = simple_property(id_="my_ulonglong", name="my_ulonglong_name", type_="ulonglong", defvalue=7, mode="readwrite", action="external", kinds=("configure", )) seq_octet_name = simpleseq_property(id_="seq_octet", name="seq_octet_name", type_="octet", defvalue=[ 1, 2, ], mode="readwrite", action="external", kinds=("configure", )) seq_short_name = simpleseq_property(id_="seq_short", name="seq_short_name", type_="short", defvalue=[ 1, 2, ], mode="readwrite", action="external", kinds=("configure", )) seq_ushort_name = simpleseq_property(id_="seq_ushort", name="seq_ushort_name", type_="ushort", defvalue=[ 1, 2, ], mode="readwrite", action="external", kinds=("configure", )) seq_long_name = simpleseq_property(id_="seq_long", name="seq_long_name", type_="long", defvalue=[ 1, 2, ], mode="readwrite", action="external", kinds=("configure", )) seq_ulong_name = simpleseq_property(id_="seq_ulong", name="seq_ulong_name", type_="ulong", defvalue=[ 1, 2, ], mode="readwrite", action="external", kinds=("configure", )) seq_longlong_name = simpleseq_property(id_="seq_longlong", name="seq_longlong_name", type_="longlong", defvalue=[ 1, 2, ], mode="readwrite", action="external", kinds=("configure", )) seq_ulonglong_name = simpleseq_property(id_="seq_ulonglong", name="seq_ulonglong_name", type_="ulonglong", defvalue=[ 1, 2, ], mode="readwrite", action="external", kinds=("configure", )) seq_char_name = simpleseq_property(id_="seq_char", name="seq_char_name", type_="char", defvalue=[ 'a', 'b', ], mode="readwrite", action="external", kinds=("configure", )) class MyStructName(object): struct_octet_name = simple_property(id_="struct_octet", name="struct_octet_name", type_="octet", defvalue=1) struct_short_name = simple_property(id_="struct_short", name="struct_short_name", type_="short", defvalue=2) struct_ushort_name = simple_property(id_="struct_ushort", name="struct_ushort_name", type_="ushort", defvalue=3) struct_long_name = simple_property(id_="struct_long", name="struct_long_name", type_="long", defvalue=4) struct_ulong_name = simple_property(id_="struct_ulong", name="struct_ulong_name", type_="ulong", defvalue=5) struct_longlong_name = simple_property(id_="struct_longlong", name="struct_longlong_name", type_="longlong", defvalue=6) struct_ulonglong_name = simple_property(id_="struct_ulonglong", name="struct_ulonglong_name", type_="ulonglong", defvalue=7) struct_seq_octet_name = simpleseq_property( id_="struct_seq_octet", name="struct_seq_octet_name", type_="octet", defvalue=[ 1, 2, ]) struct_seq_short_name = simpleseq_property( id_="struct_seq_short", name="struct_seq_short_name", type_="short", defvalue=[ 1, 2, ]) struct_seq_ushort_name = simpleseq_property( id_="struct_seq_ushort", name="struct_seq_ushort_name", type_="ushort", defvalue=[ 1, 2, ]) struct_seq_long_name = simpleseq_property(id_="struct_seq_long", name="struct_seq_long_name", type_="long", defvalue=[ 1, 2, ]) struct_seq_ulong_name = simpleseq_property( id_="struct_seq_ulong", name="struct_seq_ulong_name", type_="ulong", defvalue=[ 1, 2, ]) struct_seq_longlong_name = simpleseq_property( id_="struct_seq_longlong", name="struct_seq_longlong_name", type_="longlong", defvalue=[ 1, 2, ]) struct_seq_ulonglong_name = simpleseq_property( id_="struct_seq_ulonglong", name="struct_seq_ulonglong_name", type_="ulonglong", defvalue=[ 1, 2, ]) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property or type( classattr) == simpleseq_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["struct_octet_name"] = self.struct_octet_name d["struct_short_name"] = self.struct_short_name d["struct_ushort_name"] = self.struct_ushort_name d["struct_long_name"] = self.struct_long_name d["struct_ulong_name"] = self.struct_ulong_name d["struct_longlong_name"] = self.struct_longlong_name d["struct_ulonglong_name"] = self.struct_ulonglong_name d["struct_seq_octet_name"] = self.struct_seq_octet_name d["struct_seq_short_name"] = self.struct_seq_short_name d["struct_seq_ushort_name"] = self.struct_seq_ushort_name d["struct_seq_long_name"] = self.struct_seq_long_name d["struct_seq_ulong_name"] = self.struct_seq_ulong_name d["struct_seq_longlong_name"] = self.struct_seq_longlong_name d["struct_seq_ulonglong_name"] = self.struct_seq_ulonglong_name return str(d) def getId(self): return "my_struct" def isStruct(self): return True def getMembers(self): return [ ("struct_octet_name", self.struct_octet_name), ("struct_short_name", self.struct_short_name), ("struct_ushort_name", self.struct_ushort_name), ("struct_long_name", self.struct_long_name), ("struct_ulong_name", self.struct_ulong_name), ("struct_longlong_name", self.struct_longlong_name), ("struct_ulonglong_name", self.struct_ulonglong_name), ("struct_seq_octet_name", self.struct_seq_octet_name), ("struct_seq_short_name", self.struct_seq_short_name), ("struct_seq_ushort_name", self.struct_seq_ushort_name), ("struct_seq_long_name", self.struct_seq_long_name), ("struct_seq_ulong_name", self.struct_seq_ulong_name), ("struct_seq_longlong_name", self.struct_seq_longlong_name), ("struct_seq_ulonglong_name", self.struct_seq_ulonglong_name) ] my_struct_name = struct_property(id_="my_struct", name="my_struct_name", structdef=MyStructName, configurationkind=("configure", ), mode="readwrite") class SsStructName(object): ss_octet_name = simple_property(id_="ss_octet", name="ss_octet_name", type_="octet") ss_short_name = simple_property(id_="ss_short", name="ss_short_name", type_="short") ss_ushort_name = simple_property(id_="ss_ushort", name="ss_ushort_name", type_="ushort") ss_long_name = simple_property(id_="ss_long", name="ss_long_name", type_="long") ss_ulong_name = simple_property(id_="ss_ulong", name="ss_ulong_name", type_="ulong") ss_longlong_name = simple_property(id_="ss_longlong", name="ss_longlong_name", type_="longlong") ss_ulonglong_name = simple_property(id_="ss_ulonglong", name="ss_ulonglong_name", type_="ulonglong") ss_seq_octet_name = simpleseq_property(id_="ss_seq_octet", name="ss_seq_octet_name", type_="octet") ss_seq_short_name = simpleseq_property(id_="ss_seq_short", name="ss_seq_short_name", type_="short") ss_seq_ushort_name = simpleseq_property(id_="ss_seq_ushort", name="ss_seq_ushort_name", type_="ushort") ss_seq_long_name = simpleseq_property(id_="ss_seq_long", name="ss_seq_long_name", type_="long") ss_seq_ulong_name = simpleseq_property(id_="ss_seq_ulong", name="ss_seq_ulong_name", type_="ulong") ss_seq_longlong_name = simpleseq_property(id_="ss_seq_longlong", name="ss_seq_longlong_name", type_="longlong") ss_seq_ulonglong_name = simpleseq_property( id_="ss_seq_ulonglong", name="ss_seq_ulonglong_name", type_="ulonglong") def __init__(self, ss_octet_name=0, ss_short_name=0, ss_ushort_name=0, ss_long_name=0, ss_ulong_name=0, ss_longlong_name=0, ss_ulonglong_name=0, ss_seq_octet_name=0, ss_seq_short_name=0, ss_seq_ushort_name=0, ss_seq_long_name=0, ss_seq_ulong_name=0, ss_seq_longlong_name=0, ss_seq_ulonglong_name=0): self.ss_octet_name = ss_octet_name self.ss_short_name = ss_short_name self.ss_ushort_name = ss_ushort_name self.ss_long_name = ss_long_name self.ss_ulong_name = ss_ulong_name self.ss_longlong_name = ss_longlong_name self.ss_ulonglong_name = ss_ulonglong_name self.ss_seq_octet_name = ss_seq_octet_name self.ss_seq_short_name = ss_seq_short_name self.ss_seq_ushort_name = ss_seq_ushort_name self.ss_seq_long_name = ss_seq_long_name self.ss_seq_ulong_name = ss_seq_ulong_name self.ss_seq_longlong_name = ss_seq_longlong_name self.ss_seq_ulonglong_name = ss_seq_ulonglong_name def __str__(self): """Return a string representation of this structure""" d = {} d["ss_octet_name"] = self.ss_octet_name d["ss_short_name"] = self.ss_short_name d["ss_ushort_name"] = self.ss_ushort_name d["ss_long_name"] = self.ss_long_name d["ss_ulong_name"] = self.ss_ulong_name d["ss_longlong_name"] = self.ss_longlong_name d["ss_ulonglong_name"] = self.ss_ulonglong_name d["ss_seq_octet_name"] = self.ss_seq_octet_name d["ss_seq_short_name"] = self.ss_seq_short_name d["ss_seq_ushort_name"] = self.ss_seq_ushort_name d["ss_seq_long_name"] = self.ss_seq_long_name d["ss_seq_ulong_name"] = self.ss_seq_ulong_name d["ss_seq_longlong_name"] = self.ss_seq_longlong_name d["ss_seq_ulonglong_name"] = self.ss_seq_ulonglong_name return str(d) def getId(self): return "ss_struct" def isStruct(self): return True def getMembers(self): return [("ss_octet_name", self.ss_octet_name), ("ss_short_name", self.ss_short_name), ("ss_ushort_name", self.ss_ushort_name), ("ss_long_name", self.ss_long_name), ("ss_ulong_name", self.ss_ulong_name), ("ss_longlong_name", self.ss_longlong_name), ("ss_ulonglong_name", self.ss_ulonglong_name), ("ss_seq_octet_name", self.ss_seq_octet_name), ("ss_seq_short_name", self.ss_seq_short_name), ("ss_seq_ushort_name", self.ss_seq_ushort_name), ("ss_seq_long_name", self.ss_seq_long_name), ("ss_seq_ulong_name", self.ss_seq_ulong_name), ("ss_seq_longlong_name", self.ss_seq_longlong_name), ("ss_seq_ulonglong_name", self.ss_seq_ulonglong_name)] my_structseq_name = structseq_property( id_="my_structseq", name="my_structseq_name", structdef=SsStructName, defvalue=[ SsStructName(0, 1, 2, 3, 4, 5, 6, [1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14]), SsStructName(7, 8, 9, 10, 11, 12, 13, [15, 16], [17, 18], [19, 20], [21, 22], [23, 24], [25, 26], [27, 28]) ], configurationkind=("configure", ), mode="readwrite")
class fei_exc_src_base(CF__POA.Device, FrontendTunerDevice, digital_tuner_delegation, rfinfo_delegation, rfsource_delegation, gps_delegation, nav_delegation, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): FrontendTunerDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams) ThreadedComponent.__init__(self) self.listeners = {} # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 devices. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this device self.port_RFInfo_in = frontend.InRFInfoPort("RFInfo_in", self) self.port_DigitalTuner_in = frontend.InDigitalScanningTunerPort( "DigitalTuner_in", self) self.port_GPS_in = frontend.InGPSPort("GPS_in", self) self.port_NavData_in = frontend.InNavDataPort("NavData_in", self) self.port_RFSource_in = frontend.InRFSourcePort("RFSource_in", self) self.port_dataDouble_out = bulkio.OutDoublePort("dataDouble_out") self.addPropertyChangeListener('connectionTable', self.updated_connectionTable) self.device_kind = "FRONTEND::TUNER" self.frontend_listener_allocation = frontend.fe_types.frontend_listener_allocation( ) self.frontend_tuner_allocation = frontend.fe_types.frontend_tuner_allocation( ) def start(self): FrontendTunerDevice.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): FrontendTunerDevice.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def updated_connectionTable(self, id, oldval, newval): self.port_dataDouble_out.updateConnectionFilter(newval) def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") FrontendTunerDevice.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. port_RFInfo_in = providesport(name="RFInfo_in", repid="IDL:FRONTEND/RFInfo:1.0", type_="data") port_DigitalTuner_in = providesport(name="DigitalTuner_in", repid="IDL:FRONTEND/DigitalTuner:1.0", type_="control") port_GPS_in = providesport(name="GPS_in", repid="IDL:FRONTEND/GPS:1.0", type_="control") port_NavData_in = providesport(name="NavData_in", repid="IDL:FRONTEND/NavData:1.0", type_="control") port_RFSource_in = providesport(name="RFSource_in", repid="IDL:FRONTEND/RFSource:1.0", type_="control") port_dataDouble_out = usesport(name="dataDouble_out", repid="IDL:BULKIO/dataDouble:1.0", type_="data") ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. class frontend_tuner_status_struct_struct( frontend.default_frontend_tuner_status_struct_struct): def __init__(self, allocation_id_csv="", bandwidth=0.0, center_frequency=0.0, enabled=False, group_id="", rf_flow_id="", sample_rate=0.0, tuner_type=""): frontend.default_frontend_tuner_status_struct_struct.__init__( self, allocation_id_csv=allocation_id_csv, bandwidth=bandwidth, center_frequency=center_frequency, enabled=enabled, group_id=group_id, rf_flow_id=rf_flow_id, sample_rate=sample_rate, tuner_type=tuner_type) def __str__(self): """Return a string representation of this structure""" d = {} d["allocation_id_csv"] = self.allocation_id_csv d["bandwidth"] = self.bandwidth d["center_frequency"] = self.center_frequency d["enabled"] = self.enabled d["group_id"] = self.group_id d["rf_flow_id"] = self.rf_flow_id d["sample_rate"] = self.sample_rate d["tuner_type"] = self.tuner_type return str(d) @classmethod def getId(cls): return "FRONTEND::tuner_status_struct" @classmethod def isStruct(cls): return True def getMembers(self): return frontend.default_frontend_tuner_status_struct_struct.getMembers( self) + [] connectionTable = structseq_property( id_="connectionTable", structdef=bulkio.connection_descriptor_struct, defvalue=[], configurationkind=("property", ), mode="readonly") # Rebind tuner status property with custom struct definition frontend_tuner_status = FrontendTunerDevice.frontend_tuner_status.rebind() frontend_tuner_status.structdef = frontend_tuner_status_struct_struct def frontendTunerStatusChanged(self, oldValue, newValue): pass def getTunerStatus(self, allocation_id): tuner_id = self.getTunerMapping(allocation_id) if tuner_id < 0: raise FRONTEND.FrontendException( ("ERROR: ID: " + str(allocation_id) + " IS NOT ASSOCIATED WITH ANY TUNER!")) return [ CF.DataType(id=self.frontend_tuner_status[tuner_id].getId(), value=self.frontend_tuner_status[tuner_id]._toAny()) ] def assignListener(self, listen_alloc_id, allocation_id): # find control allocation_id existing_alloc_id = allocation_id if self.listeners.has_key(existing_alloc_id): existing_alloc_id = self.listeners[existing_alloc_id] self.listeners[listen_alloc_id] = existing_alloc_id old_table = self.connectionTable new_entries = [] for entry in self.connectionTable: if entry.connection_id == existing_alloc_id: tmp = bulkio.connection_descriptor_struct() tmp.connection_id = listen_alloc_id tmp.stream_id = entry.stream_id tmp.port_name = entry.port_name new_entries.append(tmp) for new_entry in new_entries: foundEntry = False for entry in self.connectionTable: if entry.connection_id == new_entry.connection_id and \ entry.stream_id == entry.stream_id and \ entry.port_name == entry.port_name: foundEntry = True break if not foundEntry: self.connectionTable.append(new_entry) self.connectionTableChanged(old_table, self.connectionTable) def connectionTableChanged(self, oldValue, newValue): self.port_dataDouble_out.updateConnectionFilter(newValue) def removeListener(self, listen_alloc_id): if self.listeners.has_key(listen_alloc_id): del self.listeners[listen_alloc_id] old_table = self.connectionTable for entry in list(self.connectionTable): if entry.connection_id == listen_alloc_id: self.connectionTable.remove(entry) # Check to see if port "port_dataDouble_out" has a connection for this listener tmp = self.port_dataDouble_out._get_connections() for i in range(len(self.port_dataDouble_out._get_connections())): connection_id = tmp[i].connectionId if connection_id == listen_alloc_id: self.port_dataDouble_out.disconnectPort(connection_id) self.connectionTableChanged(old_table, self.connectionTable) def removeAllocationIdRouting(self, tuner_id): allocation_id = self.getControlAllocationId(tuner_id) old_table = self.connectionTable for entry in list(self.connectionTable): if entry.connection_id == allocation_id: self.connectionTable.remove(entry) for key, value in self.listeners.items(): if (value == allocation_id): for entry in list(self.connectionTable): if entry.connection_id == key: self.connectionTable.remove(entry) self.connectionTableChanged(old_table, self.connectionTable) def removeStreamIdRouting(self, stream_id, allocation_id): old_table = self.connectionTable for entry in list(self.connectionTable): if allocation_id == "": if entry.stream_id == stream_id: self.connectionTable.remove(entry) else: if entry.stream_id == stream_id and entry.connection_id == allocation_id: self.connectionTable.remove(entry) for key, value in self.listeners.items(): if (value == allocation_id): for entry in list(self.connectionTable): if entry.connection_id == key and entry.stream_id == stream_id: self.connectionTable.remove(entry) self.connectionTableChanged(old_table, self.connectionTable) def matchAllocationIdToStreamId(self, allocation_id, stream_id, port_name): if port_name != "": for entry in list(self.connectionTable): if entry.port_name != port_name: continue if entry.stream_id != stream_id: continue if entry.connection_id != allocation_id: continue # all three match. This is a repeat return old_table = self.connectionTable tmp = bulkio.connection_descriptor_struct() tmp.connection_id = allocation_id tmp.port_name = port_name tmp.stream_id = stream_id self.connectionTable.append(tmp) self.connectionTableChanged(old_table, self.connectionTable) return old_table = self.connectionTable tmp = bulkio.connection_descriptor_struct() tmp.connection_id = allocation_id tmp.port_name = "port_dataDouble_out" tmp.stream_id = stream_id self.connectionTable.append(tmp) self.connectionTableChanged(old_table, self.connectionTable)
class TestComplexProps_base(CF__POA.Resource, Resource): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatability # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False def initialize(self): Resource.initialize(self) # Instantiate the default implementations for all ports on this component def start(self): self.threadControlLock.acquire() try: Resource.start(self) if self.process_thread == None: self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE) self.process_thread.start() finally: self.threadControlLock.release() def process(self): """The process method should process a single "chunk" of data and then return. This method will be called from the processing thread again, and again, and again until it returns FINISH or stop() is called on the component. If no work is performed, then return NOOP""" raise NotImplementedError def stop(self): self.threadControlLock.acquire() try: process_thread = self.process_thread self.process_thread = None if process_thread != None: process_thread.stop() process_thread.join(self.TIMEOUT) if process_thread.isAlive(): raise CF.Resource.StopError( CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) finally: self.threadControlLock.release() def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") self.threadControlLock.acquire() try: Resource.releaseObject(self) finally: self.threadControlLock.release() ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. complexBooleanProp = simple_property(id_="complexBooleanProp", type_="boolean", defvalue=complex(0, 1), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexULongProp = simple_property(id_="complexULongProp", type_="ulong", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexShortProp = simple_property(id_="complexShortProp", type_="short", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexFloatProp = simple_property(id_="complexFloatProp", type_="float", defvalue=complex(4.0, 5.0), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexOctetProp = simple_property(id_="complexOctetProp", type_="octet", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexCharProp = simple_property(id_="complexCharProp", type_="char", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexUShort = simple_property(id_="complexUShort", type_="ushort", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexDouble = simple_property(id_="complexDouble", type_="double", defvalue=complex(4.0, 5.0), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexLong = simple_property(id_="complexLong", type_="long", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexLongLong = simple_property(id_="complexLongLong", type_="longlong", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexULongLong = simple_property(id_="complexULongLong", type_="ulonglong", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("configure", )) complexFloatSequence = simpleseq_property(id_="complexFloatSequence", type_="float", defvalue=[ complex(4.0, 5.0), complex(4.0, 5.0), complex(4.0, 5.0), ], complex=True, mode="readwrite", action="external", kinds=("configure", )) class Float(object): FloatStructMember = simple_property( id_="FloatStructMember", type_="float", defvalue=4.0, ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["FloatStructMember"] = self.FloatStructMember return str(d) def getId(self): return "FloatStruct" def isStruct(self): return True def getMembers(self): return [("FloatStructMember", self.FloatStructMember)] FloatStruct = struct_property(id_="FloatStruct", structdef=Float, configurationkind=("configure", ), mode="readwrite") class ComplexFloat(object): complexFloatStructMember = simple_property( id_="complexFloatStructMember", type_="float", defvalue=complex(4.0, 5.0), complex=True, ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["complexFloatStructMember"] = self.complexFloatStructMember return str(d) def getId(self): return "complexFloatStruct" def isStruct(self): return True def getMembers(self): return [("complexFloatStructMember", self.complexFloatStructMember) ] complexFloatStruct = struct_property(id_="complexFloatStruct", structdef=ComplexFloat, configurationkind=("configure", ), mode="readwrite") class FloatStructSequenceMember(object): FloatStructSequenceMemberMemember = simple_property( id_="FloatStructSequenceMemberMemember", type_="float", defvalue=4.0, ) def __init__(self, FloatStructSequenceMemberMemember=4.0): self.FloatStructSequenceMemberMemember = FloatStructSequenceMemberMemember def __str__(self): """Return a string representation of this structure""" d = {} d["FloatStructSequenceMemberMemember"] = self.FloatStructSequenceMemberMemember return str(d) def getId(self): return "FloatStructSequenceMember" def isStruct(self): return True def getMembers(self): return [("FloatStructSequenceMemberMemember", self.FloatStructSequenceMemberMemember)] FloatStructSequence = structseq_property( id_="FloatStructSequence", structdef=FloatStructSequenceMember, defvalue=[], configurationkind=("configure", ), mode="readwrite") class ComplexFloatStructSequenceMember(object): complexFloatStructSequenceMemberMemember = simple_property( id_="complexFloatStructSequenceMemberMemember", type_="float", defvalue=complex(4.0, 5.0), complex=True, ) def __init__(self, complexFloatStructSequenceMemberMemember=complex( 4.0, 5.0)): self.complexFloatStructSequenceMemberMemember = complexFloatStructSequenceMemberMemember def __str__(self): """Return a string representation of this structure""" d = {} d["complexFloatStructSequenceMemberMemember"] = self.complexFloatStructSequenceMemberMemember return str(d) def getId(self): return "complexFloatStructSequenceMember" def isStruct(self): return True def getMembers(self): return [("complexFloatStructSequenceMemberMemember", self.complexFloatStructSequenceMemberMemember)] complexFloatStructSequence = structseq_property( id_="complexFloatStructSequence", structdef=ComplexFloatStructSequenceMember, defvalue=[], configurationkind=("configure", ), mode="readwrite")
mode="readonly", action="eq", kinds=("allocation","configure"), description=""" This specifies the specific device""" ) frontend_video_allocation = struct_property(id_="FRONTEND::video_allocation", name="frontend_video_allocation", structdef=frontend_video_allocation, configurationkind=("allocation",), mode="readwrite", description="""Frontend Interfaces v2.0 main allocation structure""" ) frontend_listener_allocation = struct_property(id_="FRONTEND::listener_allocation", name="frontend_listener_allocation", structdef=frontend_listener_allocation, configurationkind=("allocation",), mode="readwrite", description="""Allocates a listener (subscriber) based off a previous allocation """ ) frontend_video_status = structseq_property(id_="FRONTEND::video_status", name="frontend_video_status", structdef=default_frontend_video_status_struct_struct, defvalue=[], configurationkind=("configure",), mode="readonly", description="""Frontend Interfaces v2.0 status structure. One element for every frontend resource (receiver, transmitter) configured on this hardware""" )
class BasicTestDevice(CF__POA.AggregateExecutableDevice, ExecutableDevice, AggregateDevice): def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES) AggregateDevice.__init__(self) self._props["memCapacity"] = 100000000 self._props["BogoMipsCapacity"] = 100000000 self._props["nicCapacity"] = 100.0 self._props["fakeCapacity"] = 3 self._props["execparams"] = " ".join( ["%s %s" % x for x in execparams.items()]) def initialize(self): # change the no_default_prop to be not None to ensure that the device manager # doesn't configure properties with no value (i.e. test_NoConfigureNilDeviceProperties) self._props["no_default_prop"] = "not_none" def execute(self, name, options, parameters): retval = ExecutableDevice.execute(self, name, options, parameters) for option in options: if option.id == 'STACK_SIZE': self._props['check_STACK_SIZE'] = option.value._v elif option.id == 'PRIORITY': self._props['check_PRIORITY'] = option.value._v return retval # See BasicChildDevice for an example of manually dealing with allocate/deallocate def allocate_fakeCapacity(self, value): if self._props["fakeCapacity"] < value: return False self._props["fakeCapacity"] = self._props["fakeCapacity"] - value return True def allocate_nicCapacity(self, value): if self._props["nicCapacity"] < value: return False self._props["nicCapacity"] = self._props["nicCapacity"] - value return True def allocate_memCapacity(self, value): if self._props["memCapacity"] < value: return False self._props["memCapacity"] = self._props["memCapacity"] - value return True def allocate_BogoMipsCapacity(self, value): if self._props["BogoMipsCapacity"] < value: return False self._props[ "BogoMipsCapacity"] = self._props["BogoMipsCapacity"] - value return True def deallocate_fakeCapacity(self, value): self._props["fakeCapacity"] = self._props["fakeCapacity"] + value def deallocate_nicCapacity(self, value): self._props["nicCapacity"] = self._props["nicCapacity"] + value def deallocate_memCapacity(self, value): self._props["memCapacity"] = self._props["memCapacity"] + value def deallocate_BogoMipsCapacity(self, value): self._props[ "BogoMipsCapacity"] = self._props["BogoMipsCapacity"] + value def allocate_allocStruct(self, value): if value > self.allocStruct: return False self.allocStruct -= value return True def deallocate_allocStruct(self, value): self.allocStruct += value def allocate_passwordStruct(self, value): if value == self.passwordStruct: return True else: self._log.error("Wrong allocation property value") def updateUsageState(self): # Update usage state if self._props["memCapacity"] == 0 and self._props[ "BogoMipsCapacity"] == 0: self._usageState = CF.Device.BUSY elif self._props["memCapacity"] == 100000000 and self._props[ "BogoMipsCapacity"] == 100000000: self._usageState = CF.Device.IDLE else: self._usageState = CF.Device.ACTIVE class SomeStruct(object): field1 = simple_property(id_="item1", type_="string", defvalue="value1") field2 = simple_property(id_="item2", type_="long", defvalue=100) field3 = simple_property(id_="item3", type_="double", defvalue=3.14156) struct = struct_property(id_="DCE:ffe634c9-096d-425b-86cc-df1cce50612f", name="struct_test", structdef=SomeStruct) class PasswordStruct(object): password = simple_property(id_="password", type_="string", defvalue="abracadabra") def __eq__(self, other): return self.password == other.password passwordStruct = struct_property( id_="DCE:a5a6ab83-d2a8-4350-ac4d-05b40ee93838", name="passwordStruct", configurationkind=("allocation"), structdef=PasswordStruct) class AllocStruct(object): long_capacity = simple_property(id_="long_capacity", type_="long", defvalue=100) float_capacity = simple_property(id_="float_capacity", type_="float", defvalue=1.0) struct_simple_seq = simpleseq_property(id_="struct_simple_seq", type_="short", defvalue=[50, 500]) def __gt__(self, other): return (self.long_capacity > other.long_capacity or self.float_capacity > other.float_capacity) def __iadd__(self, other): self.long_capacity += other.long_capacity self.float_capacity += other.float_capacity self.struct_simple_seq[0] += other.struct_simple_seq[0] self.struct_simple_seq[1] += other.struct_simple_seq[1] return self def __isub__(self, other): self.long_capacity -= other.long_capacity self.float_capacity -= other.float_capacity self.struct_simple_seq[0] -= other.struct_simple_seq[0] self.struct_simple_seq[1] -= other.struct_simple_seq[1] return self allocStruct = struct_property( id_="DCE:001fad60-b4b3-4ed2-94cb-40e1d956bf4f", name="allocStruct", configurationkind=("configure", "allocation"), structdef=AllocStruct) structseq = structseq_property( id_="DCE:e836f007-5821-4671-b05a-e0ff5147fe86", name="structseq_test", structdef=SomeStruct, defvalue=[]) hex_props = simpleseq_property(id_="hex_props", name="hex_props", type_='short', defvalue=(0x01, 0x02))
class TestComponentProperty_base(CF__POA.Resource, Resource): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False def initialize(self): Resource.initialize(self) # Instantiate the default implementations for all ports on this component def start(self): self.threadControlLock.acquire() try: Resource.start(self) if self.process_thread == None: self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE) self.process_thread.start() finally: self.threadControlLock.release() def process(self): """The process method should process a single "chunk" of data and then return. This method will be called from the processing thread again, and again, and again until it returns FINISH or stop() is called on the component. If no work is performed, then return NOOP""" raise NotImplementedError def stop(self): self.threadControlLock.acquire() try: process_thread = self.process_thread self.process_thread = None if process_thread != None: process_thread.stop() process_thread.join(self.TIMEOUT) if process_thread.isAlive(): raise CF.Resource.StopError( CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) finally: self.threadControlLock.release() def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") self.threadControlLock.acquire() try: Resource.releaseObject(self) finally: self.threadControlLock.release() ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. my_long_enum = simple_property(id_="my_long_enum", type_="long", defvalue=11, mode="readwrite", action="external", kinds=("configure", )) simpleExecparam = simple_property(id_="simpleExecparam", type_="float", defvalue=1.0, mode="readwrite", action="eq", kinds=("execparam", )) seqTest = simpleseq_property(id_="seqTest", type_="char", defvalue=[ 'a', 'b', 'c', ], mode="readwrite", action="external", kinds=("configure", )) class MyStruct(object): bool_true = simple_property( id_="bool_true", type_="boolean", defvalue=True, ) bool_false = simple_property( id_="bool_false", type_="boolean", ) bool_empty = simple_property( id_="bool_empty", type_="boolean", ) long_s = simple_property( id_="long_s", type_="long", ) str_s = simple_property( id_="str_s", type_="string", ) enum_bool = simple_property( id_="enum_bool", type_="boolean", ) enum_str = simple_property( id_="enum_str", type_="string", ) enum_long = simple_property( id_="enum_long", type_="long", ) es__3 = simple_property( id_="es::3", type_="long", ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["bool_true"] = self.bool_true d["bool_false"] = self.bool_false d["bool_empty"] = self.bool_empty d["long_s"] = self.long_s d["str_s"] = self.str_s d["enum_bool"] = self.enum_bool d["enum_str"] = self.enum_str d["enum_long"] = self.enum_long d["es__3"] = self.es__3 return str(d) def getId(self): return "my_struct" def isStruct(self): return True def getMembers(self): return [("bool_true", self.bool_true), ("bool_false", self.bool_false), ("bool_empty", self.bool_empty), ("long_s", self.long_s), ("str_s", self.str_s), ("enum_bool", self.enum_bool), ("enum_str", self.enum_str), ("enum_long", self.enum_long), ("es__3", self.es__3)] my_struct = struct_property(id_="my_struct", structdef=MyStruct, configurationkind=("configure", ), mode="readwrite") class Tests(object): b = simple_property( id_="b", type_="ulonglong", defvalue=32, ) t = simple_property( id_="t", type_="string", defvalue="dfdasfas", ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["b"] = self.b d["t"] = self.t return str(d) def getId(self): return "tests" def isStruct(self): return True def getMembers(self): return [("b", self.b), ("t", self.t)] tests = struct_property(id_="tests", structdef=Tests, configurationkind=("configure", ), mode="readwrite") class StructsTest(object): simpleShort = simple_property( id_="simpleShort", type_="short", defvalue=3, ) simpleFloat = simple_property( id_="simpleFloat", type_="long", defvalue=2, ) def __init__(self, simpleShort=3, simpleFloat=2): self.simpleShort = simpleShort self.simpleFloat = simpleFloat def __str__(self): """Return a string representation of this structure""" d = {} d["simpleShort"] = self.simpleShort d["simpleFloat"] = self.simpleFloat return str(d) def getId(self): return "structsTest" def isStruct(self): return True def getMembers(self): return [("simpleShort", self.simpleShort), ("simpleFloat", self.simpleFloat)] structSeqTest = structseq_property( id_="structSeqTest", structdef=StructsTest, defvalue=[StructsTest(3, 2), StructsTest(3, 2)], configurationkind=("allocation", "configure"), mode="readwrite")
class Sandbox_base(CF__POA.Resource, Resource): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatability # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False def initialize(self): Resource.initialize(self) # Instantiate the default implementations for all ports on this component def start(self): self.threadControlLock.acquire() try: Resource.start(self) if self.process_thread == None: self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE) self.process_thread.start() finally: self.threadControlLock.release() def process(self): """The process method should process a single "chunk" of data and then return. This method will be called from the processing thread again, and again, and again until it returns FINISH or stop() is called on the component. If no work is performed, then return NOOP""" raise NotImplementedError def stop(self): self.threadControlLock.acquire() try: process_thread = self.process_thread self.process_thread = None if process_thread != None: process_thread.stop() process_thread.join(self.TIMEOUT) if process_thread.isAlive(): raise CF.Resource.StopError( CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) finally: self.threadControlLock.release() def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") self.threadControlLock.acquire() try: Resource.releaseObject(self) finally: self.threadControlLock.release() ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. my_bool_true = simple_property(id_="my_bool_true", type_="boolean", defvalue=True, mode="readwrite", action="external", kinds=("configure", )) my_bool_false = simple_property(id_="my_bool_false", type_="boolean", defvalue=False, mode="readwrite", action="external", kinds=("configure", )) my_bool_empty = simple_property(id_="my_bool_empty", type_="boolean", mode="readwrite", action="external", kinds=("configure", )) my_long = simple_property(id_="my_long", type_="long", defvalue=10, mode="readwrite", action="external", kinds=("configure", )) my_long_empty = simple_property(id_="my_long_empty", type_="long", mode="readwrite", action="external", kinds=("configure", )) my_str = simple_property(id_="my_str", type_="string", defvalue="Hello World!", mode="readwrite", action="external", kinds=("configure", )) my_str_empty = simple_property(id_="my_str_empty", type_="string", mode="readwrite", action="external", kinds=("configure", )) my_long_enum = simple_property(id_="my_long_enum", type_="long", mode="readwrite", action="external", kinds=("configure", )) my_str_enum = simple_property(id_="my_str_enum", type_="string", mode="readwrite", action="external", kinds=("configure", )) my_bool_enum = simple_property(id_="my_bool_enum", type_="boolean", mode="readwrite", action="external", kinds=("configure", )) escape__simple = simple_property(id_="escape::simple", type_="long", mode="readwrite", action="external", kinds=("configure", )) readonly_simp = simple_property(id_="readonly_simp", type_="string", defvalue="Read only simple prop", mode="readonly", action="external", kinds=("configure", )) my_seq_bool = simpleseq_property(id_="my_seq_bool", type_="boolean", defvalue=(True, False), mode="readwrite", action="external", kinds=("configure", )) my_seq_str = simpleseq_property(id_="my_seq_str", type_="string", defvalue=("one", "", "three"), mode="readwrite", action="external", kinds=("configure", )) readonly_seq = simpleseq_property(id_="readonly_seq", type_="string", defvalue=("read only", "sequence property"), mode="readonly", action="external", kinds=("configure", )) class MyStruct(object): bool_true = simple_property( id_="bool_true", type_="boolean", defvalue=True, ) bool_false = simple_property( id_="bool_false", type_="boolean", defvalue=False, ) bool_empty = simple_property( id_="bool_empty", type_="boolean", ) long_s = simple_property( id_="long_s", type_="long", ) str_s = simple_property( id_="str_s", type_="string", ) enum_bool = simple_property( id_="enum_bool", type_="boolean", ) enum_str = simple_property( id_="enum_str", type_="string", ) enum_long = simple_property( id_="enum_long", type_="long", ) es__3 = simple_property( id_="es::3", type_="long", ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["bool_true"] = self.bool_true d["bool_false"] = self.bool_false d["bool_empty"] = self.bool_empty d["long_s"] = self.long_s d["str_s"] = self.str_s d["enum_bool"] = self.enum_bool d["enum_str"] = self.enum_str d["enum_long"] = self.enum_long d["es__3"] = self.es__3 return str(d) def getId(self): return "my_struct" def isStruct(self): return True def getMembers(self): return [("bool_true", self.bool_true), ("bool_false", self.bool_false), ("bool_empty", self.bool_empty), ("long_s", self.long_s), ("str_s", self.str_s), ("enum_bool", self.enum_bool), ("enum_str", self.enum_str), ("enum_long", self.enum_long), ("es__3", self.es__3)] my_struct = struct_property(id_="my_struct", structdef=MyStruct, configurationkind=("configure", ), mode="readwrite") class EscapeStruct(object): es__1 = simple_property( id_="es::1", type_="long", ) es__2 = simple_property( id_="es::2", type_="long", ) normal = simple_property( id_="normal", type_="long", ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["es__1"] = self.es__1 d["es__2"] = self.es__2 d["normal"] = self.normal return str(d) def getId(self): return "escape::struct" def isStruct(self): return True def getMembers(self): return [("es__1", self.es__1), ("es__2", self.es__2), ("normal", self.normal)] escape__struct = struct_property(id_="escape::struct", structdef=EscapeStruct, configurationkind=("configure", ), mode="readwrite") class ReadonlyStruct(object): readonly_struct_simp = simple_property( id_="readonly_struct_simp", type_="string", defvalue="read only struct property", ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["readonly_struct_simp"] = self.readonly_struct_simp return str(d) def getId(self): return "readonly_struct" def isStruct(self): return True def getMembers(self): return [("readonly_struct_simp", self.readonly_struct_simp)] readonly_struct = struct_property(id_="readonly_struct", structdef=ReadonlyStruct, configurationkind=("configure", ), mode="readonly") class StructGood(object): simp__bad = simple_property( id_="simp::bad", type_="long", ) simp_bool = simple_property( id_="simp_bool", type_="boolean", ) def __init__(self, simp__bad=0, simp_bool=False): self.simp__bad = simp__bad self.simp_bool = simp_bool def __str__(self): """Return a string representation of this structure""" d = {} d["simp__bad"] = self.simp__bad d["simp_bool"] = self.simp_bool return str(d) def getId(self): return "struct_good" def isStruct(self): return True def getMembers(self): return [("simp__bad", self.simp__bad), ("simp_bool", self.simp_bool)] my_struct_seq = structseq_property( id_="my_struct_seq", structdef=StructGood, defvalue=[StructGood(0, False), StructGood(0, False)], configurationkind=("configure", ), mode="readwrite") class EsSs(object): val__1 = simple_property( id_="val::1", type_="long", ) val_2 = simple_property( id_="val_2", type_="string", ) def __init__(self, val__1=0, val_2=""): self.val__1 = val__1 self.val_2 = val_2 def __str__(self): """Return a string representation of this structure""" d = {} d["val__1"] = self.val__1 d["val_2"] = self.val_2 return str(d) def getId(self): return "es::ss" def isStruct(self): return True def getMembers(self): return [("val__1", self.val__1), ("val_2", self.val_2)] escape__structseq = structseq_property(id_="escape::structseq", structdef=EsSs, defvalue=[EsSs(0, ""), EsSs(0, "")], configurationkind=("configure", ), mode="readwrite") class ReadonlySs(object): readonly_s = simple_property( id_="readonly_s", type_="string", ) def __init__(self, readonly_s=""): self.readonly_s = readonly_s def __str__(self): """Return a string representation of this structure""" d = {} d["readonly_s"] = self.readonly_s return str(d) def getId(self): return "readonly_ss" def isStruct(self): return True def getMembers(self): return [("readonly_s", self.readonly_s)] readonly_structseq = structseq_property( id_="readonly_structseq", structdef=ReadonlySs, defvalue=[ReadonlySs("read only"), ReadonlySs("struct seq property")], configurationkind=("configure", ), mode="readonly")
class PropertyApi_base(CF__POA.Resource, Component, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Component.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component self.port_dataFloat_in = bulkio.InFloatPort( "dataFloat_in", maxsize=self.DEFAULT_QUEUE_SIZE) self.port_dataFloat_in._portLog = self._baseLog.getChildLogger( 'dataFloat_in', 'ports') self.port_dataFloat_out = bulkio.OutFloatPort("dataFloat_out") self.port_dataFloat_out._portLog = self._baseLog.getChildLogger( 'dataFloat_out', 'ports') def start(self): Component.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): Component.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._baseLog.exception("Error stopping") Component.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. port_dataFloat_in = providesport(name="dataFloat_in", repid="IDL:BULKIO/dataFloat:1.0", type_="data") port_dataFloat_out = usesport(name="dataFloat_out", repid="IDL:BULKIO/dataFloat:1.0", type_="data") ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. simp_seq_c = simpleseq_property(id_="simp_seq_c", name="simp_seq_c", type_="string", defvalue=["c_1", "c_2"], mode="readwrite", action="external", kinds=("property", )) simp_seq_d = simpleseq_property(id_="simp_seq_d", name="simp_seq_d", type_="string", defvalue=["d_1", "d_2"], mode="readwrite", action="external", kinds=("property", )) class StructA(object): simple_a = simple_property(id_="struct_a::simple_a", name="simple_a", type_="string", defvalue="simp_a") simpseq_a1 = simpleseq_property(id_="struct_a::simpseq_a1", name="simpseq_a1", type_="string", defvalue=["a1_1", "a2_2"]) simpseq_a2 = simpleseq_property(id_="struct_a::simpseq_a2", name="simpseq_a2", type_="string", defvalue=[]) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["simple_a"] = self.simple_a d["simpseq_a1"] = self.simpseq_a1 d["simpseq_a2"] = self.simpseq_a2 return str(d) @classmethod def getId(cls): return "struct_a" @classmethod def isStruct(cls): return True def getMembers(self): return [("simple_a", self.simple_a), ("simpseq_a1", self.simpseq_a1), ("simpseq_a2", self.simpseq_a2)] struct_a = struct_property(id_="struct_a", name="struct_a", structdef=StructA, configurationkind=("property", ), mode="readwrite") class StructB(object): simple_b = simple_property(id_="struct_seq_b::simple_b", name="simple_b", type_="string", defvalue="simp_b") simp_seq_b1 = simpleseq_property(id_="struct_seq_b::simp_seq_b1", name="simp_seq_b1", type_="string", defvalue=[]) simp_seq_b2 = simpleseq_property(id_="struct_seq_b::simp_seq_b2", name="simp_seq_b2", type_="string", defvalue=["b2_1", "b2_2"]) def __init__(self, simple_b="simp_b", simp_seq_b1=[], simp_seq_b2=["b2_1", "b2_2"]): self.simple_b = simple_b self.simp_seq_b1 = simp_seq_b1 self.simp_seq_b2 = simp_seq_b2 def __str__(self): """Return a string representation of this structure""" d = {} d["simple_b"] = self.simple_b d["simp_seq_b1"] = self.simp_seq_b1 d["simp_seq_b2"] = self.simp_seq_b2 return str(d) @classmethod def getId(cls): return "struct_seq_b::struct_b" @classmethod def isStruct(cls): return True def getMembers(self): return [("simple_b", self.simple_b), ("simp_seq_b1", self.simp_seq_b1), ("simp_seq_b2", self.simp_seq_b2)] struct_seq_b = structseq_property(id_="struct_seq_b", name="struct_seq_b", structdef=StructB, defvalue=[ StructB(simple_b="simp_b", simp_seq_b1=[""], simp_seq_b2=["b2_1", "b2_2"]) ], configurationkind=("property", ), mode="readwrite") class StructE(object): simple_e = simple_property(id_="struct_seq_e::simple_e", name="simple_e", type_="string", defvalue="simp_e") simpseq_e1 = simpleseq_property(id_="struct_seq_e::simpseq_e1", name="simpseq_e1", type_="string", defvalue=["e1_1", "e1_2"]) simpseq_e2 = simpleseq_property(id_="struct_seq_e::simpseq_e2", name="simpseq_e2", type_="string", defvalue=[]) def __init__(self, simple_e="simp_e", simpseq_e1=["e1_1", "e1_2"], simpseq_e2=[]): self.simple_e = simple_e self.simpseq_e1 = simpseq_e1 self.simpseq_e2 = simpseq_e2 def __str__(self): """Return a string representation of this structure""" d = {} d["simple_e"] = self.simple_e d["simpseq_e1"] = self.simpseq_e1 d["simpseq_e2"] = self.simpseq_e2 return str(d) @classmethod def getId(cls): return "struct_seq_e::struct_e" @classmethod def isStruct(cls): return True def getMembers(self): return [("simple_e", self.simple_e), ("simpseq_e1", self.simpseq_e1), ("simpseq_e2", self.simpseq_e2)] struct_seq_e = structseq_property(id_="struct_seq_e", name="struct_seq_e", structdef=StructE, defvalue=[ StructE(simple_e="simp_e", simpseq_e1=["e1_1", "e1_2"], simpseq_e2=[""]), StructE(simple_e="simp_e", simpseq_e1=["e1_1", "e1_2"], simpseq_e2=[""]) ], configurationkind=("property", ), mode="readwrite")
class TestComplexProps_base(CF__POA.Resource, Component, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Component.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component def start(self): Component.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): Component.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Component.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. complexBooleanProp = simple_property(id_="complexBooleanProp", type_="boolean", defvalue=complex(0, 1), complex=True, mode="readwrite", action="external", kinds=("property", )) complexULongProp = simple_property(id_="complexULongProp", type_="ulong", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("property", )) complexShortProp = simple_property(id_="complexShortProp", type_="short", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("property", )) complexFloatProp = simple_property(id_="complexFloatProp", type_="float", defvalue=complex(4.0, 5.0), complex=True, mode="readwrite", action="external", kinds=("property", )) complexOctetProp = simple_property(id_="complexOctetProp", type_="octet", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("property", )) complexUShort = simple_property(id_="complexUShort", type_="ushort", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("property", )) complexDouble = simple_property(id_="complexDouble", type_="double", defvalue=complex(4.0, 5.0), complex=True, mode="readwrite", action="external", kinds=("property", )) complexLong = simple_property(id_="complexLong", type_="long", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("property", )) complexLongLong = simple_property(id_="complexLongLong", type_="longlong", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("property", )) complexULongLong = simple_property(id_="complexULongLong", type_="ulonglong", defvalue=complex(4, 5), complex=True, mode="readwrite", action="external", kinds=("property", )) complexFloatSequence = simpleseq_property( id_="complexFloatSequence", type_="float", defvalue=[complex(6.0, 7.0), complex(4.0, 5.0), complex(4.0, 5.0)], complex=True, mode="readwrite", action="external", kinds=("property", )) class _Float(object): FloatStructMember = simple_property(id_="FloatStructMember", type_="float", defvalue=6.0) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["FloatStructMember"] = self.FloatStructMember return str(d) @classmethod def getId(cls): return "FloatStruct" @classmethod def isStruct(cls): return True def getMembers(self): return [("FloatStructMember", self.FloatStructMember)] FloatStruct = struct_property(id_="FloatStruct", structdef=_Float, configurationkind=("property", ), mode="readwrite") class ComplexFloat(object): complexFloatStructMember = simple_property( id_="complexFloatStructMember", type_="float", defvalue=complex(6.0, 7.0), complex=True) complex_float_seq = simpleseq_property( id_="complexFloatStruct::complex_float_seq", name="complex_float_seq", type_="float", defvalue=[complex(3.0, 2.0)], complex=True) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["complexFloatStructMember"] = self.complexFloatStructMember d["complex_float_seq"] = self.complex_float_seq return str(d) @classmethod def getId(cls): return "complexFloatStruct" @classmethod def isStruct(cls): return True def getMembers(self): return [("complexFloatStructMember", self.complexFloatStructMember), ("complex_float_seq", self.complex_float_seq)] complexFloatStruct = struct_property(id_="complexFloatStruct", structdef=ComplexFloat, configurationkind=("property", ), mode="readwrite") class _FloatStructSequenceMember(object): FloatStructSequenceMemberMemember = simple_property( id_="FloatStructSequenceMemberMemember", type_="float", defvalue=6.0) float_seq = simpleseq_property(id_="FloatStructSequence::float_seq", name="float_seq", type_="float", defvalue=[3.0]) def __init__(self, FloatStructSequenceMemberMemember=6.0, float_seq=[3.0]): self.FloatStructSequenceMemberMemember = FloatStructSequenceMemberMemember self.float_seq = float_seq def __str__(self): """Return a string representation of this structure""" d = {} d["FloatStructSequenceMemberMemember"] = self.FloatStructSequenceMemberMemember d["float_seq"] = self.float_seq return str(d) @classmethod def getId(cls): return "FloatStructSequenceMember" @classmethod def isStruct(cls): return True def getMembers(self): return [("FloatStructSequenceMemberMemember", self.FloatStructSequenceMemberMemember), ("float_seq", self.float_seq)] FloatStructSequence = structseq_property( id_="FloatStructSequence", structdef=_FloatStructSequenceMember, defvalue=[], configurationkind=("property", ), mode="readwrite") class ComplexFloatStructSequenceMember(object): complexFloatStructSequenceMemberMemember = simple_property( id_="complexFloatStructSequenceMemberMemember", type_="float", defvalue=complex(6.0, 5.0), complex=True) complex_float_seq = simpleseq_property( id_="complexFloatStructSequence::complex_float_seq", name="complex_float_seq", type_="float", defvalue=[complex(3.0, 2.0)], complex=True) def __init__(self, complexFloatStructSequenceMemberMemember=complex( 6.0, 5.0), complex_float_seq=[complex(3.0, 2.0)]): self.complexFloatStructSequenceMemberMemember = complexFloatStructSequenceMemberMemember self.complex_float_seq = complex_float_seq def __str__(self): """Return a string representation of this structure""" d = {} d["complexFloatStructSequenceMemberMemember"] = self.complexFloatStructSequenceMemberMemember d["complex_float_seq"] = self.complex_float_seq return str(d) @classmethod def getId(cls): return "complexFloatStructSequenceMember" @classmethod def isStruct(cls): return True def getMembers(self): return [("complexFloatStructSequenceMemberMemember", self.complexFloatStructSequenceMemberMemember), ("complex_float_seq", self.complex_float_seq)] complexFloatStructSequence = structseq_property( id_="complexFloatStructSequence", structdef=ComplexFloatStructSequenceMember, defvalue=[], configurationkind=("property", ), mode="readwrite")
class TestAllPropTypes_base(CF__POA.Resource, Resource): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatability # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False def initialize(self): Resource.initialize(self) # Instantiate the default implementations for all ports on this component def start(self): self.threadControlLock.acquire() try: Resource.start(self) if self.process_thread == None: self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE) self.process_thread.start() finally: self.threadControlLock.release() def process(self): """The process method should process a single "chunk" of data and then return. This method will be called from the processing thread again, and again, and again until it returns FINISH or stop() is called on the component. If no work is performed, then return NOOP""" raise NotImplementedError def stop(self): self.threadControlLock.acquire() try: process_thread = self.process_thread self.process_thread = None if process_thread != None: process_thread.stop() process_thread.join(self.TIMEOUT) if process_thread.isAlive(): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) finally: self.threadControlLock.release() def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") self.threadControlLock.acquire() try: Resource.releaseObject(self) finally: self.threadControlLock.release() ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. simple_string = simple_property(id_="simple_string", type_="string", mode="readwrite", action="external", kinds=("configure",) ) simple_boolean = simple_property(id_="simple_boolean", type_="boolean", mode="readwrite", action="external", kinds=("configure",) ) simple_ulong = simple_property(id_="simple_ulong", type_="ulong", mode="readwrite", action="external", kinds=("configure",) ) # simple_objref = simple_property(id_="simple_objref", # type_="objref", # mode="readwrite", # action="external", # kinds=("configure",) # ) simple_short = simple_property(id_="simple_short", type_="short", mode="readwrite", action="external", kinds=("configure",) ) simple_float = simple_property(id_="simple_float", type_="float", mode="readwrite", action="external", kinds=("configure",) ) simple_octet = simple_property(id_="simple_octet", type_="octet", mode="readwrite", action="external", kinds=("configure",) ) simple_char = simple_property(id_="simple_char", type_="char", mode="readwrite", action="external", kinds=("configure",) ) simple_ushort = simple_property(id_="simple_ushort", type_="ushort", mode="readwrite", action="external", kinds=("configure",) ) simple_double = simple_property(id_="simple_double", type_="double", mode="readwrite", action="external", kinds=("configure",) ) simple_long = simple_property(id_="simple_long", type_="long", mode="readwrite", action="external", kinds=("configure",) ) simple_longlong = simple_property(id_="simple_longlong", type_="longlong", mode="readwrite", action="external", kinds=("configure",) ) simple_ulonglong = simple_property(id_="simple_ulonglong", type_="ulonglong", mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_string = simpleseq_property(id_="simple_sequence_string", type_="string", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_boolean = simpleseq_property(id_="simple_sequence_boolean", type_="boolean", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_ulong = simpleseq_property(id_="simple_sequence_ulong", type_="ulong", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) # simple_sequence_objref = simpleseq_property(id_="simple_sequence_objref", # type_="objref", # defvalue=None, # mode="readwrite", # action="external", # kinds=("configure",) # ) simple_sequence_short = simpleseq_property(id_="simple_sequence_short", type_="short", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_float = simpleseq_property(id_="simple_sequence_float", type_="float", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_octet = simpleseq_property(id_="simple_sequence_octet", type_="octet", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_char = simpleseq_property(id_="simple_sequence_char", type_="char", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_ushort = simpleseq_property(id_="simple_sequence_ushort", type_="ushort", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_double = simpleseq_property(id_="simple_sequence_double", type_="double", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_long = simpleseq_property(id_="simple_sequence_long", type_="long", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_longlong = simpleseq_property(id_="simple_sequence_longlong", type_="longlong", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) simple_sequence_ulonglong = simpleseq_property(id_="simple_sequence_ulonglong", type_="ulonglong", defvalue=None, mode="readwrite", action="external", kinds=("configure",) ) class StructVars(object): struct_string = simple_property(id_="struct_string", type_="string", ) struct_boolean = simple_property(id_="struct_boolean", type_="boolean", ) struct_ulong = simple_property(id_="struct_ulong", type_="ulong", ) # struct_objref = simple_property(id_="struct_objref", # type_="objref", # ) struct_short = simple_property(id_="struct_short", type_="short", ) struct_float = simple_property(id_="struct_float", type_="float", ) struct_octet = simple_property(id_="struct_octet", type_="octet", ) struct_char = simple_property(id_="struct_char", type_="char", ) struct_ushort = simple_property(id_="struct_ushort", type_="ushort", ) struct_double = simple_property(id_="struct_double", type_="double", ) struct_long = simple_property(id_="struct_long", type_="long", ) struct_longlong = simple_property(id_="struct_longlong", type_="longlong", ) struct_ulonglong = simple_property(id_="struct_ulonglong", type_="ulonglong", ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k,v in kw.items(): setattr(self,k,v) def __str__(self): """Return a string representation of this structure""" d = {} d["struct_string"] = self.struct_string d["struct_boolean"] = self.struct_boolean d["struct_ulong"] = self.struct_ulong # d["struct_objref"] = self.struct_objref d["struct_short"] = self.struct_short d["struct_float"] = self.struct_float d["struct_octet"] = self.struct_octet d["struct_char"] = self.struct_char d["struct_ushort"] = self.struct_ushort d["struct_double"] = self.struct_double d["struct_long"] = self.struct_long d["struct_longlong"] = self.struct_longlong d["struct_ulonglong"] = self.struct_ulonglong return str(d) def getId(self): return "struct_vars" def isStruct(self): return True def getMembers(self): return [("struct_string",self.struct_string),("struct_boolean",self.struct_boolean),("struct_ulong",self.struct_ulong),#("struct_objref",self.struct_objref), ("struct_short",self.struct_short),("struct_float",self.struct_float),("struct_octet",self.struct_octet),("struct_char",self.struct_char),("struct_ushort",self.struct_ushort),("struct_double",self.struct_double),("struct_long",self.struct_long),("struct_longlong",self.struct_longlong),("struct_ulonglong",self.struct_ulonglong)] struct_vars = struct_property(id_="struct_vars", structdef=StructVars, configurationkind=("configure",), mode="readwrite" ) class StructSeqVars(object): struct_seq_string = simple_property(id_="struct_seq_string", type_="string", ) struct_seq_boolean = simple_property(id_="struct_seq_boolean", type_="boolean", ) struct_seq_ulong = simple_property(id_="struct_seq_ulong", type_="ulong", ) # struct_seq_objref = simple_property(id_="struct_seq_objref", # type_="objref", # ) struct_seq_short = simple_property(id_="struct_seq_short", type_="short", ) struct_seq_float = simple_property(id_="struct_seq_float", type_="float", ) struct_seq_octet = simple_property(id_="struct_seq_octet", type_="octet", ) struct_seq_char = simple_property(id_="struct_seq_char", type_="char", ) struct_seq_ushort = simple_property(id_="struct_seq_ushort", type_="ushort", ) struct_seq_double = simple_property(id_="struct_seq_double", type_="double", ) struct_seq_long = simple_property(id_="struct_seq_long", type_="long", ) struct_seq_longlong = simple_property(id_="struct_seq_longlong", type_="longlong", ) struct_seq_ulonglong = simple_property(id_="struct_seq_ulonglong", type_="ulonglong", ) def __init__(self, struct_seq_string="", struct_seq_boolean=False, struct_seq_ulong=0, struct_seq_objref="", struct_seq_short=0, struct_seq_float=0, struct_seq_octet=0, struct_seq_char="", struct_seq_ushort=0, struct_seq_double=0, struct_seq_long=0, struct_seq_longlong=0, struct_seq_ulonglong=0): self.struct_seq_string = struct_seq_string self.struct_seq_boolean = struct_seq_boolean self.struct_seq_ulong = struct_seq_ulong self.struct_seq_objref = struct_seq_objref self.struct_seq_short = struct_seq_short self.struct_seq_float = struct_seq_float self.struct_seq_octet = struct_seq_octet self.struct_seq_char = struct_seq_char self.struct_seq_ushort = struct_seq_ushort self.struct_seq_double = struct_seq_double self.struct_seq_long = struct_seq_long self.struct_seq_longlong = struct_seq_longlong self.struct_seq_ulonglong = struct_seq_ulonglong def __str__(self): """Return a string representation of this structure""" d = {} d["struct_seq_string"] = self.struct_seq_string d["struct_seq_boolean"] = self.struct_seq_boolean d["struct_seq_ulong"] = self.struct_seq_ulong d["struct_seq_objref"] = self.struct_seq_objref d["struct_seq_short"] = self.struct_seq_short d["struct_seq_float"] = self.struct_seq_float d["struct_seq_octet"] = self.struct_seq_octet d["struct_seq_char"] = self.struct_seq_char d["struct_seq_ushort"] = self.struct_seq_ushort d["struct_seq_double"] = self.struct_seq_double d["struct_seq_long"] = self.struct_seq_long d["struct_seq_longlong"] = self.struct_seq_longlong d["struct_seq_ulonglong"] = self.struct_seq_ulonglong return str(d) def getId(self): return "struct_seq_vars" def isStruct(self): return True def getMembers(self): return [("struct_seq_string",self.struct_seq_string),("struct_seq_boolean",self.struct_seq_boolean),("struct_seq_ulong",self.struct_seq_ulong),("struct_seq_objref",self.struct_seq_objref),("struct_seq_short",self.struct_seq_short),("struct_seq_float",self.struct_seq_float),("struct_seq_octet",self.struct_seq_octet),("struct_seq_char",self.struct_seq_char),("struct_seq_ushort",self.struct_seq_ushort),("struct_seq_double",self.struct_seq_double),("struct_seq_long",self.struct_seq_long),("struct_seq_longlong",self.struct_seq_longlong),("struct_seq_ulonglong",self.struct_seq_ulonglong)] struct_seq = structseq_property(id_="struct_seq", structdef=StructSeqVars, defvalue=[], configurationkind=("configure",), mode="readwrite" )
class AVS4000_base(CF__POA.Device, FrontendTunerDevice, digital_tuner_delegation, rfinfo_delegation, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): print("--> AVS4000_base.__init__()") FrontendTunerDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams) ThreadedComponent.__init__(self) self.listeners = {} # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 devices. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this device self.port_RFInfo_in = frontend.InRFInfoPort("RFInfo_in", self) self.port_RFInfo_in._portLog = self._baseLog.getChildLogger( 'RFInfo_in', 'ports') self.port_DigitalTuner_in = frontend.InDigitalTunerPort( "DigitalTuner_in", self) self.port_DigitalTuner_in._portLog = self._baseLog.getChildLogger( 'DigitalTuner_in', 'ports') self.port_dataShort_out = bulkio.OutShortPort("dataShort_out") self.port_dataShort_out._portLog = self._baseLog.getChildLogger( 'dataShort_out', 'ports') self.device_kind = "FRONTEND::TUNER" self.device_model = "AVS-4000" self.frontend_listener_allocation = frontend.fe_types.frontend_listener_allocation( ) self.frontend_tuner_allocation = frontend.fe_types.frontend_tuner_allocation( ) print("<-- AVS4000_Base.__init__()") def start(self): self._baseLog.info("--> start()") FrontendTunerDevice.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) self._baseLog.info("<-- start()") def stop(self): self._baseLog.info("--> stop()") FrontendTunerDevice.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): self._baseLog.info("<-- stop()") raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") self._baseLog.info("<-- stop()") def releaseObject(self): self._baseLog.info("--> releaseObject()") try: self.stop() except Exception: self._baseLog.exception("Error stopping") FrontendTunerDevice.releaseObject(self) self._baseLog.info("<-- releaseObject()") ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. port_RFInfo_in = providesport(name="RFInfo_in", repid="IDL:FRONTEND/RFInfo:1.0", type_="data") port_DigitalTuner_in = providesport(name="DigitalTuner_in", repid="IDL:FRONTEND/DigitalTuner:1.0", type_="control") port_dataShort_out = usesport( name="dataShort_out", repid="IDL:BULKIO/dataShort:1.0", type_="data", description="""This port delivers complex 16 bit I/Q data """) ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. class frontend_tuner_status_struct_struct( frontend.default_frontend_tuner_status_struct_struct): complex = simple_property(id_="FRONTEND::tuner_status::complex", name="complex", type_="boolean") decimation = simple_property(id_="FRONTEND::tuner_status::decimation", name="decimation", type_="long") gain = simple_property(id_="FRONTEND::tuner_status::gain", name="gain", type_="double") tuner_number = simple_property( id_="FRONTEND::tuner_status::tuner_number", name="tuner_number", type_="short") def __init__(self, allocation_id_csv="", bandwidth=0.0, center_frequency=0.0, complex=False, decimation=0, enabled=False, gain=0.0, group_id="", rf_flow_id="", sample_rate=0.0, tuner_number=0, tuner_type=""): frontend.default_frontend_tuner_status_struct_struct.__init__( self, allocation_id_csv=allocation_id_csv, bandwidth=bandwidth, center_frequency=center_frequency, enabled=enabled, group_id=group_id, rf_flow_id=rf_flow_id, sample_rate=sample_rate, tuner_type=tuner_type) self.complex = complex self.decimation = decimation self.gain = gain self.tuner_number = tuner_number def __str__(self): """Return a string representation of this structure""" d = {} d["allocation_id_csv"] = self.allocation_id_csv d["bandwidth"] = self.bandwidth d["center_frequency"] = self.center_frequency d["complex"] = self.complex d["decimation"] = self.decimation d["enabled"] = self.enabled d["gain"] = self.gain d["group_id"] = self.group_id d["rf_flow_id"] = self.rf_flow_id d["sample_rate"] = self.sample_rate d["tuner_number"] = self.tuner_number d["tuner_type"] = self.tuner_type return str(d) @classmethod def getId(cls): return "FRONTEND::tuner_status_struct" @classmethod def isStruct(cls): return True def getMembers(self): return frontend.default_frontend_tuner_status_struct_struct.getMembers( self) + [("complex", self.complex), ("decimation", self.decimation), ("gain", self.gain), ("tuner_number", self.tuner_number)] class avs4000_output_configuration___struct(object): tuner_number = simple_property( id_="avs4000_output_configuration::tuner_number", name="tuner_number", type_="long", defvalue=0) output_format = simple_property( id_="avs4000_output_configuration::output_format", name="output_format", type_="string", defvalue="COMPLEX_Format") output_source = simple_property( id_="avs4000_output_configuration::output_source", name="output_source", type_="string", defvalue="TCP_Source") def __init__(self, tuner_number=0, output_format="COMPLEX_Format", output_source="TCP_Source"): print("--> avs4000_output_configuration___struct.__init__()") self.tuner_number = tuner_number self.output_format = output_format self.output_source = output_source print("<-- avs4000_output_configuration___struct.__init__()") def __str__(self): """Return a string representation of this structure""" d = {} d["tuner_number"] = self.tuner_number d["output_format"] = self.output_format d["output_source"] = self.output_source return str(d) @classmethod def getId(cls): return "avs4000_output_configuration::" @classmethod def isStruct(cls): return True def getMembers(self): print("--> avs4000_output_configuration___struct.get_Members()") print(" {}".format(self)) print("<-- avs4000_output_configuration___struct.get_Members()") return [("tuner_number", self.tuner_number), ("output_format", self.output_format), ("output_source", self.output_source)] avs4000_output_configuration = structseq_property( id_="avs4000_output_configuration", structdef=avs4000_output_configuration___struct, defvalue=[ avs4000_output_configuration___struct( tuner_number=0, output_format="VITA49_Format", output_source="TCP_Source") ], configurationkind=("property", ), mode="readwrite") # Rebind tuner status property with custom struct definition frontend_tuner_status = FrontendTunerDevice.frontend_tuner_status.rebind() frontend_tuner_status.structdef = frontend_tuner_status_struct_struct def frontendTunerStatusChanged(self, oldValue, newValue): self._baseLog.info("--> frontendTunerStatusChanged()") self._baseLog.info("<-- frontendTunerStatusChanged()") pass def getTunerStatus(self, allocation_id): self._baseLog.info("--> getTunerStatus()") tuner_id = self.getTunerMapping(allocation_id) if tuner_id < 0: self._baseLog.info("<-- getTunerStatus()") raise FRONTEND.FrontendException( ("ERROR: ID: " + str(allocation_id) + " IS NOT ASSOCIATED WITH ANY TUNER!")) _props = self.query([ CF.DataType(id='FRONTEND::tuner_status', value=_any.to_any(None)) ]) self._baseLog.info("<-- getTunerStatus()") return _props[0].value._v[tuner_id]._v def assignListener(self, listen_alloc_id, allocation_id): # find control allocation_id existing_alloc_id = allocation_id if self.listeners.has_key(existing_alloc_id): existing_alloc_id = self.listeners[existing_alloc_id] self.listeners[listen_alloc_id] = existing_alloc_id def removeListener(self, listen_alloc_id): if self.listeners.has_key(listen_alloc_id): del self.listeners[listen_alloc_id] def removeAllocationIdRouting(self, tuner_id): pass
class multiout_attachable_base(CF__POA.Resource, Resource, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component self.port_dataSDDS_in = bulkio.InSDDSPort("dataSDDS_in") self.port_dataVITA49_in = bulkio.InVITA49Port("dataVITA49_in") self.port_dataFloat_in = bulkio.InFloatPort( "dataFloat_in", maxsize=self.DEFAULT_QUEUE_SIZE) self.port_dataSDDS_out = bulkio.OutSDDSPort("dataSDDS_out") self.port_dataVITA49_out = bulkio.OutVITA49Port("dataVITA49_out") self.addPropertyChangeListener('connectionTable', self.updated_connectionTable) def start(self): Resource.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def updated_connectionTable(self, id, oldval, newval): self.port_dataSDDS_out.updateConnectionFilter(newval) self.port_dataVITA49_out.updateConnectionFilter(newval) def stop(self): if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Resource.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. port_dataSDDS_in = providesport(name="dataSDDS_in", repid="IDL:BULKIO/dataSDDS:1.0", type_="control") port_dataVITA49_in = providesport(name="dataVITA49_in", repid="IDL:BULKIO/dataVITA49:1.0", type_="control") port_dataFloat_in = providesport(name="dataFloat_in", repid="IDL:BULKIO/dataFloat:1.0", type_="control") port_dataSDDS_out = usesport(name="dataSDDS_out", repid="IDL:BULKIO/dataSDDS:1.0", type_="control") port_dataVITA49_out = usesport(name="dataVITA49_out", repid="IDL:BULKIO/dataVITA49:1.0", type_="control") ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. packets_ingested = simple_property(id_="packets_ingested", name="packets_ingested", type_="ushort", defvalue=0, mode="readwrite", action="external", kinds=("configure", )) class CallbackStats(object): num_sdds_attaches = simple_property(id_="num_sdds_attaches", type_="ushort") num_sdds_detaches = simple_property(id_="num_sdds_detaches", type_="ushort") num_vita49_attaches = simple_property(id_="num_vita49_attaches", type_="ushort") num_vita49_detaches = simple_property(id_="num_vita49_detaches", type_="ushort") num_new_sri_callbacks = simple_property(id_="num_new_sri_callbacks", type_="ushort") num_sri_change_callbacks = simple_property( id_="num_sri_change_callbacks", type_="ushort") def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["num_sdds_attaches"] = self.num_sdds_attaches d["num_sdds_detaches"] = self.num_sdds_detaches d["num_vita49_attaches"] = self.num_vita49_attaches d["num_vita49_detaches"] = self.num_vita49_detaches d["num_new_sri_callbacks"] = self.num_new_sri_callbacks d["num_sri_change_callbacks"] = self.num_sri_change_callbacks return str(d) def getId(self): return "callback_stats" def isStruct(self): return True def getMembers(self): return [("num_sdds_attaches", self.num_sdds_attaches), ("num_sdds_detaches", self.num_sdds_detaches), ("num_vita49_attaches", self.num_vita49_attaches), ("num_vita49_detaches", self.num_vita49_detaches), ("num_new_sri_callbacks", self.num_new_sri_callbacks), ("num_sri_change_callbacks", self.num_sri_change_callbacks) ] callback_stats = struct_property(id_="callback_stats", structdef=CallbackStats, configurationkind=("configure", ), mode="readwrite") connectionTable = structseq_property( id_="connectionTable", structdef=bulkio.connection_descriptor_struct, defvalue=[], configurationkind=("configure", ), mode="readwrite") class SDDSStreamDefinition(object): id = simple_property(id_="sdds::id", name="id", type_="string") multicastAddress = simple_property(id_="sdds::multicastAddress", name="multicastAddress", type_="string", defvalue="0.0.0.0") vlan = simple_property(id_="sdds::vlan", name="vlan", type_="ulong") port = simple_property(id_="sdds::port", name="port", type_="ulong") sampleRate = simple_property(id_="sdds::sampleRate", name="sampleRate", type_="ulong") timeTagValid = simple_property(id_="sdds::timeTagValid", name="timeTagValid", type_="boolean") privateInfo = simple_property(id_="sdds::privateInfo", name="privateInfo", type_="string") def __init__(self, id="", multicastAddress="0.0.0.0", vlan=0, port=0, sampleRate=0, timeTagValid=False, privateInfo=""): self.id = id self.multicastAddress = multicastAddress self.vlan = vlan self.port = port self.sampleRate = sampleRate self.timeTagValid = timeTagValid self.privateInfo = privateInfo def __str__(self): """Return a string representation of this structure""" d = {} d["id"] = self.id d["multicastAddress"] = self.multicastAddress d["vlan"] = self.vlan d["port"] = self.port d["sampleRate"] = self.sampleRate d["timeTagValid"] = self.timeTagValid d["privateInfo"] = self.privateInfo return str(d) def getId(self): return "SDDSStreamDefinition" def isStruct(self): return True def getMembers(self): return [("id", self.id), ("multicastAddress", self.multicastAddress), ("vlan", self.vlan), ("port", self.port), ("sampleRate", self.sampleRate), ("timeTagValid", self.timeTagValid), ("privateInfo", self.privateInfo)] SDDSStreamDefinitions = structseq_property( id_="SDDSStreamDefinitions", structdef=SDDSStreamDefinition, defvalue=[], configurationkind=("configure", ), mode="readwrite") class VITA49StreamDefinition(object): id = simple_property(id_="vita49::id", name="id", type_="string") ip_address = simple_property(id_="vita49::ip_address", name="ip_address", type_="string", defvalue="0.0.0.0") vlan = simple_property(id_="vita49::vlan", name="vlan", type_="ulong") port = simple_property(id_="vita49::port", name="port", type_="ulong") valid_data_format = simple_property(id_="vita49::valid_data_format", name="valid_data_format", type_="boolean") packing_method_processing_efficient = simple_property( id_="vita49::packing_method_processing_efficient", name="packing_method_processing_efficient", type_="boolean") repeating = simple_property(id_="vita49::repeating", name="repeating", type_="boolean") event_tag_size = simple_property(id_="vita49::event_tag_size", name="event_tag_size", type_="long") channel_tag_size = simple_property(id_="vita49::channel_tag_size", name="channel_tag_size", type_="long") item_packing_field_size = simple_property( id_="vita49::item_packing_field_size", name="item_packing_field_size", type_="long") data_item_size = simple_property(id_="vita49::data_item_size", name="data_item_size", type_="long") repeat_count = simple_property(id_="vita49::repeat_count", name="repeat_count", type_="long") vector_size = simple_property(id_="vita49::vector_size", name="vector_size", type_="long") def __init__(self, id="", ip_address="0.0.0.0", vlan=0, port=0, valid_data_format=False, packing_method_processing_efficient=False, repeating=False, event_tag_size=0, channel_tag_size=0, item_packing_field_size=0, data_item_size=0, repeat_count=0, vector_size=0): self.id = id self.ip_address = ip_address self.vlan = vlan self.port = port self.valid_data_format = valid_data_format self.packing_method_processing_efficient = packing_method_processing_efficient self.repeating = repeating self.event_tag_size = event_tag_size self.channel_tag_size = channel_tag_size self.item_packing_field_size = item_packing_field_size self.data_item_size = data_item_size self.repeat_count = repeat_count self.vector_size = vector_size def __str__(self): """Return a string representation of this structure""" d = {} d["id"] = self.id d["ip_address"] = self.ip_address d["vlan"] = self.vlan d["port"] = self.port d["valid_data_format"] = self.valid_data_format d["packing_method_processing_efficient"] = self.packing_method_processing_efficient d["repeating"] = self.repeating d["event_tag_size"] = self.event_tag_size d["channel_tag_size"] = self.channel_tag_size d["item_packing_field_size"] = self.item_packing_field_size d["data_item_size"] = self.data_item_size d["repeat_count"] = self.repeat_count d["vector_size"] = self.vector_size return str(d) def getId(self): return "VITA49StreamDefinition" def isStruct(self): return True def getMembers(self): return [("id", self.id), ("ip_address", self.ip_address), ("vlan", self.vlan), ("port", self.port), ("valid_data_format", self.valid_data_format), ("packing_method_processing_efficient", self.packing_method_processing_efficient), ("repeating", self.repeating), ("event_tag_size", self.event_tag_size), ("channel_tag_size", self.channel_tag_size), ("item_packing_field_size", self.item_packing_field_size), ("data_item_size", self.data_item_size), ("repeat_count", self.repeat_count), ("vector_size", self.vector_size)] VITA49StreamDefinitions = structseq_property( id_="VITA49StreamDefinitions", structdef=VITA49StreamDefinition, defvalue=[], configurationkind=("configure", ), mode="readwrite") class SddsAttachment(object): streamId = simple_property(id_="sdds::streamId", name="streamId", type_="string") attachId = simple_property(id_="sdds::attachId", name="attachId", type_="string") port = simple_property(id_="sdds::rec_port", name="port", type_="ulong") def __init__(self, streamId="", attachId="", port=0): self.streamId = streamId self.attachId = attachId self.port = port def __str__(self): """Return a string representation of this structure""" d = {} d["streamId"] = self.streamId d["attachId"] = self.attachId d["port"] = self.port return str(d) def getId(self): return "sdds_attachment" def isStruct(self): return True def getMembers(self): return [("streamId", self.streamId), ("attachId", self.attachId), ("port", self.port)] received_sdds_attachments = structseq_property( id_="received_sdds_attachments", structdef=SddsAttachment, defvalue=[], configurationkind=("configure", ), mode="readwrite") class Vita49Attachment(object): streamId = simple_property(id_="vita49::streamId", name="streamId", type_="string") attachId = simple_property(id_="vita49::attachId", name="attachId", type_="string") port = simple_property(id_="vita49::rec_port", name="port", type_="ulong") def __init__(self, streamId="", attachId="", port=0): self.streamId = streamId self.attachId = attachId self.port = port def __str__(self): """Return a string representation of this structure""" d = {} d["streamId"] = self.streamId d["attachId"] = self.attachId d["port"] = self.port return str(d) def getId(self): return "vita49_attachment" def isStruct(self): return True def getMembers(self): return [("streamId", self.streamId), ("attachId", self.attachId), ("port", self.port)] received_vita49_attachments = structseq_property( id_="received_vita49_attachments", structdef=Vita49Attachment, defvalue=[], configurationkind=("configure", ), mode="readwrite")
class TestStructDep(CF__POA.Resource, Resource): """Python component for testing properties""" prop1 = simple_property(id_="DCE:b8f43ac8-26b5-40b3-9102-d127b84f9e4b", name="string_prop", type_="string", action="external", kinds=("configure", )) prop2 = simpleseq_property( id_="DCE:10b3364d-f035-4639-8e7f-02ac4706f5c7[]", name="stringseq_prop", type_="string", action="external", kinds=("configure", )) prop3 = simple_property(id_="float_capacity", name="float_capacity", type_="float", action="external", kinds=("configure", ), defvalue=0.123) prop4 = simple_property(id_="test_double", name="test_double", type_="double", action="external", kinds=("configure", ), defvalue=1.234) class SomeStruct(object): field1 = simple_property(id_="long_capacity", type_="long", defvalue=100) field2 = simple_property(id_="another_float_capacity", type_="float", defvalue=1.234) struct = struct_property(id_="struct_test", name="struct_test", structdef=SomeStruct) class MulticastAddress(object): ip_address = simple_property(id_="ip_address", type_="string") port = simple_property(id_="port", type_="ushort") def __init__(self, ip_address="", port=0): self.ip_address = ip_address self.port = port multicasts = structseq_property( id_="DCE:897a5489-f680-46a8-a698-e36fd8bbae80[]", name="multicasts", structdef=MulticastAddress, defvalue=[ MulticastAddress("127.0.0.1", 6800), MulticastAddress("127.0.0.1", 42000) ]) magicword = simple_property( id_="magicword", name="magicword", type_="string", action="external", kinds=("configure", ), defvalue="nada - better change me when you create me") def __init__(self, identifier, execparams): Resource.__init__(self, identifier, execparams)
class comp_prop_special_char_base(CF__POA.Resource, Component, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Component.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component def start(self): Component.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): Component.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Component.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. class MyBase(object): my_element = simple_property(id_="my:element", type_="string", defvalue="foo") my_stuff = simple_property(id_="my.stuff", type_="string", defvalue="bar") def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["my_element"] = self.my_element d["my_stuff"] = self.my_stuff return str(d) @classmethod def getId(cls): return "my:base" @classmethod def isStruct(cls): return True def getMembers(self): return [("my_element", self.my_element), ("my_stuff", self.my_stuff)] my_base = struct_property(id_="my:base", structdef=MyBase, configurationkind=("property", ), mode="readwrite") class MyStr(object): my_seq_my_str_my_prop = simple_property(id_="my_seq:my_str:my_prop", type_="string", defvalue="qwe") def __init__(self, my_seq_my_str_my_prop="qwe"): self.my_seq_my_str_my_prop = my_seq_my_str_my_prop def __str__(self): """Return a string representation of this structure""" d = {} d["my_seq_my_str_my_prop"] = self.my_seq_my_str_my_prop return str(d) @classmethod def getId(cls): return "my:str" @classmethod def isStruct(cls): return True def getMembers(self): return [("my_seq_my_str_my_prop", self.my_seq_my_str_my_prop)] my_seq = structseq_property(id_="my:seq", structdef=MyStr, defvalue=[], configurationkind=("property", ), mode="readwrite")
d["tuner_number"] = self.tuner_number return str(d) def getId(self): return "frontend_tuner_status_struct" def isStruct(self): return True def getMembers(self): return [("tuner_type",self.tuner_type),("allocation_id_csv",self.allocation_id_csv),("center_frequency",self.center_frequency),("bandwidth",self.bandwidth),("sample_rate",self.sample_rate),("group_id",self.group_id),("rf_flow_id",self.rf_flow_id),("enabled",self.enabled),("bandwidth_tolerance",self.bandwidth_tolerance),("sample_rate_tolerance",self.sample_rate_tolerance),("complex",self.complex),("gain",self.gain),("agc",self.agc),("valid",self.valid),("available_frequency",self.available_frequency),("available_bandwidth",self.available_bandwidth),("available_gain",self.available_gain),("available_sample_rate",self.available_sample_rate),("reference_source",self.reference_source),("output_format",self.output_format),("output_multicast",self.output_multicast),("output_vlan",self.output_vlan),("output_port",self.output_port),("decimation",self.decimation),("tuner_number",self.tuner_number)] frontend_tuner_status = structseq_property(id_="FRONTEND::tuner_status", name="frontend_tuner_status", structdef=FrontendTunerStatusStruct, defvalue=[], configurationkind=("configure",), mode="readonly", description="""Frontend Interfaces v2.0 status structure. One element for every frontend resource (receiver, transmitter) configured on this hardware""" ) class SimChannelStruct(object): tuner_type = simple_property(id_="sim::tuner_type", name="tuner_type", type_="string", defvalue="RX_DIGITIZER", ) freq_min = simple_property(id_="sim::freq_min", name="freq_min", type_="double", ) freq_max = simple_property(id_="sim::freq_max", name="freq_max",
class writeonly_py_base(CF__POA.Device, Device, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): Device.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 devices. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this device def start(self): Device.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): Device.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Device.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. device_kind = simple_property(id_="DCE:cdc5ee18-7ceb-4ae6-bf4c-31f983179b4d", name="device_kind", type_="string", mode="readonly", action="eq", kinds=("allocation",), description="""This specifies the device kind""") device_model = simple_property(id_="DCE:0f99b2e4-9903-4631-9846-ff349d18ecfb", name="device_model", type_="string", mode="readonly", action="eq", kinds=("allocation",), description=""" This specifies the specific device""") foo = simple_property(id_="foo", type_="string", defvalue="something", mode="writeonly", action="external", kinds=("allocation",)) foo_seq = simpleseq_property(id_="foo_seq", type_="string", defvalue=["abc" ], mode="writeonly", action="external", kinds=("allocation",)) class FooStruct(object): abc = simple_property( id_="abc", type_="string", defvalue="def" ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k,v in kw.items(): setattr(self,k,v) def __str__(self): """Return a string representation of this structure""" d = {} d["abc"] = self.abc return str(d) @classmethod def getId(cls): return "foo_struct" @classmethod def isStruct(cls): return True def getMembers(self): return [("abc",self.abc)] foo_struct = struct_property(id_="foo_struct", structdef=FooStruct, configurationkind=("allocation",), mode="writeonly") class Ghi(object): jkl = simple_property( id_="jkl", type_="string") def __init__(self, jkl=""): self.jkl = jkl def __str__(self): """Return a string representation of this structure""" d = {} d["jkl"] = self.jkl return str(d) @classmethod def getId(cls): return "ghi" @classmethod def isStruct(cls): return True def getMembers(self): return [("jkl",self.jkl)] foo_struct_seq = structseq_property(id_="foo_struct_seq", structdef=Ghi, defvalue=[Ghi(jkl="mno")], configurationkind=("allocation",), mode="writeonly")
class default_kinds_base(CF__POA.Resource, Resource, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component def start(self): Resource.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Resource.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. long_prop = simple_property(id_="long_prop", type_="long", defvalue=0, mode="readwrite", action="external", kinds=("configure", )) floatseq_prop = simpleseq_property(id_="floatseq_prop", type_="float", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) class StructProp(object): string_field = simple_property(id_="struct_prop::string_field", name="string_field", type_="string") def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["string_field"] = self.string_field return str(d) def getId(self): return "struct_prop" def isStruct(self): return True def getMembers(self): return [("string_field", self.string_field)] struct_prop = struct_property(id_="struct_prop", structdef=StructProp, configurationkind=("configure", ), mode="readwrite") class Endpoint(object): address = simple_property(id_="endpoints::endpoint::address", name="address", type_="string", defvalue="") port = simple_property(id_="endpoints::endpoint::port", name="port", type_="short", defvalue=0) def __init__(self, address="", port=0): self.address = address self.port = port def __str__(self): """Return a string representation of this structure""" d = {} d["address"] = self.address d["port"] = self.port return str(d) def getId(self): return "endpoints::endpoint" def isStruct(self): return True def getMembers(self): return [("address", self.address), ("port", self.port)] endpoints = structseq_property(id_="endpoints", structdef=Endpoint, defvalue=[], configurationkind=("configure", ), mode="readwrite")
class PropertyComponent_base(CF__POA.Resource, Resource): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.process_thread = None # self.auto_start is deprecated and is only kept for API compatability # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False def initialize(self): Resource.initialize(self) # Instantiate the default implementations for all ports on this component self.port_propEvent = PropertyEventSupplier(self) def start(self): Resource.start(self) if self.process_thread == None: self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE) self.process_thread.start() def process(self): """The process method should process a single "chunk" of data and then return. This method will be called from the processing thread again, and again, and again until it returns FINISH or stop() is called on the component. If no work is performed, then return NOOP""" raise NotImplementedError def stop(self): # Technically not thread-safe but close enough for now process_thread = self.process_thread self.process_thread = None if process_thread != None: process_thread.stop() process_thread.join(self.TIMEOUT) if process_thread.isAlive(): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Resource.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. def compareSRI(self, a, b): if a.hversion != b.hversion: return False if a.xstart != b.xstart: return False if a.xdelta != b.xdelta: return False if a.xunits != b.xunits: return False if a.subsize != b.subsize: return False if a.ystart != b.ystart: return False if a.ydelta != b.ydelta: return False if a.yunits != b.yunits: return False if a.mode != b.mode: return False if a.streamID != b.streamID: return False if a.blocking != b.blocking: return False if len(a.keywords) != len(b.keywords): return False for keyA, keyB in zip(a.keywords, b.keywords): if keyA.value._t != keyB.value._t: return False if keyA.value._v != keyB.value._v: return False return True port_propEvent = usesport( name="propEvent", repid="IDL:omg.org/CosEventChannelAdmin/EventChannel:1.0", type_="responses", ) ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. simplePropStr = simple_property(id_="simplePropStr", type_="string", defvalue="Hello", mode="readwrite", action="external", kinds=("configure", "event")) simplePropBoolean = simple_property(id_="simplePropBoolean", type_="boolean", defvalue=True, mode="readwrite", action="external", kinds=("configure", )) simplePropUlong = simple_property(id_="simplePropUlong", type_="ulong", defvalue=1, mode="readwrite", action="external", kinds=("configure", )) simplePropObjRef = simple_property(id_="simplePropObjRef", type_="objref", mode="readwrite", action="external", kinds=("configure", )) simplePropShort = simple_property(id_="simplePropShort", type_="short", mode="readwrite", action="external", kinds=("configure", )) simplePropFloat = simple_property(id_="simplePropFloat", type_="float", mode="readwrite", action="external", kinds=("configure", )) simplePropOctet = simple_property(id_="simplePropOctet", type_="octet", mode="readwrite", action="external", kinds=("configure", )) simplePropChar = simple_property(id_="simplePropChar", type_="char", mode="readwrite", action="external", kinds=("configure", )) simplePropUShort = simple_property(id_="simplePropUShort", type_="ushort", mode="readwrite", action="external", kinds=("configure", )) simplePropDouble = simple_property(id_="simplePropDouble", type_="double", mode="readwrite", action="external", kinds=("configure", )) simplePropLong = simple_property(id_="simplePropLong", type_="long", mode="readwrite", action="external", kinds=("configure", )) simplePropLongLong = simple_property(id_="simplePropLongLong", type_="longlong", mode="readwrite", action="external", kinds=("configure", )) simplePropUlonglong = simple_property(id_="simplePropUlonglong", type_="ulonglong", mode="readwrite", action="external", kinds=("configure", )) simpleEnum = simple_property(id_="simpleEnum", type_="string", defvalue="hello", mode="readwrite", action="external", kinds=("configure", )) simpleReadOnly = simple_property(id_="simpleReadOnly", type_="string", defvalue="READ ONLY VALUE", mode="readonly", action="external", kinds=("configure", )) seqPropStr = simpleseq_property(id_="seqPropStr", type_="string", defvalue=("test", "test1", "test3"), mode="readwrite", action="external", kinds=("configure", )) seqPropBoolean = simpleseq_property(id_="seqPropBoolean", type_="boolean", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropULong = simpleseq_property(id_="seqPropULong", type_="ulong", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropObjRef = simpleseq_property(id_="seqPropObjRef", type_="objref", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropShort = simpleseq_property(id_="seqPropShort", type_="short", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropFloat = simpleseq_property(id_="seqPropFloat", type_="float", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropOctet = simpleseq_property(id_="seqPropOctet", type_="octet", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropChar = simpleseq_property(id_="seqPropChar", type_="char", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropUShort = simpleseq_property(id_="seqPropUShort", type_="ushort", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropDouble = simpleseq_property(id_="seqPropDouble", type_="double", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropLong = simpleseq_property(id_="seqPropLong", type_="long", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropLongLong = simpleseq_property(id_="seqPropLongLong", type_="longlong", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) seqPropulonglong = simpleseq_property(id_="seqPropulonglong", type_="ulonglong", defvalue=None, mode="readwrite", action="external", kinds=("configure", )) class StructProp(object): structSimpleStr = simple_property( id_="structSimpleStr", type_="string", ) structSimpleBoolean = simple_property( id_="structSimpleBoolean", type_="boolean", ) structSimpleulong = simple_property( id_="structSimpleulong", type_="ulong", ) structSimpleObjRef = simple_property( id_="structSimpleObjRef", type_="objref", ) structSimpleShort = simple_property( id_="structSimpleShort", type_="short", ) structSimpleFloat = simple_property( id_="structSimpleFloat", type_="float", ) structSimpleOctet = simple_property( id_="structSimpleOctet", type_="octet", ) structSimpleChar = simple_property( id_="structSimpleChar", type_="char", ) structSimpleushort = simple_property( id_="structSimpleushort", type_="ushort", ) structSimpledouble = simple_property( id_="structSimpledouble", type_="double", ) structSimplelong = simple_property( id_="structSimplelong", type_="long", ) structSimplelonglong = simple_property( id_="structSimplelonglong", type_="longlong", ) structSimpleulonglong = simple_property( id_="structSimpleulonglong", type_="ulonglong", ) structSimpleEnum = simple_property( id_="structSimpleEnum", type_="double", defvalue=1.5, ) def __init__(self): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) def __str__(self): """Return a string representation of this structure""" d = {} d["structSimpleStr"] = self.structSimpleStr d["structSimpleBoolean"] = self.structSimpleBoolean d["structSimpleulong"] = self.structSimpleulong d["structSimpleObjRef"] = self.structSimpleObjRef d["structSimpleShort"] = self.structSimpleShort d["structSimpleFloat"] = self.structSimpleFloat d["structSimpleOctet"] = self.structSimpleOctet d["structSimpleChar"] = self.structSimpleChar d["structSimpleushort"] = self.structSimpleushort d["structSimpledouble"] = self.structSimpledouble d["structSimplelong"] = self.structSimplelong d["structSimplelonglong"] = self.structSimplelonglong d["structSimpleulonglong"] = self.structSimpleulonglong d["structSimpleEnum"] = self.structSimpleEnum return str(d) def getId(self): return "structProp" def isStruct(self): return True def getMembers(self): return [("structSimpleStr", self.structSimpleStr), ("structSimpleBoolean", self.structSimpleBoolean), ("structSimpleulong", self.structSimpleulong), ("structSimpleObjRef", self.structSimpleObjRef), ("structSimpleShort", self.structSimpleShort), ("structSimpleFloat", self.structSimpleFloat), ("structSimpleOctet", self.structSimpleOctet), ("structSimpleChar", self.structSimpleChar), ("structSimpleushort", self.structSimpleushort), ("structSimpledouble", self.structSimpledouble), ("structSimplelong", self.structSimplelong), ("structSimplelonglong", self.structSimplelonglong), ("structSimpleulonglong", self.structSimpleulonglong), ("structSimpleEnum", self.structSimpleEnum)] structProp = struct_property(id_="structProp", structdef=StructProp, configurationkind=("configure", ), mode="readwrite") class StructSeq(object): structSeqSimple = simple_property( id_="structSeqSimple", type_="string", ) structSeqSimpleBoolean = simple_property( id_="structSeqSimpleBoolean", type_="boolean", ) structSeqSimpleUlong = simple_property( id_="structSeqSimpleUlong", type_="ulong", ) structSeqSimpleObjecRef = simple_property( id_="structSeqSimpleObjecRef", type_="objref", ) structSeqSimpleShort = simple_property( id_="structSeqSimpleShort", type_="short", ) structSeqFloat = simple_property( id_="structSeqFloat", type_="float", ) structSeqSimpleOctet = simple_property( id_="structSeqSimpleOctet", type_="octet", ) structSeqSimpleChar = simple_property( id_="structSeqSimpleChar", type_="char", ) structSeqSimpleushort = simple_property( id_="structSeqSimpleushort", type_="ushort", ) structSeqSimpleDouble = simple_property( id_="structSeqSimpleDouble", type_="double", ) structSeqSimpleLong = simple_property( id_="structSeqSimpleLong", type_="long", ) structSeqSimpleLongLong = simple_property( id_="structSeqSimpleLongLong", type_="longlong", ) structSeqSimpleULongLong = simple_property( id_="structSeqSimpleULongLong", type_="ulonglong", ) structSeqSimpleEnum = simple_property( id_="structSeqSimpleEnum", type_="string", defvalue="3", ) def __init__(self, structSeqSimple="", structSeqSimpleBoolean=False, structSeqSimpleUlong=0, structSeqSimpleObjecRef="", structSeqSimpleShort=0, structSeqFloat=0, structSeqSimpleOctet=0, structSeqSimpleChar="", structSeqSimpleushort=0, structSeqSimpleDouble=0, structSeqSimpleLong=0, structSeqSimpleLongLong=0, structSeqSimpleULongLong=0, structSeqSimpleEnum=""): self.structSeqSimple = structSeqSimple self.structSeqSimpleBoolean = structSeqSimpleBoolean self.structSeqSimpleUlong = structSeqSimpleUlong self.structSeqSimpleObjecRef = structSeqSimpleObjecRef self.structSeqSimpleShort = structSeqSimpleShort self.structSeqFloat = structSeqFloat self.structSeqSimpleOctet = structSeqSimpleOctet self.structSeqSimpleChar = structSeqSimpleChar self.structSeqSimpleushort = structSeqSimpleushort self.structSeqSimpleDouble = structSeqSimpleDouble self.structSeqSimpleLong = structSeqSimpleLong self.structSeqSimpleLongLong = structSeqSimpleLongLong self.structSeqSimpleULongLong = structSeqSimpleULongLong self.structSeqSimpleEnum = structSeqSimpleEnum def __str__(self): """Return a string representation of this structure""" d = {} d["structSeqSimple"] = self.structSeqSimple d["structSeqSimpleBoolean"] = self.structSeqSimpleBoolean d["structSeqSimpleUlong"] = self.structSeqSimpleUlong d["structSeqSimpleObjecRef"] = self.structSeqSimpleObjecRef d["structSeqSimpleShort"] = self.structSeqSimpleShort d["structSeqFloat"] = self.structSeqFloat d["structSeqSimpleOctet"] = self.structSeqSimpleOctet d["structSeqSimpleChar"] = self.structSeqSimpleChar d["structSeqSimpleushort"] = self.structSeqSimpleushort d["structSeqSimpleDouble"] = self.structSeqSimpleDouble d["structSeqSimpleLong"] = self.structSeqSimpleLong d["structSeqSimpleLongLong"] = self.structSeqSimpleLongLong d["structSeqSimpleULongLong"] = self.structSeqSimpleULongLong d["structSeqSimpleEnum"] = self.structSeqSimpleEnum return str(d) def getId(self): return "structSeqStruct" def isStruct(self): return True def getMembers(self): return [("structSeqSimple", self.structSeqSimple), ("structSeqSimpleBoolean", self.structSeqSimpleBoolean), ("structSeqSimpleUlong", self.structSeqSimpleUlong), ("structSeqSimpleObjecRef", self.structSeqSimpleObjecRef), ("structSeqSimpleShort", self.structSeqSimpleShort), ("structSeqFloat", self.structSeqFloat), ("structSeqSimpleOctet", self.structSeqSimpleOctet), ("structSeqSimpleChar", self.structSeqSimpleChar), ("structSeqSimpleushort", self.structSeqSimpleushort), ("structSeqSimpleDouble", self.structSeqSimpleDouble), ("structSeqSimpleLong", self.structSeqSimpleLong), ("structSeqSimpleLongLong", self.structSeqSimpleLongLong), ("structSeqSimpleULongLong", self.structSeqSimpleULongLong), ("structSeqSimpleEnum", self.structSeqSimpleEnum)] structSeq = structseq_property(id_="structSeq", structdef=StructSeq, defvalue=[], configurationkind=("configure", ), mode="readwrite")
mode="readonly", action="eq", kinds=("allocation", "configure"), description=""" This specifies the specific device""") frontend_video_allocation = struct_property( id_="FRONTEND::video_allocation", name="frontend_video_allocation", structdef=frontend_video_allocation, configurationkind=("allocation", ), mode="readwrite", description="""Frontend Interfaces v2.0 main allocation structure""") frontend_listener_allocation = struct_property( id_="FRONTEND::listener_allocation", name="frontend_listener_allocation", structdef=frontend_listener_allocation, configurationkind=("allocation", ), mode="readwrite", description= """Allocates a listener (subscriber) based off a previous allocation """ ) frontend_video_status = structseq_property( id_="FRONTEND::video_status", name="frontend_video_status", structdef=default_frontend_video_status_struct_struct, defvalue=[], configurationkind=("configure", ), mode="readonly", description= """Frontend Interfaces v2.0 status structure. One element for every frontend resource (receiver, transmitter) configured on this hardware""" )
class TestPythonProps (CF__POA.Resource, Resource): """Python component for testing properties""" prop1 = simple_property(id_="DCE:b8f43ac8-26b5-40b3-9102-d127b84f9e4b", name="string_prop", type_="string", action="external", kinds=("configure",)) prop2 = simpleseq_property(id_="DCE:10b3364d-f035-4639-8e7f-02ac4706f5c7[]", name="stringseq_prop", type_="string", action="external", kinds=("configure",)) prop3 = simple_property(id_="test_float", name="test_float", type_="float", action="external", kinds=("configure",), defvalue=1.234) prop4 = simple_property(id_="test_double", name="test_double", type_="double", action="external", kinds=("configure",), defvalue=1.234) class SomeStruct(object): field1 = simple_property(id_="item1", type_="string", defvalue="value1") field2 = simple_property(id_="item2", type_="long", defvalue=100) field3 = simple_property(id_="item3", type_="double", defvalue=3.14156) field4 = simple_property(id_="item4", type_="float", defvalue=1.234) struct = struct_property(id_="DCE:ffe634c9-096d-425b-86cc-df1cce50612f", name="struct_test", structdef=SomeStruct) class MulticastAddress(object): ip_address = simple_property(id_="ip_address", type_="string") port = simple_property(id_="port", type_="ushort") def __init__(self, ip_address="", port=0): self.ip_address = ip_address self.port = port multicasts = structseq_property(id_="DCE:897a5489-f680-46a8-a698-e36fd8bbae80[]", name="multicasts", structdef=MulticastAddress, defvalue=[MulticastAddress("127.0.0.1", 6800), MulticastAddress("127.0.0.1", 42000)]) def __init__(self, identifier, execparams): Resource.__init__(self, identifier, execparams) def runTest(self, test, props): if test == 0: # Inject values directly into property storage to allow testing of # bad conditions (invalid values) for dt in props: try: self._props[dt.id] = from_any(dt.value) except KeyError: pass return []
class BadReleaseBefore(CF__POA.AggregateExecutableDevice, ExecutableDevice, AggregateDevice): def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams, PROPERTIES) AggregateDevice.__init__(self) self._props["memCapacity"] = 100000000 self._props["BogoMipsCapacity"] = 100000000 self._props["nicCapacity"] = 100.0 self._props["fakeCapacity"] = 3 self._props["execparams"] = " ".join( ["%s %s" % x for x in execparams.items()]) def execute(self, name, options, parameters): retval = ExecutableDevice.execute(self, name, options, parameters) for option in options: if option.id == 'STACK_SIZE': self._props['check_STACK_SIZE'] = option.value._v elif option.id == 'PRIORITY': self._props['check_PRIORITY'] = option.value._v return retval # See BasicChildDevice for an example of manually dealing with allocate/deallocate def allocate_fakeCapacity(self, value): if self._props["fakeCapacity"] < value: return False self._props["fakeCapacity"] = self._props["fakeCapacity"] - value return True def allocate_nicCapacity(self, value): if self._props["nicCapacity"] < value: return False self._props["nicCapacity"] = self._props["nicCapacity"] - value return True def allocate_memCapacity(self, value): if self._props["memCapacity"] < value: return False self._props["memCapacity"] = self._props["memCapacity"] - value return True def allocate_BogoMipsCapacity(self, value): if self._props["BogoMipsCapacity"] < value: return False self._props[ "BogoMipsCapacity"] = self._props["BogoMipsCapacity"] - value return True def deallocate_fakeCapacity(self, value): self._props["fakeCapacity"] = self._props["fakeCapacity"] + value def deallocate_nicCapacity(self, value): self._props["nicCapacity"] = self._props["nicCapacity"] + value def deallocate_memCapacity(self, value): self._props["memCapacity"] = self._props["memCapacity"] + value def deallocate_BogoMipsCapacity(self, value): self._props[ "BogoMipsCapacity"] = self._props["BogoMipsCapacity"] + value def allocate_allocStruct(self, value): if value > self.allocStruct: return False self.allocStruct -= value return True def deallocate_allocStruct(self, value): self.allocStruct += value def updateUsageState(self): # Update usage state if self._props["memCapacity"] == 0 and self._props[ "BogoMipsCapacity"] == 0: self._usageState = CF.Device.BUSY elif self._props["memCapacity"] == 100000000 and self._props[ "BogoMipsCapacity"] == 100000000: self._usageState = CF.Device.IDLE else: self._usageState = CF.Device.ACTIVE def releaseObject(self): a = b ExecutableDevice.releaseObject(self) class SomeStruct(object): field1 = simple_property(id_="item1", type_="string", defvalue="value1") field2 = simple_property(id_="item2", type_="long", defvalue=100) field3 = simple_property(id_="item3", type_="double", defvalue=3.14156) struct = struct_property(id_="DCE:ffe634c9-096d-425b-86cc-df1cce50612f", name="struct_test", structdef=SomeStruct) class AllocStruct(object): long_capacity = simple_property(id_="long_capacity", type_="long", defvalue=100) float_capacity = simple_property(id_="float_capacity", type_="float", defvalue=1.0) def __gt__(self, other): if self.long_capacity <= other.long_capacity: return False if self.float_capacity <= other.float_capacity: return False return True def __iadd__(self, other): self.long_capacity += other.long_capacity self.float_capacity += other.float_capacity return self def __isub__(self, other): self.long_capacity -= other.long_capacity self.float_capacity -= other.float_capacity return self allocStruct = struct_property( id_="DCE:001fad60-b4b3-4ed2-94cb-40e1d956bf4f", name="allocStruct", configurationkind=("configure", "allocation"), structdef=AllocStruct) structseq = structseq_property( id_="DCE:e836f007-5821-4671-b05a-e0ff5147fe86", name="structseq_test", structdef=SomeStruct, defvalue=[])
class TestPythonPropsRange_base(CF__POA.Resource, Resource): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatability # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False def initialize(self): Resource.initialize(self) # Instantiate the default implementations for all ports on this component def start(self): self.threadControlLock.acquire() try: Resource.start(self) if self.process_thread == None: self.process_thread = ProcessThread(target=self.process, pause=self.PAUSE) self.process_thread.start() finally: self.threadControlLock.release() def process(self): """The process method should process a single "chunk" of data and then return. This method will be called from the processing thread again, and again, and again until it returns FINISH or stop() is called on the component. If no work is performed, then return NOOP""" raise NotImplementedError def stop(self): self.threadControlLock.acquire() try: process_thread = self.process_thread self.process_thread = None if process_thread != None: process_thread.stop() process_thread.join(self.TIMEOUT) if process_thread.isAlive(): raise CF.Resource.StopError( CF.CF_NOTSET, "Processing thread did not die") Resource.stop(self) finally: self.threadControlLock.release() def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") self.threadControlLock.acquire() try: Resource.releaseObject(self) finally: self.threadControlLock.release() ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. my_octet_name = simple_property(id_="my_octet", name="my_octet_name", type_="octet", defvalue=1, mode="readwrite", action="external", kinds=("configure", )) my_short_name = simple_property(id_="my_short", name="my_short_name", type_="short", defvalue=2, mode="readwrite", action="external", kinds=("configure", )) my_ushort_name = simple_property(id_="my_ushort", name="my_ushort_name", type_="ushort", defvalue=3, mode="readwrite", action="external", kinds=("configure", )) my_long_name = simple_property(id_="my_long", name="my_long_name", type_="long", defvalue=4, mode="readwrite", action="external", kinds=("configure", )) my_ulong_name = simple_property(id_="my_ulong", name="my_ulong_name", type_="ulong", defvalue=5, mode="readwrite", action="external", kinds=("configure", )) my_longlong_name = simple_property(id_="my_longlong", name="my_longlong_name", type_="longlong", defvalue=6, mode="readwrite", action="external", kinds=("configure", )) my_ulonglong_name = simple_property(id_="my_ulonglong", name="my_ulonglong_name", type_="ulonglong", defvalue=7, mode="readwrite", action="external", kinds=("configure", )) seq_octet_name = simpleseq_property(id_="seq_octet", name="seq_octet_name", type_="octet", defvalue="\x01\x02", mode="readwrite", action="external", kinds=("configure", )) seq_short_name = simpleseq_property(id_="seq_short", name="seq_short_name", type_="short", defvalue=(1, 2), mode="readwrite", action="external", kinds=("configure", )) seq_ushort_name = simpleseq_property(id_="seq_ushort", name="seq_ushort_name", type_="ushort", defvalue=(1, 2), mode="readwrite", action="external", kinds=("configure", )) seq_long_name = simpleseq_property(id_="seq_long", name="seq_long_name", type_="long", defvalue=(1, 2), mode="readwrite", action="external", kinds=("configure", )) seq_ulong_name = simpleseq_property(id_="seq_ulong", name="seq_ulong_name", type_="ulong", defvalue=(1, 2), mode="readwrite", action="external", kinds=("configure", )) seq_longlong_name = simpleseq_property(id_="seq_longlong", name="seq_longlong_name", type_="longlong", defvalue=(1, 2), mode="readwrite", action="external", kinds=("configure", )) seq_ulonglong_name = simpleseq_property(id_="seq_ulonglong", name="seq_ulonglong_name", type_="ulonglong", defvalue=(1, 2), mode="readwrite", action="external", kinds=("configure", )) seq_char_name = simpleseq_property(id_="seq_char", name="seq_char_name", type_="char", defvalue="ab", mode="readwrite", action="external", kinds=("configure", )) class MyStructName(object): struct_octet_name = simple_property( id_="struct_octet", name="struct_octet_name", type_="octet", defvalue=1, ) struct_short_name = simple_property( id_="struct_short", name="struct_short_name", type_="short", defvalue=2, ) struct_ushort_name = simple_property( id_="struct_ushort", name="struct_ushort_name", type_="ushort", defvalue=3, ) struct_long_name = simple_property( id_="struct_long", name="struct_long_name", type_="long", defvalue=4, ) struct_ulong_name = simple_property( id_="struct_ulong", name="struct_ulong_name", type_="ulong", defvalue=5, ) struct_longlong_name = simple_property( id_="struct_longlong", name="struct_longlong_name", type_="longlong", defvalue=6, ) struct_ulonglong_name = simple_property( id_="struct_ulonglong", name="struct_ulonglong_name", type_="ulonglong", defvalue=7, ) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["struct_octet_name"] = self.struct_octet_name d["struct_short_name"] = self.struct_short_name d["struct_ushort_name"] = self.struct_ushort_name d["struct_long_name"] = self.struct_long_name d["struct_ulong_name"] = self.struct_ulong_name d["struct_longlong_name"] = self.struct_longlong_name d["struct_ulonglong_name"] = self.struct_ulonglong_name return str(d) def getId(self): return "my_struct" def isStruct(self): return True def getMembers(self): return [("struct_octet_name", self.struct_octet_name), ("struct_short_name", self.struct_short_name), ("struct_ushort_name", self.struct_ushort_name), ("struct_long_name", self.struct_long_name), ("struct_ulong_name", self.struct_ulong_name), ("struct_longlong_name", self.struct_longlong_name), ("struct_ulonglong_name", self.struct_ulonglong_name)] my_struct_name = struct_property(id_="my_struct", name="my_struct_name", structdef=MyStructName, configurationkind=("configure", ), mode="readwrite") class SsStructName(object): ss_octet_name = simple_property( id_="ss_octet", name="ss_octet_name", type_="octet", ) ss_short_name = simple_property( id_="ss_short", name="ss_short_name", type_="short", ) ss_ushort_name = simple_property( id_="ss_ushort", name="ss_ushort_name", type_="ushort", ) ss_long_name = simple_property( id_="ss_long", name="ss_long_name", type_="long", ) ss_ulong_name = simple_property( id_="ss_ulong", name="ss_ulong_name", type_="ulong", ) ss_longlong_name = simple_property( id_="ss_longlong", name="ss_longlong_name", type_="longlong", ) ss_ulonglong_name = simple_property( id_="ss_ulonglong", name="ss_ulonglong_name", type_="ulonglong", ) def __init__(self, ss_octet_name=0, ss_short_name=0, ss_ushort_name=0, ss_long_name=0, ss_ulong_name=0, ss_longlong_name=0, ss_ulonglong_name=0): self.ss_octet_name = ss_octet_name self.ss_short_name = ss_short_name self.ss_ushort_name = ss_ushort_name self.ss_long_name = ss_long_name self.ss_ulong_name = ss_ulong_name self.ss_longlong_name = ss_longlong_name self.ss_ulonglong_name = ss_ulonglong_name def __str__(self): """Return a string representation of this structure""" d = {} d["ss_octet_name"] = self.ss_octet_name d["ss_short_name"] = self.ss_short_name d["ss_ushort_name"] = self.ss_ushort_name d["ss_long_name"] = self.ss_long_name d["ss_ulong_name"] = self.ss_ulong_name d["ss_longlong_name"] = self.ss_longlong_name d["ss_ulonglong_name"] = self.ss_ulonglong_name return str(d) def getId(self): return "ss_struct" def isStruct(self): return True def getMembers(self): return [("ss_octet_name", self.ss_octet_name), ("ss_short_name", self.ss_short_name), ("ss_ushort_name", self.ss_ushort_name), ("ss_long_name", self.ss_long_name), ("ss_ulong_name", self.ss_ulong_name), ("ss_longlong_name", self.ss_longlong_name), ("ss_ulonglong_name", self.ss_ulonglong_name)] my_structseq_name = structseq_property( id_="my_structseq", name="my_structseq_name", structdef=SsStructName, defvalue=[ SsStructName(0, 1, 2, 3, 4, 5, 6), SsStructName(7, 8, 9, 10, 11, 12, 13) ], configurationkind=("configure", ), mode="readwrite")
class NicExecDevice_base(CF__POA.ExecutableDevice, ExecutableDevice, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams): ExecutableDevice.__init__(self, devmgr, uuid, label, softwareProfile, compositeDevice, execparams) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 devices. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this device def start(self): ExecutableDevice.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): ExecutableDevice.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") ExecutableDevice.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. device_kind = simple_property( id_="DCE:cdc5ee18-7ceb-4ae6-bf4c-31f983179b4d", name="device_kind", type_="string", defvalue="GPP", mode="readonly", action="eq", kinds=("allocation", ), description="""This specifies the device kind""") device_model = simple_property( id_="DCE:0f99b2e4-9903-4631-9846-ff349d18ecfb", name="device_model", type_="string", defvalue="NicExecDevice", mode="readonly", action="eq", kinds=("allocation", ), description=""" This specifies the specific device""") processor_name = simple_property( id_="DCE:9B445600-6C7F-11d4-A226-0050DA314CD6", name="processor_name", type_="string", defvalue="x86_64", mode="readonly", action="eq", kinds=("allocation", ), description="""SCA required property describing the CPU type""") os_name = simple_property( id_="DCE:80BF17F0-6C7F-11d4-A226-0050DA314CD6", name="os_name", type_="string", defvalue="Linux", mode="readonly", action="eq", kinds=("allocation", ), description= """SCA required property describing the Operating System Name""") os_version = simple_property( id_="DCE:0f3a9a37-a342-43d8-9b7f-78dc6da74192", name="os_version", type_="string", mode="readonly", action="eq", kinds=("allocation", ), description= """SCA required property describing the Operating System Version""") nic_list = simpleseq_property(id_="nic_list", type_="string", defvalue=[], mode="readonly", action="external", kinds=("property", )) class NicAllocation(object): identifier = simple_property(id_="nic_allocation::identifier", name="identifier", type_="string", defvalue="") interface = simple_property(id_="nic_allocation::interface", name="interface", type_="string", defvalue="") def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["identifier"] = self.identifier d["interface"] = self.interface return str(d) @classmethod def getId(cls): return "nic_allocation" @classmethod def isStruct(cls): return True def getMembers(self): return [("identifier", self.identifier), ("interface", self.interface)] nic_allocation = struct_property(id_="nic_allocation", structdef=NicAllocation, configurationkind=("allocation", ), mode="readwrite") class NicAllocationStatusStruct(object): identifier = simple_property(id_="nic_allocation_status::identifier", name="identifier", type_="string") interface = simple_property(id_="nic_allocation_status::interface", name="interface", type_="string") def __init__(self, identifier="", interface=""): self.identifier = identifier self.interface = interface def __str__(self): """Return a string representation of this structure""" d = {} d["identifier"] = self.identifier d["interface"] = self.interface return str(d) @classmethod def getId(cls): return "nic_allocation_status_struct" @classmethod def isStruct(cls): return True def getMembers(self): return [("identifier", self.identifier), ("interface", self.interface)] nic_allocation_status = structseq_property( id_="nic_allocation_status", structdef=NicAllocationStatusStruct, defvalue=[], configurationkind=("property", ), mode="readonly")
class AllPropertyTypesComponent_base(CF__POA.Resource, Component, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Component.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component def start(self): Component.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): Component.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Component.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. simpleString = simple_property(id_="simpleString", name="simpleString", type_="string", defvalue="simpleStringTest", mode="readwrite", action="external", kinds=("property", )) simpleBool = simple_property(id_="simpleBool", name="simpleBool", type_="boolean", defvalue=True, mode="readwrite", action="external", kinds=("property", )) simpleDouble = simple_property(id_="simpleDouble", name="simpleDouble", type_="double", defvalue=123.456, mode="readwrite", action="external", kinds=("property", )) simpleShort = simple_property(id_="simpleShort", name="simpleShort", type_="short", defvalue=123, mode="readwrite", action="external", kinds=("property", )) readOnlyString = simple_property(id_="readOnlyString", name="readOnlyString", type_="string", defvalue="doNotChangeMe", mode="readonly", action="external", kinds=("property", )) simpleSeqString = simpleseq_property(id_="simpleSeqString", name="simpleSeqString", type_="string", defvalue=[ "simpleSeqStringTest1", "simpleSeqStringTest2", "simpleSeqStringTest3" ], mode="readwrite", action="external", kinds=("property", )) simpleSeqBool = simpleseq_property(id_="simpleSeqBool", name="simpleSeqBool", type_="boolean", defvalue=[True, False, True], mode="readwrite", action="external", kinds=("property", )) simpleSeqDouble = simpleseq_property( id_="simpleSeqDouble", name="simpleSeqDouble", type_="double", defvalue=[234.56700000000001, 345.678, 456.78899999999999], mode="readwrite", action="external", kinds=("property", )) simpleSeqShort = simpleseq_property(id_="simpleSeqShort", name="simpleSeqShort", type_="short", defvalue=[234, 345, 456], mode="readwrite", action="external", kinds=("property", )) class StructString(object): structSimpleString = simple_property(id_="structSimpleString", name="structSimpleString", type_="string", defvalue="structSimpleStringTest") structSimpleSeqString = simpleseq_property( id_="structSimpleSeqString", name="structSimpleSeqString", type_="string", defvalue=[ "structSeqSimpleStringTest1", "structSeqSimpleStringTest2", "structSeqSimpleStringTest3" ]) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["structSimpleString"] = self.structSimpleString d["structSimpleSeqString"] = self.structSimpleSeqString return str(d) @classmethod def getId(cls): return "structString" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSimpleString", self.structSimpleString), ("structSimpleSeqString", self.structSimpleSeqString)] structString = struct_property(id_="structString", name="structString", structdef=StructString, configurationkind=("property", ), mode="readwrite") class StructBool(object): structSimpleBool = simple_property(id_="structSimpleBool", name="structSimpleBool", type_="boolean", defvalue=False) structSimpleSeqBool = simpleseq_property(id_="structSimpleSeqBool", name="structSimpleSeqBool", type_="boolean", defvalue=[False, True, False]) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["structSimpleBool"] = self.structSimpleBool d["structSimpleSeqBool"] = self.structSimpleSeqBool return str(d) @classmethod def getId(cls): return "structBool" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSimpleBool", self.structSimpleBool), ("structSimpleSeqBool", self.structSimpleSeqBool)] structBool = struct_property(id_="structBool", name="structBool", structdef=StructBool, configurationkind=("property", ), mode="readwrite") class StructDouble(object): structSimpleDouble = simple_property(id_="structSimpleDouble", name="structSimpleDouble", type_="double", defvalue=987.654) structSimpleSeqDouble = simpleseq_property( id_="structSimpleSeqDouble", name="structSimpleSeqDouble", type_="double", defvalue=[ 876.54300000000001, 765.43200000000002, 654.32100000000003 ]) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["structSimpleDouble"] = self.structSimpleDouble d["structSimpleSeqDouble"] = self.structSimpleSeqDouble return str(d) @classmethod def getId(cls): return "structDouble" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSimpleDouble", self.structSimpleDouble), ("structSimpleSeqDouble", self.structSimpleSeqDouble)] structDouble = struct_property(id_="structDouble", name="structDouble", structdef=StructDouble, configurationkind=("property", ), mode="readwrite") class StructShort(object): structSimpleShort = simple_property(id_="structSimpleShort", name="structSimpleShort", type_="short", defvalue=987) structSimpleSeqShort = simpleseq_property(id_="structSimpleSeqShort", name="structSimpleSeqShort", type_="short", defvalue=[876, 765, 654]) def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k, v in kw.items(): setattr(self, k, v) def __str__(self): """Return a string representation of this structure""" d = {} d["structSimpleShort"] = self.structSimpleShort d["structSimpleSeqShort"] = self.structSimpleSeqShort return str(d) @classmethod def getId(cls): return "structShort" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSimpleShort", self.structSimpleShort), ("structSimpleSeqShort", self.structSimpleSeqShort)] structShort = struct_property(id_="structShort", name="structShort", structdef=StructShort, configurationkind=("property", ), mode="readwrite") class StructSeqStructString(object): structSeqStructSimpleString = simple_property( id_="structSeqStructSimpleString", name="structSeqStructSimpleString", type_="string", defvalue="structSeqStructSimpleStringTest") structSeqStructSimpleSeqString = simpleseq_property( id_="structSeqStructSimpleSeqString", name="structSeqStructSimpleSeqString", type_="string", defvalue=[ "structSeqStructSimpleStringTest1", "structSeqStructSimpleStringTest2", "structSeqStructSimpleStringTest3" ]) def __init__( self, structSeqStructSimpleString="structSeqStructSimpleStringTest", structSeqStructSimpleSeqString=[ "structSeqStructSimpleStringTest1", "structSeqStructSimpleStringTest2", "structSeqStructSimpleStringTest3" ]): self.structSeqStructSimpleString = structSeqStructSimpleString self.structSeqStructSimpleSeqString = structSeqStructSimpleSeqString def __str__(self): """Return a string representation of this structure""" d = {} d["structSeqStructSimpleString"] = self.structSeqStructSimpleString d["structSeqStructSimpleSeqString"] = self.structSeqStructSimpleSeqString return str(d) @classmethod def getId(cls): return "structSeqStructString" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSeqStructSimpleString", self.structSeqStructSimpleString), ("structSeqStructSimpleSeqString", self.structSeqStructSimpleSeqString)] structSeqString = structseq_property( id_="structSeqString", name="structSeqString", structdef=StructSeqStructString, defvalue=[ StructSeqStructString( structSeqStructSimpleString="structSeqStructSimpleStringTest", structSeqStructSimpleSeqString=[ "structSeqStructSimpleStringTest1", "structSeqStructSimpleStringTest2", "structSeqStructSimpleStringTest3" ]) ], configurationkind=("property", ), mode="readwrite") class StructSeqStructBool(object): structSeqStructSimpleBool = simple_property( id_="structSeqStructSimpleBool", name="structSeqStructSimpleBool", type_="boolean", defvalue=True) structSeqStructSimpleSeqBool = simpleseq_property( id_="structSeqStructSimpleSeqBool", name="structSeqStructSimpleSeqBool", type_="boolean", defvalue=[True, True, False]) def __init__(self, structSeqStructSimpleBool=True, structSeqStructSimpleSeqBool=[True, True, False]): self.structSeqStructSimpleBool = structSeqStructSimpleBool self.structSeqStructSimpleSeqBool = structSeqStructSimpleSeqBool def __str__(self): """Return a string representation of this structure""" d = {} d["structSeqStructSimpleBool"] = self.structSeqStructSimpleBool d["structSeqStructSimpleSeqBool"] = self.structSeqStructSimpleSeqBool return str(d) @classmethod def getId(cls): return "structSeqStructBool" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSeqStructSimpleBool", self.structSeqStructSimpleBool), ("structSeqStructSimpleSeqBool", self.structSeqStructSimpleSeqBool)] structSeqBool = structseq_property( id_="structSeqBool", name="structSeqBool", structdef=StructSeqStructBool, defvalue=[ StructSeqStructBool( structSeqStructSimpleBool=True, structSeqStructSimpleSeqBool=[True, True, False]) ], configurationkind=("property", ), mode="readwrite") class StructSeqStructDouble(object): structSeqStructSimpleDouble = simple_property( id_="structSeqStructSimpleDouble", name="structSeqStructSimpleDouble", type_="double", defvalue=12.34) structSeqStructSimpleSeqDouble = simpleseq_property( id_="structSeqStructSimpleSeqDouble", name="structSeqStructSimpleSeqDouble", type_="double", defvalue=[ 23.449999999999999, 34.560000000000002, 45.670000000000002 ]) def __init__(self, structSeqStructSimpleDouble=12.34, structSeqStructSimpleSeqDouble=[ 23.449999999999999, 34.560000000000002, 45.670000000000002 ]): self.structSeqStructSimpleDouble = structSeqStructSimpleDouble self.structSeqStructSimpleSeqDouble = structSeqStructSimpleSeqDouble def __str__(self): """Return a string representation of this structure""" d = {} d["structSeqStructSimpleDouble"] = self.structSeqStructSimpleDouble d["structSeqStructSimpleSeqDouble"] = self.structSeqStructSimpleSeqDouble return str(d) @classmethod def getId(cls): return "structSeqStructDouble" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSeqStructSimpleDouble", self.structSeqStructSimpleDouble), ("structSeqStructSimpleSeqDouble", self.structSeqStructSimpleSeqDouble)] structSeqDouble = structseq_property( id_="structSeqDouble", name="structSeqDouble", structdef=StructSeqStructDouble, defvalue=[ StructSeqStructDouble(structSeqStructSimpleDouble=12.34, structSeqStructSimpleSeqDouble=[ 23.449999999999999, 34.560000000000002, 45.670000000000002 ]) ], configurationkind=("property", ), mode="readwrite") class StructSeqStructShort(object): structSeqStructSimpleShort = simple_property( id_="structSeqStructSimpleShort", name="structSeqStructSimpleShort", type_="short", defvalue=12) structSeqStructSimpleSeqShort = simpleseq_property( id_="structSeqStructSimpleSeqShort", name="structSeqStructSimpleSeqShort", type_="short", defvalue=[23, 34, 45]) def __init__(self, structSeqStructSimpleShort=12, structSeqStructSimpleSeqShort=[23, 34, 45]): self.structSeqStructSimpleShort = structSeqStructSimpleShort self.structSeqStructSimpleSeqShort = structSeqStructSimpleSeqShort def __str__(self): """Return a string representation of this structure""" d = {} d["structSeqStructSimpleShort"] = self.structSeqStructSimpleShort d["structSeqStructSimpleSeqShort"] = self.structSeqStructSimpleSeqShort return str(d) @classmethod def getId(cls): return "structSeqStructShort" @classmethod def isStruct(cls): return True def getMembers(self): return [("structSeqStructSimpleShort", self.structSeqStructSimpleShort), ("structSeqStructSimpleSeqShort", self.structSeqStructSimpleSeqShort)] structSeqShort = structseq_property( id_="structSeqShort", name="structSeqShort", structdef=StructSeqStructShort, defvalue=[ StructSeqStructShort(structSeqStructSimpleShort=12, structSeqStructSimpleSeqShort=[23, 34, 45]) ], configurationkind=("property", ), mode="readwrite")
class cf_1535_p1_base(CF__POA.Resource, Component, ThreadedComponent): # These values can be altered in the __init__ of your derived class PAUSE = 0.0125 # The amount of time to sleep if process return NOOP TIMEOUT = 5.0 # The amount of time to wait for the process thread to die when stop() is called DEFAULT_QUEUE_SIZE = 100 # The number of BulkIO packets that can be in the queue before pushPacket will block def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Component.__init__(self, identifier, execparams, loggerName=loggerName) ThreadedComponent.__init__(self) # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False # Instantiate the default implementations for all ports on this component self.port_d1 = bulkio.InLongPort("d1", maxsize=self.DEFAULT_QUEUE_SIZE) self.port_d3 = bulkio.OutLongPort("d3") def start(self): Component.start(self) ThreadedComponent.startThread(self, pause=self.PAUSE) def stop(self): Component.stop(self) if not ThreadedComponent.stopThread(self, self.TIMEOUT): raise CF.Resource.StopError(CF.CF_NOTSET, "Processing thread did not die") def releaseObject(self): try: self.stop() except Exception: self._log.exception("Error stopping") Component.releaseObject(self) ###################################################################### # PORTS # # DO NOT ADD NEW PORTS HERE. You can add ports in your derived class, in the SCD xml file, # or via the IDE. port_d1 = providesport(name="d1", repid="IDL:BULKIO/dataLong:1.0", type_="data") port_d3 = usesport(name="d3", repid="IDL:BULKIO/dataLong:1.0", type_="data") ###################################################################### # PROPERTIES # # DO NOT ADD NEW PROPERTIES HERE. You can add properties in your derived class, in the PRF xml file # or by using the IDE. p1 = simple_property(id_="p1", name="p1", type_="string", mode="readwrite", action="external", kinds=("property",), description="""can you dig it { ( [""") window = simple_property(id_="window", name="window", type_="string", mode="readwrite", action="external", kinds=("property",)) freq = simple_property(id_="freq", name="freq", type_="float", defvalue=0.0, mode="readwrite", action="external", kinds=("property",)) s1 = simpleseq_property(id_="s1", name="s1", type_="long", defvalue=[], mode="readwrite", action="external", kinds=("property",)) class St1(object): a1 = simple_property( id_="st1::a1", name="a1", type_="string") b1 = simple_property( id_="st1::b1", name="b1", type_="float") def __init__(self, **kw): """Construct an initialized instance of this struct definition""" for classattr in type(self).__dict__.itervalues(): if isinstance(classattr, (simple_property, simpleseq_property)): classattr.initialize(self) for k,v in kw.items(): setattr(self,k,v) def __str__(self): """Return a string representation of this structure""" d = {} d["a1"] = self.a1 d["b1"] = self.b1 return str(d) @classmethod def getId(cls): return "st1" @classmethod def isStruct(cls): return True def getMembers(self): return [("a1",self.a1),("b1",self.b1)] st1 = struct_property(id_="st1", name="st1", structdef=St1, configurationkind=("property",), mode="readwrite") class Ss1St1(object): a1 = simple_property( id_="ss1::st1::a1", name="a1", type_="string") b1 = simple_property( id_="ss1::st1::b1", name="b1", type_="float") def __init__(self, a1="", b1=0.0): self.a1 = a1 self.b1 = b1 def __str__(self): """Return a string representation of this structure""" d = {} d["a1"] = self.a1 d["b1"] = self.b1 return str(d) @classmethod def getId(cls): return "ss1::st1" @classmethod def isStruct(cls): return True def getMembers(self): return [("a1",self.a1),("b1",self.b1)] ss1 = structseq_property(id_="ss1", name="ss1", structdef=Ss1St1, defvalue=[], configurationkind=("property",), mode="readwrite")
class PropertyChangeEvents(CF__POA.Resource, Resource): """ Example component to send property change events to an EventChannel port. """ myprop = simple_property(id_="myprop", type_="long", name="myprop", defvalue=0, mode="readwrite", action="external", kinds=("configure", "event")) anotherprop = simple_property(id_="anotherprop", type_="long", name="anotherprop", defvalue=0, mode="readwrite", action="external", kinds=("configure", )) propEvent = usesport(name="propEvent", repid="IDL:CosEventChannelAdmin/EventChannel:1.0", type_="data") seqprop = simpleseq_property(id_="seqprop", type_="float", defvalue=None, mode="readwrite", action="external", kinds=("configure", "event")) class SomeStruct(object): some_number = simple_property( id_="some_number", type_="double", ) some_string = simple_property( id_="some_string", type_="string", ) def __init__(self): """Construct an initialized instance of this struct definition""" for attrname, classattr in type(self).__dict__.items(): if type(classattr) == simple_property: classattr.initialize(self) def __str__(self): """Return a string representation of this structure""" d = {} d["some_number"] = self.some_number d["some_string"] = self.some_string return str(d) def isStruct(self): return True def getMembers(self): return [("some_number", self.some_number), ("some_string", self.some_string)] def __init__(self, identifier, execparams): Resource.__init__(self, identifier, execparams) def initialize(self): self.propEvent = PropertyEventSupplier(self) some_struct = struct_property(id_="some_struct", structdef=SomeStruct, configurationkind=("configure", "event"), mode="readwrite") structseq_prop = structseq_property(id_="structseq_prop", structdef=SomeStruct, defvalue=[], configurationkind=("configure", "event"), mode="readwrite") def start(self): self.myprop = 123 self.anotherprop = 123 self.seqprop = [1.0] self.some_struct.some_number = 123.0 tmp = self.SomeStruct() tmp.some_number = 2.0 tmp.some_string = "another string" newval = copy.deepcopy(self.structseq_prop) newval.append(tmp) self.structseq_prop = newval def runTest(self, testid, properties): if testid == 1061: # Ticket #1061: Ensure that if an eventable struct or struct sequence # has None for both the current and prior values, sendChangedPropertiesEvent # does not raise an exception. # Save values of struct and struct sequence properties saved_struct = copy.deepcopy(self.some_struct) saved_structseq = copy.deepcopy(self.structseq_prop) self.some_struct = None self.saved_structseq = None try: # Send two consecutive property change events so that the current # and saved values are both None. self.propEvent.sendChangedPropertiesEvent() self.propEvent.sendChangedPropertiesEvent() success = True except: success = False results = [CF.DataType('1061', any.to_any(success))] # Restore saved state self.some_struct = saved_struct self.saved_structseq = saved_structseq else: raise CF.TestableObject.UnknownTest('No test %d' % testid) return results
class TestPythonProps (CF__POA.Resource, Resource): """Python component for testing properties""" prop1 = simple_property(id_="DCE:b8f43ac8-26b5-40b3-9102-d127b84f9e4b", name="string_prop", type_="string", action="external", kinds=("configure",)) prop2 = simpleseq_property(id_="DCE:10b3364d-f035-4639-8e7f-02ac4706f5c7[]", name="stringseq_prop", type_="string", action="external", kinds=("configure",), defvalue=[]) class SomeStruct(object): field1 = simple_property(id_="item1", type_="string", defvalue=None) field2 = simple_property(id_="item2", type_="long", defvalue=None) field3 = simple_property(id_="item3", type_="double", defvalue=None) struct = struct_property(id_="DCE:ffe634c9-096d-425b-86cc-df1cce50612f", name="struct_test", structdef=SomeStruct) class MulticastAddress(object): ip_address = simple_property(id_="ip_address", type_="string") port = simple_property(id_="port", type_="ushort") def __init__(self, ip_address="", port=0): self.ip_address = ip_address self.port = port multicasts = structseq_property(id_="DCE:897a5489-f680-46a8-a698-e36fd8bbae80[]", name="multicasts", structdef=MulticastAddress, defvalue=[]) def __init__(self, identifier, execparams): Resource.__init__(self, identifier, execparams) def initialize(self): Resource.initialize(self) self.prop1 = "MyDefault1" self.prop2.append("1") self.prop2.append("2") self.prop2.append("3") self.struct.field1 = "StructDefault" self.struct.field2 = 100 self.struct.field3 = 1.0 self.multicasts.append(TestPythonProps.MulticastAddress("127.0.0.1", 123)) self.multicasts.append(TestPythonProps.MulticastAddress("127.0.0.1", 456))