Thread: [Virtplayground-svn] SF.net SVN: virtplayground:[306] trunk/server/core

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 306
          http://virtplayground.svn.sourceforge.net/virtplayground/?rev=306&view=rev
Author:   BlueWolf_
Date:     2009-10-24 18:56:45 +0000 (Sat, 24 Oct 2009)

Log Message:
-----------
* Will now uses the defaults in the config
* Send will not crash when the connection is dead
* connection_close renamed to connection_closed
* Some changes in the callback

Modified Paths:
--------------
    trunk/server/core/__init__.py
    trunk/server/core/callback.py
    trunk/server/core/server.py

Modified: trunk/server/core/__init__.py
===================================================================

--- trunk/server/core/__init__.py	2009-10-21 22:34:25 UTC (rev 305)
+++ trunk/server/core/__init__.py	2009-10-24 18:56:45 UTC (rev 306)
@@ -1,3 +1,7 @@
+"""
+This is the server core for Virtual Playground.
+You can use this by importing Server and Callback
+"""
 ## This file is part of Virtual Playground
 ## Copyright (c) 2009 Jos Ratsma + Koen Koning
 
@@ -19,3 +23,4 @@
 Server = server.Server
 Callback = callback.Callback
 
+__all__ = ['Server', 'Callback']

Modified: trunk/server/core/callback.py
===================================================================
--- trunk/server/core/callback.py	2009-10-21 22:34:25 UTC (rev 305)
+++ trunk/server/core/callback.py	2009-10-24 18:56:45 UTC (rev 306)
@@ -16,40 +16,54 @@
 ## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
 class Callback:
-	def server_online(self, clients):
+	def server_online(self):
 		"""
-		server_online(self, clients)
 		Called when the server is online and ready to accept incoming
 		connections. This means it has successfully bounded itself to a
 		port. Most of the times this will be called immediately after
 		calling Server.start()
 		
-		This is a placeholder.
-		If you want to catch this event, overwrite it.
+		
+		This is placeholder. If you want to catch this event,
+		overwrite this in your own callback.
 		"""
 		pass
 		
 	def connection_opened(self, uid, client, host, port):
 		"""
-		connection_opened(self, uid, client, host, port)
-		Called when a new client connects, and we accepted the
+		Called when a new client connects and we accepted the
 		connection. You can, however, still kill the connection by
 		returning True in this function.
 		
-		This is a placeholder.
-		If you want to catch this event, overwrite it.
+		uid:
+			The unique ID for this connection. This is usually
+			'ip:port'.
+		client:
+			The client class. Normally, you don't need this.
+		host:
+			The IP adress for this user
+		port:
+			The current port this connection uses.
+		
+		
+		This is placeholder. If you want to catch this event,
+		overwrite this in your own callback.
 		"""
 		pass
 	
 	def connection_closed(self, uid):
 		"""
-		connection_closed(self, uid)
 		Called when a connection with a client is closed. This can be
 		when they closed their connection themselves, or when we
 		disconnect someone.
 		
-		This is a placeholder.
-		If you want to catch this event, overwrite it.
+		uid:
+			The unique ID for this connection. This is usually
+			'ip:port'.
+		
+		
+		This is placeholder. If you want to catch this event,
+		overwrite this in your own callback.
 		"""
 		#TODO: Reason?
 		pass
@@ -57,34 +71,53 @@
 	def connection_limit_exceeded(self, ip, current_connections,
 							max_connections):
 		"""
-		connection_limit_exceeded(self, ip, current_connections,
-								max_connections)
 		Called when a new client connects, but the maximum number of
 		connections is exceeded. You can, however, still accept the
 		connection by returning True in this function.
 		
-		This is a placeholder.
-		If you want to catch this event, overwrite it.
+		ip:
+			The IP-adress for this connection
+		current_connections:
+			Amount of current open connections
+		max_connections:
+			This is the same as in the config
+			'max_connections'.
+				
+		
+		This is placeholder. If you want to catch this event,
+		overwrite this in your own callback.
 		"""
 		pass
 	
 	def data_received(self, uid, data):
 		"""
-		data_received(self, uid, data)
 		Called when the server received data from one of the clients.
+		Normally, you don't need this.
 		
-		This is a placeholder.
-		If you want to catch this event, overwrite it.
+		uid:
+			The unique ID for this connection. This is usually
+			'ip:port'.
+		
+		
+		This is placeholder. If you want to catch this event,
+		overwrite this in your own callback.
 		"""
 		pass
 		
 	def data_send(self, uid, data):
 		"""
-		data_send(self, uid, data)
 		Called when the server send data to one of the clients.
+		Normally, you don't need this.
 		
-		This is a placeholder.
-		If you want to catch this event, overwrite it.
+		uid:
+			The unique ID for this connection. This is usually
+			'ip:port'.
+		data:
+			Dict with the data that will be send.
+		
+		
+		This is placeholder. If you want to catch this event,
+		overwrite this in your own callback.
 		"""
 		pass
 

Modified: trunk/server/core/server.py
===================================================================
--- trunk/server/core/server.py	2009-10-21 22:34:25 UTC (rev 305)
+++ trunk/server/core/server.py	2009-10-24 18:56:45 UTC (rev 306)
@@ -19,46 +19,76 @@
 from parser import Parser
 
 class Server(threading.Thread):
-	def __init__(self, config, callback_class):
-		"""
-		Will handle all connections from clients. It has one main
-		socket, and creates all (client)sockets.
+	"""
+	This is the server-core for Virtual Playground. This will handle all
+	connections from clients. It has one main socket, and it will create
+	all (client)sockets.
+	
+	
+	config: 
+		This should be a dict with settings for the server. See the
+		bottom of this documentation for a list of all possible
+		settings.
 		
