FM / wsgiref

/opt/alt/python27/lib64/python2.7/wsgiref/

/opt/alt/python27/lib64/python2.7/wsgiref

Name	Size	Mode	Actions
handlers.py	15982	0644	edit dl rm
handlers.pyc	16735	0644	edit dl rm
handlers.pyo	16088	0644	edit dl rm
headers.py	5879	0644	edit dl rm
headers.pyc	7707	0644	edit dl rm
headers.pyo	7707	0644	edit dl rm
simple_server.py	4974	0644	edit dl rm
simple_server.pyc	6417	0644	edit dl rm
simple_server.pyo	6417	0644	edit dl rm
util.py	5576	0644	edit dl rm
util.pyc	6149	0644	edit dl rm
util.pyo	6149	0644	edit dl rm
validate.py	14743	0644	edit dl rm
validate.pyc	17360	0644	edit dl rm
validate.pyo	17360	0644	edit dl rm
__init__.py	586	0644	edit dl rm
__init__.pyc	742	0644	edit dl rm
__init__.pyo	742	0644	edit dl rm

Edit: /opt/alt/python27/lib64/python2.7/wsgiref/simple_server.py (4974B)

"""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(65537)
        if len(self.raw_requestline) > 65536:
            self.requestline = ''
            self.request_version = ''
            self.command = ''
            self.send_error(414)
            return

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
    httpd.server_close()

cmd: