"""BaseHTTPServer that implements the Python WSGI protocol (PEP 333, rev 1.21)

This is both an example of how WSGI can be implemented, and a basis for running

simple web applications on a local machine, such as might be done when testing

or debugging an application.  It has not been reviewed for security issues,

however, and we strongly recommend that you use a "real" web server for

production use.

For example usage, see the 'if __name__=="__main__"' block at the end of the

module.  See also the BaseHTTPServer module docs for other API information.

"""

from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer

import urllib, sys

from wsgiref.handlers import SimpleHandler

__version__ = "0.1"

__all__ = ['WSGIServer', 'WSGIRequestHandler', 'demo_app', 'make_server']

server_version = "WSGIServer/" + __version__

sys_version = "Python/" + sys.version.split()[0]

software_version = server_version + ' ' + sys_version

class ServerHandler(SimpleHandler):

    server_software = software_version

    def close(self):

        try:

            self.request_handler.log_request(

                self.status.split(' ',1)[0], self.bytes_sent

            )

        finally:

            SimpleHandler.close(self)

class WSGIServer(HTTPServer):

    """BaseHTTPServer that implements the Python WSGI protocol"""

    application = None

    def server_bind(self):

        """Override server_bind to store the server name."""

        HTTPServer.server_bind(self)

        self.setup_environ()

    def setup_environ(self):

        # Set up base environment

        env = self.base_environ = {}

        env['SERVER_NAME'] = self.server_name

        env['GATEWAY_INTERFACE'] = 'CGI/1.1'

        env['SERVER_PORT'] = str(self.server_port)

        env['REMOTE_HOST']=''

        env['CONTENT_LENGTH']=''

        env['SCRIPT_NAME'] = ''

    def get_app(self):

        return self.application

    def set_app(self,application):

        self.application = application

class WSGIRequestHandler(BaseHTTPRequestHandler):

    server_version = "WSGIServer/" + __version__

    def get_environ(self):

        env = self.server.base_environ.copy()

        env['SERVER_PROTOCOL'] = self.request_version

        env['REQUEST_METHOD'] = self.command

        if '?' in self.path:

            path,query = self.path.split('?',1)

        else:

            path,query = self.path,''

        env['PATH_INFO'] = urllib.unquote(path)

        env['QUERY_STRING'] = query

        host = self.address_string()

        if host != self.client_address[0]:

            env['REMOTE_HOST'] = host

        env['REMOTE_ADDR'] = self.client_address[0]

        if self.headers.typeheader is None:

            env['CONTENT_TYPE'] = self.headers.type

        else:

            env['CONTENT_TYPE'] = self.headers.typeheader

        length = self.headers.getheader('content-length')

        if length:

            env['CONTENT_LENGTH'] = length

        for h in self.headers.headers:

            k,v = h.split(':',1)

            k=k.replace('-','_').upper(); v=v.strip()

            if k in env:

                continue                    # skip content length, type,etc.

            if 'HTTP_'+k in env:

                env['HTTP_'+k] += ','+v     # comma-separate multiple headers

            else:

                env['HTTP_'+k] = v

        return env

    def get_stderr(self):

        return sys.stderr

    def handle(self):

        """Handle a single HTTP request"""

        self.raw_requestline = self.rfile.readline()

        if not self.parse_request(): # An error code has been sent, just exit

            return

        handler = ServerHandler(

            self.rfile, self.wfile, self.get_stderr(), self.get_environ()

        )

        handler.request_handler = self      # backpointer for logging

        handler.run(self.server.get_app())

def demo_app(environ,start_response):

    from StringIO import StringIO

    stdout = StringIO()

    print >>stdout, "Hello world!"

    print >>stdout

    h = environ.items(); h.sort()

    for k,v in h:

        print >>stdout, k,'=', repr(v)

    start_response("200 OK", [('Content-Type','text/plain')])

    return [stdout.getvalue()]

def make_server(

    host, port, app, server_class=WSGIServer, handler_class=WSGIRequestHandler

):

    """Create a new WSGI server listening on `host` and `port` for `app`"""

    server = server_class((host, port), handler_class)

    server.set_app(app)

    return server

if __name__ == '__main__':

    httpd = make_server('', 8000, demo_app)

    sa = httpd.socket.getsockname()

    print "Serving HTTP on", sa[0], "port", sa[1], "..."

    import webbrowser

    webbrowser.open('http://localhost:8000/xyz?abc')

    httpd.handle_request()  # serve one request, then exit

#