def __init__(self,
left_button=None,
left_led=None,
right_button=None,
right_led=None,
track=None,
strawberry_factory=None,
chocolate_factory=None):
self.buttons_locked = False
self.micro_lock = threading.Lock()
self.pending_cookies = Queue.Queue()
self.left_button = left_button
self.left_button.register(self.button_pressed)
self.left_led = left_led
self.left_led.off()
self.right_button = right_button
self.right_button.register(self.button_pressed)
self.right_led = right_led
self.right_led.off()
self.track = track
self.strawberry_factory = strawberry_factory
self.chocolate_factory = chocolate_factory
self.evolution = Evolution()
self._fsm = Fysom(initial='waiting',
events=[('reproduce', 'waiting', 'waiting')],
callbacks=[('on_state_waiting', self._unlock),
('onreproduce', self._reproduce)])
def do_stem(self, word):
fsm = Fysom(initial='start', events=self.events)
# FIXME: uncomment below and make sanitize functions support
# both Python 2 and 3 versions
# word = WordProcessor.sanitize(word)
i = len(word) - 1
j = len(word)
while (True):
if i <= 0:
break
v = word[i:j]
# print v
res = fsm.can(v)
if (res):
if v == 'i' and fsm.can(word[i - 1:j]):
i = i - 1
continue
fsm.trigger(v)
if fsm.current == 'h':
if word[i - 1:i] == 'i':
i = i - 1 # skip i
if word[i - 1:i] == 'n':
# ning qushimchasi
fsm.current = 'start'
continue
elif fsm.current == 'b':
fsm.current = 'start'
j = i
i = i - 1
return word[:j]
def test_pickling_does_not_work_with_callbacks(self):
fsm = Fysom({
'initial':
'green',
'events': [{
'name': 'warn',
'src': 'green',
'dst': 'yellow'
}, {
'name': 'panic',
'src': 'yellow',
'dst': 'red'
}, {
'name': 'panic',
'src': 'green',
'dst': 'red'
}, {
'name': 'calm',
'src': 'red',
'dst': 'yellow'
}, {
'name': 'clear',
'src': 'yellow',
'dst': 'green'
}],
'callbacks': {
'onpanic': lambda: 1,
}
})
self.assertRaises(RuntimeError, dumps, fsm)
def __init__(self):
self._states = []
self._fsm = Fysom({
'initial':
'green',
'events': [{
'name': 'warn',
'src': 'green',
'dst': 'yellow'
}, {
'name': 'panic',
'src': 'yellow',
'dst': 'red'
}, {
'name': 'calm',
'src': 'red',
'dst': 'yellow'
}, {
'name': 'clear',
'src': 'yellow',
'dst': 'green'
}],
'callbacks': {
'ongreen': self._on_green,
'onyellow': self._on_yellow,
'onred': self._on_red
}
})
def __init__(self, debuglevel=0, debugname='Log Service Base'):
self.debuglevel = debuglevel
self.debugname = debugname
self._error_string = ''
self.on_error_string_changed = []
# Log
self._log_channel = Publish(debuglevel=debuglevel)
self._log_channel.debugname = '%s - %s' % (self.debugname, 'log')
# more efficient to reuse protobuf messages
self._log_tx = Container()
# callbacks
self.on_state_changed = []
# fsm
self._fsm = Fysom(
{
'initial': 'down',
'events': [
{'name': 'connect', 'src': 'down', 'dst': 'up'},
{'name': 'disconnect', 'src': 'up', 'dst': 'down'},
],
}
)
self._fsm.ondown = self._on_fsm_down
self._fsm.onafterconnect = self._on_fsm_connect
self._fsm.onup = self._on_fsm_up
self._fsm.onafterdisconnect = self._on_fsm_disconnect
def __init__(self):
self.electionTimerInterval=randint(6,10) #seconds timeout
# self.electionTimerInterval=randint(2,5) #seconds timeout
self.ns = NodeState()
self.ownAddress = socket.gethostbyname(socket.gethostname())
self.leaderId = None
print(self.ownAddress)
self.serverState = Fysom({'initial': 'follower',
'events': [
('startElection', 'follower', 'candidate'),
('discoverLeader', 'candidate', 'follower'),
('newTerm', 'candidate', 'follower'),
('startElection', 'candidate', 'candidate'),
('receivedMajority', 'candidate', 'leader'),
('discoverServerWithHigherTerm',
'leader', 'follower')
],
'callbacks': {
'onleader': self.become_leader,
'onstartElection': self.become_candidate,
'onleaveleader': self.stop_being_leader,
'onfollower': self.become_follower
}
})
self.nodeAddresses = []
# need to make sure all nodes are started up before populating the node list
while len(self.nodeAddresses) < self.nodesInCluster:
self.update_node_list()
time.sleep(1)
print(self.nodeAddresses)
self.otherNodeAddresses = [
a for a in self.nodeAddresses if a != str(self.ownAddress)]
print(self.otherNodeAddresses)
def test_it_should_indicate_whether_fsm_in_finished_state(self):
fsm = Fysom({
'initial':
'green',
'final':
'red',
'events': [{
'name': 'warn',
'src': 'green',
'dst': 'yellow'
}, {
'name': 'panic',
'src': 'yellow',
'dst': 'red'
}, {
'name': 'calm',
'src': 'red',
'dst': 'yellow'
}, {
'name': 'clear',
'src': 'yellow',
'dst': 'green'
}]
})
self.assertFalse(fsm.is_finished())
fsm.warn()
self.assertFalse(fsm.is_finished())
fsm.panic()
self.assertTrue(fsm.is_finished())
def __init__(self, cfg):
from fysom import Fysom
events = set([event['name'] for event in cfg['events']])
cfg['callbacks'] = self.collect_event_listeners(
events, cfg['callbacks'])
self.fsm = Fysom(cfg)
self.attach_proxy_methods(self.fsm, events)
def create_voting_fsm(tracking_id,
vote,
broadcast_vote,
spawn_yadtshell,
fold,
cleanup_fsm):
fsm = Fysom({
'initial': 'negotiating',
'events': [
{'name': 'call', 'src': 'negotiating', 'dst': 'negotiating'},
{'name': 'fold', 'src': 'negotiating', 'dst': 'finish'},
{'name': 'showdown', 'src': 'negotiating', 'dst': 'spawning'},
{'name': 'spawned', 'src': 'spawning', 'dst': 'finish'},
{'name': 'showdown', 'src': 'finish', 'dst': 'finish'}
],
'callbacks': {
'onnegotiating': broadcast_vote,
'onspawning': spawn_yadtshell,
'onfinish': cleanup_fsm,
'onfold': fold,
}
})
fsm.tracking_id = tracking_id
fsm.vote = vote
return fsm
def test_it_doesnt_break_with_unicode_literals(self):
try:
fsm = Fysom({
'initial':
'green',
'final':
'red',
'events': [{
'name': 'warn',
'src': 'green',
'dst': 'yellow'
}, {
'name': 'panic',
'src': 'yellow',
'dst': 'red'
}, {
'name': 'calm',
'src': 'red',
'dst': 'yellow'
}, {
'name': 'clear',
'src': 'yellow',
'dst': 'green'
}]
})
self.assertTrue(True)
except TypeError:
self.assertTrue(False)
def __init__(self, agent):
logger.debug("Initializing host agent state machine")
self.agent = agent
self.fsm = Fysom({
"events": [("lookup", "*", "found"),
("announce", "found", "announced"),
("pending", "announced", "wait4init"),
("ready", "wait4init", "good2go")],
"callbacks": {
# Can add the following to debug
# "onchangestate": self.print_state_change,
"onlookup": self.lookup_agent_host,
"onannounce": self.announce_sensor,
"onpending": self.on_ready,
"ongood2go": self.on_good2go
}
})
self.timer = threading.Timer(1, self.fsm.lookup)
self.timer.daemon = True
self.timer.name = self.THREAD_NAME
# Only start the announce process when not in Test
if not "INSTANA_TEST" in os.environ:
self.timer.start()
def logon(self):
self.psget = PasswordProtect(self.baseurl)
self.logon_fsm = Fysom({
'initial': {
'state': 'start'
},
'events': [{
'name': 'userid',
'src': 'start',
'dst': 'username_sent'
}, {
'name': 'password',
'src': 'username_sent',
'dst': 'password_sent'
}, {
'name': 'logon',
'src': 'password_sent',
'dst': 'logged_on'
}],
'final':
'logged_on',
'callbacks': {
'onuserid': self.send_userid,
'onpassword': self.send_password,
'onlogon': self.send_logon
}
})
self.logon_fsm.userid(html_id='userid')
self.logon_fsm.password(html_id='password')
self.logon_fsm.logon(html_id='logon')
def test_onchangestate_should_fire_for_all_state_changes(self):
def on_change_state(e):
self.current_event = e
fsm = Fysom({
'initial': 'foo',
'events': [
{'name': 'footobar', 'src': 'foo', 'dst': 'bar'},
{'name': 'bartobaz', 'src': 'bar', 'dst': 'baz'},
],
'callbacks': {
'onchangestate': on_change_state
}
})
fsm.footobar(id=123)
self.assertEqual(self.current_event.event, 'footobar')
self.assertEqual(self.current_event.src, 'foo')
self.assertEqual(self.current_event.dst, 'bar')
self.assertEqual(self.current_event.id, 123)
self.assertTrue(self.current_event.fsm is fsm)
fsm.bartobaz('positional', named_attribute='test')
self.assertEqual(self.current_event.event, 'bartobaz')
self.assertEqual(self.current_event.src, 'bar')
self.assertEqual(self.current_event.dst, 'baz')
self.assertEqual(self.current_event.named_attribute, 'test')
self.assertEqual(self.current_event.args[0], 'positional')
self.assertTrue(self.current_event.fsm is fsm)
def setUp(self):
self.fired_callbacks = []
self.fsm = Fysom({
'initial': 'sleeping',
'events': [
{'name': 'foo', 'src': 'sleeping', 'dst': 'fooed'},
{'name': 'foo', 'src': 'fooed', 'dst': 'fooed'},
{'name': 'bar', 'src': 'fooed', 'dst': 'bared'},
{'name': 'bar', 'src': 'bared', 'dst': 'bared'},
{'name': 'baz', 'src': 'bared', 'dst': 'bazed'},
{'name': 'wait', 'src': 'sleeping', 'dst': 'waiting'}
],
'callbacks': {
'onfoo': self.on_foo,
'onbar': self.on_bar,
'onbaz': self.on_baz,
'onbeforefoo': self.before_foo,
'onbeforebar': self.before_bar,
'onbeforewait': self.before_wait,
'onenterfooed': self.on_enter_fooed,
'onenterbared': self.on_enter_bared,
'onreenterfooed': self.on_reenter_fooed,
'onreenterbared': self.on_reenter_bared,
'onleavesleeping': self.on_leave_sleeping,
'onleavefooed': self.on_leave_fooed
}
})
def __init__(self, agent):
package_version = 'unknown'
try:
package_version = pkg_resources.get_distribution('instana').version
except pkg_resources.DistributionNotFound:
pass
logger.info("Stan is on the scene. Starting Instana instrumentation version: %s", package_version)
logger.debug("initializing fsm")
self.agent = agent
self.fsm = Fysom({
"events": [
("lookup", "*", "found"),
("announce", "found", "announced"),
("pending", "announced", "wait4init"),
("ready", "wait4init", "good2go")],
"callbacks": {
# Can add the following to debug
# "onchangestate": self.print_state_change,
"onlookup": self.lookup_agent_host,
"onannounce": self.announce_sensor,
"onpending": self.agent.start,
"onready": self.on_ready}})
self.timer = t.Timer(5, self.fsm.lookup)
self.timer.daemon = True
self.timer.name = self.THREAD_NAME
self.timer.start()
def test_never_finished_if_final_is_unspecified(self):
fsm = Fysom({
'initial':
'green',
'events': [{
'name': 'warn',
'src': 'green',
'dst': 'yellow'
}, {
'name': 'panic',
'src': 'yellow',
'dst': 'red'
}, {
'name': 'calm',
'src': 'red',
'dst': 'yellow'
}, {
'name': 'clear',
'src': 'yellow',
'dst': 'green'
}]
})
self.assertFalse(fsm.is_finished())
fsm.warn()
self.assertFalse(fsm.is_finished())
fsm.panic()
self.assertFalse(fsm.is_finished())
def setUp(self):
self.fsm = Fysom({
'initial':
'green',
'events': [{
'name': 'warn',
'src': 'green',
'dst': 'yellow'
}, {
'name': 'panic',
'src': 'yellow',
'dst': 'red'
}, {
'name': 'calm',
'src': 'red',
'dst': 'yellow'
}, {
'name': 'clear',
'src': 'yellow',
'dst': 'green'
}, {
'name': 'warm',
'src': 'green',
'dst': 'blue'
}]
})
def __init__(self,
my_id,
zmq_context,
img_socket,
queueing_fun,
output_dir,
router_address,
resize_factor=100,
debug=False):
self.my_id = my_id
self.zmq_context = zmq_context
self.socket_img = img_socket
self.enqueue_fun = queueing_fun
self.output_dir = output_dir
self.router_address = router_address
self.resize_ratio = resize_factor
events = [{
'name': 'start',
'src': 'idle',
'dst': 'in_sweep'
}, {
'name': 'stop',
'src': '*',
'dst': 'idle'
}]
callbacks = {'onleaveidle': self.reset, 'onstop': self.halt}
self.fsm = Fysom(initial='idle', events=events, callbacks=callbacks)
self.time_start = get_utc_now_ms()
if debug:
self.fsm.onchangestate = print_state_change
def __init__(self, location, size, disease):
self.state = Fysom({
'initial':
'healthy',
'events': [
{
'name': 'get infected',
'src': 'healthy',
'dst': 'incubation'
},
{
'name': 'finish incubation',
'src': 'incubation',
'dst': 'contagious'
},
{
'name': 'die',
'src': 'contagious',
'dst': 'dead'
},
{
'name': 'recover',
'src': 'contagious',
'dst': 'immune'
},
],
})
self.incubation_duration = disease['incubation duration']
self.contagious_duration = disease['contagious duration']
self.color = colors[self.state.current]
self.next_trigger = None
self.neighbors = []
self.size = size
self.x, self.y = location[0] * self.size, location[1] * self.size
def test_rest_should_always_transition_to_hungry_state(self):
fsm = Fysom(self.fsm_descr)
fsm.rest()
self.assertEquals(fsm.current, 'hungry')
fsm = Fysom(self._get_descr('satisfied'))
fsm.rest()
self.assertEquals(fsm.current, 'hungry')
fsm = Fysom(self._get_descr('full'))
fsm.rest()
self.assertEquals(fsm.current, 'hungry')
fsm = Fysom(self._get_descr('sick'))
fsm.rest()
self.assertEquals(fsm.current, 'hungry')
def do_stem(self, word):
fsm = Fysom(initial='start', events=self.events)
i = len(word) - 1
j = len(word)
while (True):
if i <= 0:
break
v = word[i:j]
# print v
res = fsm.can(v)
if (res):
if v == 'i' and fsm.can(word[i - 1:j]):
i = i - 1
continue
fsm.trigger(v)
if fsm.current == 'h':
if word[i - 1:i] == 'i':
i = i - 1 # skip i
if word[i - 1:i] == 'n':
# ning qushimchasi
fsm.current = 'start'
continue
elif fsm.current == 'b':
fsm.current = 'start'
j = i
i = i - 1
return word[:j]
def test_if_src_not_specified_then_is_wildcard(self):
fsm = Fysom({
'initial':
'hungry',
'events': [{
'name': 'eat',
'src': 'hungry',
'dst': 'satisfied'
}, {
'name': 'eat',
'src': 'satisfied',
'dst': 'full'
}, {
'name': 'eat',
'src': 'full',
'dst': 'sick'
}, {
'name': 'rest',
'dst': 'hungry'
}]
})
fsm.eat()
self.assertEqual(fsm.current, 'satisfied')
fsm.rest()
self.assertEqual(fsm.current, 'hungry')
fsm.eat()
fsm.eat()
self.assertEqual(fsm.current, 'full')
fsm.rest()
self.assertEqual(fsm.current, 'hungry')
def __init__(self, debuglevel=0, debugname='Halrcomp Subscribe'):
self.debuglevel = debuglevel
self.debugname = debugname
self._error_string = ''
self.on_error_string_changed = []
# ZeroMQ
context = zmq.Context()
context.linger = 0
self._context = context
# pipe to signalize a shutdown
self._shutdown = context.socket(zmq.PUSH)
self._shutdown_uri = b'inproc://shutdown-%s' % str(uuid.uuid4()).encode()
self._shutdown.bind(self._shutdown_uri)
self._thread = None # socket worker tread
self._tx_lock = threading.Lock() # lock for outgoing messages
# Socket
self.socket_uri = ''
self._socket_topics = set()
# more efficient to reuse protobuf messages
self._socket_rx = Container()
# Heartbeat
self._heartbeat_lock = threading.Lock()
self._heartbeat_interval = 2500
self._heartbeat_timer = None
self._heartbeat_active = False
self._heartbeat_liveness = 0
self._heartbeat_reset_liveness = 5
# callbacks
self.on_socket_message_received = []
self.on_state_changed = []
# fsm
self._fsm = Fysom(
{
'initial': 'down',
'events': [
{'name': 'start', 'src': 'down', 'dst': 'trying'},
{'name': 'full_update_received', 'src': 'trying', 'dst': 'up'},
{'name': 'stop', 'src': 'trying', 'dst': 'down'},
{'name': 'heartbeat_timeout', 'src': 'up', 'dst': 'trying'},
{'name': 'heartbeat_tick', 'src': 'up', 'dst': 'up'},
{'name': 'any_msg_received', 'src': 'up', 'dst': 'up'},
{'name': 'stop', 'src': 'up', 'dst': 'down'},
],
}
)
self._fsm.ondown = self._on_fsm_down
self._fsm.onafterstart = self._on_fsm_start
self._fsm.ontrying = self._on_fsm_trying
self._fsm.onafterfull_update_received = self._on_fsm_full_update_received
self._fsm.onafterstop = self._on_fsm_stop
self._fsm.onup = self._on_fsm_up
self._fsm.onafterheartbeat_timeout = self._on_fsm_heartbeat_timeout
self._fsm.onafterheartbeat_tick = self._on_fsm_heartbeat_tick
self._fsm.onafterany_msg_received = self._on_fsm_any_msg_received
def test_gc_should_not_break_callback(self):
class MyTestObject(object):
def __init__(self):
self._states = []
self._fsm = None
def warn(self):
self._fsm.warn()
def panic(self):
self._fsm.panic()
def calm(self):
self._fsm.calm()
def clear(self):
self._fsm.clear()
def _on_green(self, *args, **kwargs):
self._states.append('green')
def _on_yellow(self, *args, **kwargs):
self._states.append('yellow')
def _on_red(self, *args, **kwargs):
self._states.append('red')
obj = MyTestObject()
fsm = Fysom({
'initial':
'green',
'events': [{
'name': 'warn',
'src': 'green',
'dst': 'yellow'
}, {
'name': 'panic',
'src': 'yellow',
'dst': 'red'
}, {
'name': 'calm',
'src': 'red',
'dst': 'yellow'
}, {
'name': 'clear',
'src': 'yellow',
'dst': 'green'
}],
'callbacks': {
'ongreen': obj._on_green,
'onyellow': obj._on_yellow,
'onred': obj._on_red
}
})
obj._fsm = fsm
obj.warn()
obj.clear()
del obj
fsm.warn()
def test_initial_state_should_work_with_different_event_name(self):
fsm = Fysom({
'initial': {'state': 'green', 'event': 'init'},
'events': [
{'name': 'panic', 'src': 'green', 'dst': 'red'},
{'name': 'calm', 'src': 'red', 'dst': 'green'},
]
})
self.assertEquals(fsm.current, 'green')
def test_init_kwargs_only(self):
fsm = Fysom(initial='green',
events=[('panic', 'green', 'red'),
('calm', 'red', 'green')])
self.assertEqual(fsm.current, "green")
fsm.panic()
self.assertEqual(fsm.current, "red")
fsm.calm()
self.assertEqual(fsm.current, "green")
def test_should_have_no_state_when_no_initial_state_is_given(self):
fsm = Fysom({
'events': [
{'name': 'warn', 'src': 'green', 'dst': 'yellow'},
{'name': 'panic', 'src': 'yellow', 'dst': 'red'},
{'name': 'calm', 'src': 'red', 'dst': 'yellow'},
{'name': 'clear', 'src': 'yellow', 'dst': 'green'}
]
})
self.assertEqual(fsm.current, 'none')
def __init__(self, debuglevel=0, debugname='Log Base'):
self.debuglevel = debuglevel
self.debugname = debugname
self._error_string = ''
self.on_error_string_changed = []
# Log
self._log_channel = SimpleSubscribe(debuglevel=debuglevel)
self._log_channel.debugname = '%s - %s' % (self.debugname, 'log')
self._log_channel.on_state_changed.append(
self._log_channel_state_changed)
self._log_channel.on_socket_message_received.append(
self._log_channel_message_received)
# more efficient to reuse protobuf messages
self._log_rx = Container()
# callbacks
self.on_log_message_received = []
self.on_state_changed = []
# fsm
self._fsm = Fysom({
'initial':
'down',
'events': [
{
'name': 'connect',
'src': 'down',
'dst': 'trying'
},
{
'name': 'log_up',
'src': 'trying',
'dst': 'up'
},
{
'name': 'disconnect',
'src': 'trying',
'dst': 'down'
},
{
'name': 'disconnect',
'src': 'up',
'dst': 'down'
},
],
})
self._fsm.ondown = self._on_fsm_down
self._fsm.onafterconnect = self._on_fsm_connect
self._fsm.ontrying = self._on_fsm_trying
self._fsm.onafterlog_up = self._on_fsm_log_up
self._fsm.onafterdisconnect = self._on_fsm_disconnect
self._fsm.onup = self._on_fsm_up
self._fsm.onleaveup = self._on_fsm_up_exit
def __init__(self, states, events, config, callbacks):
"""TODO params dont match
:param callbacks: it is used to indicate some event happens, we should take some action
{
Type:event/state
TrackPoint:On/Before/After/ Leave/Enter/reenter
Name:
Handler:
}
"""
# Get all the Event
generatedCallbackDict = dict()
newConfig = copy(config)
for callback in callbacks:
if callback["Type"] == 'event':
if callback["TrackPoint"] not in ["on", "before", "after"]:
raise l2tpv3FsmParameterError(
"Cannot register event callback since Trackpoint type unrecognised"
)
if callback["Name"] not in events:
raise l2tpv3FsmParameterError(
"Cannot register event callback since event name is unrecognised"
)
elif callback["Type"] == 'state':
if callback["TrackPoint"] not in [
"on", "leave", "enter", "reenter", "after"
]:
raise l2tpv3FsmParameterError(
"Cannot register state callback since Trackpoint type unrecognised"
)
if callback["Name"] not in states:
raise l2tpv3FsmParameterError(
"Cannot register event callback since states name is unrecognised"
)
else:
raise l2tpv3FsmParameterError(
"Cannot register state callback since Type unrecognised")
if not callable(callback['Handler']):
raise l2tpv3FsmParameterError(
"Cannot register state callback since handler is not callable"
)
if callback["TrackPoint"] == "on":
callbackTrackpoint = "on"
else:
callbackTrackpoint = "on" + callback["TrackPoint"]
prefix = callbackTrackpoint + callback['Name']
generatedCallbackDict[prefix] = callback["Handler"]
if len(generatedCallbackDict) > 0:
newConfig["callbacks"] = generatedCallbackDict
self.fsm = Fysom(newConfig)
def test_deferred_initial_state_should_be_none_then_state(self):
fsm = Fysom({
'initial': {'state': 'green', 'event': 'init', 'defer': True},
'events': [
{'name': 'panic', 'src': 'green', 'dst': 'red'},
{'name': 'calm', 'src': 'red', 'dst': 'green'},
]
})
self.assertEqual(fsm.current, 'none')
fsm.init()
self.assertEqual(fsm.current, 'green')
