Django搭建及源码分析(二)

#!/usr/bin/env python
import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "MyDjProj.settings")

    from django.core.management import execute_from_command_line

    execute_from_command_line(sys.argv)

    def setdefault(self, key, failobj=None):
        if key not in self:
            self[key] = failobj
        return self[key]

def execute_from_command_line(argv=None):
    """
    A simple method that runs a ManagementUtility.
    """
    utility = ManagementUtility(argv)
    utility.execute()

class ManagementUtility(object):
    """
    Encapsulates the logic of the django-admin.py and manage.py utilities.

    A ManagementUtility has a number of commands, which can be manipulated
    by editing the self.commands dictionary.
    """
    def __init__(self, argv=None):
        self.argv = argv or sys.argv[:]
        self.prog_name = os.path.basename(self.argv[0])

    def execute(self):
        """
        Given the command-line arguments, this figures out which subcommand is
        being run, creates a parser appropriate to that command, and runs it.
        """
        # Preprocess options to extract --settings and --pythonpath.
        # These options could affect the commands that are available, so they
        # must be processed early.
        parser = LaxOptionParser(usage="%prog subcommand [options] [args]",
                                 version=get_version(),
                                 option_list=BaseCommand.option_list)
        self.autocomplete()
        try:
            options, args = parser.parse_args(self.argv)
            handle_default_options(options)
        except:
            pass # Ignore any option errors at this point.

        try:
            subcommand = self.argv[1]
        except IndexError:
            subcommand = ‘help‘ # Display help if no arguments were given.

        if subcommand == ‘help‘:
            if len(args) <= 2:
                parser.print_lax_help()
                sys.stdout.write(self.main_help_text() + ‘\n‘)
            elif args[2] == ‘--commands‘:
                sys.stdout.write(self.main_help_text(commands_only=True) + ‘\n‘)
            else:
                self.fetch_command(args[2]).print_help(self.prog_name, args[2])
        elif subcommand == ‘version‘:
            sys.stdout.write(parser.get_version() + ‘\n‘)
        # Special-cases: We want ‘django-admin.py --version‘ and
        # ‘django-admin.py --help‘ to work, for backwards compatibility.
        elif self.argv[1:] == [‘--version‘]:
            # LaxOptionParser already takes care of printing the version.
            pass
        elif self.argv[1:] in ([‘--help‘], [‘-h‘]):
            parser.print_lax_help()
            sys.stdout.write(self.main_help_text() + ‘\n‘)
        else:
            self.fetch_command(subcommand).run_from_argv(self.argv)

def handle_default_options(options):
    """
    Include any default options that all commands should accept here
    so that ManagementUtility can handle them before searching for
    user commands.

    """
    if options.settings:
        os.environ[‘DJANGO_SETTINGS_MODULE‘] = options.settings
    if options.pythonpath:
        sys.path.insert(0, options.pythonpath)

    def fetch_command(self, subcommand):
        """
        Tries to fetch the given subcommand, printing a message with the
        appropriate command called from the command line (usually
        "django-admin.py" or "manage.py") if it can‘t be found.
        """
        # Get commands outside of try block to prevent swallowing exceptions
        commands = get_commands()
        try:
            app_name = commands[subcommand]
        except KeyError:
            sys.stderr.write("Unknown command: %r\nType ‘%s help‘ for usage.\n" %                 (subcommand, self.prog_name))
            sys.exit(1)
        if isinstance(app_name, BaseCommand):
            # If the command is already loaded, use it directly.
            klass = app_name
        else:
            klass = load_command_class(app_name, subcommand)
        return klass

def load_command_class(app_name, name):
    """
    Given a command name and an application name, returns the Command
    class instance. All errors raised by the import process
    (ImportError, AttributeError) are allowed to propagate.
    """
    module = import_module(‘%s.management.commands.%s‘ % (app_name, name))
    return module.Command()

    def run_from_argv(self, argv):
        """
        Set up any environment changes requested (e.g., Python path
        and Django settings), then run this command. If the
        command raises a ``CommandError``, intercept it and print it sensibly
        to stderr. If the ``--traceback`` option is present or the raised
        ``Exception`` is not ``CommandError``, raise it.
        """
