__all__ = ["runsimple"]

import sys, os

from SimpleHTTPServer import SimpleHTTPRequestHandler

import urllib

import posixpath

import webapi as web

import net

import utils

def runbasic(func, server_address=("0.0.0.0", 8080)):

    """

    Runs a simple HTTP server hosting WSGI app `func`. The directory `static/` 

    is hosted statically.

    Based on [WsgiServer][ws] from [Colin Stewart][cs].

  [ws]: http://www.owlfish.com/software/wsgiutils/documentation/wsgi-server-api.html

  [cs]: http://www.owlfish.com/

    """

    # Copyright (c) 2004 Colin Stewart (http://www.owlfish.com/)

    # Modified somewhat for simplicity

    # Used under the modified BSD license:

    # http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5

    import SimpleHTTPServer, SocketServer, BaseHTTPServer, urlparse

    import socket, errno

    import traceback

    class WSGIHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):

        def run_wsgi_app(self):

            protocol, host, path, parameters, query, fragment = \

                urlparse.urlparse('http://dummyhost%s' % self.path)

            # we only use path, query

            env = {'wsgi.version': (1, 0)

                   ,'wsgi.url_scheme': 'http'

                   ,'wsgi.input': self.rfile

                   ,'wsgi.errors': sys.stderr

                   ,'wsgi.multithread': 1

                   ,'wsgi.multiprocess': 0

                   ,'wsgi.run_once': 0

                   ,'REQUEST_METHOD': self.command

                   ,'REQUEST_URI': self.path

                   ,'PATH_INFO': path

                   ,'QUERY_STRING': query

                   ,'CONTENT_TYPE': self.headers.get('Content-Type', '')

                   ,'CONTENT_LENGTH': self.headers.get('Content-Length', '')

                   ,'REMOTE_ADDR': self.client_address[0]

                   ,'SERVER_NAME': self.server.server_address[0]

                   ,'SERVER_PORT': str(self.server.server_address[1])

                   ,'SERVER_PROTOCOL': self.request_version

                   }

            for http_header, http_value in self.headers.items():

                env ['HTTP_%s' % http_header.replace('-', '_').upper()] = \

                    http_value

            # Setup the state

            self.wsgi_sent_headers = 0

            self.wsgi_headers = []

            try:

                # We have there environment, now invoke the application

                result = self.server.app(env, self.wsgi_start_response)

                try:

                    try:

                        for data in result:

                            if data: 

                                self.wsgi_write_data(data)

                    finally:

                        if hasattr(result, 'close'): 

                            result.close()

                except socket.error, socket_err:

                    # Catch common network errors and suppress them

                    if (socket_err.args[0] in \

                       (errno.ECONNABORTED, errno.EPIPE)): 

                        return

                except socket.timeout, socket_timeout: 

                    return

            except:

                print >> web.debug, traceback.format_exc(),

            if (not self.wsgi_sent_headers):

                # We must write out something!

                self.wsgi_write_data(" ")

            return

        do_POST = run_wsgi_app

        do_PUT = run_wsgi_app

        do_DELETE = run_wsgi_app

        def do_GET(self):

            if self.path.startswith('/static/'):

                SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)

            else:

                self.run_wsgi_app()

        def wsgi_start_response(self, response_status, response_headers, 

                              exc_info=None):

            if (self.wsgi_sent_headers):

                raise Exception \

                      ("Headers already sent and start_response called again!")

            # Should really take a copy to avoid changes in the application....

            self.wsgi_headers = (response_status, response_headers)

            return self.wsgi_write_data

        def wsgi_write_data(self, data):

            if (not self.wsgi_sent_headers):

                status, headers = self.wsgi_headers

                # Need to send header prior to data

                status_code = status[:status.find(' ')]

                status_msg = status[status.find(' ') + 1:]

                self.send_response(int(status_code), status_msg)

                for header, value in headers:

                    self.send_header(header, value)

                self.end_headers()

                self.wsgi_sent_headers = 1

            # Send the data

            self.wfile.write(data)

    class WSGIServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):

        def __init__(self, func, server_address):

            BaseHTTPServer.HTTPServer.__init__(self, 

                                               server_address, 

                                               WSGIHandler)

            self.app = func

            self.serverShuttingDown = 0

    print "http://%s:%d/" % server_address

    WSGIServer(func, server_address).serve_forever()

# The WSGIServer instance. 

# Made global so that it can be stopped in embedded mode.

server = None

def runsimple(func, server_address=("0.0.0.0", 8080)):

    """

    Runs [CherryPy][cp] WSGI server hosting WSGI app `func`. 

    The directory `static/` is hosted statically.

    [cp]: http://www.cherrypy.org

    """

    global server

    func = StaticMiddleware(func)

    func = LogMiddleware(func)

    server = WSGIServer(server_address, func)

    if server.ssl_adapter:

        print "https://%s:%d/" % server_address

    else:

        print "http://%s:%d/" % server_address

    try:

        server.start()

    except (KeyboardInterrupt, SystemExit):

        server.stop()

        server = None

