You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
842 lines
27 KiB
Python
842 lines
27 KiB
Python
# Copyright (C) 2006, Red Hat, Inc.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
import avahi, dbus, dbus.glib, gobject
|
|
import Buddy
|
|
import Service
|
|
import Activity
|
|
import random
|
|
import logging
|
|
from sugar import util
|
|
from sugar import env
|
|
import BuddyIconCache
|
|
|
|
|
|
_SA_UNRESOLVED = 0
|
|
_SA_RESOLVE_PENDING = 1
|
|
_SA_RESOLVED = 2
|
|
class ServiceAdv(object):
|
|
"""Wrapper class to track services from Avahi."""
|
|
def __init__(self, interface, protocol, name, stype, domain, local):
|
|
self._interface = interface
|
|
self._protocol = protocol
|
|
if not isinstance(name, unicode):
|
|
raise ValueError("service advertisement name must be unicode.")
|
|
self._name = name
|
|
if not isinstance(stype, unicode):
|
|
raise ValueError("service advertisement type must be unicode.")
|
|
self._stype = stype
|
|
if not isinstance(domain, unicode):
|
|
raise ValueError("service advertisement domain must be unicode.")
|
|
self._domain = domain
|
|
self._service = None
|
|
if not isinstance(local, bool):
|
|
raise ValueError("local must be a bool.")
|
|
self._local = local
|
|
self._state = _SA_UNRESOLVED
|
|
self._resolver = None
|
|
|
|
def __del__(self):
|
|
if self._resolver:
|
|
del self._resolver
|
|
|
|
def interface(self):
|
|
return self._interface
|
|
def protocol(self):
|
|
return self._protocol
|
|
def name(self):
|
|
return self._name
|
|
def stype(self):
|
|
return self._stype
|
|
def domain(self):
|
|
return self._domain
|
|
def is_local(self):
|
|
return self._local
|
|
def service(self):
|
|
return self._service
|
|
def set_service(self, service):
|
|
if not isinstance(service, Service.Service):
|
|
raise ValueError("must be a valid service.")
|
|
if service != self._service:
|
|
self._service = service
|
|
def resolver(self):
|
|
return self._resolver
|
|
def set_resolver(self, resolver):
|
|
if not isinstance(resolver, dbus.Interface):
|
|
raise ValueError("must be a valid dbus object")
|
|
self._resolver = resolver
|
|
def state(self):
|
|
return self._state
|
|
def set_state(self, state):
|
|
if state == _SA_RESOLVE_PENDING:
|
|
if self._state == _SA_RESOLVED:
|
|
raise ValueError("Can't reset to resolve pending from resolved.")
|
|
self._state = state
|
|
|
|
class RegisteredServiceType(object):
|
|
def __init__(self, stype):
|
|
self._stype = stype
|
|
self._refcount = 1
|
|
|
|
def get_type(self):
|
|
return self._stype
|
|
|
|
def ref(self):
|
|
self._refcount += 1
|
|
|
|
def unref(self):
|
|
self._refcount -= 1
|
|
return self._refcount
|
|
|
|
def _txt_to_dict(txt):
|
|
"""Convert an avahi-returned TXT record formatted
|
|
as nested arrays of integers (from dbus) into a dict
|
|
of key/value string pairs."""
|
|
prop_dict = {}
|
|
props = avahi.txt_array_to_string_array(txt)
|
|
for item in props:
|
|
key = value = None
|
|
if '=' not in item:
|
|
# No = means a boolean value of true
|
|
key = item
|
|
value = True
|
|
else:
|
|
(key, value) = item.split('=')
|
|
prop_dict[key] = value
|
|
return prop_dict
|
|
|
|
|
|
_PRESENCE_SERVICE = "org.laptop.Presence"
|
|
_PRESENCE_DBUS_INTERFACE = "org.laptop.Presence"
|
|
_PRESENCE_OBJECT_PATH = "/org/laptop/Presence"
|
|
|
|
class NotFoundError(Exception):
|
|
pass
|
|
|
|
class PresenceServiceDBusHelper(dbus.service.Object):
|
|
def __init__(self, parent, bus_name):
|
|
self._parent = parent
|
|
self._bus_name = bus_name
|
|
dbus.service.Object.__init__(self, bus_name, _PRESENCE_OBJECT_PATH)
|
|
|
|
@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
|
|
signature="o")
|
|
def BuddyAppeared(self, object_path):
|
|
pass
|
|
|
|
@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
|
|
signature="o")
|
|
def BuddyDisappeared(self, object_path):
|
|
pass
|
|
|
|
@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
|
|
signature="o")
|
|
def ServiceAppeared(self, object_path):
|
|
pass
|
|
|
|
@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
|
|
signature="o")
|
|
def ServiceDisappeared(self, object_path):
|
|
pass
|
|
|
|
@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
|
|
signature="o")
|
|
def ActivityAppeared(self, object_path):
|
|
pass
|
|
|
|
@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
|
|
signature="o")
|
|
def ActivityDisappeared(self, object_path):
|
|
pass
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="", out_signature="ao")
|
|
def getServices(self):
|
|
ret = []
|
|
for serv in self._parent.get_services():
|
|
ret.append(serv.object_path())
|
|
return ret
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="s", out_signature="ao")
|
|
def getServicesOfType(self, stype):
|
|
ret = []
|
|
for serv in self._parent.get_services_of_type(stype):
|
|
ret.append(serv.object_path())
|
|
return ret
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="", out_signature="ao")
|
|
def getActivities(self):
|
|
ret = []
|
|
for act in self._parent.get_activities():
|
|
ret.append(act.object_path())
|
|
return ret
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="s", out_signature="o")
|
|
def getActivity(self, actid):
|
|
act = self._parent.get_activity(actid)
|
|
if not act:
|
|
raise NotFoundError("Not found")
|
|
return act.object_path()
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="", out_signature="ao")
|
|
def getBuddies(self):
|
|
ret = []
|
|
for buddy in self._parent.get_buddies():
|
|
ret.append(buddy.object_path())
|
|
return ret
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="s", out_signature="o")
|
|
def getBuddyByName(self, name):
|
|
buddy = self._parent.get_buddy_by_name(name)
|
|
if not buddy:
|
|
raise NotFoundError("Not found")
|
|
return buddy.object_path()
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="s", out_signature="o")
|
|
def getBuddyByAddress(self, addr):
|
|
buddy = self._parent.get_buddy_by_address(addr)
|
|
if not buddy:
|
|
raise NotFoundError("Not found")
|
|
return buddy.object_path()
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="", out_signature="o")
|
|
def getOwner(self):
|
|
owner = self._parent.get_owner()
|
|
if not owner:
|
|
raise NotFoundError("Not found")
|
|
return owner.object_path()
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="os", out_signature="o",
|
|
sender_keyword="sender")
|
|
def joinActivity(self, activity_op, stype, sender):
|
|
found_activity = None
|
|
acts = self._parent.get_activities()
|
|
for act in acts:
|
|
if act.object_path() == activity_op:
|
|
found_activity = act
|
|
break
|
|
if not found_activity:
|
|
raise NotFoundError("The activity %s was not found." % activity_op)
|
|
return self._parent.join_activity(found_activity, stype, sender)
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="ssa{ss}sis", out_signature="o",
|
|
sender_keyword="sender")
|
|
def shareActivity(self, activity_id, stype, properties, address, port,
|
|
domain, sender=None):
|
|
if not len(address):
|
|
address = None
|
|
service = self._parent.share_activity(activity_id, stype, properties, address,
|
|
port, domain, sender)
|
|
return service.object_path()
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="ssa{ss}sis", out_signature="o",
|
|
sender_keyword="sender")
|
|
def registerService(self, name, stype, properties, address, port, domain,
|
|
sender=None):
|
|
if not len(address):
|
|
address = None
|
|
service = self._parent.register_service(name, stype, properties, address,
|
|
port, domain, sender)
|
|
return service.object_path()
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="o", out_signature="",
|
|
sender_keyword="sender")
|
|
def unregisterService(self, service_op, sender):
|
|
found_serv = None
|
|
services = self._parent.get_services()
|
|
for serv in services:
|
|
if serv.object_path() == service_op:
|
|
found_serv = serv
|
|
break
|
|
if not found_serv:
|
|
raise NotFoundError("The service %s was not found." % service_op)
|
|
return self._parent.unregister_service(found_serv, sender)
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="s", out_signature="")
|
|
def registerServiceType(self, stype):
|
|
self._parent.register_service_type(stype)
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
|
|
in_signature="s", out_signature="")
|
|
def unregisterServiceType(self, stype):
|
|
self._parent.unregister_service_type(stype)
|
|
|
|
@dbus.service.method(_PRESENCE_DBUS_INTERFACE)
|
|
def start(self):
|
|
self._parent.start()
|
|
|
|
class PresenceService(object):
|
|
def __init__(self):
|
|
# interface -> IP address: interfaces we've gotten events on so far
|
|
self._local_addrs = {}
|
|
|
|
self._next_object_id = 0
|
|
|
|
self._buddies = {} # nick -> Buddy
|
|
self._services = {} # (name, type) -> Service
|
|
self._activities = {} # activity id -> Activity
|
|
|
|
# Keep track of stuff we're already browsing
|
|
self._service_type_browsers = {}
|
|
self._service_browsers = {}
|
|
|
|
# Resolved service list
|
|
self._service_advs = []
|
|
|
|
# Service types we care about resolving
|
|
self._registered_service_types = []
|
|
|
|
# Set up the dbus service we provide
|
|
self._session_bus = dbus.SessionBus()
|
|
self._bus_name = dbus.service.BusName(_PRESENCE_SERVICE, bus=self._session_bus)
|
|
self._dbus_helper = PresenceServiceDBusHelper(self, self._bus_name)
|
|
|
|
self._icon_cache = BuddyIconCache.BuddyIconCache()
|
|
|
|
# Our owner object
|
|
if env.get_nick_name():
|
|
objid = self._get_next_object_id()
|
|
self._owner = Buddy.Owner(self, self._bus_name,
|
|
objid, self._icon_cache)
|
|
self._buddies[self._owner.get_name()] = self._owner
|
|
else:
|
|
self._owner = None
|
|
|
|
self._started = False
|
|
|
|
def start(self):
|
|
if self._started:
|
|
return
|
|
self._started = True
|
|
|
|
# Connect to Avahi for mDNS stuff
|
|
self._system_bus = dbus.SystemBus()
|
|
self._mdns_service = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME,
|
|
avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER)
|
|
|
|
# Always browse .local
|
|
self._new_domain_cb(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, "local")
|
|
|
|
# Connect to Avahi and start looking for stuff
|
|
domain_browser = self._mdns_service.DomainBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC,
|
|
"", avahi.DOMAIN_BROWSER_BROWSE, dbus.UInt32(0))
|
|
db = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, domain_browser), avahi.DBUS_INTERFACE_DOMAIN_BROWSER)
|
|
db.connect_to_signal('ItemNew', self._new_domain_cb_glue)
|
|
|
|
def _get_next_object_id(self):
|
|
"""Increment and return the object ID counter."""
|
|
self._next_object_id = self._next_object_id + 1
|
|
return self._next_object_id
|
|
|
|
def get_services(self):
|
|
return self._services.values()
|
|
|
|
def get_services_of_type(self, stype):
|
|
ret = []
|
|
for serv in self._services.values():
|
|
if serv.get_type() == stype:
|
|
ret.append(serv)
|
|
return ret
|
|
|
|
def get_activities(self):
|
|
# Only return valid activities
|
|
ret = []
|
|
for act in self._activities.values():
|
|
if act.is_valid():
|
|
ret.append(act)
|
|
return ret
|
|
|
|
def get_activity(self, actid):
|
|
if self._activities.has_key(actid):
|
|
act = self._activities[actid]
|
|
if act.is_valid():
|
|
return act
|
|
return None
|
|
|
|
def get_buddies(self):
|
|
buddies = []
|
|
for buddy in self._buddies.values():
|
|
if buddy.is_valid():
|
|
buddies.append(buddy)
|
|
return buddies
|
|
|
|
def get_buddy_by_name(self, name):
|
|
if self._buddies.has_key(name):
|
|
if self._buddies[name].is_valid():
|
|
return self._buddies[name]
|
|
return None
|
|
|
|
def get_buddy_by_address(self, address):
|
|
for buddy in self._buddies.values():
|
|
if buddy.get_address() == address and buddy.is_valid():
|
|
return buddy
|
|
return None
|
|
|
|
def get_owner(self):
|
|
return self._owner
|
|
|
|
def _find_service_adv(self, interface=None, protocol=None, name=None,
|
|
stype=None, domain=None, local=None):
|
|
"""Search a list of service advertisements for ones matching
|
|
certain criteria."""
|
|
adv_list = []
|
|
for adv in self._service_advs:
|
|
if interface and adv.interface() != interface:
|
|
continue
|
|
if protocol and adv.protocol() != protocol:
|
|
continue
|
|
if name and adv.name() != name:
|
|
continue
|
|
if stype and adv.stype() != stype:
|
|
continue
|
|
if domain and adv.domain() != domain:
|
|
continue
|
|
if local is not None and adv.is_local() != local:
|
|
continue
|
|
adv_list.append(adv)
|
|
return adv_list
|
|
|
|
def _find_registered_service_type(self, stype):
|
|
for item in self._registered_service_types:
|
|
if item.get_type() == stype:
|
|
return item
|
|
return None
|
|
|
|
def _handle_new_service_for_buddy(self, service, local):
|
|
"""Deal with a new discovered service object."""
|
|
# Once a service is resolved, we match it up to an existing buddy,
|
|
# or create a new Buddy if this is the first service known about the buddy
|
|
buddy_was_valid = False
|
|
name = service.get_name()
|
|
buddy = None
|
|
try:
|
|
buddy = self._buddies[name]
|
|
buddy_was_valid = buddy.is_valid()
|
|
service_added = buddy.add_service(service)
|
|
if service_added:
|
|
self._dbus_helper.ServiceAppeared(service.object_path())
|
|
except KeyError:
|
|
source_addr = service.get_source_address()
|
|
objid = self._get_next_object_id()
|
|
buddy = Buddy.Buddy(self._bus_name, objid, service, self._icon_cache)
|
|
self._buddies[name] = buddy
|
|
self._dbus_helper.ServiceAppeared(service.object_path())
|
|
if not buddy_was_valid and buddy.is_valid():
|
|
self._dbus_helper.BuddyAppeared(buddy.object_path())
|
|
return buddy
|
|
|
|
def _handle_new_activity_service(self, service):
|
|
# If the serivce is an activity service, merge it into our activities list
|
|
actid = service.get_activity_id()
|
|
if not actid:
|
|
return
|
|
activity = None
|
|
was_valid = False
|
|
if not self._activities.has_key(actid):
|
|
objid = self._get_next_object_id()
|
|
activity = Activity.Activity(self._bus_name, objid, service)
|
|
self._activities[actid] = activity
|
|
else:
|
|
activity = self._activities[actid]
|
|
was_valid = activity.is_valid()
|
|
|
|
if activity:
|
|
activity.add_service(service)
|
|
|
|
# Add the activity to its buddy
|
|
# FIXME: use something other than name to attribute to buddy
|
|
try:
|
|
buddy = self._buddies[service.get_name()]
|
|
buddy.add_activity(activity)
|
|
except KeyError:
|
|
pass
|
|
|
|
if not was_valid and activity.is_valid():
|
|
self._dbus_helper.ActivityAppeared(activity.object_path())
|
|
|
|
def _handle_remove_activity_service(self, service):
|
|
actid = service.get_activity_id()
|
|
if not actid:
|
|
return
|
|
if not self._activities.has_key(actid):
|
|
return
|
|
|
|
activity = self._activities[actid]
|
|
|
|
activity.remove_service(service)
|
|
if len(activity.get_services()) == 0:
|
|
# Remove the activity from its buddy
|
|
# FIXME: use something other than name to attribute to buddy
|
|
try:
|
|
buddy = self._buddies[service.get_name()]
|
|
buddy.remove_activity(activity)
|
|
except KeyError:
|
|
pass
|
|
|
|
# Kill the activity
|
|
self._dbus_helper.ActivityDisappeared(activity.object_path())
|
|
del self._activities[actid]
|
|
|
|
def _service_resolved_cb(self, adv, interface, protocol, full_name,
|
|
stype, domain, host, aprotocol, address, port, txt, flags,
|
|
updated):
|
|
"""When the service discovery finally gets here, we've got enough
|
|
information about the service to assign it to a buddy."""
|
|
if updated == False:
|
|
logging.debug("Resolved service '%s' type '%s' domain '%s' to " \
|
|
" %s:%s" % (full_name, stype, domain, address, port))
|
|
|
|
if not adv in self._service_advs:
|
|
return False
|
|
if adv.state() != _SA_RESOLVED:
|
|
return False
|
|
|
|
# See if we know about this service already
|
|
service = None
|
|
key = (full_name, stype)
|
|
props = _txt_to_dict(txt)
|
|
if not self._services.has_key(key):
|
|
objid = self._get_next_object_id()
|
|
service = Service.Service(self._bus_name, objid, name=full_name,
|
|
stype=stype, domain=domain, address=address, port=port,
|
|
properties=props, source_address=address)
|
|
self._services[key] = service
|
|
else:
|
|
# Already tracking this service; either:
|
|
# a) we were the one that shared it in the first place,
|
|
# and therefore the source address would not have
|
|
# been set yet
|
|
# b) the service has been updated
|
|
service = self._services[key]
|
|
if not service.get_source_address():
|
|
service.set_source_address(address)
|
|
if not service.get_address():
|
|
service.set_address(address)
|
|
|
|
adv.set_service(service)
|
|
|
|
if service and updated:
|
|
service.set_properties(props, from_network=True)
|
|
return False
|
|
|
|
# Merge the service into our buddy and activity lists, if needed
|
|
buddy = self._handle_new_service_for_buddy(service, adv.is_local())
|
|
if buddy and service.get_activity_id():
|
|
self._handle_new_activity_service(service)
|
|
|
|
return False
|
|
|
|
def _service_resolved_cb_glue(self, adv, interface, protocol, name,
|
|
stype, domain, host, aprotocol, address, port, txt, flags):
|
|
# Avahi doesn't flag updates to existing services, so we have
|
|
# to determine that here
|
|
updated = False
|
|
if adv.state() == _SA_RESOLVED:
|
|
updated = True
|
|
|
|
adv.set_state(_SA_RESOLVED)
|
|
gobject.idle_add(self._service_resolved_cb, adv, interface,
|
|
protocol, name, stype, domain, host, aprotocol, address,
|
|
port, txt, flags, updated)
|
|
|
|
def _service_resolved_failure_cb(self, adv, err):
|
|
adv.set_state(_SA_UNRESOLVED)
|
|
logging.error("Error resolving service %s.%s: %s" % (adv.name(), adv.stype(), err))
|
|
|
|
def _resolve_service(self, adv):
|
|
"""Resolve and lookup a ZeroConf service to obtain its address and TXT records."""
|
|
# Ask avahi to resolve this particular service
|
|
path = self._mdns_service.ServiceResolverNew(dbus.Int32(adv.interface()),
|
|
dbus.Int32(adv.protocol()), adv.name(), adv.stype(), adv.domain(),
|
|
avahi.PROTO_UNSPEC, dbus.UInt32(0))
|
|
resolver = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, path),
|
|
avahi.DBUS_INTERFACE_SERVICE_RESOLVER)
|
|
resolver.connect_to_signal('Found', lambda *args: self._service_resolved_cb_glue(adv, *args))
|
|
resolver.connect_to_signal('Failure', lambda *args: self._service_resolved_failure_cb(adv, *args))
|
|
adv.set_resolver(resolver)
|
|
return False
|
|
|
|
def _service_appeared_cb(self, interface, protocol, full_name, stype, domain, flags):
|
|
local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
|
|
adv_list = self._find_service_adv(interface=interface, protocol=protocol,
|
|
name=full_name, stype=stype, domain=domain, local=local)
|
|
adv = None
|
|
if not adv_list:
|
|
adv = ServiceAdv(interface=interface, protocol=protocol, name=full_name,
|
|
stype=stype, domain=domain, local=local)
|
|
self._service_advs.append(adv)
|
|
else:
|
|
adv = adv_list[0]
|
|
|
|
# Decompose service name if we can
|
|
(actid, buddy_name) = Service.decompose_service_name(full_name)
|
|
|
|
# If we care about the service right now, resolve it
|
|
resolve = False
|
|
item = self._find_registered_service_type(stype)
|
|
if actid is not None or item is not None:
|
|
resolve = True
|
|
if resolve and adv.state() == _SA_UNRESOLVED:
|
|
logging.debug("Found '%s' (%d) of type '%s' in domain" \
|
|
" '%s' on %i.%i; will resolve." % (full_name, flags, stype,
|
|
domain, interface, protocol))
|
|
adv.set_state(_SA_RESOLVE_PENDING)
|
|
gobject.idle_add(self._resolve_service, adv)
|
|
|
|
return False
|
|
|
|
def _service_appeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
|
|
gobject.idle_add(self._service_appeared_cb, interface, protocol, name, stype, domain, flags)
|
|
|
|
def _service_disappeared_cb(self, interface, protocol, full_name, stype, domain, flags):
|
|
local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
|
|
# If it's an unresolved service, remove it from our unresolved list
|
|
adv_list = self._find_service_adv(interface=interface, protocol=protocol,
|
|
name=full_name, stype=stype, domain=domain, local=local)
|
|
if not adv_list:
|
|
return False
|
|
|
|
# Get the service object; if none, we have nothing left to do
|
|
adv = adv_list[0]
|
|
service = adv.service()
|
|
self._service_advs.remove(adv)
|
|
del adv
|
|
if not service:
|
|
return False
|
|
|
|
logging.debug("Service %s.%s in domain %s on %i.%i disappeared." % (full_name,
|
|
stype, domain, interface, protocol))
|
|
|
|
self._dbus_helper.ServiceDisappeared(service.object_path())
|
|
self._handle_remove_activity_service(service)
|
|
|
|
# Decompose service name if we can
|
|
(actid, buddy_name) = Service.decompose_service_name(full_name)
|
|
|
|
# Remove the service from the buddy
|
|
try:
|
|
buddy = self._buddies[buddy_name]
|
|
except KeyError:
|
|
pass
|
|
else:
|
|
buddy.remove_service(service)
|
|
if not buddy.is_valid():
|
|
self._dbus_helper.BuddyDisappeared(buddy.object_path())
|
|
del self._buddies[buddy_name]
|
|
key = (service.get_full_name(), service.get_type())
|
|
del self._services[key]
|
|
return False
|
|
|
|
def _service_disappeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
|
|
gobject.idle_add(self._service_disappeared_cb, interface, protocol, name, stype, domain, flags)
|
|
|
|
def _new_service_type_cb(self, interface, protocol, stype, domain, flags):
|
|
# Are we already browsing this domain for this type?
|
|
if self._service_browsers.has_key((interface, protocol, stype, domain)):
|
|
return
|
|
|
|
# Start browsing for all services of this type in this domain
|
|
try:
|
|
s_browser = self._mdns_service.ServiceBrowserNew(interface,
|
|
protocol, stype, domain, dbus.UInt32(0))
|
|
browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, s_browser),
|
|
avahi.DBUS_INTERFACE_SERVICE_BROWSER)
|
|
browser_obj.connect_to_signal('ItemNew', self._service_appeared_cb_glue)
|
|
browser_obj.connect_to_signal('ItemRemove', self._service_disappeared_cb_glue)
|
|
|
|
self._service_browsers[(interface, protocol, stype, domain)] = browser_obj
|
|
except dbus.DBusException:
|
|
logging.debug("Error browsing service type '%s'" % stype)
|
|
return False
|
|
|
|
def _new_service_type_cb_glue(self, interface, protocol, stype, domain, flags):
|
|
if len(stype) > 0:
|
|
gobject.idle_add(self._new_service_type_cb, interface, protocol,
|
|
stype, domain, flags)
|
|
|
|
def _new_domain_cb(self, interface, protocol, domain, flags=0):
|
|
"""Callback from Avahi when a new domain has been found. Start
|
|
browsing the new domain."""
|
|
# Only use .local for now...
|
|
if domain != "local":
|
|
return
|
|
|
|
# Are we already browsing this domain?
|
|
if self._service_type_browsers.has_key((interface, protocol, domain)):
|
|
return
|
|
|
|
# Start browsing this domain for the services its members offer
|
|
try:
|
|
st_browser = self._mdns_service.ServiceTypeBrowserNew(interface, protocol, domain, dbus.UInt32(0))
|
|
browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, st_browser),
|
|
avahi.DBUS_INTERFACE_SERVICE_TYPE_BROWSER)
|
|
except dbus.DBusException, exc:
|
|
str_exc = str(exc)
|
|
logging.error("got exception %s while attempting to browse domain %s on %i.%i" % (str_exc, domain, interface, protocol))
|
|
if str_exc.find("The name org.freedesktop.Avahi was not provided by any .service files") >= 0:
|
|
raise Exception("Avahi does not appear to be running. '%s'" % str_exc)
|
|
else:
|
|
raise exc
|
|
logging.debug("Browsing domain '%s' on %i.%i ..." % (domain, interface, protocol))
|
|
browser_obj.connect_to_signal('ItemNew', self._new_service_type_cb_glue)
|
|
self._service_type_browsers[(interface, protocol, domain)] = browser_obj
|
|
return False
|
|
|
|
def _new_domain_cb_glue(self, interface, protocol, domain, flags=0):
|
|
gobject.idle_add(self._new_domain_cb, interface, protocol, domain, flags)
|
|
|
|
def join_activity(self, activity, stype, sender):
|
|
services = activity.get_services_of_type(stype)
|
|
if not len(services):
|
|
raise NotFoundError("The service type %s was not present within " \
|
|
"the activity %s" % (stype, activity.object_path()))
|
|
act_service = services[0]
|
|
props = act_service.get_properties()
|
|
color = activity.get_color()
|
|
if color:
|
|
props['color'] = color
|
|
return self._share_activity(activity.get_id(), stype, properties,
|
|
act_service.get_address(), act_service.get_port(),
|
|
act_service.get_domain(), sender)
|
|
|
|
def share_activity(self, activity_id, stype, properties=None, address=None,
|
|
port=-1, domain=u"local", sender=None):
|
|
"""Convenience function to share an activity with other buddies."""
|
|
if not util.validate_activity_id(activity_id):
|
|
raise ValueError("invalid activity id")
|
|
owner_nick = self._owner.get_name()
|
|
real_name = Service.compose_service_name(owner_nick, activity_id)
|
|
if address and not isinstance(address, unicode):
|
|
raise ValueError("address must be a unicode string.")
|
|
if address == None and stype.endswith('_udp'):
|
|
# Use random currently unassigned multicast address
|
|
address = u"232.%d.%d.%d" % (random.randint(0, 254), random.randint(1, 254),
|
|
random.randint(1, 254))
|
|
properties['address'] = address
|
|
properties['port'] = port
|
|
if port and port != -1 and (not isinstance(port, int) or port <= 1024 or port >= 65535):
|
|
raise ValueError("port must be a number between 1024 and 65535")
|
|
|
|
color = self._owner.get_color()
|
|
if color:
|
|
properties['color'] = color
|
|
|
|
logging.debug('Share activity %s, type %s, address %s, port %d, " \
|
|
"properties %s' % (activity_id, stype, address, port,
|
|
properties))
|
|
return self.register_service(real_name, stype, properties, address,
|
|
port, domain, sender)
|
|
|
|
def register_service(self, name, stype, properties={}, address=None,
|
|
port=-1, domain=u"local", sender=None):
|
|
"""Register a new service, advertising it to other Buddies on the network."""
|
|
# Refuse to register if we can't get the dbus connection this request
|
|
# came from for some reason
|
|
if not sender:
|
|
raise RuntimeError("Service registration request must have a sender.")
|
|
|
|
(actid, person_name) = Service.decompose_service_name(name)
|
|
if self.get_owner() and person_name != self.get_owner().get_name():
|
|
raise RuntimeError("Tried to register a service that didn't have" \
|
|
" Owner nick as the service name!")
|
|
if not domain or not len(domain):
|
|
domain = u"local"
|
|
if not port or port == -1:
|
|
port = random.randint(4000, 65000)
|
|
|
|
objid = self._get_next_object_id()
|
|
service = Service.Service(self._bus_name, objid, name=name,
|
|
stype=stype, domain=domain, address=address, port=port,
|
|
properties=properties, source_address=None,
|
|
local_publisher=sender)
|
|
self._services[(name, stype)] = service
|
|
self.register_service_type(stype)
|
|
service.register(self._system_bus, self._mdns_service)
|
|
return service
|
|
|
|
def unregister_service(self, service, sender=None):
|
|
service.unregister(sender)
|
|
|
|
def register_service_type(self, stype):
|
|
"""Requests that the Presence service look for and recognize
|
|
a certain mDNS service types."""
|
|
if not isinstance(stype, unicode):
|
|
raise ValueError("service type must be a unicode string.")
|
|
|
|
# If we've already registered it as a service type, ref it and return
|
|
item = self._find_registered_service_type(stype)
|
|
if item is not None:
|
|
item.ref()
|
|
return
|
|
|
|
# Otherwise track this type now
|
|
obj = RegisteredServiceType(stype)
|
|
self._registered_service_types.append(obj)
|
|
|
|
# Find unresolved services that match the service type
|
|
# we're now interested in, and resolve them
|
|
resolv_list = []
|
|
|
|
# Find services of this type
|
|
resolv_list = self._find_service_adv(stype=stype)
|
|
# Request resolution for them if they aren't in-process already
|
|
for adv in resolv_list:
|
|
if adv.state() == _SA_UNRESOLVED:
|
|
adv.set_state(_SA_RESOLVE_PENDING)
|
|
gobject.idle_add(self._resolve_service, adv)
|
|
|
|
def unregister_service_type(self, stype):
|
|
"""Stop tracking a certain mDNS service."""
|
|
if not isinstance(stype, unicode):
|
|
raise ValueError("service type must be a unicode string.")
|
|
|
|
# if it was found, unref it and possibly remove it
|
|
item = self._find_registered_service_type(stype)
|
|
if not item:
|
|
return
|
|
if item.unref() <= 0:
|
|
self._registered_service_types.remove(item)
|
|
del item
|
|
|
|
|
|
def main():
|
|
from sugar import TracebackUtils
|
|
loop = gobject.MainLoop()
|
|
ps = PresenceService()
|
|
tbh = TracebackUtils.TracebackHelper()
|
|
try:
|
|
loop.run()
|
|
except KeyboardInterrupt:
|
|
print 'Ctrl+C pressed, exiting...'
|
|
|
|
del tbh
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|