def __init__(self):
self.count = 0
self.eventKey = EventKey(Prefix(Subsystems.CSW, "testassembly"),
EventName("myAssemblyEvent"))
self.eventSubscriber = EventSubscriber()
self.eventThread = self.eventSubscriber.subscribe([self.eventKey],
self.callback)
class TestSubscriber1:
def __init__(self):
self.count = 0
self.eventKey = EventKey(Prefix(Subsystems.CSW, "testassembly"),
EventName("myAssemblyEvent"))
self.eventSubscriber = EventSubscriber()
self.eventThread = self.eventSubscriber.subscribe([self.eventKey],
self.callback)
def callback(self, event: Event):
print(f"Event = {event} (Event Time = {str(event.eventTime)}")
self.count = self.count + 1
if (self.count > 4):
self.eventSubscriber.unsubscribe([self.eventKey])
self.eventThread.stop()
class TestSubscriber2:
def __init__(self):
self.eventKey = "CSW.testassembly.myAssemblyEvent"
self.eventSubscriber = EventSubscriber()
self.count = 0
self.eventThread = self.eventSubscriber.subscribe([self.eventKey],
self.callback)
def callback(self, systemEvent):
print(f"Received system event '{systemEvent.eventName}'")
for i in systemEvent.paramSet:
print(f" with values: {i.keyName}: {i.values}")
if systemEvent.isInvalid():
print(" Invalid")
if systemEvent.exists("assemblyEventValue"):
p = systemEvent.get("assemblyEventValue")
if p is not None:
print(f"Found: {p.keyName}")
self.count = self.count + 1
if (self.count > 4):
self.eventSubscriber.unsubscribe([self.eventKey])
self.eventThread.stop()
def test_pub_sub(self):
pub = EventPublisher()
sub = EventSubscriber()
prefix = Prefix(Subsystems.CSW, "assembly")
eventName = EventName("test_event")
eventKey = EventKey(prefix, eventName)
keyName = "testEventValue"
keyType = KeyType.IntKey
values = [42]
param = Parameter(keyName, keyType, values)
paramSet = [param]
event = SystemEvent(prefix, eventName, paramSet)
thread = sub.subscribe([eventKey], self.callback)
pub.publish(event)
time.sleep(1)
e = sub.get(eventKey)
assert (e == event)
assert (self.count == 1)
sub.unsubscribe([eventKey])
thread.stop()
class TestEventsWithAssembly:
log = structlog.get_logger()
dir = pathlib.Path(__file__).parent.absolute()
inFileName = "PyTestAssemblyEventHandlers.in"
outFileName = "PyTestAssemblyEventHandlers.out"
tmpInFile = f"/tmp/{inFileName}"
tmpOutFile = f"/tmp/{outFileName}"
inFile = f"{dir}/{inFileName}"
outFile = f"{dir}/{outFileName}"
pub = EventPublisher()
sub = EventSubscriber()
prefix = Prefix(Subsystems.CSW, "TestPublisher")
# def setup_method(self):
# self.cleanup()
def teardown_method(self):
# pass
self.cleanup()
def cleanup(self):
if os.path.exists(self.tmpInFile):
os.remove(self.tmpInFile)
if os.path.exists(self.tmpOutFile):
os.remove(self.tmpOutFile)
def test_pub_sub(self):
time.sleep(1.0)
self.log.debug("Starting test...")
thread = self.sub.subscribe([
EventKey(self.prefix, EventName("testEvent1")),
EventKey(self.prefix, EventName("testEvent2")),
EventKey(self.prefix, EventName("testEvent3"))
], self.callback)
try:
self.publishEvent1()
self.publishEvent2()
self.publishEvent3()
self.publishEvent4()
self.log.debug("Published three events...")
# make sure assembly has time to write the file
time.sleep(3)
# compare file created from received events below with known good version
assert filecmp.cmp(self.inFile, self.tmpInFile, False)
# compare file created by assembly with known good version
assert filecmp.cmp(self.outFile, self.tmpOutFile, False)
self.log.info("Event pub/sub tests passed")
finally:
self.log.debug("Stopping subscriber...")
thread.stop()
def publishEvent1(self):
keyName = "assemblyEventValue"
keyType = KeyType.DoubleKey
values = [42.0]
param = Parameter(keyName, keyType, values)
paramSet = [param]
event = SystemEvent(self.prefix, EventName("testEvent1"), paramSet)
self.log.debug(f"Publishing event {event}")
self.pub.publish(event)
def publishEvent2(self):
intParam = Parameter("IntValue", KeyType.IntKey, [42], Units.arcsec)
intArrayParam = Parameter("IntArrayValue", KeyType.IntArrayKey,
[[1, 2, 3, 4], [5, 6, 7, 8]])
floatArrayParam = Parameter("FloatArrayValue", KeyType.FloatArrayKey,
[[1.2, 2.3, 3.4], [5.6, 7.8, 9.1]],
Units.marcsec)
intMatrixParam = Parameter("IntMatrixValue", KeyType.IntMatrixKey,
[[[1, 2, 3, 4], [5, 6, 7, 8]],
[[-1, -2, -3, -4], [-5, -6, -7, -8]]],
Units.meter)
paramSet = [intParam, intArrayParam, floatArrayParam, intMatrixParam]
event = SystemEvent(self.prefix, EventName("testEvent2"), paramSet)
self.pub.publish(event)
def publishEvent3(self):
intParam = Parameter("IntValue", KeyType.IntKey, [42], Units.arcsec)
floatParam = Parameter("floatValue", KeyType.FloatKey, [float(42.1)],
Units.arcsec)
longParam = Parameter("longValue", KeyType.LongKey, [42], Units.arcsec)
shortParam = Parameter("shortValue", KeyType.ShortKey, [42],
Units.arcsec)
byteParam = Parameter("byteValue", KeyType.ByteKey,
b'\xDE\xAD\xBE\xEF')
booleanParam = Parameter("booleanValue", KeyType.BooleanKey,
[True, False], Units.arcsec)
intArrayParam = Parameter("IntArrayValue", KeyType.IntArrayKey,
[[1, 2, 3, 4], [5, 6, 7, 8]])
floatArrayParam = Parameter("FloatArrayValue", KeyType.FloatArrayKey,
[[1.2, 2.3, 3.4], [5.6, 7.8, 9.1]],
Units.arcsec)
doubleArrayParam = Parameter("DoubleArrayValue",
KeyType.DoubleArrayKey,
[[1.2, 2.3, 3.4], [5.6, 7.8, 9.1]],
Units.arcsec)
byteArrayParam = Parameter(
"ByteArrayValue", KeyType.ByteArrayKey,
[b'\xDE\xAD\xBE\xEF', bytes([1, 2, 3, 4])])
intMatrixParam = Parameter("IntMatrixValue", KeyType.IntMatrixKey,
[[[1, 2, 3, 4], [5, 6, 7, 8]],
[[-1, -2, -3, -4], [-5, -6, -7, -8]]],
Units.meter)
eqCoord = EqCoord.make(ra="12:13:14.15 hours",
dec="-30:31:32.3 deg",
frame=EqFrame.FK5,
pm=(0.5, 2.33))
solarSystemCoord = SolarSystemCoord.make("BASE",
SolarSystemObject.Venus)
minorPlanetCoord = MinorPlanetCoord.make("GUIDER1", 2000, "90 deg",
"2 deg", "100 deg", 1.4,
0.234, "220 deg")
cometCoord = CometCoord.make("BASE", 2000.0, "90 deg", "2 deg",
"100 deg", 1.4, 0.234)
altAzCoord = AltAzCoord.make("301 deg", "42.5 deg")
coordsParam = Parameter("CoordParam", KeyType.CoordKey, [
eqCoord, solarSystemCoord, minorPlanetCoord, cometCoord, altAzCoord
])
paramSet = [
coordsParam, byteParam, intParam, floatParam, longParam,
shortParam, booleanParam, byteArrayParam, intArrayParam,
floatArrayParam, doubleArrayParam, intMatrixParam
]
event = SystemEvent(self.prefix, EventName("testEvent3"), paramSet)
self.pub.publish(event)
def publishEvent4(self):
keyName = "assemblyEventValue"
keyType = KeyType.UTCTimeKey
values = [UTCTime.from_str("2021-09-20T20:43:35.419053077Z")]
param = Parameter(keyName, keyType, values)
keyName2 = "assemblyEventValue2"
keyType2 = KeyType.TAITimeKey
values2 = [TAITime.from_str("2021-09-20T18:44:12.419084072Z")]
param2 = Parameter(keyName2, keyType2, values2)
paramSet = [param, param2]
event = SystemEvent(self.prefix, EventName("testEvent4"), paramSet)
self.log.debug(f"Publishing event {event}")
self.pub.publish(event)
# Event subscriber callback
def callback(self, systemEvent):
self.log.debug(f"Received system event '{systemEvent}'")
# Save event to file as JSON like dict (Not JSON, since byte arrays are not serializable in python),
# but change the date and id for comparison
systemEvent.eventId = "test"
systemEvent.eventTime = EventTime(0, 0)
mode = "w" if (systemEvent.eventName.name == "testEvent1") else "a"
f = open(self.tmpInFile, mode)
jsonStr = str(systemEvent._asDict())
f.write(f"{jsonStr}\n")
f.close()
def __init__(self):
self.eventKey = "CSW.testassembly.myAssemblyEvent"
self.eventSubscriber = EventSubscriber()
self.count = 0
self.eventThread = self.eventSubscriber.subscribe([self.eventKey],
self.callback)