Code cleaning

Deleting code from old standalone server

lodel/plugins/multisite/main.py

-#Known bugs : 
-#Sockets are not closed properly leading in a listening socket leak, a patch
-#will be submitted for cpython 3.6
-#
-
-import os
-import sys
-import signal
-import socket
-import socketserver
-import wsgiref
-import wsgiref.simple_server
-from wsgiref.simple_server import make_server
-from io import BufferedWriter
-
-from lodel.context import LodelContext
-from lodel.context import ContextError
-
-##@brief Set the poll interval to detect shutdown requests (do not work)
-SHUTDOWN_POLL_INTERVAL = 0.1 # <-- No impact because of ForkingTCPServer bug
-
-##@brief Stores the signal we uses to kill childs
-KILLING_CHILDS_SIGNAL = signal.SIGTERM
-
-FAST_APP_EXPOSAL_CACHE = dict()
-
-##@brief Reimplementation of WSGIRequestHandler
-#
-#Handler class designed to be called by socketserver child classes to handle
-#a request.
-#We inherit from wsgiref.simple_server.WSGIRequestHandler to avoid writing
-#all the construction of the wsgi variables
-class LodelWSGIHandler(wsgiref.simple_server.WSGIRequestHandler):
-    
-    ##@brief Method called by the socketserver to handle a request
-    def handle(self):
-        #Register a signal handler for sigint in the child process
-        req_ref = self.request
-        def sigstop_handler_client(signal, frame):
-            req_ref.close()
-            print("Client %d stopping by signal" % os.getpid())
-            os._exit(0)
-        signal.signal(KILLING_CHILDS_SIGNAL, sigstop_handler_client)
-        #Dirty copy & past from Lib/http/server.py in Cpython sources       
-        try:
-            self.raw_requestline = self.rfile.readline(65537)
-            if len(self.raw_requestline) > 65536:
-                self.requestline = ''
-                self.request_version = ''
-                self.command = ''
-                self.send_error(HTTPStatus.REQUEST_URI_TOO_LONG)
-                return
-            if not self.raw_requestline:
-                self.close_connection = True
-                return
-            if not self.parse_request():
-                return
-            #Here begin custom code
-            env = self.get_environ()
-            stdout = BufferedWriter(self.wfile)
-            try:
-                handler = wsgiref.handlers.SimpleHandler(
-                    self.rfile, stdout, self.get_stderr(), env)
-                handler.request_handler = self      # backpointer for logging
-                handler.run(self.server.get_app())
-            finally:
-                stdout.detach()
-        except socket.timeout as e:
-            self.log_error("Request timed out: %r", e)
-            self.close_connection = True
-            return
-    
-    ##@brief An attempt to solve the socket leak problem
-    def close(self):
-        self.request.close()
-        super().close()
-
-   
-class CustomForkingTCPServer(socketserver.ForkingTCPServer):
-    ##@brief static property indicating the max number of childs allowed
-    max_children = 40
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if self.__class__.active_children is None:
-            self.__class__.active_childer = set()
-    
-    ##@brief Implements max_children limitations
-    def process_request(self, request, client_address):
-        while self.active_children is not None and \
-                len(self.active_children) > self.__class__.max_children:
-            self.collect_children()
-        super().process_request(request, client_address)
-        
-    ##@brief Custom reimplementation of shutdown method in order to ensure
-    #that we close all listening sockets
-    #
-    #This method is here because of a bug (or a missing feature) : 
-    #The socketserver implementation force to call the shutdown method
-    #from another thread/process else it leads in a deadlock.
-    #The problem is that the implementation of shutdown set a private attribute
-    #__shutdown_request to true. So we cannot reimplement a method that will
-    #just set the flag to True, we have to manually collect each actives 
-    #childs. A patch is prepared and will be proposed for cpython upstream.
-    def shutdown(self):
-        if self.active_children is not None:
-            for pid in self.active_children.copy():
-                print("Killing : %d"%pid)
-                os.kill(pid, KILLING_CHILDS_SIGNAL)
-                try:
-                    pid, _ = os.waitpid(pid, 0)
-                    self.active_children.discard(pid)
-                except ChildProcessError:
-                    self.active_children.discard(pid)
-        self.server_close()
-
-##@brief WSGIServer implementing ForkingTCPServer.
-#
-#Same features than wsgiref.simple_server.WSGIServer but process each requests
-#in a child process
-class ForkingWSGIServer(
-        wsgiref.simple_server.WSGIServer, CustomForkingTCPServer):
-    pass
- 
-
-##@brief utility function to extract site id from an url
-def site_id_from_url(url):
-    res = ''
-    for c in url[1:]:
-        if c == '/':
-            break
-        res += c
-    if len(res) == 0:
-        return None
-    return res
-
-##@brief Utility function to return quickly an error
-def http_error(env, start_response, status = '500 internal server error', \
-        extra = None):
-    headers = [('Content-type', 'text/plain; charset=utf-8')]
-    start_response(status, headers)
-    msg = status
-    if extra is not None:
-        msg = extra
-    return [msg.encode('utf-8')]
-
-##@brief This method is run in a child process by the handler
-def wsgi_router(env, start_response):
-    #Attempt to load a context
-    site_id = site_id_from_url(env['PATH_INFO'])
-    if site_id is None:
-        #It can be nice to provide a list of instances here
-        return http_error(env, start_response, '404 Not Found')
-    try:
-        LodelContext.set(site_id)
-        #We are in the good context
-
-    except ContextError as e:
-        print(e)
-        return http_error(env, start_response, '404 Not found',
-            "No site named '%s'" % site_id)
-    #Calling webui
-    return FAST_APP_EXPOSAL_CACHE[site_id].application(env, start_response)
-    #LodelContext.expose_modules(globals(), {
-    #    'lodel.plugins.webui.run': ['application']})
-    #return application(env, start_response)
-
-##@brief Starts the server until a SIGINT is received
-def main_loop():
-    LodelContext.expose_modules(globals(), {'lodel.settings': ['Settings']})
-    ForkingWSGIServer.max_children = Settings.server.max_children
-    listen_addr = Settings.server.listen_address
-    listen_port = Settings.server.listen_port
-    server = wsgiref.simple_server.make_server(
-        listen_addr, listen_port, wsgi_router,
-        server_class=ForkingWSGIServer, handler_class = LodelWSGIHandler)
-    #Signal handler to close server properly on sigint
-    def sigint_handler(signal, frame):
-        print("Ctrl-c pressed, exiting")
-        server.shutdown()
-        server.server_close()
-        exit(0)
-    signal.signal(signal.SIGINT, sigint_handler)
-    #Listen until SIGINT
-    server.serve_forever(SHUTDOWN_POLL_INTERVAL)
-