def WSGIServer(server_address, wsgi_app):

    """Creates CherryPy WSGI server listening at `server_address` to serve `wsgi_app`.

    This function can be overwritten to customize the webserver or use a different webserver.

    """

    import wsgiserver

    # Default values of wsgiserver.ssl_adapters uses cherrypy.wsgiserver

    # prefix. Overwriting it make it work with web.wsgiserver.

    wsgiserver.ssl_adapters = {

        'builtin': 'web.wsgiserver.ssl_builtin.BuiltinSSLAdapter',

        'pyopenssl': 'web.wsgiserver.ssl_pyopenssl.pyOpenSSLAdapter',

    }

    server = wsgiserver.CherryPyWSGIServer(server_address, wsgi_app, server_name="localhost")

    def create_ssl_adapter(cert, key):

        # wsgiserver tries to import submodules as cherrypy.wsgiserver.foo.

        # That doesn't work as not it is web.wsgiserver. 

        # Patching sys.modules temporarily to make it work.

        import types

        cherrypy = types.ModuleType('cherrypy')

        cherrypy.wsgiserver = wsgiserver

        sys.modules['cherrypy'] = cherrypy

        sys.modules['cherrypy.wsgiserver'] = wsgiserver

        from wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter

        adapter = pyOpenSSLAdapter(cert, key)

        # We are done with our work. Cleanup the patches.

        del sys.modules['cherrypy']

        del sys.modules['cherrypy.wsgiserver']

        return adapter

    # SSL backward compatibility

    if (server.ssl_adapter is None and

        getattr(server, 'ssl_certificate', None) and

        getattr(server, 'ssl_private_key', None)):

        server.ssl_adapter = create_ssl_adapter(server.ssl_certificate, server.ssl_private_key)

    server.nodelay = not sys.platform.startswith('java') # TCP_NODELAY isn't supported on the JVM

    return server

class StaticApp(SimpleHTTPRequestHandler):

    """WSGI application for serving static files."""

    def __init__(self, environ, start_response):

        self.headers = []

        self.environ = environ

        self.start_response = start_response

    def send_response(self, status, msg=""):

        self.status = str(status) + " " + msg

    def send_header(self, name, value):

        self.headers.append((name, value))

    def end_headers(self):

        pass

    def log_message(*a): pass

    def __iter__(self):

        environ = self.environ

        self.path = environ.get('PATH_INFO', '')

        self.client_address = environ.get('REMOTE_ADDR','-'), \

                              environ.get('REMOTE_PORT','-')

        self.command = environ.get('REQUEST_METHOD', '-')

        from cStringIO import StringIO

        self.wfile = StringIO() # for capturing error

        try:

            path = self.translate_path(self.path)

            etag = '"%s"' % os.path.getmtime(path)

            client_etag = environ.get('HTTP_IF_NONE_MATCH')

            self.send_header('ETag', etag)

            if etag == client_etag:

                self.send_response(304, "Not Modified")

                self.start_response(self.status, self.headers)

                raise StopIteration

        except OSError:

            pass # Probably a 404

        f = self.send_head()

        self.start_response(self.status, self.headers)

        if f:

            block_size = 16 * 1024

            while True:

                buf = f.read(block_size)

                if not buf:

                    break

                yield buf

            f.close()

        else:

            value = self.wfile.getvalue()

            yield value

class StaticMiddleware:

    """WSGI middleware for serving static files."""

    def __init__(self, app, prefix='/static/'):

        self.app = app

        self.prefix = prefix

    def __call__(self, environ, start_response):

        path = environ.get('PATH_INFO', '')

        path = self.normpath(path)

        if path.startswith(self.prefix):

            return StaticApp(environ, start_response)

        else:

            return self.app(environ, start_response)

    def normpath(self, path):

        path2 = posixpath.normpath(urllib.unquote(path))

        if path.endswith("/"):

            path2 += "/"

        return path2

class LogMiddleware:

    """WSGI middleware for logging the status."""

    def __init__(self, app):

        self.app = app

        self.format = '%s - - [%s] "%s %s %s" - %s'

        from BaseHTTPServer import BaseHTTPRequestHandler

        import StringIO

        f = StringIO.StringIO()

        class FakeSocket:

            def makefile(self, *a):

                return f

        # take log_date_time_string method from BaseHTTPRequestHandler

        self.log_date_time_string = BaseHTTPRequestHandler(FakeSocket(), None, None).log_date_time_string

    def __call__(self, environ, start_response):

        def xstart_response(status, response_headers, *args):

            out = start_response(status, response_headers, *args)

            self.log(status, environ)

            return out

        return self.app(environ, xstart_response)

    def log(self, status, environ):

        outfile = environ.get('wsgi.errors', web.debug)

        req = environ.get('PATH_INFO', '_')

        protocol = environ.get('ACTUAL_SERVER_PROTOCOL', '-')

        method = environ.get('REQUEST_METHOD', '-')

        host = "%s:%s" % (environ.get('REMOTE_ADDR','-'), 

                          environ.get('REMOTE_PORT','-'))

        time = self.log_date_time_string()

        msg = self.format % (host, time, protocol, method, req, status)

        print >> outfile, utils.safestr(msg)