def _NH_VirtualGroupWasActivated(self, notification):
group = notification.sender
self.groups[group.id] = group
notification_center = NotificationCenter()
notification_center.post_notification(
'VirtualGroupsManagerDidAddGroup',
sender=self,
data=NotificationData(group=group))
def _OH_EndOperation(self, operation):
if self.state not in ('connecting', 'connected'):
return
if self._timer is not None and self._timer.active():
self._timer.cancel()
self._timer = None
prev_state = self.state
self.state = 'terminating'
notification_center = NotificationCenter()
notification_center.post_notification('JingleSessionWillEnd', self)
streams = (self.streams or []) + (self.proposed_streams or [])
for stream in streams[:]:
try:
notification_center.remove_observer(self, sender=stream)
except KeyError:
streams.remove(stream)
else:
stream.deactivate()
if prev_state == 'connected':
reason = jingle.Reason(jingle.ReasonType('success'))
else:
reason = jingle.Reason(jingle.ReasonType('cancel'))
stanza = self._protocol.sessionTerminate(self._local_jid,
self._remote_jid, self._id,
reason)
self._send_stanza(stanza)
self.state = 'terminated'
if prev_state == 'connected':
self.end_time = datetime.now()
notification_center.post_notification(
'JingleSessionDidEnd', self,
NotificationData(originator='local'))
else:
notification_center.post_notification(
'JingleSessionDidFail', self,
NotificationData(originator='local', reason='cancel'))
for stream in streams:
stream.end()
self._channel.send_exception(proc.ProcExit)
def lookup_xcap_server(self, uri, timeout=3.0, lifetime=15.0):
"""
Performs a TXT query against xcap.<uri.host> and returns all results
that look like HTTP URIs.
"""
log_context = dict(context='lookup_xcap_server', uri=uri)
notification_center = NotificationCenter()
try:
# If the host part of the URI is an IP address, we cannot not do any lookup
if re.match("^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$", uri.host):
raise DNSLookupError(
"Cannot perform DNS query because the host is an IP address"
)
resolver = DNSResolver()
resolver.cache = self.cache
resolver.timeout = timeout
resolver.lifetime = lifetime
record_name = 'xcap.%s' % uri.host
results = []
try:
answer = resolver.query(record_name, rdatatype.TXT)
except dns.resolver.Timeout, e:
notification_center.post_notification(
'DNSLookupTrace',
sender=self,
data=NotificationData(query_type='TXT',
query_name=str(record_name),
nameservers=resolver.nameservers,
answer=None,
error=e,
**log_context))
raise
except exception.DNSException, e:
notification_center.post_notification(
'DNSLookupTrace',
sender=self,
data=NotificationData(query_type='TXT',
query_name=str(record_name),
nameservers=resolver.nameservers,
answer=None,
error=e,
**log_context))
def _CH_register(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._register_timer is not None and self._register_timer.active():
self._register_timer.cancel()
self._register_timer = None
supported_transports = set(
transport for transport in settings.sip.transport_list
if transport != 'tls' or self.account.tls.certificate is not None)
registered_transports = set(
file.transport for file in self._files
if isinstance(file, BonjourRegistrationFile))
missing_transports = supported_transports - registered_transports
added_transports = set()
for transport in missing_transports:
notification_center.post_notification(
'BonjourAccountWillRegister',
sender=self.account,
data=NotificationData(transport=transport))
try:
contact = self.account.contact[NoGRUU, transport]
instance_id = str(uuid.UUID(settings.instance_id))
txtdata = dict(txtvers=1,
name=self.account.display_name.encode('utf-8'),
contact="<%s>" % str(contact),
instance_id=instance_id)
state = self.account.presence_state
if self.account.presence.enabled and state is not None:
txtdata['state'] = state.state
txtdata['note'] = state.note.encode('utf-8')
file = _bonjour.DNSServiceRegister(
name=str(contact),
regtype="_sipuri._%s" %
(transport if transport == 'udp' else 'tcp'),
port=contact.port,
callBack=self._register_cb,
txtRecord=_bonjour.TXTRecord(items=txtdata))
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification(
'BonjourAccountRegistrationDidFail',
sender=self.account,
data=NotificationData(reason=str(e), transport=transport))
else:
self._files.append(BonjourRegistrationFile(file, transport))
added_transports.add(transport)
def _on_transaction_response(self, message_id, response):
if message_id in self.sent_messages and response.code != 200:
self.sent_messages.remove(message_id)
data = NotificationData(message_id=message_id,
message=response,
code=response.code,
reason=response.comment)
NotificationCenter().post_notification(
'ChatStreamDidNotDeliverMessage', sender=self, data=data)
def sendMessage(self, payload, *args, **kw):
self.notification_center.post_notification('WebRTCClientTrace',
sender=self,
data=NotificationData(
direction='OUTGOING',
message=payload,
peer=self.peer))
super(SylkWebSocketServerProtocol,
self).sendMessage(payload, *args, **kw)
def _NH_FileTransferHandlerHashProgress(self, notification):
progress = int(notification.data.processed * 100 /
notification.data.total)
if self.progress is None or progress > self.progress:
self.progress = progress
notification.center.post_notification(
'BlinkFileTransferHashProgress',
sender=self,
data=NotificationData(progress=progress))
def exception(self, message='', *args, **kw):
if self.log_settings.trace_msrp:
message = message % args if args else message
exception = traceback.format_exc()
self.notification_center.post_notification(
'MSRPLibraryLog',
data=NotificationData(message=message + '\n' +
exception if message else exception,
level=self.level.ERROR))
def _NH_MediaStreamWillEnd(self, notification):
if self._started:
self.end()
elif self._session_started:
notification.center.post_notification('FileTransferHandlerDidEnd',
sender=self,
data=NotificationData(
error=True,
reason='Refused'))
def _on_transaction_response(self, response):
if self.stop_event.is_set():
return
if response.code != 200:
NotificationCenter().post_notification(
'FileTransferHandlerError',
sender=self,
data=NotificationData(error=response.comment))
self.end()
def _run(self):
notification_center = NotificationCenter()
while True:
item = self.channel.wait()
if isinstance(item, ChatMessage):
notification_center.post_notification(
'XMPPChatSessionGotMessage',
sender=self,
data=NotificationData(message=item))
elif isinstance(item, ChatComposingIndication):
if item.state == 'gone':
self._clear_pending_receipts()
notification_center.post_notification(
'XMPPChatSessionDidEnd',
sender=self,
data=NotificationData(originator='remote'))
self.state = 'terminated'
break
else:
notification_center.post_notification(
'XMPPChatSessionGotComposingIndication',
sender=self,
data=NotificationData(message=item))
elif isinstance(item, MessageReceipt):
if item.receipt_id in self.pending_receipts:
timer = self.pending_receipts.pop(item.receipt_id)
timer.cancel()
notification_center.post_notification(
'XMPPChatSessionDidDeliverMessage',
sender=self,
data=NotificationData(message_id=item.receipt_id))
elif isinstance(item, ErrorStanza):
if item.id in self.pending_receipts:
timer = self.pending_receipts.pop(item.id)
timer.cancel()
# TODO: translate cause
notification_center.post_notification(
'XMPPChatSessionDidNotDeliverMessage',
sender=self,
data=NotificationData(message_id=item.id,
code=503,
reason='Service Unavailable'))
self._proc = None
def end(self):
self.send_composing_indication('gone')
self._clear_pending_receipts()
self._proc.kill()
self._proc = None
NotificationCenter().post_notification(
'XMPPChatSessionDidEnd',
sender=self,
data=NotificationData(originator='local'))
self.state = 'terminated'
def muted(self, value):
if not isinstance(value, bool):
raise ValueError("illegal value for muted property: %r" % (value,))
if value == self.muted:
return
old_producer_slot = self.producer_slot
self.__dict__['muted'] = value
notification_center = NotificationCenter()
data = NotificationData(consumer_slot_changed=False, producer_slot_changed=True, old_producer_slot=old_producer_slot, new_producer_slot=self.producer_slot)
notification_center.post_notification('AudioPortDidChangeSlots', sender=self, data=data)
def _NH_RTPTransportZRTPNotSupportedByRemote(self, notification):
stream = self._stream
with stream._lock:
if stream.state == "ENDED":
return
reason = 'ZRTP not supported by remote'
notification.center.post_notification(
'RTPStreamDidNotEnableEncryption',
sender=stream,
data=NotificationData(reason=reason))
def _NH_RTPTransportZRTPNegotiationFailed(self, notification):
stream = self._stream
with stream._lock:
if stream.state == "ENDED":
return
reason = 'Negotiation failed: %s' % notification.data.reason
notification.center.post_notification(
'RTPStreamDidNotEnableEncryption',
sender=stream,
data=NotificationData(reason=reason))
def _handle_REPORT(self, chunk):
# in theory, REPORT can come with Byte-Range which would limit the scope of the REPORT to the part of the message.
if chunk.message_id in self.sent_messages:
self.sent_messages.remove(chunk.message_id)
notification_center = NotificationCenter()
data = NotificationData(message_id=chunk.message_id, message=chunk, code=chunk.status.code, reason=chunk.status.comment)
if chunk.status.code == 200:
notification_center.post_notification('ChatStreamDidDeliverMessage', sender=self, data=data)
else:
notification_center.post_notification('ChatStreamDidNotDeliverMessage', sender=self, data=data)
def _NH_SIPMessageDidFail(self, notification):
if self.content_type.lower() in self.__ignored_content_types__:
return
notification_center = NotificationCenter()
notification_center.post_notification('BlinkMessageDidFail',
sender=self.session,
data=NotificationData(
data=notification.data,
id=self.id))
def end(self):
if self.state == 'terminated':
return
self._proc.kill()
self._proc = None
NotificationCenter().post_notification(
'XMPPSubscriptionDidEnd',
sender=self,
data=NotificationData(originator='local'))
self.state = 'terminated'
def _NH_SIPMessageDidSucceed(self, notification):
notification_center = NotificationCenter()
if self.content_type.lower() in self.__ignored_content_types__:
if self.content_type.lower() == IMDNDocument.content_type:
document = IMDNDocument.parse(self.content)
imdn_message_id = document.message_id.value
imdn_status = document.notification.status.__str__()
notification_center.post_notification(
'BlinkDidSendDispositionNotification',
sender=self.session,
data=NotificationData(id=imdn_message_id,
status=imdn_status))
return
notification_center.post_notification('BlinkMessageDidSucceed',
sender=self.session,
data=NotificationData(
data=notification.data,
id=self.id))
def wrapper(obj, *args, **kwargs):
notification_center = NotificationCenter()
try:
result = func(obj, *args, **kwargs)
except DNSLookupError, e:
notification_center.post_notification(
'DNSLookupDidFail',
sender=obj,
data=NotificationData(error=str(e)))
raise
def _NH_MediaStreamDidEnd(self, notification):
if self.message_queue_thread is not None:
self.message_queue_thread.kill()
else:
message_queue, self.message_queue = self.message_queue, queue()
while message_queue:
message = message_queue.wait()
if message.notify_progress:
data = NotificationData(message_id=message.id, message=None, code=0, reason='Stream ended')
notification.center.post_notification('ChatStreamDidNotDeliverMessage', sender=self, data=data)
def process_chunk(self, chunk):
# here we process the REPORT chunks
notification_center = NotificationCenter()
if chunk.status.code == 200:
transferred_bytes = chunk.byte_range.end
total_bytes = chunk.byte_range.total
notification_center.post_notification(
'FileTransferHandlerProgress',
sender=self,
data=NotificationData(transferred_bytes=transferred_bytes,
total_bytes=total_bytes))
if transferred_bytes == total_bytes:
self.finished_event.set()
self.end()
else:
notification_center.post_notification(
'FileTransferHandlerError',
sender=self,
data=NotificationData(error=chunk.status.comment))
self.end()
def probeReceived(self, stanza):
sender_uri = FrozenURI.parse('xmpp:' + stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:' + stanza.element['to'])
recipient = Identity(recipient_uri)
id = stanza.element.getAttribute('id')
presence_stanza = ProbePresence(sender, recipient, id=id)
NotificationCenter().post_notification(
'XMPPGotPresenceProbe',
sender=self.parent,
data=NotificationData(presence_stanza=presence_stanza))
def initialize(self, stream, session):
super(OutgoingFileTransferHandler, self).initialize(stream, session)
if stream.file_selector.fd is None:
NotificationCenter().post_notification(
'FileTransferHandlerDidNotInitialize',
sender=self,
data=NotificationData(reason='file descriptor not specified'))
return
if stream.file_selector.size == 0:
NotificationCenter().post_notification(
'FileTransferHandlerDidNotInitialize',
sender=self,
data=NotificationData(reason='file is empty'))
return
if stream.file_selector.hash is None:
self._calculate_file_hash()
else:
NotificationCenter().post_notification(
'FileTransferHandlerDidInitialize', sender=self)
def _NH_SIPSessionDidFail(self, notification):
if not self._session_started and self._initialize_successful:
if notification.data.code == 487:
reason = 'Cancelled'
else:
reason = notification.data.reason or 'Failed'
notification.center.post_notification('FileTransferHandlerDidEnd',
sender=self,
data=NotificationData(
error=True,
reason=reason))
def _clear_pending_receipts(self):
notification_center = NotificationCenter()
while self.pending_receipts:
message_id, timer = self.pending_receipts.popitem()
timer.cancel()
notification_center.post_notification(
'XMPPChatSessionDidNotDeliverMessage',
sender=self,
data=NotificationData(message_id=message_id,
code=408,
reason='Timeout'))
def changeStatus(self, newstate, fail_reason=None):
self.sessionController.log_debug("%s changed state to %s" %
(self, newstate))
self.sessionController.log_debug(
"Session state=%s, substate=%s, proposal=%s" %
(self.sessionController.state, self.sessionController.sub_state,
self.sessionController.inProposal))
NotificationCenter().post_notification(
"BlinkStreamHandlerChangedState",
sender=self,
data=NotificationData(state=newstate, detail=fail_reason))
def received_illegal_data(self, data, transport):
if self.log_settings.trace_msrp:
notification_data = NotificationData(
direction='incoming',
local_address=transport.getHost(),
remote_address=transport.getPeer(),
data=data,
illegal=True)
self.notification_center.post_notification('MSRPTransportTrace',
sender=transport,
data=notification_data)
def _NH_MediaStreamDidNotInitialize(self, notification):
message_queue, self.message_queue = self.message_queue, queue()
while message_queue:
message = message_queue.wait()
if message.notify_progress:
data = NotificationData(message_id=message.id,
message=None,
code=0,
reason='Stream was closed')
notification.center.post_notification(
'ChatStreamDidNotDeliverMessage', sender=self, data=data)
def _enqueue_message(self, message):
if self._done:
if message.notify_progress:
data = NotificationData(message_id=message.id,
message=None,
code=0,
reason='Stream ended')
NotificationCenter().post_notification(
'ChatStreamDidNotDeliverMessage', sender=self, data=data)
else:
self.message_queue.send(message)
