def EventFromInputfile(inputfile,
datatypePolicy,
metadataPolicy,
topicName='triggerImageprocEvent',
hostName='lsst4.ncsa.uiuc.edu'):
"""generate a new file event for a given FITS file
@param inputfile the name of the FITS file
@param datatyepPolicy the policy describing the metadata transformation
@param metadataPolicy the policy describing the event metadata types
@param topicName the name of the topic to send event as
@param hostName the event broker hostname
"""
global exposureCount
exposureCount += 1
# For DC3a, inputfile is a .fits file on disk
metadata = afwImage.readMetadata(inputfile)
# First, transform the input metdata
transformMetadata(metadata, datatypePolicy, metadataPolicy, 'Keyword')
# To be consistent...
if not validateMetadata(metadata, metadataPolicy):
logger.log(logger.FATAL, 'Unable to create event from %s' % inputfile)
# Create event policy, using defaults from input metadata
event = dafBase.PropertySet()
event.copy('visitId', metadata, 'visitId')
event.copy('ccdId', metadata, 'ccdId')
event.copy('ampId', metadata, 'ampId')
event.copy('exposureId', metadata, 'exposureId')
event.copy('datasetId', metadata, 'datasetId')
event.copy('filter', metadata, 'filter')
event.copy('expTime', metadata, 'expTime')
event.copy('ra', metadata, 'ra')
event.copy('decl', metadata, 'decl')
event.copy('equinox', metadata, 'EQUINOX')
event.copy('airmass', metadata, 'airmass')
event.copy('dateObs', metadata, 'dateObs')
if event.getInt('exposureId') == 0:
eventTransmitter = ctrlEvents.EventTransmitter(hostName,
topicName + '0')
elif event.getInt('exposureId') == 1:
eventTransmitter = ctrlEvents.EventTransmitter(hostName,
topicName + '1')
logger.log(logger.INFO,
'Sending event for %s' % os.path.basename(inputfile))
if logger.sends(logger.DEBUG):
logger.log(logger.DEBUG, "Data Event data:\n%s" % event.toString())
elif logger.sends(VERB3):
logger.log(
VERB3, "Event data: datasetId=%s; ra=%f, dec=%f" %
(event.get("datasetId"), event.get("ra"), event.get("decl")))
eventTransmitter.publish(event)
return True
def _publish(self, clipboard, log=None):
"""
Publish events if required
"""
if log is None:
log = self.log
log = Debug(log, "publish")
log.debug(4, "Looking for keysToPublish")
if not self.policy.exists('keysToPublish'):
log.log(Log.WARN,
"Did not find keysToPublish in EventStage Policy")
return
log.debug(4, "Found keysToPublish")
publKeyList = self.policy.getArray("keysToPublish")
if len(publKeyList) <= 0:
log.log(Log.WARN, "Empty keysToPublish in EventStage Policy")
return
log.debug(4, "Got array: " + str(publKeyList))
for key in publKeyList:
log.debug(4, "Got key %s" % key)
(eventName, propertySetName) = self._parseKeysToPublish(key)
log.debug(
4, "eventName=%s, propertySetName=%s" %
(eventName, propertySetName))
psPtr = clipboard.get(propertySetName)
log.debug(4, "Got propertySet %s" % psPtr.toString(False))
oneEventTransmitter = \
events.EventTransmitter(self.getEventBrokerHost(), eventName)
oneEventTransmitter.publish(psPtr)
log.debug(4, 'Published event %s' % key)
def shutdown(self):
"""
Shutdown the Pipeline execution: delete the MPI environment
Send the Exit Event if required
"""
if self.exitTopic == None:
pass
else:
oneEventTransmitter = events.EventTransmitter(
self.eventBrokerHost, self.exitTopic)
psPtr = dafBase.PropertySet()
psPtr.setString("message", str("exiting_") + self._runId)
oneEventTransmitter.publish(psPtr)
for i in range(self.nSlices):
slice = self.sliceThreadList[i]
slice.join()
self.log.log(self.VERB2, 'Slice ' + str(i) + ' ended.')
# Also have to tell the shutdown Thread to stop
self.oneShutdownThread.setStop()
self.oneShutdownThread.join()
self.log.log(self.VERB2, 'Shutdown thread ended ')
sys.exit()
def sendEvent(self, runid, brokerName, topic):
trans = events.EventTransmitter(brokerName, topic)
root = PropertySet()
root.set(events.Event.TOPIC, topic)
root.set("myname","myname")
root.set(events.Event.STATUS, "my special status")
locationID = events.LocationId()
event = events.StatusEvent(runid, locationID, root)
# ok...now publish it
trans.publishEvent(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 __init__(self,
runid,
topic,
brokerhost,
originatorId=None,
brokerport=0):
"""
create a sender that will send events to a given broker on a given
topic.
@param runid the Run ID to send in events
@param topic the event topic
@param brokerhost the hostname where the event broker is running
@param originatorId the number to use as the Originator ID
@param brokerport the port that the broker is listening on.
"""
self.runid = runid
self.esys = ev.EventSystem.getDefaultEventSystem()
if originatorId is None:
originatorId = self.esys.createOriginatorId()
self.origid = originatorId
if brokerport and brokerport > 0:
self.trxr = ev.EventTransmitter(brokerhost, brokerport, topic)
else:
self.trxr = ev.EventTransmitter(brokerhost, topic)
def sendEvent(self, brokerName, topic):
"""Send an Event."""
trans = events.EventTransmitter(brokerName, topic)
root = PropertySet()
root.set(events.Event.TOPIC, topic)
root.set("myname", "myname")
root.set(events.StatusEvent.STATUS, "my special status")
root.set(events.StatusEvent.RUNID, "srptestrun")
root.set("bazinga", "sheldon")
originatorId = events.LocationId()
event = events.StatusEvent("srptestrun", originatorId, root)
# ok...now publish it
trans.publishEvent(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 sendPlainStatusEvent(self, broker, topic, runID=None):
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("logger.status", "my logger special status")
root.set("logger.pid", "1")
eventSystem = events.EventSystem.getDefaultEventSystem()
locationID = eventSystem.createOriginatorId()
if runID is None:
event = events.StatusEvent(locationID, root)
else:
event = events.StatusEvent(runID, locationID, root)
# ok...now publish it
trans.publishEvent(event)
def shutdown(self):
"""
Shutdown the Pipeline execution: delete the MPI environment
Send the Exit Event if required
"""
if self.exitTopic == None:
pass
else:
oneEventTransmitter = events.EventTransmitter(
self.eventBrokerHost, self.exitTopic)
psPtr = dafBase.PropertySet()
psPtr.setString("message", str("exiting_") + self._runId)
oneEventTransmitter.publish(psPtr)
# Also have to tell the shutdown Thread to stop
self.oneShutdownThread.stop()
self.oneShutdownThread.join()
self.log.log(self.VERB2, 'Shutdown thread ended ')
self.log.log(self.VERB2, 'Pipeline calling MPI_Finalize ')
self.cppPipeline.shutdown()
def sendFilterableStatusEvent(self, broker, topic, runID=None):
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")
filter = PropertySet()
filter.set("FOO", "bar")
filter.set("PLOUGH", 123)
filter.set("PLOVER", 0.45)
eventSystem = events.EventSystem.getDefaultEventSystem()
locationID = eventSystem.createOriginatorId()
if runID is None:
event = events.StatusEvent(locationID, root, filter)
else:
event = events.StatusEvent(runID, locationID, root, filter)
# ok...now publish it
trans.publishEvent(event)
#
# 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"
shutdownTopic = "triggerShutdownA"
eventBrokerHost = "lsst8.ncsa.uiuc.edu"
externalEventTransmitter = events.EventTransmitter(eventBrokerHost,
shutdownTopic)
root = PropertySet()
# Shutdown at level 1 : stop immediately by killing process (ugly)
# Shutdown at level 2 : exit in a clean manner (Pipeline and Slices) at a synchronization point
# Shutdown at level 3 : exit in a clean manner (Pipeline and Slices) at the end of a Stage
# Shutdown at level 4 : exit in a clean manner (Pipeline and Slices) at the end of a Visit
root.setInt("level", 3)
externalEventTransmitter.publish(root)
def sendEvent(self, broker, topicName, value):
root = base.PropertySet()
root.addInt("FOO", value)
trans = events.EventTransmitter(broker, topicName)
event = events.Event("myrunid", root)
trans.publishEvent(event)
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)
# (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.daf.base as datap
import lsst.ctrl.events as events
import time
if __name__ == "__main__":
print "Issueing shutdown event ...\n"
shutdownTopic = "triggerShutdownEvent"
activemqBroker = "lsst8.ncsa.uiuc.edu"
externalEventTransmitter = events.EventTransmitter(activemqBroker, shutdownTopic )
root = datap.DataProperty.createPropertyNode("root");
externalEventTransmitter.publish("eventtype", root)
print "Sent.\n"
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)
# event generator for DC2
import lsst.ctrl.events as events
import lsst.daf.base as datap
import sys
if __name__ == "__main__":
brokernode = "lsst8.ncsa.uiuc.edu"
if len(sys.argv) > 1:
brokernode = sys.argv[1]
if brokernode.find('.') < 0:
brokernode += ".ncsa.uiuc.edu"
print "brokernode =", brokernode
x = events.EventTransmitter(brokernode, "triggerVisitEvent, mops1Event")
for image in sys.stdin:
d = image.split()
root = datap.DataProperty.createPropertyNode("root")
exposureId = datap.DataProperty("exposureId", int(d[0]))
visitId = datap.DataProperty("visitId", int(d[0]))
ra = datap.DataProperty("FOVRA", float(d[1]))
dec = datap.DataProperty("FOVDec", float(d[2]))
filter = datap.DataProperty("filterName", d[3])
visitTime = datap.DataProperty("visitTime", float(d[4]))
dateObs = datap.DataProperty("dateObs", d[5])
airMass = datap.DataProperty("airMass", float(d[6]))
exposureTime = datap.DataProperty("exposureTime", float(d[7]))
equinox = datap.DataProperty("equinox", float(d[8]))
# 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 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)
x.publish(root)
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)
# 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 = "lsst8.ncsa.uiuc.edu"
externalEventTransmitter = events.EventTransmitter(
eventBrokerHost, "triggerAssociationEvent")
root = PropertySet()
root.setInt("visitId", 1)
root.setDouble("FOVRa", 273.48066298343)
root.setDouble("FOVDec", -27.125)
externalEventTransmitter.publish(root)
# 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 = "lsst8.ncsa.uiuc.edu"
externalEventTransmitter = events.EventTransmitter(eventBrokerHost, "triggerMatchMopEvent")
root = PropertySet()
root.setInt("visitId", 1)
externalEventTransmitter.publish(root)
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)
# 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 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"
externalEventTransmitter = events.EventTransmitter("lsst4.ncsa.uiuc.edu",
"triggerIpdpEvent")
root = PropertySet()
root.set("visitid", "fov391")
externalEventTransmitter.publish(root)
