sugar-toolkit-gtk3/services/presence/PresenceService.py

877 lines
34 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
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
self._service_blacklist = {}
# 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))
else:
key = adv.name() + "." + adv.stype()
if not self._service_blacklist.has_key(key):
logging.error("Adding service %s to blacklist" % key)
self._service_blacklist[key] = 1
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."""
key = adv.name() + "." + adv.stype()
if self._service_blacklist.has_key(key):
return False
# Ask avahi to resolve this particular service
try:
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))
except dbus.DBusException, e:
if str(e).find("TooManyObjectsError") >= 0:
return False
raise e
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():
loop = gobject.MainLoop()
ps = PresenceService()
try:
loop.run()
except KeyboardInterrupt:
print 'Ctrl+C pressed, exiting...'
if __name__ == "__main__":
main()