Merge remote-tracking branch 'upstream/master'

James Rutherford · James Rutherford · commit fd17760b6eb7 · 2013-10-09T11:37:38.000+01:00
diff --git a/README.rst b/README.rst
@@ -9,6 +9,8 @@ A drop in replacement for Django's built-in runserver command. Features include:
 * Threaded (default) and multi-process development servers.
 * Ability to specify a WSGI application as your target environment.
 
+.. note:: django-devserver works on Django 1.3 and newer
+
 ------------
 Installation
 ------------
diff --git a/devserver/__init__.py b/devserver/__init__.py
@@ -10,7 +10,7 @@
 """
 
 __all__ = ('__version__', '__build__', '__docformat__', 'get_revision')
-__version__ = (0, 4, 0)
+__version__ = (0, 6, 2)
 __docformat__ = 'restructuredtext en'
 
 import os
diff --git a/devserver/management/commands/runserver.py b/devserver/management/commands/runserver.py
@@ -1,11 +1,11 @@
 from django.conf import settings
-from django.core.management.base import BaseCommand, CommandError, handle_default_options
+from django.core.management.commands.runserver import Command as BaseCommand
+from django.core.management.base import CommandError, handle_default_options
 from django.core.servers.basehttp import WSGIServerException, WSGIServer
 from django.core.handlers.wsgi import WSGIHandler
 
 import os
 import sys
-import django
 import imp
 import SocketServer
 from optparse import make_option
@@ -14,11 +14,14 @@
 from devserver.utils.http import SlimWSGIRequestHandler
 
 
+STATICFILES_APPS = ('django.contrib.staticfiles', 'staticfiles')
+
+
 def null_technical_500_response(request, exc_type, exc_value, tb):
     raise exc_type, exc_value, tb
 
 
-def run(addr, port, wsgi_handler, mixin=None):
+def run(addr, port, wsgi_handler, mixin=None, ipv6=False):
     if mixin:
         class new(mixin, WSGIServer):
             def __init__(self, *args, **kwargs):
@@ -27,29 +30,30 @@ def __init__(self, *args, **kwargs):
         new = WSGIServer
     server_address = (addr, port)
     new.request_queue_size = 10
-    httpd = new(server_address, SlimWSGIRequestHandler)
+    httpd = new(server_address, SlimWSGIRequestHandler, ipv6=ipv6)
     httpd.set_app(wsgi_handler)
     httpd.serve_forever()
 
 
 class Command(BaseCommand):
     option_list = BaseCommand.option_list + (
-        make_option('--noreload', action='store_false', dest='use_reloader', default=True,
-            help='Tells Django to NOT use the auto-reloader.'),
-        make_option('--werkzeug', action='store_true', dest='use_werkzeug', default=False,
+        make_option(
+            '--werkzeug', action='store_true', dest='use_werkzeug', default=False,
             help='Tells Django to use the Werkzeug interactive debugger.'),
-        make_option('--adminmedia', dest='admin_media_path', default='',
-            help='Specifies the directory from which to serve admin media.'),
-        make_option('--forked', action='store_true', dest='use_forked', default=False,
+        make_option(
+            '--forked', action='store_true', dest='use_forked', default=False,
             help='Use forking instead of threading for multiple web requests.'),
-        make_option('--dozer', action='store_true', dest='use_dozer', default=False,
+        make_option(
+            '--dozer', action='store_true', dest='use_dozer', default=False,
             help='Enable the Dozer memory debugging middleware.'),
-        make_option('--wsgi-app', dest='wsgi_app', default=None,
+        make_option(
+            '--wsgi-app', dest='wsgi_app', default=None,
             help='Load the specified WSGI app as the server endpoint.'),
     )
-    if any(map(lambda app: app in settings.INSTALLED_APPS, ('django.contrib.staticfiles', 'staticfiles', ))):
-        option_list += make_option('--nostatic', dest='use_static_files', default=True,
-                          help='Tells Django to NOT automatically serve static files at STATIC_URL.'),
+    if any(map(lambda app: app in settings.INSTALLED_APPS, STATICFILES_APPS)):
+        option_list += make_option(
+            '--nostatic', dest='use_static_files', action='store_false', default=True,
+            help='Tells Django to NOT automatically serve static files at STATIC_URL.'),
 
     help = "Starts a lightweight Web server for development which outputs additional debug information."
     args = '[optional port number, or ipaddr:port]'
@@ -75,135 +79,132 @@ def handle(self, addrport='', *args, **options):
             raise CommandError('Usage is runserver %s' % self.args)
 
         if not addrport:
-            addr = getattr(settings, 'DEVSERVER_DEFAULT_ADDR', '')
+            addr = getattr(settings, 'DEVSERVER_DEFAULT_ADDR', '127.0.0.1')
             port = getattr(settings, 'DEVSERVER_DEFAULT_PORT', '8000')
+            addrport = '%s:%s' % (addr, port)
+
+        return super(Command, self).handle(addrport=addrport, *args, **options)
+
+    def get_handler(self, *args, **options):
+        if int(options['verbosity']) < 1:
+            handler = WSGIHandler()
         else:
-            try:
-                addr, port = addrport.split(':')
-            except ValueError:
-                addr, port = '', addrport
-        if not addr:
-            addr = '127.0.0.1'
+            handler = DevServerHandler()
+
+        # AdminMediaHandler is removed in Django 1.5
+        # Add it only when it avialable.
+        try:
+            from django.core.servers.basehttp import AdminMediaHandler
+        except ImportError:
+            pass
+        else:
+            handler = AdminMediaHandler(
+                handler, options['admin_media_path'])
 
-        if not port.isdigit():
-            raise CommandError("%r is not a valid port number." % port)
+        if 'django.contrib.staticfiles' in settings.INSTALLED_APPS and options['use_static_files']:
+            from django.contrib.staticfiles.handlers import StaticFilesHandler
+            handler = StaticFilesHandler(handler)
+
+        return handler
+
+    def inner_run(self, *args, **options):
+        # Flag the server as active
+        from devserver import settings
+        import devserver
+        settings.DEVSERVER_ACTIVE = True
+        settings.DEBUG = True
+
+        from django.conf import settings
+        from django.utils import translation
 
-        use_reloader = options.get('use_reloader', True)
-        admin_media_path = options.get('admin_media_path', '')
         shutdown_message = options.get('shutdown_message', '')
         use_werkzeug = options.get('use_werkzeug', False)
         quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
         wsgi_app = options.get('wsgi_app', None)
-        use_static_files = options.get('use_static_files', True)
 
         if use_werkzeug:
             try:
                 from werkzeug import run_simple, DebuggedApplication
             except ImportError, e:
-                print >> sys.stderr, "WARNING: Unable to initialize werkzeug: %s" % e
+                self.stderr.write("WARNING: Unable to initialize werkzeug: %s\n" % e)
                 use_werkzeug = False
             else:
-                use_werkzeug = True
                 from django.views import debug
                 debug.technical_500_response = null_technical_500_response
 
-        def inner_run():
-            # Flag the server as active
-            from devserver import settings
-            import devserver
-            settings.DEVSERVER_ACTIVE = True
-            settings.DEBUG = True
-
-            from django.conf import settings
-            from django.utils import translation
-
-            print "Validating models..."
-            self.validate(display_num_errors=True)
-            print "\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE)
-            print "Running django-devserver %s" % (devserver.get_version(),)
-            if use_werkzeug:
-                server_type = 'werkzeug'
+        self.stdout.write("Validating models...\n\n")
+        self.validate(display_num_errors=True)
+        self.stdout.write((
+            "Django version %(version)s, using settings %(settings)r\n"
+            "Running django-devserver %(devserver_version)s\n"
+            "%(server_model)s %(server_type)s server is running at http://%(addr)s:%(port)s/\n"
+            "Quit the server with %(quit_command)s.\n"
+        ) % {
+            "server_type": use_werkzeug and 'werkzeug' or 'Django',
+            "server_model": options['use_forked'] and 'Forked' or 'Threaded',
+            "version": self.get_version(),
+            "devserver_version": devserver.get_version(),
+            "settings": settings.SETTINGS_MODULE,
+            "addr": self._raw_ipv6 and '[%s]' % self.addr or self.addr,
+            "port": self.port,
+            "quit_command": quit_command,
+        })
+
+        # django.core.management.base forces the locale to en-us. We should
+        # set it up correctly for the first request (particularly important
+        # in the "--noreload" case).
+        translation.activate(settings.LANGUAGE_CODE)
+
+        app = self.get_handler(*args, **options)
+        if wsgi_app:
+            self.stdout.write("Using WSGI application %r\n" % wsgi_app)
+            if os.path.exists(os.path.abspath(wsgi_app)):
+                # load from file
+                app = imp.load_source('wsgi_app', os.path.abspath(wsgi_app)).application
             else:
-                server_type = 'django'
-            print "%s %s server is running at http://%s:%s/" % (options['use_forked'] and 'Forked' or 'Threaded', server_type, addr, port)
-            print "Quit the server with %s." % quit_command
+                try:
+                    app = __import__(wsgi_app, {}, {}, ['application']).application
+                except (ImportError, AttributeError):
+                    raise
 
-            # django.core.management.base forces the locale to en-us. We should
-            # set it up correctly for the first request (particularly important
-            # in the "--noreload" case).
-            translation.activate(settings.LANGUAGE_CODE)
+        if options['use_forked']:
+            mixin = SocketServer.ForkingMixIn
+        else:
+            mixin = SocketServer.ThreadingMixIn
 
-            if int(options['verbosity']) < 1:
-                app = WSGIHandler()
-            else:
-                app = DevServerHandler()
-
-            if wsgi_app:
-                print "Using WSGI application %r" % wsgi_app
-                if os.path.exists(os.path.abspath(wsgi_app)):
-                    # load from file
-                    app = imp.load_source('wsgi_app', os.path.abspath(wsgi_app)).application
-                else:
-                    try:
-                        app = __import__(wsgi_app, {}, {}, ['application']).application
-                    except (ImportError, AttributeError):
-                        raise
-
-            if options['use_forked']:
-                mixin = SocketServer.ForkingMixIn
-            else:
-                mixin = SocketServer.ThreadingMixIn
+        middleware = getattr(settings, 'DEVSERVER_WSGI_MIDDLEWARE', [])
+        for middleware in middleware:
+            module, class_name = middleware.rsplit('.', 1)
+            app = getattr(__import__(module, {}, {}, [class_name]), class_name)(app)
 
-            middleware = getattr(settings, 'DEVSERVER_WSGI_MIDDLEWARE', [])
-            for middleware in middleware:
-                module, class_name = middleware.rsplit('.', 1)
-                app = getattr(__import__(module, {}, {}, [class_name]), class_name)(app)
+        if options['use_dozer']:
+            from dozer import Dozer
+            app = Dozer(app)
 
-            if 'django.contrib.staticfiles' in settings.INSTALLED_APPS and use_static_files:
-                from django.contrib.staticfiles.handlers import StaticFilesHandler
-                app = StaticFilesHandler(app)
+        try:
+            if use_werkzeug:
+                run_simple(
+                    self.addr, int(self.port), DebuggedApplication(app, True),
+                    use_reloader=False, use_debugger=True)
             else:
-                # AdminMediaHandler is removed in Django 1.5
-                # Add it only when it avialable.
-                try:
-                    from django.core.servers.basehttp import AdminMediaHandler
-                except ImportError:
-                    pass
-                else:
-                    app = AdminMediaHandler(app, admin_media_path)
-
-            if options['use_dozer']:
-                from dozer import Dozer
-                app = Dozer(app)
-
+                run(self.addr, int(self.port), app, mixin, ipv6=options['use_ipv6'])
+
+        except WSGIServerException, e:
+            # Use helpful error messages instead of ugly tracebacks.
+            ERRORS = {
+                13: "You don't have permission to access that port.",
+                98: "That port is already in use.",
+                99: "That IP address can't be assigned-to.",
+            }
             try:
-                if use_werkzeug:
-                    run_simple(addr, int(port), DebuggedApplication(app, True),
-                        use_reloader=False, use_debugger=True)
-                else:
-                    run(addr, int(port), app, mixin)
-            except WSGIServerException, e:
-                # Use helpful error messages instead of ugly tracebacks.
-                ERRORS = {
-                    13: "You don't have permission to access that port.",
-                    98: "That port is already in use.",
-                    99: "That IP address can't be assigned-to.",
-                }
-                try:
-                    error_text = ERRORS[e.args[0].args[0]]
-                except (AttributeError, KeyError):
-                    error_text = str(e)
-                sys.stderr.write(self.style.ERROR("Error: %s" % error_text) + '\n')
-                # Need to use an OS exit because sys.exit doesn't work in a thread
-                os._exit(1)
-            except KeyboardInterrupt:
-                if shutdown_message:
-                    print shutdown_message
-                sys.exit(0)
-
-        # werkzeug does its own autoreload stuff
-        if use_reloader:
-            from django.utils import autoreload
-            autoreload.main(inner_run)
-        else:
-            inner_run()
+                error_text = ERRORS[e.args[0].args[0]]
+            except (AttributeError, KeyError):
+                error_text = str(e)
+            sys.stderr.write(self.style.ERROR("Error: %s" % error_text) + '\n')
+            # Need to use an OS exit because sys.exit doesn't work in a thread
+            os._exit(1)
+
+        except KeyboardInterrupt:
+            if shutdown_message:
+                self.stdout.write("%s\n" % shutdown_message)
+            sys.exit(0)
diff --git a/devserver/modules/profile.py b/devserver/modules/profile.py
@@ -125,15 +125,20 @@ def __init__(self, follow=[]):
             self.follow = follow
 
         def __call__(self, func):
-            def profiled_func(request, *args, **kwargs):
+            def profiled_func(*args, **kwargs):
+                request = args[0]
+                if hasattr(request, 'request'):
+                    # We're decorating a Django class-based-view and the first argument is actually self:
+                    request = args[1]
+
                 try:
                     request.devserver_profiler.add_function(func)
                     request.devserver_profiler_run = True
                     for f in self.follow:
                         request.devserver_profiler.add_function(f)
                     request.devserver_profiler.enable_by_count()
-                    retval = func(request, *args, **kwargs)
+                    return func(*args, **kwargs)
                 finally:
                     request.devserver_profiler.disable_by_count()
-                return retval
+
             return functools.wraps(func)(profiled_func)
diff --git a/devserver/modules/sql.py b/devserver/modules/sql.py
@@ -13,6 +13,7 @@
     connections = {'default': connection}
 
 from django.db.backends import util
+from django.conf import settings as django_settings
 #from django.template import Node
 
 from devserver.modules import DevServerModule
@@ -83,7 +84,7 @@ def execute(self, sql, params=()):
                 if self.cursor.rowcount >= 0:
                     self.logger.debug('Found %s matching rows', self.cursor.rowcount, duration=duration)
 
-            if not (debug_toolbar or settings.DEBUG):
+            if not (debug_toolbar or django_settings.DEBUG):
                 self.db.queries.append({
                     'sql': formatted_sql,
                     'time': duration,
