Switch from Groups to grouping services based on activity UID
This commit is contained in:
Dan Williams
parent
55f538253c
commit
1cdaf97f20
@ -1,61 +0,0 @@
|
||||
import Service
|
||||
|
||||
import sugar.util
|
||||
|
||||
def is_group_service_type(stype):
|
||||
"""Return True if the service type matches a group
|
||||
service type, or False if it does not."""
|
||||
if stype.endswith("_group_olpc._tcp") or stype.endswith("_group_olpc._udp"):
|
||||
return True
|
||||
return False
|
||||
|
||||
__GROUP_NAME_TAG = "Name"
|
||||
__GROUP_RESOURCE_TAG = "Resource"
|
||||
|
||||
def new_group_service(group_name, resource):
|
||||
"""Create a new service suitable for defining a new group."""
|
||||
if type(group_name) != type("") or not len(group_name):
|
||||
raise ValueError("group name must be a valid string.")
|
||||
if type(resource) != type("") or not len(resource):
|
||||
raise ValueError("group resource must be a valid string.")
|
||||
|
||||
# Create a randomized service type
|
||||
data = "%s%s" % (group_name, resource)
|
||||
stype = "_%s_group_olpc._udp" % sugar.util.unique_id(data)
|
||||
|
||||
properties = {__GROUP_NAME_TAG: group_name, __GROUP_RESOURCE_TAG: resource }
|
||||
owner_nick = ""
|
||||
port = random.randint(5000, 65000)
|
||||
# Use random currently unassigned multicast address
|
||||
address = "232.%d.%d.%d" % (random.randint(0, 254), random.randint(1, 254),
|
||||
random.randint(1, 254))
|
||||
service = Service.Service(owner_nick, stype, "local", address=address,
|
||||
port=port, properties=properties)
|
||||
return service
|
||||
|
||||
|
||||
class Group(object):
|
||||
"""Represents a collection of buddies all interested in the same resource."""
|
||||
def __init__(self, service):
|
||||
if not isinstance(service, Service.Service):
|
||||
raise ValueError("service argument was not a Service object.")
|
||||
if not service.is_group_service():
|
||||
raise ValueError("provided serivce was not a group service.")
|
||||
name = service.get_one_property(__GROUP_NAME_TAG)
|
||||
if name == None:
|
||||
raise ValueError("provided service did not provide a group name.")
|
||||
self._name = name
|
||||
resource = service.get_one_property(__GROUP_RESOURCE_TAG)
|
||||
if resource == None:
|
||||
raise ValueError("provided service did not provide a group resource.")
|
||||
self._resource = resource
|
||||
self._service = service
|
||||
|
||||
def get_name(self):
|
||||
return self._name
|
||||
|
||||
def get_service(self):
|
||||
return self._service
|
||||
|
||||
def get_resource(self):
|
||||
return self._resource
|
||||
@ -2,9 +2,9 @@ import threading
|
||||
import avahi, dbus, dbus.glib, dbus.dbus_bindings, gobject
|
||||
import Buddy
|
||||
import Service
|
||||
import Group
|
||||
import os
|
||||
|
||||
import string
|
||||
from sugar import util
|
||||
|
||||
def _get_local_ip_address(ifname):
|
||||
"""Call Linux specific bits to retrieve our own IP address."""
|
||||
@ -97,8 +97,8 @@ class PresenceService(gobject.GObject):
|
||||
# Our owner object
|
||||
self._owner = None
|
||||
|
||||
# group UID -> Group: groups we've found
|
||||
self._groups = {}
|
||||
# activity UID -> Service: services grouped by activity UID
|
||||
self._activity_services = {}
|
||||
|
||||
# All the mdns service types we care about
|
||||
self._allowed_service_types = []
|
||||
@ -110,7 +110,7 @@ class PresenceService(gobject.GObject):
|
||||
# Resolved service list
|
||||
self._service_advs = []
|
||||
|
||||
# Main activity UID to filter on
|
||||
# Main activity UID to filter services on
|
||||
self._activity_uid = None
|
||||
|
||||
self._bus = dbus.SystemBus()
|
||||
@ -126,8 +126,8 @@ class PresenceService(gobject.GObject):
|
||||
self._started = True
|
||||
self._lock.release()
|
||||
|
||||
if activity_uid and (not type(activity_uid) == type("") or not len(activity_uid)):
|
||||
raise ValueError("activity uid must be a string.")
|
||||
if activity_uid and not util.validate_activity_uid(activity_uid):
|
||||
raise ValueError("activity uid must be a valid UID string.")
|
||||
self._activity_uid = activity_uid
|
||||
|
||||
# Always browse .local
|
||||
@ -177,8 +177,6 @@ class PresenceService(gobject.GObject):
|
||||
type, and False if it's not."""
|
||||
if stype == Buddy.PRESENCE_SERVICE_TYPE:
|
||||
return True
|
||||
if Group.is_group_service_type(stype):
|
||||
return True
|
||||
return False
|
||||
|
||||
def _handle_new_service_for_buddy(self, service):
|
||||
@ -204,12 +202,24 @@ class PresenceService(gobject.GObject):
|
||||
self.emit("buddy-appeared", buddy)
|
||||
return buddy
|
||||
|
||||
def _handle_new_service_for_group(self, service, buddy):
|
||||
def _handle_new_service_for_activity(self, service, buddy):
|
||||
# If the serivce is a group service, merge it into our groups list
|
||||
group = None
|
||||
if not self._groups.has_key(service.get_type()):
|
||||
group = Group.Group(service)
|
||||
self._groups[service.get_type()] = group
|
||||
uid = service.get_activity_uid()
|
||||
if not uid:
|
||||
uid = "*"
|
||||
if not self._activity_services.has_key(uid):
|
||||
self._activity_services[uid] = []
|
||||
self._activity_services[uid].append((buddy, service))
|
||||
|
||||
def _handle_remove_service_for_activity(self, service, buddy):
|
||||
uid = service.get_activity_uid()
|
||||
if not uid:
|
||||
uid = "*"
|
||||
if self._activity_services.has_key(uid):
|
||||
try:
|
||||
self._activity_services.remove((buddy, service))
|
||||
except:
|
||||
pass
|
||||
|
||||
def _resolve_service_reply_cb(self, interface, protocol, name, stype, domain, host, aprotocol, address, port, txt, flags):
|
||||
"""When the service discovery finally gets here, we've got enough information about the
|
||||
@ -226,13 +236,14 @@ class PresenceService(gobject.GObject):
|
||||
adv.set_resolved(True)
|
||||
|
||||
# Update the service now that it's been resolved
|
||||
service = Service.Service(name, stype, domain, address, port, txt)
|
||||
service = Service.Service(name=name, stype=stype, domain=domain,
|
||||
address=address, port=port, properties=txt)
|
||||
adv.set_service(service)
|
||||
|
||||
# Merge the service into our buddy and group lists, if needed
|
||||
buddy = self._handle_new_service_for_buddy(service)
|
||||
if buddy and service.is_group_service():
|
||||
self._handle_new_service_for_group(service, buddy)
|
||||
if buddy and service.get_activity_uid():
|
||||
self._handle_new_service_for_activity(service, buddy)
|
||||
|
||||
return False
|
||||
|
||||
@ -268,8 +279,19 @@ class PresenceService(gobject.GObject):
|
||||
if addr:
|
||||
self._local_addrs[interface] = addr
|
||||
|
||||
# Decompose service type if we can
|
||||
(uid, stype) = Service._decompose_service_type(stype)
|
||||
|
||||
# If we care about the service right now, resolve it
|
||||
if stype in self._allowed_service_types or self._is_special_service_type(stype):
|
||||
resolve = False
|
||||
if self._activity_uid and self._activity_uid == uid:
|
||||
if stype in self._allowed_service_types:
|
||||
resolve = True
|
||||
elif not self._activity_uid:
|
||||
resolve = True
|
||||
if self._is_special_service_type(stype):
|
||||
resolve = True
|
||||
if resolve:
|
||||
gobject.idle_add(self._resolve_service, interface, protocol, name, stype, domain, flags)
|
||||
return False
|
||||
|
||||
@ -284,20 +306,23 @@ class PresenceService(gobject.GObject):
|
||||
if not adv_list:
|
||||
return False
|
||||
|
||||
# Unresolved services by definition aren't assigned to a buddy
|
||||
try:
|
||||
# Remove the service from the buddy
|
||||
buddy = self._buddies[name]
|
||||
# FIXME: need to be more careful about how we remove services
|
||||
# from buddies; this could be spoofed
|
||||
# Get the service object; if none, we have nothing left to do
|
||||
adv = adv_list[0]
|
||||
service = adv.get_service()
|
||||
service = adv.service()
|
||||
if not service:
|
||||
return False
|
||||
|
||||
# Remove the service from the buddy
|
||||
try:
|
||||
buddy = self._buddies[name]
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
buddy.remove_service(service)
|
||||
if not buddy.is_valid():
|
||||
self.emit("buddy-disappeared", buddy)
|
||||
del self._buddies[name]
|
||||
except KeyError:
|
||||
pass
|
||||
self._handle_remove_service_for_activity(service, buddy)
|
||||
|
||||
return False
|
||||
|
||||
|
||||
@ -1,5 +1,28 @@
|
||||
import avahi
|
||||
import Group
|
||||
from sugar import util
|
||||
import string
|
||||
|
||||
def new_group_service(group_name, resource):
|
||||
"""Create a new service suitable for defining a new group."""
|
||||
if type(group_name) != type("") or not len(group_name):
|
||||
raise ValueError("group name must be a valid string.")
|
||||
if type(resource) != type("") or not len(resource):
|
||||
raise ValueError("group resource must be a valid string.")
|
||||
|
||||
# Create a randomized service type
|
||||
data = "%s%s" % (group_name, resource)
|
||||
stype = "_%s_group_olpc._udp" % sugar.util.unique_id(data)
|
||||
|
||||
properties = {__GROUP_NAME_TAG: group_name, __GROUP_RESOURCE_TAG: resource }
|
||||
owner_nick = ""
|
||||
port = random.randint(5000, 65000)
|
||||
# Use random currently unassigned multicast address
|
||||
address = "232.%d.%d.%d" % (random.randint(0, 254), random.randint(1, 254),
|
||||
random.randint(1, 254))
|
||||
service = Service.Service(owner_nick, stype, "local", address=address,
|
||||
port=port, properties=properties)
|
||||
return service
|
||||
|
||||
|
||||
def _txt_to_dict(txt):
|
||||
"""Convert an avahi-returned TXT record formatted
|
||||
@ -18,6 +41,21 @@ def _txt_to_dict(txt):
|
||||
prop_dict[key] = value
|
||||
return prop_dict
|
||||
|
||||
def _decompose_service_type(stype):
|
||||
"""Break a service type into the UID and real service type, if we can."""
|
||||
if len(stype) < util.ACTIVITY_UID_LEN + 5:
|
||||
return (None, stype)
|
||||
if stype[0] != "_":
|
||||
return (None, stype)
|
||||
start = 1
|
||||
end = start + util.ACTIVITY_UID_LEN
|
||||
if stype[end] != "_":
|
||||
return (None, stype)
|
||||
uid = stype[start:end]
|
||||
if not util.validate_activity_uid(uid):
|
||||
return (None, stype)
|
||||
return (uid, stype[end:])
|
||||
|
||||
def is_multicast_address(address):
|
||||
"""Simple numerical check for whether an IP4 address
|
||||
is in the range for multicast addresses or not."""
|
||||
@ -31,12 +69,10 @@ def is_multicast_address(address):
|
||||
return False
|
||||
|
||||
|
||||
__GROUP_UID_TAG = "GroupUID"
|
||||
|
||||
class Service(object):
|
||||
"""Encapsulates information about a specific ZeroConf/mDNS
|
||||
service as advertised on the network."""
|
||||
def __init__(self, name, stype, domain, address=None, port=-1, properties=None, group=None):
|
||||
def __init__(self, name, stype, domain, address=None, port=-1, properties=None):
|
||||
# Validate immutable options
|
||||
if not name or (type(name) != type("") and type(name) != type(u"")) or not len(name):
|
||||
raise ValueError("must specify a valid service name.")
|
||||
@ -51,15 +87,13 @@ class Service(object):
|
||||
if len(domain) and domain != "local" and domain != u"local":
|
||||
raise ValueError("must use the 'local' domain (for now).")
|
||||
|
||||
# Group services must have multicast addresses
|
||||
if Group.is_group_service_type(stype) and address and not is_multicast_address(address):
|
||||
raise ValueError("group service type specified, but address was not multicast.")
|
||||
|
||||
if group and not isinstance(group, Group.Group):
|
||||
raise ValueError("group was not a valid group object.")
|
||||
(uid, real_stype) = _decompose_service_type(stype)
|
||||
if uid and not util.validate_activity_uid(activity_uid):
|
||||
raise ValueError("activity_uid not a valid activity UID.")
|
||||
|
||||
self._name = name
|
||||
self._stype = stype
|
||||
self._real_stype = real_stype
|
||||
self._domain = domain
|
||||
self._address = None
|
||||
self.set_address(address)
|
||||
@ -67,9 +101,7 @@ class Service(object):
|
||||
self.set_port(port)
|
||||
self._properties = {}
|
||||
self.set_properties(properties)
|
||||
self._group = group
|
||||
if group:
|
||||
self._properties[__GROUP_UID_TAG] = group.get_uid()
|
||||
self._activity_uid = uid
|
||||
|
||||
def get_name(self):
|
||||
"""Return the service's name, usually that of the
|
||||
@ -81,11 +113,6 @@ class Service(object):
|
||||
False if it is not."""
|
||||
return is_multicast_address(self._address)
|
||||
|
||||
def is_group_service(self):
|
||||
"""Return True if the service represents a Group,
|
||||
False if it does not."""
|
||||
return Group.is_group_service_type(self._stype)
|
||||
|
||||
def get_one_property(self, key):
|
||||
"""Return one property of the service, or None
|
||||
if the property was not found. Cannot distinguish
|
||||
@ -131,17 +158,15 @@ class Service(object):
|
||||
raise ValueError("must specify a valid address.")
|
||||
if not len(address):
|
||||
raise ValueError("must specify a valid address.")
|
||||
if Group.is_group_service_type(self._stype) and not is_multicast_address(address):
|
||||
raise ValueError("group service type specified, but address was not multicast.")
|
||||
self._address = address
|
||||
|
||||
def get_domain(self):
|
||||
"""Return the ZeroConf/mDNS domain the service was found in."""
|
||||
return self._domain
|
||||
|
||||
def get_group(self):
|
||||
"""Return the group this service is associated with, if any."""
|
||||
return self._group
|
||||
def get_activity_uid(self):
|
||||
"""Return the activity UID this service is associated with, if any."""
|
||||
return self._activity_uid
|
||||
|
||||
|
||||
#################################################################
|
||||
|
||||
@ -19,3 +19,20 @@ def _sha_data(data):
|
||||
def unique_id(data = ''):
|
||||
data_string = "%s%s%s" % (time.time(), random.randint(10000, 100000), data)
|
||||
return _stringify_sha(_sha_data(data_string))
|
||||
|
||||
|
||||
ACTIVITY_UID_LEN = 40
|
||||
|
||||
def is_hex(s):
|
||||
return s.strip(string.hexdigits) == ''
|
||||
|
||||
def validate_activity_uid(uid):
|
||||
"""Validate an activity UID."""
|
||||
if type(uid) != type(""):
|
||||
return False
|
||||
if len(uid) != ACTIVITY_UID_LEN:
|
||||
return False
|
||||
if not is_hex(uid):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user