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 makeReceivers(broker, topics, runid=None): out = [] select = None if runid: select = "RUNID = '%s'" % runid for topic in topics: if select: rcvr = events.EventReceiver(broker, topic, select) else: rcvr = events.EventReceiver(broker, topic) out.append(rcvr) return out
def watchLogs(broker, lognames, sleep=10, sliceid=None, hosts=None, hostexclude=False, minimport=None, maximport=None): """ print selected log messages @param broker the host where the event broker is running @param lognames a list (or space-delimited string) of log names to listen for @parma sleep seconds to sleep when no events are available @param sliceid restrict to the given sliceid. If none, print all slices @param hosts restrict to the given list of host origins @param hostexclude if True, the hosts lists are hosts to ignore messages from @param minimport restrict to messages with this importance level or higher. If None (default), set no minimum restriction. @param maximport restrict to messages with this importance level or lower. If None (default), set no maximum restriction. """ if not isinstance(lognames, list): lognames = lognames.split() logger.log(VERB, "Watching for log names: " + ", ".join(lognames)) rcvr = events.EventReceiver(broker, "LSSTLogging") listen(rcvr, sys.stdout, lognames, sleep, sliceid, hosts, hostexclude, minimport, maximport)
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 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 launchDC3a(policyFile, runid, visitFiles, colls, opts, logger): if not os.environ.has_key(pkgdirvar): raise pexExcept.LsstException("%s env. var not set (setup %s)" % (pkgdirvar, dc3apkg)) if opts.repos is None: opts.repos = os.path.join(os.environ[pkgdirvar], "pipeline") policy = Policy.createPolicy(policyFile, opts.repos) broker = policy.get("eventBrokerHost") logger.log(Log.DEBUG, "Using event broker on %s" % broker) recvr = events.EventReceiver(broker, loggingEventTopic) runOrca(policyFile, runid, opts, logger) waitForReady(policy, runid, recvr, opts.pipeverb, logger) runEventGen(policy, visitFiles, colls, opts, broker, logger)
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 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 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())
# 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 threading import lsst.daf.base as dafBase from lsst.daf.base import * import lsst.ctrl.events as events import time if __name__ == "__main__": print "starting...\n" eventBrokerHost = "lsst4.ncsa.uiuc.edu" eventRec = events.EventReceiver(eventBrokerHost, "outgoingEvent") print 'Python listenEvents : waiting on receive...\n' inputParamPropertySetPtr = eventRec.receive(800000) print 'Python listenEvents : - received event.\n' nameList = inputParamPropertySetPtr.names() for name in nameList: print 'name is ' + name
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 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 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 createReceiver(self, broker, topic): receiver = events.EventReceiver(broker, topic) return receiver
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 run(self): runId = self.pipeline.getRun() shutdownTopic = self.pipeline.getShutdownTopic() eventBrokerHost = self.pipeline.getEventBrokerHost() # eventsSystem = events.EventSystem.getDefaultEventSystem() # eventsSystem.createReceiver(eventBrokerHost, shutdownTopic) clause = "RUNID = '" + runId + "'" recv = events.EventReceiver(eventBrokerHost, shutdownTopic, clause) # works # recv = events.EventReceiver(eventBrokerHost, shutdownTopic) sleepTimeout = 2.0 transTimeout = 900 shutdownEvent = None shutdownPropertySetPtr = None # while(shutdownPropertySetPtr == None): while (shutdownEvent == None): if (self.logthresh == Log.DEBUG): print "ShutdownThread Looping : checking for Shutdown event ... \n" print "ShutdownThread Looping : " + clause time.sleep(sleepTimeout) # shutdownPropertySetPtr = eventsSystem.receive(shutdownTopic, transTimeout) shutdownEvent = recv.receiveEvent(transTimeout) if (shutdownEvent == None): pass else: # if (shutdownPropertySetPtr != None): # if (shutdownEvent != None): shutdownPropertySetPtr = shutdownEvent.getCustomPropertySet() self.level = shutdownPropertySetPtr.getInt("level") if (self._stop.isSet()): if (self.logthresh == self.VERB3): print "ShutdownThread exiting from loop : Stop from Pipeline \n" sys.exit() self.pipeline.setExitLevel(self.level) # Shutdown at level 1 : stop immediately by killing process (ugly) if (self.level == 1): self.pipeline.exit() # Shutdown at level 2 : exit in a clean manner (Pipeline and Slices) # at a synchronization point if (self.level == 2): self.pipeline.setStop() # Shutdown at level 3 : exit in a clean manner (Pipeline and Slices) # at the end of a Stage if (self.level == 3): self.pipeline.setStop() # Shutdown at level 4 : exit in a clean manner (Pipeline and Slices) # at the end of a Visit if (self.level == 4): self.pipeline.setStop()
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)
# 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/>. # # # logwatcher.py - watches for logging events, and prints them # # from __future__ import print_function import lsst.daf.base as datap import lsst.ctrl.events as events import time import sys if __name__ == "__main__": host = sys.argv[1] print("listening on host " + host) x = events.EventReceiver(host, events.LogEvent.LOGGING_TOPIC) while (True): print("waiting on logging event...\n") event = x.receiveEvent() val = event.getPropertySet() if val != None: print(val.toString())
# # You should have received a copy of the LSST License Statement and # the GNU General Public License along with this program. If not, # see <https://www.lsstcorp.org/LegalNotices/>. # # # EventListener - This utility prints out events, given a host name and # topic. This allows you to keep an eye on events while # they are happening for debugging. # # from __future__ import print_function import lsst.ctrl.events as events import time import sys if __name__ == "__main__": print("starting...\n") host = sys.argv[1] topic = sys.argv[2] print(host + "->" + topic) x = events.EventReceiver(host, topic) print("waiting on receive...\n") while (True): ev = x.receiveEvent() if ev != None: ps = ev.getPropertySet() print(ps.toString())
# LSST Project (http://www.lsst.org/). # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # 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 time if __name__ == "__main__": print("starting...\n") x = events.EventReceiver("lsst8.ncsa.illinois.edu", "test_logging") print("waiting on receive...\n") val = x.receive(8000) print("finished!\n") if val != None: print(val.toString()) else: print("nothing received")
# 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 threading import lsst.daf.base as dafBase from lsst.daf.base import * import lsst.ctrl.events as events import time if __name__ == "__main__": print "starting...\n" eventBrokerHost = "lsst4.ncsa.uiuc.edu" eventRec = events.EventReceiver(eventBrokerHost, "SampleExitTopic") print 'Python listenEvents : waiting on receive...\n' inputParamPropertySetPtr = eventRec.receive(800000) print 'Python listenEvents : - received event.\n' nameList = inputParamPropertySetPtr.names() for name in nameList: print 'name is ' + name
Run with: python testLog """ import os import tempfile import lsst.log as log import lsst.ctrl.events as events if __name__ == "__main__": broker = "example.host.com" topic = "loggingtest" recv = events.EventReceiver(broker, topic) confStr = "log4j.rootLogger=TRACE, EA\n" confStr += "log4j.appender.EA=EventAppender\n" confStr += "log4j.appender.EA.BROKER=" + broker + "\n" confStr += "log4j.appender.EA.TOPIC=" + topic + "\n" tempDir = tempfile.mkdtemp() outputFileName = os.path.join(tempDir, "log.out") log.configure_prop(confStr.format(outputFileName)) # test a simple message #with log.LogContext("component"): log.trace("this is a trace message")
def makeReceivers(broker, topics): out = [] for topic in topics: out.append(events.EventReceiver(broker, topic)) return out
# # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # 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 time if __name__ == "__main__": print("starting...\n") receiver = events.EventReceiver("lsst8.ncsa.illinois.edu", events.EventLog.LOGGING_TOPIC) print("waiting on receive...\n") for i in range(5): event = receiver.receiveEvent(8000) if event is not None: payload = event.getPropertySet() print("finished!\n") if payload.nameCount() != None: print(payload.toString())
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)