　　　　"""
　　　　以下为上该函数中文说明：
　　　　#设置环境变量，然后运行这个命令    
　　　　#如pythonmanage.pyrunserver,manage.py就是argv[0],runserver是argv[1]
　　　　#create_parser直接调用OptionParser(prog=prog_name,usage=self.usage(subcommand),version=self.get_version(),option_list=self.option_list)
            #将manage.py 和runserver加入参数列表
　　　　#接下来用parser.parse_args进行解析，argv[2]之后为默认参数，ip地址还有端口号，我们也可以显示的传进去，默认是127.0.0.1，端口号8000.
　　　　#下面又到了handle_default_options函数。
　　　　#接下来是执行execute函数，还有异常捕获。
　　　　"""
        parser = self.create_parser(argv[0], argv[1])
        options, args = parser.parse_args(argv[2:])
        handle_default_options(options)
        try:
            self.execute(*args, **options.__dict__)
        except Exception as e:
            if options.traceback or not isinstance(e, CommandError):
                raise

            # self.stderr is not guaranteed to be set here
            stderr = getattr(self, ‘stderr‘, OutputWrapper(sys.stderr, self.style.ERROR))
            stderr.write(‘%s: %s‘ % (e.__class__.__name__, e))
            sys.exit(1)                    

def execute(self, *args, **options):
        """
        Try to execute this command, performing model validation if
        needed (as controlled by the attribute
        ``self.requires_model_validation``, except if force-skipped).
        """
        self.stdout = OutputWrapper(options.get(‘stdout‘, sys.stdout))
        self.stderr = OutputWrapper(options.get(‘stderr‘, sys.stderr), self.style.ERROR)

        if self.can_import_settings:
            from django.conf import settings

        saved_locale = None
        if not self.leave_locale_alone:
            # Only mess with locales if we can assume we have a working
            # settings file, because django.utils.translation requires settings
            # (The final saying about whether the i18n machinery is active will be
            # found in the value of the USE_I18N setting)
            if not self.can_import_settings:
                raise CommandError("Incompatible values of ‘leave_locale_alone‘ "
                                   "(%s) and ‘can_import_settings‘ (%s) command "
                                   "options." % (self.leave_locale_alone,
                                                 self.can_import_settings))
            # Switch to US English, because django-admin.py creates database
            # content like permissions, and those shouldn‘t contain any
            # translations.
            from django.utils import translation
            saved_locale = translation.get_language()
            translation.activate(‘en-us‘)

        try:
            if self.requires_model_validation and not options.get(‘skip_validation‘):
                self.validate()
            output = self.handle(*args, **options)
            if output:
                if self.output_transaction:
                    # This needs to be imported here, because it relies on
                    # settings.
                    from django.db import connections, DEFAULT_DB_ALIAS
                    connection = connections[options.get(‘database‘, DEFAULT_DB_ALIAS)]
                    if connection.ops.start_transaction_sql():
                        self.stdout.write(self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()))
                self.stdout.write(output)
                if self.output_transaction:
                    self.stdout.write(‘\n‘ + self.style.SQL_KEYWORD("COMMIT;"))
        finally:
            if saved_locale is not None:
                translation.activate(saved_locale)

   def handle(self, addrport=‘‘, *args, **options):
        from django.conf import settings

        if not settings.DEBUG and not settings.ALLOWED_HOSTS:
            raise CommandError(‘You must set settings.ALLOWED_HOSTS if DEBUG is False.‘)

        self.use_ipv6 = options.get(‘use_ipv6‘)
        if self.use_ipv6 and not socket.has_ipv6:
            raise CommandError(‘Your Python does not support IPv6.‘)
        if args:
            raise CommandError(‘Usage is runserver %s‘ % self.args)
        self._raw_ipv6 = False
        if not addrport:
            self.addr = ‘‘
            self.port = DEFAULT_PORT
        else:　　　　　　　　
　　　　　　　#如果设置了IP地址，用正则匹配出来
            m = re.match(naiveip_re, addrport)
            if m is None:
                raise CommandError(‘"%s" is not a valid port number ‘
                                   ‘or address:port pair.‘ % addrport)
            self.addr, _ipv4, _ipv6, _fqdn, self.port = m.groups()
            if not self.port.isdigit():
                raise CommandError("%r is not a valid port number." % self.port)
            if self.addr:
                if _ipv6:
                    self.addr = self.addr[1:-1]
                    self.use_ipv6 = True
                    self._raw_ipv6 = True
                elif self.use_ipv6 and not _fqdn:
                    raise CommandError(‘"%s" is not a valid IPv6 address.‘ % self.addr)
        if not self.addr:
