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 __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 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 _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 __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 _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_delivered(self, trid):
callback, errback = self._delivery_callbacks.pop(trid, (None, None))
run(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 __on_command_sent(self, command, user_callback):
self.emit("command-sent", command)
run(user_callback)
def _command_answered_cb(self, tr_id, *args):
callback, errback = self._callbacks.get(tr_id, (None, None))
run(callback, *args)
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 _on_message_sent(self, message, user_callback):
run(user_callback)
self.emit("message-sent", message)
def callback(self):
"""Run the callback function if supplied"""
run(self._callback)
def __common_errback(self, error, errback=None):
run(errback, error)
self.emit('error', error)
def errback(self, error):
"""Run the errback function if supplied"""
run(self._errback, error)
