Merge

services/presence/Activity.py

@@ -0,0 +1,171 @@
+import dbus
+
+PRESENCE_SERVICE_TYPE = "_presence_olpc._tcp"
+ACTIVITY_DBUS_OBJECT_PATH = "/org/laptop/Presence/Activities/"
+ACTIVITY_DBUS_INTERFACE = "org.laptop.Presence.Activity"
+
+class NotFoundError(Exception):
+	pass
+
+class ActivityDBusHelper(dbus.service.Object):
+	def __init__(self, parent, bus_name, object_path):
+		self._parent = parent
+		self._bus_name = bus_name
+		self._object_path = object_path
+		dbus.service.Object.__init__(self, bus_name, self._object_path)
+
+	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+						in_signature="s", out_signature="ao")
+	def getServicesOfType(self, stype):
+		services = self._parent.get_services_of_type(stype)
+		if not services:
+			raise NotFoundError("Not found")
+		ret = []
+		for serv in services:
+			ret.append(serv.object_path())
+		return ret
+
+	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+						in_signature="", out_signature="ao")
+	def getServices(self):
+		services = self._parent.get_services()
+		if not services:
+			raise NotFoundError("Not found")
+		ret = []
+		for serv in services:
+			ret.append(serv.object_path())
+		return ret
+
+	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+						in_signature="", out_signature="s")
+	def getId(self):
+		return self._parent.get_id()
+
+	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+						in_signature="", out_signature="s")
+	def getColor(self):
+		return self._parent.get_color()
+
+	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+						in_signature="", out_signature="ao")
+	def getJoinedBuddies(self):
+		buddies = self._parent.get_joined_buddies()
+		if not buddies:
+			raise NotFoundError("Not found")
+		ret = []
+		for buddy in buddies:
+			ret.append(buddy.object_path())
+		return ret
+	
+	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+						signature="o")
+	def ServiceAppeared(self, object_path):
+		pass
+
+	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+						signature="o")
+	def ServiceDisappeared(self, object_path):
+		pass
+
+	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+						signature="o")
+	def BuddyJoined(self, object_path):
+		pass
+
+	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+						signature="o")
+	def BuddyLeft(self, object_path):
+		pass
+
+
+class Activity(object):
+	def __init__(self, bus_name, object_id, initial_service):
+		if not initial_service.get_activity_id():
+			raise ValueError("Service must have a valid Activity ID")
+		self._activity_id = initial_service.get_activity_id()
+
+		self._buddies = []
+		self._services = {}	# service type -> list of Services
+		self._color = None
+		self._valid = False
+
+		self._object_id = object_id
+		self._object_path = "/org/laptop/Presence/Activities/%d" % self._object_id
+		self._dbus_helper = ActivityDBusHelper(self, bus_name, self._object_path)
+		
+		self.add_service(initial_service)
+
+	def object_path(self):
+		return dbus.ObjectPath(self._object_path)
+
+	def is_valid(self):
+		"""An activity is only valid when it's color is available."""
+		return self._valid
+
+	def get_id(self):
+		return self._activity_id
+
+	def get_color(self):
+		return self._color
+
+	def get_services(self):
+		ret = []
+		for serv_list in self._services.values():
+			for service in serv_list:
+				if service not in ret:
+					ret.append(service)
+		return ret
+
+	def get_services_of_type(self, stype):
+		if self._services.has_key(stype):
+			return self._services[stype]
+		return None
+
+	def get_joined_buddies(self):
+		buddies = []
+		for serv_list in self._services.values():
+			for serv in serv_list:
+				owner = serv.get_owner()
+				if not owner in buddies and owner.is_valid():
+					buddies.append(owner)
+		return buddies
+
+	def add_service(self, service):
+		stype = service.get_type()
+		if not self._services.has_key(stype):
+			self._services[stype] = []
+
+		if not self._color:
+			color = service.get_one_property('color')
+			if color:
+				self._color = color
+				self._valid = True
+
+		# Send out the BuddyJoined signal if this is the first
+		# service from the buddy that we've seen
+		buddies = self.get_joined_buddies()
+		serv_owner = service.get_owner()
+		if serv_owner and serv_owner not in buddies and serv_owner.is_valid():
+			self._dbus_helper.BuddyJoined(serv_owner.object_path())
+			serv_owner.add_activity(self)
+
+		if not service in self._services[stype]:
+			self._services[stype].append(service)
+			self._dbus_helper.ServiceAppeared(service.object_path())
+
+	def remove_service(self, service):
+		stype = service.get_type()
+		if not self._services.has_key(stype):
+			return
+		self._services[stype].remove(service)
+		self._dbus_helper.ServiceDisappeared(service.object_path())
+		if len(self._services[stype]) == 0:
+			del self._services[stype]
+
+		# Send out the BuddyLeft signal if this is the last
+		# service from the buddy
+		buddies = self.get_joined_buddies()
+		serv_owner = service.get_owner()
+		if serv_owner and serv_owner not in buddies and serv_owner.is_valid():
+			serv_owner.remove_activity(self)
+			self._dbus_helper.BuddyLeft(serv_owner.object_path())

services/presence/Buddy.py

