import socket, select
try: import threading
except ImportError: import dummy_threading as threading
class BaseServer:
    timeout = None

    def __init__(self, server_address, RequestHandlerClass):
        self.server_address = server_address
        self.RequestHandlerClass = RequestHandlerClass
        self.__is_shut_down = threading.Event()
        self.__shutdown_request = False

    def server_activate(self): pass

    def serve_forever(self, poll_interval=0.5):
        self.__is_shut_down.clear()
        try:
            while not self.__shutdown_request:
                r, w, e = select.select([self], [], [], poll_interval)
                if self in r:
                    self._handle_request_noblock()
        finally:
            self.__shutdown_request = False
            self.__is_shut_down.set()

    def shutdown(self):
        self.__shutdown_request = True
        self.__is_shut_down.wait()

    def handle_request(self):
        timeout = self.socket.gettimeout()
        if timeout is None:
            timeout = self.timeout
        elif self.timeout is not None:
            timeout = min(timeout, self.timeout)
        fd_sets = select.select([self], [], [], timeout)
        if not fd_sets[0]:
            self.handle_timeout()
            return
        self._handle_request_noblock()

    def _handle_request_noblock(self):
        try: request, client_address = self.get_request()
        except socket.error:
            return
        if self.verify_request(request, client_address):
            try: self.process_request(request, client_address)
            except:
                self.handle_error(request, client_address)
                self.shutdown_request(request)

    def handle_timeout(self): pass

    def verify_request(self, request, client_address): return True

    def process_request(self, request, client_address):
        self.finish_request(request, client_address)
        self.shutdown_request(request)

    def server_close(self): pass

    def finish_request(self, request, client_address): self.RequestHandlerClass(request, client_address, self)

    def shutdown_request(self, request): self.close_request(request)

    def close_request(self, request): pass

    def handle_error(self, request, client_address):
        print('-'*40)
        print('Exception happened during processing of request from', end=' ')
        print(client_address)
        import traceback
        traceback.print_exc() # XXX But this goes to stderr!
        print('-'*40)

class socketserver:
    """I can't figure out how to modify that (insert up arrow here) without making a big mess so I am doing a complete rewrite"""
    def __init__(self, address, handler):
        self.server_address = address
        self.RequestHandlerClass = handler
        self.running = False
    def serve_forever(self, poll_interval=0.5):
        self.running = True
        while self.running:
            r, w, e = select.select([self], [], [], poll_interval) # what does this do?
            if self in r: self._handle_request_noblock() # and this?
    def shutdown(self): self.running = False
    def handle_request(self):
        try: request, client_address = self.get_request()
        except socket.error: return
        if self.verify_request(request, client_address):
            try: self.finish_request(request, client_address)
            except: self.handle_error(request, client_address)
    def finish_request(self, request, client_address): self.RequestHandlerClass(request, client_address, self)
    def handle_error(self, request, client_address):
        print('-'*40)
        print('Exception happened during processing of request from %s' % client_address)
        __import__(traceback).print_exc() # I have bad experiences with trying to import from inside a function
        print('-'*40)