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 deactivate(self):
if not self.started:
raise RuntimeError("not started")
self.active = False
self._command_channel.send(Command('unsubscribe'))
notification_center = NotificationCenter()
notification_center.post_notification(self.__class__.__name__ + 'DidDeactivate', sender=self)
def _NH_SIPOptionsDidFail(self, notification):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=notification.sender)
if not self._routes:
notification_center.post_notification('SIPOptionsRequestDidFail', sender=self, data=TimestampedNotificationData(code=notification.data.code, reason=notification.data.reason))
return
self._send_options()
def _CH_update_registrations(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._update_timer is not None and self._update_timer.active():
self._update_timer.cancel()
self._update_timer = None
available_transports = settings.sip.transport_list
old_files = []
for file in (f for f in self._files[:] if isinstance(f, BonjourRegistrationFile) and f.transport not in available_transports):
old_files.append(file)
self._files.remove(file)
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
update_failure = False
for file in (f for f in self._files if isinstance(f, BonjourRegistrationFile)):
try:
contact = self.account.contact[NoGRUU, file.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')
_bonjour.DNSServiceUpdateRecord(file.file, None, flags=0, rdata=_bonjour.TXTRecord(items=txtdata), ttl=0)
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourAccountRegistrationUpdateDidFail', sender=self.account, data=NotificationData(reason=str(e), transport=file.transport))
update_failure = True
def _browse_cb(self, file, flags, interface_index, error_code, service_name, regtype, reply_domain):
notification_center = NotificationCenter()
file = BonjourDiscoveryFile.find_by_file(file)
service_description = BonjourServiceDescription(service_name, regtype, reply_domain)
if error_code != _bonjour.kDNSServiceErr_NoError:
error = _bonjour.BonjourError(error_code)
notification_center.post_notification('BonjourConferenceServicesDiscoveryDidFail', sender=self, data=NotificationData(reason=str(error), transport=file.transport))
removed_files = [file] + [f for f in self._files if isinstance(f, BonjourResolutionFile) and f.discovery_file==file]
for f in removed_files:
self._files.remove(f)
self._select_proc.kill(RestartSelect)
for f in removed_files:
f.close()
if self._discover_timer is None:
self._discover_timer = reactor.callLater(1, self._command_channel.send, Command('discover'))
return
if reply_domain != 'local.':
return
if flags & _bonjour.kDNSServiceFlagsAdd:
try:
resolution_file = (f for f in self._files if isinstance(f, BonjourResolutionFile) and f.discovery_file==file and f.service_description==service_description).next()
except StopIteration:
try:
resolution_file = _bonjour.DNSServiceResolve(0, interface_index, service_name, regtype, reply_domain, self._resolve_cb)
except _bonjour.BonjourError, e:
notification_center.post_notification('BonjourConferenceServicesDiscoveryFailure', sender=self, data=NotificationData(error=str(e), transport=file.transport))
else:
resolution_file = BonjourResolutionFile(resolution_file, discovery_file=file, service_description=service_description)
self._files.append(resolution_file)
self._select_proc.kill(RestartSelect)
def start(self):
notification_center = NotificationCenter()
download_folder = unicodedata.normalize('NFC', NSSearchPathForDirectoriesInDomains(NSDownloadsDirectory, NSUserDomainMask, True)[0])
for name in self.filename_generator(os.path.join(download_folder, self.file_name)):
if not os.path.exists(name) and not os.path.exists(name+".download"):
self.file_path = name + '.download'
break
self.ft_info = FileTransferInfo(transfer_id=self.transfer_id, direction='incoming', local_uri=format_identity_to_string(self.account) if self.account is not BonjourAccount() else 'bonjour' , file_size=self.file_size, remote_uri=self.remote_identity, file_path=self.file_path)
self.log_info(u"Will write file to %s" % self.file_path)
self.file_selector.fd = open(self.file_path, "w+")
self.ft_info.status = "preparing"
self.status = "Accepting File Transfer..."
notification_center.add_observer(self, sender=self)
notification_center.add_observer(self, sender=self.session)
notification_center.add_observer(self, sender=self.stream)
self.log_info("Initiating Incoming File Transfer")
notification_center.post_notification("BlinkFileTransferInitializing", self)
notification_center.post_notification("BlinkFileTransferInitiated", self)
def _CH_update_registrations(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._update_timer is not None and self._update_timer.active():
self._update_timer.cancel()
self._update_timer = None
available_transports = settings.sip.transport_list
old_files = []
for file in (f for f in self._files[:] if isinstance(f, BonjourRegistrationFile) and f.transport not in available_transports):
old_files.append(file)
self._files.remove(file)
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
update_failure = False
for file in (f for f in self._files if isinstance(f, BonjourRegistrationFile)):
try:
contact_uri, txtdata = self._build_txtdata(file.transport)
if txtdata is None:
raise KeyError('error processing %s transport' % file.transport)
_bonjour.DNSServiceUpdateRecord(file.file, None, flags=0, rdata=_bonjour.TXTRecord(items=txtdata), ttl=0)
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourServiceRegistrationUpdateDidFail', sender=self,
data=NotificationData(reason=str(e), transport=file.transport))
update_failure = True
def start(self):
notification_center = NotificationCenter()
self.greenlet = api.getcurrent()
settings = SIPSimpleSettings()
account = AccountManager().sylkserver_account
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = self.destination_uri
lookup = DNSLookup()
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
notification_center.post_notification('OutgoingFileTransferHandlerDidFail', sender=self)
return
self.session = Session(account)
self.stream = FileTransferStream(self.file_selector, 'sendonly')
notification_center.add_observer(self, sender=self.session)
notification_center.add_observer(self, sender=self.stream)
from_header = FromHeader(self.sender_uri, u'SIPStache File Transfer')
to_header = ToHeader(self.destination_uri)
transport = routes[0].transport
parameters = {} if transport=='udp' else {'transport': transport}
contact_header = ContactHeader(SIPURI(user=self.sender_uri.user, host=SIPConfig.local_ip.normalized, port=getattr(Engine(), '%s_port' % transport), parameters=parameters))
extra_headers = []
if ThorNodeConfig.enabled:
extra_headers.append(Header('Thor-Scope', 'sipstache-file'))
extra_headers.append(Header('X-Originator-From', str(self.destination_uri)))
self.session.connect(from_header, to_header, contact_header=contact_header, routes=routes, streams=[self.stream], is_focus=False, extra_headers=extra_headers)
notification_center.post_notification('OutgoingFileTransferHandlerDidStart', sender=self)
def accept(self):
if self._done:
return
self.accepted_streams = [next(stream for stream in self.streams if stream.type=='audio')]
notification_center = NotificationCenter()
notification_center.post_notification('IncomingRequestAccepted', sender=self)
self._done = True
def _start_outgoing_sip_session(self, target_uri):
notification_center = NotificationCenter()
# self.xmpp_identity is our local identity
from_uri = self.xmpp_identity.uri.as_sip_uri()
del from_uri.parameters['gr'] # no GRUU in From header
contact_uri = self.xmpp_identity.uri.as_sip_uri()
contact_uri.parameters['gr'] = encode_resource(contact_uri.parameters['gr'].decode('utf-8'))
to_uri = target_uri.as_sip_uri()
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
log.warning('DNS lookup error while looking for %s proxy' % uri)
notification_center.post_notification('ChatSessionDidFail', sender=self, data=NotificationData(reason='DNS lookup error'))
return
self.msrp_stream = MediaStreamRegistry().get('chat')()
route = routes.pop(0)
from_header = FromHeader(from_uri)
to_header = ToHeader(to_uri)
contact_header = ContactHeader(contact_uri)
self.sip_session = Session(account)
notification_center.add_observer(self, sender=self.sip_session)
notification_center.add_observer(self, sender=self.msrp_stream)
self.sip_session.connect(from_header, to_header, contact_header=contact_header, route=route, streams=[self.msrp_stream])
def register(self, contact_header, route_header, timeout=None):
with self._lock:
try:
self._make_and_send_request(contact_header, route_header, timeout, True)
except SIPCoreError, e:
notification_center = NotificationCenter()
notification_center.post_notification('SIPRegistrationDidFail', sender=self, data=NotificationData(code=0, reason=e.args[0], route_header=route_header))
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 __setstate__(self, state):
for name, value in state.iteritems():
attribute = getattr(self.__class__, name, None)
if isinstance(attribute, SettingsGroupMeta):
group = getattr(self, name)
try:
group.__setstate__(value)
except ValueError, e:
configuration_manager = ConfigurationManager()
notification_center = NotificationCenter()
notification_center.post_notification('CFGManagerLoadFailed', sender=configuration_manager, data=TimestampedNotificationData(attribute=name, container=self, error=e))
elif isinstance(attribute, Setting):
try:
if value is None:
pass
elif issubclass(attribute.type, bool):
if value.lower() in ('true', 'yes', 'on', '1'):
value = True
elif value.lower() in ('false', 'no', 'off', '0'):
value = False
else:
raise ValueError("invalid boolean value: %s" % (value,))
elif issubclass(attribute.type, (int, long, basestring)):
value = attribute.type(value)
else:
object = attribute.type.__new__(attribute.type)
object.__setstate__(value)
value = object
setattr(self, name, value)
except ValueError, e:
configuration_manager = ConfigurationManager()
notification_center = NotificationCenter()
notification_center.post_notification('CFGManagerLoadFailed', sender=configuration_manager, data=TimestampedNotificationData(attribute=name, container=self, error=e))
class MusicApplications(object):
__metaclass__ = Singleton
is_resuming = False
is_pausing = False
def __init__(self):
self.notification_center = NotificationCenter()
self.must_pause = False
self.itunes = iTunesInterface(self)
self.spotify = SpotifyInterface(self)
# self.vlc = VLCInterface(self)
@run_in_thread("Music-interface")
def pause(self):
settings = SIPSimpleSettings()
if not settings.audio.pause_music:
return
self.is_pausing = True
self.itunes.pause()
# self.spotify.pause()
# self.vlc.pause()
self.is_pausing = False
self.notification_center.post_notification("MusicPauseDidExecute", sender=self)
@run_in_thread("Music-interface")
def resume(self):
settings = SIPSimpleSettings()
if not settings.audio.pause_music:
return
self.must_pause = False
self.is_resuming = True
self.itunes.resume()
# self.spotify.resume()
# self.vlc.resume()
self.is_resuming = False
def busy(self):
if self._done:
return
self.reject_mode = 'busy'
notification_center = NotificationCenter()
notification_center.post_notification('IncomingRequestRejected', sender=self)
self._done = True
def _start_outgoing_sip_session(self, streams):
notification_center = NotificationCenter()
# self.xmpp_identity is our local identity on the SIP side
from_uri = self.xmpp_identity.uri.as_sip_uri()
from_uri.parameters.pop('gr', None) # no GRUU in From header
to_uri = self.sip_identity.uri.as_sip_uri()
to_uri.parameters.pop('gr', None) # no GRUU in To header
# TODO: need to fix GRUU in the proxy
#contact_uri = self.xmpp_identity.uri.as_sip_uri()
#contact_uri.parameters['gr'] = encode_resource(contact_uri.parameters['gr'].decode('utf-8'))
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
log.warning('DNS lookup error while looking for %s proxy' % uri)
notification_center.post_notification('MedialSessionHandlerDidFail', sender=self, data=NotificationData(reason='DNS lookup error'))
return
route = routes.pop(0)
from_header = FromHeader(from_uri)
to_header = ToHeader(to_uri)
self.sip_session = Session(account)
notification_center.add_observer(self, sender=self.sip_session)
self.sip_session.connect(from_header, to_header, route=route, streams=streams)
def _NH_SIPRequestDidSucceed(self, notification):
request = notification.sender
notification_center = NotificationCenter()
with self._lock:
if request is not self._current_request:
return
self._current_request = None
if self._unregistering:
if self._last_request is not None:
self._last_request.end()
self._last_request = None
notification_center.post_notification("SIPRegistrationDidEnd", sender=self,
data=TimestampedNotificationData(expired=False))
else:
self._last_request = request
try:
contact_header_list = notification.data.headers["Contact"]
except KeyError:
contact_header_list = []
notification_center.post_notification("SIPRegistrationDidSucceed", sender=self,
data=TimestampedNotificationData(code=notification.data.code,
reason=notification.data.reason,
contact_header=request.contact_header,
contact_header_list=contact_header_list,
expires_in=notification.data.expires,
route_header=request.route_header))
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(settings.sip.transport_list)
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('BonjourServiceWillRegister', sender=self, data=NotificationData(transport=transport))
try:
contact_uri, txtdata = self._build_txtdata(transport)
if txtdata is None:
raise KeyError('error processing %s transport' % transport)
file = _bonjour.DNSServiceRegister(name=str(contact_uri),
regtype="_op2-phone._%s" % (transport if transport == 'udp' else 'tcp'),
port=contact_uri.port,
callBack=self._register_cb,
txtRecord=_bonjour.TXTRecord(items=txtdata))
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourServiceRegistrationDidFail', sender=self,
data=NotificationData(reason=str(e), transport=transport))
else:
self._files.append(BonjourRegistrationFile(file, transport))
added_transports.add(transport)
def _NH_DNSLookupDidSucceed(self, sender, data):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=sender)
if self.interrupted:
notification_center.post_notification("BlinkFileTransferDidFail", sender=self)
return
self.session.connect(ToHeader(self.target_uri), data.result, [self.stream])
def initialize(self, session, streams, new_session=True):
self.session = session
self.streams = streams
self.new_session = new_session
notification_center = NotificationCenter()
notification_center.post_notification('IncomingRequestReceived', sender=self)
def _NH_BlinkFileTransferDidComputeHash(self, sender, data):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
self.stream = FileTransferStream(self.file_selector, 'sendonly')
self.session = Session(self.account)
notification_center.add_observer(self, sender=self.session)
notification_center.add_observer(self, sender=self.stream)
self.status = "Offering File..."
self.ft_info.status = "proposing"
self.log_info(u"Initiating DNS Lookup of %s to %s" % (self.account, self.target_uri))
lookup = DNSLookup()
notification_center.add_observer(self, sender=lookup)
if isinstance(self.account, Account) and self.account.sip.outbound_proxy is not None:
uri = SIPURI(host=self.account.sip.outbound_proxy.host, port=self.account.sip.outbound_proxy.port, parameters={'transport': self.account.sip.outbound_proxy.transport})
self.log_info(u"Initiating DNS Lookup for SIP routes of %s (through proxy %s)" % (self.target_uri, uri))
elif isinstance(self.account, Account) and self.account.sip.always_use_my_proxy:
uri = SIPURI(host=self.account.id.domain)
self.log_info(u"Initiating DNS Lookup for SIP routes of %s (through account %s proxy)" % (self.target_uri, self.account.id))
else:
uri = self.target_uri
self.log_info(u"Initiating DNS Lookup for SIP routes of %s" % self.target_uri)
notification_center.post_notification("BlinkFileTransferInitiated", self)
lookup.lookup_sip_proxy(uri, settings.sip.transport_list)
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 activate(self):
if not self.started:
raise RuntimeError("not started")
self.active = True
self._command_channel.send(Command('publish', state=self.state))
notification_center = NotificationCenter()
notification_center.post_notification(self.__class__.__name__ + 'DidActivate', sender=self)
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 stop(self):
old_slot = self.consumer_slot
self._recording_wave_file.stop()
self._recording_wave_file = None
notification_center = NotificationCenter()
notification_center.post_notification('AudioPortDidChangeSlots', sender=self, data=NotificationData(consumer_slot_changed=True, producer_slot_changed=False,
old_consumer_slot=old_slot, new_consumer_slot=None))
def _CH_register(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._registration_timer is not None and self._registration_timer.active():
self._registration_timer.cancel()
self._registration_timer = None
# Initialize the registration
if self._registration is None:
duration = command.refresh_interval or self.account.sip.register_interval
self._registration = Registration(FromHeader(self.account.uri, self.account.display_name), credentials=self.account.credentials, duration=duration, extra_headers=[Header('Supported', 'gruu')])
notification_center.add_observer(self, sender=self._registration)
notification_center.post_notification('SIPAccountWillRegister', sender=self.account)
else:
notification_center.post_notification('SIPAccountRegistrationWillRefresh', sender=self.account)
try:
# Lookup routes
if self.account.sip.outbound_proxy is not None and self.account.sip.outbound_proxy.transport in settings.sip.transport_list:
uri = SIPURI(host=self.account.sip.outbound_proxy.host, port=self.account.sip.outbound_proxy.port, parameters={'transport': self.account.sip.outbound_proxy.transport})
else:
uri = SIPURI(host=self.account.id.domain)
lookup = DNSLookup()
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError, e:
retry_after = random.uniform(self._dns_wait, 2*self._dns_wait)
self._dns_wait = limit(2*self._dns_wait, max=30)
raise RegistrationError('DNS lookup failed: %s' % e, retry_after=retry_after)
else:
def _CH_unregister(self, command):
# Cancel any timer which would restart the registration process
if self._registration_timer is not None and self._registration_timer.active():
self._registration_timer.cancel()
self._registration_timer = None
registered = self.registered
self.registered = False
if self._registration is not None:
notification_center = NotificationCenter()
if registered:
self._registration.end(timeout=2)
try:
while True:
notification = self._data_channel.wait()
if notification.name == 'SIPRegistrationDidEnd':
break
except (SIPRegistrationDidFail, SIPRegistrationDidNotEnd), e:
notification_center.post_notification('SIPAccountRegistrationDidNotEnd', sender=self.account, data=NotificationData(code=e.data.code, reason=e.data.reason,
registration=self._registration))
else:
notification_center.post_notification('SIPAccountRegistrationDidEnd', sender=self.account, data=NotificationData(registration=self._registration))
notification_center.remove_observer(self, sender=self._registration)
self._registration = None
self.account.contact.public_gruu = None
self.account.contact.temporary_gruu = None
def _NH_IncomingFileTransferHandlerDidEnd(self, sender, data):
notification_center = NotificationCenter()
if not self.finished_transfer:
self.log_info(u"Removing incomplete file %s" % self.file_path)
os.remove(self.file_path)
self.fail_reason = "Interrupted"
else:
local_hash = 'sha1:' + ':'.join(re.findall(r'..', self.hash.hexdigest()))
remote_hash = self.file_selector.hash.lower()
if local_hash == remote_hash:
oname = self.file_path
self.file_path = self.file_path[:-len(".download")]
self.log_info(u"Renaming transferred file to %s" % self.file_path)
os.rename(oname, self.file_path)
else:
self.error = True
self.fail_reason = "File hash mismatch"
self.log_info(u"Removing corrupted file %s" % self.file_path)
os.remove(self.file_path)
self.log_info("Incoming File Transfer ended (%i of %i bytes transferred)" % (self.file_pos, self.file_size))
self.end_time = datetime.datetime.now()
if self.finished_transfer and not self.error:
self.status = "Completed in %s %s %s" % (format_duration(self.end_time-self.start_time), unichr(0x2014), format_size(self.file_size))
self.ft_info.status = "completed"
self.ft_info.bytes_transfered = self.file_size
notification_center.post_notification("BlinkFileTransferDidEnd", sender=self, data=NotificationData(file_path=self.file_path))
else:
self.status = self.fail_reason
self.ft_info.status = "failed"
self.ft_info.bytes_transfered = self.file_pos
notification_center.post_notification("BlinkFileTransferDidFail", sender=self)
def initiate_file_transfer(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self)
try:
self.file_selector = FileSelector.for_file(self.file_path.encode('utf-8'), hash=None)
except IOError:
notification_center.post_notification('BlinkFileTransferDidNotComputeHash', sender=self, data=NotificationData(reason='Cannot open file'))
return
self.ft_info.file_size = self.file_size
# compute the file hash first
self.ft_info.status = "preparing"
self.status = "Computing checksum..."
hash = hashlib.sha1()
pos = progress = 0
chunk_size = limit(self.file_selector.size/100, min=65536, max=1048576)
notification_center.post_notification('BlinkFileTransferHashUpdate', sender=self, data=NotificationData(progress=0))
while not self.stop_event.isSet():
content = self.file_selector.fd.read(chunk_size)
if not content:
break
hash.update(content)
pos += len(content)
old_progress, progress = progress, int(float(pos)/self.file_selector.size*100)
if old_progress != progress:
notification_center.post_notification('BlinkFileTransferHashUpdate', sender=self, data=NotificationData(progress=progress))
else:
self.file_selector.fd.close()
notification_center.post_notification('BlinkFileTransferDidNotComputeHash', sender=self, data=NotificationData(reason='Cancelled computing checksum'))
return
self.file_selector.fd.seek(0)
self.file_selector.hash = hash
notification_center.post_notification('BlinkFileTransferDidComputeHash', sender=self)
def _NH_FileTransferStreamDidDeliverChunk(self, sender, data):
self.file_pos = data.transferred_bytes
self.update_transfer_rate()
self.status = self.format_progress()
notification_center = NotificationCenter()
notification_center.post_notification("BlinkFileTransferUpdate", sender=self)
def publish(self):
center = NotificationCenter()
print "Sending notification with name 'simple':"
print "Expecting SimpleObserver to receive notifications (CatchAllObserver and VolatileAllObserver have been unregistered)"
center.post_notification(name='simple')
print "\nSending notification with name 'empty':"
print "Expecting no observer to receive notifications (CatchAllObserver and VolatileAllObserver have been unregistered)"
center.post_notification(name='empty', data=None)
def start(self):
notification_center = NotificationCenter()
self._xmpp_subscription = XMPPIncomingSubscription(local_identity=self.sip_identity, remote_identity=self.xmpp_identity)
notification_center.add_observer(self, sender=self._xmpp_subscription)
self._xmpp_subscription.start()
self._command_proc = proc.spawn(self._run)
self._subscribe_sip()
notification_center.post_notification('X2SPresenceHandlerDidStart', sender=self)
def _NH_DNSNameserversDidChange(self, notification):
if self.running:
self.engine.set_nameservers(notification.data.nameservers)
notification_center = NotificationCenter()
notification_center.post_notification(
'NetworkConditionsDidChange',
sender=self,
data=NotificationData(changed=['dns']))
def update_name(rtp_transport, name):
rtp_transport.zrtp_peer_name = name if isinstance(
name, bytes) else name.encode()
notification_center = NotificationCenter()
notification_center.post_notification(
'RTPStreamZRTPPeerNameChanged',
sender=self._stream,
data=NotificationData(name=name))
def _NH_VirtualGroupWasDeleted(self, notification):
group = notification.sender
del self.groups[group.id]
notification_center = NotificationCenter()
notification_center.post_notification(
'VirtualGroupsManagerDidRemoveGroup',
sender=self,
data=NotificationData(group=group))
def on_received_char(self, char_data):
self.trace("TTYToneDemodulator on_received_char {}".format(char_data))
notification_center = NotificationCenter()
notification_center.post_notification('TTYReceivedChar',
sender=self,
data=NotificationData(
room_number=self.room_number,
tty_char=char_data))
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 _CH_publish(self, command):
if command.state is None or self._publication is None and command.state is SameState:
command.signal()
return
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._publication_timer is not None and self._publication_timer.active(
):
self._publication_timer.cancel()
self._publication_timer = None
if self._publication is None:
duration = command.refresh_interval or self.account.sip.publish_interval
from_header = FromHeader(self.account.uri,
self.account.display_name)
self._publication = Publication(
from_header,
self.event,
self.payload_type.content_type,
credentials=self.account.credentials,
duration=duration,
extra_headers=self.extra_headers)
notification_center.add_observer(self, sender=self._publication)
notification_center.post_notification(
self.__class__.__name__ + 'WillPublish',
sender=self,
data=NotificationData(state=command.state, duration=duration))
else:
notification_center.post_notification(
self.__class__.__name__ + 'WillRefresh',
sender=self,
data=NotificationData(state=command.state))
try:
# Lookup routes
valid_transports = self.__transports__.intersection(
settings.sip.transport_list)
if self.account.sip.outbound_proxy is not None and self.account.sip.outbound_proxy.transport in valid_transports:
uri = SIPURI(host=self.account.sip.outbound_proxy.host,
port=self.account.sip.outbound_proxy.port,
parameters={
'transport':
self.account.sip.outbound_proxy.transport
})
else:
uri = SIPURI(host=self.account.id.domain)
lookup = DNSLookup()
try:
routes = lookup.lookup_sip_proxy(uri, valid_transports).wait()
except DNSLookupError, e:
retry_after = random.uniform(self._dns_wait,
2 * self._dns_wait)
self._dns_wait = limit(2 * self._dns_wait, max=30)
raise PublicationError('DNS lookup failed: %s' % e,
retry_after=retry_after)
else:
def start(self, restart=False):
notification_center = NotificationCenter()
file_path = self._file_selector.name.decode() if isinstance(
self._file_selector.name, bytes) else self._file_selector.name
self.ft_info = FileTransferInfo(
transfer_id=str(uuid.uuid4()),
direction='outgoing',
file_size=self._file_selector.size,
local_uri=format_identity_to_string(self.account)
if self.account is not BonjourAccount() else 'bonjour.local',
remote_uri=self.remote_identity,
file_path=file_path)
self.status = NSLocalizedString("Offering File...", "Label")
self.ft_info.status = "proposing"
self.log_info("Initiating DNS Lookup of %s to %s" %
(self.account, self.target_uri))
lookup = DNSLookup()
notification_center.add_observer(self, sender=lookup)
if isinstance(self.account,
Account) and self.account.sip.outbound_proxy is not None:
uri = SIPURI(host=self.account.sip.outbound_proxy.host,
port=self.account.sip.outbound_proxy.port,
parameters={
'transport':
self.account.sip.outbound_proxy.transport
})
self.log_info("Initiating DNS Lookup for %s (through proxy %s)" %
(self.target_uri, uri))
elif isinstance(self.account,
Account) and self.account.sip.always_use_my_proxy:
uri = SIPURI(host=self.account.id.domain)
self.log_info(
"Initiating DNS Lookup for %s (through account %s proxy)" %
(self.target_uri, self.account.id))
else:
uri = self.target_uri
self.log_info("Initiating DNS Lookup for %s" % self.target_uri)
settings = SIPSimpleSettings()
tls_name = None
if isinstance(self.account, Account):
tls_name = self.account.sip.tls_name or self.account.id.domain
lookup.lookup_sip_proxy(uri,
settings.sip.transport_list,
tls_name=tls_name)
if restart:
notification_center.post_notification(
"BlinkFileTransferWillRestart", self)
else:
notification_center.post_notification(
"BlinkFileTransferNewOutgoing", sender=self)
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()
if len(missing_transports) > 1 and 'udp' in missing_transports:
missing_transports.remove('udp')
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,
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
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) as 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)
if added_transports:
self._select_proc.kill(RestartSelect)
if added_transports != missing_transports:
self._register_timer = reactor.callLater(
1, self._command_channel.send,
Command('register', command.event))
else:
command.signal()
def start(self):
notification_center = NotificationCenter()
self._xmpp_subscription = XMPPSubscription(
local_identity=self.sip_identity,
remote_identity=self.xmpp_identity)
notification_center.add_observer(self, sender=self._xmpp_subscription)
self._xmpp_subscription.start()
notification_center.post_notification('S2XPresenceHandlerDidStart',
sender=self)
def activate(self):
if not self.started:
raise RuntimeError("not started")
self.active = True
self._command_channel.send(Command('subscribe'))
notification_center = NotificationCenter()
notification_center.post_notification(self.__class__.__name__ +
'DidActivate',
sender=self)
def _SH_ThreadFinished(self):
self.finished.emit()
notification_center = NotificationCenter()
notification_center.post_notification('VNCClientWillEnd', sender=self)
if self.socket_notifier is not None:
self.socket_notifier.activated.disconnect(self._SH_SocketNotifierActivated)
self.socket_notifier = None
self.rfb_client = None
notification_center.post_notification('VNCClientDidEnd', sender=self)
def deactivate(self):
if not self.started:
raise RuntimeError("not started")
self.active = False
self._command_channel.send(Command('unpublish'))
notification_center = NotificationCenter()
notification_center.post_notification(self.__class__.__name__ +
'DidDeactivate',
sender=self)
def _NH_FileTransferStreamDidDeliverChunk(self, sender, data):
self.file_pos = data.transferred_bytes
self.update_transfer_rate()
self.status = self.format_progress()
notification_center = NotificationCenter()
notification_center.post_notification(
"BlinkFileTransferUpdate",
sender=self,
data=TimestampedNotificationData())
def start(self):
notification_center = NotificationCenter()
self._xmpp_muc_session = XMPPIncomingMucSession(
local_identity=self.sip_identity,
remote_identity=self.xmpp_identity)
notification_center.add_observer(self, sender=self._xmpp_muc_session)
self._xmpp_muc_session.start()
notification_center.post_notification('X2SMucHandlerDidStart',
sender=self)
self._start_sip_session()
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 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 _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 peer_name(self, name):
old_name = self.peer_name
new_name = self.__dict__['peer_name'] = name
if old_name != new_name:
trusted_peer = self.otr_cache.trusted_peers.get(self.peer_fingerprint, None)
if trusted_peer is not None:
trusted_peer.description = new_name
self.otr_cache.save()
notification_center = NotificationCenter()
notification_center.post_notification("ChatStreamOTRPeerNameChanged", sender=self.stream, data=NotificationData(name=name))
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)
class MusicApplications(object):
__metaclass__ = Singleton
implements(IObserver)
itunes_paused = False
spotify_paused = False
vlc_paused = False
def __init__(self):
self.notification_center = NotificationCenter()
self.itunes = ITunesInterface()
self.spotify = SpotifyInterface()
self.vlc = VLCInterface()
self.notification_center.add_observer(self, sender=self.itunes)
self.notification_center.add_observer(self, sender=self.spotify)
self.notification_center.add_observer(self, sender=self.vlc)
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification.sender, notification.data)
def _NH_iTunesPauseDidExecute(self, sender, data):
self.itunes_paused = True
self.send_global_pause_notification()
def _NH_SpotifyPauseDidExecute(self, sender, data):
self.spotify_paused = True
self.send_global_pause_notification()
def _NH_VLCPauseDidExecute(self, sender, data):
self.vlc_paused = True
self.send_global_pause_notification()
def send_global_pause_notification(self):
if self.itunes_paused and self.spotify_paused and self.vlc_paused:
self.notification_center.post_notification('MusicPauseDidExecute', sender=self, data=TimestampedNotificationData())
self.itunes_paused = False
self.spotify_paused = False
self.vlc_paused = False
BlinkLogger().log_info(u"Playback of music applications stopped")
@run_in_thread('iTunes-interface')
def pause(self):
BlinkLogger().log_info(u"Stopping playback of music applications")
self.itunes.pause()
self.spotify.pause()
self.vlc.pause()
@run_in_thread('iTunes-interface')
def resume(self):
BlinkLogger().log_info(u"Resuming playback of music applications")
self.itunes.resume()
self.spotify.resume()
self.vlc.resume()
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(
'BonjourServiceWillRegister',
sender=self,
data=NotificationData(transport=transport))
try:
contact_uri = self.account.contact[transport]
contact_uri.user = self.uri_user
if self.is_focus:
contact_uri.parameters['isfocus'] = None
txtdata = dict(txtvers=1,
name=self.name,
contact="<%s>" % str(contact_uri),
instance_id=self.id)
state = self.presence_state
if state is not None:
txtdata['state'] = state.state
txtdata['note'] = state.note.encode('utf-8')
file = _bonjour.DNSServiceRegister(
name=str(contact_uri),
regtype="_%s._%s" %
(self.service, transport if transport == 'udp' else 'tcp'),
port=contact_uri.port,
callBack=self._register_cb,
txtRecord=_bonjour.TXTRecord(items=txtdata))
except (_bonjour.BonjourError, KeyError) as e:
notification_center.post_notification(
'BonjourServiceRegistrationDidFail',
sender=self,
data=NotificationData(reason=str(e), transport=transport))
else:
self._files.append(BonjourRegistrationFile(file, transport))
added_transports.add(transport)
if added_transports:
self._select_proc.kill(RestartSelect)
if added_transports != missing_transports:
self._register_timer = reactor.callLater(
1, self._command_channel.send,
Command('register', command.event))
else:
command.signal()
def _NH_MediaStreamDidStart(self, sender, data):
self.log_info("Receiving File...")
self.status = format_size(self.file_pos, 1024)
self.ft_info.status = "transfering"
self.started = True
self.start_time = datetime.datetime.now()
notification_center = NotificationCenter()
notification_center.post_notification(
"BlinkFileTransferDidStart",
sender=self,
data=TimestampedNotificationData())
def _NH_BlinkFileTransferDidNotComputeHash(self, sender, data):
self.file_selector.fd.close()
self.file_selector = None
self.status = "Interrupted"
self.ft_info.status = "interrupted"
notification_center = NotificationCenter()
notification_center.post_notification(
"BlinkFileTransferDidFail",
sender=self,
data=TimestampedNotificationData())
def _activate(self):
with self._activation_lock:
if self._active:
return
notification_center = NotificationCenter()
notification_center.post_notification('SIPAccountWillActivate',
sender=self)
self._active = True
self._bonjour_services.activate()
notification_center.post_notification('SIPAccountDidActivate',
sender=self)
def _deactivate(self):
with self._activation_lock:
if not self._active:
return
notification_center = NotificationCenter()
notification_center.post_notification('SIPAccountWillDeactivate',
sender=self)
self._active = False
self._bonjour_services.deactivate()
notification_center.post_notification('SIPAccountDidDeactivate',
sender=self)
def _NH_DNSLookupDidSucceed(self, sender, data):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=sender)
if self.interrupted:
notification_center.post_notification(
"BlinkFileTransferDidFail",
sender=self,
data=TimestampedNotificationData())
return
self.session.connect(ToHeader(self.target_uri), data.result,
[self.stream])
def start(self):
if self.started:
return
self.started = True
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self)
notification_center.post_notification(self.__class__.__name__ + 'WillStart', sender=self)
notification_center.add_observer(self, name='NetworkConditionsDidChange')
self._command_proc = proc.spawn(self._run)
notification_center.post_notification(self.__class__.__name__ + 'DidStart', sender=self)
notification_center.remove_observer(self, sender=self)
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'))