@@ -0,0 +1,402 @@
+import base64
+import logging
+
+import gobject
+import dbus, dbus.service
+from sugar import env
+
+
+PRESENCE_SERVICE_TYPE = "_presence_olpc._tcp"
+BUDDY_DBUS_OBJECT_PATH = "/org/laptop/Presence/Buddies/"
+BUDDY_DBUS_INTERFACE = "org.laptop.Presence.Buddy"
+
+class NotFoundError(Exception):
+	pass
+
+class BuddyDBusHelper(dbus.service.Object):
+	def __init__(self, parent, bus_name, object_path):
+		self._parent = parent
+		self._bus_name = bus_name
+		self._object_path = object_path
+		dbus.service.Object.__init__(self, bus_name, self._object_path)
+
+	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
+						signature="o")
+	def ServiceAppeared(self, object_path):
+		pass
+
+	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
+						signature="o")
+	def ServiceDisappeared(self, object_path):
+		pass
+
+	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
+						signature="")
+	def IconChanged(self):
+		pass
+
+	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
+						signature="o")
+	def JoinedActivity(self, object_path):
+		pass
+
+	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
+						signature="o")
+	def LeftActivity(self, object_path):
+		pass
+
+	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
+						signature="as")
+	def PropertyChanged(self, prop_list):
+		pass
+
+	@dbus.service.method(BUDDY_DBUS_INTERFACE,
+						in_signature="", out_signature="ay")
+	def getIcon(self):
+		icon = self._parent.get_icon()
+		if not icon:
+			return ""
+		return icon
+
+	@dbus.service.method(BUDDY_DBUS_INTERFACE,
+						in_signature="s", out_signature="o")
+	def getServiceOfType(self, stype):
+		service = self._parent.get_service_of_type(stype)
+		if not service:
+			raise NotFoundError("Not found")
+		return service.object_path()
+
+	@dbus.service.method(BUDDY_DBUS_INTERFACE,
+						in_signature="", out_signature="ao")
+	def getJoinedActivities(self):
+		acts = []
+		for act in self._parent.get_joined_activities():
+			acts.append(act.object_path())
+		return acts
+
+	@dbus.service.method(BUDDY_DBUS_INTERFACE,
+						in_signature="", out_signature="a{sv}")
+	def getProperties(self):
+		props = {}
+		props['name'] = self._parent.get_name()
+		addr = self._parent.get_address()
+		if addr:
+			props['ip4_address'] = addr
+		props['owner'] = self._parent.is_owner()
+		color = self._parent.get_color()
+		if color:
+			props['color'] = self._parent.get_color()
+		return props
+
+
+class Buddy(object):
+	"""Represents another person on the network and keeps track of the
+	activities and resources they make available for sharing."""
+
+	def __init__(self, bus_name, object_id, service):
+		if not bus_name:
+			raise ValueError("DBus bus name must be valid")
+		if not object_id or type(object_id) != type(1):
+			raise ValueError("object id must be a valid number")
+		# Normal Buddy objects must be created with a valid service,
+		# owner objects do not
+		if not isinstance(self, Owner):
+			if not isinstance(service, Service.Service):
+				raise ValueError("service must be a valid service object")
+
+		self._services = {}
+		self._activities = {}
+
+		self._nick_name = None
+		self._address = None
+		if service is not None:
+			self._nick_name = service.get_name()
+			self._address = service.get_source_address()
+		self._color = None
+		self._valid = False
+		self._icon = None
+		self._icon_tries = 0
+
+		self._object_id = object_id
+		self._object_path = BUDDY_DBUS_OBJECT_PATH + str(self._object_id)
+		self._dbus_helper = BuddyDBusHelper(self, bus_name, self._object_path)
+
+		if service is not None:
+			self.add_service(service)
+
+	def object_path(self):
+		return dbus.ObjectPath(self._object_path)
+
+	def _request_buddy_icon_cb(self, result_status, response, user_data):
+		"""Callback when icon request has completed."""
+		from sugar.p2p import network
+		icon = response
+		service = user_data
+		if result_status == network.RESULT_SUCCESS:
+			if icon and len(icon):
+				icon = base64.b64decode(icon)
+				logging.debug("Buddy icon for '%s' is size %d" % (self._nick_name, len(icon)))
+				self._set_icon(icon)
+
+		if (result_status == network.RESULT_FAILED or not icon) and self._icon_tries < 3:
+			self._icon_tries = self._icon_tries + 1
+			logging.debug("Failed to retrieve buddy icon for '%s' on try %d of %d" % (self._nick_name, \
+					self._icon_tries, 3))
+			gobject.timeout_add(1000, self._request_buddy_icon, service)
+		return False
+
+	def _request_buddy_icon(self, service):
+		"""Contact the buddy to retrieve the buddy icon."""
+		from sugar.p2p import Stream
+		buddy_stream = Stream.Stream.new_from_service(service, start_reader=False)
+		writer = buddy_stream.new_writer(service)
+		success = writer.custom_request("get_buddy_icon", self._request_buddy_icon_cb, service)
+		if not success:
+			del writer, buddy_stream
+			gobject.timeout_add(1000, self._request_buddy_icon, service)
+		return False
+
+	def _get_service_key(self, service):
+		return (service.get_type(), service.get_activity_id())
+
+	def add_service(self, service):
+		"""Adds a new service to this buddy's service list, returning
+		True if the service was successfully added, and False if it was not."""
+		if service.get_name() != self._nick_name:
+			logging.error("Service and buddy nick names doesn't match: " \
+					"%s %s" % (service.get_name(), self._nick_name))
+			return False
+
+		source_addr = service.get_source_address()
+		if source_addr != self._address:
+			logging.error("Service source and buddy address doesn't " \
+					"match: %s %s" % (source_addr, self._address))
+			return False		
+		return self._internal_add_service(service)
+
+	def _internal_add_service(self, service):
+		service_key = self._get_service_key(service)
+		if service_key in self._services.keys():
+			logging.error("Service already known: %s %s" % (service_key[0],
+					service_key[1]))
+			return False
+
+		logging.debug("Buddy %s added service type %s id %s" % (self._nick_name,
+				service.get_type(), service.get_activity_id()))
+		self._services[service_key] = service
+		service.set_owner(self)
+
+		if service.get_type() == PRESENCE_SERVICE_TYPE:
+			# A buddy isn't valid until its official presence
+			# service has been found and resolved
+			self._valid = True
+			print 'Requesting buddy icon %s' % self._nick_name
+			self._request_buddy_icon(service)
+			self._color = service.get_one_property('color')
+			if self._color:
+				self._dbus_helper.PropertyChanged(['color'])
+
+		if self._valid:
+			self._dbus_helper.ServiceAppeared(service.object_path())
+		return True
+
+	def add_activity(self, activity):
+		actid = activity.get_id()
+		if activity in self._activities.values():
+			raise RuntimeError("Tried to add activity twice")
+		found = False
+		for serv in self._services.values():
+			if serv.get_activity_id() == activity.get_id():
+				found = True
+				break
+		if not found:
+			raise RuntimeError("Tried to add activity for which we had no service")
+		self._activities[actid] = activity
+		if activity.is_valid():
+			self._dbus_helper.JoinedActivity(activity.object_path())
+
+	def remove_service(self, service):
+		"""Remove a service from a buddy; ie, the activity was closed
+		or the buddy went away."""
+		if service.get_source_address() != self._address:
+			return
+		if service.get_name() != self._nick_name:
+			return
+		service_key = self._get_service_key(service)
+		if self._services.has_key(service_key):
+			if self._valid:
+				self._dbus_helper.ServiceDisappeared(service.object_path())
+			del self._services[service_key]
+
+		if service.get_type() == PRESENCE_SERVICE_TYPE:
+			self._valid = False
+
+	def remove_activity(self, activity):
+		actid = activity.get_id()
+		if not self._activities.has_key(actid):
+			return
+		del self._activities[actid]
+		if activity.is_valid():
+			self._dbus_helper.LeftActivity(activity.object_path())
+
+	def get_joined_activities(self):
+		acts = []
+		for act in self._activities.values():
+			if act.is_valid():
+				acts.append(act)
+		return acts
+
+	def get_service_of_type(self, stype=None, activity=None):
+		"""Return a service of a certain type, or None if the buddy
+		doesn't provide that service."""
+		if not stype:
+			raise RuntimeError("Need to specify a service type.")
+
+		if activity and not activity.is_valid():
+			raise RuntimeError("Activity is not yet valid.")
+
+		if activity:
+			key = (stype, activity.get_id())
+		else:
+			key = (stype, None)
+		if self._services.has_key(key):
+			return self._services[key]
+		return None
+
+	def is_valid(self):
+		"""Return whether the buddy is valid or not.  A buddy is
+		not valid until its official presence service has been found
+		and successfully resolved."""
+		return self._valid
+
+	def get_icon(self):
+		"""Return the buddies icon, if any."""
+		return self._icon
+		
+	def get_address(self):
+		return self._address
+
+	def get_name(self):
+		return self._nick_name
+
+	def get_color(self):
+		return self._color
+
+	def _set_icon(self, icon):
+		"""Can only set icon for other buddies.  The Owner
+		takes care of setting it's own icon."""
+		if icon != self._icon:
+			self._icon = icon
+			self._dbus_helper.IconChanged()
+
+	def is_owner(self):
+		return False
+
+
+class Owner(Buddy):
+	"""Class representing the owner of the machine.  This is the client
+	portion of the Owner, paired with the server portion in Owner.py."""
+	def __init__(self, ps, bus_name, object_id):
+		Buddy.__init__(self, bus_name, object_id, None)
+		self._nick_name = env.get_nick_name()
+		self._color = env.get_color()
+		self._ps = ps
+
+	def add_service(self, service):
+		"""Adds a new service to this buddy's service list, returning
+		True if the service was successfully added, and False if it was not."""
+		if service.get_name() != self._nick_name:
+			logging.error("Service and buddy nick names doesn't match: " \
+					"%s %s" % (service.get_name(), self._nick_name))
+			return False
+
+		# The Owner initially doesn't have an address, so the first
+		# service added to the Owner determines the owner's address
+		source_addr = service.get_source_address()
+		if self._address is None and service.is_local():
+			self._address = source_addr
+			self._dbus_helper.PropertyChanged(['ip4_address'])
+
+		# The owner bypasses address checks and only cares if
+		# avahi says the service is a local service
+		if not service.is_local():
+			logging.error("Cannot add remote service to owner object.")
+			return False
+
+		logging.debug("Adding owner service %s.%s at %s:%d." % (service.get_name(),
+				service.get_type(), service.get_source_address(),
+				service.get_port()))
+		return self._internal_add_service(service)
+
+	def is_owner(self):
+		return True
+
+
+#################################################################
+# Tests
+#################################################################
+
+import unittest
+import Service
+
+__objid_seq = 0
+def _next_objid():
+	global __objid_seq
+	__objid_seq = __objid_seq + 1
+	return __objid_seq
+
+
+class BuddyTestCase(unittest.TestCase):
+	_DEF_NAME = u"Tommy"
+	_DEF_STYPE = unicode(PRESENCE_SERVICE_TYPE)
+	_DEF_DOMAIN = u"local"
+	_DEF_ADDRESS = u"1.1.1.1"
+	_DEF_PORT = 1234
+
+	def __init__(self, name):
+		self._bus = dbus.SessionBus()
+		self._bus_name = dbus.service.BusName('org.laptop.Presence', bus=self._bus)		
+		unittest.TestCase.__init__(self, name)
+
+	def __del__(self):
+		del self._bus_name
+		del self._bus
+
+	def _test_init_fail(self, service, fail_msg):
+		"""Test something we expect to fail."""
+		try:
+			objid = _next_objid()
+			buddy = Buddy(self._bus_name, objid, service, owner=False)
+		except ValueError, exc:
+			pass
+		else:
+			self.fail("expected a ValueError for %s." % fail_msg)
+
+	def testService(self):
+		service = None
+		self._test_init_fail(service, "invalid service")
+
+	def testGoodInit(self):
+		objid = _next_objid()
+		service = Service.Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
+				self._DEF_ADDRESS, self._DEF_PORT)
+		objid = _next_objid()
+		buddy = Buddy(self._bus_name, objid, service)
+		assert buddy.get_name() == self._DEF_NAME, "buddy name wasn't correct after init."
+		assert buddy.get_address() == self._DEF_ADDRESS, "buddy address wasn't correct after init."
+		assert buddy.object_path() == BUDDY_DBUS_OBJECT_PATH + str(objid)
+
+	def addToSuite(suite):
+		suite.addTest(BuddyTestCase("testService"))
+		suite.addTest(BuddyTestCase("testGoodInit"))
+	addToSuite = staticmethod(addToSuite)
+
+
+def main():
+	suite = unittest.TestSuite()
+	BuddyTestCase.addToSuite(suite)
+	runner = unittest.TextTestRunner()
+	runner.run(suite)
+
+if __name__ == "__main__":
+	main()

