This repository has been archived by the owner on Jan 30, 2018. It is now read-only.
forked from fritzy/SleekXMPP
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Browse files
Browse the repository at this point in the history
starting to integrate new state manager and state machine
- Loading branch information
Showing
6 changed files
with
711 additions
and
514 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Empty file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,267 @@ | ||
""" | ||
SleekXMPP: The Sleek XMPP Library | ||
Copyright (C) 2010 Nathanael C. Fritz | ||
This file is part of SleekXMPP. | ||
See the file LICENSE for copying permission. | ||
""" | ||
import threading | ||
import time | ||
import logging | ||
|
||
log = logging.getLogger(__name__) | ||
|
||
|
||
class StateMachine(object): | ||
|
||
def __init__(self, states=[]): | ||
self.lock = threading.Lock() | ||
self.notifier = threading.Event() | ||
self.__states= [] | ||
self.addStates(states) | ||
self.__default_state = self.__states[0] | ||
self.__current_state = self.__default_state | ||
|
||
def addStates(self, states): | ||
self.lock.acquire() | ||
try: | ||
for state in states: | ||
if state in self.__states: | ||
raise IndexError("The state '%s' is already in the StateMachine." % state) | ||
self.__states.append( state ) | ||
finally: self.lock.release() | ||
|
||
|
||
def transition(self, from_state, to_state, wait=0.0, func=None, args=[], kwargs={} ): | ||
''' | ||
Transition from the given `from_state` to the given `to_state`. | ||
This method will return `True` if the state machine is now in `to_state`. It | ||
will return `False` if a timeout occurred the transition did not occur. | ||
If `wait` is 0 (the default,) this method returns immediately if the state machine | ||
is not in `from_state`. | ||
If you want the thread to block and transition once the state machine to enters | ||
`from_state`, set `wait` to a non-negative value. Note there is no 'block | ||
indefinitely' flag since this leads to deadlock. If you want to wait indefinitely, | ||
choose a reasonable value for `wait` (e.g. 20 seconds) and do so in a while loop like so: | ||
:: | ||
while not thread_should_exit and not state_machine.transition('disconnected', 'connecting', wait=20 ): | ||
pass # timeout will occur every 20s unless transition occurs | ||
if thread_should_exit: return | ||
# perform actions here after successful transition | ||
This allows the thread to be responsive by setting `thread_should_exit=True`. | ||
The optional `func` argument allows the user to pass a callable operation which occurs | ||
within the context of the state transition (e.g. while the state machine is locked.) | ||
If `func` returns a True value, the transition will occur. If `func` returns a non- | ||
True value or if an exception is thrown, the transition will not occur. Any thrown | ||
exception is not caught by the state machine and is the caller's responsibility to handle. | ||
If `func` completes normally, this method will return the value returned by `func.` If | ||
values for `args` and `kwargs` are provided, they are expanded and passed like so: | ||
`func( *args, **kwargs )`. | ||
''' | ||
|
||
return self.transition_any( (from_state,), to_state, wait=wait, | ||
func=func, args=args, kwargs=kwargs ) | ||
|
||
|
||
def transition_any(self, from_states, to_state, wait=0.0, func=None, args=[], kwargs={} ): | ||
''' | ||
Transition from any of the given `from_states` to the given `to_state`. | ||
''' | ||
|
||
if not (isinstance(from_states,tuple) or isinstance(from_states,list)): | ||
raise ValueError( "from_states should be a list or tuple" ) | ||
|
||
for state in from_states: | ||
if not state in self.__states: | ||
raise ValueError( "StateMachine does not contain from_state %s." % state ) | ||
if not to_state in self.__states: | ||
raise ValueError( "StateMachine does not contain to_state %s." % to_state ) | ||
|
||
|
||
start = time.time() | ||
while not self.__current_state in from_states or not self.lock.acquire(False): | ||
# detect timeout: | ||
remainder = start + wait - time.time() | ||
if remainder > 0: self.notifier.wait(remainder) | ||
else: return False | ||
|
||
try: # lock is acquired; all other threads will return false or wait until notify/timeout | ||
if self.__current_state in from_states: # should always be True due to lock | ||
|
||
# Note that func might throw an exception, but that's OK, it aborts the transition | ||
return_val = func(*args,**kwargs) if func is not None else True | ||
|
||
# some 'false' value returned from func, | ||
# indicating that transition should not occur: | ||
if not return_val: return return_val | ||
|
||
log.debug(' ==== TRANSITION %s -> %s', self.__current_state, to_state) | ||
self._set_state( to_state ) | ||
return return_val # some 'true' value returned by func or True if func was None | ||
else: | ||
log.error( "StateMachine bug!! The lock should ensure this doesn't happen!" ) | ||
return False | ||
finally: | ||
self.notifier.set() # notify any waiting threads that the state has changed. | ||
self.notifier.clear() | ||
self.lock.release() | ||
|
||
|
||
def transition_ctx(self, from_state, to_state, wait=0.0): | ||
''' | ||
Use the state machine as a context manager. The transition occurs on /exit/ from | ||
the `with` context, so long as no exception is thrown. For example: | ||
:: | ||
with state_machine.transition_ctx('one','two', wait=5) as locked: | ||
if locked: | ||
# the state machine is currently locked in state 'one', and will | ||
# transition to 'two' when the 'with' statement ends, so long as | ||
# no exception is thrown. | ||
print 'Currently locked in state one: %s' % state_machine['one'] | ||
else: | ||
# The 'wait' timed out, and no lock has been acquired | ||
print 'Timed out before entering state "one"' | ||
print 'Since no exception was thrown, we are now in state "two": %s' % state_machine['two'] | ||
The other main difference between this method and `transition()` is that the | ||
state machine is locked for the duration of the `with` statement. Normally, | ||
after a `transition()` occurs, the state machine is immediately unlocked and | ||
available to another thread to call `transition()` again. | ||
''' | ||
|
||
if not from_state in self.__states: | ||
raise ValueError( "StateMachine does not contain from_state %s." % from_state ) | ||
if not to_state in self.__states: | ||
raise ValueError( "StateMachine does not contain to_state %s." % to_state ) | ||
|
||
return _StateCtx(self, from_state, to_state, wait) | ||
|
||
|
||
def ensure(self, state, wait=0.0, block_on_transition=False ): | ||
''' | ||
Ensure the state machine is currently in `state`, or wait until it enters `state`. | ||
''' | ||
return self.ensure_any( (state,), wait=wait, block_on_transition=block_on_transition ) | ||
|
||
|
||
def ensure_any(self, states, wait=0.0, block_on_transition=False): | ||
''' | ||
Ensure we are currently in one of the given `states` or wait until | ||
we enter one of those states. | ||
Note that due to the nature of the function, you cannot guarantee that | ||
the entirety of some operation completes while you remain in a given | ||
state. That would require acquiring and holding a lock, which | ||
would mean no other threads could do the same. (You'd essentially | ||
be serializing all of the threads that are 'ensuring' their tasks | ||
occurred in some state. | ||
''' | ||
if not (isinstance(states,tuple) or isinstance(states,list)): | ||
raise ValueError('states arg should be a tuple or list') | ||
|
||
for state in states: | ||
if not state in self.__states: | ||
raise ValueError( "StateMachine does not contain state '%s'" % state ) | ||
|
||
# if we're in the middle of a transition, determine whether we should | ||
# 'fall back' to the 'current' state, or wait for the new state, in order to | ||
# avoid an operation occurring in the wrong state. | ||
# TODO another option would be an ensure_ctx that uses a semaphore to allow | ||
# threads to indicate they want to remain in a particular state. | ||
|
||
# will return immediately if no transition is in process. | ||
if block_on_transition: | ||
# we're not in the middle of a transition; don't hold the lock | ||
if self.lock.acquire(False): self.lock.release() | ||
# wait for the transition to complete | ||
else: self.notifier.wait() | ||
|
||
start = time.time() | ||
while not self.__current_state in states: | ||
# detect timeout: | ||
remainder = start + wait - time.time() | ||
if remainder > 0: self.notifier.wait(remainder) | ||
else: return False | ||
return True | ||
|
||
|
||
def reset(self): | ||
# TODO need to lock before calling this? | ||
self.transition(self.__current_state, self.__default_state) | ||
|
||
|
||
def _set_state(self, state): #unsynchronized, only call internally after lock is acquired | ||
self.__current_state = state | ||
return state | ||
|
||
|
||
def current_state(self): | ||
''' | ||
Return the current state name. | ||
''' | ||
return self.__current_state | ||
|
||
|
||
def __getitem__(self, state): | ||
''' | ||
Non-blocking, non-synchronized test to determine if we are in the given state. | ||
Use `StateMachine.ensure(state)` to wait until the machine enters a certain state. | ||
''' | ||
return self.__current_state == state | ||
|
||
def __str__(self): | ||
return "".join(( "StateMachine(", ','.join(self.__states), "): ", self.__current_state )) | ||
|
||
|
||
|
||
class _StateCtx: | ||
|
||
def __init__( self, state_machine, from_state, to_state, wait ): | ||
self.state_machine = state_machine | ||
self.from_state = from_state | ||
self.to_state = to_state | ||
self.wait = wait | ||
self._locked = False | ||
|
||
def __enter__(self): | ||
start = time.time() | ||
while not self.state_machine[ self.from_state ] or not self.state_machine.lock.acquire(False): | ||
# detect timeout: | ||
remainder = start + self.wait - time.time() | ||
if remainder > 0: self.state_machine.notifier.wait(remainder) | ||
else: | ||
log.debug('StateMachine timeout while waiting for state: %s', self.from_state ) | ||
return False | ||
|
||
self._locked = True # lock has been acquired at this point | ||
self.state_machine.notifier.clear() | ||
log.debug('StateMachine entered context in state: %s', | ||
self.state_machine.current_state() ) | ||
return True | ||
|
||
def __exit__(self, exc_type, exc_val, exc_tb): | ||
if exc_val is not None: | ||
log.exception( "StateMachine exception in context, remaining in state: %s\n%s:%s", | ||
self.state_machine.current_state(), exc_type.__name__, exc_val ) | ||
|
||
if self._locked: | ||
if exc_val is None: | ||
log.debug(' ==== TRANSITION %s -> %s', | ||
self.state_machine.current_state(), self.to_state) | ||
self.state_machine._set_state( self.to_state ) | ||
|
||
self.state_machine.notifier.set() | ||
self.state_machine.lock.release() | ||
|
||
return False # re-raise any exception | ||
|
Oops, something went wrong.