183 lines
4.2 KiB
Python
183 lines
4.2 KiB
Python
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 )
|
|
|
|
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() )
|
|
|
|
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)):
|
|
self.__listen = (listen[0],listen[1])
|
|
|
|
self.__disksync = objectbroker.DiscObjectStore("./DiskSync")
|
|
self.__broker = objectbroker.ObjectBroker( self.__disksync )
|
|
|
|
self.__packages = PackageManager("./packages")
|
|
#self.__packages.loadPackageFromPath( "{0}/../hcore".format( os.path.dirname(__file__) ) )
|
|
|
|
if "ROOT" in self.__disksync:
|
|
self.__root = self.__broker.load( self.__disksync["ROOT"].decode("UTF-8") )
|
|
else:
|
|
self.__root = hserver.manage.RootFolder()
|
|
persistence_id = self.__broker.save( self.__root )
|
|
log("Created new RootFolder {0}".format(persistence_id))
|
|
self.__disksync["ROOT"] = persistence_id.encode("UTF-8")
|
|
|
|
#self.__packages.hcore.module().core.init(self)
|
|
|
|
|
|
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()
|
|
|
|
|
|
|
|
def handle(self,request):
|
|
log("Hserver.handle(%s)" % (request,))
|
|
|
|
root = self.aq_root()
|
|
|
|
if (request.pathwalker().len()==0):
|
|
root( request )
|
|
else:
|
|
root.walk( request )
|
|
self.__broker.save( self.__root )
|
|
|
|
|
|
|
|
|
|
|
|
|