services/presence/Makefile.am

@@ -0,0 +1,20 @@
+servicedir = $(datadir)/sugar/services
+service_in_files = org.laptop.Presence.service.in
+service_DATA = $(service_in_files:.service.in=.service)
+
+$(service_DATA): $(service_in_files) Makefile
+	@sed -e "s|\@bindir\@|$(bindir)|" $< > $@
+
+sugardir = $(pkgdatadir)/services/presence
+sugar_PYTHON =				\
+	__init__.py			\
+	Activity.py			\
+	Buddy.py			\
+	PresenceService.py		\
+	Service.py
+
+bin_SCRIPTS = sugar-presence-service
+
+DISTCLEANFILES = $(service_DATA)
+
+EXTRA_DIST = $(service_in_files) $(bin_SCRIPTS)

services/presence/PresenceService.py

@@ -0,0 +1,785 @@
+import avahi, dbus, dbus.glib, gobject
+import Buddy
+import Service
+import Activity
+import random
+import logging
+from sugar import util
+
+
+_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 type(name) != type(u""):
+			raise ValueError("service advertisement name must be unicode.")
+		self._name = name
+		if type(stype) != type(u""):
+			raise ValueError("service advertisement type must be unicode.")
+		self._stype = stype
+		if type(domain) != type(u""):
+			raise ValueError("service advertisement domain must be unicode.")
+		self._domain = domain
+		self._service = None
+		if type(local) != type(False):
+			raise ValueError("local must be a boolean.")
+		self._local = local
+		self._state = _SA_UNRESOLVED
+
+	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.")
+		self._service = service
+	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):
+		services = self._parent.get_services()
+		ret = []
+		for serv in services:
+			ret.append(serv.object_path())
+		return ret
+
+	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+						in_signature="s", out_signature="ao")
+	def getServicesOfType(self, stype):
+		services = self._parent.get_services_of_type(stype)
+		ret = []
+		for serv in services:
+			ret.append(serv.object_path())
+		return ret
+
+	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+						in_signature="", out_signature="ao")
+	def getActivities(self):
+		activities = self._parent.get_activities()
+		ret = []
+		for act in 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):
+		buddies = self._parent.get_buddies()
+		ret = []
+		for buddy in 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 activity %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)
+
+		# Our owner object
+		objid = self._get_next_object_id()
+		self._owner = Buddy.Owner(self, self._bus_name, objid)
+		self._buddies[self._owner.get_name()] = self._owner
+
+		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 _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._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)
+
+		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:
+			# Kill the activity
+			self._dbus_helper.ActivityDisappeared(activity.object_path())
+			del self._activities[actid]
+
+	def _resolve_service_reply_cb(self, adv, interface, protocol, full_name,
+			stype, domain, host, aprotocol, address, port, txt, flags):
+		"""When the service discovery finally gets here, we've got enough
+		information about the service to assign it to a buddy."""
+		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
+		key = (full_name, stype)
+		if not self._services.has_key(key):
+			objid = self._get_next_object_id()
+			props = _txt_to_dict(txt)
+			service = Service.Service(self._bus_name, objid, name=full_name,
+					stype=stype, domain=domain, address=address, port=port,
+					properties=props, source_address=address, local=adv.is_local())
+			self._services[key] = service
+		else:
+			# Already tracking this service; likely we were the one that shared it
+			# in the first place, and therefore the source address would not have
+			# been set yet
+			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)
+
+		# 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 _resolve_service_reply_cb_glue(self, adv, interface, protocol, name,
+			stype, domain, host, aprotocol, address, port, txt, flags):
+		adv.set_state(_SA_RESOLVED)
+		gobject.idle_add(self._resolve_service_reply_cb, adv, interface,
+				protocol, name, stype, domain, host, aprotocol, address,
+				port, txt, flags)
+
+	def _resolve_service_error_handler(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
+		self._mdns_service.ResolveService(int(adv.interface()), int(adv.protocol()), adv.name(),
+				adv.stype(), adv.domain(), avahi.PROTO_UNSPEC, dbus.UInt32(0),
+				reply_handler=lambda *args: self._resolve_service_reply_cb_glue(adv, *args),
+				error_handler=lambda *args: self._resolve_service_error_handler(adv, *args))
+		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
+		if actid is not None or stype in self._registered_service_types:
+			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
+		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
+		return False
+
+	def _new_service_type_cb_glue(self, interface, protocol, stype, domain, flags):
+		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 type(address) != type(u""):
+			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 (type(port) != type(1) 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."""
+		(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)
+
+		try:
+			obj = self._system_bus.get_object(avahi.DBUS_NAME, self._mdns_service.EntryGroupNew())
+			group = dbus.Interface(obj, avahi.DBUS_INTERFACE_ENTRY_GROUP)
+
+			# Add properties; ensure they are converted to ByteArray types
+			# because python sometimes can't figure that out
+			info = dbus.Array([], signature="aay")
+			for k, v in properties.items():
+				info.append(dbus.types.ByteArray("%s=%s" % (k, v)))
+
+			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=True,
+					local_publisher=sender)
+			self._services[(name, stype)] = service
+			port = service.get_port()
+
+			logging.debug("PS: Will register service with name='%s', stype='%s'," \
+					" domain='%s', address='%s', port=%d, info='%s'" % (name, stype,
+					domain, address, port, info))
+			group.AddService(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, 0, dbus.String(name),
+					dbus.String(stype), dbus.String(domain), dbus.String(""), # let Avahi figure the 'host' out
+					dbus.UInt16(port), info)
+			service.set_avahi_entry_group(group)
+			group.Commit()
+		except dbus.exceptions.DBusException, exc:
+			# FIXME: ignore local name collisions, since that means
+			# the zeroconf service is already registered.  Ideally we
+			# should un-register it an re-register with the correct info
+			if str(exc) == "Local name collision":
+				pass
+		self.register_service_type(stype)
+		return service
+
+	def unregister_service(self, service, sender=None):
+		local_publisher = service.get_local_publisher()
+		if sender is not None and local_publisher != sender:
+			raise ValueError("Service was not not registered by requesting process!")
+		group = service.get_avahi_entry_group()
+		if not group:
+			raise ValueError("Service was not a local service provided by this laptop!")
+		group.Free()
+
+	def register_service_type(self, stype):
+		"""Requests that the Presence service look for and recognize
+		a certain mDNS service types."""
+		if type(stype) != type(u""):
+			raise ValueError("service type must be a unicode string.")
+
+		# If we've already registered it as a service type, ref it and return
+		for item in self._registered_service_types:
+			if item.get_type() == stype:
+				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 type(stype) != type(u""):
+			raise ValueError("service type must be a unicode string.")
+		item = None
+		for item in self._registered_service_types:
+			if item.get_type() == stype:
+				break
+		# if it was found, unref it and possibly remove it
+		if item is not None:
+			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()

services/presence/Service.py

@@ -0,0 +1,488 @@
+import avahi
+import sys, os
+sys.path.insert(0, os.path.abspath("../../"))
+from sugar import util
+import dbus, dbus.service
+import random
+
+def compose_service_name(name, activity_id):
+	if type(name) == type(""):
+		name = unicode(name)
+	if not name:
+		raise ValueError("name must be a valid string.")
+	if not activity_id:
+		return name
+	if type(name) != type(u""):
+		raise ValueError("name must be in unicode.")
+	composed = "%s [%s]" % (name, activity_id)
+	return composed
+
+def decompose_service_name(name):
+	"""Break a service name into the name and activity ID, if we can."""
+	if type(name) != type(u""):
+		raise ValueError("name must be a valid unicode string.")
+	name_len = len(name)
+	if name_len < util.ACTIVITY_ID_LEN + 5:
+		return (None, name)
+	# check for activity id end marker
+	if name[name_len - 1] != "]":
+		return (None, name)
+	start = name_len - 1 - util.ACTIVITY_ID_LEN
+	end = name_len - 1
+	# check for activity id start marker
+	if name[start - 1] != "[" or name[start - 2] != " ":
+		return (None, name)
+	activity_id = name[start:end]
+	if not util.validate_activity_id(activity_id):
+		return (None, name)
+	return (activity_id, name[:start - 2])
+
+
+_ACTIVITY_ID_TAG = "ActivityID"
+SERVICE_DBUS_INTERFACE = "org.laptop.Presence.Service"
+SERVICE_DBUS_OBJECT_PATH = "/org/laptop/Presence/Services/"
+
+class ServiceDBusHelper(dbus.service.Object):
+	"""Handle dbus requests and signals for Service objects"""
+	def __init__(self, parent, bus_name, object_path):
+		self._parent = parent
+		self._bus_name = bus_name
+		self._object_path = object_path
+		dbus.service.Object.__init__(self, bus_name, self._object_path)
+
+	@dbus.service.signal(SERVICE_DBUS_INTERFACE,
+						signature="as")
+	def PublishedValueChanged(self, keylist):
+		pass
+
+	@dbus.service.method(SERVICE_DBUS_INTERFACE,
+						in_signature="", out_signature="a{sv}")
+	def getProperties(self):
+		"""Return service properties."""
+		pary = {}
+		pary['name'] = self._parent.get_name()
+		pary['type'] = self._parent.get_type()
+		pary['domain'] = self._parent.get_domain()
+		actid = self._parent.get_activity_id()
+		if actid:
+			pary['activityId'] = actid
+		port = self._parent.get_port()
+		if port:
+			pary['port'] = self._parent.get_port()
+		addr = self._parent.get_address()
+		if addr:
+			pary['address'] = addr
+		source_addr = self._parent.get_source_address()
+		if source_addr:
+			pary['sourceAddress'] = source_addr
+		return pary
+
+	@dbus.service.method(SERVICE_DBUS_INTERFACE,
+						in_signature="s")
+	def getPublishedValue(self, key):
+		"""Return the value belonging to the requested key from the
+		service's TXT records."""
+		val = self._parent.get_one_property(key)
+		if not val:
+			raise KeyError("Value was not found.")
+		return val
+
+	@dbus.service.method(SERVICE_DBUS_INTERFACE,
+						in_signature="", out_signature="a{sv}")
+	def getPublishedValues(self):
+		pary = {}
+		props = self._parent.get_properties()
+		for key, value in props.items():
+			pary[key] = str(value)
+		return dbus.Dictionary(pary)
+
+	@dbus.service.method(SERVICE_DBUS_INTERFACE,
+						sender_keyword="sender")
+	def setPublishedValue(self, key, value, sender):
+		self._parent.set_property(key, value, sender)
+
+	@dbus.service.method(SERVICE_DBUS_INTERFACE,
+						in_signature="a{sv}", sender_keyword="sender")
+	def setPublishedValues(self, values, sender):
+		self._parent.set_properties(values, sender)
+
+
+class Service(object):
+	"""Encapsulates information about a specific ZeroConf/mDNS
+	service as advertised on the network."""
+	def __init__(self, bus_name, object_id, name, stype, domain=u"local",
+				address=None, port=-1, properties=None, source_address=None,
+				local=False, local_publisher=None):
+		if not bus_name:
+			raise ValueError("DBus bus name must be valid")
+		if not object_id or type(object_id) != type(1):
+			raise ValueError("object id must be a valid number")
+
+		# Validate immutable options
+		if name and type(name) != type(u""):
+			raise ValueError("name must be unicode.")
+		if not name or not len(name):
+			raise ValueError("must specify a valid service name.")
+
+		if stype and type(stype) != type(u""):
+			raise ValueError("service type must be in unicode.")
+		if not stype or not len(stype):
+			raise ValueError("must specify a valid service type.")
+		if not stype.endswith("._tcp") and not stype.endswith("._udp"):
+			raise ValueError("must specify a TCP or UDP service type.")
+
+		if type(domain) != type(u""):
+			raise ValueError("domain must be in unicode.")
+		if domain and domain != "local":
+			raise ValueError("must use the 'local' domain (for now).")
+
+		(actid, real_name) = decompose_service_name(name)
+		self._name = real_name
+		self._full_name = name
+		self._stype = stype
+		self._domain = domain
+		self._port = -1
+		self.set_port(port)
+		self._properties = {}
+		self._internal_set_properties(properties, first_time=True)
+		self._avahi_entry_group = None
+		self._local = local
+
+		# Source address is the unicast source IP
+		self._source_address = None
+		if source_address is not None:
+			self.set_source_address(source_address)
+
+		# Address is the published address, could be multicast or unicast
+		self._address = None
+		if self._properties.has_key('address'):
+			self.set_address(self._properties['address'])
+		elif address is not None:
+			self.set_address(address)
+			self._properties['address'] = address
+
+		# Ensure that an ActivityID tag, if given, matches
+		# what we expect from the service type
+		if self._properties.has_key(_ACTIVITY_ID_TAG):
+			prop_actid = self._properties[_ACTIVITY_ID_TAG]
+			if (prop_actid and not actid) or (prop_actid != actid):
+				raise ValueError("ActivityID property specified, but the " \
+						"service names's activity ID didn't match it: %s," \
+						" %s" % (prop_actid, actid))
+		self._activity_id = actid
+		if actid and not self._properties.has_key(_ACTIVITY_ID_TAG):
+			self._properties[_ACTIVITY_ID_TAG] = actid
+
+		self._owner = None
+
+		# ID of the D-Bus connection that published this service, if any.
+		# We only let the local publisher modify the service.
+		self._local_publisher = local_publisher
+
+		# register ourselves with dbus
+		self._object_id = object_id
+		self._object_path = SERVICE_DBUS_OBJECT_PATH + str(self._object_id)
+		self._dbus_helper = ServiceDBusHelper(self, bus_name, self._object_path)
+
+	def object_path(self):
+		return dbus.ObjectPath(self._object_path)
+
+	def get_owner(self):
+		return self._owner
+
+	def set_owner(self, owner):
+		if self._owner is not None:
+			raise RuntimeError("Can only set a service's owner once")
+		self._owner = owner
+
+	def get_local_publisher(self):
+		return self._local_publisher
+
+	def is_local(self):
+		return self._local
+
+	def get_name(self):
+		"""Return the service's name, usually that of the
+		buddy who provides it."""
+		return self._name
+
+	def get_full_name(self):
+		return self._full_name
+
+	def get_one_property(self, key):
+		"""Return one property of the service, or None
+		if the property was not found.  Cannot distinguish
+		between lack of a property, and a property value that
+		actually is None."""
+		if key in self._properties.keys():
+			return self._properties[key]
+		return None
+
+	def get_properties(self):
+		"""Return a python dictionary of all the service's
+		properties."""
+		return self._properties
+
+	def set_property(self, key, value, sender=None):
+		"""Set one service property"""
+		if sender is not None and self._local_publisher != sender:
+			raise ValueError("Service was not not registered by requesting process!")
+
+		if type(key) != type(u""):
+			raise ValueError("Key must be a unicode string.")
+		if type(value) != type(u"") or type(value) != type(True):
+			raise ValueError("Key must be a unicode string or a boolean.")
+
+		# Ignore setting the key to it's current value
+		if self._properties.has_key(key):
+			if self._properties[key] == value:
+				return
+
+		# Blank value means remove key
+		remove = False
+		if type(value) == type(u"") and len(value) == 0:
+			remove = True
+		if type(value) == type(False) and value == False:
+			remove = True
+
+		if remove:
+			# If the key wasn't present, return without error
+			if self._properties.has_key(key):
+				del self._properties[key]
+		else:
+			# Otherwise set it
+			if type(value) == type(True):
+				value = ""
+			self._properties[key] = value
+		self._dbus_helper.PublishedValueChanged(key)
+
+	def set_properties(self, properties, sender=None):
+		"""Set all service properties in one call"""
+		if sender is not None and self._local_publisher != sender:
+			raise ValueError("Service was not not registered by requesting process!")
+		self._internal_set_properties(properties)
+
+	def _internal_set_properties(self, properties, first_time=False):
+		"""Set the service's properties from either an Avahi
+		TXT record (a list of lists of integers), or a
+		python dictionary."""
+		if type(properties) != type({}):
+			raise ValueError("Properties must be a dictionary.")
+		self._properties = {}
+
+		# Set key/value pairs on internal property list
+		for key, value in properties.items():
+			if len(key) == 0:
+				continue
+			tmp_key = key
+			tmp_val = value
+			if type(tmp_key) != type(u""):
+				tmp_key = unicode(tmp_key)
+			if type(tmp_val) != type(u""):
+				tmp_val = unicode(tmp_val)
+			self._properties[tmp_key] = tmp_val
+
+		if not first_time:
+			self._dbus_helper.PublishedValueChanged(self._properties.keys())
+
+	def get_type(self):
+		"""Return the service's service type."""
+		return self._stype
+
+	def get_activity_id(self):
+		"""Return the activity ID this service is associated with, if any."""
+		return self._activity_id
+
+	def get_port(self):
+		return self._port
+
+	def set_port(self, port):
+		if type(port) != type(1) or (port <= 1024 and port > 65536):
+			raise ValueError("must specify a valid port number between 1024 and 65536.")
+		self._port = port
+
+	def get_source_address(self):
+		return self._source_address
+
+	def set_source_address(self, address):
+		if not address or type(address) != type(u""):
+			raise ValueError("address must be unicode")
+		self._source_address = address
+
+	def get_address(self):
+		return self._address
+
+	def set_address(self, address):
+		if not address or type(address) != type(u""):
+			raise ValueError("address must be a unicode string")
+		self._address = address
+		self._properties['address'] = address
+
+	def get_domain(self):
+		"""Return the ZeroConf/mDNS domain the service was found in."""
+		return self._domain
+
+	def set_avahi_entry_group(self, group):
+		self._avahi_entry_group = group
+
+	def get_avahi_entry_group(self):
+		return self._avahi_entry_group
+
+#################################################################
+# Tests
+#################################################################
+
+import unittest
+
+__objid_seq = 0
+def _next_objid():
+	global __objid_seq
+	__objid_seq = __objid_seq + 1
+	return __objid_seq
+
+
+class ServiceTestCase(unittest.TestCase):
+	_DEF_NAME = u"foobar"
+	_DEF_STYPE = u"_foo._bar._tcp"
+	_DEF_DOMAIN = u"local"
+	_DEF_ADDRESS = u"1.1.1.1"
+	_DEF_PORT = 1234
+	_DEF_PROPS = {'foobar': 'baz'}
+	_STR_TEST_ARGS = [None, 0, [], {}]
+
+	def __init__(self, name):
+		self._bus = dbus.SessionBus()
+		self._bus_name = dbus.service.BusName('org.laptop.Presence', bus=self._bus)		
+		unittest.TestCase.__init__(self, name)
+
+	def __del__(self):
+		del self._bus_name
+		del self._bus
+
+	def _test_init_fail(self, name, stype, domain, address, port, properties, fail_msg):
+		"""Test something we expect to fail."""
+		try:
+			objid = _next_objid()
+			service = Service(self._bus_name, objid, name, stype, domain, address,
+					port, properties)
+		except ValueError, exc:
+			pass
+		else:
+			self.fail("expected a ValueError for %s." % fail_msg)
+
+	def testName(self):
+		for item in self._STR_TEST_ARGS:
+			self._test_init_fail(item, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+					self._DEF_PORT, self._DEF_PROPS, "invalid name")
+
+	def testType(self):
+		for item in self._STR_TEST_ARGS:
+			self._test_init_fail(self._DEF_NAME, item, self._DEF_DOMAIN, self._DEF_ADDRESS,
+					self._DEF_PORT, self._DEF_PROPS, "invalid service type")
+		self._test_init_fail(self._DEF_NAME, u"_bork._foobar", self._DEF_DOMAIN, self._DEF_ADDRESS,
+				self._DEF_PORT, self._DEF_PROPS, "invalid service type")
+
+	def testDomain(self):
+		for item in self._STR_TEST_ARGS:
+			self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, item, self._DEF_ADDRESS,
+					self._DEF_PORT, self._DEF_PROPS, "invalid domain")
+		# Only accept local for now
+		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, u"foobar", self._DEF_ADDRESS,
+				self._DEF_PORT, self._DEF_PROPS, "invalid domain")
+		# Make sure "" works
+		objid = _next_objid()
+		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, u"",
+				self._DEF_ADDRESS, self._DEF_PORT, self._DEF_PROPS)
+		assert service, "Empty domain was not accepted!"
+
+	def testAddress(self):
+		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, [],
+				self._DEF_PORT, self._DEF_PROPS, "invalid address")
+		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, {},
+				self._DEF_PORT, self._DEF_PROPS, "invalid address")
+		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, 1234,
+				self._DEF_PORT, self._DEF_PROPS, "invalid address")
+
+	def testPort(self):
+		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+				[], self._DEF_PROPS, "invalid port")
+		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+				{}, self._DEF_PROPS, "invalid port")
+		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+				"adf", self._DEF_PROPS, "invalid port")
+
+	def testGoodInit(self):
+		objid = _next_objid()
+		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
+				self._DEF_ADDRESS, self._DEF_PORT, self._DEF_PROPS)
+		assert service.get_name() == self._DEF_NAME, "service name wasn't correct after init."
+		assert service.get_type() == self._DEF_STYPE, "service type wasn't correct after init."
+		assert service.get_domain() == "local", "service domain wasn't correct after init."
+		assert service.get_address() == self._DEF_ADDRESS, "service address wasn't correct after init."
+		assert service.get_port() == self._DEF_PORT, "service port wasn't correct after init."
+		assert service.object_path() == SERVICE_DBUS_OBJECT_PATH + str(objid)
+		value = service.get_one_property('foobar')
+		assert value and value == 'baz', "service property wasn't correct after init."
+
+	def testAvahiProperties(self):
+		props = [[111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 65, 118, 97, 104, 105, 46, 99, 111, 111, 107, 105, 101, 61, 50, 54, 48, 49, 53, 52, 51, 57, 53, 50]]
+		key = "org.freedesktop.Avahi.cookie"
+		expected_value = "2601543952"
+		objid = _next_objid()
+		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
+				self._DEF_ADDRESS, self._DEF_PORT, props)
+		value = service.get_one_property(key)
+		assert value and value == expected_value, "service properties weren't correct after init."
+		value = service.get_one_property('bork')
+		assert not value, "service properties weren't correct after init."
+
+	def testBoolProperty(self):
+		props = [[111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 65, 118, 97, 104, 105, 46, 99, 111, 111, 107, 105, 101]]
+		key = "org.freedesktop.Avahi.cookie"
+		expected_value = True
+		objid = _next_objid()
+		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+				self._DEF_PORT, props)
+		value = service.get_one_property(key)
+		assert value is not None and value == expected_value, "service properties weren't correct after init."
+
+	def testActivityService(self):
+		# Valid group service type, non-multicast address
+		actid = "4569a71b80805aa96a847f7ac1c407327b3ec2b4"
+		name = compose_service_name("Tommy", actid)
+
+		# Valid activity service name, None address
+		objid = _next_objid()
+		service = Service(self._bus_name, objid, name, self._DEF_STYPE, self._DEF_DOMAIN, None,
+				self._DEF_PORT, self._DEF_PROPS)
+		assert service.get_address() == None, "address was not None as expected!"
+		assert service.get_activity_id() == actid, "activity id was different than expected!"
+
+		# Valid activity service name and multicast address, ensure it works
+		mc_addr = u"224.0.0.34"
+		objid = _next_objid()
+		service = Service(self._bus_name, objid, name, self._DEF_STYPE, self._DEF_DOMAIN, mc_addr,
+				self._DEF_PORT, self._DEF_PROPS)
+		assert service.get_address() == mc_addr, "address was not expected address!"
+
+	def addToSuite(suite):
+		suite.addTest(ServiceTestCase("testName"))
+		suite.addTest(ServiceTestCase("testType"))
+		suite.addTest(ServiceTestCase("testDomain"))
+		suite.addTest(ServiceTestCase("testAddress"))
+		suite.addTest(ServiceTestCase("testPort"))
+		suite.addTest(ServiceTestCase("testGoodInit"))
+		suite.addTest(ServiceTestCase("testAvahiProperties"))
+		suite.addTest(ServiceTestCase("testBoolProperty"))
+		suite.addTest(ServiceTestCase("testActivityService"))
+	addToSuite = staticmethod(addToSuite)
+
+
+def main():
+	suite = unittest.TestSuite()
+	ServiceTestCase.addToSuite(suite)
+	runner = unittest.TextTestRunner()
+	runner.run(suite)
+
+if __name__ == "__main__":
+	main()

services/presence/org.laptop.Presence.service.in

@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name = org.laptop.Presence
+Exec = @bindir@/sugar-presence-service
+

services/presence/sugar-presence-service

@@ -0,0 +1,11 @@
+#!/usr/bin/python
+
+import logging
+from presence import PresenceService
+import sugar.logger
+
+sugar.logger.start('PresenceService')
+
+logging.info('Starting presence service')
+
+PresenceService.main()