class InSDDSPort(BULKIO__POA.dataSDDS):
_TYPE_='b'
def __init__(self, name, logger=None, callback = None, sriCmp=None, timeCmp=None, PortType = _TYPE_ ):
self.name = name
self.logger = logger
self.sri = None
self.port_lock = threading.Lock()
self._attachedStreams = {} # key=attach_id, value = (streamDef, userid)
self.stats = InStats(name, PortType )
self.sriDict = {} # key=streamID, value=(StreamSRI, PrecisionUTCTime)
self.callback = callback
self.sri_cmp = sriCmp
self.time_cmp = timeCmp
self.sriChanged = False
try:
self._attach_cb = getattr(callback, "attach")
if not callable(self._attach_cb):
self._attach_cb = None
except AttributeError:
self._attach_cb = None
try:
self._detach_cb = getattr(callback, "detach")
if not callable(self._detach_cb):
self._attach_cb = None
except AttributeError:
self._detach_cb = None
if self.logger:
self.logger.debug("bulkio::InSDDSPort CTOR port:" + str(name) )
def setBitSize(self, bitSize):
self.stats.setBitSize(bitSize)
def enableStats(self, enabled):
self.stats.setEnabled(enabled)
def updateStats(self, elementsReceived, queueSize, streamID):
self.port_lock.acquire()
self.stats.update(elementsReceived, queueSize, streamID)
self.port_lock.release()
def _get_statistics(self):
self.port_lock.acquire()
recStat = self.stats.retrieve()
self.port_lock.release()
return recStat
def _get_state(self):
if len(self._attachedStreams.values()) == 0:
return BULKIO.IDLE
# default behavior is to limit to one connection
elif len(self._attachedStreams.values()) == 1:
return BULKIO.BUSY
else:
return BULKIO.ACTIVE
def _get_attachedSRIs(self):
sris = []
for entry in self.sriDict:
sris.append(copy.deepcopy(self.sriDict[entry]))
self.port_lock.release()
return sris
def _get_usageState(self):
if len(self._attachedStreams.values()) == 0:
return BULKIO.dataSDDS.IDLE
# default behavior is to limit to one connection
elif len(self._attachedStreams.values()) == 1:
return BULKIO.dataSDDS.BUSY
else:
return BULKIO.dataSDDS.ACTIVE
def _get_attachedStreams(self):
return [x[0] for x in self._attachedStreams.values()]
def _get_attachmentIds(self):
return self._attachedStreams.keys()
def attach(self, streamDef, userid):
if self.logger:
self.logger.trace("bulkio::InSDDSPort attach ENTER (port=" + str(name) +")" )
self.logger.debug("SDDS PORT, ATTACH REQUEST, STREAM/USER" + str(streamDef) + '/' + str(userid))
if self._get_usageState() == BULKIO.dataSDDS.BUSY:
if self.logger:
self.logger.error("SDDS PORT, No Capacity to satisfy request. STREAM/USER" + str(streamDef) + '/' + str(userid))
raise BULKIO.dataSDDS.AttachError("No capacity")
#
# Allocate capacities here if applicable
#
# The attachment succeeded so generate a attachId
attachId = None
try:
if self.logger:
self.logger.debug("SDDS PORT: CALLING ATTACH CALLBACK, STREAM/USER" + str(streamDef) + '/' + str(userid) )
if self._attach_cb != None:
attachId = self._attach_cb(streamDef, userid)
except Exception, e:
if self.logger:
self.logger.error("SDDS PORT: ATTACH CALLBACK EXCEPTION : " + str(e) + " STREAM/USER" + str(streamDef) + '/' + str(userid) )
raise BULKIO.dataSDDS.AttachError(str(e))
if attachId == None:
attachId = str(uuid.uuid4())
self._attachedStreams[attachId] = (streamDef, userid)
if self.logger:
self.logger.debug("SDDS PORT, ATTACH COMPLETED, ID:" + str(attachId) + " STREAM/USER: "******"bulkio::InSDDSPort attach EXIT (port=" + str(name) +")" )
return attachId
class InAttachablePort:
_TYPE_ = 'b'
def __init__(self,
name,
logger=None,
attachDetachCallback=None,
sriCmp=sri.compare,
timeCmp=timestamp.compare,
PortType=_TYPE_,
newSriCallback=None,
sriChangeCallback=None,
interface=None):
self.name = name
self.logger = logger
self.port_lock = threading.Lock()
self.sri_query_lock = threading.Lock()
self._attachedStreams = {
} # key=attach_id, value = (streamDef, userid)
self.stats = InStats(name, PortType)
self.sriDict = {} # key=streamID, value=(StreamSRI, PrecisionUTCTime)
self.attachDetachCallback = attachDetachCallback
self.newSriCallback = newSriCallback
self.sriChangeCallback = sriChangeCallback
self.sri_cmp = sriCmp
self.time_cmp = timeCmp
self.sriChanged = False
if not interface:
if self.logger:
self.logger.error(
"InAttachablePort __init__ - an interface must be specified, set to BULKIO.dataSDDS or BULKIO.dataVITA49"
)
raise Port.InvalidPort(
1,
"InAttachablePort __init__ - an interface must be specified, set to BULKIO.dataSDDS or BULKIO.dataVITA49"
)
self.interface = interface # BULKIO port interface (valid options are BULKIO.dataSDDS or BULKIO.dataVITA49)
self.setNewAttachDetachListener(attachDetachCallback)
if self.logger:
self.logger.debug("bulkio::InAttachablePort CTOR port:" +
str(self.name) + " using interface " +
str(self.interface))
def setNewAttachDetachListener(self, attachDetachCallback):
self.port_lock.acquire()
try:
self.attachDetachCallback = attachDetachCallback
# Set _attach_cb
try:
self._attach_cb = getattr(attachDetachCallback, "attach")
if not callable(self._attach_cb):
self._attach_cb = None
except AttributeError:
self._attach_cb = None
# Set _detach_cb
try:
self._detach_cb = getattr(attachDetachCallback, "detach")
if not callable(self._detach_cb):
self._detach_cb = None
except AttributeError:
self._detach_cb = None
finally:
self.port_lock.release()
def setNewSriListener(self, newSriCallback):
self.port_lock.acquire()
try:
self.newSriCallback = newSriCallback
finally:
self.port_lock.release()
def setSriChangeListener(self, sriChangeCallback):
self.port_lock.acquire()
try:
self.sriChangeCallback = sriChangeCallback
finally:
self.port_lock.release()
def setBitSize(self, bitSize):
self.stats.setBitSize(bitSize)
def enableStats(self, enabled):
self.stats.setEnabled(enabled)
def updateStats(self, elementsReceived, queueSize, streamID):
self.port_lock.acquire()
try:
self.stats.update(elementsReceived, queueSize, streamID)
finally:
self.port_lock.release()
def _get_statistics(self):
self.port_lock.acquire()
try:
recStat = self.stats.retrieve()
finally:
self.port_lock.release()
return recStat
def _get_state(self):
self.port_lock.acquire()
try:
numAttachedStreams = len(self._attachedStreams.values())
finally:
self.port_lock.release()
if numAttachedStreams == 0:
return BULKIO.IDLE
# default behavior is to limit to one connection
elif numAttachedStreams == 1:
return BULKIO.BUSY
else:
return BULKIO.ACTIVE
def _get_attachedSRIs(self):
sris = []
self.sri_query_lock.acquire()
try:
for entry in self.sriDict:
# First value of sriDict entry is the StreamSRI object
sris.append(copy.deepcopy(self.sriDict[entry][0]))
finally:
self.sri_query_lock.release()
return sris
def _get_usageState(self):
self.port_lock.acquire()
try:
numAttachedStreams = len(self._attachedStreams.values())
finally:
self.port_lock.release()
if numAttachedStreams == 0:
return self.interface.IDLE
# default behavior is to limit to one connection
elif numAttachedStreams == 1:
return self.interface.BUSY
else:
return self.interface.ACTIVE
def _get_attachedStreams(self):
return [x[0] for x in self._attachedStreams.values()]
def _get_attachmentIds(self):
return self._attachedStreams.keys()
def attach(self, streamDef, userid):
if self.logger:
self.logger.trace("bulkio::InAttachablePort attach ENTER (port=" +
str(self.name) + ")")
self.logger.debug(
"InAttachablePort.attach() - ATTACH REQUEST, STREAM/USER" +
str(streamDef) + '/' + str(userid))
attachId = None
self.port_lock.acquire()
try:
try:
if self.logger:
self.logger.debug(
"InAttachablePort.attach() - CALLING ATTACH CALLBACK, STREAM/USER"
+ str(streamDef) + '/' + str(userid))
if self._attach_cb != None:
attachId = self._attach_cb(streamDef, userid)
except Exception, e:
if self.logger:
self.logger.error(
"InAttachablePort.attach() - ATTACH CALLBACK EXCEPTION : "
+ str(e) + " STREAM/USER" + str(streamDef) + '/' +
str(userid))
raise self.interface.AttachError(str(e))
if attachId == None:
attachId = str(uuid.uuid4())
self._attachedStreams[attachId] = (streamDef, userid)
finally:
class InAttachablePort:
_TYPE_='b'
def __init__(self, name, logger=None, attachDetachCallback=None, sriCmp=sri.compare, timeCmp=timestamp.compare, PortType = _TYPE_, newSriCallback=None, sriChangeCallback=None,interface=None):
self.name = name
self.logger = logger
self.port_lock = threading.Lock()
self.sri_query_lock = threading.Lock()
self._attachedStreams = {} # key=attach_id, value = (streamDef, userid)
self.stats = InStats(name, PortType )
self.sriDict = {} # key=streamID, value=(StreamSRI, PrecisionUTCTime)
self.attachDetachCallback = attachDetachCallback
self.newSriCallback = newSriCallback
self.sriChangeCallback = sriChangeCallback
self.sri_cmp = sriCmp
self.time_cmp = timeCmp
self.sriChanged = False
if not interface:
if self.logger:
self.logger.error("InAttachablePort __init__ - an interface must be specified, set to BULKIO.dataSDDS or BULKIO.dataVITA49")
raise Port.InvalidPort(1, "InAttachablePort __init__ - an interface must be specified, set to BULKIO.dataSDDS or BULKIO.dataVITA49")
self.interface=interface # BULKIO port interface (valid options are BULKIO.dataSDDS or BULKIO.dataVITA49)
self.setNewAttachDetachListener(attachDetachCallback)
if self.logger:
self.logger.debug("bulkio::InAttachablePort CTOR port:" + str(self.name) + " using interface " + str(self.interface))
def setNewAttachDetachListener(self, attachDetachCallback ):
self.port_lock.acquire()
try:
self.attachDetachCallback = attachDetachCallback
# Set _attach_cb
try:
self._attach_cb = getattr(attachDetachCallback, "attach")
if not callable(self._attach_cb):
self._attach_cb = None
except AttributeError:
self._attach_cb = None
# Set _detach_cb
try:
self._detach_cb = getattr(attachDetachCallback, "detach")
if not callable(self._detach_cb):
self._detach_cb = None
except AttributeError:
self._detach_cb = None
finally:
self.port_lock.release()
def setNewSriListener(self, newSriCallback):
self.port_lock.acquire()
try:
self.newSriCallback = newSriCallback
finally:
self.port_lock.release()
def setSriChangeListener(self, sriChangeCallback):
self.port_lock.acquire()
try:
self.sriChangeCallback = sriChangeCallback
finally:
self.port_lock.release()
def setBitSize(self, bitSize):
self.stats.setBitSize(bitSize)
def enableStats(self, enabled):
self.stats.setEnabled(enabled)
def updateStats(self, elementsReceived, queueSize, streamID):
self.port_lock.acquire()
try:
self.stats.update(elementsReceived, queueSize, streamID)
finally:
self.port_lock.release()
def _get_statistics(self):
self.port_lock.acquire()
try:
recStat = self.stats.retrieve()
finally:
self.port_lock.release()
return recStat
def _get_state(self):
self.port_lock.acquire()
try:
numAttachedStreams = len(self._attachedStreams.values())
finally:
self.port_lock.release()
if numAttachedStreams == 0:
return BULKIO.IDLE
# default behavior is to limit to one connection
elif numAttachedStreams == 1:
return BULKIO.BUSY
else:
return BULKIO.ACTIVE
def _get_attachedSRIs(self):
sris = []
self.sri_query_lock.acquire()
try:
for entry in self.sriDict:
# First value of sriDict entry is the StreamSRI object
sris.append(copy.deepcopy(self.sriDict[entry][0]))
finally:
self.sri_query_lock.release()
return sris
def _get_usageState(self):
self.port_lock.acquire()
try:
numAttachedStreams = len(self._attachedStreams.values())
finally:
self.port_lock.release()
if numAttachedStreams == 0:
return self.interface.IDLE
# default behavior is to limit to one connection
elif numAttachedStreams == 1:
return self.interface.BUSY
else:
return self.interface.ACTIVE
def _get_attachedStreams(self):
return [x[0] for x in self._attachedStreams.values()]
def _get_attachmentIds(self):
return self._attachedStreams.keys()
def attach(self, streamDef, userid):
if self.logger:
self.logger.trace("bulkio::InAttachablePort attach ENTER (port=" + str(self.name) +")" )
self.logger.debug("InAttachablePort.attach() - ATTACH REQUEST, STREAM/USER" + str(streamDef) + '/' + str(userid))
attachId = None
self.port_lock.acquire()
try:
try:
if self.logger:
self.logger.debug("InAttachablePort.attach() - CALLING ATTACH CALLBACK, STREAM/USER" + str(streamDef) + '/' + str(userid) )
if self._attach_cb != None:
attachId = self._attach_cb(streamDef, userid)
except Exception, e:
if self.logger:
self.logger.error("InAttachablePort.attach() - ATTACH CALLBACK EXCEPTION : " + str(e) + " STREAM/USER" + str(streamDef) + '/' + str(userid) )
raise self.interface.AttachError(str(e))
if attachId == None:
attachId = str(uuid.uuid4())
self._attachedStreams[attachId] = (streamDef, userid)
finally:
