def performEventSelectorTest(self, runid, destination):
eventSystem = events.EventSystem.getDefaultEventSystem()
prop = self.createPropertySet()
# create and publish an event without a runid
event = events.Event(prop)
eventSystem.publishEvent(destination, event)
# attempt to receive the event, which shouldn't arrive, because the
# destination we send this to has a RUNID selector associated with
# it, which this event didn't have.
receivedEvent = eventSystem.receiveEvent(destination, 20)
self.assertIsNone(receivedEvent)
# create and publish an event with a runid
event = events.Event(runid, prop)
eventSystem.publishEvent(destination, event)
# attempt to receive the event, which SHOULD arrive, because we
# specified the RUNID
receivedEvent = eventSystem.receiveEvent(destination, 20)
self.assertIsNotNone(receivedEvent)
# should be able to get the PropertySet we sent
recvProp = receivedEvent.getPropertySet()
self.assertIsNotNone(recvProp)
# verify the RUNID
self.assertEqual(recvProp.get(events.Event.RUNID), runid)
# verify the other PropertySet contents
self.verifyPropertySet(recvProp)
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 testEventRunID(self):
runid = "testrunid"
status = "my special status"
root = PropertySet()
MYNAME = "myname"
root.set(MYNAME, MYNAME)
root.set(events.Event.STATUS, status)
event = events.Event(runid, root)
# return the property set
props = event.getPropertySet()
self.assertGreater(props.get(events.Event.EVENTTIME), 0)
self.assertEqual(props.get(events.Event.PUBTIME), 0)
self.assertEqual(props.get(events.Event.RUNID), runid)
self.assertEqual(props.get(events.Event.STATUS), status)
self.assertEqual(props.get(events.Event.TOPIC),
events.Event.UNINITIALIZED)
self.assertEqual(props.get(events.Event.TYPE), events.EventTypes.EVENT)
self.assertEqual(props.get(MYNAME), MYNAME)
filterableNames = event.getFilterablePropertyNames()
filterableNames.remove(events.Event.EVENTTIME)
filterableNames.remove(events.Event.PUBTIME)
filterableNames.remove(events.Event.RUNID)
filterableNames.remove(events.Event.STATUS)
filterableNames.remove(events.Event.TOPIC)
filterableNames.remove(events.Event.TYPE)
assert len(filterableNames) == 0
customNames = event.getCustomPropertyNames()
self.assertEqual(len(customNames), 1)
self.assertEqual(customNames[0], MYNAME)
eventTime = event.getEventTime()
self.assertEqual(event.getPubTime(), 0)
self.assertEqual(event.getRunId(), runid)
self.assertEqual(event.getType(), events.EventTypes.EVENT)
self.assertEqual(event.getStatus(), status)
# check to be sure we really update the time
event.updateEventTime()
self.assertLess(eventTime, event.getEventTime())
# set the time to zero, and make sure we get back the same time.
event.setEventTime(0)
self.assertEqual(event.getEventTime(), 0)
# reset the time to eventTime, and make sure we get back the same time.
event.setEventTime(eventTime)
self.assertEqual(event.getEventTime(), eventTime)
def testEventProperties(self):
status = "my special status"
root = PropertySet()
MYNAME = "myname"
root.set(MYNAME, MYNAME)
root.set(events.Event.STATUS, status)
event = events.Event(root)
props = event.getPropertySet()
custom = event.getCustomPropertySet()
self.assertEqual(props.nameCount(), 6)
self.assertEqual(custom.nameCount(), 1)
def sendEvent(self, topicName):
root = base.PropertySet()
root.set("DATE", "2007-07-01T14:28:32.546012")
root.setInt("PID", 200)
root.set("HOST", "lsstcorp.org")
root.set("IP", "1.2.3.4")
root.set("EVNT", "test")
root.set("misc1", "data 1")
root.set("misc2", "data 2")
root.set("value", 3.14)
eventSystem = events.EventSystem.getDefaultEventSystem()
event = events.Event("runid_es6", root)
eventSystem.publishEvent(topicName, event)
def sendEvent(self, broker, topic):
trans = events.EventTransmitter(broker, topic)
root = base.PropertySet()
root.set("DATE", "2007-07-01T14:28:32.546012")
root.setInt("PID", 200)
root.set("HOST", "lsstcorp.org")
root.set("IP", "1.2.3.4")
root.set("EVNT", "test")
root.set("misc1", "data 1")
root.set("misc2", "data 2")
root.set("value", 3.14)
event = events.Event("runid_test6", root)
trans.publishEvent(event)
def sendEvent(self, topicName):
root = base.PropertySet()
root.set("DATE","2007-07-01T14:28:32.546012")
root.setInt("PID",200)
root.set("HOST","lsstcorp.org")
root.set("IP","1.2.3.4")
root.set("EVNT","test")
root.set("misc1","data 1")
root.set("misc2","data 2")
root.set("value", 3.14)
root.set("array1", ('a', 'b', 'c', 'd'))
root.set("array2", (1, 2, 3, 4, 5))
root.set("array3", (6.1, 6.2, 6.3, 6.4, 6.5))
eventSystem = events.EventSystem.getDefaultEventSystem()
event = events.Event("runid_es4", root)
eventSystem.publishEvent(topicName, event)
def sendEvent(self, broker, topic):
trans = events.EventTransmitter(broker, topic)
root = PropertySet()
root.set(events.Event.TOPIC, topic)
root.set("myname", "myname")
root.set(events.Event.STATUS, "my special status")
root.set(events.Event.RUNID, "srptestrun")
event = events.Event("srptestrun", root)
# wait a short time so we can see the difference between the time
# the event is created and the time it is published
time.sleep(2)
# ok...now publish it
trans.publishEvent(event)
def performEventTest(self, destination):
eventSystem = events.EventSystem.getDefaultEventSystem()
prop = self.createPropertySet()
# create and publish an event without a runid
event = events.Event(prop)
eventSystem.publishEvent(destination, event)
# should receive the event
receivedEvent = eventSystem.receiveEvent(destination)
self.assertIsNotNone(receivedEvent)
# should be able to get the PropertySet we sent
recvProp = receivedEvent.getPropertySet()
self.assertIsNotNone(recvProp)
# verify PropertySet contents
# shouldn't have a RUNID
with self.assertRaises(ex.Exception):
recvProp.get(events.Event.RUNID)
self.verifyPropertySet(recvProp)
# You should have received a copy of the LSST License Statement and
# the GNU General Public License along with this program. If not,
# see <http://www.lsstcorp.org/LegalNotices/>.
#
import lsst.daf.base as base
import lsst.ctrl.events as events
if __name__ == "__main__":
system = events.EventSystem().getDefaultEventSystem()
system.createTransmitter("lsst8.ncsa.illinois.edu", "test1")
system.createTransmitter("lsst8.ncsa.illinois.edu", "test2")
system.createTransmitter("lsst8.ncsa.illinois.edu", "test3")
newSystem = events.EventSystem().getDefaultEventSystem()
root = base.PropertySet()
root.add("DATE", "2007-07-01T14:28:32.546012")
root.addInt("PID", 200)
root.add("HOST", "lsst8.ncsa.illinois.edu")
root.add("IP", "141.142.220.44")
root.add("EVNT", "test")
root.add("misc1", "data 1")
root.add("misc2", "data 2")
root.addDouble("float_value", 3.14)
newSystem.publishEvent("test1", events.Event(root))
newSystem.publishEvent("test2", events.Event(root))
newSystem.publishEvent("test3", events.Event(root))
def testEventEmpty(self):
event = events.Event()
props = event.getPropertySet()
self.assertEqual(props.nameCount(), 0)
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the LSST License Statement and
# the GNU General Public License along with this program. If not,
# see <http://www.lsstcorp.org/LegalNotices/>.
#
import lsst.ctrl.events as events
import lsst.daf.base as base
if __name__ == "__main__":
x = events.EventTransmitter("lsst8.ncsa.illinois.edu", "test_logging")
root = base.PropertySet()
root.add("DATE", "2007-07-01T14:28:32.546012")
root.addInt("PID", 200)
root.add("HOST", "lsst8.ncsa.illinois.edu")
root.add("IP", "141.142.220.44")
root.add("EVNT", "test")
root.add("misc1", "data 1")
root.add("misc2", "data 2")
root.addFloat("float_value", 3.14)
ev = events.Event(root)
x.publishEvent(ev)
def sendEvent(self, broker, topicName, port, value):
root = base.PropertySet()
root.addInt("FOO", value)
trans = events.EventEnqueuer(broker, topicName, port)
event = events.Event("myrunid", root)
trans.publishEvent(event)
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 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 create(self):
"""create a new instance of the event"""
return ev.Event(self.runid, self.props)
