async def main():
import signal
Spy.enable_spy(SimpleSpy)
s1 = HsmTest()
SimpleSpy.on_framework_add(s1)
interactive = False
if interactive:
signal.signal(signal.SIGINT, signal.SIG_DFL)
s1.init()
while not s1.terminated:
sig_name = input('\tEvent --> ')
try:
sig = getattr(Signal, sig_name)
except LookupError:
print("\nInvalid signal name", end="")
continue
event = Event(sig, None)
s1.dispatch(event)
print("\nTerminated")
else:
seq = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a', 't']
# seq = ['g', 'i', 'a', 'd', 'd', 'c', 'e', 'e', 'g', 'i', 'i', 't']
s1.start(0)
for sig in seq:
event = Event(getattr(Signal, sig), None)
s1.postFIFO(event)
await Framework.done()
def _error(self, event):
sig = event.signal
if sig == Signal.ENTRY:
print(f"{self.name} in error state")
self.postFIFO(Event(Signal.TERMINATE, None))
return self.handled(event)
return self.super(self._running)
async def main():
hsm = HsmExample1()
# Spy.enable_spy(SimpleSpy)
# SimpleSpy.on_framework_add(hsm)
hsm.start(0)
while not hsm.terminated:
sig_name = input('\tEvent --> ')
try:
sig = getattr(Signal, sig_name)
except LookupError:
print("\nInvalid signal name", end="")
continue
event = Event(sig, None)
hsm.dispatch(event)
await Framework.done()
async def my_middleware(self, request, handler):
try:
resp = await handler(request)
except Exception as e:
if self.publish_errors:
Framework.publish(
Event(
Signal.ERROR, {
"exc": e,
"traceback": traceback.format_exc(),
"location": self.__class__.__name__,
"request": request.url
}))
raise HTTPInternalServerError(
text=
f"Error handling request {request.path_qs}\n{traceback.format_exc()}"
)
return resp
async def main():
hsm = HsmExample1()
# Spy.enable_spy(SimpleSpy)
# SimpleSpy.on_framework_add(hsm)
seq = ['E1', 'E2', 'E1', 'E2']
hsm.start(0)
for sig_name in seq:
sig = getattr(Signal, sig_name)
print(f'\tEvent --> {sig_name}')
Framework.publish(Event(sig, None))
# Allow other tasks to run
await asyncio.sleep(0)
# Wait for CTRL-C to signal TERMINATE to all the HSMs. If we want to
# automatically terminate them, we can publish the TERMINATE event, but
# it is then necessary include Framework.subscribe("TERMINATE") in
# _initial above
# Framework.publish(Event.TERMINATE)
await Framework.done()
def _running(self, event):
sig = event.signal
if sig == Signal.ENTRY:
print(f"{self.name} enters running state, period {self.period}")
self.te.postEvery(self, self.period)
# raise ValueError("Exception in entry handler for _running")
return self.handled(event)
elif sig == getattr(Signal, f"TIMER_{self.name}"):
self.count += 1
print(f"{self.name} receives tick")
self.postFIFO(
Event(Signal.NOTIFY,
f"{self.__class__.__name__}: {self.name}"))
# raise ValueError("Error raised in notify")
return self.handled(event)
elif sig == Signal.NOTIFY:
print(f"Received Signal.NOTIFY with payload {event.value}")
self.run_async(self.async_task_example(self.name))
return self.handled(event)
elif sig == Signal.TERMINATE:
print("Received TERMINATE")
return self.tran(self._exit)
elif sig == Signal.EXIT:
self.te.disarm()
return self.handled(event)
elif sig == Signal.ERROR:
print(f"ERROR: {event.value}")
return self.handled(event)
# if self.name == "alpha":
# return self.tran(self._running)
# else:
# return self.tran(self._error)
return self.super(self.top)
async def main():
hsm = HsmExample1()
# Spy.enable_spy(SimpleSpy)
# SimpleSpy.on_framework_add(hsm)
seq = ['E1', 'E2', 'E1', 'E2']
hsm.start(0)
while not hsm.terminated:
if seq:
sig_name = seq.pop(0)
print(f'\tEvent --> {sig_name}')
else:
sig_name = input('\tEvent --> ')
try:
sig = getattr(Signal, sig_name)
hsm.postFIFO(Event(sig, None))
except LookupError:
print("\nInvalid signal name", end="")
continue
while hsm.has_msgs():
event = hsm.pop_msg()
hsm.dispatch(event)
print("\nTerminated")
await Framework.done()