diff options
Diffstat (limited to 'sleekxmpp')
| -rw-r--r-- | sleekxmpp/clientxmpp.py | 9 | ||||
| -rw-r--r-- | sleekxmpp/thirdparty/__init__.py | 0 | ||||
| -rw-r--r-- | sleekxmpp/thirdparty/statemachine.py | 278 | ||||
| -rw-r--r-- | sleekxmpp/xmlstream/scheduler.py | 68 | ||||
| -rw-r--r-- | sleekxmpp/xmlstream/statemachine.py | 59 | ||||
| -rw-r--r-- | sleekxmpp/xmlstream/statemanager.py | 139 | ||||
| -rw-r--r-- | sleekxmpp/xmlstream/xmlstream.py | 261 |
7 files changed, 459 insertions, 355 deletions
diff --git a/sleekxmpp/clientxmpp.py b/sleekxmpp/clientxmpp.py index 13de39df..1aab4a78 100644 --- a/sleekxmpp/clientxmpp.py +++ b/sleekxmpp/clientxmpp.py @@ -92,6 +92,7 @@ class ClientXMPP(BaseXMPP): self.sessionstarted = False self.bound = False self.bindfail = False + self.add_event_handler('connected', self.handle_connected) self.register_handler( Callback('Stream Features', @@ -116,6 +117,14 @@ class ClientXMPP(BaseXMPP): self.register_feature( "<session xmlns='urn:ietf:params:xml:ns:xmpp-session' />", self._handle_start_session) + + def handle_connected(self, event=None): + #TODO: Use stream state here + self.authenticated = False + self.sessionstarted = False + self.bound = False + self.bindfail = False + def connect(self, address=tuple()): """ diff --git a/sleekxmpp/thirdparty/__init__.py b/sleekxmpp/thirdparty/__init__.py new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/sleekxmpp/thirdparty/__init__.py diff --git a/sleekxmpp/thirdparty/statemachine.py b/sleekxmpp/thirdparty/statemachine.py new file mode 100644 index 00000000..140c0819 --- /dev/null +++ b/sleekxmpp/thirdparty/statemachine.py @@ -0,0 +1,278 @@ +""" + 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 + +if __name__ == '__main__': + + def callback(s, s2): + print 1, s.transition('on', 'off', wait=0.0, func=callback, args=[s,s2]) + print 2, s2.transition('off', 'on', func=callback, args=[s,s2]) + return True + + s = StateMachine(('off', 'on')) + s2 = StateMachine(('off', 'on')) + print 3, s.transition('off', 'on', wait=0.0, func=callback, args=[s,s2]), + print s.current_state(), s2.current_state() diff --git a/sleekxmpp/xmlstream/scheduler.py b/sleekxmpp/xmlstream/scheduler.py index 0e3d30b3..0af1f508 100644 --- a/sleekxmpp/xmlstream/scheduler.py +++ b/sleekxmpp/xmlstream/scheduler.py @@ -104,7 +104,7 @@ class Scheduler(object): quit -- Stop the scheduler. """ - def __init__(self, parentqueue=None): + def __init__(self, parentqueue=None, parentstop=None): """ Create a new scheduler. @@ -116,6 +116,7 @@ class Scheduler(object): self.thread = None self.run = False self.parentqueue = parentqueue + self.parentstop = parentstop def process(self, threaded=True): """ @@ -135,38 +136,41 @@ class Scheduler(object): def _process(self): """Process scheduled tasks.""" self.run = True - while self.run: - try: - wait = 1 - updated = False - if self.schedule: - wait = self.schedule[0].next - time.time() - try: - if wait <= 0.0: - newtask = self.addq.get(False) - else: - newtask = self.addq.get(True, wait) - except queue.Empty: - cleanup = [] - for task in self.schedule: - if time.time() >= task.next: - updated = True - if not task.run(): - cleanup.append(task) + try: + while self.run: + wait = 1 + updated = False + if self.schedule: + wait = self.schedule[0].next - time.time() + try: + if wait <= 0.0: + newtask = self.addq.get(False) else: - break - for task in cleanup: - x = self.schedule.pop(self.schedule.index(task)) - else: - updated = True - self.schedule.append(newtask) - finally: - if updated: - self.schedule = sorted(self.schedule, - key=lambda task: task.next) - except KeyboardInterrupt: - self.run = False - + newtask = self.addq.get(True, wait) + except queue.Empty: + cleanup = [] + for task in self.schedule: + if time.time() >= task.next: + updated = True + if not task.run(): + cleanup.append(task) + else: + break + for task in cleanup: + x = self.schedule.pop(self.schedule.index(task)) + else: + updated = True + self.schedule.append(newtask) + finally: + if updated: + self.schedule = sorted(self.schedule, + key=lambda task: task.next) + except KeyboardInterrupt: + self.run = False + if self.parentstop is not None: self.parentstop.set() + except SystemExit: + self.run = False + if self.parentstop is not None: self.parentstop.set() logging.debug("Qutting Scheduler thread") if self.parentqueue is not None: self.parentqueue.put(('quit', None, None)) diff --git a/sleekxmpp/xmlstream/statemachine.py b/sleekxmpp/xmlstream/statemachine.py deleted file mode 100644 index 8a1aa22d..00000000 --- a/sleekxmpp/xmlstream/statemachine.py +++ /dev/null @@ -1,59 +0,0 @@ -""" - SleekXMPP: The Sleek XMPP Library - Copyright (C) 2010 Nathanael C. Fritz - This file is part of SleekXMPP. - - See the file LICENSE for copying permission. -""" -from __future__ import with_statement -import threading - -class StateMachine(object): - - def __init__(self, states=[], groups=[]): - self.lock = threading.Lock() - self.__state = {} - self.__default_state = {} - self.__group = {} - self.addStates(states) - self.addGroups(groups) - - def addStates(self, states): - with self.lock: - for state in states: - if state in self.__state or state in self.__group: - raise IndexError("The state or group '%s' is already in the StateMachine." % state) - self.__state[state] = states[state] - self.__default_state[state] = states[state] - - def addGroups(self, groups): - with self.lock: - for gstate in groups: - if gstate in self.__state or gstate in self.__group: - raise IndexError("The key or group '%s' is already in the StateMachine." % gstate) - for state in groups[gstate]: - if state in self.__state: - raise IndexError("The group %s contains a key %s which is not set in the StateMachine." % (gstate, state)) - self.__group[gstate] = groups[gstate] - - def set(self, state, status): - with self.lock: - if state in self.__state: - self.__state[state] = bool(status) - else: - raise KeyError("StateMachine does not contain state %s." % state) - - def __getitem__(self, key): - if key in self.__group: - for state in self.__group[key]: - if not self.__state[state]: - return False - return True - return self.__state[key] - - def __getattr__(self, attr): - return self.__getitem__(attr) - - def reset(self): - self.__state = self.__default_state - diff --git a/sleekxmpp/xmlstream/statemanager.py b/sleekxmpp/xmlstream/statemanager.py deleted file mode 100644 index c7f76e75..00000000 --- a/sleekxmpp/xmlstream/statemanager.py +++ /dev/null @@ -1,139 +0,0 @@ -""" - SleekXMPP: The Sleek XMPP Library - Copyright (C) 2010 Nathanael C. Fritz, Lance J.T. Stout - This file is part of SleekXMPP. - - See the file LICENSE for copying permission. -""" - -from __future__ import with_statement -import threading - - -class StateError(Exception): - """Raised whenever a state transition was attempted but failed.""" - - -class StateManager(object): - """ - At the very core of SleekXMPP there is a need to track various - library configuration settings, XML stream features, and the - network connection status. The state manager is responsible for - tracking this information in a thread-safe manner. - - State 'variables' store the current state of these items as simple - string values or booleans. Changing those values must be done - according to transitions defined when creating the state variable. - - If a state variable is given a value that is not allowed according - to the transition definitions, a StateError is raised. When a - valid value is assigned an event is raised named: - - _state_changed_nameofthestatevariable - - The event carries a dictionary containing the previous and the new - state values. - """ - - def __init__(self, event_func=None): - """ - Initialize the state manager. The parameter event_func should be - the event() method of a SleekXMPP object in order to enable - _state_changed_* events. - """ - self.main_lock = threading.Lock() - self.locks = {} - self.state_variables = {} - - if event_func is not None: - self.event = event_func - else: - self.event = lambda name, data: None - - def add(self, name, default=False, values=None, transitions=None): - """ - Create a new state variable. - - When transitions is specified, only those defined state change - transitions will be allowed. - - When values is specified (and not transitions), any state changes - between those values are allowed. - - If neither values nor transitions are defined, then the state variable - will be a binary switch between True and False. - """ - if name in self.state_variables: - raise IndexError("State variable %s already exists" % name) - - self.locks[name] = threading.Lock() - with self.locks[name]: - var = {'value': default, - 'default': default, - 'transitions': {}} - - if transitions is not None: - for start in transitions: - var['transitions'][start] = set(transitions[start]) - elif values is not None: - values = set(values) - for value in values: - var['transitions'][value] = values - elif values is None: - var['transitions'] = {True: [False], - False: [True]} - - self.state_variables[name] = var - - def addStates(self, var_defs): - """ - Create multiple state variables at once. - """ - for var, data in var_defs: - self.add(var, - default=data.get('default', False), - values=data.get('values', None), - transitions=data.get('transitions', None)) - - def force_set(self, name, val): - """ - Force setting a state variable's value by overriding transition checks. - """ - with self.locks[name]: - self.state_variables[name]['value'] = val - - def reset(self, name): - """ - Reset a state variable to its default value. - """ - with self.locks[name]: - default = self.state_variables[name]['default'] - self.state_variables[name]['value'] = default - - def __getitem__(self, name): - """ - Get the value of a state variable if it exists. - """ - with self.locks[name]: - if name not in self.state_variables: - raise IndexError("State variable %s does not exist" % name) - return self.state_variables[name]['value'] - - def __setitem__(self, name, val): - """ - Attempt to set the value of a state variable, but raise StateError - if the transition is undefined. - - A _state_changed_* event is triggered after a successful transition. - """ - with self.locks[name]: - if name not in self.state_variables: - raise IndexError("State variable %s does not exist" % name) - current = self.state_variables[name]['value'] - if current == val: - return - if val in self.state_variables[name]['transitions'][current]: - self.state_variables[name]['value'] = val - self.event('_state_changed_%s' % name, {'from': current, 'to': val}) - else: - raise StateError("Can not transition from '%s' to '%s'" % (str(current), str(val))) diff --git a/sleekxmpp/xmlstream/xmlstream.py b/sleekxmpp/xmlstream/xmlstream.py index 3152ec94..23aef6b7 100644 --- a/sleekxmpp/xmlstream/xmlstream.py +++ b/sleekxmpp/xmlstream/xmlstream.py @@ -21,7 +21,8 @@ try: except ImportError: import Queue as queue -from sleekxmpp.xmlstream import StateMachine, Scheduler, tostring +from sleekxmpp.thirdparty.statemachine import StateMachine +from sleekxmpp.xmlstream import Scheduler, tostring from sleekxmpp.xmlstream.stanzabase import StanzaBase, ET # In Python 2.x, file socket objects are broken. A patched socket @@ -92,6 +93,8 @@ class XMLStream(object): stream_header -- The closing tag of the stream's root element. use_ssl -- Flag indicating if SSL should be used. use_tls -- Flag indicating if TLS should be used. + stop -- threading Event used to stop all threads. + auto_reconnect-- Flag to determine whether we auto reconnect. Methods: add_event_handler -- Add a handler for a custom event. @@ -152,15 +155,8 @@ class XMLStream(object): self.ssl_support = SSL_SUPPORT - # TODO: Integrate the new state machine. - self.state = StateMachine() - self.state.addStates({'connected': False, - 'is client': False, - 'ssl': False, - 'tls': False, - 'reconnect': True, - 'processing': False, - 'disconnecting': False}) + self.state = StateMachine(('disconnected', 'connected')) + self.state._set_state('disconnected') self.address = (host, int(port)) self.filesocket = None @@ -178,9 +174,10 @@ class XMLStream(object): self.stream_header = "<stream>" self.stream_footer = "</stream>" + self.stop = threading.Event() self.event_queue = queue.Queue() self.send_queue = queue.Queue() - self.scheduler = Scheduler(self.event_queue) + self.scheduler = Scheduler(self.event_queue, self.stop) self.namespace_map = {} @@ -193,7 +190,8 @@ class XMLStream(object): self._id = 0 self._id_lock = threading.Lock() - self.run = True + self.auto_reconnect = True + self.is_client = False def new_id(self): """ @@ -232,17 +230,23 @@ class XMLStream(object): if host and port: self.address = (host, int(port)) + self.is_client = True # Respect previous SSL and TLS usage directives. if use_ssl is not None: self.use_ssl = use_ssl if use_tls is not None: self.use_tls = use_tls - self.state.set('is client', True) - # Repeatedly attempt to connect until a successful connection # is established. - while reattempt and not self.state['connected']: + connected = self.state.transition('disconnected', 'connected', func=self._connect) + while reattempt and not connected: + connected = self.state.transition('disconnected', 'connected', func=self._connect) + return connected + + + def _connect(self): + self.stop.clear() self.socket = self.socket_class(socket.AF_INET, socket.SOCK_STREAM) self.socket.settimeout(None) if self.use_ssl and self.ssl_support: @@ -257,13 +261,15 @@ class XMLStream(object): try: self.socket.connect(self.address) - self.set_socket(self.socket) - self.state.set('connected', True) + self.set_socket(self.socket, ignore=True) + #this event is where you should set your application state + self.event("connected", direct=True) return True except socket.error as serr: error_msg = "Could not connect. Socket Error #%s: %s" logging.error(error_msg % (serr.errno, serr.strerror)) time.sleep(1) + return False def disconnect(self, reconnect=False): """ @@ -277,40 +283,38 @@ class XMLStream(object): and processing should be restarted. Defaults to False. """ - self.event("disconnected") - self.state.set('reconnect', reconnect) - if self.state['disconnecting']: - return - if not self.state['reconnect']: - logging.debug("Disconnecting...") - self.state.set('disconnecting', True) - self.run = False - self.scheduler.run = False - if self.state['connected']: - # Send the end of stream marker. - self.send_raw(self.stream_footer) - # Wait for confirmation that the stream was - # closed in the other direction. - time.sleep(1) + self.state.transition('connected', 'disconnected', wait=0.0, func=self._disconnect, args=(reconnect,)) + + def _disconnect(self, reconnect=False): + # Send the end of stream marker. + self.send_raw(self.stream_footer) + # Wait for confirmation that the stream was + # closed in the other direction. + time.sleep(1) + if not reconnect: + self.auto_reconnect = False + self.stop.set() try: self.socket.close() self.filesocket.close() self.socket.shutdown(socket.SHUT_RDWR) except socket.error as serr: pass + finally: + #clear your application state + self.event("disconnected", direct=True) + return True + def reconnect(self): """ Reset the stream's state and reconnect to the server. """ - logging.info("Reconnecting") - self.event("disconnected") - self.state.set('tls', False) - self.state.set('ssl', False) - time.sleep(1) - self.connect() + logging.debug("reconnecting...") + self.state.transition('connected', 'disconnected', wait=0.0, func=self._disconnect, args=(True,)) + return self.state.transition('disconnected', 'connected', wait=0.0, func=self._connect) - def set_socket(self, socket): + def set_socket(self, socket, ignore=False): """ Set the socket to use for the stream. @@ -318,6 +322,7 @@ class XMLStream(object): Arguments: socket -- The new socket to use. + ignore -- don't set the state """ self.socket = socket if socket is not None: @@ -331,7 +336,8 @@ class XMLStream(object): self.filesocket = FileSocket(self.socket) else: self.filesocket = self.socket.makefile('rb', 0) - self.state.set('connected', True) + if not ignore: + self.state._set_state('connected') def start_tls(self): """ @@ -490,17 +496,21 @@ class XMLStream(object): self.__event_handlers[name] = filter(filter_pointers, self.__event_handlers[name]) - def event(self, name, data={}): + def event(self, name, data={}, direct=False): """ Manually trigger a custom event. Arguments: - name -- The name of the event to trigger. - data -- Data that will be passed to each event handler. - Defaults to an empty dictionary. + name -- The name of the event to trigger. + data -- Data that will be passed to each event handler. + Defaults to an empty dictionary. + direct -- Runs the event directly if True. """ for handler in self.__event_handlers.get(name, []): - self.event_queue.put(('event', handler, copy.copy(data))) + if direct: + handler[0](copy.copy(data)) + else: + self.event_queue.put(('event', handler, copy.copy(data))) if handler[2]: # If the handler is disposable, we will go ahead and # remove it now instead of waiting for it to be @@ -640,49 +650,36 @@ class XMLStream(object): # The body of this loop will only execute once per connection. # Additional passes will be made only if an error occurs and # reconnecting is permitted. - while self.run and (firstrun or self.state['reconnect']): - self.state.set('processing', True) + while not self.stop.isSet() and firstrun or self.auto_reconnect: firstrun = False try: - if self.state['is client']: + if self.is_client: self.send_raw(self.stream_header) # The call to self.__read_xml will block and prevent # the body of the loop from running until a disconnect # occurs. After any reconnection, the stream header will # be resent and processing will resume. - while self.run and self.__read_xml(): + while not self.stop.isSet() and self.__read_xml(): # Ensure the stream header is sent for any # new connections. - if self.state['is client']: + if self.is_client: self.send_raw(self.stream_header) except KeyboardInterrupt: - logging.debug("Keyboard Escape Detected") - self.state.set('processing', False) - self.state.set('reconnect', False) - self.disconnect() - self.run = False - self.scheduler.run = False - self.event_queue.put(('quit', None, None)) - return + logging.debug("Keyboard Escape Detected in _process") + self.stop.set() except SystemExit: - self.event_queue.put(('quit', None, None)) - return + logging.debug("SystemExit in _process") + self.stop.set() except socket.error: - if not self.state.reconnect: - return - self.state.set('processing', False) logging.exception('Socket Error') - self.disconnect(reconnect=True) except: - if not self.state.reconnect: - return - self.state.set('processing', False) logging.exception('Connection error. Reconnecting.') - self.disconnect(reconnect=True) - if self.state['reconnect']: + if not self.stop.isSet() and self.auto_reconnect: self.reconnect() - self.state.set('processing', False) - self.event_queue.put(('quit', None, None)) + else: + self.disconnect() + self.event_queue.put(('quit', None, None)) + self.scheduler.run = False def __read_xml(self): """ @@ -705,7 +702,6 @@ class XMLStream(object): if depth == 0: # The stream's root element has closed, # terminating the stream. - self.disconnect(reconnect=self.state['reconnect']) logging.debug("Ending read XML loop") return False elif depth == 1: @@ -754,8 +750,11 @@ class XMLStream(object): stanza_copy = stanza_type(self, copy.deepcopy(xml)) handler.prerun(stanza_copy) self.event_queue.put(('stanza', handler, stanza_copy)) - if handler.checkDelete(): - self.__handlers.pop(self.__handlers.index(handler)) + try: + if handler.checkDelete(): + self.__handlers.pop(self.__handlers.index(handler)) + except: + pass #not thread safe unhandled = False # Some stanzas require responses, such as Iq queries. A default @@ -773,61 +772,73 @@ class XMLStream(object): handlers may be spawned in individual threads. """ logging.debug("Loading event runner") - while self.run: - try: - event = self.event_queue.get(True, timeout=5) - except queue.Empty: - event = None - except KeyboardInterrupt: - self.run = False - self.scheduler.run = False - if event is None: - continue + try: + while not self.stop.isSet(): + try: + event = self.event_queue.get(True, timeout=5) + except queue.Empty: + event = None + if event is None: + continue - etype, handler = event[0:2] - args = event[2:] + etype, handler = event[0:2] + args = event[2:] - if etype == 'stanza': - try: - handler.run(args[0]) - except Exception as e: - error_msg = 'Error processing stream handler: %s' - logging.exception(error_msg % handler.name) - args[0].exception(e) - elif etype == 'schedule': - try: - logging.debug(args) - handler(*args[0]) - except: - logging.exception('Error processing scheduled task') - elif etype == 'event': - func, threaded, disposable = handler - try: - if threaded: - x = threading.Thread(name="Event_%s" % str(func), - target=func, - args=args) - x.start() - else: - func(*args) - except: - logging.exception('Error processing event handler: %s') - elif etype == 'quit': - logging.debug("Quitting event runner thread") - return False + if etype == 'stanza': + try: + handler.run(args[0]) + except Exception as e: + error_msg = 'Error processing stream handler: %s' + logging.exception(error_msg % handler.name) + args[0].exception(e) + elif etype == 'schedule': + try: + logging.debug(args) + handler(*args[0]) + except: + logging.exception('Error processing scheduled task') + elif etype == 'event': + func, threaded, disposable = handler + try: + if threaded: + x = threading.Thread(name="Event_%s" % str(func), + target=func, + args=args) + x.start() + else: + func(*args) + except: + logging.exception('Error processing event handler: %s') + elif etype == 'quit': + logging.debug("Quitting event runner thread") + return False + except KeyboardInterrupt: + logging.debug("Keyboard Escape Detected in _event_runner") + self.disconnect() + return + except SystemExit: + self.disconnect() + self.event_queue.put(('quit', None, None)) + return def _send_thread(self): """ Extract stanzas from the send queue and send them on the stream. """ - while self.run: - data = self.send_queue.get(True) - logging.debug("SEND: %s" % data) - try: - self.socket.send(data.encode('utf-8')) - except: - logging.warning("Failed to send %s" % data) - self.state.set('connected', False) - if self.state.reconnect: - logging.exception("Disconnected. Socket Error.") - self.disconnect(reconnect=True) + try: + while not self.stop.isSet(): + data = self.send_queue.get(True) + logging.debug("SEND: %s" % data) + try: + self.socket.send(data.encode('utf-8')) + except: + logging.warning("Failed to send %s" % data) + self.disconnect(self.auto_reconnect) + except KeyboardInterrupt: + logging.debug("Keyboard Escape Detected in _send_thread") + self.disconnect() + return + except SystemExit: + self.disconnect() + self.event_queue.put(('quit', None, None)) + return |