python-hserver/hserver/server.py

import socketserver
import traceback
import io
import os.path

import hserver
import hserver.systemplates

import threading
import socket

from hserver.mime import MIME
from hserver.packages import PackageManager
import hserver.manage

import objectbroker
from objectbroker import AquisitionProxy

from simplelog import log

class HServerRequestHandler(socketserver.StreamRequestHandler):
	""

	def handle(self):
		self.__keepalive = False

		log("handle():")

		try:
			self.handle_request()
			while (self.__keepalive):
				self.handle_request()
				
		except:
			log("handle(): Exception:")
			traceback.print_exc()
			
#		self.rfile.close()
#		self.wfile.close()
		self.request.close()
		
		log("handle(): finished.")
		
	def handle_request(self):
		log("handle_request():")
		
		l = self.rfile.readline()
		rline = str(l,"iso-8859-1")
		toks = rline.split()
		log("handle_request: requestline: %s" % (toks,))
		
		if (len(toks)!=3):
			return
		
		method,uri,version = toks
		
		if (not version.startswith("HTTP/")):
			log("handle_request: Version String: %s" % (version,))
			return
			
		#self.rbfile = self.rfile
		#self.rfile = io.TextIOWrapper(self.rbfile, "iso-8859-1")
			
		log("MIMEing...")
			
		mime = MIME(self.rfile, defaultlength=0)
		r = hserver.Request( URI=uri, MIME=mime, method=method, read=self.rfile, client=self.client_address )
		
		try:
			self.server.hserver.handle(r)
		except hserver.FinishRequestException:
			pass
		except hserver.HttpException as ex:
			r.reset()
			r.setResponseHeader("Content-Type","text/html")

			t = self.server.hserver.packagemanager().hcore.Templates.provide("%s.html" % (ex.status,))
			t.run( ex, outfile=r.getContentFile() )
				
		except Exception as ex:
			traceback.print_exception(type(ex),ex,ex.__traceback__)
		
			r.reset()
			r.setResponseHeader("Content-Type","text/html")

			self.templ_exception = hserver.Template(source=hserver.systemplates.tmpl_exception, disable_sandbox=True)
			self.templ_exception.run( ex, globals(), outfile=r.getContentFile() )
				
			print("handle_request(): reply")
			
		log("handle_request(): reply")

			
		r.setResponseHeader("Connection","close")
		
		w = io.TextIOWrapper(self.wfile)
		w.write("%s %s %s\r\n" % (version,r.getStatus(),r.getStatus()))
		
		c = r.getContent()
		
		r.getResponseHeaders()['Content-Length'] = str(len(c))
		
		for k in r.getResponseHeaders().keys():
			if isinstance(r.getResponseHeaders()[k],list):
				for v in r.getResponseHeaders()[k]:
					w.write("%s: %s\r\n" % (k, v))	
			else:
				w.write("%s: %s\r\n" % (k, r.getResponseHeaders()[k]))
			
		w.write("\r\n")
		w.flush()
		
		log("handle_request(): sending content... (%s Bytes)" % (len(c),))
		
		self.wfile.write( c )
		#self.wfile.write( b"\r\n" );
		log("handle_request(): finished.")
		
		
	

class HServer:

	def __init__(self,listen = ('localhost',8080), object_store = None, object_broker = None,root_object = None, packagemanager = None):
		self.__listen = (listen[0],listen[1])
		
		self.__disksync = object_store
		self.__broker = object_broker
		self.__packages = packagemanager

		if (root_object is None):
			if (not (self.__disksync is None)) and ("ROOT" in self.__disksync):
				self.__root = self.__broker.load( self.__disksync["ROOT"].decode("UTF-8") )
			else:
				self.__root = hserver.manage.RootFolder()
		else:
			self.__root = root_object

		if not self.__broker is None:
			persistence_id = self.__broker.save( self.__root )
			log("Created new RootFolder {0}".format(persistence_id))
			self.__disksync["ROOT"] = persistence_id.encode("UTF-8")
		
	def _shutdown(self):
		self.__http.shutdown()
		
	def shutdown(self):
		t = threading.Thread(target=HServer._shutdown,args=(self,))
		t.start()
		
	def packagemanager(self):
		return self.__packages
		
	def getRoot(self):
		return self.__root
		
	def aq_root(self):
		return AquisitionProxy( self.__root )
		
	def run(self):
		socketserver.TCPServer.allow_reuse_address = True
		self.__http = socketserver.TCPServer(self.__listen,HServerRequestHandler)
		self.__http.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
		self.__http.hserver = self
		self.__http.serve_forever()
		
		try:
			self.__http.serve_forever()
		except Exception as e:
			pass
			
		self.__http.socket.close()

	def start(self):
		self.thread = threading.Thread( target = self.run, args = () )
		self.thread.start()

	def handle(self,request):
		log("Hserver.handle(%s)" % (request,))
		
		root = self.aq_root()
		
		if (request.pathwalker().len()==0):
			root( request )
		else:
			root.walk( request )
			if not self.__broker is None:
				self.__broker.save( self.__root )