def testReceiverShutdownByCall(self):
# start a Receiver
rec = Receiver(self.addr, self.printer, self.ctrl)
rec.startReceiver() # non blocking call
workChann, contChann = self._getSenderChannels()
# send some messages to the receiver and shut it eventually
contChann.send_json(RegisterMsg("Receiver_t"))
workChann.send_json(Alert(Type="Alert", Level=20))
contChann.send_json(UnregisterMsg("Receiver_t"))
# now messages are sent so shutdown the Receiver by a convenience
# call, should block until the Receiver finishes, don't have to wait
rec.shutdown()
def testReceiverShutdownByCall(self):
# start a Receiver
rec = Receiver(self.addr, self.printer, self.ctrl)
rec.startReceiver() # non blocking call
workChann, contChann = self._getSenderChannels()
# send some messages to the receiver and shut it eventually
contChann.send_json(RegisterMsg("Receiver_t"))
workChann.send_json(Alert(Type = "Alert", Level = 20))
contChann.send_json(UnregisterMsg("Receiver_t"))
# now messages are sent so shutdown the Receiver by a convenience
# call, should block until the Receiver finishes, don't have to wait
rec.shutdown()
class AlertProcessor(Harness):
def __init__(self, config):
Harness.__init__(self, config)
self._myName = self.__class__.__name__
self.config = config
# instance of processor
self._processor = None
# instance of Receiver which owns Processor (self._processor)
# and runs on background
self._receiver = None
logging.info("%s initialized." % self._myName)
def preInitialization(self):
"""
Start up the ZMQ Receiver + Processor.
"""
logging.info("%s starting ..." % self._myName)
self._processor = Processor(self.config.AlertProcessor)
# Receiver listens on work channel (address) and on control
# channel (controlAddr)
self._receiver = Receiver(self.config.AlertProcessor.address,
self._processor,
self.config.AlertProcessor.controlAddr)
self._receiver.startReceiver()
logging.info("%s started, Receiver should be listening." % self._myName)
def stopProcessor(self):
"""
Method to shutdown the Alert Processor.
"""
logging.info("%s shutting down, waiting for Receiver ..." % self._myName)
self._receiver.shutdown()
def prepareToStop(self, wait = False, stopPayload = ""):
"""
Override prepareToStop to include call to stopProcessor.
Ugly, but seems no other way to do this...
"""
self.stopProcessor()
Harness.prepareToStop(self, wait, stopPayload)
class SenderTest(unittest.TestCase):
def setUp(self):
self.addr = "tcp://127.0.0.1:5557"
self.control = "tcp://127.0.0.1:5559"
logging.basicConfig(logLevel = logging.DEBUG)
# real Receiver instance, do test real stuff rather than with
# mock Receiver
self.receiver = None
def tearDown(self):
"""
Clean up.
"""
if self.receiver:
print "Receiver should be stopped now."
print "Receiver running: (isReady()): %s" % self.receiver.isReady()
if self.receiver.isReady():
print "Receiver shutdown ..."
self.receiver.shutdown()
print "Receiver running: (isReady()): %s" % self.receiver.isReady()
self.receiver = None
def testSenderBasic(self):
"""
Immediate testing register, unregister messages.
Alert messages tested as saved in the queue.
"""
nAlerts = 10
# start Receiver, handler is list for alerts
# wait for control messages to arrive and test immediately
alertsQueue = []
handler = lambda x: alertsQueue.append(x)
self.receiver = Receiver(self.addr, handler, self.control)
self.receiver.startReceiver() # non blocking call
# instantiate sender and send ...
s = Sender(self.addr, "Sender_t", self.control)
# nothing is registered up to now with the Receiver
self.assertEqual(len(self.receiver._receiver._registSenders), 0)
s.register()
# test that RegisterMsg arrived, consider delay
while len(self.receiver._receiver._registSenders) == 0:
time.sleep(0.2)
self.assertEqual(len(self.receiver._receiver._registSenders), 1)
# send some alerts
for i in range(0, nAlerts):
a = Alert(Level = i, Type = "Alert")
s(a) # actual alert message sending
s.unregister()
while len(self.receiver._receiver._registSenders) == 1:
time.sleep(0.2)
self.assertEqual(len(self.receiver._receiver._registSenders), 0)
# this makes sure that Receiver waits certain delay even after shutdown
# is received if there is no more messages coming
self.receiver.shutdown()
self.assertEqual(nAlerts, len(alertsQueue))
def testSenderNonBlockingWhenReceiverNotAvailable(self):
"""
Repeatedly instantiate Sender, register, send alerts, etc
and test that the Sender is not blocking due to undelivered
messages since no Receiver is available.
This test shall wait (between iterations) only delay specified
in the Sender (was hanging indefinitely due to -1 default value).
"""
iterations = 2
nAlerts = 3
for i in range(iterations):
# instantiate sender and send ...
s = Sender(self.addr, "Sender_t", self.control)
s.register()
# send some alerts
for i in range(0, nAlerts):
a = Alert(Level = 10, Type = "Alert")
s(a) # actual alert message sending
s.unregister()
# call destructor explicitly, the hanging should not occur here
del s
class SenderTest(unittest.TestCase):
def setUp(self):
self.addr = "tcp://127.0.0.1:5557"
self.control = "tcp://127.0.0.1:5559"
logging.basicConfig(logLevel=logging.DEBUG)
# real Receiver instance, do test real stuff rather than with
# mock Receiver
self.receiver = None
def tearDown(self):
"""
Clean up.
"""
if self.receiver:
print "Receiver should be stopped now."
print "Receiver running: (isReady()): %s" % self.receiver.isReady()
if self.receiver.isReady():
print "Receiver shutdown ..."
self.receiver.shutdown()
print "Receiver running: (isReady()): %s" % self.receiver.isReady(
)
self.receiver = None
def testSenderBasic(self):
"""
Immediate testing register, unregister messages.
Alert messages tested as saved in the queue.
"""
nAlerts = 10
# start Receiver, handler is list for alerts
# wait for control messages to arrive and test immediately
alertsQueue = []
handler = lambda x: alertsQueue.append(x)
self.receiver = Receiver(self.addr, handler, self.control)
self.receiver.startReceiver() # non blocking call
# instantiate sender and send ...
s = Sender(self.addr, self.control, "Sender_t")
# nothing is registered up to now with the Receiver
self.assertEqual(len(self.receiver._receiver._registSenders), 0)
s.register()
# test that RegisterMsg arrived, consider delay
while len(self.receiver._receiver._registSenders) == 0:
time.sleep(0.2)
self.assertEqual(len(self.receiver._receiver._registSenders), 1)
# send some alerts
for i in range(0, nAlerts):
a = Alert(Level=i, Type="Alert")
s(a) # actual alert message sending
s.unregister()
while len(self.receiver._receiver._registSenders) == 1:
time.sleep(0.2)
self.assertEqual(len(self.receiver._receiver._registSenders), 0)
# this makes sure that Receiver waits certain delay even after shutdown
# is received if there is no more messages coming
self.receiver.shutdown()
self.assertEqual(nAlerts, len(alertsQueue))
def testSenderNonBlockingWhenReceiverNotAvailable(self):
"""
Repeatedly instantiate Sender, register, send alerts, etc
and test that the Sender is not blocking due to undelivered
messages since no Receiver is available.
This test shall wait (between iterations) only delay specified
in the Sender.
"""
iterations = 2
nAlerts = 3
for i in range(iterations):
# instantiate sender and send ...
s = Sender(self.addr, self.control, "Sender_t")
s.register()
# send some alerts
for i in range(0, nAlerts):
a = Alert(Level=10, Type="Alert")
s(a) # actual alert message sending
s.unregister()
# call destructor explicitly, the hanging should not occur here
del s
class AlertProcessor(Harness):
def __init__(self, config):
Harness.__init__(self, config)
self.config = config
# instance of processor
self._processor = None
# instance of Receiver which owns Processor (self._processor)
# and runs on background
self._receiver = None
#3602 related:
# Harness, nor the components, handle signal.SIGTERM which
# is used by wmcoreD --shutdown, hence shutdown sequence is not called
# this shall later be moved into (hopefully largely improved) Harness
signal.signal(signal.SIGTERM, self._signalHandler)
def _signalHandler(self, signalNumber, frame):
logging.info("Signal number %s caught." % signalNumber)
self.prepareToStop()
def preInitialization(self):
"""
Start up the ZMQ Receiver + Processor.
"""
logging.info("preInitialization ...")
# something fishy (again) going on in Harness, wmcoreD
# component may fail, still will be considered as running (#3602)
# this is why #3320 is difficult to fix ... wmcoreD would happily
# continue even after raising an exception even from this very method directly
self._processor = Processor(self.config.AlertProcessor)
# Receiver listens on work channel (address) and on control
# channel (controlAddr)
self._receiver = Receiver(self.config.AlertProcessor.address,
self._processor,
self.config.AlertProcessor.controlAddr)
self._receiver.startReceiver()
logging.info("preInitialization - finished.")
def stopAlertProcessor(self):
"""
Method to shutdown the AlertProcessor.
"""
logging.info("stopAlertProcessor - stopping Receiver ...")
self._receiver.shutdown()
logging.info("stopAlertProcessor finished.")
def prepareToStop(self, wait = False, stopPayload = ""):
"""
Override prepareToStop to include call to stopProcessor.
Ugly, but seems no other way to do this...
"""
logging.info("Shutting down the component - prepareToStop ...")
self.stopAlertProcessor()
Harness.prepareToStop(self, wait, stopPayload)
logging.info("prepareToStop finished.")
