#!/usr/bin/python

from __future__ import print_function

try:
    from SocketServer import BaseServer, ThreadingMixIn, ForkingMixIn
except ImportError:
    from socketserver import BaseServer, ThreadingMixIn, ForkingMixIn
try:
    from http.server import HTTPServer, SimpleHTTPRequestHandler
except ImportError:
    from BaseHTTPServer import HTTPServer
    from SimpleHTTPServer import SimpleHTTPRequestHandler

Servers = ('HTTPServer', 'ForkedHTTPServer', 'ThreadedHTTPServer')

def msg(*args):
    import os, threading
    print('%d:%s %s' % (os.getpid(), threading.current_thread().getName(),
                        ' '.join([str(a) for a in args])))

def str2byte(s):
    try:
        return bytes(s)
    except TypeError:
        return bytes(s, encoding='ascii')

class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    pass
class ForkedHTTPServer(ForkingMixIn, HTTPServer):
    pass

class RequestHandler(SimpleHTTPRequestHandler):
    def do_GET(self):
        """Immediately shutdown on any GET request."""
        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()
        self.wfile.write(str2byte('Stopping...\r\n'))
        msg('calling shutdown()')
        self.server.shutdown()

def server(servername, port):
    import __main__
    serverklass = getattr(__main__, servername)
    httpd = serverklass(('', port), RequestHandler)
    msg(httpd)
    httpd.serve_forever()

def client(port):
    import time
    try:
        from urllib2 import urlopen, URLError
    except ImportError:
        from urllib.request import urlopen
        from urllib.error import URLError
    if True:
        try:
            time.sleep(1)
            u = 'http://localhost:%d' % port
            f = urlopen(u)
            if f.getcode() != 200:
                pass #break
        except URLError:
            pass #break

def main():
    """Start a simple http server."""
    import __main__, os, subprocess, sys

    try:
        servername = sys.argv[1]
    except:
        servername = None
    try:
        port = int(sys.argv[2])
    except:
        port = 8081

    if servername:
        pid = os.fork()
        if pid:  # parent/server
            msg('starting server as', os.getpid())
            server(servername, port)
            os.waitpid(pid, 0)
            msg('ending server')
        else: # pid - child/client
            msg('starting client as', os.getpid())
            client(port)
            msg('ending client')
        os._exit(0)

    else: # cycle through servers
        msg('starting with', Servers)
        for servername in Servers:
            p = subprocess.Popen(
                [sys.executable, sys.argv[0], servername, str(port)]
            )
            msg('started', servername, 'as pid', p.pid, os.getpid())
            p.wait()
            msg('stopped', servername, '...', p.returncode)
        os._exit(0)

def klass_test(servers):
    import __main__
    for server_name in servers:
        klass = getattr(__main__, server_name)
        inst = klass(('', 10000), RequestHandler)
        inst.socket.shutdown(0)
        inst.socket.close()
        msg(klass, isinstance(inst, BaseServer))

if __name__ == '__main__':
    #klass_test(Servers)
    main()