Changeset 1573

Timestamp:

12/28/06 14:10:07

Author:

fumanchu

Message:

Copied recent changes from trunk to _cpwsgiserver3.

Files:

• branches/cherrypy-2.x/cherrypy/_cpwsgiserver3.py (modified) (30 diffs)

branches/cherrypy-2.x/cherrypy/_cpwsgiserver3.py

@@ -1 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-import base64
-import mimetools # todo: use email
-import Queue
-import os
@@ -39 +75 @@
-socket_errors_to_ignore.append("timed out")
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-class HTTPRequest(object):
+    """An HTTP Request (and response).
+    
+    A single HTTP connection may consist of multiple request/response pairs.
+    
+    connection: the HTTP Connection object which spawned this request.
+    rfile: the 'read' fileobject from the connection's socket
+    ready: when True, the request has been parsed and is ready to begin
+        generating the response. When False, signals the calling Connection
+        that the response should not be generated and the connection should
+        close.
+    close_connection: signals the calling Connection that the request
+        should close. This does not imply an error! The client and/or
+        server may each request that the connection be closed.
+    chunked_write: if True, output will be encoded with the "chunked"
+        transfer-coding. This value is set automatically inside
+        send_headers.
+    """
-    
-    def __init__(self, connection):
-        self.connection = connection
-        self.rfile = self.connection.rfile
+        self.sendall = self.connection.sendall
-        self.environ = connection.environ.copy()
-        
@@ -65 +116 @@
-    
-    def parse_request(self):
+        """Parse the next HTTP request start-line and message-headers."""
-        # HTTP/1.1 connections are persistent by default. If a client
-        # requests a page, then idles (leaves the connection open),
@@ -78 +130 @@
-            return
-        
+        if request_line == "\r\n":
+            # RFC 2616 sec 4.1: "...if the server is reading the protocol
+            # stream at the beginning of a message and receives a CRLF
+            # first, it should ignore the CRLF."
+            # But only ignore one leading line! else we enable a DoS.
+            request_line = self.rfile.readline()
+            if not request_line:
+                self.ready = False
+                return
+        
-        server = self.connection.server
-
+
+
-        
-        method, path, req_protocol = request_line.strip().split(" ", 2)
-self.
+
-        
-        # path may be an abs_path (including "http://host.domain.tld");
@@ -93 +156 @@
-        
-        if scheme:
-self.
+
-        if params:
-            path = path + ";" + params
@@ -109 +172 @@
-            # This means, of course, that the last wsgi_app (shortest path)
-            # will always handle a URI of "*".
-self.
-self.
+
+
-            self.wsgi_app = server.mount_points[-1][1]
-        else:
@@ -116 +179 @@
-                # The mount_points list should be sorted by length, descending.
-                if path.startswith(mount_point + "/") or path == mount_point:
-self.
-self.
+
+
-                    self.wsgi_app = wsgi_app
-                    break
@@ -126 +189 @@
-        # Note that, like wsgiref and most other WSGI servers,
-        # we unquote the path but not the query string.
-self.
+
-        
-        # Compare request and server HTTP protocol versions, in case our
@@ -146 +209 @@
-            return
-        # Bah. "SERVER_PROTOCOL" is actually the REQUEST protocol.
-self.
+
-        # set a non-standard environ entry so the WSGI app can know what
-        # the *real* server protocol is (and what features to support).
-        # See http://www.faqs.org/rfcs/rfc2145.html.
-self.
+
-        self.response_protocol = "HTTP/%s.%s" % min(rp, sp)
-        
-        # If the Request-URI was an absoluteURI, use its location atom.
-        if location:
-self.
+
-        
-        # then all the http headers
-
-
-
-
-
+
+
+
+
+
+
+
+
-        if creds[0].lower() == 'basic':
-            user, pw = base64.decodestring(creds[1]).split(":", 1)
-self.
+
-        
-        # Persistent connection support
-        if self.response_protocol == "HTTP/1.1":
-headers.getheader("Connection
+environ.get("HTTP_CONNECTION
-                self.close_connection = True
-                self.outheaders.append(("Connection", "close"))
-        else:
-            # HTTP/1.0
-
-
-
-
+
-                self.close_connection = True
-        
-        # Transfer-Encoding support
-
-
+
+
+
+
+
+
+
+
-        if te:
-
-
-
-
-
+
+
+
-                else:
+                    # Note that, even if we see "chunked", we must reject
+                    # if there is an extension we don't recognize.
-                    self.simple_response("501 Unimplemented")
-                    self.close_connection = True
-                    return
+        
+        if read_chunked:
+            if not self.decode_chunked():
+                return
-        else:
-headers.getheader("Content-length
+environ.get("CONTENT_LENGTH
-            if method in ("POST", "PUT") and cl is None:
-                # No Content-Length header supplied. This will hang
@@ -220 +292 @@
-        # We used to do 3, but are now doing 1. Maybe we'll do 2 someday,
-        # but it seems like it would be a big slowdown for such a rare case.
-headers.getheader("Expect
+environ.get("HTTP_EXPECT
-            self.simple_response(100)
-        
-        self.ready = True
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-            
-
+
+
+
+
+
+
+
+
+
+
+
+
-            if k in comma_separated_headers:
-                existing = environ.get(envname)
-                if existing:
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-    
-    def decode_chunked(self):
@@ -269 +351 @@
-                return
-        
-
-
+
+
+
-        data.seek(0)
-        self.environ["wsgi.input"] = data
@@ -277 +360 @@
-    
-    def respond(self):
-wfile = self.connection.wfile
+"""Call the appropriate WSGI app and write its iterable output."""
-        response = self.wsgi_app(self.environ, self.start_response)
-        try:
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-        finally:
-            if hasattr(response, "close"):
@@ -300 +373 @@
-            self.send_headers()
-        if self.chunked_write:
-
-
+
-    
-    def simple_response(self, status, msg=""):
-        """Write a simple response back to the client."""
-        status = str(status)
-
-
-
+
+
-        
-        if status[:3] == "413" and self.response_protocol == 'HTTP/1.1':
-            # Request Entity Too Large
-            self.close_connection = True
-wfile.write
-
-wfile.write
+buf.append
+
+buf.append
-        if msg:
-wfile.write
-wfile.flush(
+buf.append
+self.sendall("".join(buf)
-    
-    def start_response(self, status, headers, exc_info = None):
+        """WSGI callable to begin the HTTP response."""
-        if self.started_response:
-            if not exc_info:
@@ -334 +406 @@
-        return self.write
-    
-
+
+
+
+
+
+
-        if not self.sent_headers:
-            self.sent_headers = True
-            self.send_headers()
-
-
+
+
+
+
+
+
-    
-    def send_headers(self):
-
+
+
-        status = int(self.status[:3])
-        
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-                    # Use the chunked transfer-coding
-                    self.chunked_write = True
-                    self.outheaders.append(("Transfer-Encoding", "chunked"))
-
-
-
-
-
+
+
-                    self.close_connection = True
-        
-
-
+
+
+
+
+
+
+
-        
-        if "date" not in hkeys:
@@ -368 +457 @@
-        
-        server = self.connection.server
-        wfile = self.connection.wfile
-        
-        if "server" not in hkeys:
-            self.outheaders.append(("Server", server.version))
-        
-wfile.write(server.protocol + " " + self.status + "\r\n")
+buf = [server.protocol, " ", self.status, "\r\n"]
-        try:
-
-
+
-        except TypeError:
-            if not isinstance(k, str):
@@ -384 +471 @@
-            else:
-                raise
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-    def ssl_method_wrapper(self, *args, **kwargs):
-##        print (id(self), method, args, kwargs)
@@ -396 +488 @@
-                return method(self, *args, **kwargs)
-            except (SSL.WantReadError, SSL.WantWriteError):
-
+
+
+
+
-                time.sleep(self.ssl_retry)
-            except SSL.SysCallError, e:
-
+is_reader and 
-                    return ""
-                
-                errno = e.args[0]
-
-
-
-
+
+
+
-            except SSL.Error, e:
-
+is_reader and 
-                    return ""
-elif
+if is_reader and
-                    return ""
-
-
+
-            if time.time() - start > self.ssl_timeout:
-                raise socket.timeout("timed out")
@@ -428 +521 @@
-    write = _ssl_wrap_method(socket._fileobject.write)
-    writelines = _ssl_wrap_method(socket._fileobject.writelines)
-
-
-
+, is_reader=True
+, is_reader=True
+, is_reader=True
-
-
-class HTTPConnection(object):
+    """An HTTP connection (active socket).
+    
+    socket: the raw socket object (usually TCP) for this connection.
+    addr: the "bind address" for the remote end of the socket.
+        For IP sockets, this is a tuple of (REMOTE_ADDR, REMOTE_PORT).
+        For UNIX domain sockets, this will be a string.
+    server: the HTTP Server for this Connection. Usually, the server
+        object possesses a passive (server) socket which spawns multiple,
+        active (client) sockets, one for each connection.
+    
+    environ: a WSGI environ template. This will be copied for each request.
+    rfile: a fileobject for reading from the socket.
+    sendall: a function for writing (+ flush) to the socket.
+    """
-    
-    rbufsize = -1
-    wbufsize = -1
-    RequestHandlerClass = HTTPRequest
-    environ = {"wsgi.version": (1, 0),
@@ -455 +561 @@
-        
-        if SSL and isinstance(sock, SSL.ConnectionType):
+            timeout = sock.gettimeout()
-            self.rfile = SSL_fileobject(sock, "r", self.rbufsize)
-
+
+
-            self.environ["wsgi.url_scheme"] = "https"
-            self.environ["HTTPS"] = "on"
@@ -463 +571 @@
-                self.environ.update(sslenv)
-        else:
-elf.socket
-wfile = self.socket.makefile("w", self.wbufsize)
+ock
+sendall = sock.sendall
-        
-        self.environ.update({"wsgi.input": self.rfile,
@@ -511 +619 @@
-    
-    def close(self):
+        """Close the socket underlying this connection."""
-        self.rfile.close()
-        self.wfile.close()
-        self.socket.close()
-
@@ -528 +636 @@
-
-class WorkerThread(threading.Thread):
+    """Thread which continuously polls a Queue for Connection objects.
+    
+    server: the HTTP Server which spawned this thread, and which owns the
+        Queue and is placing active connections into it.
+    ready: a simple flag for the calling server to know when this thread
+        has begun polling the Queue.
+    
+    Due to the timing issues of polling a Queue, a WorkerThread does not
+    check its own 'ready' flag after it has started. To stop the thread,
+    it is necessary to stick a _SHUTDOWNREQUEST object onto the Queue
+    (one for each running WorkerThread).
+    """
-    
-    def __init__(self, server):
@@ -551 +671 @@
-
-class SSLConnection:
+    """A thread-safe wrapper for an SSL.Connection.
+    
+    *args: the arguments to create the wrapped SSL.Connection(*args).
+    """
+    
-    def __init__(self, *args):
-        self._ssl_conn = SSL.Connection(*args)
@@ -586 +711 @@
-        specifies the maximum number of queued connections (default 5).
-    timeout: the timeout in seconds for accepted connections (default 10).
+    
+    protocol: the version string to write in the Status-Line of all
+        HTTP responses. For example, "HTTP/1.1" (the default). This
+        also limits the supported features used in the response.
+    
+    
+    SSL/HTTPS
+    ---------
+    The OpenSSL module must be importable for SSL functionality.
+    You can obtain it from http://pyopenssl.sourceforge.net/
+    
+    ssl_certificate: the filename of the server SSL certificate.
+    ssl_privatekey: the filename of the server's private key file.
+    
+    If either of these is None (both are None by default), this server
+    will not use SSL. If both are given and are valid, they will be read
+    on server start and used in the SSL context for the listening socket.
-    """
-    
-    protocol = "HTTP/1.1"
-RC1
+
-    ready = False
-    _interrupt = None
@@ -631 +773 @@
-        # trap those exceptions in whatever code block calls start().
-        self._interrupt = None
-        
-        def bind(family, type, proto=0):
-            """Create (or recreate) the actual socket object."""
-            self.socket = socket.socket(family, type, proto)
-            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            if self.ssl_certificate and self.ssl_private_key:
-                if SSL is None:
-                    raise ImportError("You must install pyOpenSSL to use HTTPS.")
-                
-                # See http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/442473
-                ctx = SSL.Context(SSL.SSLv23_METHOD)
-                ctx.use_privatekey_file(self.ssl_private_key)
-                ctx.use_certificate_file(self.ssl_certificate)
-                self.socket = SSLConnection(ctx, self.socket)
-                self.populate_ssl_environ()
-            self.socket.bind(self.bind_addr)
-        
-        # Select the appropriate socket
@@ -665 +791 @@
-            # Get the correct address family for our host (allows IPv6 addresses)
-            host, port = self.bind_addr
+            flags = 0
+            if host == '':
+                # Despite the socket module docs, using '' does not
+                # allow AI_PASSIVE to work. Passing None instead
+                # returns '0.0.0.0' like we want. In other words:
+                #     host    AI_PASSIVE     result
+                #      ''         Y         192.168.x.y
+                #      ''         N         192.168.x.y
+                #     None        Y         0.0.0.0
+                #     None        N         127.0.0.1
+                host = None
+                flags = socket.AI_PASSIVE
-            try:
-                info = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
-
+, 0, flags
-            except socket.gaierror:
-                # Probably a DNS issue. Assume IPv4.
@@ -677 +815 @@
-            af, socktype, proto, canonname, sa = res
-            try:
-
+self.
-            except socket.error, msg:
-                if self.socket:
@@ -710 +848 @@
-                raise self.interrupt
-    
+    def bind(self, family, type, proto=0):
+        """Create (or recreate) the actual socket object."""
+        self.socket = socket.socket(family, type, proto)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+##        self.socket.setsockopt(socket.SOL_SOCKET, socket.TCP_NODELAY, 1)
+        if self.ssl_certificate and self.ssl_private_key:
+            if SSL is None:
+                raise ImportError("You must install pyOpenSSL to use HTTPS.")
+            
+            # See http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/442473
+            ctx = SSL.Context(SSL.SSLv23_METHOD)
+            ctx.use_privatekey_file(self.ssl_private_key)
+            ctx.use_certificate_file(self.ssl_certificate)
+            self.socket = SSLConnection(ctx, self.socket)
+            self.populate_ssl_environ()
+        self.socket.bind(self.bind_addr)
+    
-    def tick(self):
+        """Accept a new connection and put it on the Queue."""
-        try:
-            s, addr = self.socket.accept()
@@ -740 +896 @@
-        self.stop()
-        self._interrupt = interrupt
-
+
+
+
-    
-    def stop(self):
@@ -756 +914 @@
-                        raise
-                else:
+                    # Note that we're explicitly NOT using AI_PASSIVE,
+                    # here, because we want an actual IP to touch.
+                    # localhost won't work if we've bound to a public IP,
+                    # but it would if we bound to INADDR_ANY via host = ''.
-                    for res in socket.getaddrinfo(host, port, socket.AF_UNSPEC,
-                                                  socket.SOCK_STREAM):