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)
