django源码分析之自动加载(autoreload模块)

自动加载模块(autoreload)

在用runserver启动服务的开发者模式下,Django提供了一种auto-reloader的机制,让用户修改的代码不需要手动重启服务就能生效,它会自动加载新的代码。这个功能大大提高了开发调试的效率。

代码分析

autoreload模块的调用发生在runserver里面,具体代码如下:

def run(self, **options):
    """Run the server, using the autoreloader if needed."""
    use_reloader = options['use_reloader']

    if use_reloader:
        # 自动加载模块的入口
        autoreload.main(self.inner_run, None, options)
    else:
        self.inner_run(None, **options)

runserver.run()根据用户传入的use_reloader来判断是否使用auto-reloader机制(在启动命令中是否加--noreload)。可以看出,真正干活的是self.inner_run,而负责自动加载的则是django.utils.autoreload,入口在autoreload.main(),具体位置在django/utils/autoreload.py

def main(main_func, args=None, kwargs=None):
    if args is None:
        args = ()
    if kwargs is None:
        kwargs = {}

    wrapped_main_func = check_errors(main_func)
    python_reloader(wrapped_main_func, args, kwargs)

autoreload.main()主要针对main_func加了一层错误处理相关的封装,接下来看autoreload.python_reloader

def python_reloader(main_func, args, kwargs):
    # 判断是否存在环境变量RUN_MAIN,且值被设置为true,后续会讲解什么情况下会存在它
    if os.environ.get("RUN_MAIN") == "true":
        # 启动新线程来执行main_func
        _thread.start_new_thread(main_func, args, kwargs)
        try:
            # 这里是检查文件更新的地方,后面讲解
            reloader_thread()
        except KeyboardInterrupt:
            pass
    # 第一次进来的时候,必然会进这个分支,因为没有地方设置过RUN_MAIN
    else:
        try:
            # 其实这里会创建一个新的子进程来运行服务,后面分析
            exit_code = restart_with_reloader()
            # 退出服务
            if exit_code < 0:
                os.kill(os.getpid(), -exit_code)
            else:
                sys.exit(exit_code)
        except KeyboardInterrupt:
            pass

python_reloader比较关键,很明显一开始不存在值为true的环境变量RUN_MAIN,所以第一次肯定会进else分支执行restart_with_reloader()

def restart_with_reloader():
    import django.__main__
    while True:
        # 大概就是生成命令行 python manage.py runserver
        args = [sys.executable] + ['-W%s' % o for o in sys.warnoptions]
        if sys.argv[0] == django.__main__.__file__:
            # The server was started with `python -m django runserver`.
            args += ['-m', 'django']
            args += sys.argv[1:]
        else:
            args += sys.argv
        # 这里设置了环境变量RUN_MAIN,且值为true
        new_environ = {**os.environ, 'RUN_MAIN': 'true'}
        # 这里 再调了一遍命令行 python manage.py runserver
        exit_code = subprocess.call(args, env=new_environ)
        # hard code,>_>,3在这里是一个特殊的退出码,有特殊的用处,下文马上会提到
        if exit_code != 3:
            return exit_code

restart_with_reloader()重新执行了一遍runserver命令,同时设置了值为true的环境变量RUN_MAIN。咋一看,这是一个死循环!其实并不会,环境变量RUN_MAIN防止了这种事情的发生。subprocess.call创建了重新执行runserver命令的子进程,这个子进程会过runserver.run()->autoreload.main()->autoreload.python_reloader这样一条调用链路。然后到autoreload.python_reloader后,因为刚设置了RUN_MAIN,所以新的子进程再进来的时候,它就会进第一个分支了,而不是else分支,也就不会导致死循环,再贴下相关代码。

def python_reloader(main_func, args, kwargs):
    # 判断是否存在环境变量RUN_MAIN,且值被设置为true,后续会讲解什么情况下会存在它
    if os.environ.get("RUN_MAIN") == "true":
        # 启动新线程来执行main_func
        _thread.start_new_thread(main_func, args, kwargs)
        try:
            # 这里是检查文件更新的地方,后面讲解
            reloader_thread()
        except KeyboardInterrupt:
            pass
    # 第一次进来的时候,必然会进这个分支,因为没有地方设置过RUN_MAIN
    else:
        ...

这次新的进程会创建新的线程来执行main_func(上文中的self.inner_run),它才真正启动了服务。而新进程的当前线程去执行reloader_thread(),没错,它就是去执行文件更新检查的逻辑了:

def reloader_thread():
    # 这个是针对unix的设备,貌似是处理写Terminal的信号的逻辑
    ensure_echo_on()
    # 检查文件更新的两种方法
    if USE_INOTIFY:
        # 第一种方法是通过Linux的Inotify来监控文件系统,前提是系统支持。
        fn = inotify_code_changed
    else:
        # 如果系统不支持Inotify特性,就用code_changed,本质上就是对比文件的修改时间。
        fn = code_changed
    while RUN_RELOADER:
        # 循环执行,每一秒会去检查文件是否有更新
        change = fn()
        if change == FILE_MODIFIED:
            # 这里的3就和上文对应上了,如果发现是py文件有修改,就强制退出当前进程,退出码是3,然后restart_with_reloader判断是3,就继续重新subprocess.call生成一个新进程。
            sys.exit(3)  # force reload
        elif change == I18N_MODIFIED:
            # 如果是语音包相关的文件,就通过reset_translations重新加载
            reset_translations()
        time.sleep(1)

到这里已经很明朗了,reloader_thread()每隔1秒去检查文件是否有更新,如果有更新,则退出当前的进程,退出码为3,在上文的restart_with_reloader里,如果退出码为3,在父进程的while循环里面,会重新生成一个子进程,然后重新加载新文件来运行服务。所以不需要我们手动去重启服务,是因为autoreload自动帮我们重启了服务。
最后再看下code_changed,其中一种检查文件更新的方法,它主要通过文件修改时间来判断:

def code_changed():
    global _mtimes, _win
    for filename in gen_filenames():
        # 获取文件属性
        stat = os.stat(filename)
        # 获取文件最后一次修改时间
        mtime = stat.st_mtime
        if _win:
            mtime -= stat.st_ctime
        if filename not in _mtimes:
            _mtimes[filename] = mtime
            continue
        # 判断文件当前修改时间,和上次保存的修改时间是否一致
        if mtime != _mtimes[filename]:
            _mtimes = {}
            try:
                del _error_files[_error_files.index(filename)]
            except ValueError:
                pass
            # 通过判断被修改文件的类型,来做相应的操作
            return I18N_MODIFIED if filename.endswith('.mo') else FILE_MODIFIED
    return False

总结

以上就是autoreload机制的流程:执行runserver命令启动服务时,主进程并没有去启动服务,而是相当于一个守护进程的作用,它会通过subprocess创建子进程,该子进程会创建一个新线程来启动服务,然后子进程的主线程负责检测文件更新,如果发生文件更新则退出该子进程,返回约定的退出码3,守护进程检查子进程的退出码(exist code)如果与约定的退出码一致,则重新启动一个新的子进程继续工作。
需要说明的是autoreload模块是一个独立的模块,也还算比较通用,如果有需要的话,是可以直接拿来主义用的。

推荐阅读更多精彩内容