def __on_sent(self, transport, http_request): if len(self._command_queue) == 0: return command, increment, callback, errback = self._command_queue.pop(0) if command is not None: run(callback) self.emit("command-sent", command)
def send(self, buffer, callback=None, errback=None): if self._status != IoStatus.OPEN: run(errback, IoConnectionClosed(self, self._status)) return self._outgoing_queue.append( OutgoingPacket(buffer, len(buffer), callback, errback)) self._watch_add_cond(gobject.IO_OUT)
def send(self, buffer, callback=None, errback=None): if self._status != IoStatus.OPEN: run(errback, IoConnectionClosed(self, self._status)) return self._outgoing_queue.append(OutgoingPacket(buffer, len(buffer), callback, errback)) self._watch_add_cond(glib.IO_OUT)
def on_request_timeout(self, id): if id not in self._requests: return logger.info("Timeout on TURN request") callback, errback, count, result = self._requests.pop(id) run(callback, result) if not self._requests: self._transport.close()
def __on_message_undelivered(self, trid): callback, errback = self._delivery_callbacks.pop(trid, (None, None)) error = MessageError.DELIVERY_FAILED run(errback, error) if hasattr(self, "max_chunk_size"): self._on_error(ConversationErrorType.P2P, error) else: self._on_error(ConversationErrorType.MESSAGE, error)
def send_command(self, command, increment=True, callback=None, errback=None): if self.__error: logger.warning("Transport is errored, not sending %s" % command.name) run(errback, self.__error) return logger.debug('>>> ' + unicode(command)) self._transport.send(str(command), (self.__on_command_sent, command, callback), errback) if increment: self._increment_transaction_id()
def __remove_contact(self, contact, removed_memberships, done_cb=None): emit_deleted = False if removed_memberships & Membership.FORWARD \ and contact.is_member(Membership.FORWARD): emit_deleted = True contact._remove_membership(removed_memberships) # Do not use __common_callback() here to avoid race # conditions with the event-triggered contact._reset(). run(done_cb, contact) if contact.memberships == Membership.NONE: self.contacts.discard(contact) if emit_deleted: self.emit('contact-deleted', contact)
def query(self, host, callback, errback): try: result = socket.getaddrinfo(host, None, socket.AF_INET, socket.SOCK_STREAM) except socket.gaierror: result = [] if len(result) == 0: run(errback, HostnameError(host)) return cname = result[0][3] expires = 0 addresses = ((socket.AF_INET, result[0][4][0]),) run(callback, HostnameResponse((cname, expires, addresses)))
def on_relay_discovered(self, relay): logger.info("Discovered %s" % str(relay)) keys = self._requests.keys() if not keys: logger.warning("No active request necessitating new relay") return keys.sort() callback, errback, count, result = self._requests.get(keys[0]) result.append(relay) if len(result) >= count: del self._requests[keys[0]] run(callback, result) if not self._requests: self.stop_all_timeout() self._transport.close()
def _handle_XFR(self, command): if command.arguments[0] == 'NS': try: host, port = command.arguments[1].split(":", 1) port = int(port) except ValueError: host = command.arguments[1] port = self._transport.server[1] logger.debug("<-> Redirecting to " + command.arguments[1]) self._transport.reset_connection((host,port)) else: # connect to a switchboard try: host, port = command.arguments[1].split(":", 1) port = int(port) except ValueError: host = command.arguments[1] port = self._transport.server[1] session_id = command.arguments[3] callback = self.__switchboard_callbacks.pop(0) run(callback, ((host, port), session_id, None))
def _handle_XFR(self, command): if command.arguments[0] == 'NS': try: host, port = command.arguments[1].split(":", 1) port = int(port) except ValueError: host = command.arguments[1] port = self._transport.server[1] logger.debug("<-> Redirecting to " + command.arguments[1]) self._transport.reset_connection((host, port)) else: # connect to a switchboard try: host, port = command.arguments[1].split(":", 1) port = int(port) except ValueError: host = command.arguments[1] port = self._transport.server[1] session_id = command.arguments[3] callback = self.__switchboard_callbacks.pop(0) run(callback, ((host, port), session_id, None))
def errback(self, error): """Run the errback function if supplied""" run(self._errback, error)
def callback(self): """Run the callback function if supplied""" run(self._callback)
def _on_message_sent(self, message, user_callback): run(user_callback) self.emit("message-sent", message)
def __common_errback(self, error, errback=None): run(errback, error) while self.__frozen: self.__unfreeze_address_book() self.emit('error', error)
def __common_callback(self, signal, callback, *args): if signal is not None: self.emit(signal, *args) run(callback, *args)
def _command_error_cb(self, tr_id, error): callback, errback = self._callbacks.get(tr_id, (None, None)) run(errback, error)
def __on_message_delivered(self, trid): callback, errback = self._delivery_callbacks.pop(trid, (None, None)) run(callback)
def _command_answered_cb(self, tr_id, *args): callback, errback = self._callbacks.get(tr_id, (None, None)) run(callback, *args)
def __on_command_sent(self, command, user_callback): self.emit("command-sent", command) run(user_callback)
def __on_message_undelivered(self, trid): callback, errback = self._delivery_callbacks.pop(trid, (None, None)) error = MessageError.DELIVERY_FAILED run(errback, error) self._on_error(ConversationErrorType.MESSAGE, error)
def __common_errback(self, error, errback=None): run(errback, error) self.emit('error', error)