def testHostNameAndProcessId(self):
testEnv = EventsEnvironment()
topic = testEnv.getLoggingTopic()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER="+testEnv.getBroker()+"\n"
confStr += "log4j.appender.EA.TOPIC="+topic+"\n"
self.configure(confStr)
recv = events.EventReceiver(testEnv.getBroker(), topic)
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.MDCRemove("x")
e = recv.receiveEvent()
self.assertValidMessage(e, "This is TRACE")
ps = e.getPropertySet()
# the host name should be the same since we're sending and receiving
# from the same host
host = ps.get(events.LogEvent.ORIG_HOSTNAME)
self.assertEqual(host, socket.gethostname())
# the process id should be the same since we're sending and receiving
# from the same process
pid = ps.get(events.LogEvent.ORIG_PROCESSID)
self.assertEqual(os.getpid(), pid)
t = ps.get(events.LogEvent.TYPE)
self.assertEqual(t, events.EventTypes.LOG)
def testHostNameAndProcessId(self):
testEnv = EventsEnvironment()
topic = testEnv.getLoggingTopic()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER=" + testEnv.getBroker() + "\n"
confStr += "log4j.appender.EA.TOPIC=" + topic + "\n"
self.configure(confStr)
recv = events.EventReceiver(testEnv.getBroker(), topic)
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.MDCRemove("x")
e = recv.receiveEvent()
self.assertValidMessage(e, "This is TRACE")
ps = e.getPropertySet()
# the host name should be the same since we're sending and receiving
# from the same host
host = ps.get(events.LogEvent.ORIG_HOSTNAME)
self.assertEqual(host, socket.gethostname())
# the process id should be the same since we're sending and receiving
# from the same process
pid = ps.get(events.LogEvent.ORIG_PROCESSID)
self.assertEqual(os.getpid(), pid)
t = ps.get(events.LogEvent.TYPE)
self.assertEqual(t, events.EventTypes.LOG)
def testQueueOrder(self):
# this tests the order in which the sender and receiver are created
# and event is created and sent before the receiver exists, and the
# receiver should still get the message
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
eventSystem = events.EventSystem.getDefaultEventSystem()
# test with default port
queue = self.createDestination("test_queues4")
eventSystem = events.EventSystem.getDefaultEventSystem()
eventSystem.createEnqueuer(broker, queue)
prop = self.createPropertySet()
# create and publish an event without a runid, BEFORE
# creating a receiver
event = events.Event(prop)
eventSystem.publishEvent(queue, event)
eventSystem.createDequeuer(broker, queue)
# should receive the event
receivedEvent = eventSystem.receiveEvent(queue)
self.assertIsNotNone(receivedEvent)
# should be able to get the PropertySet we sent
recvProp = receivedEvent.getPropertySet()
self.assertIsNotNone(recvProp)
# verify PropertySet contents
self.verifyPropertySet(recvProp)
def testEventSelector(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
host_pid = "%s_%d" % (thisHost, os.getpid())
topic = "test_events_11_%s" % host_pid
runid = 'test_runid_11_%d' % os.getpid()
rec = events.EventReceiver(broker, topic, "%s = '%s'" % (events.Event.RUNID, runid))
#
# send a test event, and wait to receive it
#
self.sendEvent(runid, broker, topic)
# we'll get the second event, not the first
val = rec.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
self.assertTrue(ps.exists(events.Event.RUNID))
self.assertEqual(ps.get(events.Event.RUNID),runid)
self.sendEvent("invalid", broker, topic)
# shouldn't receive anything else
val2 = rec.receiveEvent(1)
self.assertIsNone(val2)
def testIllegalFilterableStatusEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic = self.createTopicName("test_events_10_%s.A")
#
# send a test event, and wait to receive it
#
trans = events.EventTransmitter(broker, topic)
root = PropertySet()
root.set(events.StatusEvent.TOPIC, topic)
root.set("myname","myname")
root.set(events.StatusEvent.STATUS, "my special status")
filter = PropertySet()
filter.set("FOO", "bar")
filter.set("PLOUGH", 123)
filter.set("PLOVER.FIRST", 1)
filter.set("PLOVER.SECOND", 2)
eventSystem = events.EventSystem.getDefaultEventSystem();
locationID = eventSystem.createOriginatorId()
event = events.StatusEvent(locationID, root, filter)
self.assertRaises(ex.Exception, trans.publishEvent, event)
def testPlainStatusEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic = self.createTopicName("test_events_10_%s.A")
receiver = self.createReceiver(broker, topic)
#
# send a test event, and wait to receive it
#
self.sendPlainStatusEvent(broker, topic)
val = receiver.receiveEvent()
self.assertIsNotNone(val)
values = [
events.Event.EVENTTIME, events.StatusEvent.ORIG_HOSTNAME,
events.StatusEvent.ORIG_LOCALID, events.StatusEvent.ORIG_PROCESSID,
events.Event.PUBTIME, events.Event.STATUS, events.Event.TOPIC,
events.Event.TYPE
]
customValues = ['myname', 'logger']
self.assertValid(val, values, customValues)
self.assertNotEqual(val.getEventTime(), 0)
self.assertNotEqual(val.getPubTime(), 0)
self.assertGreater(val.getPubTime(), val.getEventTime())
self.assertEqual(val.getType(), events.EventTypes.STATUS)
def testMultiTopicSend(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
pid = os.getpid()
host_pid = "%s_%d" % (thisHost, pid)
topic1 = "test_events_6_%s" % host_pid
topic2 = "test_events_6a_%s" % host_pid
y1 = events.EventReceiver(broker, topic1)
y2 = events.EventReceiver(broker, topic2)
#
# send a test event on both topics at once, and have each receiver wait to
# receive it
#
self.sendEvent(broker, topic1 + "," + topic2)
val = y1.receiveEvent()
self.assertIsNotNone(val)
val = y2.receiveEvent()
self.assertIsNotNone(val)
def testEventTransmitterCreatedFirst(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
port = testEnv.getPort()
thisHost = platform.node()
topic = "test_events_queue2_%s_%d" % (thisHost, os.getpid())
# Integer tests
#
# send two test events
#
self.sendEvent(broker, topic, port, 300)
self.sendEvent(broker, topic, port, 200)
recv = events.EventDequeuer(broker, topic, port);
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 300 back
ps = val.getPropertySet()
self.assertEqual(ps.get("FOO"), 300)
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 200 back
ps = val.getPropertySet()
self.assertEqual(ps.get("FOO"), 200)
# check to see no other events are waiting
val = recv.receiveEvent(1)
self.assertIsNone(val)
def testBrokerOption(self):
testEnv = EventsEnvironment()
topic = testEnv.getLoggingTopic()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER="+testEnv.getBroker()+"\n"
confStr += "log4j.appender.EA.TOPIC="+topic+"\n"
self.configure(confStr)
recv = events.EventReceiver(testEnv.getBroker(), topic)
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.info("This is INFO")
log.debug("This is DEBUG")
log.MDCRemove("x")
self.assertValidMessage(recv.receiveEvent(), "This is TRACE")
self.assertValidMessage(recv.receiveEvent(), "This is INFO")
self.assertValidMessage(recv.receiveEvent(), "This is DEBUG")
def testBrokerOption(self):
testEnv = EventsEnvironment()
topic = testEnv.getLoggingTopic()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER=" + testEnv.getBroker() + "\n"
confStr += "log4j.appender.EA.TOPIC=" + topic + "\n"
self.configure(confStr)
recv = events.EventReceiver(testEnv.getBroker(), topic)
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.info("This is INFO")
log.debug("This is DEBUG")
log.MDCRemove("x")
self.assertValidMessage(recv.receiveEvent(), "This is TRACE")
self.assertValidMessage(recv.receiveEvent(), "This is INFO")
self.assertValidMessage(recv.receiveEvent(), "This is DEBUG")
def testBadPort(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
port = 1
testEnv = EventsEnvironment()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER="+broker+"\n"
confStr += "log4j.appender.EA.PORT="+str(port)+"\n"
self.assertConfigOutput(confStr, "log4cxx: Couldn't reach broker " + broker + " at port " + str(port))
def testQueueSelector(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
eventSystem = events.EventSystem.getDefaultEventSystem()
queue3 = self.createDestination("test_queue3")
runid = "id007"
eventSystem.createEnqueuer(broker, queue3)
eventSystem.createDequeuer(broker, queue3, "%s = '%s'" % (events.Event.RUNID, runid))
self.performEventSelectorTest(runid, queue3)
def testQueueSpecifiedPort(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
eventSystem = events.EventSystem.getDefaultEventSystem()
thisHost = platform.node()
# test with specified port
queue2 = self.createDestination("test_queues2")
eventSystem.createEnqueuer(broker, queue2, testEnv.getPort())
eventSystem.createDequeuer(broker, queue2, testEnv.getPort())
self.performEventTest(queue2)
def testTopicSelector(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
eventSystem = events.EventSystem.getDefaultEventSystem()
topic3 = self.createDestination("test_topics3")
runid = "id007"
eventSystem.createTransmitter(broker, topic3)
eventSystem.createReceiver(broker, topic3, "%s = '%s'" % (events.Event.RUNID, runid))
self.performEventSelectorTest(runid, topic3)
def testTopicDefault(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
eventSystem = events.EventSystem.getDefaultEventSystem()
# test with default port
topic1 = self.createDestination("test_topics1")
eventSystem.createTransmitter(broker, topic1)
eventSystem.createReceiver(broker, topic1)
self.performEventTest(topic1)
def testDestinationPropertyName(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
port = testEnv.getPort()
thisHost = platform.node()
topic = "test_events_queue3_%s_%d" % (thisHost, os.getpid())
recv = events.EventDequeuer(broker, topic, port);
trans = events.EventDequeuer(broker, topic, port);
self.assertEqual(events.Event.QUEUE, recv.getDestinationPropertyName());
self.assertEqual(events.Event.QUEUE, trans.getDestinationPropertyName());
def testFilterableStatusEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic = self.createTopicName("test_events_10_%s.B")
receiver = self.createReceiver(broker, topic)
#
# send a test event, and wait to receive it
#
self.sendFilterableStatusEvent(broker, topic)
val = receiver.receiveEvent()
self.assertIsNotNone(val)
def testQueueDefaultPort(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
eventSystem = events.EventSystem.getDefaultEventSystem()
# test with default port
queue1 = self.createDestination("test_queues1")
eventSystem = events.EventSystem.getDefaultEventSystem()
eventSystem.createEnqueuer(broker, queue1)
eventSystem.createDequeuer(broker, queue1)
self.performEventTest(queue1)
def testTopicSpecified(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
eventSystem = events.EventSystem.getDefaultEventSystem()
# test with specified port
topic2 = self.createDestination("test_topics2")
eventSystem.createTransmitter(broker, topic2, testEnv.getPort())
eventSystem.createReceiver(broker, topic2, testEnv.getPort())
self.performEventTest(topic2)
def testBadPort(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
port = 1
testEnv = EventsEnvironment()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER=" + broker + "\n"
confStr += "log4j.appender.EA.PORT=" + str(port) + "\n"
self.assertConfigOutput(
confStr, "log4cxx: Couldn't reach broker " + broker + " at port " +
str(port))
def testEventSystemReceive(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_%s_%d" % (thisHost, os.getpid())
eventSystem = events.EventSystem.getDefaultEventSystem()
eventSystem.createTransmitter(broker, topic)
eventSystem.createReceiver(broker, topic)
#
# send a test event, and wait to receive it
#
self.sendEvent(topic)
val = eventSystem.receiveEvent(topic)
self.assertIsNotNone(val)
cpNames = val.getCustomPropertyNames()
names = ["DATE", "PID", "HOST", "IP", "EVNT", "misc1", "misc2", "value", "array1", "array2", "array3"]
self.assertEqual(len(cpNames), len(names))
for x in names:
self.assertTrue(x in cpNames)
ps = val.getCustomPropertySet()
self.assertEqual(ps.nameCount(), len(names))
self.assertEqual(ps.get("DATE"), "2007-07-01T14:28:32.546012")
self.assertEqual(ps.get("PID"), 200)
self.assertEqual(ps.get("HOST"), "lsstcorp.org")
self.assertEqual(ps.get("IP"), "1.2.3.4")
self.assertEqual(ps.get("EVNT"), "test")
self.assertEqual(ps.get("misc1"), "data 1")
self.assertEqual(ps.get("misc2"), "data 2")
self.assertEqual(ps.get("value"), 3.14)
self.assertTupleEqual(ps.get("array1"), ('a', 'b', 'c', 'd'))
self.assertTupleEqual(ps.get("array2"), (1, 2, 3, 4, 5))
self.assertTupleEqual(ps.get("array3"), (6.1, 6.2, 6.3, 6.4, 6.5))
#
# wait a short time to receive an event. none was sent, so we should
# time out and confirm that we didn't get anything
#
val = eventSystem.receiveEvent(topic, 1000)
self.assertIsNone(val)
def testFilterableStatusEventWithRunID(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic = self.createTopicName("test_events_10_%s.D")
receiver = self.createReceiver(broker, topic)
self.sendFilterableStatusEvent(broker, topic, "test_runID_10")
val = receiver.receiveEvent()
# should receive an event
self.assertIsNotNone(val)
values = [events.Event.EVENTTIME, 'FOO', events.StatusEvent.ORIG_HOSTNAME, events.StatusEvent.ORIG_LOCALID, events.StatusEvent.ORIG_PROCESSID, 'PLOUGH', 'PLOVER', events.Event.PUBTIME, events.Event.RUNID, events.Event.STATUS, events.Event.TOPIC, events.Event.TYPE]
customValues = ['myname']
self.assertValid(val, values, customValues)
def testEventTransmitter(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_5_%s_%d" % (thisHost, os.getpid())
recv = events.EventReceiver(broker, topic)
# Integer tests
#
# send two test events
#
self.sendEvent(broker, topic, 300)
self.sendEvent(broker, topic, 200)
self.sendEvent(broker, topic, ( 6, 7, 8, 9, 6))
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 300 back
ps = val.getPropertySet()
self.assertEqual(ps.get("FOO"), 300)
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 200 back
ps = val.getPropertySet()
self.assertEqual(ps.get("FOO"), 200)
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 200 back
ps = val.getPropertySet()
self.assertTupleEqual(ps.get("FOO"), (6, 7, 8, 9, 6))
# check to see no other events are waiting
val = recv.receiveEvent(1)
self.assertIsNone(val)
def testEventTransmitter(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_5_%s_%d" % (thisHost, os.getpid())
recv = events.EventReceiver(broker, topic)
# Integer tests
#
# send two test events
#
self.sendEvent(broker, topic, 300)
self.sendEvent(broker, topic, 200)
self.sendEvent(broker, topic, (6, 7, 8, 9, 6))
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 300 back
ps = val.getPropertySet()
self.assertEqual(ps.get("FOO"), 300)
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 200 back
ps = val.getPropertySet()
self.assertEqual(ps.get("FOO"), 200)
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check to see we got 200 back
ps = val.getPropertySet()
self.assertTupleEqual(ps.get("FOO"), (6, 7, 8, 9, 6))
# check to see no other events are waiting
val = recv.receiveEvent(1)
self.assertIsNone(val)
def testFilterableStatusEventWithRunID(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic = self.createTopicName("test_events_10_%s.D")
receiver = self.createReceiver(broker, topic)
self.sendFilterableStatusEvent(broker, topic, "test_runID_10")
val = receiver.receiveEvent()
# should receive an event
self.assertIsNotNone(val)
values = [
events.Event.EVENTTIME, 'FOO', events.StatusEvent.ORIG_HOSTNAME,
events.StatusEvent.ORIG_LOCALID, events.StatusEvent.ORIG_PROCESSID,
'PLOUGH', 'PLOVER', events.Event.PUBTIME, events.Event.RUNID,
events.Event.STATUS, events.Event.TOPIC, events.Event.TYPE
]
customValues = ['myname']
self.assertValid(val, values, customValues)
def testPlainStatusEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic = self.createTopicName("test_events_10_%s.A")
receiver = self.createReceiver(broker, topic)
#
# send a test event, and wait to receive it
#
self.sendPlainStatusEvent(broker, topic)
val = receiver.receiveEvent()
self.assertIsNotNone(val)
values = [events.Event.EVENTTIME, events.StatusEvent.ORIG_HOSTNAME, events.StatusEvent.ORIG_LOCALID, events.StatusEvent.ORIG_PROCESSID, events.Event.PUBTIME, events.Event.STATUS, events.Event.TOPIC, events.Event.TYPE]
customValues = ['myname', 'logger']
self.assertValid(val, values, customValues)
self.assertNotEqual(val.getEventTime(), 0)
self.assertNotEqual(val.getPubTime(), 0)
self.assertGreater(val.getPubTime(), val.getEventTime())
self.assertEqual(val.getType(), events.EventTypes.STATUS)
def testCombinedEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic1 = "test_events_3_%s_%d" % (platform.node(), os.getpid())
topic2 = "test_events_3a_%s_%d" % (platform.node(), os.getpid())
combinedTopic = topic1 + "," + topic2
eventSystem = events.EventSystem.getDefaultEventSystem()
eventSystem.createReceiver(broker, topic1)
eventSystem.createReceiver(broker, topic2)
eventSystem.createTransmitter(broker, combinedTopic)
#
# send a test event on both topics at once, and have each receiver wait to
# receive it
#
self.sendEvent(combinedTopic)
val = eventSystem.receiveEvent(topic1)
self.assertIsNotNone(val)
val = eventSystem.receiveEvent(topic2)
self.assertIsNotNone(val)
def testCombinedEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
topic1 = "test_events_3_%s_%d" % (platform.node(), os.getpid())
topic2 = "test_events_3a_%s_%d" % (platform.node(), os.getpid())
combinedTopic = topic1 + "," + topic2
eventSystem = events.EventSystem.getDefaultEventSystem()
eventSystem.createReceiver(broker, topic1)
eventSystem.createReceiver(broker, topic2)
eventSystem.createTransmitter(broker, combinedTopic)
#
# send a test event on both topics at once, and have each receiver wait to
# receive it
#
self.sendEvent(combinedTopic)
val = eventSystem.receiveEvent(topic1)
self.assertIsNotNone(val)
val = eventSystem.receiveEvent(topic2)
self.assertIsNotNone(val)
def testStatusEventOriginator(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_12_%s_%d" % (thisHost, os.getpid())
recv = events.EventReceiver(broker, topic)
#
# send a test event, and wait to receive it
#
self.sendEvent(broker, topic)
val = recv.receiveEvent()
self.assertIsNotNone(val)
eventSystem = events.EventSystem.getDefaultEventSystem()
statusevent = eventSystem.castToStatusEvent(val)
originatorID = statusevent.getOriginator()
self.assertEqual(originatorID.getLocalID(), 0)
self.assertEqual(originatorID.getProcessID(), os.getpid())
self.assertEqual(platform.node(), originatorID.getHostName())
def testLockRelease(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
flag = Flag()
t = EventThread(broker, flag)
# wait until the thread has started up
with flag.lock:
# print "starting thread"
flag.markers.append("thread starting")
t.start()
flag.lock.wait(2.0)
# by the time we wake up, the other thread should be listening
# for an event (that will never come :-o)
time.sleep(0.2)
# print "waiting for receive"
# sys.stdout.flush()
flag.markers.append("waiting")
t.join()
self.assertEquals(flag.markers[2], "waiting",
"receive failed to release GIL")
def testLockRelease(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
flag = Flag()
t = EventThread(broker, flag)
# wait until the thread has started up
with flag.lock:
# print "starting thread"
flag.markers.append("thread starting")
t.start()
flag.lock.wait(2.0)
# by the time we wake up, the other thread should be listening
# for an event (that will never come :-o)
time.sleep(0.2)
# print "waiting for receive"
# sys.stdout.flush()
flag.markers.append("waiting")
t.join()
self.assertEquals(flag.markers[2], "waiting",
"receive failed to release GIL")
def testCommandEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_command_%s_%d" % (thisHost, os.getpid())
# send a command event
receiver = events.EventReceiver(broker, topic)
trans = events.EventTransmitter(broker, topic)
originatorId = events.LocationId()
root = PropertySet()
root.set(events.StatusEvent.TOPIC,topic)
root.set("myname","myname")
root.set(events.StatusEvent.STATUS, "my special status")
event = events.StatusEvent("srptestrun", originatorId, root)
statusOriginatorId = event.getOriginator()
destinationID = events.LocationId(statusOriginatorId)
commandOriginatorID = events.LocationId()
root2 = PropertySet()
root2.set(events.CommandEvent.TOPIC,topic)
root2.set("myname","myname2")
root2.set(events.CommandEvent.STATUS, "my special status2")
event2 = events.CommandEvent("srptestrun", commandOriginatorID, destinationID, root2)
trans.publishEvent(event2)
val = receiver.receiveCommandEvent()
# be sure we received an event
self.assertIsNotNone(val)
# these are the filterable names we expect to see
names = [events.CommandEvent.DEST_HOSTNAME, events.CommandEvent.DEST_LOCALID, events.CommandEvent.DEST_PROCESSID,
events.CommandEvent.EVENTTIME, events.CommandEvent.ORIG_HOSTNAME, events.CommandEvent.ORIG_LOCALID,
events.CommandEvent.ORIG_PROCESSID, events.CommandEvent.PUBTIME, events.CommandEvent.RUNID,
events.CommandEvent.STATUS, events.CommandEvent.TOPIC, events.CommandEvent.TYPE]
self.assertValid(val, names, commandOriginatorID.getLocalID(), destinationID.getLocalID())
# send a command event with additional filterable properties
receiver = events.EventReceiver(broker, topic)
trans = events.EventTransmitter(broker, topic)
originatorId = events.LocationId()
event = events.StatusEvent("srptestrun", originatorId, root)
statusOriginatorId = event.getOriginator()
destinationID = events.LocationId(statusOriginatorId)
commandOriginatorID = events.LocationId()
filterable = PropertySet()
filterable.set("FOO", 12.3)
filterable.set("BAR", .45)
event2 = events.CommandEvent("srptestrun", commandOriginatorID, destinationID, root2, filterable)
trans.publishEvent(event2)
val = receiver.receiveCommandEvent()
# be sure we received an event
self.assertIsNotNone(val)
# these are the filterable names we expect to see
names = [events.CommandEvent.DEST_HOSTNAME, events.CommandEvent.DEST_LOCALID, events.CommandEvent.DEST_PROCESSID,
events.CommandEvent.EVENTTIME, events.CommandEvent.ORIG_HOSTNAME, events.CommandEvent.ORIG_LOCALID,
events.CommandEvent.ORIG_PROCESSID, events.CommandEvent.PUBTIME, events.CommandEvent.RUNID,
events.CommandEvent.STATUS, events.CommandEvent.TOPIC, events.CommandEvent.TYPE, 'FOO', 'BAR']
self.assertValid(val, names, commandOriginatorID.getLocalID(), destinationID.getLocalID())
self.assertTrue(event.getType(), events.EventTypes.COMMAND)
def testSendEvent(self):
"""Send an Event"""
testEnv = EventsEnvironment()
self.thisHost = platform.node()
self.broker = testEnv.getBroker()
topic = "test_events_3_%s_%d" % (self.thisHost, os.getpid())
runID = "test3_runid"
recv = events.EventReceiver(self.broker, topic)
trans = events.EventTransmitter(self.broker, topic)
DATE = "date"
DATE_VAL = "2007-07-01T14:28:32.546012"
BLANK = "blank"
BLANK_VAL = ""
PID = "pid"
PID_VAL = os.getpid()
HOST = "host"
HOST_VAL = "lsstcorp.org"
IP = "ip"
IP_VAL = "1.2.3.4"
EVNT = "evnt"
EVNT_VAL = "test"
MISC1 = "misc1"
MISC1_VAL = "data 1"
MISC2 = "misc2"
MISC2_VAL = "data 2"
MISC3 = "misc3"
MISC3_VAL = ""
DATA = "data"
DATA_VAL = 3.14
root = PropertySet()
root.set(DATE, DATE_VAL)
root.set(BLANK, BLANK_VAL)
root.setInt(PID, PID_VAL)
root.set(HOST, HOST_VAL)
root.set(IP, IP_VAL)
root.set(EVNT, EVNT_VAL)
root.set(MISC1, MISC1_VAL)
root.set(MISC2, MISC2_VAL)
root.set(MISC3, MISC3_VAL)
root.setDouble(DATA, DATA_VAL)
event = events.Event(runID, root)
trans.publishEvent(event)
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check the validity of all sent values
ps = val.getPropertySet()
self.assertEqual(ps.get(DATE), DATE_VAL)
self.assertEqual(ps.get(BLANK), BLANK_VAL)
self.assertEqual(ps.get(PID), PID_VAL)
self.assertEqual(ps.get(HOST), HOST_VAL)
self.assertEqual(ps.get(IP), IP_VAL)
self.assertEqual(ps.get(EVNT), EVNT_VAL)
self.assertEqual(ps.get(MISC1), MISC1_VAL)
self.assertEqual(ps.get(MISC2), MISC2_VAL)
self.assertEqual(ps.get(MISC3), MISC3_VAL)
self.assertEqual(ps.get(DATA), DATA_VAL)
self.assertGreater(ps.get(events.Event.EVENTTIME), 0)
self.assertGreater(ps.get(events.Event.PUBTIME), 0)
self.assertEqual(ps.get(events.Event.RUNID), runID)
self.assertEqual(ps.get(events.Event.STATUS), "unknown")
self.assertEqual(ps.get(events.Event.TOPIC), topic)
self.assertEqual(ps.get(events.Event.TYPE), events.EventTypes.EVENT)
#
# wait a short time to receive an event. none was sent, so we should
# time out and confirm that we didn't get anything
#
val = recv.receiveEvent(1000)
self.assertIsNone(val)
def testLocationId(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
locationID = events.LocationId()
# check to see if localID is 0
localId = locationID.getLocalID()
self.assertEqual(localId, 0)
# check host name
hostname = locationID.getHostName()
self.assertEqual(hostname, socket.gethostname())
# check process id
processId = locationID.getProcessID()
self.assertEqual(processId, os.getpid())
locationID2 = events.LocationId()
# check to see if localID is 1
localId = locationID2.getLocalID()
self.assertEqual(localId, 1)
self.assertEqual(locationID.getLocalID(), 0)
# check host name
hostname = locationID.getHostName()
self.assertEqual(hostname, socket.gethostname())
# check process id
processId = locationID2.getProcessID()
self.assertEqual(processId, os.getpid())
root = PropertySet()
root.set("myname", "myname")
status = "my special status"
root.set(events.Event.STATUS, status)
statusEvent = events.StatusEvent("my runid", locationID, root)
statusEvent2 = events.StatusEvent("my runid", locationID2, root)
topic = "mytopic_%s_%d" % (thisHost, os.getpid())
transmitter = events.EventTransmitter(broker, topic)
hostname = locationID2.getHostName()
# create a receiver selector with the hostname, process id and local id
sel = "%s = '%s' and %s = %d and %s = %d" % (
events.StatusEvent.ORIG_HOSTNAME, hostname,
events.StatusEvent.ORIG_PROCESSID, os.getpid(),
events.StatusEvent.ORIG_LOCALID, 1)
receiver = events.EventReceiver(broker, topic, sel)
# transmit the events
transmitter.publishEvent(statusEvent)
transmitter.publishEvent(statusEvent2)
# should receive event with with the process id
returnedEvent = receiver.receiveEvent()
ps = returnedEvent.getPropertySet()
self.assertEqual(ps.get('ORIG_HOSTNAME'), hostname)
self.assertEqual(ps.get('ORIG_PROCESSID'), os.getpid())
self.assertEqual(ps.get('ORIG_LOCALID'), 1)
# should NOT receive another event, because it was filtered out by
# the broker
returnedEvent2 = receiver.receiveEvent(1)
self.assertIsNone(returnedEvent2)
def testFilterableSendEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_filters_%s_%d" % (thisHost, os.getpid())
runId = "test_filters_runid"
recv = events.EventReceiver(broker, topic)
trans = events.EventTransmitter(broker, topic)
root = PropertySet()
DATE = "date"
DATE_VAL = "2007-07-01T14:28:32.546012"
root.set(DATE, DATE_VAL)
BLANK = "blank"
BLANK_VAL = ""
root.set(BLANK, BLANK_VAL)
PID = "pid"
PID_VAL = os.getpid()
root.setInt(PID, PID_VAL)
HOST = "host"
HOST_VAL = "lsstcorp.org"
root.set(HOST, HOST_VAL)
IP = "ip"
IP_VAL = "1.2.3.4"
root.set(IP, IP_VAL)
EVNT = "evnt"
EVNT_VAL = "test"
root.set(EVNT, EVNT_VAL)
MISC1 = "misc1"
MISC1_VAL = "data 1"
root.set(MISC1, MISC1_VAL)
MISC2 = "misc2"
MISC2_VAL = "data 2"
root.set(MISC2, MISC2_VAL)
MISC3 = "misc3"
MISC3_VAL = ""
root.set(MISC3, MISC3_VAL)
DATA = "data"
DATA_VAL = 3.14
root.setDouble(DATA, DATA_VAL)
filterable = PropertySet()
filterable.set("FOO", "bar")
filterable.set("XYZZY", 123)
filterable.set("PLOUGH", 0.867)
event = events.Event(runId, root, filterable)
trans.publishEvent(event)
val = recv.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
self.assertEqual(ps.get(DATE), DATE_VAL)
self.assertEqual(ps.get(BLANK), BLANK_VAL)
self.assertEqual(ps.get(PID), PID_VAL)
self.assertEqual(ps.get(HOST), HOST_VAL)
self.assertEqual(ps.get(IP), IP_VAL)
self.assertEqual(ps.get(EVNT), EVNT_VAL)
self.assertEqual(ps.get(MISC1), MISC1_VAL)
self.assertEqual(ps.get(MISC2), MISC2_VAL)
self.assertEqual(ps.get(MISC3), MISC3_VAL)
self.assertEqual(ps.get(DATA), DATA_VAL)
self.assertGreater(ps.get(events.Event.EVENTTIME), 0)
self.assertGreater(ps.get(events.Event.PUBTIME), 0)
self.assertEqual(ps.get(events.Event.RUNID), runId)
self.assertEqual(ps.get(events.Event.STATUS), "unknown")
self.assertEqual(ps.get(events.Event.TOPIC), topic)
self.assertEqual(ps.get(events.Event.TYPE), events.EventTypes.EVENT)
self.assertEqual(ps.get("FOO"), "bar")
self.assertEqual(ps.get("XYZZY"), 123)
self.assertEqual(ps.get("PLOUGH"), 0.867)
names = val.getFilterablePropertyNames()
values = [
events.Event.EVENTTIME, 'FOO', 'PLOUGH', events.Event.PUBTIME,
events.Event.RUNID, events.Event.STATUS, events.Event.TOPIC,
events.Event.TYPE, 'XYZZY'
]
for x in values:
self.assertTrue(x in names)
#
# wait a short time to receive an event. none was sent, so we should
# time out and confirm that we didn't get anything
#
val = recv.receiveEvent(1000)
self.assertIsNone(val)
def testCombinedReceive(self):
# Test sending on two topics, and receiving bother on a third.
#
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
pid = os.getpid()
host_pid = "%s_%d" % (thisHost,pid)
topicA = "test_events_9_%s.A" % host_pid
topicB = "test_events_9_%s.B" % host_pid
topicC = "test_events_9_%s.*" % host_pid
recvA = events.EventReceiver(broker, topicA)
recvB = events.EventReceiver(broker, topicB)
recvC = events.EventReceiver(broker, topicC)
# send a test event on topicA and topicB
self.sendEvent(broker, topicA)
self.sendEvent(broker, topicB)
# receive event on topicA, and check to see it's the right one
val = recvA.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicA)
# receiving no more messages on topicA
val = recvA.receiveEvent(1)
self.assertIsNone(val)
# receive event on topicB, and check to see it's the right one
val = recvB.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicB)
# receiving no more messages on topicB
val = recvB.receiveEvent(1)
self.assertIsNone(val)
# receive event on topicC, and check to see it's the one sent to topicA
val = recvC.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicA)
# receive event on topicC, and check to see it's the one sent to topicB
val = recvC.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicB)
# receiving no more messages on topicC
val = recvC.receiveEvent(1)
self.assertIsNone(val)
def testCombinedReceive(self):
# Test sending on two topics, and receiving bother on a third.
#
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
pid = os.getpid()
host_pid = "%s_%d" % (thisHost, pid)
topicA = "test_events_9_%s.A" % host_pid
topicB = "test_events_9_%s.B" % host_pid
topicC = "test_events_9_%s.*" % host_pid
recvA = events.EventReceiver(broker, topicA)
recvB = events.EventReceiver(broker, topicB)
recvC = events.EventReceiver(broker, topicC)
# send a test event on topicA and topicB
self.sendEvent(broker, topicA)
self.sendEvent(broker, topicB)
# receive event on topicA, and check to see it's the right one
val = recvA.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicA)
# receiving no more messages on topicA
val = recvA.receiveEvent(1)
self.assertIsNone(val)
# receive event on topicB, and check to see it's the right one
val = recvB.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicB)
# receiving no more messages on topicB
val = recvB.receiveEvent(1)
self.assertIsNone(val)
# receive event on topicC, and check to see it's the one sent to topicA
val = recvC.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicA)
# receive event on topicC, and check to see it's the one sent to topicB
val = recvC.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
name = ps.get(events.Event.TOPIC)
self.assertEqual(name, topicB)
# receiving no more messages on topicC
val = recvC.receiveEvent(1)
self.assertIsNone(val)
def testSendEvent(self):
"""Send an Event"""
testEnv = EventsEnvironment()
self.thisHost = platform.node()
self.broker = testEnv.getBroker()
topic = "test_events_3_%s_%d" % (self.thisHost, os.getpid())
runID = "test3_runid"
recv = events.EventReceiver(self.broker, topic)
trans = events.EventTransmitter(self.broker, topic)
DATE = "date"
DATE_VAL = "2007-07-01T14:28:32.546012"
BLANK = "blank"
BLANK_VAL = ""
PID = "pid"
PID_VAL = os.getpid()
HOST = "host"
HOST_VAL = "lsstcorp.org"
IP = "ip"
IP_VAL = "1.2.3.4"
EVNT = "evnt"
EVNT_VAL = "test"
MISC1 = "misc1"
MISC1_VAL = "data 1"
MISC2 = "misc2"
MISC2_VAL = "data 2"
MISC3 = "misc3"
MISC3_VAL = ""
DATA = "data"
DATA_VAL = 3.14
root = PropertySet()
root.set(DATE, DATE_VAL)
root.set(BLANK, BLANK_VAL)
root.setInt(PID, PID_VAL)
root.set(HOST, HOST_VAL)
root.set(IP, IP_VAL)
root.set(EVNT, EVNT_VAL)
root.set(MISC1, MISC1_VAL)
root.set(MISC2, MISC2_VAL)
root.set(MISC3, MISC3_VAL)
root.setDouble(DATA, DATA_VAL)
event = events.Event(runID, root)
trans.publishEvent(event)
val = recv.receiveEvent()
self.assertIsNotNone(val)
# check the validity of all sent values
ps = val.getPropertySet()
self.assertEqual(ps.get(DATE), DATE_VAL)
self.assertEqual(ps.get(BLANK), BLANK_VAL)
self.assertEqual(ps.get(PID), PID_VAL)
self.assertEqual(ps.get(HOST), HOST_VAL)
self.assertEqual(ps.get(IP), IP_VAL)
self.assertEqual(ps.get(EVNT), EVNT_VAL)
self.assertEqual(ps.get(MISC1), MISC1_VAL)
self.assertEqual(ps.get(MISC2), MISC2_VAL)
self.assertEqual(ps.get(MISC3), MISC3_VAL)
self.assertEqual(ps.get(DATA), DATA_VAL)
self.assertGreater(ps.get(events.Event.EVENTTIME), 0)
self.assertGreater(ps.get(events.Event.PUBTIME), 0)
self.assertEqual(ps.get(events.Event.RUNID), runID)
self.assertEqual(ps.get(events.Event.STATUS), "unknown")
self.assertEqual(ps.get(events.Event.TOPIC), topic)
self.assertEqual(ps.get(events.Event.TYPE), events.EventTypes.EVENT)
#
# wait a short time to receive an event. none was sent, so we should
# time out and confirm that we didn't get anything
#
val = recv.receiveEvent(1000)
self.assertIsNone(val)
def testLocationId(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
locationID = events.LocationId()
# check to see if localID is 0
localId = locationID.getLocalID()
self.assertEqual(localId, 0)
# check host name
hostname = locationID.getHostName()
self.assertEqual(hostname, socket.gethostname())
# check process id
processId = locationID.getProcessID()
self.assertEqual(processId, os.getpid())
locationID2 = events.LocationId()
# check to see if localID is 1
localId = locationID2.getLocalID()
self.assertEqual(localId, 1)
self.assertEqual(locationID.getLocalID(), 0)
# check host name
hostname = locationID.getHostName()
self.assertEqual(hostname, socket.gethostname())
# check process id
processId = locationID2.getProcessID()
self.assertEqual(processId, os.getpid())
root = PropertySet()
root.set("myname","myname")
status = "my special status"
root.set(events.Event.STATUS, status)
statusEvent = events.StatusEvent("my runid", locationID, root)
statusEvent2 = events.StatusEvent("my runid", locationID2, root)
topic = "mytopic_%s_%d" % (thisHost, os.getpid())
transmitter = events.EventTransmitter(broker, topic)
hostname = locationID2.getHostName()
# create a receiver selector with the hostname, process id and local id
sel = "%s = '%s' and %s = %d and %s = %d" % (events.StatusEvent.ORIG_HOSTNAME, hostname, events.StatusEvent.ORIG_PROCESSID, os.getpid(), events.StatusEvent.ORIG_LOCALID, 1)
receiver = events.EventReceiver(broker, topic, sel)
# transmit the events
transmitter.publishEvent(statusEvent)
transmitter.publishEvent(statusEvent2)
# should receive event with with the process id
returnedEvent = receiver.receiveEvent()
ps = returnedEvent.getPropertySet()
self.assertEqual(ps.get('ORIG_HOSTNAME'), hostname)
self.assertEqual(ps.get('ORIG_PROCESSID'), os.getpid())
self.assertEqual(ps.get('ORIG_LOCALID'), 1)
# should NOT receive another event, because it was filtered out by
# the broker
returnedEvent2 = receiver.receiveEvent(1)
self.assertIsNone(returnedEvent2)
def testRunidSelector(self):
testEnv = EventsEnvironment()
topic = testEnv.getLoggingTopic()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER=" + testEnv.getBroker() + "\n"
confStr += "log4j.appender.EA.RUNID=" + str(os.getpid()) + "\n"
confStr += "log4j.appender.EA.TOPIC=" + topic + "\n"
self.configure(confStr)
# receive for all events
recvALL = events.EventReceiver(testEnv.getBroker(), topic)
# receive for events for this runid
recv = events.EventReceiver(testEnv.getBroker(), topic,
"RUNID = '%s'" % str(os.getpid()))
# send log messages
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.info("This is INFO")
log.debug("This is DEBUG")
log.MDCRemove("x")
# make sure we got all the events we should have
self.assertValidMessage(recv.receiveEvent(), "This is TRACE")
self.assertValidMessage(recv.receiveEvent(), "This is INFO")
self.assertValidMessage(recv.receiveEvent(), "This is DEBUG")
# make sure we didn't get any more than we should have
ev = recv.receiveEvent(100)
self.assertIsNone(ev)
# reconfigure with a new run id
confStr2 = "log4j.rootLogger=TRACE, EA\n"
confStr2 += "log4j.appender.EA=EventAppender\n"
confStr2 += "log4j.appender.EA.BROKER=" + testEnv.getBroker() + "\n"
confStr2 += "log4j.appender.EA.RUNID=" + "blah_" + str(
os.getpid()) + "\n"
confStr2 += "log4j.appender.EA.TOPIC=" + topic + "\n"
self.configure(confStr2)
# set up a receiver for the new run id
recv2 = events.EventReceiver(testEnv.getBroker(), topic,
"RUNID = 'blah_%s'" % str(os.getpid()))
# send log messages
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.info("This is INFO")
log.debug("This is DEBUG")
log.MDCRemove("x")
# make sure we didn't receive any events from another run id
ev = recv.receiveEvent(100)
self.assertIsNone(ev)
# make sure we got all the events we should have
self.assertValidMessage(recv2.receiveEvent(), "This is TRACE")
self.assertValidMessage(recv2.receiveEvent(), "This is INFO")
self.assertValidMessage(recv2.receiveEvent(), "This is DEBUG")
# make sure we didn't get any more than we should have
ev = recv2.receiveEvent(100)
self.assertIsNone(ev)
# make sure we got all the events, for all messages on this topic
self.assertValidMessage(recvALL.receiveEvent(), "This is TRACE")
self.assertValidMessage(recvALL.receiveEvent(), "This is INFO")
self.assertValidMessage(recvALL.receiveEvent(), "This is DEBUG")
self.assertValidMessage(recvALL.receiveEvent(), "This is TRACE")
self.assertValidMessage(recvALL.receiveEvent(), "This is INFO")
self.assertValidMessage(recvALL.receiveEvent(), "This is DEBUG")
# make sure we didn't get any more than we should have
ev = recvALL.receiveEvent(100)
self.assertIsNone(ev)
def testCommandEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_command_%s_%d" % (thisHost, os.getpid())
# send a command event
receiver = events.EventReceiver(broker, topic)
trans = events.EventTransmitter(broker, topic)
originatorId = events.LocationId()
root = PropertySet()
root.set(events.StatusEvent.TOPIC, topic)
root.set("myname", "myname")
root.set(events.StatusEvent.STATUS, "my special status")
event = events.StatusEvent("srptestrun", originatorId, root)
statusOriginatorId = event.getOriginator()
destinationID = events.LocationId(statusOriginatorId)
commandOriginatorID = events.LocationId()
root2 = PropertySet()
root2.set(events.CommandEvent.TOPIC, topic)
root2.set("myname", "myname2")
root2.set(events.CommandEvent.STATUS, "my special status2")
event2 = events.CommandEvent("srptestrun", commandOriginatorID,
destinationID, root2)
trans.publishEvent(event2)
val = receiver.receiveCommandEvent()
# be sure we received an event
self.assertIsNotNone(val)
# these are the filterable names we expect to see
names = [
events.CommandEvent.DEST_HOSTNAME,
events.CommandEvent.DEST_LOCALID,
events.CommandEvent.DEST_PROCESSID, events.CommandEvent.EVENTTIME,
events.CommandEvent.ORIG_HOSTNAME,
events.CommandEvent.ORIG_LOCALID,
events.CommandEvent.ORIG_PROCESSID, events.CommandEvent.PUBTIME,
events.CommandEvent.RUNID, events.CommandEvent.STATUS,
events.CommandEvent.TOPIC, events.CommandEvent.TYPE
]
self.assertValid(val, names, commandOriginatorID.getLocalID(),
destinationID.getLocalID())
# send a command event with additional filterable properties
receiver = events.EventReceiver(broker, topic)
trans = events.EventTransmitter(broker, topic)
originatorId = events.LocationId()
event = events.StatusEvent("srptestrun", originatorId, root)
statusOriginatorId = event.getOriginator()
destinationID = events.LocationId(statusOriginatorId)
commandOriginatorID = events.LocationId()
filterable = PropertySet()
filterable.set("FOO", 12.3)
filterable.set("BAR", .45)
event2 = events.CommandEvent("srptestrun", commandOriginatorID,
destinationID, root2, filterable)
trans.publishEvent(event2)
val = receiver.receiveCommandEvent()
# be sure we received an event
self.assertIsNotNone(val)
# these are the filterable names we expect to see
names = [
events.CommandEvent.DEST_HOSTNAME,
events.CommandEvent.DEST_LOCALID,
events.CommandEvent.DEST_PROCESSID, events.CommandEvent.EVENTTIME,
events.CommandEvent.ORIG_HOSTNAME,
events.CommandEvent.ORIG_LOCALID,
events.CommandEvent.ORIG_PROCESSID, events.CommandEvent.PUBTIME,
events.CommandEvent.RUNID, events.CommandEvent.STATUS,
events.CommandEvent.TOPIC, events.CommandEvent.TYPE, 'FOO', 'BAR'
]
self.assertValid(val, names, commandOriginatorID.getLocalID(),
destinationID.getLocalID())
self.assertTrue(event.getType(), events.EventTypes.COMMAND)
def testFilterableSendEvent(self):
testEnv = EventsEnvironment()
broker = testEnv.getBroker()
thisHost = platform.node()
topic = "test_events_filters_%s_%d" % (thisHost, os.getpid())
runId = "test_filters_runid"
recv = events.EventReceiver(broker, topic)
trans = events.EventTransmitter(broker, topic)
root = PropertySet()
DATE = "date"
DATE_VAL = "2007-07-01T14:28:32.546012"
root.set(DATE, DATE_VAL)
BLANK = "blank"
BLANK_VAL = ""
root.set(BLANK, BLANK_VAL)
PID = "pid"
PID_VAL = os.getpid()
root.setInt(PID, PID_VAL)
HOST = "host"
HOST_VAL = "lsstcorp.org"
root.set(HOST, HOST_VAL)
IP = "ip"
IP_VAL = "1.2.3.4"
root.set(IP, IP_VAL)
EVNT = "evnt"
EVNT_VAL = "test"
root.set(EVNT, EVNT_VAL)
MISC1 = "misc1"
MISC1_VAL = "data 1"
root.set(MISC1, MISC1_VAL)
MISC2 = "misc2"
MISC2_VAL = "data 2"
root.set(MISC2, MISC2_VAL)
MISC3 = "misc3"
MISC3_VAL = ""
root.set(MISC3, MISC3_VAL)
DATA = "data"
DATA_VAL = 3.14
root.setDouble(DATA, DATA_VAL)
filterable = PropertySet()
filterable.set("FOO", "bar")
filterable.set("XYZZY", 123)
filterable.set("PLOUGH", 0.867)
event = events.Event(runId, root, filterable)
trans.publishEvent(event)
val = recv.receiveEvent()
self.assertIsNotNone(val)
ps = val.getPropertySet()
self.assertEqual(ps.get(DATE), DATE_VAL)
self.assertEqual(ps.get(BLANK), BLANK_VAL)
self.assertEqual(ps.get(PID), PID_VAL)
self.assertEqual(ps.get(HOST), HOST_VAL)
self.assertEqual(ps.get(IP), IP_VAL)
self.assertEqual(ps.get(EVNT), EVNT_VAL)
self.assertEqual(ps.get(MISC1), MISC1_VAL)
self.assertEqual(ps.get(MISC2), MISC2_VAL)
self.assertEqual(ps.get(MISC3), MISC3_VAL)
self.assertEqual(ps.get(DATA), DATA_VAL)
self.assertGreater(ps.get(events.Event.EVENTTIME), 0)
self.assertGreater(ps.get(events.Event.PUBTIME), 0)
self.assertEqual(ps.get(events.Event.RUNID), runId)
self.assertEqual(ps.get(events.Event.STATUS), "unknown")
self.assertEqual(ps.get(events.Event.TOPIC), topic)
self.assertEqual(ps.get(events.Event.TYPE), events.EventTypes.EVENT)
self.assertEqual(ps.get("FOO"), "bar")
self.assertEqual(ps.get("XYZZY"), 123)
self.assertEqual(ps.get("PLOUGH"), 0.867)
names = val.getFilterablePropertyNames()
values = [events.Event.EVENTTIME, 'FOO', 'PLOUGH', events.Event.PUBTIME, events.Event.RUNID, events.Event.STATUS,
events.Event.TOPIC, events.Event.TYPE, 'XYZZY']
for x in values:
self.assertTrue(x in names)
#
# wait a short time to receive an event. none was sent, so we should
# time out and confirm that we didn't get anything
#
val = recv.receiveEvent(1000)
self.assertIsNone(val)
def testRunidSelector(self):
testEnv = EventsEnvironment()
topic = testEnv.getLoggingTopic()
confStr = "log4j.rootLogger=TRACE, EA\n"
confStr += "log4j.appender.EA=EventAppender\n"
confStr += "log4j.appender.EA.BROKER="+testEnv.getBroker()+"\n"
confStr += "log4j.appender.EA.RUNID="+str(os.getpid())+"\n";
confStr += "log4j.appender.EA.TOPIC="+topic+"\n"
self.configure(confStr)
# receive for all events
recvALL = events.EventReceiver(testEnv.getBroker(), topic)
# receive for events for this runid
recv = events.EventReceiver(testEnv.getBroker(), topic, "RUNID = '%s'" % str(os.getpid()))
# send log messages
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.info("This is INFO")
log.debug("This is DEBUG")
log.MDCRemove("x")
# make sure we got all the events we should have
self.assertValidMessage(recv.receiveEvent(), "This is TRACE")
self.assertValidMessage(recv.receiveEvent(), "This is INFO")
self.assertValidMessage(recv.receiveEvent(), "This is DEBUG")
# make sure we didn't get any more than we should have
ev = recv.receiveEvent(100)
self.assertIsNone(ev)
# reconfigure with a new run id
confStr2 = "log4j.rootLogger=TRACE, EA\n"
confStr2 += "log4j.appender.EA=EventAppender\n"
confStr2 += "log4j.appender.EA.BROKER="+testEnv.getBroker()+"\n"
confStr2 += "log4j.appender.EA.RUNID="+"blah_"+str(os.getpid())+"\n";
confStr2 += "log4j.appender.EA.TOPIC="+topic+"\n"
self.configure(confStr2)
# set up a receiver for the new run id
recv2 = events.EventReceiver(testEnv.getBroker(), topic, "RUNID = 'blah_%s'" % str(os.getpid()))
# send log messages
log.MDC("x", 3)
with log.LogContext("component"):
log.trace("This is TRACE")
log.info("This is INFO")
log.debug("This is DEBUG")
log.MDCRemove("x")
# make sure we didn't receive any events from another run id
ev = recv.receiveEvent(100)
self.assertIsNone(ev)
# make sure we got all the events we should have
self.assertValidMessage(recv2.receiveEvent(), "This is TRACE")
self.assertValidMessage(recv2.receiveEvent(), "This is INFO")
self.assertValidMessage(recv2.receiveEvent(), "This is DEBUG")
# make sure we didn't get any more than we should have
ev = recv2.receiveEvent(100)
self.assertIsNone(ev)
# make sure we got all the events, for all messages on this topic
self.assertValidMessage(recvALL.receiveEvent(), "This is TRACE")
self.assertValidMessage(recvALL.receiveEvent(), "This is INFO")
self.assertValidMessage(recvALL.receiveEvent(), "This is DEBUG")
self.assertValidMessage(recvALL.receiveEvent(), "This is TRACE")
self.assertValidMessage(recvALL.receiveEvent(), "This is INFO")
self.assertValidMessage(recvALL.receiveEvent(), "This is DEBUG")
# make sure we didn't get any more than we should have
ev = recvALL.receiveEvent(100)
self.assertIsNone(ev)
