# 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 from sugar import profile 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 self._resolv_tries = 0 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 resolv_tries(self): return self._resolv_tries def inc_resolv_tries(self): self._resolv_tries += 1 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 resolver and not isinstance(resolver, dbus.Interface): raise ValueError("'resolver' must be a valid dbus object") if not resolver and self._resolver: del self._resolver 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.") if state == _SA_UNRESOLVED: self._resolv_tries = 0 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('=', 1) 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._started = False 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 profile.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 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_INET, "local") # Connect to Avahi and start looking for stuff domain_browser = self._mdns_service.DomainBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_INET, "", 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): retried = False adv.set_resolver(None) if adv.stype() == Buddy.PRESENCE_SERVICE_TYPE: # Retry the presence service type a few times if adv.resolv_tries() < 4: adv.set_state(_SA_RESOLVE_PENDING) gobject.timeout_add(250, self._resolve_service, adv) retried = True logging.error("Retrying resolution of service %s.%s: %s" % (adv.name(), adv.stype(), err)) if not retried: logging.error("Error resolving service %s.%s: %s" % (adv.name(), adv.stype(), err)) adv.set_state(_SA_UNRESOLVED) 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_INET, 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.inc_resolv_tries() 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()