def __init__(self,connector,connectParams):
assert isinstance(connector,ApiConnector.ApiConnector)
assert isinstance(connectParams,(str,tuple))
# store params
self.connector = connector
self.connectParams = connectParams
# local variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.goOn = True
self.delayCounter = self.SNAPSHOT_PERIOD_FIRST
self.dataLock = threading.Lock()
self.busySnapshotting = threading.Lock()
# initialize parent
threading.Thread.__init__(self)
self.name = '{0}_SnapShot'.format(self.netname)
# connect to EventBus
dispatcher.connect(
self._timeToNextSnapShot,
signal = "timeToNextSnapShot_{0}".format(self.netname),
weak = False,
)
dispatcher.connect(
self._snapShotNow,
signal = "snapShotNow_{0}".format(self.netname),
weak = False,
)
# start itself
self.start()
def __init__(self, connectParams):
# log
log.info("creating instance")
# store params
self.connectParams = connectParams
# local variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.hrParser = HrParser.HrParser()
self.dataLock = threading.Lock()
self.snapPaths = []
self.snapshotOngoing = False
# initialize parent class
EventBusClient.EventBusClient.__init__(
self,
signal='notifEvent_{0}'.format(self.netname),
cb=self._ebHandler_notifEvent,
teardown_cb=self._cleanup,
queuesize=self.QUEUESIZE,
)
self.name = '{0}_NetworkState'.format(self.netname)
# connect extra applications
dispatcher.connect(
self._ebHandler_snapShotStart,
signal='snapShotStart_{0}'.format(self.netname),
weak=False,
)
dispatcher.connect(
self._ebHandler_managerCmd,
signal='managerCmd_{0}'.format(self.netname),
weak=False,
)
dispatcher.connect(
self._ebHandler_snapShotEnd,
signal='snapShotEnd_{0}'.format(self.netname),
weak=False,
)
dispatcher.connect(
self._ebHandler_notifHealthReport,
signal='notifHealthReport_{0}'.format(self.netname),
weak=False,
)
def __init__(self,connectParams):
# log
log.info("creating instance")
# store params
self.connectParams = connectParams
# local variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.hrParser = HrParser.HrParser()
self.dataLock = threading.Lock()
self.snapPaths = []
self.snapshotOngoing = False
# initialize parent class
EventBusClient.EventBusClient.__init__(self,
signal = 'notifEvent_{0}'.format(self.netname),
cb = self._ebHandler_notifEvent,
teardown_cb = self._cleanup,
queuesize = self.QUEUESIZE,
)
self.name = '{0}_NetworkState'.format(self.netname)
# connect extra applications
dispatcher.connect(
self._ebHandler_snapShotStart,
signal = 'snapShotStart_{0}'.format(self.netname),
weak = False,
)
dispatcher.connect(
self._ebHandler_managerCmd,
signal = 'managerCmd_{0}'.format(self.netname),
weak = False,
)
dispatcher.connect(
self._ebHandler_snapShotEnd,
signal = 'snapShotEnd_{0}'.format(self.netname),
weak = False,
)
dispatcher.connect(
self._ebHandler_notifHealthReport,
signal = 'notifHealthReport_{0}'.format(self.netname),
weak = False,
)
def __init__(self,connectParams):
# log
log.info("creating instance")
# store params
self.connectParams = connectParams
# local variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
# initialize parent class
EventBusClient.EventBusClient.__init__(self,
signal = 'testResult_{0}'.format(self.netname),
cb = self._ebHandler_testResult,
teardown_cb = self._cleanup,
queuesize = self.QUEUESIZE,
)
self.name = '{0}_NetworkStatePublisher'.format(self.netname)
def __init__(self, connectParams):
# log
log.info("creating instance")
# store params
self.connectParams = connectParams
# local variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
# initialize parent class
EventBusClient.EventBusClient.__init__(
self,
signal='testResult_{0}'.format(self.netname),
cb=self._ebHandler_testResult,
teardown_cb=self._cleanup,
queuesize=self.QUEUESIZE,
)
self.name = '{0}_NetworkStatePublisher'.format(self.netname)
def __init__(self,connectParams):
# log
log.info("creating instance")
# store params
self.connectParams = connectParams
# local variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.busyTesting = threading.Lock()
# initialize parent class
EventBusClient.EventBusClient.__init__(self,
signal = 'snapShotEnd_{0}'.format(self.netname),
cb = self._ebHandler_snapShotEnd,
teardown_cb = self._cleanup,
queuesize = self.QUEUESIZE,
)
self.name = '{0}_NetworkStateAnalyzer'.format(self.netname)
def __init__(self, connectParams):
# log
log.info("creating instance")
# store params
self.connectParams = connectParams
# local variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.busyTesting = threading.Lock()
# initialize parent class
EventBusClient.EventBusClient.__init__(
self,
signal='snapShotEnd_{0}'.format(self.netname),
cb=self._ebHandler_snapShotEnd,
teardown_cb=self._cleanup,
queuesize=self.QUEUESIZE,
)
self.name = '{0}_NetworkStateAnalyzer'.format(self.netname)
def _deleteManagerConnection(self, connectParam):
dld = DustLinkData.DustLinkData()
with dld.dataLock:
#===== NetworkStateAnalyzer
if connectParam in self.publishers:
self.publishers[connectParam].tearDown()
del self.publishers[connectParam]
log.info('deleted publisher {0}'.format(connectParam))
#===== NetworkStateAnalyzer
if connectParam in self.analyzers:
self.analyzers[connectParam].tearDown()
del self.analyzers[connectParam]
log.info('deleted analyzer {0}'.format(connectParam))
#===== NetworkState
if connectParam in self.netstate:
self.netstate[connectParam].tearDown()
del self.netstate[connectParam]
log.info('deleted netstate {0}'.format(connectParam))
#===== GatewayListener
if connectParam in self.listeners:
self.listeners[connectParam].tearDown()
del self.listeners[connectParam]
log.info('deleted listener {0}'.format(connectParam))
#===== apiconnectors
if connectParam in self.apiconnectors:
self.apiconnectors[connectParam].disconnect()
del self.apiconnectors[connectParam]
log.info('deleted apiconnector {0}'.format(connectParam))
#===== delete network
try:
dld.deleteNetwork(FormatUtils.formatConnectionParams(connectParam))
except ValueError:
pass # happens if network was already deleted, e.g. by an earlier call to this function
def __init__(self,connector,connectParams):
assert isinstance(connector,ApiConnector.ApiConnector)
assert isinstance(connectParams,(str,tuple))
# record parameters
self.connector = connector
self.connectParams = connectParams
# log
log.info("creating instance")
# variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.statsLock = threading.Lock()
self._clearStats()
# start snapshot thread this manager
self.snapShotThread = SnapShot.SnapShot(connector,connectParams)
# subscribe to flows
try:
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun = self._subs_notifData,
isRlbl = False,
)
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun = self._subs_notifEvent,
isRlbl = True,
)
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
],
fun = self._subs_notifHealthReport,
isRlbl = True,
)
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun = self._subs_errorORfinish,
isRlbl = True,
)
except TypeError as err:
log.error(str(err))
raise ApiException.ConnectionError(str(err))
self.subscriber._thread.name = '{0}_IpMgrSubscribe'.format(self.netname)
# initialize parent class
EventBusClient.EventBusClient.__init__(self,
'dataToMesh_{0}'.format(self.netname),
self._ebHandler_dataToMesh,
)
# give this thread a name
self.name = '{0}_GatewayListener'.format(self.netname)
def _addManagerConnection(self,connectParam):
dld = DustLinkData.DustLinkData()
with dld.dataLock:
assert(connectParam not in self.apiconnectors)
assert(connectParam not in self.listeners)
assert(connectParam not in self.netstate)
assert(connectParam not in self.analyzers)
assert(connectParam not in self.publishers)
try:
#===== self.apiconnectors
if isinstance(connectParam,str):
# connecting to a serial port
newConnector = IpMgrConnectorSerial.IpMgrConnectorSerial()
newConnector.connect({
'port': connectParam,
})
else:
# connecting to the serialMux
newConnector = IpMgrConnectorMux.IpMgrConnectorMux()
newConnector.connect({
'host': connectParam[0],
'port': connectParam[1],
})
# log
log.info('added apiconnectors {0}'.format(connectParam))
self.apiconnectors[connectParam] = newConnector
dld.updateManagerConnectionState(
connectParam,
DustLinkData.DustLinkData.MANAGERCONNECTION_STATE_ACTIVE
)
#===== delete network
try:
dld.deleteNetwork(FormatUtils.formatConnectionParams(connectParam))
except ValueError:
pass # happens if network doesn't exist
#===== add network
try:
dld.addNetwork(FormatUtils.formatConnectionParams(connectParam))
except ValueError:
pass # happens if network already exists from previous connection
#===== self.listeners
assert(connectParam not in self.listeners)
self.listeners[connectParam] = GatewayListener.GatewayListener(
self.apiconnectors[connectParam],
connectParam,
)
log.info('added listener {0}'.format(connectParam))
#===== self.netstate
assert(connectParam not in self.netstate)
self.netstate[connectParam] = NetworkState.NetworkState(connectParam)
log.info('added netstate {0}'.format(connectParam))
#===== self.analyzers
assert(connectParam not in self.analyzers)
self.analyzers[connectParam] = NetworkStateAnalyzer.NetworkStateAnalyzer(connectParam)
log.info('added analyzer {0}'.format(connectParam))
#===== self.publishers
assert(connectParam not in self.publishers)
self.publishers[connectParam] = NetworkStatePublisher.NetworkStatePublisher(connectParam)
log.info('added publisher {0}'.format(connectParam))
except Exception as err:
# log
log.warning('could not add apiconnectors {0}: {1}'.format(connectParam, err))
# update state
dld.updateManagerConnectionState(
connectParam,
DustLinkData.DustLinkData.MANAGERCONNECTION_STATE_FAIL,
reason = str(err),
)
# detelete the connection to the manager
self._deleteManagerConnection(connectParam)
def __init__(self, connector, connectParams):
assert isinstance(connector, ApiConnector.ApiConnector)
assert isinstance(connectParams, (str, tuple))
# record parameters
self.connector = connector
self.connectParams = connectParams
# log
log.info("creating instance")
# variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.statsLock = threading.Lock()
self._clearStats()
# start snapshot thread this manager
self.snapShotThread = SnapShot.SnapShot(connector, connectParams)
# subscribe to flows
try:
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._subs_notifData,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun=self._subs_notifEvent,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
],
fun=self._subs_notifHealthReport,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self._subs_errorORfinish,
isRlbl=True,
)
except TypeError as err:
log.error(str(err))
raise ApiException.ConnectionError(str(err))
self.subscriber._thread.name = '{0}_IpMgrSubscribe'.format(
self.netname)
# initialize parent class
EventBusClient.EventBusClient.__init__(
self,
'dataToMesh_{0}'.format(self.netname),
self._ebHandler_dataToMesh,
)
# give this thread a name
self.name = '{0}_GatewayListener'.format(self.netname)
