Merge

sugar/p2p/Buddy.py

@@ -6,18 +6,35 @@ from Service import Service
 PRESENCE_SERVICE_TYPE = "_olpc_presence._tcp"
 PRESENCE_SERVICE_PORT = 6000
 
-class Buddy:
+class BuddyBase:
 	def __init__(self, service, nick_name):
 		self._service = service
 		self._nick_name = nick_name
+
+	def get_icon(self):
+		"""Return the buddies icon, if any."""
+		return self._icon
 		
+	def get_address(self):
+		return self._service.get_address()
+
 	def get_service_name(self):
 		return self._service.get_name()
 		
 	def get_nick_name(self):
 		return self._nick_name
 		
-class Owner(Buddy):
+class Buddy(BuddyBase):
+	"""Normal buddy class."""
+
+	def set_icon(self, icon):
+		"""Can only set icon for other buddies.  The Owner
+		takes care of setting it's own icon."""
+		self._icon = icon
+	
+
+class Owner(BuddyBase):
+	"""Class representing the owner of this machine/instance."""
 	def __init__(self, group):
 		self._group = group
 	
@@ -26,8 +43,18 @@ class Owner(Buddy):
 			nick = "n00b"
 
 		service = Service(nick, PRESENCE_SERVICE_TYPE, PRESENCE_SERVICE_PORT)
+		BuddyBase.__init__(self, service, nick)
+
+		sugar_dir = os.path.abspath(os.path.expanduser("~/.sugar"))
+		icon = None
+		for fname in os.listdir(sugar_dir):
+			if not fname.startswith("buddy-icon."):
+				continue
+			fd = open(os.path.join(sugar_dir, fname), "r")
+			self._icon = fd.read()
+			fd.close()
+			break
 
-		Buddy.__init__(self, service, nick)
 		
 	def register(self):
 		self._service.register(self._group)

sugar/p2p/Group.py

@@ -7,6 +7,8 @@ from Service import Service
 from sugar.p2p.model.Store import Store
 import presence
 
+_OLPC_SERVICE_TYPE_PREFIX = "_olpc"
+
 class Group:
 	SERVICE_ADDED = "service_added"
 	SERVICE_REMOVED = "service_removed"
@@ -78,11 +80,12 @@ class LocalGroup(Group):
 	def get_service(self, name, stype):
 		if self._services.has_key((name, stype)):
 			return self._services[(name, stype)]
-		else:
-			return None
+		return None
 
 	def get_buddy(self, name):
-		return self._buddies[name]
+		if self._buddies.has_key(name):
+			return self._buddies[name]
+		return None
 	
 	def _add_buddy(self, buddy):
 		bid = buddy.get_nick_name()
@@ -104,7 +107,7 @@ class LocalGroup(Group):
 		elif action == presence.ACTION_SERVICE_REMOVED:
 			if stype == PRESENCE_SERVICE_TYPE:
 				self._remove_buddy(name)
-			elif stype.startswith("_olpc"):
+			elif stype.startswith(_OLPC_SERVICE_TYPE_PREFIX):
 				self.remove_service((name, stype))
 						
 	def _on_service_resolved(self, interface, protocol, name, stype, domain,
@@ -119,5 +122,5 @@ class LocalGroup(Group):
 
 		if stype == PRESENCE_SERVICE_TYPE:
 			self._add_buddy(Buddy(service, name))
-		elif stype.startswith("_olpc"):
+		elif stype.startswith(_OLPC_SERVICE_TYPE_PREFIX):
 			self.add_service(service)

sugar/p2p/Stream.py

@@ -1,11 +1,14 @@
 import xmlrpclib
 import socket
+import traceback
 
 import network
 from MostlyReliablePipe import MostlyReliablePipe
 
 class Stream(object):
 	def __init__(self, service, group):
+		if not service:
+			raise ValueError("service must be valid")
 		self._service = service
 		self._group = group
 		self._owner_nick_name = self._group.get_owner().get_nick_name()
@@ -32,6 +35,8 @@ class Stream(object):
 class UnicastStreamWriter(object):
 	def __init__(self, stream, service, owner_nick_name):
 		# set up the writer
+		if not service:
+			raise ValueError("service must be valid")
 		self._service = service
 		self._owner_nick_name = owner_nick_name
 		self._address = self._service.get_address()
@@ -40,6 +45,7 @@ class UnicastStreamWriter(object):
 		self._writer = xmlrpclib.ServerProxy(self._xmlrpc_addr)
 
 	def write(self, data):
+		"""Write some data to the default endpoint of this pipe on the remote server."""
 		try:
 			self._writer.message(self._owner_nick_name, data)
 			return True
@@ -47,6 +53,15 @@ class UnicastStreamWriter(object):
 			traceback.print_exc()
 		return False
 
+	def custom_request(self, method_name, *args):
+		"""Call a custom XML-RPC method on the remote server."""
+		try:
+			method = getattr(self._writer, method_name)
+			return method(*args)
+		except (socket.error, xmlrpclib.Fault, xmlrpclib.ProtocolError):
+			traceback.print_exc()
+		return None
+
 
 class UnicastStream(Stream):
 	def __init__(self, service, group):
@@ -62,18 +77,23 @@ class UnicastStream(Stream):
 		while not started and tries > 0:
 			try:
 				self._reader = network.GlibXMLRPCServer(("", port))
-				self._reader.register_instance(self)
+				self._reader.register_function(self._message, "message")
 				started = True
 			except(socket.error):
 				port = port + 1
 				tries = tries - 1
 		self._service.set_port(port)
 
-	def message(self, nick_name, message):
+	def _message(self, nick_name, message):
 		"""Called by the XMLRPC server when network data arrives."""
 		self.recv(nick_name, message)
 		return True
 
+	def register_handler(self, handler, name):
+		if name == "message":
+			raise ValueError("Handler name 'message' is a reserved handler.")
+		self._reader.register_function(handler, name)
+
 	def new_writer(self, service):
 		return UnicastStreamWriter(self, service, self._owner_nick_name)