def testSubscriptionForwarding6(self): Info("---- testSubscriptionForwarding6 ----", "TestEventRouterHTTP") evmatch = makeEvent(evtype="R1Events/ev1", source="R1Source/src1") evdrop = makeEvent(evtype="R1Events/ev2", source="R1Source/src2") self.doSubscriptionForwardingR2R1(None, "R1Source/src1", evmatch, evdrop) return
def testSubscriptionForwarding11(self): Info("---- testSubscriptionForwarding11 ----", "TestEventRouterHTTP") evmatch = makeEvent(evtype="R3Events1/ev1", source="R3Source1/src1") evdrop = makeEvent(evtype="R3Events1/ev2", source="R3Source1/src2") self.doSubscriptionForwardingR2R3("R3Events1/ev1", "R3Source1/src1", evmatch, evdrop) return
def testSubscriptionForwarding3(self): Info("---- testSubscriptionForwarding3 ----", "EventLib.TestEventHTTPClient") evmatch = makeEvent(evtype="R3Events1/ev1", source="R3Source1/src1") evdrop = makeEvent(evtype="R3Events1/ev2", source="R3Source1/src2") self.doSubscriptionForwardingR2R3("R3Events1/ev1", "R3Source1/src1", evmatch, evdrop) return
def testSubscriptionForwarding2(self): Info("---- testSubscriptionForwarding2 ----", "TestEventHTTPClientServer") evmatch = makeEvent(evtype="R3Events/ev1", source="R3Source/src1") evdrop = makeEvent(evtype="R3Events/ev2", source="R3Source/src2") self.doSubscriptionForwardingR2R3(None, "R3Source/src1", evmatch, evdrop) return
def testSubscriptionForwarding1(self): Info("---- testSubscriptionForwarding1 ----------", "TestEventRouterHTTP") evmatch = makeEvent(evtype="R2Events/ev1", source="R2Source/src1") evdrop = makeEvent(evtype="R2Events/ev2", source="R2Source/src2") self.doSubscriptionForwardingR1R2("R2Events/ev1", None, evmatch, evdrop) return
def testSubscriptionForwarding12(self): Info("---- testSubscriptionForwarding12 ----", "TestEventRouterHTTP") evmatch = makeEvent(evtype="RREvents3/ev1", source="RRSource3/src1") evdrop = makeEvent(evtype="RREvents3/ev2", source="RRSource3/src2") self.doSubscriptionForwardingR2R3("RREvents3/ev1", "RRSource3/src1", evmatch, evdrop, r1fwd=1) return
def testSubscriptionForwarding4(self): Info("---- testSubscriptionForwarding4 ----", "EventLib.TestEventHTTPClient") evmatch = makeEvent(evtype="RREvents3/ev1", source="RRSource3/src1") evdrop = makeEvent(evtype="RREvents3/ev2", source="RRSource3/src2") self.doSubscriptionForwardingR2R3("RREvents3/ev1", "RRSource3/src1", evmatch, evdrop, r1fwd=1) return
def testWriteTCPAndLocal(self): """ Test what happens when we start a write event to a TCP serial port and a Local one at the same time """ self._log.debug( "\n\n-------------------------------testWriteTCPAndLocal-------------------------------" ) self._log.debug( "\nInitializng TCP server" ) TCPServ = TestTCPServer(4747) TCPServ.start() try: self._log.debug( "\nInitializing serial eventhandler" ) testCfg = getDictFromXmlString(testConfigLocalAndTCP) self._log.debug( "\ntestCfg : %s" %testCfg ) eh=Serial(self._router) self.assertNotEqual( eh, None ) self._log.debug( "\n Configuring serial eventhandler" ) eh.configure(testCfg['eventInterface']) eh.start() self._log.debug( "\nCreating test events :" ) TCPSerialevent = makeEvent( 'internal/test/serial', 'serial/test/1', {} ) localSerialevent = makeEvent( 'internal/test/serial', 'serial/test/2', {} ) self._log.debug( "%s and %s" %(localSerialevent,TCPSerialevent) ) self._log.debug( "\nSending TCP event..." ) eh.handleEvent( TCPSerialevent ) self._log.debug( "\nSending local event..." ) eh.handleEvent( localSerialevent ) time.sleep(1) portlist = eh.getSerialPorts() self._log.debug( "\nList of active ports : %s" %portlist ) TCPData = TCPServ.data self._log.debug( "\nTCP server recieved : ##%s##" %TCPData ) assert TCPData == 'ABC' self.assertEqual( len(self._router._pubs), 1 ) self.assertEqual( self._router._pubs[0][1].getType(), "http://id.webbrick.co.uk/events/serial/receive" ) self.assertEqual( self._router._pubs[0][1].getSource(), "serial-2/receive" ) self.assertEqual( self._router._pubs[0][1].getPayload()['data'], "66;67;68:" ) self._log.debug( "\nLocal serial recieved local data ") eh.stop() finally : TCPServ.stop() time.sleep(1)
def testWriteTCP(self): """ Test what happens when we start a write event to a TCP serial port """ self._log.debug( "\n\n-------------------------------testWriteTCP-------------------------------" ) self._log.debug( "\nInitializng TCP server" ) TCPServ = TestTCPServer(4747) TCPServ.start() try: self._log.debug( "\nInitializing serial eventhandler" ) testCfg = getDictFromXmlString(testConfigTCP) self._log.debug( "\ntestCfg : %s" %testCfg ) eh=Serial(self._router) self.assertNotEqual( eh, None ) eh.configure(testCfg['eventInterface']) eh.start() self._log.debug( "\nCreating test event :" ) testEvent = makeEvent( 'internal/test/serial', 'serial/test/1', {} ) self._log.debug( testEvent ) self._log.debug( "\nTesting eventhandler..." ) eh.handleEvent( testEvent ) time.sleep(1) portlist = eh.getSerialPorts() self._log.debug( "\nList of active ports : %s" %portlist ) data = TCPServ.data self._log.debug( "\nTCP server recieved : ##%s##" %data ) assert data == "turn lights onsuccess!" eh.stop() finally: TCPServ.stop()
def doActions( self, actions, inEvent ): for de in actions[0]: # update from event de.update(inEvent) for ae in actions[1]: # perform action if ae._action == ACTION_CSV: # write an event log entry ntry = ",".join( [de.get() for de in self._columns] ) ls = logging.getLogger(ae._streamname) ls.info( ntry ) elif ae._action == ACTION_XML: atts = "".join( [" %s='%s' " % (de._name, de._value) for de in self._columns] ) elms = "".join( ["<%s>%s</%s>" % (de._name, de._value, de._name) for de in self._columns] ) ntry = "<%s %s>%s</%s>" % (ae._element, atts, elms, ae._element) ls = logging.getLogger(ae._streamname) ls.info( ntry ) elif ae._action == ACTION_EVENT: # create an event od = dict() for de in self._columns: od[de._name] = de._value self.sendEvent( makeEvent( ae._type, ae._source, od ) ) elif ae._action == ACTION_CLEAR: # clear current data values for de in self._columns: de.clear()
def doTestPublish(self,typid,srcid,expectTriggered): src = makeEventAgent(typid+srcid) evt = makeEvent(evtype=typid,source=srcid) sts = self.router.publish(src, evt) self.assertEqual( sts.syncValue(), StatusVal.OK, str(sts.syncValue())+" is not StatusVal.OK" ) mapAssert(evTriggerEq, self.handlers, expectTriggered, "Trigger "+typid+srcid) return
def testMakeEvent2(self): e = makeEvent(evtype="EventTypeUri", source="EventSourceUri", payload="payload") assert e.getType() == "EventTypeUri", "testMakeEvent2, getType" assert e.getSource() == "EventSourceUri", "testMakeEvent2, getSource" assert e.getPayload() == "payload", "testMakeEvent2, getPayload"
def testBlockingEventDelivery(self): es = makeEventAgent(uri="es") eh = makeEventHandler(uri="eh", handler=eventHandlerBlocking, initSubscription=subHandler, endSubscription=unsubHandler) eh.subcount = 0 eh.evcount = 0 evtyp = "R3Events1/ev1" # Select event routed R3 -> R1 -> R2 .. evsrc = "R3Source1/src1" # .. (see setUp) ev = makeEvent(evtype=evtyp, source=evsrc) sts = self.R2.subscribe(60, eh, evtype=evtyp, source=evsrc) Trace("Subscribe returned", "EventLib.TestEventRouterThreaded") time.sleep(0.1) # Allow subscribe time to propagate Trace("Subscribed", "EventLib.TestEventRouterThreaded") self.assertEqual(eh.evcount, 0) sts = self.R3.publish(es, ev) self.assertEqual(eh.evcount, 0) # Not delivered immediately ... Trace("Before sleep", "EventLib.TestEventRouterThreaded") time.sleep(1.5) # Note: evcent handler blocks for 1 sec Trace("After sleep: eh.evcount %d" % (eh.evcount), "EventLib.TestEventRouterThreaded") self.assertEqual(eh.evcount, 1) # ... but sometime after a second self.assertEqual(eh.event.getType(), evtyp) self.assertEqual(eh.event.getSource(), evsrc) Trace("testBlockingEventDelivery OK", "EventLib.TestEventRouterThreaded") return
def sendTestEvent(self): print ("sendTestEvent start") self.setUpRouter() # Listen for incoming events using a custom handler. eventType = "to/router/original" eventSource = "source/router2" router1EventAgentIncoming = makeEventAgent(uri="router1EventAgentIncoming") router1EventHandlerIncoming = makeEventHandler( uri="router1EventAgentIncoming", handler=eventHandlerIncoming, initSubscription=subHandlerIncoming, endSubscription=unsubHandlerIncoming, ) router1EventHandlerIncoming.subcount = 0 router1EventHandlerIncoming.evcount = 0 status = self.R1.subscribe( 60, router1EventHandlerIncoming, evtype=eventType, source=eventSource ) # R1 subscribes to eventType to send a response back # Set the counter to 1, make our first event. self.inC() eventType = "to/router/2" eventSource = "source/router1" event = makeEvent(evtype=eventType, source=eventSource, payload=router.getCount()) self.sendTestEventDo(self.R3C, self.R1, event, eventType, eventSource) # Send the event print ("sendTestEvent end")
def testFloatCounterSet(self): """ Set Counter to a fixed value """ _log.debug( "\ntestFloatCounterSet" ) self.loader = EventRouterLoader() errCount = self.loader.loadHandlers( getDictFromXmlString(testConfigFloatCounterSet) ) self.assertEqual( errCount, 0) self.loader.start() # all tasks self.router = self.loader.getEventRouter() self.router.publish( EventAgent("testCounters"), makeEvent( 'test/event', 'set/counter', { 'val':'300.45' } ) ) TestEventLogger.logEvents() expectedEvents = { "test/event" : [ ("set/counter" , 'val', 300.45) ], "test/1" : [ ("test/entryCount",'val', 300.45) ] } Utils.expectNevents(self, 2) haveErr, excessEvents = Utils.verifyEvents2( expectedEvents, TestEventLogger._events ) _log.debug( "Excess Events %s " % (excessEvents) ) self.assertEqual( haveErr, False, "Incorrect event set" )
def eventHandlerIncoming(h, e): h.evcount += 1 h.event = e if h.event.getType() == "to/router/original": rootlogger.warn("== Received an incoming event, event number: %s ==", router.getCount()) # Increment the counter for the incoming events. Sleep so that we don't have a continuous loop of events. router.inC() time.sleep(0.5) # Make and publish an event back to Router2Console eventType = "to/router/2" eventSource = "source/router1" router1EventAgentOutgoing = makeEventAgent(uri="router1EventAgentOutgoing") router1EventHandlerOutgoing = makeEventHandler( uri="router1EventAgentOutgoing", handler=eventHandlerOutgoing, initSubscription=subHandlerOutgoing, endSubscription=unsubHandlerOutgoing, ) router1EventHandlerOutgoing.subcount = 0 router1EventHandlerOutgoing.evcount = 0 event = makeEvent(evtype=eventType, source=eventSource, payload=router.getCount()) rootlogger.warn("== Sending out event, number: %s ==", router.getCount()) status2 = router.getR1().publish( router1EventHandlerOutgoing, event ) ## R1 publishes the main event, R2C picks it up and forwards it to TestEventHTTPRouter1Console.py rootlogger.warn("== The event has completed being published ==") return makeDeferred(StatusVal.OK)
def testBlockingEventDelivery(self): es = makeEventAgent(uri="es") eh = makeEventHandler( uri="eh", handler=eventHandlerBlocking, initSubscription=subHandler, endSubscription=unsubHandler) eh.subcount = 0 eh.evcount = 0 evtyp = "R3Events1/ev1" # Select event routed R3 -> R1 -> R2 .. evsrc = "R3Source1/src1" # .. (see setUp) ev = makeEvent(evtype=evtyp, source=evsrc) sts = self.R2.subscribe(60, eh, evtype=evtyp, source=evsrc) Trace("Subscribe returned", "EventLib.TestEventRouterThreaded") time.sleep(0.1) # Allow subscribe time to propagate Trace("Subscribed", "EventLib.TestEventRouterThreaded") self.assertEqual(eh.evcount, 0) sts = self.R3.publish(es, ev) self.assertEqual(eh.evcount, 0) # Not delivered immediately ... Trace("Before sleep", "EventLib.TestEventRouterThreaded") time.sleep(1.5) # Note: evcent handler blocks for 1 sec Trace("After sleep: eh.evcount %d"%(eh.evcount), "EventLib.TestEventRouterThreaded") self.assertEqual(eh.evcount, 1) # ... but sometime after a second self.assertEqual(eh.event.getType(), evtyp) self.assertEqual(eh.event.getSource(), evsrc) Trace("testBlockingEventDelivery OK", "EventLib.TestEventRouterThreaded") return
def testMakeEnvSubscribeData4(self): payload = [44, None, None] ev = makeEvent(URI.EventSubscribeType, "agent", payload) env = EventEnvelope(ev, "router") self.assertEqual( es.sub("/", makeEnvelopeData(env)), '["forward", ' + '[["router"], ' + '"http://id.webbrick.co.uk/events/subscribe", ' + '"agent", ' + '[44, null, null]]]')
def testMakeEnvSubscribeData3(self): payload = [33, self.ev.getType(), None] ev = makeEvent(URI.EventSubscribeType, "agent", payload) env = EventEnvelope(ev, "router") self.assertEqual( es.sub("/", makeEnvelopeData(env)), '["forward", ' + '[["router"], ' + '"http://id.webbrick.co.uk/events/subscribe", ' + '"agent", ' + '[33, "s://auth.b/path/type/d#frag", null]]]')
def testMakeEnvelopeData2(self): self.ev2 = makeEvent("s://auth.b/path/type/d#frag", "s://auth.b/path/source/d#frag", None) self.env2 = EventEnvelope(self.ev2, "R1").nextHop("R2").nextHop("R3") self.assertEqual( es.sub("/", makeEnvelopeData(self.env2)), '["forward", ' + '[["R1", "R2", "R3"], ' + '"s://auth.b/path/type/d#frag", ' + '"s://auth.b/path/source/d#frag", ' + 'null]]')
def clickhandler(self, h, e): """ On receiving a button-click, bump the counter and generate some more events """ log.info("clickhandler %s", e) buttonstates = ('up', 'down', 'waiting', 'unknown') displaystates = ('normal', 'low', 'high', 'unknown') if e.getPayload() == "click": self._count += 1 e1 = makeEvent(SetButtonTextEvent, h.getUri(), "Button:%i"%(self._count)) self._router.publish(h, e1) e2 = makeEvent(SetButtonStateEvent, h.getUri(), buttonstates[self._count%4]) self._router.publish(h, e2) e3 = makeEvent(SetNumericDisplayValueEvent, h.getUri(), str(self._count)) self._router.publish(h, e3) e4 = makeEvent(SetNumericDisplayStateEvent, h.getUri(), displaystates[self._count%4]) self._router.publish(h, e4) return makeDeferred(StatusVal.OK)
def testMakeEnvelopeData2(self): self.ev2 = makeEvent("s://auth.b/path/type/d#frag", "s://auth.b/path/source/d#frag", None) self.env2 = EventEnvelope(self.ev2,"R1").nextHop("R2").nextHop("R3") self.assertEqual( es.sub("/", makeEnvelopeData(self.env2)), '["forward", '+ '[["R1", "R2", "R3"], '+ '"s://auth.b/path/type/d#frag", '+ '"s://auth.b/path/source/d#frag", '+ 'null]]' )
def publishFromThread( es, cq, wait0, wait1, evlist): n = 0 for (et,es) in evlist: n += 1 time.sleep(wait0) wait0 = wait1 ev = makeEvent(evtype=et, source=es) sts = self.R3.publish(es, ev) cq.put(n) return
def publishFromThread(es, cq, wait0, wait1, evlist): n = 0 for (et, es) in evlist: n += 1 time.sleep(wait0) wait0 = wait1 ev = makeEvent(evtype=et, source=es) sts = self.R3.publish(es, ev) cq.put(n) return
def testMakeEnvSubscribeData4(self): payload = [44, None, None] ev = makeEvent(URI.EventSubscribeType, "agent", payload) env = EventEnvelope(ev, "router") self.assertEqual( es.sub("/", makeEnvelopeData(env)), '["forward", '+ '[["router"], '+ '"http://id.webbrick.co.uk/events/subscribe", '+ '"agent", '+ '[44, null, null]]]' )
def testMakeEnvSubscribeData3(self): payload = [33, self.ev.getType(), None] ev = makeEvent(URI.EventSubscribeType, "agent", payload) env = EventEnvelope(ev, "router") self.assertEqual( es.sub("/", makeEnvelopeData(env)), '["forward", '+ '[["router"], '+ '"http://id.webbrick.co.uk/events/subscribe", '+ '"agent", '+ '[33, "s://auth.b/path/type/d#frag", null]]]' )
def testMakeEventHandler2(self): eh = makeEventHandler("EventHandlerUri") self.assertEqual(eh.getUri(), "EventHandlerUri") ev = makeEvent("EventUri", source=eh.getUri()) sh = eh.handleEvent(ev).syncValue() self.assertEqual(sh, StatusVal.OK) ss = eh.initSubscription(StatusVal.OK).syncValue() self.assertEqual(sh, StatusVal.OK) ss = eh.endSubscription(StatusVal.OK).syncValue() self.assertEqual(sh, StatusVal.OK) return
def handleMinute( self, inEvent ): """ Look through the schedule and process it """ od = inEvent.getPayload() nowDay = od["day"] nowTime = od["timestr"] _log.debug( 'handleMinute %s %s', nowTime, nowDay ) for schKey in self.schedule: _log.debug( 'schKey %s', schKey ) for schEntry in self.schedule[schKey].getEntries(nowDay, nowTime): _log.debug( 'schEntry %s', schEntry ) for devKey,devAction in schEntry.getDevices(): if devAction.has_key("onoff"): self.sendEvent( makeEvent( "http://id.webbrick.co.uk/events/schedule/control", "%s/%s" % (devKey,devAction["onoff"]) ) ) if devAction.has_key("val"): self.sendEvent( makeEvent( "http://id.webbrick.co.uk/events/schedule/control", "%s/set" % (devKey,) , {'val': devAction["val"] } ) )
def testMakeEventHandler5(self): # Test response to event handler throwing an exception eh = makeEventHandler("EventHandlerUri", handleEventException, initSub, endSub) self.assertEqual(eh.getUri(), "EventHandlerUri") ev = makeEvent("EventUri", source=eh.getUri()) sh = eh.handleEvent(ev).syncValue() self.assertEqual(sh, Status(URI.Status_OK, ev.getType())) # The status message value here depends on the default status value set up by # EventHandler.handleEvent, which is currently the default supplied by the # Status object constructor. self.assertEqual(sh.getMessage(), "") return
def publish_versions(evt_router): from EventLib.Event import makeEvent from EventLib.EventAgent import EventAgent from socket import gethostname from WebBrickLibs import __VERSION__ as libVersion from WebBrickRes import __VERSION__ as resVersion from WebBrickDoc import __VERSION__ as docVersion from WebBrickGateway import __VERSION__ as gwyVersion from WebBrickConfig import __VERSION__ as cfgVersion # # Now publish these as events # sysName = gethostname() evt_router.publish( EventAgent(""), makeEvent( 'http://id.webbrick.co.uk/events/diagnostics/software/version', 'WebBrickLibs', { 'build':libVersion, 'name':sysName } ) ) evt_router.publish( EventAgent(""), makeEvent( 'http://id.webbrick.co.uk/events/diagnostics/software/version', 'WebBrickRes', { 'build':resVersion, 'name':sysName } ) ) evt_router.publish( EventAgent(""), makeEvent( 'http://id.webbrick.co.uk/events/diagnostics/software/version', 'WebBrickDoc', { 'build':docVersion, 'name':sysName } ) ) evt_router.publish( EventAgent(""), makeEvent( 'http://id.webbrick.co.uk/events/diagnostics/software/version', 'WebBrickGateway', { 'build':gwyVersion, 'name':sysName } ) ) evt_router.publish( EventAgent(""), makeEvent( 'http://id.webbrick.co.uk/events/diagnostics/software/version', 'WebBrickConfig', { 'build':cfgVersion, 'name':sysName } ) )
def testMakeEventHandler1(self): eh = makeEventHandler("EventHandlerUri", handleEvent, initSub, endSub) self.assertEqual(eh.getUri(), "EventHandlerUri") ev = makeEvent("EventUri", source=eh.getUri()) sh = eh.handleEvent(ev).syncValue() self.assertEqual(sh, Status(URI.Status_TRIGGERED, ev.getType())) self.assertEqual(sh.getMessage(), ev.getType()) ss = eh.initSubscription(StatusVal.OK).syncValue() self.assertEqual(ss, Status(URI.Status_SUBSCRIBED, str(StatusVal.OK))) self.assertEqual(ss.getMessage(), str(StatusVal.OK)) su = eh.endSubscription(StatusVal.OK).syncValue() self.assertEqual(su, Status(URI.Status_UNSUBSCRIBED, str(StatusVal.OK))) self.assertEqual(su.getMessage(), str(StatusVal.OK)) return
def checkVacationStatus( self, dt_str ): if self._currentStatus is None: self._log.debug(dt_str) self._currentStatus = 1 for entry in self._entries: if entry.onVacation(dt_str): self._currentStatus = 0 self.sendEvent( makeEvent( 'http://id.webbrick.co.uk/events/config/set', 'occupants/home', {'val': self._currentStatus}) ) else: pass #if first call # if ical loaded # locate current time and see whether between VacationStart/VacationEnd i.e. onVacation or not # send relevant event # else # if current time matches an entry send relevant event. pass
def testDisconnectRecover(self): """ Test recieve callback is working correctly for serial ports """ self._log.debug( "\n\n-------------------------------testReadTCP-------------------------------" ) TCPServ = TestTCPServer(4747) TCPServ.start() self._log.debug( "\nInitializing serial eventhandler with tcp connection configured" ) testCfg = getDictFromXmlString(testConfigTCP) eh = Serial(self._router) self.assertNotEqual( eh, None ) eh.configure(testCfg['eventInterface']) eh.start() self._log.debug ( "Sending test data" ) TCPServ.send("hello\r") time.sleep(0.5) self.assertEqual( len(self._router._pubs), 1 ) self.assertEqual( self._router._pubs[0][1].getType(), "lighting/update" ) self.assertEqual( self._router._pubs[0][1].getSource(), "light1/on" ) self.assertEqual( self._router._pubs[0][1].getPayload()['lightval'], "1") TCPServ.stop() time.sleep(0.5) TCPServ = TestTCPServer(4747) TCPServ.start() testEvent = makeEvent( 'internal/test/serial', 'serial/test/1', {} ) self._log.debug( testEvent ) self._log.debug( "\nTesting eventhandler..." ) eh.handleEvent( testEvent ) eh.handleEvent( testEvent ) eh.handleEvent( testEvent ) eh.handleEvent( testEvent ) TCPServ.send("hello\r") time.sleep(1) assert TCPServ.read() == "turn lights onsuccess!turn lights onsuccess!" self.assertEqual( len(self._router._pubs), 2 ) self.assertEqual( self._router._pubs[1][1].getType(), "lighting/update" ) self.assertEqual( self._router._pubs[1][1].getSource(), "light1/on" ) self.assertEqual( self._router._pubs[1][1].getPayload()['lightval'], "1") time.sleep(0.5)
def sendBackResponse(count): # Send back an event that the Router1Console's INCOMING handler will pickup. eventType = "to/router/original" eventSource = "source/router2" router2EventAgentOutgoing = makeEventAgent(uri="router2EventAgentOutgoing") router2EventHandlerOutgoing = makeEventHandler( uri="router2EventAgentOutgoing", handler=eventHandlerOutgoing, initSubscription=subHandlerOutgoing, endSubscription=unsubHandlerOutgoing) router2EventHandlerOutgoing.subcount = 0 router2EventHandlerOutgoing.evcount = 0 event = makeEvent(evtype=eventType, source=eventSource) # Only subscribe the first time around. if count == 1: status = router.getR2C().subscribe(60, router2EventHandlerOutgoing, evtype=eventType, source=eventSource) ## R2C subscribes to all interested events (e.g. eventType) # Publish the event to Router1Console status2 = router.getR1().publish(router2EventHandlerOutgoing, event) ## R1 publishes the main event, R2C picks it up and forwards it to TestEventHTTPRouter1Console.py rootlogger.warn("== Router 2 sent out event ==")
def testMakeEvent(self): self._log.debug("\ntestMakeEvent") newEvent = makeNewEvent( { "type": "newtype", "source": "newsource", "other_data": {"data": "data", "data1": "data1", "data2": "data2"}, "copy_other_data": {"data1": "data1", "data2": "data2"}, }, makeEvent("oldType", "oldSource", {"data1": "olddata1"}), {"data2": "xtradata2"}, ) self.assertNotEqual(newEvent, None) self.assertEqual(newEvent.getType(), "newtype") self.assertEqual(newEvent.getSource(), "newsource") od = newEvent.getPayload() self.assertEqual(od["data"], "data") self.assertEqual(od["data1"], "olddata1") self.assertEqual(od["data2"], "xtradata2")
def testWriteLocalCustomPayload(self): """ Test what happens when we start a write event with a custom payload to a Local serial port. """ self._log.debug( "\n\n-------------------------------testWriteLocalCustomPayLoad-------------------------------" ) testCfg = getDictFromXmlString(testConfigLocal) self._log.debug( "testCfg %s" % testCfg ) eh = Serial(self._router) self.assertNotEqual( eh, None) eh.configure(testCfg['eventInterface']) eh.start() testEvent = makeEvent( 'internal/test/serial', 'serial/test/2', {'cmd':'write','data':'66;67;68:','address':'serial-2'} ) eh.handleEvent( testEvent ) time.sleep(2) portlist = eh.getSerialPorts() self._log.debug(portlist) self.assertEqual( len(self._router._pubs), 1 ) self.assertEqual( self._router._pubs[0][1].getType(), "http://id.webbrick.co.uk/events/serial/receive" ) self.assertEqual( self._router._pubs[0][1].getSource(), "serial-2/receive" ) self.assertEqual( self._router._pubs[0][1].getPayload()['data'], "66;67;68:" ) eh.stop()
def testMakeEventSubsitution(self): self._log.debug("\ntestMakeEventSubsitution") newEvent = makeNewEvent( { "type": "%(Newtype)s", "source": "%(Newsource)s", "other_data": {"data": "data", "data1": "TEST%(Subdata)sTEST", "data2": "data2"}, }, makeEvent( "oldType", "oldSource", {"data1": "olddata1", "Newtype": "SubType", "Newsource": "SubSource", "Subdata": "SUBBEDDATA"}, ), {"data2": "xtradata2"}, ) print newEvent self.assertNotEqual(newEvent, None) self.assertEqual(newEvent.getType(), "SubType") self.assertEqual(newEvent.getSource(), "SubSource") od = newEvent.getPayload() self.assertEqual(od["data"], "data") self.assertEqual(od["data1"], "TESTSUBBEDDATATEST")
def setUp(self): self.ev = makeEvent("s://auth.b/path/type/d#frag", "s://auth.b/path/source/d#frag", "--- payload ---") self.env = EventEnvelope(self.ev, "R1").nextHop("R2").nextHop("R3") return
def setUp(self): self.evt = makeEvent("evtype", "evsource", "payload") self.env1 = EventEnvelope(self.evt, "R1") self.env2 = self.env1.nextHop("R2") self.env3 = self.env2.nextHop("R3") return
def testSubscriptionForwarding2(self): evmatch = makeEvent(evtype="R2Events/ev1",source="R2Source/src1") evdrop = makeEvent(evtype="R2Events/ev2",source="R2Source/src2") self.doSubscriptionForwardingR1R2(None, "R2Source/src1", evmatch, evdrop) return
def testSubscriptionForwarding3(self): Info("---- testSubscriptionForwarding3 ----","EventLib.TestEventHTTPClient") evmatch = makeEvent(evtype="R3Events1/ev1",source="R3Source1/src1") evdrop = makeEvent(evtype="R3Events1/ev2",source="R3Source1/src2") self.doSubscriptionForwardingR2R3("R3Events1/ev1", "R3Source1/src1", evmatch, evdrop) return
def testSubscriptionForwarding4(self): Info("---- testSubscriptionForwarding4 ----","EventLib.TestEventHTTPClient") evmatch = makeEvent(evtype="RREvents3/ev1",source="RRSource3/src1") evdrop = makeEvent(evtype="RREvents3/ev2",source="RRSource3/src2") self.doSubscriptionForwardingR2R3("RREvents3/ev1", "RRSource3/src1", evmatch, evdrop, r1fwd=1) return
def testSubscriptionForwarding7(self): evmatch = makeEvent(evtype="R3Events1/ev1",source="R3Source1/src1") evdrop = makeEvent(evtype="R3Events1/ev2",source="R3Source1/src2") self.doSubscriptionForwardingR2R3("R3Events1/ev1", "R3Source1/src1", evmatch, evdrop) return
# Copyright L.P.Klyne 2013 # Licenced under 3 clause BSD licence # $Id: Events.py 3738 2010-10-01 15:04:17Z andy.harris $ # # Some test Events # import threading, sys, time from EventLib.Event import Event, makeEvent # Some test events that can be sent. evtTD0 = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/TD', 'webbrick/100/TD/0', {'tgtChannel': 0, 'srcChannel': 0, 'val': 1, 'setPoint': 0, 'fromNode': 100, 'udpType': 'G', 'version': 6, 'action': 1, 'dwell': 0, 'pktType': 'TD', 'ipAdr': '10.100.100.100'} ) evtTD1 = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/TD', 'webbrick/100/TD/1', {'tgtChannel': 0, 'srcChannel': 0, 'val': 1, 'setPoint': 0, 'fromNode': 100, 'udpType': 'G', 'version': 6, 'action': 1, 'dwell': 0, 'pktType': 'TD', 'ipAdr': '10.100.100.100'} ) evtDO_0_off = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DO', 'webbrick/100/DO/0', { 'state':'0' } ) evtDO_1_off = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DO', 'webbrick/100/DO/1', { 'state':'0' } ) evtDO_2_off = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DO', 'webbrick/100/DO/2', { 'state':'0' } ) evtDO_0_on = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DO', 'webbrick/100/DO/0', { 'state':'1' } ) evtDO_1_on = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DO', 'webbrick/100/DO/1', { 'state':'1' } ) evtDO_2_on = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DO', 'webbrick/100/DO/2', { 'state':'1' } ) evtDI_0_off = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DI', 'webbrick/100/DI/0', { 'state':'0' } ) evtDI_1_off = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DI', 'webbrick/100/DI/1', { 'state':'0' } ) evtDI_0_on = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DI', 'webbrick/100/DI/0', { 'state':'1' } ) evtDI_1_on = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/DI', 'webbrick/100/DI/1', { 'state':'1' } ) # # AnalogueIn events # evtAI_0_10 = makeEvent( 'http://id.webbrick.co.uk/events/webbrick/AI', 'webbrick/100/AI/0', { 'srcChannel': 0, 'curhi': 99.0, 'val': 10.0, 'fromNode': 100, 'curlo': 98.0, 'defhi': 99, 'deflo': 98} )
def testMakeEvent1(self): e = makeEvent("EventTypeUri", "EventSourceUri", "payload") assert e.getType() == "EventTypeUri", "testMakeEvent1, getType" assert e.getSource() == "EventSourceUri", "testMakeEvent1, getSource" assert e.getPayload() == "payload", "testMakeEvent1, getPayload"
def testEventEqual6(self): e2 = makeEvent(evtype="EventTypeUri", source="EventSourceUri2", payload="payload") self.assertNotEqual(None, e2, "testEventEqual6")
def testSubscriptionForwarding8(self): evmatch = makeEvent(evtype="RREvents3/ev1",source="RRSource3/src1") evdrop = makeEvent(evtype="RREvents3/ev2",source="RRSource3/src2") self.doSubscriptionForwardingR2R3("RREvents3/ev1", "RRSource3/src1", evmatch, evdrop, r1fwd=1) return
def testEventEqual2(self): e1 = Event("EventTypeUri", "", None) e2 = makeEvent(evtype="EventTypeUri") self.assertEqual(e1, e2, "testEventEqual2")
def testEventEqual5(self): e1 = Event("EventTypeUri", "EventSourceUri", "payload1") e2 = makeEvent(evtype="EventTypeUri", source="EventSourceUri", payload="payload2") self.assertNotEqual(e1, e2, "testEventEqual5")