　　　　　　 #如果没有设置ip地址用127.0.0.1代替。
            self.addr = ‘::1‘ if self.use_ipv6 else ‘127.0.0.1‘
            self._raw_ipv6 = bool(self.use_ipv6)
        #运行命令
        self.run(*args, **options)

   def run(self, *args, **options):
        """
        Runs the server, using the autoreloader if needed
        """
        use_reloader = options.get(‘use_reloader‘)

        if use_reloader:
            autoreload.main(self.inner_run, args, options)
        else:
            self.inner_run(*args, **options)

    def inner_run(self, *args, **options):
        from django.conf import settings
        from django.utils import translation

        threading = options.get(‘use_threading‘)
        shutdown_message = options.get(‘shutdown_message‘, ‘‘)
        quit_command = ‘CTRL-BREAK‘ if sys.platform == ‘win32‘ else ‘CONTROL-C‘

        self.stdout.write("Validating models...\n\n")
        self.validate(display_num_errors=True)
        now = datetime.now().strftime(‘%B %d, %Y - %X‘)
        if six.PY2:
            now = now.decode(get_system_encoding())
    
 　　　　#这里是开始运行时，打印到终端的信息
        self.stdout.write((
            "%(started_at)s\n"
            "Django version %(version)s, using settings %(settings)r\n"
            "Starting development server at http://%(addr)s:%(port)s/\n"
            "Quit the server with %(quit_command)s.\n"
        ) % {
            "started_at": now,
            "version": self.get_version(),
            "settings": settings.SETTINGS_MODULE,
            "addr": ‘[%s]‘ % self.addr if self._raw_ipv6 else 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)

        try:
            handler = self.get_handler(*args, **options)
            run(self.addr, int(self.port), handler,
                ipv6=self.use_ipv6, threading=threading)
        except socket.error as e:
            # Use helpful error messages instead of ugly tracebacks.
            ERRORS = {
                errno.EACCES: "You don‘t have permission to access that port.",
                errno.EADDRINUSE: "That port is already in use.",
                errno.EADDRNOTAVAIL: "That IP address can‘t be assigned-to.",
            }
            try:
                error_text = ERRORS[e.errno]
            except KeyError:
                error_text = str(e)
            self.stderr.write("Error: %s" % error_text)
            # 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(shutdown_message)
            sys.exit(0)

    def get_handler(self, *args, **options):
        """
        Returns the default WSGI handler for the runner.
        """
        return get_internal_wsgi_application()

def get_internal_wsgi_application():
    """
    Loads and returns the WSGI application as configured by the user in
    ``settings.WSGI_APPLICATION``. With the default ``startproject`` layout,
    this will be the ``application`` object in ``projectname/wsgi.py``.

    This function, and the ``WSGI_APPLICATION`` setting itself, are only useful
    for Django‘s internal servers (runserver, runfcgi); external WSGI servers
    should just be configured to point to the correct application object
    directly.

    If settings.WSGI_APPLICATION is not set (is ``None``), we just return
    whatever ``django.core.wsgi.get_wsgi_application`` returns.

    """
    from django.conf import settings
    app_path = getattr(settings, ‘WSGI_APPLICATION‘)
    if app_path is None:
        return get_wsgi_application()

    return import_by_path(
        app_path,
        error_prefix="WSGI application ‘%s‘ could not be loaded; " % app_path
    )

def get_wsgi_application():
    """
    The public interface to Django‘s WSGI support. Should return a WSGI
    callable.

    Allows us to avoid making django.core.handlers.WSGIHandler public API, in
    case the internal WSGI implementation changes or moves in the future.

    """
    return WSGIHandler()

class WSGIHandler(base.BaseHandler):
    initLock = Lock()
    request_class = WSGIRequest    #WSGIRequest实现了wsgi规范 

def run(addr, port, wsgi_handler, ipv6=False, threading=False):
    server_address = (addr, port)
    if threading:
        httpd_cls = type(str(‘WSGIServer‘), (socketserver.ThreadingMixIn, WSGIServer), {})
    else:
        httpd_cls = WSGIServer
    httpd = httpd_cls(server_address, WSGIRequestHandler, ipv6=ipv6)
    httpd.set_app(wsgi_handler)
    httpd.serve_forever()