cleemesser avatar cleemesser committed a3b1c83

bump to 0.8.x django 1.5 compat, python3, autoreload

Comments (0)

Files changed (8)

 I've added a few small improvements from my point of view: It doesn't require
 installing cherrypy separately. It uses the same port as the development server
 (8000) so I don't need to re-enter my testing url in my browser, and it works by
-default with OS's like Mac OS 10.6 and Ubuntu 10.04 which prefer binding
+default with OS's like Mac OS 10.6 and 10.8 and Ubuntu 10.04 which prefer binding
 localhost to an ip6 address.
 
 Feature list
 
 Planned features
 ----------------
-- serve static media automatically (see django 1.3 static files support)
-- improve autoreload of changed files during development
+- It would be nice allow to run without installing into INSTALLED_APPS so don't need to touch code cf. gunicorn_django
+- It would be nice to print out the requests in development mode (like runserver dose) using logging. Maybe do this with wsgi middleware?
 
 Requirements
 ------------
-To get started using the server, you need nothing outside of django itself and
+- django version 1.5. It might work with 1.3 or 1.4. It will not work fully with 1.2 or below. (see 0.6 series for that)
+
+To get started using the server, you need nothing outside of itself and
 the project code that you would like to serve up. However, for ssl support, you
 may need PyOpenSSL--though the new cherrypy server includes support for using the
 python built-in ssl module depending on which version of python you are using.
     
 from within your project directory. You'll see something like what's below::
 
-  Run this project in CherryPy's production quality http webserver.
-  Note that it's called wsgiserver but it is actually a complete http server.
+    CPWSGI_HELP = r"""
+      Run this project in CherryPy's production quality http webserver.
+      Note that it's called wsgiserver but it is actually a complete http server.
 
-    runwsgiserver [options] [wsgi settings] [stop]
+	runwsgiserver [options] [cpwsgi settings] [stop]
 
     Optional CherryPy server settings: (setting=value)
       host=HOSTNAME         hostname to listen on
 			    Defaults to www-data
       server_group=STRING   group to daemonized process
 			    Defaults to www-data
-      adminserve=True|False  Serve the django admin media automatically. Useful
-                             in development. Defaults to True so turn to False
-                             if  using in production.
+
+      staticserve=True|False|collectstatic]
+			    If True, serve the static files automatically using
+			    django.contrib.staticfiles like the builting django server.
+			    If staticserve=collectstatic, instead serve static files
+			    from a single directory at STATIC_ROOT. You need to run
+			    "manage.py collectstatic" first.
+			    Defaults to True.
+
+      adminserve=True|False  Deprecated. Has no effect. The admin is served if
+			     staticserve is active.
+
 
     Examples:
-      Run a "standard" CherryPy server server
+      Run a "standard" CherryPy wsgi server--good for local development
 	$ manage.py runwsgiserver
 
       Run a CherryPy server on port 80
-    $ manage.py runwsgiserver port=80
+	$ manage.py runwsgiserver port=80
 
-  Run a CherryPy server as a daemon and write the spawned PID in a file
-    $ manage.py runwsgiserver daemonize=true pidfile=/var/run/django-cpwsgi.pid
+      Run a CherryPy server as a daemon and write the spawned PID in a file, don't serve staticfiles or autoreload
+	$ manage.py runwsgiserver daemonize=true pidfile=/var/run/django-cpwsgi.pid autoreload=False staticserve=False
 
       Run a CherryPy server using ssl with test certificates located in /tmp
-    $ manage.py runwsgiserver ssl_certificate=/tmp/testserver.crt ssl_private_key=/tmp/testserver.key
+	$ manage.py runwsgiserver ssl_certificate=/tmp/testserver.crt ssl_private_key=/tmp/testserver.key
+
+      Run the wsgi server but serve all the static files from a single collected file tree
+	$ manage.py collectstatic    # collects all the static files to STATIC_ROOT
+	$ manage.py runwsgiserver staticserve=collectstatic
+
 
 
 Notes
 To do
 -----
 - I should probably just add a switch to allow use of the native cherrypy install
-- Consider other server backends: tornado, uwsgi
+- Consider comparisons to other server backends: tornado, uwsgi, gunicorn
 - further security tests
 - add shell command that will serve a django project in a default way without needing to alter settings.py to add to INSTALLED_APPS
 - ? add ability to printout requests like django built in runserver (cf. django-odeon)
 
 Changelog
 ---------
-- 0.7.0 target django 1.3
+- 0.8.0 target django 1.5+, python 2.6, 2.7, and 3.2+
+        - add autoreload as default
+	- serve static files correctly
+
+- 0.7.0 target django 1.3 -- not released -- 
         added support for serving static files directory by default if
 	STATICFILES_ROOT is defined. Added more tests: ssl, staticfiles and
 	started to document them.  Experimental: STATICFILES_DIRS during
-	development to avoid needing to collect all files. Added django-odeon's
-	patch to wsgiserver to make it robust to illegal header lines
+	development to avoid needing to collect all files.
+	- Added django-odeon's patch to wsgiserver to make it robust to illegal header lines
+	
 - 0.6.10 add path for django.contrib.admin to address issue #5,#6
 - 0.6.9 typo fix
 - 0.6.8 Changed name of bitbucket repo to django-wsgiserver to match it's pypi name

django_wsgiserver/management/commands/runwsgiserver.py

 
 
 import logging, sys, os, signal, time, errno
+from datetime import datetime
+from pprint import (pprint, pformat)
+logger = logging.getLogger('django')
 from socket import gethostname
 from django.core.management.base import BaseCommand
 from django_wsgiserver import mediahandler
-import django.contrib.admin # used to find where admin media is in filesystem
 
 CPWSGI_HELP = r"""
   Run this project in CherryPy's production quality http webserver.
                         Defaults to www-data
   server_group=STRING   group to daemonized process
                         Defaults to www-data
-  adminserve=True|False  Serve the django admin media automatically. Useful
-                         in development. Defaults to True so turn to False
-                         if  using in production.
+
+  staticserve=True|False|collectstatic]
+                        If True, serve the static files automatically using
+                        django.contrib.staticfiles like the builting django server.
+                        If staticserve=collectstatic, instead serve static files
+                        from a single directory at STATIC_ROOT. You need to run
+                        "manage.py collectstatic" first.
+                        Defaults to True.
+
+  adminserve=True|False  Deprecated. Has no effect. The admin is served if
+                         staticserve is active.
+
 
 Examples:
-  Run a "standard" CherryPy wsgi server
+  Run a "standard" CherryPy wsgi server--good for local development
     $ manage.py runwsgiserver
 
   Run a CherryPy server on port 80
     $ manage.py runwsgiserver port=80
 
-  Run a CherryPy server as a daemon and write the spawned PID in a file
-    $ manage.py runwsgiserver daemonize=true pidfile=/var/run/django-cpwsgi.pid
+  Run a CherryPy server as a daemon and write the spawned PID in a file, don't serve staticfiles or autoreload
+    $ manage.py runwsgiserver daemonize=true pidfile=/var/run/django-cpwsgi.pid autoreload=False staticserve=False
   
   Run a CherryPy server using ssl with test certificates located in /tmp
     $ manage.py runwsgiserver ssl_certificate=/tmp/testserver.crt ssl_private_key=/tmp/testserver.key
 
+  Run the wsgi server but serve all the static files from a single collected file tree
+    $ manage.py collectstatic    # collects all the static files to STATIC_ROOT
+    $ manage.py runwsgiserver staticserve=collectstatic
+
 """
 
+
 CPWSGI_OPTIONS = {
 'host': '127.0.0.1', # changed from localhost to avoid ip6 problem -clm
 'port': 8000,   # changed from 8088 to 8000 to follow django devserver default
 'ssl_certificate': None,
 'ssl_private_key': None,
 # options useful for development - should these all be true by default or off by default?
-'autoreload' : False,
-'adminserve' : True,  # please serve the admin media too by default
+'autoreload' : True,
+'adminserve' : 'Deprecated',  
 'staticserve' : True, # serve static
 'servestaticdirs': True, # will use STATICFILES_DIRS and actuall serve each directory so
                           # you don't need to collect them all in development
 }
 
-
-class Command(BaseCommand):
-    help = "CherryPy Server for project. Requires CherryPy."
-    args = "[various KEY=val options, use `runwsgiserver help` for help]"
-
-    def handle(self, *args, **options):
-        from django.conf import settings
-        from django.utils import translation
-        # Activate the current language, because it won't get activated later.
-        try:
-            translation.activate(settings.LANGUAGE_CODE)
-        except AttributeError:
-            pass
-        runwsgiserver(args)
-        
-    def usage(self, subcommand):
-        return CPWSGI_HELP
-
 def change_uid_gid(uid, gid=None):
     """Try to change UID and GID to the provided values.
     UID and GID are given as names like 'nobody' not integer.
     #from cherrypy.wsgiserver import CherryPyWSGIServer
     from django.core.handlers.wsgi import WSGIHandler
     app = WSGIHandler()