+	callback_class:
+		The callback class will be used to notify you for certain events
+		that happens in the core. It has to look something like this:
 		
-		Config: (maybe this explanation should be moved? maybe provide
-			 example config with the core? maybe this function
-			 should check the given config for error, raise
-			 exceptions, and fill in standard values for some
-			 missing keys)
-		Should be dict with settings for the server. Below a list of all
-		posible keys and an explanation.
+		class Callback(core.Callback):
+			...
 		
-		-host:	Host to which the server binds itself(am i saying this
-			correctly?) standard value is '', an empty string, which
-			means everyone can connect to the server.
-		-port: 	Port the server should listen on. Should be int, and can
-			be anything.
-		-max_connections: Maximum ammount of clients that can be
-			connected simultaneously. If this number is exceeded,
-			the client will dropped, unless specified otherwise (see
-			callback `connection_limit_exceeded`). Should be int. If
-			this value is either None or 0, there will be no limit.
-		"""
+		See the doc in core.Callback for more information about this.
+	
+	--------
+	
+	The settings:
+		-host:
+			Host to which the server binds itself. The default is an
+			empty string, an empty string, which means everyone can
+			connect to the server.
 		
+		-port:
+			The port the server should listen on. Should be int
+			between 1 and 65535. Note that everything lower than 100
+			usually needs to be run as root under Unix/Linux.
+			Default is 5162.
+		
+		-max_connections:
+			Maximum amount of clients that can be connected
+			simultaneously. If this number is exceeded, the new
+			connection will dropped, unless specified otherwise
+			(see callback `connection_limit_exceeded`). Should be
+			int. If	this value is either None or 0, there will be no
+			limit. Default is 0. But it is wise to specify a limit.
+	"""
+	
+	
+	def __init__(self, config, callback_class):
 		self.__sock = None
-		self.__call = callback_class()
+		self.__call = callback_class
+		
+		# Create all default settings
+		self.__config_default(config) 
 		self.__config = config
-		self.__clients = {}
-		self.__parse = Parser(self.__call, self.__clients)
 		
+		self.clients = {}
+		self.__parse = Parser(self.__call, self.clients)
+		
 		threading.Thread.__init__(self)
+	
+	def __config_default(self, config):
+		"""
+		Create all the config-defaults
+		"""
+		config.setdefault('host', '')
+		config.setdefault('port', 5162)
+		config.setdefault('max_connections', 0)
 		
+	
 	def start_server(self):
 		"""
-		start_server() => None
-		
-		This will start the server. It will listen on the port
-		specified in the config.
+		This will start the server. It will listen on the port specified
+		in the config.
 		"""
 		
 		#Isn't the server running already?
@@ -90,19 +120,19 @@
 				time.sleep(1)
 
 		self.__sock.listen(20)
-		self.__call.server_online(self.__clients)
+		self.__call.server_online(self.clients)
 		
 		#Infinite loop that will wait for incomming connections
 		while 1:
 			sock, addr = self.__sock.accept()
 			
-			if self.__config['max_connections'] != None and \
-				len(self.__clients) >=  \
+			if self.__config['max_connections'] and \
+				len(self.clients) >=  \
 					self.__config['max_connections']:
 				#We exceeded our connection limit, but maybe
 				#this is a special occasion? Send callback!
 				if not self.__call.connection_limit_exceeded(
-					addr[0], len(self.__clients),
+					addr[0], len(self.clients),
 					self.__config['max_connections']):
 					
 					#We're full, kick him out
@@ -111,24 +141,25 @@
 					continue
 			
 			uid = addr[0] + ':' + str(addr[1])
-			self.__clients[uid] = Client(uid, sock, self.__clients, 
+			self.clients[uid] = Client(uid, sock, self.clients, 
 						self.__call, self.__parse)
-			self.__clients[uid].start()
+			self.clients[uid].start()
 			
 			if self.__call.connection_opened(uid,
-						self.__clients[uid], *addr):
+						self.clients[uid], *addr):
 				#User returned True -> drop user
 				time.sleep(0.1) #Let the `run` start
-				self.__clients[uid].close()
+				self.clients[uid].close()
 			
 		
 		
 class Client(threading.Thread):
+	"""
+	This class manages the socket for the connection to clients. 
+	Each client has it's own class.
+	"""
+	
 	def __init__(self, uid, sock, clients, callback, parser):
-		"""
-		This class manages the socket for the connection to clients. 
-		Each client has it's own class.
-		"""
 		
 		self.__uid = uid
 		self.__sock = sock
@@ -176,26 +207,27 @@
 	
 	def close(self):
 		"""
-		close() => None
-		Closes this connection, and kills the socket.
+		Closes the connection for this client and kills the socket.
 		"""
 				
 		self.__sock.close()
 		self.is_online = False
 		
-		self.__call.connection_close(self.__uid)
+		self.__call.connection_closed(self.__uid)
 		
 		del self.__clients[self.__uid]
 		
 	def send(self, data_header, data_body = {}):
 		"""
-		send(data_header, data_body = {}) => None
 		Sends `data_body` of type `data_header` to the client. It will 
 		automatically be encoded as JSON, and the delimeter character 
 		(chr(1)) will be send automatically too.
-		`Data_header` is a string, `data_body` a dict.
+		`data_header` is a string, `data_body` a dict.
 		"""
 		self.__call.data_send(self.__uid, {data_header:data_body})
 		data = simplejson.dumps({data_header:data_body})
-		self.__sock.send(data + chr(1))
+		
+		try:
+			self.__sock.send(data + chr(1))
+		except: pass
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: [Virtplayground-svn] SF.net SVN: virtplayground:[306] trunk/server/core

virtplayground-svn