def __init__(self, *args, **kwargs): """ Create a new test socket. Arguments: Same as arguments for socket.socket """ self.socket = socket.socket(*args, **kwargs) self.recv_queue = Queue() self.send_queue = Queue() self.is_live = False self.disconnected = False
def __init__(self, *args, **kwargs): """ Create a new, live test socket. Arguments: Same as arguments for socket.socket """ self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.recv_buffer = [] self.recv_queue = Queue() self.send_queue = Queue() self.send_queue_lock = threading.Lock() self.recv_queue_lock = threading.Lock() self.is_live = True
def __init__(self, xmpp, sid, block_size, to, ifrom, window_size=1, use_messages=False): self.xmpp = xmpp self.sid = sid self.block_size = block_size self.window_size = window_size self.use_messages = use_messages self.receiver = to self.sender = ifrom self.send_seq = -1 self.recv_seq = -1 self._send_seq_lock = threading.Lock() self._recv_seq_lock = threading.Lock() self.stream_started = threading.Event() self.stream_in_closed = threading.Event() self.stream_out_closed = threading.Event() self.recv_queue = Queue() self.send_window = threading.BoundedSemaphore(value=self.window_size) self.window_ids = set() self.window_empty = threading.Event() self.window_empty.set()
def __init__(self, xmpp, sid, block_size, jid, peer, window_size=1, use_messages=False): self.xmpp = xmpp self.sid = sid self.block_size = block_size self.window_size = window_size self.use_messages = use_messages if jid is None: jid = xmpp.boundjid self.self_jid = jid self.peer_jid = peer self.send_seq = -1 self.recv_seq = -1 self._send_seq_lock = threading.Lock() self._recv_seq_lock = threading.Lock() self.stream_started = threading.Event() self.stream_in_closed = threading.Event() self.stream_out_closed = threading.Event() self.recv_queue = Queue() self.send_window = threading.BoundedSemaphore(value=self.window_size) self.window_ids = set() self.window_empty = threading.Event() self.window_empty.set()
def __init__(self, parentstop=None): #: A queue for storing tasks self.addq = Queue() #: A list of tasks in order of execution time. self.schedule = [] #: If running in threaded mode, this will be the thread processing #: the schedule. self.thread = None #: A flag indicating that the scheduler is running. self.run = False #: An :class:`~threading.Event` instance for signalling to stop #: the scheduler. self.stop = parentstop #: Lock for accessing the task queue. self.schedule_lock = threading.RLock()
def __init__(self, master, jid_password): self.master = master self.buffer_size = 0 #number of bytes of data waiting to be sent self.buffer_queue = Queue() self.buffer_size_lock = threading.Lock() self.num_clients = 0 #number of clients sockets using this bot self.num_clients_lock = threading.Lock() self.__failed_send_stanza = None #some sleekxmpp thing for resending stuff sleekxmpp.ClientXMPP.__init__(self, *jid_password) # gmail xmpp server is actually at talk.google.com if jid_password[0].find("@gmail.com") != -1: self.connect_address = ("talk.google.com", 5222) else: self.connect_address = None # event handlers are sleekxmpp's way of dealing with important xml tags it receives self.add_event_handler("session_start", lambda event: self.session_start()) self.add_event_handler("disconnected", lambda event: self.disconnected()) self.register_plugin('xep_0199') # Ping
def __init__(self, parentstop=None): #: A queue for storing tasks self.addq = Queue() #: A list of tasks in order of execution time. self.schedule = [] #: If running in threaded mode, this will be the thread processing #: the schedule. self.thread = None #: A flag indicating that the scheduler is running. self.run = False #: An :class:`~threading.Event` instance for signalling to stop #: the scheduler. self.stop = parentstop #: Lock for accessing the task queue. self.schedule_lock = threading.RLock() #: The time in seconds to wait for events from the event queue, #: and also the time between checks for the process stop signal. self.wait_timeout = WAIT_TIMEOUT
def __init__(self, name, matcher, stream=None): BaseHandler.__init__(self, name, matcher, stream=stream) self._payload = Queue()
def stream_start(self, mode='client', skip=True, header=None, socket='mock', jid='tester@localhost', password='******', server='localhost', port=5222, sasl_mech=None, plugins=None, plugin_config={}): """ Initialize an XMPP client or component using a dummy XML stream. Arguments: mode -- Either 'client' or 'component'. Defaults to 'client'. skip -- Indicates if the first item in the sent queue (the stream header) should be removed. Tests that wish to test initializing the stream should set this to False. Otherwise, the default of True should be used. socket -- Either 'mock' or 'live' to indicate if the socket should be a dummy, mock socket or a live, functioning socket. Defaults to 'mock'. jid -- The JID to use for the connection. Defaults to 'tester@localhost'. password -- The password to use for the connection. Defaults to 'test'. server -- The name of the XMPP server. Defaults to 'localhost'. port -- The port to use when connecting to the server. Defaults to 5222. plugins -- List of plugins to register. By default, all plugins are loaded. """ if mode == 'client': self.xmpp = ClientXMPP(jid, password, sasl_mech=sasl_mech, plugin_config=plugin_config) elif mode == 'component': self.xmpp = ComponentXMPP(jid, password, server, port, plugin_config=plugin_config) else: raise ValueError("Unknown XMPP connection mode.") # Remove unique ID prefix to make it easier to test self.xmpp._id_prefix = '' self.xmpp._disconnect_wait_for_threads = False self.xmpp.default_lang = None self.xmpp.peer_default_lang = None # We will use this to wait for the session_start event # for live connections. skip_queue = Queue() if socket == 'mock': self.xmpp.set_socket(TestSocket()) # Simulate connecting for mock sockets. self.xmpp.auto_reconnect = False self.xmpp.state._set_state('connected') # Must have the stream header ready for xmpp.process() to work. if not header: header = self.xmpp.stream_header self.xmpp.socket.recv_data(header) elif socket == 'live': self.xmpp.socket_class = TestLiveSocket def wait_for_session(x): self.xmpp.socket.clear() skip_queue.put('started') self.xmpp.add_event_handler('session_start', wait_for_session) if server is not None: self.xmpp.connect((server, port)) else: self.xmpp.connect() else: raise ValueError("Unknown socket type.") if plugins is None: self.xmpp.register_plugins() else: for plugin in plugins: self.xmpp.register_plugin(plugin) # Some plugins require messages to have ID values. Set # this to True in tests related to those plugins. self.xmpp.use_message_ids = False self.xmpp.process(threaded=True) if skip: if socket != 'live': # Mark send queue as usable self.xmpp.session_started_event.set() # Clear startup stanzas self.xmpp.socket.next_sent(timeout=1) if mode == 'component': self.xmpp.socket.next_sent(timeout=1) else: skip_queue.get(block=True, timeout=10)