-    if options['adminserve']: # serve the admin media too
-        # AdminMediaHandler is middleware for local use
-        import django.core.servers.basehttp
-        app = django.core.servers.basehttp.AdminMediaHandler(app)
+    # if options['adminserve']: # serve the admin media too
+    #     # AdminMediaHandler is middleware for local use
+    #     import django.core.servers.basehttp
+    #     app = django.core.servers.basehttp.AdminMediaHandler(app)
         
     server = CherryPyWSGIServer(
         (options['host'], int(options['port'])),
         server.ssl_certificate = options['ssl_certificate']
         server.ssl_private_key = options['ssl_private_key']  
     try:
+        logging.debug('starting server with options:\n%s' % pformat(options) )
         server.start()
     except KeyboardInterrupt:
         server.stop()
 
-def process_staticfiles_dirs(staticfiles_dirs, default_prefix='/static/'): # settings.STATIC_URL
+def process_staticfiles_dirs(staticfiles_dirs, default_prefix='/'): # settings.STATIC_URL
     """
     normalizes all elements of STATICFILES_DIRS to be of ('prefix','/root/path/to/files') form
     the prefix gets added after STATIC_URL
     return staticlocations
 
 
-def start_server_servestatic(options):
-    """
-    Start CherryPy server AND serve default static files
+class Command(BaseCommand):
+    help = "CherryPy Server for project."
+    args = "[various KEY=val options, use `runwsgiserver help` for help]"
 
-    Want SSL support?
-    a. The new (3.1 or 3.2) way: Just set server.ssl_adapter to an SSLAdapter instance.
-    b. The old way (deprecated way) is to set these attributes:
+    def handle(self, *args, **options):
+        from django.conf import settings
+        from django.utils import translation
+        # Activate the current language, because it won't get activated later.
+        try:
+            translation.activate(settings.LANGUAGE_CODE)
+        except AttributeError:
+            pass
+        self.runwsgiserver(args)
+        
+    def usage(self, subcommand):
+        return CPWSGI_HELP
 
-       server.ssl_certificate = <filename>
-       server.ssl_private_key = <filename>
+    def runwsgiserver(self, argset=[], **kwargs):
+        # Get the options
+        options = CPWSGI_OPTIONS.copy()
+        options.update(kwargs)
+        for x in argset:
+            if "=" in x:
+                k, v = x.split('=', 1)
+            else:
+                k, v = x, True
+            if v=='False' or v=='false':
+                v = False
+                # print "found false", v
+            options[k.lower()] = v
 
-       But this is the only way from the management command line
-       in the future I may need to adapt this to use a server.ssl_adapter
+        self.options = options
+        
+        if "help" in options:
+            print CPWSGI_HELP
+            return
 
-    """
-    # debug
-    # print "options:"
-    from pprint import pprint; pprint(options)
-    
-    if options['daemonize'] and options['server_user'] and options['server_group']:
-        #ensure the that the daemon runs as specified user
-        change_uid_gid(options['server_user'], options['server_group'])
-    
-    from django_wsgiserver.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
-    #from cherrypy.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
-    from django.core.handlers.wsgi import WSGIHandler
-    from django.conf import settings
-    app = WSGIHandler()
-    path = { '/': app}
-    if options['adminserve']: # serve the admin media too
-        # AdminMediaHandler is middleware for local use
-        #import django.core.servers.basehttp
-        #adminapp = django.core.servers.basehttp.AdminMediaHandler(app)
-        # another way to serve the admin media three application
-        import django.contrib.admin
-        path[settings.ADMIN_MEDIA_PREFIX] = mediahandler.MediaHandler(        
-            os.path.join( django.contrib.admin.__path__[0], 'media'))
+        if "stop" in options:
+            stop_server(options['pidfile'])
+            return True
 
-    if options['staticserve']:
+        if options['daemonize']:
+            if not options['pidfile']:
+                options['pidfile'] = '/var/run/cpwsgi_%s.pid' % options['port']
+            stop_server(options['pidfile'])     
+
+            from django.utils.daemonize import become_daemon
+            if options['workdir']:
+                become_daemon(our_home_dir=options['workdir'])
+            else:
+                become_daemon()
+
+            fp = open(options['pidfile'], 'w')
+            fp.write("%d\n" % os.getpid())
+            fp.close()
+
+        # autoreload is not implemented see cherrypy.process.autoreload or the django runserver
+        if options['autoreload']:
+            import django.utils.autoreload
+            django.utils.autoreload.main(self.start_server_servestatic, (options,))
+        else:
+            # Start the webserver
+            logging.info('starting server with options:\n%s' % pformat(options) )
+            self.start_server_servestatic(options)
+
+
+    def start_server_servestatic(self, options):
+        """
+        Start CherryPy server AND serve default static files
+
+        Want SSL support?
+        a. The new (3.1 or 3.2) way: Just set server.ssl_adapter to an SSLAdapter instance.
+        b. The old way (deprecated way) is to set these attributes:
+
+           server.ssl_certificate = <filename>
+           server.ssl_private_key = <filename>
+
+           But this is the only way from the management command line
+           in the future I may need to adapt this to use a server.ssl_adapter
+
+        """
+        # debug?
+        # print "options:"
+        from django.conf import settings
+        quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
+
+        self.stdout.write("Validating models..")
+        self.validate(display_num_errors=True)
+        self.stdout.write((
+                "%(started_at)s\n"
+                "Django version %(version)s, using settings %(settings)r\n"
+                "cherrypy django_wsgiserver is running at http://%(addr)s:%(port)s/\n"
+                "Quit the server with %(quit_command)s.\n"
+            ) % {
+                "started_at": datetime.now().strftime('%B %d, %Y - %X'),
+                "version": self.get_version(),
+                "settings": settings.SETTINGS_MODULE,
+                "addr": options['host'], # self._raw_ipv6 and '[%s]' % self.addr or self.addr,
+                "port": options['port'],
+                "quit_command": quit_command,
+            })
+
+        #logger.info("launching wsgiserver with the following options")
+        #logger.info(pformat(options))
+        self.stdout.write("launching with the following options:\n")
+        self.stdout.write(pformat(options))
+
+        if options['daemonize'] and options['server_user'] and options['server_group']:
+            #ensure the that the daemon runs as specified user
+            change_uid_gid(options['server_user'], options['server_group'])
+
+        from django_wsgiserver.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
+        #from cherrypy.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
+
+        from django.core.handlers.wsgi import WSGIHandler
+        from django.conf import settings
+        app = WSGIHandler()  # serve the django content
+        path = { '/': app}  # well will build up the serving url routing path below
+
+        # Now work on serving the static content
+        # note as of django 1.4, ADMIN_MEDIA_PREFIX is depreciated and instead uses django.contrib.staticfiles
+        # so it is not an error for ADMIN_MEDIA_PREFIX to not be defined, I will test to see if exists
+        # and print a warning that adminserve is activated but it's not defined.
+        # so for django 1.4 (or 1.5 ?) staticserve=True => adminserve=True
+        # so the choices
+        # There are basically two ways for statics to be served
+        # 1. in development, one often wants each application's static files to be served from within its file structure
+        #    this is what the django runserver dose
+        # 2. in production usually, all the static files are collected into a common storage region (files, S3, CDN) and a good webserver
+        #    serve them from there
+
+        # deprecated
+        # if options['adminserve']: # serve the admin media too 
+        #     # AdminMediaHandler is middleware for local use
+        #     #import django.core.servers.basehttp
+        #     #adminapp = django.core.servers.basehttp.AdminMediaHandler(app)
+        #     # another way to serve the admin media three application
+        #     if settings.__dict__.has_key('ADMIN_MEDIA_PREFIX'):
+        #         import django.contrib.admin
+
+        #         path[settings.ADMIN_MEDIA_PREFIX] = mediahandler.MediaHandler(        
+        #             os.path.join( django.contrib.admin.__path__[0], 'media'))
+        #     else:
+        #         print "Warning adminserve was selected BUT ADMIN_MEDIA_PREFIX was not defined"
+
+        if options['staticserve']:
+            try:
+                if not settings.STATIC_URL or not settings.STATIC_ROOT:
+                    # could use misconfigured exception (what is this in django)  instead of AttributeError
+                    raise AttributeError, "settings.STATIC_URL = %s, settings.STATIC_ROOT=%s" % (repr(settings.STATIC_URL),
+                                                                                                 repr(settings.STATIC_ROOT)) 
+            except AttributeError, msg:
+                logger.error(msg)
+                logger.error("****")
+                logger.error("STATIC_URL and STATIC_ROOT  must be set in settings file")
+                logger.error("****")
+                raise
+
+            if options['staticserve'] != 'collectstatic':
+                if settings.STATICFILES_FINDERS: # find the apps' static files and add them to the path
+                    logger.debug("see settings.STATICFILES_FINDERS")
+                    logger.debug(pformat (settings.STATICFILES_FINDERS))
+                    from django.contrib.staticfiles.finders import AppDirectoriesFinder
+                    app_static_finder=AppDirectoriesFinder(settings.INSTALLED_APPS)
+                    logger.debug("app_static_finder.storages:")
+                    logger.debug(pformat(app_static_finder.storages))
+                    for key,val in app_static_finder.storages.items():
+                        logger.debug(key, " static location:", val.location)
+                    # need to decide what to do with this in terms of the fusion of the app static directories
+                        app_url=key.split('.')[-1] + r'/' # I'm not sure if it needs the end '/'
+                        full_static_url = os.path.join(settings.STATIC_URL,app_url)
+                        full_dir_location = os.path.join(val.location,app_url)
+                        logger.debug(full_static_url, full_dir_location)
+                        path[full_static_url] = mediahandler.MediaHandler(full_dir_location)
+
+
+            if options['servestaticdirs'] and hasattr(settings, 'STATICFILES_DIRS'):
+                staticlocations = process_staticfiles_dirs(settings.STATICFILES_DIRS)
+                # debug !!!
+                logger.debug("staticlocations::"); logger.debug(pformat(staticlocations))
+                for urlprefix, root in staticlocations:
+                    path[os.path.join(settings.STATIC_URL, urlprefix)] =  mediahandler.MediaHandler(root)
+
+            # One important thing is that there are two different ways to serve the static files
+            # 1. convenient: serve each app's static files (assuming they follow convention)
+            # 2. do a collectstatic and serve from that node -- likely this would be done more in a "production" scenario
+
+            if options['staticserve'] == 'collectstatic':
+                # and serve the root of the STATIC_URL ? hmm !!!
+                path[settings.STATIC_URL] = mediahandler.MediaHandler(settings.STATIC_ROOT)
+                logger.warning("serving all static files from %s. *** Make sure you have done a fresh collectstatic operation ***" % settings.STATIC_ROOT)
+
+        # debug
+        logger.debug("path:", pformat(path))
+        dispatcher =  WSGIPathInfoDispatcher( path )
+        logger.debug("apps:", pformat(dispatcher.apps))
+
+        server = CherryPyWSGIServer(
+            (options['host'], int(options['port'])),
+            dispatcher,
+            int(options['threads']), 
+            options['server_name']
+        )
+        if options['ssl_certificate'] and options['ssl_private_key']:
+            server.ssl_certificate = options['ssl_certificate']
+            server.ssl_private_key = options['ssl_private_key']  
         try:
-            if settings.STATIC_URL:
-                path[settings.STATIC_URL] = mediahandler.MediaHandler(settings.STATIC_ROOT)
-            else:
-                print "****"
-                print "STATIC_URL and STATIC_ROOT  must be set in settings file if wsgiserver option staticserve is set to True"
-                print "****"
+            server.start()
+        except KeyboardInterrupt:
+            server.stop()
 
-        except AttributeError, msg:
-            print msg
-            print "****"
-            print "STATIC_URL and STATIC_ROOT  must be set in settings file"
-            print "****"
-            raise
+        
 
-        if settings.STATICFILES_FINDERS:
-            # debug
-            print "see settings.STATICFILES_FINDERS"
-            pprint (settings.STATICFILES_FINDERS)
-            from django.contrib.staticfiles.finders import AppDirectoriesFinder
-            app_static_finder=AppDirectoriesFinder(settings.INSTALLED_APPS)
-            print "app_static_finder.storages:"
-            pprint(app_static_finder.storages)
-            for key,val in app_static_finder.storages.items():
-                print key, " static location:", val.location
-            # need to decide what to do with this in terms of the fusion of the app static directories
-                
-                 
-        if options['servestaticdirs'] and hasattr(settings, 'STATICFILES_DIRS'):
-            staticlocations = process_staticfiles_dirs(settings.STATICFILES_DIRS)
-            # debug !!!
-            from pprint import pprint; print "staticlocations:"; pprint(staticlocations)
-            for urlprefix, root in staticlocations:
-                path[os.path.join(settings.STATIC_URL, urlprefix)] =  mediahandler.MediaHandler(root)
 
-    # debug
-    from pprint import pprint; print "apps:"; pprint(path)
-    dispatcher =  WSGIPathInfoDispatcher( path )
-        
-    server = CherryPyWSGIServer(
-        (options['host'], int(options['port'])),
-        dispatcher,
-        int(options['threads']), 
-        options['server_name']
-    )
-    if options['ssl_certificate'] and options['ssl_private_key']:
-        server.ssl_certificate = options['ssl_certificate']
-        server.ssl_private_key = options['ssl_private_key']  
-    try:
-        server.start()
-    except KeyboardInterrupt:
-        server.stop()
 
-def runwsgiserver(argset=[], **kwargs):
-    # Get the options
-    options = CPWSGI_OPTIONS.copy()
-    options.update(kwargs)
-    for x in argset:
-        if "=" in x:
-            k, v = x.split('=', 1)
-        else:
-            k, v = x, True
-        if v=='False' or v=='false':
-            v = False
-            # print "found false", v
-        options[k.lower()] = v
-        
-    if "help" in options:
-        print CPWSGI_HELP
-        return
-        
-    if "stop" in options:
-        stop_server(options['pidfile'])
-        return True
-    
-    if options['daemonize']:
-        if not options['pidfile']:
-            options['pidfile'] = '/var/run/cpwsgi_%s.pid' % options['port']
-        stop_server(options['pidfile'])     
-       
-        from django.utils.daemonize import become_daemon
-        if options['workdir']:
-            become_daemon(our_home_dir=options['workdir'])
-        else:
-            become_daemon()
-
-        fp = open(options['pidfile'], 'w')
-        fp.write("%d\n" % os.getpid())
-        fp.close()
-    if options['autoreload']:
-        import autoreload
-        autoreload.run()
-    
-    # Start the webserver
-    print 'starting server with options %s' % options
-    start_server_servestatic(options)
-
-
-if __name__ == '__main__':
-    runwsgiserver(sys.argv[1:])

django_wsgiserver/mediahandler.py

     def __call__( self, environ, start_response ):
 
         def done( status, headers, output ):
+            # a good place for debug loging 
+            # e.g. logger.debug('done from self.media_root: %s' %self.media_root, status, headers)
             start_response( status, headers.items() )
             return output
 
         # because the files are only read off disk for the first request
         # (assuming the browser/client supports conditional GET).
 
-        mtime = http_date( os.stat(file_path)[stat.ST_MTIME] )
+        # mtime needs to be ascii not unicode as django is all unicode need to do conversion
+        mtime = http_date( os.stat(file_path)[stat.ST_MTIME] ).encode('ascii', 'ignore') 
         headers = {'Last-Modified': mtime}
         if environ.get('HTTP_IF_MODIFIED_SINCE', None) == mtime:
             status = '304 NOT MODIFIED'
             if mime_type:
                 headers['Content-Type'] = mime_type
 
-            #output = [fp.read()]
+            # naive version with whole file read as a string place in a list
+            # output = [fp.read()]
             # fp.close()
+            # use BlockIterator for larger file/network efficiency
             output = BlockIterator(fp)
             
         return done( status, headers, output )

django_wsgiserver/wsgiserver/__init__.py

-"""A high-speed, production ready, thread pooled, generic HTTP server.
+__all__ = ['HTTPRequest', 'HTTPConnection', 'HTTPServer',
+           'SizeCheckWrapper', 'KnownLengthRFile', 'ChunkedRFile',
+           'MaxSizeExceeded', 'NoSSLError', 'FatalSSLAlert',
+           'WorkerThread', 'ThreadPool', 'SSLAdapter',
+           'CherryPyWSGIServer',
+           'Gateway', 'WSGIGateway', 'WSGIGateway_10', 'WSGIGateway_u0',
+           'WSGIPathInfoDispatcher', 'get_ssl_adapter_class']
 
-Simplest example on how to use this module directly
-(without using CherryPy's application machinery):
-
-    from cherrypy import wsgiserver
-    
-    def my_crazy_app(environ, start_response):
-        status = '200 OK'
-        response_headers = [('Content-type','text/plain')]
-        start_response(status, response_headers)
-        return ['Hello world!\n']
-    
-    server = wsgiserver.CherryPyWSGIServer(
-                ('0.0.0.0', 8070), my_crazy_app,
-                server_name='www.cherrypy.example')
-    
-The CherryPy WSGI server can serve as many WSGI applications 
-as you want in one instance by using a WSGIPathInfoDispatcher:
-    
-    d = WSGIPathInfoDispatcher({'/': my_crazy_app, '/blog': my_blog_app})
-    server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', 80), d)
-    
-Want SSL support? Just set server.ssl_adapter to an SSLAdapter instance.
-
-This won't call the CherryPy engine (application side) at all, only the
-HTTP server, which is independent from the rest of CherryPy. Don't
-let the name "CherryPyWSGIServer" throw you; the name merely reflects
-its origin, not its coupling.
-
-For those of you wanting to understand internals of this module, here's the
-basic call flow. The server's listening thread runs a very tight loop,
-sticking incoming connections onto a Queue:
-
-    server = CherryPyWSGIServer(...)
-    server.start()
-    while True:
-        tick()
-        # This blocks until a request comes in:
-        child = socket.accept()
-        conn = HTTPConnection(child, ...)
-        server.requests.put(conn)
-
-Worker threads are kept in a pool and poll the Queue, popping off and then
-handling each connection in turn. Each connection can consist of an arbitrary
-number of requests and their responses, so we run a nested loop:
-
-    while True:
-        conn = server.requests.get()
-        conn.communicate()
-        ->  while True:
-                req = HTTPRequest(...)
-                req.parse_request()
-                ->  # Read the Request-Line, e.g. "GET /page HTTP/1.1"
-                    req.rfile.readline()
-                    read_headers(req.rfile, req.inheaders)
-                req.respond()
-                ->  response = app(...)
-                    try:
-                        for chunk in response:
-                            if chunk:
-                                req.write(chunk)
-                    finally:
-                        if hasattr(response, "close"):
-                            response.close()
-                if req.close_connection:
-                    return
-"""
-
-CRLF = '\r\n'
-import os
-import Queue
-import re
-quoted_slash = re.compile("(?i)%2F")
-import rfc822
-import socket
 import sys
-if 'win' in sys.platform and not hasattr(socket, 'IPPROTO_IPV6'):
-    socket.IPPROTO_IPV6 = 41
-try:
-    import cStringIO as StringIO
-except ImportError:
-    import StringIO
-
-_fileobject_uses_str_type = isinstance(socket._fileobject(None)._rbuf, basestring)
-
-import threading
-import time
-import traceback
-from urllib import unquote
-from urlparse import urlparse
-import warnings
-
-import errno
-
-def plat_specific_errors(*errnames):
-    """Return error numbers for all errors in errnames on this platform.
-    
-    The 'errno' module contains different global constants depending on
-    the specific platform (OS). This function will return the list of
-    numeric values for a given list of potential names.
-    """
-    errno_names = dir(errno)
-    nums = [getattr(errno, k) for k in errnames if k in errno_names]
-    # de-dupe the list
-    return dict.fromkeys(nums).keys()
-
-socket_error_eintr = plat_specific_errors("EINTR", "WSAEINTR")
-
-socket_errors_to_ignore = plat_specific_errors(
-    "EPIPE",
-    "EBADF", "WSAEBADF",
-    "ENOTSOCK", "WSAENOTSOCK",
-    "ETIMEDOUT", "WSAETIMEDOUT",
-    "ECONNREFUSED", "WSAECONNREFUSED",
-    "ECONNRESET", "WSAECONNRESET",
-    "ECONNABORTED", "WSAECONNABORTED",
-    "ENETRESET", "WSAENETRESET",
-    "EHOSTDOWN", "EHOSTUNREACH",
-    )
-socket_errors_to_ignore.append("timed out")
-socket_errors_to_ignore.append("The read operation timed out")
-
-socket_errors_nonblocking = plat_specific_errors(
-    'EAGAIN', 'EWOULDBLOCK', 'WSAEWOULDBLOCK')
-
-comma_separated_headers = ['Accept', 'Accept-Charset', 'Accept-Encoding',
-    'Accept-Language', 'Accept-Ranges', 'Allow', 'Cache-Control',
-    'Connection', 'Content-Encoding', 'Content-Language', 'Expect',
-    'If-Match', 'If-None-Match', 'Pragma', 'Proxy-Authenticate', 'TE',
-    'Trailer', 'Transfer-Encoding', 'Upgrade', 'Vary', 'Via', 'Warning',
-    'WWW-Authenticate']
-
-
-def read_headers(rfile, hdict=None):
-    """Read headers from the given stream into the given header dict.
-    
-    If hdict is None, a new header dict is created. Returns the populated
-    header dict.
-    
-    Headers which are repeated are folded together using a comma if their
-    specification so dictates.
-    
-    This function raises ValueError when the read bytes violate the HTTP spec.
-    You should probably return "400 Bad Request" if this happens.
-    """
-    if hdict is None:
-        hdict = {}
-    
-    while True:
-        line = rfile.readline()
-        if not line:
-            # No more data--illegal end of headers
-            raise ValueError("Illegal end of headers.")
-        
-        if line == CRLF:
-            # Normal end of headers
-            break
-        if not line.endswith(CRLF):
-            raise ValueError("HTTP requires CRLF terminators")
-        
-        if line[0] in ' \t':
-            # It's a continuation line.
-            v = line.strip()
-        else:
-            try:
-                k, v = line.split(":", 1)
-            except ValueError:
-                # raise ValueError("Illegal header line.")
-                print "Illegal header line" # add loging
-                continue 
-            # TODO: what about TE and WWW-Authenticate?
-            k = k.strip().title()
-            v = v.strip()
-            hname = k
-        
-        if k in comma_separated_headers:
-            existing = hdict.get(hname)
-            if existing:
-                v = ", ".join((existing, v))
-        hdict[hname] = v
-    
-    return hdict
-
-
-class MaxSizeExceeded(Exception):
-    pass
-
-class SizeCheckWrapper(object):
-    """Wraps a file-like object, raising MaxSizeExceeded if too large."""
-    
-    def __init__(self, rfile, maxlen):
-        self.rfile = rfile
-        self.maxlen = maxlen
-        self.bytes_read = 0
-    
-    def _check_length(self):
-        if self.maxlen and self.bytes_read > self.maxlen:
-            raise MaxSizeExceeded()
-    
-    def read(self, size=None):
-        data = self.rfile.read(size)
-        self.bytes_read += len(data)
-        self._check_length()
-        return data
-    
-    def readline(self, size=None):
-        if size is not None:
-            data = self.rfile.readline(size)
-            self.bytes_read += len(data)
-            self._check_length()
-            return data
-        
-        # User didn't specify a size ...
-        # We read the line in chunks to make sure it's not a 100MB line !
-        res = []
-        while True:
-            data = self.rfile.readline(256)
-            self.bytes_read += len(data)
-            self._check_length()
-            res.append(data)
-            # See http://www.cherrypy.org/ticket/421
-            if len(data) < 256 or data[-1:] == "\n":
-                return ''.join(res)
-    
-    def readlines(self, sizehint=0):
-        # Shamelessly stolen from StringIO
-        total = 0
-        lines = []
-        line = self.readline()
-        while line:
-            lines.append(line)
-            total += len(line)
-            if 0 < sizehint <= total:
-                break
-            line = self.readline()
-        return lines
-    
-    def close(self):
-        self.rfile.close()
-    
-    def __iter__(self):
-        return self
-    
-    def next(self):
-        data = self.rfile.next()
-        self.bytes_read += len(data)
-        self._check_length()
-        return data
-
-
-class KnownLengthRFile(object):
-    """Wraps a file-like object, returning an empty string when exhausted."""
-    
-    def __init__(self, rfile, content_length):
-        self.rfile = rfile
-        self.remaining = content_length
-    
-    def read(self, size=None):
-        if self.remaining == 0:
-            return ''
-        if size is None:
-            size = self.remaining
-        else:
-            size = min(size, self.remaining)
-        
-        data = self.rfile.read(size)
-        self.remaining -= len(data)
-        return data
-    
-    def readline(self, size=None):
-        if self.remaining == 0:
-            return ''
-        if size is None:
-            size = self.remaining
-        else:
-            size = min(size, self.remaining)
-        
-        data = self.rfile.readline(size)
-        self.remaining -= len(data)
-        return data
-    
-    def readlines(self, sizehint=0):
-        # Shamelessly stolen from StringIO
-        total = 0
-        lines = []
-        line = self.readline(sizehint)
-        while line:
-            lines.append(line)
-            total += len(line)
-            if 0 < sizehint <= total:
-                break
-            line = self.readline(sizehint)
-        return lines
-    
-    def close(self):
-        self.rfile.close()
-    
-    def __iter__(self):
-        return self
-    
-    def __next__(self):
-        data = next(self.rfile)
-        self.remaining -= len(data)
-        return data
-
-
-class MaxSizeExceeded(Exception):
-    pass
-
-
-class ChunkedRFile(object):
-    """Wraps a file-like object, returning an empty string when exhausted.
-    
-    This class is intended to provide a conforming wsgi.input value for
-    request entities that have been encoded with the 'chunked' transfer
-    encoding.
-    """
-    
-    def __init__(self, rfile, maxlen, bufsize=8192):
-        self.rfile = rfile
-        self.maxlen = maxlen
-        self.bytes_read = 0
-        self.buffer = ''
-        self.bufsize = bufsize
-        self.closed = False
-    
-    def _fetch(self):
-        if self.closed:
-            return
-        
-        line = self.rfile.readline()
-        self.bytes_read += len(line)
-        
-        if self.maxlen and self.bytes_read > self.maxlen:
-            raise MaxSizeExceeded("Request Entity Too Large", self.maxlen)
-        
-        line = line.strip().split(";", 1)
-        
-        try:
-            chunk_size = line.pop(0)
-            chunk_size = int(chunk_size, 16)
-        except ValueError:
-            raise ValueError("Bad chunked transfer size: " + repr(chunk_size))
-        
-        if chunk_size <= 0:
-            self.closed = True
-            return
-        
-##            if line: chunk_extension = line[0]
-        
-        if self.maxlen and self.bytes_read + chunk_size > self.maxlen:
-            raise IOError("Request Entity Too Large")
-        
-        chunk = self.rfile.read(chunk_size)
-        self.bytes_read += len(chunk)
-        self.buffer += chunk
-        
-        crlf = self.rfile.read(2)
-        if crlf != CRLF:
-            raise ValueError(
-                 "Bad chunked transfer coding (expected '\\r\\n', "
-                 "got " + repr(crlf) + ")")
-    
-    def read(self, size=None):
-        data = ''
-        while True:
-            if size and len(data) >= size:
-                return data
-            
-            if not self.buffer:
-                self._fetch()
-                if not self.buffer:
-                    # EOF
-                    return data
-            
-            if size:
-                remaining = size - len(data)
-                data += self.buffer[:remaining]
-                self.buffer = self.buffer[remaining:]
-            else:
-                data += self.buffer
-    
-    def readline(self, size=None):
-        data = ''
-        while True:
-            if size and len(data) >= size:
-                return data
-            
-            if not self.buffer:
-                self._fetch()
-                if not self.buffer:
-                    # EOF
-                    return data
-            
-            newline_pos = self.buffer.find('\n')
-            if size:
-                if newline_pos == -1:
-                    remaining = size - len(data)
-                    data += self.buffer[:remaining]
-                    self.buffer = self.buffer[remaining:]
-                else:
-                    remaining = min(size - len(data), newline_pos)
-                    data += self.buffer[:remaining]
-                    self.buffer = self.buffer[remaining:]
-            else:
-                if newline_pos == -1:
-                    data += self.buffer
-                else:
-                    data += self.buffer[:newline_pos]
-                    self.buffer = self.buffer[newline_pos:]
-    
-    def readlines(self, sizehint=0):
-        # Shamelessly stolen from StringIO
-        total = 0
-        lines = []
-        line = self.readline(sizehint)
-        while line:
-            lines.append(line)
-            total += len(line)
-            if 0 < sizehint <= total:
-                break
-            line = self.readline(sizehint)
-        return lines
-    
-    def read_trailer_lines(self):
-        if not self.closed:
-            raise ValueError(
-                "Cannot read trailers until the request body has been read.")
-        
-        while True:
-            line = self.rfile.readline()
-            if not line:
-                # No more data--illegal end of headers
-                raise ValueError("Illegal end of headers.")
-            
-            self.bytes_read += len(line)
-            if self.maxlen and self.bytes_read > self.maxlen:
-                raise IOError("Request Entity Too Large")
-            
-            if line == CRLF:
-                # Normal end of headers
-                break
-            if not line.endswith(CRLF):
-                raise ValueError("HTTP requires CRLF terminators")
-            
-            yield line
-    
-    def close(self):
-        self.rfile.close()
-    
-    def __iter__(self):
-        # Shamelessly stolen from StringIO
-        total = 0
-        line = self.readline(sizehint)
-        while line:
-            yield line
-            total += len(line)
-            if 0 < sizehint <= total:
-                break
-            line = self.readline(sizehint)
-
-
-class HTTPRequest(object):
-    """An HTTP Request (and response).
-    
-    A single HTTP connection may consist of multiple request/response pairs.
-    
-    server: the Server object which is receiving this request.
-    conn: the HTTPConnection object on which this request connected.
-    
-    inheaders: a dict of request headers.
-    outheaders: a list of header tuples to write in the response.
-    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, server, conn):
-        self.server= server
-        self.conn = conn
-        
-        self.ready = False
-        self.started_request = False
-        self.scheme = "http"
-        if self.server.ssl_adapter is not None:
-            self.scheme = "https"
-        # Use the lowest-common protocol in case read_request_line errors.
-        self.response_protocol = 'HTTP/1.0'
-        self.inheaders = {}
-        
-        self.status = ""
-        self.outheaders = []
-        self.sent_headers = False
-        self.close_connection = False
-        self.chunked_read = False
-        self.chunked_write = False
-    
-    def parse_request(self):
-        """Parse the next HTTP request start-line and message-headers."""
-        self.rfile = SizeCheckWrapper(self.conn.rfile,
-                                      self.server.max_request_header_size)
-        try:
-            self.read_request_line()
-        except MaxSizeExceeded:
-            self.simple_response("414 Request-URI Too Long",
-                "The Request-URI sent with the request exceeds the maximum "
-                "allowed bytes.")
-            return
-        
-        try:
-            success = self.read_request_headers()
-        except MaxSizeExceeded:
-            self.simple_response("413 Request Entity Too Large",
-                "The headers sent with the request exceed the maximum "
-                "allowed bytes.")
-            return
-        else:
-            if not success:
-                return
-        
-        self.ready = True
-    
-    def read_request_line(self):
-        # HTTP/1.1 connections are persistent by default. If a client
-        # requests a page, then idles (leaves the connection open),
-        # then rfile.readline() will raise socket.error("timed out").
-        # Note that it does this based on the value given to settimeout(),
-        # and doesn't need the client to request or acknowledge the close
-        # (although your TCP stack might suffer for it: cf Apache's history
-        # with FIN_WAIT_2).
-        request_line = self.rfile.readline()
-        
-        # Set started_request to True so communicate() knows to send 408
-        # from here on out.
-        self.started_request = True
-        if not request_line:
-            # Force self.ready = False so the connection will close.
-            self.ready = False
-            return
-        
-        if request_line == CRLF:
-            # 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
-        
-        if not request_line.endswith(CRLF):
-            self.simple_response("400 Bad Request", "HTTP requires CRLF terminators")
-            return
-        
-        try:
-            method, uri, req_protocol = request_line.strip().split(" ", 2)
-        except ValueError:
-            self.simple_response("400 Bad Request", "Malformed Request-Line")
-            return
-        
-        self.uri = uri
-        self.method = method
-        
-        # uri may be an abs_path (including "http://host.domain.tld");
-        scheme, authority, path = self.parse_request_uri(uri)
-        if '#' in path:
-            self.simple_response("400 Bad Request",
-                                 "Illegal #fragment in Request-URI.")
-            return
-        
-        if scheme:
-            self.scheme = scheme
-        
-        qs = ''
-        if '?' in path:
-            path, qs = path.split('?', 1)
-        
-        # Unquote the path+params (e.g. "/this%20path" -> "/this path").
-        # http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2
-        #
-        # But note that "...a URI must be separated into its components
-        # before the escaped characters within those components can be
-        # safely decoded." http://www.ietf.org/rfc/rfc2396.txt, sec 2.4.2
-        # Therefore, "/this%2Fpath" becomes "/this%2Fpath", not "/this/path".
-        try:
-            atoms = [unquote(x) for x in quoted_slash.split(path)]
-        except ValueError, ex:
-            self.simple_response("400 Bad Request", ex.args[0])
-            return
-        path = "%2F".join(atoms)
-        self.path = path
-        
-        # Note that, like wsgiref and most other HTTP servers,
-        # we "% HEX HEX"-unquote the path but not the query string.
-        self.qs = qs
-        
-        # Compare request and server HTTP protocol versions, in case our
-        # server does not support the requested protocol. Limit our output
-        # to min(req, server). We want the following output:
-        #     request    server     actual written   supported response
-        #     protocol   protocol  response protocol    feature set
-        # a     1.0        1.0           1.0                1.0
-        # b     1.0        1.1           1.1                1.0
-        # c     1.1        1.0           1.0                1.0
-        # d     1.1        1.1           1.1                1.1
-        # Notice that, in (b), the response will be "HTTP/1.1" even though
-        # the client only understands 1.0. RFC 2616 10.5.6 says we should
-        # only return 505 if the _major_ version is different.
-        rp = int(req_protocol[5]), int(req_protocol[7])
-        sp = int(self.server.protocol[5]), int(self.server.protocol[7])
-        
-        if sp[0] != rp[0]:
-            self.simple_response("505 HTTP Version Not Supported")
-            return
-        self.request_protocol = req_protocol
-        self.response_protocol = "HTTP/%s.%s" % min(rp, sp)
-    
-    def read_request_headers(self):
-        """Read self.rfile into self.inheaders. Return success."""
-        
-        # then all the http headers
-        try:
-            read_headers(self.rfile, self.inheaders)
-        except ValueError, ex:
-            self.simple_response("400 Bad Request", ex.args[0])
-            return False
-        
-        mrbs = self.server.max_request_body_size
-        if mrbs and int(self.inheaders.get("Content-Length", 0)) > mrbs:
-            self.simple_response("413 Request Entity Too Large",
-                "The entity sent with the request exceeds the maximum "
-                "allowed bytes.")
-            return False
-        
-        # Persistent connection support
-        if self.response_protocol == "HTTP/1.1":
-            # Both server and client are HTTP/1.1
-            if self.inheaders.get("Connection", "") == "close":
-                self.close_connection = True
-        else:
-            # Either the server or client (or both) are HTTP/1.0
-            if self.inheaders.get("Connection", "") != "Keep-Alive":
-                self.close_connection = True
-        
-        # Transfer-Encoding support
-        te = None
-        if self.response_protocol == "HTTP/1.1":
-            te = self.inheaders.get("Transfer-Encoding")
-            if te:
-                te = [x.strip().lower() for x in te.split(",") if x.strip()]
-        
-        if te:
-            for enc in te:
-                if enc == "chunked":
-                    self.chunked_read = True
-                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 False
-        
-        # From PEP 333:
-        # "Servers and gateways that implement HTTP 1.1 must provide
-        # transparent support for HTTP 1.1's "expect/continue" mechanism.
-        # This may be done in any of several ways:
-        #   1. Respond to requests containing an Expect: 100-continue request
-        #      with an immediate "100 Continue" response, and proceed normally.
-        #   2. Proceed with the request normally, but provide the application
-        #      with a wsgi.input stream that will send the "100 Continue"
-        #      response if/when the application first attempts to read from
-        #      the input stream. The read request must then remain blocked
-        #      until the client responds.
-        #   3. Wait until the client decides that the server does not support
-        #      expect/continue, and sends the request body on its own.
-        #      (This is suboptimal, and is not recommended.)
-        #
-        # 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.
-        if self.inheaders.get("Expect", "") == "100-continue":
-            # Don't use simple_response here, because it emits headers
-            # we don't want. See http://www.cherrypy.org/ticket/951
-            msg = self.server.protocol + " 100 Continue\r\n\r\n"
-            try:
-                self.conn.wfile.sendall(msg)
-            except socket.error, x:
-                if x.args[0] not in socket_errors_to_ignore:
-                    raise
-        return True
-    
-    def parse_request_uri(self, uri):
-        """Parse a Request-URI into (scheme, authority, path).
-        
-        Note that Request-URI's must be one of:
-            
-            Request-URI    = "*" | absoluteURI | abs_path | authority
-        
-        Therefore, a Request-URI which starts with a double forward-slash
-        cannot be a "net_path":
-        
-            net_path      = "//" authority [ abs_path ]
-        
-        Instead, it must be interpreted as an "abs_path" with an empty first
-        path segment:
-        
-            abs_path      = "/"  path_segments
-            path_segments = segment *( "/" segment )
-            segment       = *pchar *( ";" param )
-            param         = *pchar
-        """
-        if uri == "*":
-            return None, None, uri
-        
-        i = uri.find('://')
-        if i > 0 and '?' not in uri[:i]:
-            # An absoluteURI.
-            # If there's a scheme (and it must be http or https), then:
-            # http_URL = "http:" "//" host [ ":" port ] [ abs_path [ "?" query ]]
-            scheme, remainder = uri[:i].lower(), uri[i + 3:]
-            authority, path = remainder.split("/", 1)
-            return scheme, authority, path
-        
-        if uri.startswith('/'):
-            # An abs_path.
-            return None, None, uri
-        else:
-            # An authority.
-            return None, uri, None
-    
-    def respond(self):
-        """Call the gateway and write its iterable output."""
-        mrbs = self.server.max_request_body_size
-        if self.chunked_read:
-            self.rfile = ChunkedRFile(self.conn.rfile, mrbs)
-        else:
-            cl = int(self.inheaders.get("Content-Length", 0))
-            if mrbs and mrbs < cl:
-                if not self.sent_headers:
-                    self.simple_response("413 Request Entity Too Large",
-                        "The entity sent with the request exceeds the maximum "
-                        "allowed bytes.")
-                return
-            self.rfile = KnownLengthRFile(self.conn.rfile, cl)
-        
-        self.server.gateway(self).respond()
-        
-        if (self.ready and not self.sent_headers):
-            self.sent_headers = True
-            self.send_headers()
-        if self.chunked_write:
-            self.conn.wfile.sendall("0\r\n\r\n")
-    
-    def simple_response(self, status, msg=""):
-        """Write a simple response back to the client."""
-        status = str(status)
-        buf = ["Content-Length: %s\r\n" % len(msg),
-               "Content-Type: text/plain\r\n"]
-        
-        if status[:3] in ("413", "414"):
-            # Request Entity Too Large / Request-URI Too Long
-            self.close_connection = True
-            if self.response_protocol == 'HTTP/1.1':
-                # This will not be true for 414, since read_request_line
-                # usually raises 414 before reading the whole line, and we
-                # therefore cannot know the proper response_protocol.
-                buf.append("Connection: close\r\n")
-            else:
-                # HTTP/1.0 had no 413/414 status nor Connection header.
-                # Emit 400 instead and trust the message body is enough.
-                status = "400 Bad Request"
-        
-        buf.append(CRLF)
-        if msg:
-            if isinstance(msg, unicode):
-                msg = msg.encode("ISO-8859-1")
-            buf.append(msg)
-        
-        status_line = self.server.protocol + " " + status + CRLF
-        try:
-            self.conn.wfile.sendall(status_line + "".join(buf))
-        except socket.error, x:
-            if x.args[0] not in socket_errors_to_ignore:
-                raise
-    
-    def write(self, chunk):
-        """Write unbuffered data to the client."""
-        if self.chunked_write and chunk:
-            buf = [hex(len(chunk))[2:], CRLF, chunk, CRLF]
-            self.conn.wfile.sendall("".join(buf))
-        else:
-            self.conn.wfile.sendall(chunk)
-    
-    def send_headers(self):
-        """Assert, process, and send the HTTP response message-headers.
-        
-        You must set self.status, and self.outheaders before calling this.
-        """
-        hkeys = [key.lower() for key, value in self.outheaders]
-        status = int(self.status[:3])
-        
-        if status == 413:
-            # Request Entity Too Large. Close conn to avoid garbage.
-            self.close_connection = True
-        elif "content-length" not in hkeys:
-            # "All 1xx (informational), 204 (no content),
-            # and 304 (not modified) responses MUST NOT
-            # include a message-body." So no point chunking.
-            if status < 200 or status in (204, 205, 304):
-                pass
-            else:
-                if (self.response_protocol == 'HTTP/1.1'
-                    and self.method != 'HEAD'):
-                    # Use the chunked transfer-coding
-                    self.chunked_write = True
-                    self.outheaders.append(("Transfer-Encoding", "chunked"))
-                else:
-                    # Closing the conn is the only way to determine len.
-                    self.close_connection = True
-        
-        if "connection" not in hkeys:
-            if self.response_protocol == 'HTTP/1.1':
-                # Both server and client are HTTP/1.1 or better
-                if self.close_connection:
-                    self.outheaders.append(("Connection", "close"))
-            else:
-                # Server and/or client are HTTP/1.0
-                if not self.close_connection:
-                    self.outheaders.append(("Connection", "Keep-Alive"))
-        
-        if (not self.close_connection) and (not self.chunked_read):
-            # Read any remaining request body data on the socket.
-            # "If an origin server receives a request that does not include an
-            # Expect request-header field with the "100-continue" expectation,
-            # the request includes a request body, and the server responds
-            # with a final status code before reading the entire request body
-            # from the transport connection, then the server SHOULD NOT close
-            # the transport connection until it has read the entire request,
-            # or until the client closes the connection. Otherwise, the client
-            # might not reliably receive the response message. However, this
-            # requirement is not be construed as preventing a server from
-            # defending itself against denial-of-service attacks, or from
-            # badly broken client implementations."
-            remaining = getattr(self.rfile, 'remaining', 0)
-            if remaining > 0:
-                self.rfile.read(remaining)
-        
-        if "date" not in hkeys:
-            self.outheaders.append(("Date", rfc822.formatdate()))
-        
-        if "server" not in hkeys:
-            self.outheaders.append(("Server", self.server.server_name))
-        
-        buf = [self.server.protocol + " " + self.status + CRLF]
-        for k, v in self.outheaders:
-            buf.append(k + ": " + v + CRLF)
-        buf.append(CRLF)
-        self.conn.wfile.sendall("".join(buf))
-
-
-class NoSSLError(Exception):
-    """Exception raised when a client speaks HTTP to an HTTPS socket."""
-    pass
-
-
-class FatalSSLAlert(Exception):
-    """Exception raised when the SSL implementation signals a fatal alert."""
-    pass
-
-
-if not _fileobject_uses_str_type:
-    class CP_fileobject(socket._fileobject):
-        """Faux file object attached to a socket object."""
-
-        def sendall(self, data):
-            """Sendall for non-blocking sockets."""
-            while data:
-                try:
-                    bytes_sent = self.send(data)
-                    data = data[bytes_sent:]
-                except socket.error, e:
-                    if e.args[0] not in socket_errors_nonblocking:
-                        raise
-
-        def send(self, data):
-            return self._sock.send(data)
-
-        def flush(self):
-            if self._wbuf:
-                buffer = "".join(self._wbuf)
-                self._wbuf = []
-                self.sendall(buffer)
-
-        def recv(self, size):
-            while True:
-                try:
-                    return self._sock.recv(size)
-                except socket.error, e:
-                    if (e.args[0] not in socket_errors_nonblocking
-                        and e.args[0] not in socket_error_eintr):
-                        raise
-
-        def read(self, size=-1):
-            # Use max, disallow tiny reads in a loop as they are very inefficient.
-            # We never leave read() with any leftover data from a new recv() call
-            # in our internal buffer.
-            rbufsize = max(self._rbufsize, self.default_bufsize)
-            # Our use of StringIO rather than lists of string objects returned by
-            # recv() minimizes memory usage and fragmentation that occurs when
-            # rbufsize is large compared to the typical return value of recv().
-            buf = self._rbuf
-            buf.seek(0, 2)  # seek end
-            if size < 0:
-                # Read until EOF
-                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf.
-                while True:
-                    data = self.recv(rbufsize)
-                    if not data:
-                        break
-                    buf.write(data)
-                return buf.getvalue()
-            else:
-                # Read until size bytes or EOF seen, whichever comes first
-                buf_len = buf.tell()
-                if buf_len >= size:
-                    # Already have size bytes in our buffer?  Extract and return.
-                    buf.seek(0)
-                    rv = buf.read(size)
-                    self._rbuf = StringIO.StringIO()
-                    self._rbuf.write(buf.read())
-                    return rv
-
-                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf.
-                while True:
-                    left = size - buf_len
-                    # recv() will malloc the amount of memory given as its
-                    # parameter even though it often returns much less data
-                    # than that.  The returned data string is short lived
-                    # as we copy it into a StringIO and free it.  This avoids
-                    # fragmentation issues on many platforms.
-                    data = self.recv(left)
-                    if not data:
-                        break
-                    n = len(data)
-                    if n == size and not buf_len:
-                        # Shortcut.  Avoid buffer data copies when:
-                        # - We have no data in our buffer.
-                        # AND
-                        # - Our call to recv returned exactly the
-                        #   number of bytes we were asked to read.
-                        return data
-                    if n == left:
-                        buf.write(data)
-                        del data  # explicit free
-                        break
-                    assert n <= left, "recv(%d) returned %d bytes" % (left, n)
-                    buf.write(data)
-                    buf_len += n
-                    del data  # explicit free
-                    #assert buf_len == buf.tell()
-                return buf.getvalue()
-
-        def readline(self, size=-1):
-            buf = self._rbuf
-            buf.seek(0, 2)  # seek end
-            if buf.tell() > 0:
-                # check if we already have it in our buffer
-                buf.seek(0)
-                bline = buf.readline(size)
-                if bline.endswith('\n') or len(bline) == size:
-                    self._rbuf = StringIO.StringIO()
-                    self._rbuf.write(buf.read())
-                    return bline
-                del bline
-            if size < 0:
-                # Read until \n or EOF, whichever comes first
-                if self._rbufsize <= 1:
-                    # Speed up unbuffered case
-                    buf.seek(0)
-                    buffers = [buf.read()]
-                    self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf.
-                    data = None
-                    recv = self.recv
-                    while data != "\n":
-                        data = recv(1)
-                        if not data:
-                            break
-                        buffers.append(data)
-                    return "".join(buffers)
-
-                buf.seek(0, 2)  # seek end
-                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf.
-                while True:
-                    data = self.recv(self._rbufsize)
-                    if not data:
-                        break
-                    nl = data.find('\n')
-                    if nl >= 0:
-                        nl += 1
-                        buf.write(data[:nl])
-                        self._rbuf.write(data[nl:])
-                        del data
-                        break
-                    buf.write(data)
-                return buf.getvalue()
-            else:
-                # Read until size bytes or \n or EOF seen, whichever comes first
-                buf.seek(0, 2)  # seek end
-                buf_len = buf.tell()
-                if buf_len >= size:
-                    buf.seek(0)
-                    rv = buf.read(size)
-                    self._rbuf = StringIO.StringIO()
-                    self._rbuf.write(buf.read())
-                    return rv
-                self._rbuf = StringIO.StringIO()  # reset _rbuf.  we consume it via buf.
-                while True:
-                    data = self.recv(self._rbufsize)
-                    if not data:
-                        break
-                    left = size - buf_len
-                    # did we just receive a newline?
-                    nl = data.find('\n', 0, left)
-                    if nl >= 0:
-                        nl += 1
-                        # save the excess data to _rbuf
-                        self._rbuf.write(data[nl:])
-                        if buf_len:
-                            buf.write(data[:nl])
-                            break
-                        else:
-                            # Shortcut.  Avoid data copy through buf when returning
-                            # a substring of our first recv().
-                            return data[:nl]
-                    n = len(data)
-                    if n == size and not buf_len:
-                        # Shortcut.  Avoid data copy through buf when
-                        # returning exactly all of our first recv().
-                        return data
-                    if n >= left:
-                        buf.write(data[:left])
-                        self._rbuf.write(data[left:])
-                        break
-                    buf.write(data)
-                    buf_len += n
-                    #assert buf_len == buf.tell()
-                return buf.getvalue()
-
+if sys.version_info < (3, 0):
+    from wsgiserver2 import *
 else:
-    class CP_fileobject(socket._fileobject):
-        """Faux file object attached to a socket object."""
-
-        def sendall(self, data):
-            """Sendall for non-blocking sockets."""
-            while data:
-                try:
-                    bytes_sent = self.send(data)
-                    data = data[bytes_sent:]
-                except socket.error, e:
-                    if e.args[0] not in socket_errors_nonblocking:
-                        raise
-
-        def send(self, data):
-            return self._sock.send(data)
-
-        def flush(self):
-            if self._wbuf:
-                buffer = "".join(self._wbuf)
-                self._wbuf = []
-                self.sendall(buffer)
-
-        def recv(self, size):
-            while True:
-                try:
-                    return self._sock.recv(size)
-                except socket.error, e:
-                    if (e.args[0] not in socket_errors_nonblocking
-                        and e.args[0] not in socket_error_eintr):
-                        raise
-
-        def read(self, size=-1):
-            if size < 0:
-                # Read until EOF
-                buffers = [self._rbuf]
-                self._rbuf = ""
-                if self._rbufsize <= 1:
-                    recv_size = self.default_bufsize
-                else:
-                    recv_size = self._rbufsize
-
-                while True:
-                    data = self.recv(recv_size)
-                    if not data:
-                        break
-                    buffers.append(data)
-                return "".join(buffers)
-            else:
-                # Read until size bytes or EOF seen, whichever comes first
-                data = self._rbuf
-                buf_len = len(data)
-                if buf_len >= size:
-                    self._rbuf = data[size:]
-                    return data[:size]
-                buffers = []
-                if data:
-                    buffers.append(data)
-                self._rbuf = ""
-                while True:
-                    left = size - buf_len
-                    recv_size = max(self._rbufsize, left)
-                    data = self.recv(recv_size)
-                    if not data:
-                        break
-                    buffers.append(data)
-                    n = len(data)
-                    if n >= left:
-                        self._rbuf = data[left:]
-                        buffers[-1] = data[:left]
-                        break
-                    buf_len += n
-                return "".join(buffers)
-
-        def readline(self, size=-1):
-            data = self._rbuf
-            if size < 0:
-                # Read until \n or EOF, whichever comes first
-                if self._rbufsize <= 1:
-                    # Speed up unbuffered case
-                    assert data == ""
-                    buffers = []
-                    while data != "\n":
-                        data = self.recv(1)
-                        if not data:
-                            break
-                        buffers.append(data)
-                    return "".join(buffers)
-                nl = data.find('\n')
-                if nl >= 0:
-                    nl += 1
-                    self._rbuf = data[nl:]
-                    return data[:nl]
-                buffers = []
-                if data:
-                    buffers.append(data)
-                self._rbuf = ""
-                while True:
-                    data = self.recv(self._rbufsize)
-                    if not data:
-                        break
-                    buffers.append(data)
-                    nl = data.find('\n')
-                    if nl >= 0:
-                        nl += 1
-                        self._rbuf = data[nl:]
-                        buffers[-1] = data[:nl]
-                        break
-                return "".join(buffers)
-            else:
-                # Read until size bytes or \n or EOF seen, whichever comes first
-                nl = data.find('\n', 0, size)
-                if nl >= 0:
-                    nl += 1
-                    self._rbuf = data[nl:]
-                    return data[:nl]
-                buf_len = len(data)
-                if buf_len >= size:
-                    self._rbuf = data[size:]
-                    return data[:size]
-                buffers = []
-                if data:
-                    buffers.append(data)
-                self._rbuf = ""
-                while True:
-                    data = self.recv(self._rbufsize)
-                    if not data:
-                        break
-                    buffers.append(data)
-                    left = size - buf_len
-                    nl = data.find('\n', 0, left)
-                    if nl >= 0:
-                        nl += 1
-                        self._rbuf = data[nl:]
-                        buffers[-1] = data[:nl]
-                        break
-                    n = len(data)
-                    if n >= left:
-                        self._rbuf = data[left:]
-                        buffers[-1] = data[:left]
-                        break
-                    buf_len += n
-                return "".join(buffers)
-
-
-class HTTPConnection(object):
-    """An HTTP connection (active socket).
-    
-    server: the Server object which received this connection.
-    socket: the raw socket object (usually TCP) for this connection.
-    makefile: a fileobject class for reading from the socket.
-    """
-    
-    remote_addr = None
-    remote_port = None
-    ssl_env = None
-    rbufsize = -1
-    RequestHandlerClass = HTTPRequest
-    
-    def __init__(self, server, sock, makefile=CP_fileobject):
-        self.server = server
-        self.socket = sock
-        self.rfile = makefile(sock, "rb", self.rbufsize)
-        self.wfile = makefile(sock, "wb", -1)
-    
-    def communicate(self):
-        """Read each request and respond appropriately."""
-        request_seen = False
-        try:
-            while True:
-                # (re)set req to None so that if something goes wrong in
-                # the RequestHandlerClass constructor, the error doesn't
-                # get written to the previous request.
-                req = None
-                req = self.RequestHandlerClass(self.server, self)
-                
-                # This order of operations should guarantee correct pipelining.
-                req.parse_request()
-                if not req.ready:
-                    # Something went wrong in the parsing (and the server has
-                    # probably already made a simple_response). Return and
-                    # let the conn close.
-                    return
-                
-                request_seen = True
-                req.respond()
-                if req.close_connection:
-                    return
-        except socket.error, e:
-            errnum = e.args[0]
-            if errnum == 'timed out':
-                # Don't error if we're between requests; only error
-                # if 1) no request has been started at all, or 2) we're
-                # in the middle of a request.
-                # See http://www.cherrypy.org/ticket/853
-                if (not request_seen) or (req and req.started_request):
-                    # Don't bother writing the 408 if the response
-                    # has already started being written.
-                    if req and not req.sent_headers:
-                        try:
-                            req.simple_response("408 Request Timeout")
-                        except FatalSSLAlert:
-                            # Close the connection.
-                            return
-            elif errnum not in socket_errors_to_ignore:
-                if req and not req.sent_headers:
-                    try:
-                        req.simple_response("500 Internal Server Error",
-                                            format_exc())
-                    except FatalSSLAlert:
-                        # Close the connection.
-                        return
-            return
-        except (KeyboardInterrupt, SystemExit):
-            raise
-        except FatalSSLAlert:
-            # Close the connection.
-            return
-        except NoSSLError:
-            if req and not req.sent_headers:
-                # Unwrap our wfile
-                self.wfile = CP_fileobject(self.socket._sock, "wb", -1)
-                req.simple_response("400 Bad Request",
-                    "The client sent a plain HTTP request, but "
-                    "this server only speaks HTTPS on this port.")
-                self.linger = True
-        except Exception:
-            if req and not req.sent_headers:
-                try:
-                    req.simple_response("500 Internal Server Error", format_exc())
-                except FatalSSLAlert:
-                    # Close the connection.
-                    return
-    
-    linger = False
-    
-    def close(self):
-        """Close the socket underlying this connection."""
-        self.rfile.close()
-        
-        if not self.linger:
-            # Python's socket module does NOT call close on the kernel socket
-            # when you call socket.close(). We do so manually here because we
-            # want this server to send a FIN TCP segment immediately. Note this
-            # must be called *before* calling socket.close(), because the latter
-            # drops its reference to the kernel socket.
-            if hasattr(self.socket, '_sock'):
-                self.socket._sock.close()
-            self.socket.close()
-        else:
-            # On the other hand, sometimes we want to hang around for a bit
-            # to make sure the client has a chance to read our entire
-            # response. Skipping the close() calls here delays the FIN
-            # packet until the socket object is garbage-collected later.
-            # Someday, perhaps, we'll do the full lingering_close that
-            # Apache does, but not today.
-            pass
-
-
-def format_exc(limit=None):
-    """Like print_exc() but return a string. Backport for Python 2.3."""
-    try:
-        etype, value, tb = sys.exc_info()
-        return ''.join(traceback.format_exception(etype, value, tb, limit))
-    finally:
-        etype = value = tb = None
-
-
-_SHUTDOWNREQUEST = None
-
-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).
-    """
-    
-    conn = None
-    
-    def __init__(self, server):
-        self.ready = False
-        self.server = server
-        threading.Thread.__init__(self)
-    
-    def run(self):
-        try:
-            self.ready = True
-            while True:
-                conn = self.server.requests.get()
-                if conn is _SHUTDOWNREQUEST:
-                    return
-                
-                self.conn = conn
-                try:
-                    conn.communicate()
-                finally:
-                    conn.close()
-                    self.conn = None
-        except (KeyboardInterrupt, SystemExit), exc:
-            self.server.interrupt = exc
-
-
-class ThreadPool(object):
-    """A Request Queue for the CherryPyWSGIServer which pools threads.
-    
-    ThreadPool objects must provide min, get(), put(obj), start()
-    and stop(timeout) attributes.
-    """
-    
-    def __init__(self, server, min=10, max=-1):
-        self.server = server
-        self.min = min
-        self.max = max
-        self._threads = []
-        self._queue = Queue.Queue()
-        self.get = self._queue.get
-    
-    def start(self):
-        """Start the pool of threads."""
-        for i in range(self.min):
-            self._threads.append(WorkerThread(self.server))
-        for worker in self._threads:
-            worker.setName("CP Server " + worker.getName())
-            worker.start()
-        for worker in self._threads:
-            while not worker.ready:
-                time.sleep(.1)
-    
-    def _get_idle(self):
-        """Number of worker threads which are idle. Read-only."""
-        return len([t for t in self._threads if t.conn is None])
-    idle = property(_get_idle, doc=_get_idle.__doc__)
-    
-    def put(self, obj):
-        self._queue.put(obj)
-        if obj is _SHUTDOWNREQUEST:
-            return
-    
-    def grow(self, amount):
-        """Spawn new worker threads (not above self.max)."""
-        for i in range(amount):
-            if self.max > 0 and len(self._threads) >= self.max:
-                break
-            worker = WorkerThread(self.server)
-            worker.setName("CP Server " + worker.getName())
-            self._threads.append(worker)
-            worker.start()
-    
-    def shrink(self, amount):
-        """Kill off worker threads (not below self.min)."""
-        # Grow/shrink the pool if necessary.
-        # Remove any dead threads from our list
-        for t in self._threads:
-            if not t.isAlive():
-                self._threads.remove(t)
-                amount -= 1
-        
-        if amount > 0:
-            for i in range(min(amount, l