计算机系统应用教程网站

网站首页 > 技术文章 正文

Django源代码-启动、接收、应用中间件链、路由匹配、完成请求

btikc 2024-09-16 13:03:08 技术文章 24 ℃ 0 评论
  1. if __name__ == "__main__":
  2. # 设置环境变量 export DJANGO_SETTINGS_MODULE="HelloWorld.settings"
  3. os.environ.setdefault("DJANGO_SETTINGS_MODULE", "DebugApp.settings")
  4. try:
  5. from django.core.management import execute_from_command_line
  6. except ImportError:
  7. # The above import may fail for some other reason. Ensure that the
  8. # issue is really that Django is missing to avoid masking other
  9. # exceptions on Python 2.
  10. try:
  11. import django
  12. except ImportError:
  13. raise ImportError(
  14. "Couldn't import Django. Are you sure it's installed and "
  15. "available on your PYTHONPATH environment variable? Did you "
  16. "forget to activate a virtual environment?"
  17. )
  18. raise
  19. execute_from_command_line(sys.argv)
  20. {
  21. utility = ManagementUtility(argv)
  22. {
  23. self.argv = argv or sys.argv[:]
  24. self.prog_name = os.path.basename(self.argv[0])
  25. self.settings_exception = None
  26. }
  28. utility.execute()
  29. {
  30. try:
  31. subcommand = self.argv[1]
  32. except IndexError:
  33. subcommand = 'help' # Display help if no arguments were given.
  35. # Preprocess options to extract --settings and --pythonpath.
  36. # These options could affect the commands that are available, so they
  37. # must be processed early.
  38. parser = CommandParser(None, usage="%(prog)s subcommand [options] [args]", add_help=False)
  39. parser.add_argument('--settings')
  40. parser.add_argument('--pythonpath')
  41. parser.add_argument('args', nargs='*') # catch-all
  42. try:
  43. options, args = parser.parse_known_args(self.argv[2:])
  44. handle_default_options(options)
  45. except CommandError:
  46. pass # Ignore any option errors at this point.
  48. try:
  49. # 安装的 app 列表
  50. settings.INSTALLED_APPS
  51. except ImproperlyConfigured as exc:
  52. self.settings_exception = exc
  54. if settings.configured:
  55. # Start the auto-reloading dev server even if the code is broken.
  56. # The hardcoded condition is a code smell but we can't rely on a
  57. # flag on the command class because we haven't located it yet.
  58. if subcommand == 'runserver' and '--noreload' not in self.argv:
  59. try:
  60. # 包装 django.setup 并执行
  61. autoreload.check_errors(django.setup)()
  62. except Exception:
  63. # The exception will be raised later in the child process
  64. # started by the autoreloader. Pretend it didn't happen by
  65. # loading an empty list of applications.
  66. apps.all_models = defaultdict(OrderedDict)
  67. apps.app_configs = OrderedDict()
  68. apps.apps_ready = apps.models_ready = apps.ready = True
  70. # Remove options not compatible with the built-in runserver
  71. # (e.g. options for the contrib.staticfiles' runserver).
  72. # Changes here require manually testing as described in
  73. # #27522.
  74. _parser = self.fetch_command('runserver').create_parser('django', 'runserver')
  75. _options, _args = _parser.parse_known_args(self.argv[2:])
  76. for _arg in _args:
  77. self.argv.remove(_arg)
  79. # In all other cases, django.setup() is required to succeed.
  80. else:
  81. django.setup()
  82. {
  83. # 安装应用
  84. from django.apps import apps
  85. from django.conf import settings
  86. from django.urls import set_script_prefix
  87. from django.utils.encoding import force_text
  88. from django.utils.log import configure_logging
  90. # 配置日志
  91. configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
  92. {
  93. if logging_config:
  94. # First find the logging configuration function ...
  95. logging_config_func = import_string(logging_config)
  97. logging.config.dictConfig(DEFAULT_LOGGING)
  99. # ... then invoke it with the logging settings
  100. if logging_settings:
  101. logging_config_func(logging_settings)
  102. }
  104. # 设置脚本前缀
  105. if set_prefix:
  106. set_script_prefix(
  107. '/' if settings.FORCE_SCRIPT_NAME is None else force_text(settings.FORCE_SCRIPT_NAME)
  108. )
  109. {
  110. if not prefix.endswith('/'):
  111. prefix += '/'
  112. _prefixes.value = prefix
  113. }
  115. # 填充被安装的应用 -------------------- settings.INSTALLED_APPS ------------- 1 ！！！
  116. apps.populate(settings.INSTALLED_APPS)
  117. {
  118. # installed_apps === settings.INSTALLED_APPS
  120. if self.ready:
  121. return
  123. # populate() might be called by two threads in parallel on servers
  124. # that create threads before initializing the WSGI callable.
  125. with self._lock:
  126. if self.ready:
  127. return
  129. # app_config should be pristine, otherwise the code below won't
  130. # guarantee that the order matches the order in INSTALLED_APPS.
  131. if self.app_configs:
  132. raise RuntimeError("populate() isn't reentrant")
  134. # 阶段 1: 初始化 app 配置 和 导入 app 模块
  135. # Phase 1: initialize app configs and import app modules.
  136. for entry in installed_apps:
  137. # 被安装的应用，如：entry === django.contrib.sessions
  138. if isinstance(entry, AppConfig):
  139. app_config = entry
  140. else:
  141. # 创建 app_config 对象
  142. app_config = AppConfig.create(entry)
  143. {
  144. try:
  145. # 导入模块，如：django.contrib.sessions
  146. # 文件：/Library/Python/2.7/site-packages/django/contrib/sessions/__init__.py ------module------- 1.1
  147. # If import_module succeeds, entry is a path to an app module,
  148. # which may specify an app config class with default_app_config.
  149. # Otherwise, entry is a path to an app config class or an error.
  150. module = import_module(entry)
  152. except ImportError:
  153. # Track that importing as an app module failed. If importing as an
  154. # app config class fails too, we'll trigger the ImportError again.
  155. module = None
  157. mod_path, _, cls_name = entry.rpartition('.')
  159. # Raise the original exception when entry cannot be a path to an
  160. # app config class.
  161. if not mod_path:
  162. raise
  164. else:
  165. try:
  166. # 模块默认app配置
  167. # 文件 /Library/Python/2.7/site-packages/django/contrib/sessions/__init__.py 中 default_app_config ------------- 1.3
  168. # 如：default_app_config = 'django.contrib.sessions.apps.SessionsConfig'
  169. # If this works, the app module specifies an app config class.
  170. entry = module.default_app_config
  171. except AttributeError:
  172. # Otherwise, it simply uses the default app config class.
  173. return cls(entry, module)
  174. else:
  175. # 模块路径，类名
  176. # 如：entry === django.contrib.sessions.apps.SessionsConfig ------------- 1.5
  177. mod_path, _, cls_name = entry.rpartition('.')
  179. # 导入默认的app模块
  180. # mod_path === django.contrib.sessions.apps
  181. # cls_name === SessionsConfig
  182. # If we're reaching this point, we must attempt to load the app config
  183. # class located at <mod_path>.<cls_name>
  184. # 导入文件 /Library/Python/2.7/site-packages/django/contrib/sessions/apps.py 中 ------ mod ------- 1.7
  185. mod = import_module(mod_path)
  186. try:
  187. # 获取类
  188. # 文件 /Library/Python/2.7/site-packages/django/contrib/sessions/apps.py 中 SessionsConfig ------------- 1.9
  189. cls = getattr(mod, cls_name)
  190. except AttributeError:
  191. if module is None:
  192. # If importing as an app module failed, that error probably
  193. # contains the most informative traceback. Trigger it again.
  194. import_module(entry)
  195. else:
  196. raise
  198. # 类必须是 AppConfig 的子类
  199. # Check for obvious errors. (This check prevents duck typing, but
  200. # it could be removed if it became a problem in practice.)
  201. if not issubclass(cls, AppConfig):
  202. raise ImproperlyConfigured(
  203. "'%s' isn't a subclass of AppConfig." % entry)
  205. # Obtain app name here rather than in AppClass.__init__ to keep
  206. # all error checking for entries in INSTALLED_APPS in one place.
  207. try:
  208. # 类的 app 名
  209. # 如：app_name = 'django.contrib.sessions' ------------- 1.11
  210. app_name = cls.name
  211. except AttributeError:
  212. raise ImproperlyConfigured(
  213. "'%s' must supply a name attribute." % entry)
  215. # Ensure app_name points to a valid module.
  216. try:
  217. # 导入 app
  218. # 如：app_name = 'django.contrib.sessions' ------ app_module ------- 1.13
  219. app_module = import_module(app_name)
  220. except ImportError:
  221. raise ImproperlyConfigured(
  222. "Cannot import '%s'. Check that '%s.%s.name' is correct." % (
  223. app_name, mod_path, cls_name,
  224. )
  225. )
  226. # 实例化类
  227. # !!! cls === django.contrib.sessions.apps.SessionsConfig
  228. # !!! 如：app_name ==== 'django.contrib.sessions'
  229. # !!! 如：app_module ==== django.contrib.sessions
  230. # Entry is a path to an app config class.
  231. return cls(app_name, app_module)
  232. {
  233. def __init__(self, app_name, app_module):
  235. # !!! 如：app_name ==== 'django.contrib.sessions'
  236. # Full Python path to the application eg. 'django.contrib.admin'.
  237. self.name = app_name
  239. # !!! 如：app_module ==== django.contrib.sessions
  240. # Root module for the application eg. <module 'django.contrib.admin'
  241. # from 'django/contrib/admin/__init__.pyc'>.
  242. self.module = app_module
  244. # Reference to the Apps registry that holds this AppConfig. Set by the
  245. # registry when it registers the AppConfig instance.
  246. self.apps = None
  248. # The following attributes could be defined at the class level in a
  249. # subclass, hence the test-and-set pattern.
  251. # !!! 如：app_name ==== 'django.contrib.sessions'
  252. # 如：self.label === sessions
  253. # Last component of the Python path to the application eg. 'admin'.
  254. # This value must be unique across a Django project.
  255. if not hasattr(self, 'label'):
  256. self.label = app_name.rpartition(".")[2]
  258. # 转成驼峰
  259. # Human-readable name for the application eg. "Admin".
  260. if not hasattr(self, 'verbose_name'):
  261. self.verbose_name = self.label.title()
  263. # 模块路径
  264. # Filesystem path to the application directory eg.
  265. # u'/usr/lib/python2.7/dist-packages/django/contrib/admin'. Unicode on
  266. # Python 2 and a str on Python 3.
  267. if not hasattr(self, 'path'):
  268. self.path = self._path_from_module(app_module)
  270. # Module containing models eg. <module 'django.contrib.admin.models'
  271. # from 'django/contrib/admin/models.pyc'>. Set by import_models().
  272. # None if the application doesn't have a models module.
  273. self.models_module = None
  275. # Mapping of lower case model names to model classes. Initially set to
  276. # None to prevent accidental access before import_models() runs.
  277. self.models = None
  278. }
  279. }
  281. # 如：app_config === django.contrib.sessions.apps.SessionsConfig
  282. # 获取 app_config 对象的属性
  283. if app_config.label in self.app_configs:
  284. raise ImproperlyConfigured(
  285. "Application labels aren't unique, "
  286. "duplicates: %s" % app_config.label)
  288. # 保存 app_config 对象到 map 结构
  289. self.app_configs[app_config.label] = app_config
  290. # !!! 设置 app_config 对 django.apps.registry.Apps 的依赖 !!!
  291. app_config.apps = self
  293. # !!!!!!!!!!!! 至此，迭代完所有的 settings.INSTALLED_APPS !!!!!!!!!!!!
  295. # 所有应用的配置
  296. # Check for duplicate app names.
  297. counts = Counter(
  298. app_config.name for app_config in self.app_configs.values())
  299. duplicates = [
  300. name for name, count in counts.most_common() if count > 1]
  301. if duplicates: # 重复
  302. raise ImproperlyConfigured(
  303. "Application names aren't unique, "
  304. "duplicates: %s" % ", ".join(duplicates))
  306. self.apps_ready = True
  308. # 阶段2：迭代 app_config，导入 models 模块 ------------------ app_configs ------------------- 1.15
  309. # Phase 2: import models modules.
  310. for app_config in self.app_configs.values():
  311. # 如：app_config === django.contrib.sessions.apps.SessionsConfig
  312. app_config.import_models()
  313. {
  314. # 如：self.apps === django.apps.registry.Apps
  315. self.models = self.apps.all_models[self.label]
  317. # !!! 导入子模块
  318. # 如：self.module === django.contrib.sessions
  319. if module_has_submodule(self.module, MODELS_MODULE_NAME):
  320. # MODELS_MODULE_NAME === models
  321. # 如：django.contrib.sessions.models
  322. models_module_name = '%s.%s' % (self.name, MODELS_MODULE_NAME)
  323. # 导入 django.contrib.sessions.models 模块
  324. self.models_module = import_module(models_module_name)
  325. }
  327. self.clear_cache()
  329. self.models_ready = True
  331. # 阶段 3: 迭代 app_config，调用 app_config 的 ready() 方法
  332. # Phase 3: run ready() methods of app configs.
  333. for app_config in self.get_app_configs():
  334. app_config.ready()
  336. self.ready = True
  337. }
  339. }
  341. self.autocomplete()
  342. {
  343. # Don't complete if user hasn't sourced bash_completion file.
  344. if 'DJANGO_AUTO_COMPLETE' not in os.environ:
  345. return
  347. ......
  348. }
  350. if subcommand == 'help':
  351. if '--commands' in args:
  352. sys.stdout.write(self.main_help_text(commands_only=True) + '\n')
  353. elif len(options.args) < 1:
  354. sys.stdout.write(self.main_help_text() + '\n')
  355. else:
  356. self.fetch_command(options.args[0]).print_help(self.prog_name, options.args[0])
  357. # Special-cases: We want 'django-admin --version' and
  358. # 'django-admin --help' to work, for backwards compatibility.
  359. elif subcommand == 'version' or self.argv[1:] == ['--version']:
  360. sys.stdout.write(django.get_version() + '\n')
  361. elif self.argv[1:] in (['--help'], ['-h']):
  362. sys.stdout.write(self.main_help_text() + '\n')
  363. else:
  364. #
  365. self.fetch_command(subcommand){
  366. # 获取 commands 列表
  367. # Get commands outside of try block to prevent swallowing exceptions
  368. commands = get_commands()
  369. {
  370. commands = {name: 'django.core' for name in find_commands(upath(__path__[0])){
  371. # 如：management_dir === upath(__path__[0])
  372. # 如：management_dir === /Library/Python/2.7/site-packages/django/core/management
  373. # 如：command_dir === /Library/Python/2.7/site-packages/django/core/management/commands
  374. command_dir = os.path.join(management_dir, 'commands')
  375. return [name for _, name, is_pkg in pkgutil.iter_modules([npath(command_dir)])
  376. if not is_pkg and not name.startswith('_')]
  377. }}
  379. if not settings.configured:
  380. return commands
  382. # 迭代 app_config 列表中的 commands
  383. for app_config in reversed(list(apps.get_app_configs())):
  384. path = os.path.join(app_config.path, 'management')
  385. # 查找 app_config 中的 Command 对象
  386. commands.update({name: app_config.name for name in find_commands(path)})
  388. return commands
  389. }
  391. try:
  392. # 命中 Command 对象
  393. # commands === {
  394. # 'check': 'django.core',
  395. # 'compilemessages': 'django.core',
  396. # 'runserver': 'django.core'
  397. # ...
  398. # }
  399. app_name = commands[subcommand]
  400. except KeyError:
  401. if os.environ.get('DJANGO_SETTINGS_MODULE'):
  402. # If `subcommand` is missing due to misconfigured settings, the
  403. # following line will retrigger an ImproperlyConfigured exception
  404. # (get_commands() swallows the original one) so the user is
  405. # informed about it.
  406. settings.INSTALLED_APPS
  407. else:
  408. sys.stderr.write("No Django settings specified.\n")
  409. sys.stderr.write(
  410. "Unknown command: %r\nType '%s help' for usage.\n"
  411. % (subcommand, self.prog_name)
  412. )
  413. sys.exit(1)
  415. if isinstance(app_name, BaseCommand):
  416. # If the command is already loaded, use it directly.
  417. klass = app_name
  418. else:
  419. # 实例化 Command 对象
  420. # 如： app_name === 'django.core'，subcommand === 'runserver'
  421. klass = load_command_class(app_name, subcommand)
  422. {
  423. # 如： module === django.core.management.commands.runserver
  424. # 导入模块 /Library/Python/2.7/site-packages/django/core/management/commands/runserver.py
  425. module = import_module('%s.management.commands.%s' % (app_name, name))
  427. # 实例化 Command 对象
  428. # 如：module.Command() === django.core.management.commands.runserver.Command()
  429. return module.Command()
  430. }
  432. # 如： klass === django.core.management.commands.runserver.Command()
  433. return klass
  434. }
  435. .run_from_argv(self.argv) # 根据参数运行
  436. {
  437. # !!!! 执行 django.core.management.commands.runserver.Command().run_from_argv(self.argv)
  439. self._called_from_command_line = True
  441. # 创建参数解析器
  442. parser = self.create_parser(argv[0], argv[1])
  443. {
  444. parser = CommandParser(
  445. self, prog="%s %s" % (os.path.basename(prog_name), subcommand),
  446. description=self.help or None,
  447. )
  448. parser.add_argument('--version', action='version', version=self.get_version())
  449. parser.add_argument(
  450. '-v', '--verbosity', action='store', dest='verbosity', default=1,
  451. type=int, choices=[0, 1, 2, 3],
  452. help='Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output',
  453. )
  454. parser.add_argument(
  455. '--settings',
  456. help=(
  457. 'The Python path to a settings module, e.g. '
  458. '"myproject.settings.main". If this isn\'t provided, the '
  459. 'DJANGO_SETTINGS_MODULE environment variable will be used.'
  460. ),
  461. )
  462. parser.add_argument(
  463. '--pythonpath',
  464. help='A directory to add to the Python path, e.g. "/home/djangoprojects/myproject".',
  465. )
  466. parser.add_argument('--traceback', action='store_true', help='Raise on CommandError exceptions')
  467. parser.add_argument(
  468. '--no-color', action='store_true', dest='no_color', default=False,
  469. help="Don't colorize the command output.",
  470. )
  471. self.add_arguments(parser)
  472. return parser
  473. }
  475. # 解析参数
  476. options = parser.parse_args(argv[2:])
  477. cmd_options = vars(options)
  478. # Move positional args out of options to mimic legacy optparse
  479. args = cmd_options.pop('args', ())
  481. # 处理默认选项
  482. handle_default_options(options)
  483. {
  484. if options.settings:
  485. os.environ['DJANGO_SETTINGS_MODULE'] = options.settings
  486. if options.pythonpath:
  487. sys.path.insert(0, options.pythonpath)
  488. }
  490. # ！！！执行 ！！！
  491. try:
  492. self.execute(*args, **cmd_options)
  493. {
  494. # 调用子类
  495. if options['no_color']:
  496. # We rely on the environment because it's currently the only
  497. # way to reach WSGIRequestHandler. This seems an acceptable
  498. # compromise considering `runserver` runs indefinitely.
  499. os.environ[str("DJANGO_COLORS")] = str("nocolor")
  501. # 调用父类 execute - begain
  502. super(Command, self).execute(*args, **options)
  503. {
  504. if options['no_color']:
  505. self.style = no_style()
  506. self.stderr.style_func = None
  507. if options.get('stdout'):
  508. self.stdout = OutputWrapper(options['stdout'])
  509. if options.get('stderr'):
  510. self.stderr = OutputWrapper(options['stderr'], self.stderr.style_func)
  512. saved_locale = None
  513. if not self.leave_locale_alone:
  514. # Deactivate translations, because django-admin creates database
  515. # content like permissions, and those shouldn't contain any
  516. # translations.
  517. from django.utils import translation
  518. saved_locale = translation.get_language()
  519. translation.deactivate_all()
  521. try:
  522. if self.requires_system_checks and not options.get('skip_checks'):
  523. self.check()
  524. if self.requires_migrations_checks:
  525. self.check_migrations()
  527. # !!! ------ 调用子类的 handle 方法 -------
  528. output = self.handle(*args, **options)
  529. {
  530. from django.conf import settings
  532. if not settings.DEBUG and not settings.ALLOWED_HOSTS:
  533. raise CommandError('You must set settings.ALLOWED_HOSTS if DEBUG is False.')
  535. self.use_ipv6 = options['use_ipv6']
  536. if self.use_ipv6 and not socket.has_ipv6:
  537. raise CommandError('Your Python does not support IPv6.')
  538. self._raw_ipv6 = False
  539. if not options['addrport']:
  540. self.addr = ''
  541. self.port = self.default_port
  542. else:
  543. m = re.match(naiveip_re, options['addrport'])
  544. if m is None:
  545. raise CommandError('"%s" is not a valid port number '
  546. 'or address:port pair.' % options['addrport'])
  547. self.addr, _ipv4, _ipv6, _fqdn, self.port = m.groups()
  548. if not self.port.isdigit():
  549. raise CommandError("%r is not a valid port number." % self.port)
  550. if self.addr:
  551. if _ipv6:
  552. self.addr = self.addr[1:-1]
  553. self.use_ipv6 = True
  554. self._raw_ipv6 = True
  555. elif self.use_ipv6 and not _fqdn:
  556. raise CommandError('"%s" is not a valid IPv6 address.' % self.addr)
  557. if not self.addr:
  558. self.addr = '::1' if self.use_ipv6 else '127.0.0.1'
  559. self._raw_ipv6 = self.use_ipv6
  561. # !!! ------ 调用 run() 方法 ------------
  562. self.run(**options)
  563. {
  564. # 是否使用自动加载器
  565. use_reloader = options['use_reloader']
  567. if use_reloader:
  568. # 包装 self.inner_run 函数
  569. autoreload.main(self.inner_run, None, options)
  570. {
  571. if args is None:
  572. args = ()
  573. if kwargs is None:
  574. kwargs = {}
  575. if sys.platform.startswith('java'):
  576. reloader = jython_reloader
  577. else:
  578. reloader = python_reloader
  580. wrapped_main_func = check_errors(main_func)
  581. {
  582. def wrapper(*args, **kwargs):
  583. global _exception
  584. try:
  585. # 执行 inner_run 函数
  586. fn(*args, **kwargs)
  587. except Exception:
  588. _exception = sys.exc_info()
  590. et, ev, tb = _exception
  592. if getattr(ev, 'filename', None) is None:
  593. # get the filename from the last item in the stack
  594. filename = traceback.extract_tb(tb)[-1][0]
  595. else:
  596. filename = ev.filename
  598. if filename not in _error_files:
  599. _error_files.append(filename)
  601. raise
  603. return wrapper
  604. }
  606. # 当 reloader = python_reloader
  607. reloader(wrapped_main_func, args, kwargs)
  608. {
  609. # main_func === wrapped_main_func
  610. if os.environ.get("RUN_MAIN") == "true":
  611. # ！！！执行 wrapped_main_func 函数
  612. thread.start_new_thread(main_func, args, kwargs)
  613. # ！！！启动监控，监控代码是否改变
  614. try:
  615. reloader_thread()
  616. {
  617. ensure_echo_on()
  618. if USE_INOTIFY:
  619. fn = inotify_code_changed
  620. else:
  621. fn = code_changed
  622. while RUN_RELOADER:
  623. # 文件改变
  624. change = fn()
  625. if change == FILE_MODIFIED:
  626. sys.exit(3) # force reload 强制重新启动,退出码=3
  627. elif change == I18N_MODIFIED:
  628. reset_translations()
  629. time.sleep(1)
  630. }
  631. except KeyboardInterrupt:
  632. pass
  633. else:
  634. try:
  635. exit_code = restart_with_reloader()
  636. {
  637. while True: # 无限循环
  638. args = [sys.executable] + ['-W%s' % o for o in sys.warnoptions] + sys.argv
  639. new_environ = os.environ.copy()
  640. if _win and six.PY2:
  641. # Environment variables on Python 2 + Windows must be str.
  642. encoding = get_system_encoding()
  643. for key in new_environ.keys():
  644. str_key = key.decode(encoding).encode('utf-8')
  645. str_value = new_environ[key].decode(encoding).encode('utf-8')
  646. del new_environ[key]
  647. new_environ[str_key] = str_value
  648. # 设置环境
  649. new_environ["RUN_MAIN"] = 'true'
  650. # 启动子进程，并等待 exit_code
  651. exit_code = subprocess.call(args, env=new_environ)
  652. if exit_code != 3: # 退出码!=3
  653. return exit_code
  654. }
  655. if exit_code < 0:
  656. os.kill(os.getpid(), -exit_code)
  657. else:
  658. sys.exit(exit_code)
  659. except KeyboardInterrupt:
  660. pass
  661. }
  662. }
  663. else:
  664. # ------------ !!! 运行 !!! ------------
  665. self.inner_run(None, **options)
  666. {
  667. # If an exception was silenced in ManagementUtility.execute in order
  668. # to be raised in the child process, raise it now.
  669. autoreload.raise_last_exception()
  671. # 使用线程
  672. threading = options['use_threading']
  673. # 'shutdown_message' is a stealth option.
  674. shutdown_message = options.get('shutdown_message', '')
  675. quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C'
  677. self.stdout.write("Performing system checks...\n\n")
  678. self.check(display_num_errors=True)
  679. # Need to check migrations here, so can't use the
  680. # requires_migrations_check attribute.
  681. self.check_migrations()
  682. now = datetime.now().strftime('%B %d, %Y - %X')
  683. if six.PY2:
  684. now = now.decode(get_system_encoding())
  685. self.stdout.write(now)
  686. self.stdout.write((
  687. "Django version %(version)s, using settings %(settings)r\n"
  688. "Starting development server at %(protocol)s://%(addr)s:%(port)s/\n"
  689. "Quit the server with %(quit_command)s.\n"
  690. ) % {
  691. "version": self.get_version(),
  692. "settings": settings.SETTINGS_MODULE,
  693. "protocol": self.protocol,
  694. "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr,
  695. "port": self.port,
  696. "quit_command": quit_command,
  697. })
  699. try:
  700. # handler === django.core.handlers.wsgi.WSGIHandler
  701. handler = self.get_handler(*args, **options)
  702. {
  703. return get_internal_wsgi_application()
  704. {
  705. from django.conf import settings
  706. app_path = getattr(settings, 'WSGI_APPLICATION')
  707. if app_path is None:
  708. return get_wsgi_application()
  709. {
  710. # 安装
  711. django.setup(set_prefix=False)
  712. {
  713. from django.apps import apps
  714. from django.conf import settings
  715. from django.urls import set_script_prefix
  716. from django.utils.encoding import force_text
  717. from django.utils.log import configure_logging
  718. # 日志
  719. configure_logging(settings.LOGGING_CONFIG, settings.LOGGING)
  720. if set_prefix:
  721. set_script_prefix(
  722. '/' if settings.FORCE_SCRIPT_NAME is None else force_text(settings.FORCE_SCRIPT_NAME)
  723. )
  724. # 填充 settings.INSTALLED_APPS
  725. apps.populate(settings.INSTALLED_APPS)
  726. }
  728. # 创建 django.core.handlers.wsgi.WSGIHandler 对象
  729. return WSGIHandler(){
  730. def __init__(self, *args, **kwargs):
  731. super(WSGIHandler, self).__init__(*args, **kwargs)
  732. {
  733. self._request_middleware = None
  734. self._view_middleware = None
  735. self._template_response_middleware = None
  736. self._response_middleware = None
  737. self._exception_middleware = None
  738. self._middleware_chain = None
  739. }
  741. # ------ 加载 中间件
  742. self.load_middleware()
  743. {
  744. self._request_middleware = []
  745. self._view_middleware = []
  746. self._template_response_middleware = []
  747. self._response_middleware = []
  748. self._exception_middleware = []
  750. # -------------------- 中间件 settings.MIDDLEWARE ------------- 1 ！！！
  751. if settings.MIDDLEWARE is None:
  752. warnings.warn(
  753. "Old-style middleware using settings.MIDDLEWARE_CLASSES is "
  754. "deprecated. Update your middleware and use settings.MIDDLEWARE "
  755. "instead.", RemovedInDjango20Warning
  756. )
  757. handler = convert_exception_to_response(self._legacy_get_response)
  759. for middleware_path in settings.MIDDLEWARE_CLASSES:
  760. mw_class = import_string(middleware_path)
  761. try:
  762. mw_instance = mw_class()
  763. except MiddlewareNotUsed as exc:
  764. if settings.DEBUG:
  765. if six.text_type(exc):
  766. logger.debug('MiddlewareNotUsed(%r): %s', middleware_path, exc)
  767. else:
  768. logger.debug('MiddlewareNotUsed: %r', middleware_path)
  769. continue
  771. if hasattr(mw_instance, 'process_request'):
  772. self._request_middleware.append(mw_instance.process_request)
  773. if hasattr(mw_instance, 'process_view'):
  774. self._view_middleware.append(mw_instance.process_view)
  775. if hasattr(mw_instance, 'process_template_response'):
  776. self._template_response_middleware.insert(0, mw_instance.process_template_response)
  777. if hasattr(mw_instance, 'process_response'):
  778. self._response_middleware.insert(0, mw_instance.process_response)
  779. if hasattr(mw_instance, 'process_exception'):
  780. self._exception_middleware.insert(0, mw_instance.process_exception)
  781. else:
  782. # !!! convert_exception_to_response 的用途是：包装一层 _get_response 函数，并添加捕获 _get_response 异常的代码
  783. handler = convert_exception_to_response(self._get_response)
  784. {
  785. # def convert_exception_to_response(get_response):
  786. @wraps(get_response, assigned=available_attrs(get_response))
  787. def inner(request):
  788. try:
  789. # get_response === self._get_response
  790. response = get_response(request)
  791. {
  792. # def _get_response(self, request):
  793. response = None
  795. # !!! 路由解析器
  796. if hasattr(request, 'urlconf'):
  797. urlconf = request.urlconf
  798. set_urlconf(urlconf)
  799. resolver = get_resolver(urlconf)
  800. else:
  801. resolver = get_resolver()
  802. {
  803. @lru_cache.lru_cache(maxsize=None)
  804. def get_resolver(urlconf=None):
  805. if urlconf is None:
  806. from django.conf import settings
  807. # ------------------------------------------------------------------- ！！！获取 settings.ROOT_URLCONF 信息
  808. urlconf = settings.ROOT_URLCONF
  809. # urlconf === 'DebugApp.urls'
  810. return RegexURLResolver(r'^/', urlconf)
  811. {
  812. # RegexURLResolver 构造函数
  813. def __init__(self, regex, urlconf_name, default_kwargs=None, app_name=None, namespace=None):
  814. LocaleRegexProvider.__init__(self, regex)
  815. {
  816. # LocaleRegexProvider 构造函数
  817. def __init__(self, regex):
  818. # regex is either a string representing a regular expression, or a
  819. # translatable string (using ugettext_lazy) representing a regular
  820. # expression.
  821. self._regex = regex
  822. self._regex_dict = {}
  823. regex = LocaleRegexDescriptor()
  824. }
  825. # urlconf_name is the dotted Python path to the module defining
  826. # urlpatterns. It may also be an object with an urlpatterns attribute
  827. # or urlpatterns itself.
  828. self.urlconf_name = urlconf_name
  829. self.callback = None
  830. self.default_kwargs = default_kwargs or {}
  831. self.namespace = namespace
  832. self.app_name = app_name
  833. self._reverse_dict = {}
  834. self._namespace_dict = {}
  835. self._app_dict = {}
  836. # set of dotted paths to all functions and classes that are used in
  837. # urlpatterns
  838. self._callback_strs = set()
  839. self._populated = False
  840. self._local = threading.local()
  841. }
  842. }
  844. # !!! ------------------------ 匹配出路由 ------------------------ !!!
  845. resolver_match = resolver.resolve(request.path_info)
  846. {
  847. path = force_text(path) # path may be a reverse_lazy object
  848. tried = []
  849. # 匹配 '/'
  850. match = self.regex.search(path)
  851. if match:
  852. new_path = path[match.end():]
  853. # self.url_patterns = {
  854. # @cached_property
  855. # def url_patterns(self):
  856. # # urlconf_module might be a valid set of patterns, so we default to it
  857. # # 导入模块
  858. # # self.urlconf_module = {
  859. # # @cached_property
  860. # # def urlconf_module(self):
  861. # # if isinstance(self.urlconf_name, six.string_types):
  862. # # return import_module(self.urlconf_name)
  863. # # else:
  864. # # return self.urlconf_name
  865. # # }
  866. # patterns = getattr(self.urlconf_module, "urlpatterns", self.urlconf_module)
  867. # try:
  868. # iter(patterns)
  869. # except TypeError:
  870. # msg = (
  871. # "The included URLconf '{name}' does not appear to have any "
  872. # "patterns in it. If you see valid patterns in the file then "
  873. # "the issue is probably caused by a circular import."
  874. # )
  875. # raise ImproperlyConfigured(msg.format(name=self.urlconf_name))
  876. # return patterns
  877. # }
  878. # 迭代所以配置的路由，进行匹配
  879. for pattern in self.url_patterns:
  880. try:
  881. # 匹配到路由
  882. sub_match = pattern.resolve(new_path)
  883. except Resolver404 as e:
  884. sub_tried = e.args[0].get('tried')
  885. if sub_tried is not None:
  886. tried.extend([pattern] + t for t in sub_tried)
  887. else:
  888. tried.append([pattern])
  889. else:
  890. if sub_match:
  891. # Merge captured arguments in match with submatch
  892. sub_match_dict = dict(match.groupdict(), **self.default_kwargs)
  893. sub_match_dict.update(sub_match.kwargs)
  895. # If there are *any* named groups, ignore all non-named groups.
  896. # Otherwise, pass all non-named arguments as positional arguments.
  897. sub_match_args = sub_match.args
  898. if not sub_match_dict:
  899. sub_match_args = match.groups() + sub_match.args
  901. return ResolverMatch(
  902. sub_match.func, # 回调函数
  903. sub_match_args, # 参数
  904. sub_match_dict,
  905. sub_match.url_name,
  906. [self.app_name] + sub_match.app_names,
  907. [self.namespace] + sub_match.namespaces,
  908. )
  909. tried.append([pattern])
  910. raise Resolver404({'tried': tried, 'path': new_path})
  911. raise Resolver404({'path': path})
  912. }
  913. # callback = 要调用的函数
  914. # callback_args = 函数参数
  915. # callback_kwargs = 函数的动态参数
  916. callback, callback_args, callback_kwargs = resolver_match
  917. request.resolver_match = resolver_match
  919. # Apply view middleware
  920. # ！！！ 应用 _view_middleware 类型的中间件
  921. for middleware_method in self._view_middleware:
  922. response = middleware_method(request, callback, callback_args, callback_kwargs)
  923. if response:
  924. break
  926. if response is None:
  927. # ------------------------------ wrapped_callback === 用户定义的 action
  928. wrapped_callback = self.make_view_atomic(callback)
  929. try:
  930. # ------------------------------ 执行用户定义的 action
  931. response = wrapped_callback(request, *callback_args, **callback_kwargs)
  932. except Exception as e:
  933. response = self.process_exception_by_middleware(e, request)
  935. # Complain if the view returned None (a common error).
  936. if response is None:
  937. if isinstance(callback, types.FunctionType): # FBV
  938. view_name = callback.__name__
  939. else: # CBV
  940. view_name = callback.__class__.__name__ + '.__call__'
  942. raise ValueError(
  943. "The view %s.%s didn't return an HttpResponse object. It "
  944. "returned None instead." % (callback.__module__, view_name)
  945. )
  947. # 对象 response 有 render 方法，那么进行调用 render
  948. # If the response supports deferred rendering, apply template
  949. # response middleware and then render the response
  950. elif hasattr(response, 'render') and callable(response.render):
  951. # 应用 _template_response_middleware 类型的中间件
  952. for middleware_method in self._template_response_middleware:
  953. response = middleware_method(request, response)
  954. # Complain if the template response middleware returned None (a common error).
  955. if response is None:
  956. raise ValueError(
  957. "%s.process_template_response didn't return an "
  958. "HttpResponse object. It returned None instead."
  959. % (middleware_method.__self__.__class__.__name__)
  960. )
  962. try:
  963. # 调用 render 方法
  964. response = response.render()
  965. except Exception as e:
  966. response = self.process_exception_by_middleware(e, request)
  968. return response
  969. }
  970. except Exception as exc:
  971. response = response_for_exception(request, exc)
  972. return response
  973. return inner # ------------
  974. }
  975. # handler = inner(request){ ... }
  977. # -------------------- 中间件列表 settings.MIDDLEWARE ------------- 1 ！！！
  978. # 反转 中间件列表，并包装 handler
  979. for middleware_path in reversed(settings.MIDDLEWARE):
  980. middleware = import_string(middleware_path)
  981. try:
  982. # 用 middleware 包裹 handler
  983. mw_instance = middleware(handler)
  984. except MiddlewareNotUsed as exc:
  985. if settings.DEBUG:
  986. if six.text_type(exc):
  987. logger.debug('MiddlewareNotUsed(%r): %s', middleware_path, exc)
  988. else:
  989. logger.debug('MiddlewareNotUsed: %r', middleware_path)
  990. continue
  992. if mw_instance is None:
  993. raise ImproperlyConfigured(
  994. 'Middleware factory %s returned None.' % middleware_path
  995. )
  997. if hasattr(mw_instance, 'process_view'):
  998. # process_view 中间件
  999. self._view_middleware.insert(0, mw_instance.process_view)
  1000. if hasattr(mw_instance, 'process_template_response'):
  1001. # process_template_response 中间件
  1002. self._template_response_middleware.append(mw_instance.process_template_response)
  1003. if hasattr(mw_instance, 'process_exception'):
  1004. # process_exception 中间件
  1005. self._exception_middleware.append(mw_instance.process_exception)
  1006. # !!! convert_exception_to_response 的用途是：包装一层 mw_instance 函数，并添加捕获 mw_instance 异常的代码
  1007. handler = convert_exception_to_response(mw_instance)
  1009. # -------------------- middleware 链条
  1010. # We only assign to this when initialization is complete as it is used
  1011. # as a flag for initialization being complete.
  1012. self._middleware_chain = handler
  1013. }
  1014. }
  1015. }
  1017. try:
  1018. return import_string(app_path)
  1019. except ImportError as e:
  1020. msg = (
  1021. "WSGI application '%(app_path)s' could not be loaded; "
  1022. "Error importing module: '%(exception)s'" % ({
  1023. 'app_path': app_path,
  1024. 'exception': e,
  1025. })
  1026. )
  1027. six.reraise(ImproperlyConfigured, ImproperlyConfigured(msg),
  1028. sys.exc_info()[2])
  1030. }
  1031. }
  1033. # handler === django.core.handlers.wsgi.WSGIHandler
  1034. # 执行
  1035. # default_port = '8000'
  1036. # protocol = 'http'
  1037. # server_cls = django.core.servers.basehttp.WSGIServer
  1038. run(self.addr, int(self.port), handler,ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls)
  1039. {
  1040. server_address = (addr, port)
  1041. if threading:
  1042. # 多线程的支持
  1043. # 让 socketserver.ThreadingMixIn 继承，并重新 server_cls 内的方法
  1044. httpd_cls = type(str('WSGIServer'), (socketserver.ThreadingMixIn, server_cls), {})
  1045. else:
  1046. # 单线程
  1047. # httpd_cls = django.core.servers.basehttp.WSGIServer
  1048. httpd_cls = server_cls
  1050. httpd = httpd_cls(server_address, WSGIRequestHandler, ipv6=ipv6)
  1051. {
  1052. def __init__(self, *args, **kwargs):
  1053. if kwargs.pop('ipv6', False):
  1054. self.address_family = socket.AF_INET6
  1055. self.allow_reuse_address = kwargs.pop('allow_reuse_address', True)
  1056. super(WSGIServer, self).__init__(*args, **kwargs)
  1057. {
  1058. # TCPServer
  1059. def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
  1060. BaseServer.__init__(self, server_address, RequestHandlerClass)
  1061. {
  1062. def __init__(self, server_address, RequestHandlerClass):
  1063. self.server_address = server_address
  1064. # ------- RequestHandlerClass ------- 处理类
  1065. self.RequestHandlerClass = RequestHandlerClass
  1066. self.__is_shut_down = threading.Event()
  1067. self.__shutdown_request = False
  1068. }
  1069. # 创建 socket
  1070. self.socket = socket.socket(self.address_family, self.socket_type)
  1071. if bind_and_activate:
  1072. try:
  1073. self.server_bind()
  1074. {
  1075. # WSGIServer
  1076. def server_bind(self):
  1077. HTTPServer.server_bind(self)
  1078. {
  1079. # HTTPServer
  1080. def server_bind(self):
  1081. # TCPServer
  1082. SocketServer.TCPServer.server_bind(self)
  1083. {
  1084. def server_bind(self):
  1085. if self.allow_reuse_address:
  1086. self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  1087. # 设置监听地址
  1088. self.socket.bind(self.server_address)
  1089. self.server_address = self.socket.getsockname()
  1090. }
  1091. host, port = self.socket.getsockname()[:2]
  1092. self.server_name = socket.getfqdn(host)
  1093. self.server_port = port
  1094. }
  1095. # WSGIServer
  1096. self.setup_environ()
  1097. {
  1098. def setup_environ(self):
  1099. # Set up base environment
  1100. env = self.base_environ = {}
  1101. env['SERVER_NAME'] = self.server_name
  1102. env['GATEWAY_INTERFACE'] = 'CGI/1.1'
  1103. env['SERVER_PORT'] = str(self.server_port)
  1104. env['REMOTE_HOST']=''
  1105. env['CONTENT_LENGTH']=''
  1106. env['SCRIPT_NAME'] = ''
  1107. }
  1108. }
  1109. self.server_activate()
  1110. {
  1111. def server_activate(self):
  1112. # 设置监听队列
  1113. self.socket.listen(self.request_queue_size)
  1114. }
  1115. except:
  1116. self.server_close()
  1117. raise
  1119. }
  1120. }
  1121. if threading:
  1122. # ThreadingMixIn.daemon_threads indicates how threads will behave on an
  1123. # abrupt shutdown; like quitting the server by the user or restarting
  1124. # by the auto-reloader. True means the server will not wait for thread
  1125. # termination before it quits. This will make auto-reloader faster
  1126. # and will prevent the need to kill the server manually if a thread
  1127. # isn't terminating correctly.
  1128. httpd.daemon_threads = True
  1130. # 设置 wsgi_handler 处理器
  1131. # 如：httpd = django.core.servers.basehttp.WSGIServer
  1132. # 如：wsgi_handler == django.core.handlers.wsgi.WSGIHandler
  1133. httpd.set_app(wsgi_handler)
  1134. {
  1135. def set_app(self,application):
  1136. # 如：application == django.core.handlers.wsgi.WSGIHandler
  1137. self.application = application
  1138. }
  1140. # 执行监听
  1141. # 如：httpd = django.core.servers.basehttp.WSGIServer
  1142. httpd.serve_forever()
  1143. {
  1144. def serve_forever(self, poll_interval=0.5):
  1145. self.__is_shut_down.clear()
  1146. try:
  1147. # 死循环
  1148. while not self.__shutdown_request:
  1149. # 通过 select.select 获取连接句柄
  1150. # XXX: Consider using another file descriptor or
  1151. # connecting to the socket to wake this up instead of
  1152. # polling. Polling reduces our responsiveness to a
  1153. # shutdown request and wastes cpu at all other times.
  1154. r, w, e = _eintr_retry(select.select, [self], [], [],poll_interval)
  1155. {
  1156. def _eintr_retry(func, *args):
  1157. # restart a system call interrupted by EINTR
  1158. while True:
  1159. try:
  1160. return func(*args)
  1161. except (OSError, select.error) as e:
  1162. if e.args[0] != errno.EINTR:
  1163. raise
  1164. }
  1165. # 读句柄
  1166. if self in r:
  1167. self._handle_request_noblock()
  1168. {
  1169. def _handle_request_noblock(self):
  1170. # Handle one request, without blocking.
  1171. # I assume that select.select has returned that the socket is
  1172. # readable before this function was called, so there should be
  1173. # no risk of blocking in get_request().
  1174. try:
  1175. # 获取连接 request === connection
  1176. request, client_address = self.get_request()
  1177. {
  1178. def get_request(self):
  1179. # Get the request and client address from the socket.
  1180. # May be overridden.
  1181. return self.socket.accept()
  1182. }
  1183. except socket.error:
  1184. return
  1185. # 连接 request === connection
  1186. if self.verify_request(request, client_address):
  1187. try:
  1188. # 单进程/单线程方案，不会被重写
  1189. # 多线程方案，socketserver.ThreadingMixIn 会重写 process_request(...) 方法
  1190. # 多进程方案，socketserver.ForkingMixIn 会重写 process_request(...) 方法
  1191. # 获取连接 request === connection
  1192. self.process_request(request, client_address)
  1193. {
  1194. # 连接 request === connection
  1195. def process_request(self, request, client_address):
  1196. # Call finish_request.
  1197. # Overridden by ForkingMixIn and ThreadingMixIn.
  1198. self.finish_request(request, client_address)
  1199. {
  1200. def finish_request(self, request, client_address):
  1201. # 执行请求 request === connection
  1202. # RequestHandlerClass === django.core.servers.basehttp.WSGIRequestHandler
  1203. # Finish one request by instantiating RequestHandlerClass.
  1204. self.RequestHandlerClass(request, client_address, self)
  1205. {
  1206. # BaseRequestHandler
  1207. def __init__(self, request, client_address, server):
  1208. # request 对象 request == connection
  1209. self.request = request
  1210. self.client_address = client_address
  1211. # 如： server == django.core.servers.basehttp.WSGIServer
  1212. self.server = server
  1213. # 安装请求 === django.core.servers.basehttp.WSGIRequestHandler.setup()
  1214. self.setup()
  1215. {
  1216. # SocketServer.StreamRequestHandler
  1217. def setup(self):
  1218. # 连接 connection == request
  1219. self.connection = self.request
  1220. if self.timeout is not None:
  1221. self.connection.settimeout(self.timeout)
  1222. if self.disable_nagle_algorithm:
  1223. self.connection.setsockopt(socket.IPPROTO_TCP,
  1224. socket.TCP_NODELAY, True)
  1225. # 读句柄
  1226. self.rfile = self.connection.makefile('rb', self.rbufsize)
  1227. # 写句柄
  1228. self.wfile = self.connection.makefile('wb', self.wbufsize)
  1229. }
  1230. try:
  1231. # 处理请求 === django.core.servers.basehttp.WSGIRequestHandler.handle()
  1232. self.handle()
  1233. {
  1234. # django.core.servers.basehttp.WSGIRequestHandler.handle()
  1235. def handle(self):
  1236. # 获取 65537 行数据
  1237. # Copy of WSGIRequestHandler, but with different ServerHandler
  1238. self.raw_requestline = self.rfile.readline(65537)
  1239. if len(self.raw_requestline) > 65536:
  1240. self.requestline = ''
  1241. self.request_version = ''
  1242. self.command = ''
  1243. self.send_error(414)
  1244. return
  1246. # 解析请求
  1247. if not self.parse_request(){
  1248. self.command = None # set in case of error on the first line
  1249. self.request_version = version = self.default_request_version
  1250. self.close_connection = 1
  1251. requestline = self.raw_requestline
  1252. requestline = requestline.rstrip('\r\n')
  1253. self.requestline = requestline
  1254. words = requestline.split()
  1255. if len(words) == 3:
  1256. command, path, version = words
  1257. if version[:5] != 'HTTP/':
  1258. self.send_error(400, "Bad request version (%r)" % version)
  1259. return False
  1260. try:
  1261. # http 版本信息
  1262. base_version_number = version.split('/', 1)[1]
  1263. version_number = base_version_number.split(".")
  1264. # RFC 2145 section 3.1 says there can be only one "." and
  1265. # - major and minor numbers MUST be treated as
  1266. # separate integers;
  1267. # - HTTP/2.4 is a lower version than HTTP/2.13, which in
  1268. # turn is lower than HTTP/12.3;
  1269. # - Leading zeros MUST be ignored by recipients.
  1270. if len(version_number) != 2:
  1271. raise ValueError
  1272. version_number = int(version_number[0]), int(version_number[1])
  1273. except (ValueError, IndexError):
  1274. self.send_error(400, "Bad request version (%r)" % version)
  1275. return False
  1276. if version_number >= (1, 1) and self.protocol_version >= "HTTP/1.1":
  1277. self.close_connection = 0
  1278. if version_number >= (2, 0):
  1279. self.send_error(505,
  1280. "Invalid HTTP Version (%s)" % base_version_number)
  1281. return False
  1282. elif len(words) == 2:
  1283. command, path = words
  1284. self.close_connection = 1
  1285. if command != 'GET':
  1286. self.send_error(400,
  1287. "Bad HTTP/0.9 request type (%r)" % command)
  1288. return False
  1289. elif not words:
  1290. return False
  1291. else:
  1292. self.send_error(400, "Bad request syntax (%r)" % requestline)
  1293. return False
  1294. self.command, self.path, self.request_version = command, path, version
  1296. # 获取头部信息
  1297. # Examine the headers and look for a Connection directive
  1298. self.headers = self.MessageClass(self.rfile, 0)
  1300. conntype = self.headers.get('Connection', "")
  1301. if conntype.lower() == 'close':
  1302. self.close_connection = 1
  1303. elif (conntype.lower() == 'keep-alive' and
  1304. self.protocol_version >= "HTTP/1.1"):
  1305. self.close_connection = 0
  1306. return True
  1308. }: # An error code has been sent, just exit
  1309. return
  1311. # 处理请求
  1312. # handler === django.core.servers.basehttp.ServerHandler
  1313. handler = ServerHandler(
  1314. self.rfile, self.wfile, self.get_stderr(), self.get_environ()
  1315. )
  1316. {
  1317. def __init__(self,stdin,stdout,stderr,environ,
  1318. multithread=True, multiprocess=False
  1319. ):
  1320. self.stdin = stdin # 输入句柄
  1321. self.stdout = stdout # 输出句柄
  1322. self.stderr = stderr
  1323. self.base_env = environ # 环境变量
  1324. self.wsgi_multithread = multithread
  1325. self.wsgi_multiprocess = multiprocess
  1326. }
  1328. # handler.request_handler === django.core.servers.basehttp.WSGIRequestHandler
  1329. handler.request_handler = self # backpointer for logging
  1331. # !!! django.core.servers.basehttp.ServerHandler.run(self.server.get_app())
  1332. # self.server === django.core.servers.basehttp.WSGIServer
  1333. # self.server.get_app() == django.core.handlers.wsgi.WSGIHandler
  1334. handler.run(self.server.get_app())
  1335. {
  1336. def run(self, application):
  1337. # Invoke the application
  1338. # Note to self: don't move the close()! Asynchronous servers shouldn't
  1339. # call close() from finish_response(), so if you close() anywhere but
  1340. # the double-error branch here, you'll break asynchronous servers by
  1341. # prematurely closing. Async servers must return from 'run()' without
  1342. # closing if there might still be output to iterate over.
  1343. try:
  1344. # 安装环境变量
  1345. # wsgiref.handlers.BaseHandler.setup_environ()
  1346. self.setup_environ()
  1347. {
  1348. def setup_environ(self):
  1349. # Set up the environment for one request
  1350. # 拷贝系统环境变量
  1351. env = self.environ = self.os_environ.copy()
  1352. # 添加 cgi 变量
  1353. self.add_cgi_vars()
  1354. {
  1355. # SimpleHandler
  1356. def add_cgi_vars(self):
  1357. self.environ.update(self.base_env)
  1358. }
  1360. env['wsgi.input'] = self.get_stdin()
  1361. env['wsgi.errors'] = self.get_stderr()
  1362. env['wsgi.version'] = self.wsgi_version
  1363. env['wsgi.run_once'] = self.wsgi_run_once
  1364. env['wsgi.url_scheme'] = self.get_scheme()
  1365. env['wsgi.multithread'] = self.wsgi_multithread
  1366. env['wsgi.multiprocess'] = self.wsgi_multiprocess
  1368. if self.wsgi_file_wrapper is not None:
  1369. env['wsgi.file_wrapper'] = self.wsgi_file_wrapper
  1371. if self.origin_server and self.server_software:
  1372. env.setdefault('SERVER_SOFTWARE',self.server_software)
  1373. }
  1375. # 执行结果放入 self.result
  1376. # application === django.core.handlers.wsgi.WSGIHandler
  1377. self.result = application(self.environ, self.start_response)
  1378. {
  1379. # 调用
  1380. # django.core.handlers.wsgi.WSGIHandler.__call__()
  1381. def __call__(self, environ, start_response):
  1382. # 设置脚本前缀
  1383. set_script_prefix(get_script_name(environ))
  1384. signals.request_started.send(sender=self.__class__, environ=environ)
  1386. # 创建 request 对象
  1387. # request_class = django.core.handlers.wsgi.WSGIRequest
  1388. request = self.request_class(environ)
  1389. {
  1390. def __init__(self, environ):
  1391. # 获取 script_name 信息
  1392. script_name = get_script_name(environ)
  1393. # 获取 path_info 信息
  1394. path_info = get_path_info(environ)
  1395. if not path_info:
  1396. # Sometimes PATH_INFO exists, but is empty (e.g. accessing
  1397. # the SCRIPT_NAME URL without a trailing slash). We really need to
  1398. # operate as if they'd requested '/'. Not amazingly nice to force
  1399. # the path like this, but should be harmless.
  1400. path_info = '/'
  1401. self.environ = environ
  1402. self.path_info = path_info
  1403. # be careful to only replace the first slash in the path because of
  1404. # http://test/something and http://test//something being different as
  1405. # stated in http://www.ietf.org/rfc/rfc2396.txt
  1406. self.path = '%s/%s' % (script_name.rstrip('/'),
  1407. path_info.replace('/', '', 1))
  1408. self.META = environ
  1409. self.META['PATH_INFO'] = path_info
  1410. self.META['SCRIPT_NAME'] = script_name
  1411. self.method = environ['REQUEST_METHOD'].upper()
  1412. self.content_type, self.content_params = cgi.parse_header(environ.get('CONTENT_TYPE', ''))
  1413. if 'charset' in self.content_params:
  1414. try:
  1415. codecs.lookup(self.content_params['charset'])
  1416. except LookupError:
  1417. pass
  1418. else:
  1419. self.encoding = self.content_params['charset']
  1420. self._post_parse_error = False
  1421. try:
  1422. content_length = int(environ.get('CONTENT_LENGTH'))
  1423. except (ValueError, TypeError):
  1424. content_length = 0
  1425. self._stream = LimitedStream(self.environ['wsgi.input'], content_length)
  1426. self._read_started = False
  1427. self.resolver_match = None
  1428. }
  1430. # 执行中间件链条，响应 response 对象
  1431. response = self.get_response(request)
  1432. {
  1433. # Setup default url resolver for this thread
  1434. set_urlconf(settings.ROOT_URLCONF)
  1436. # ------------ 传入中间件链条，并执行 ------------
  1437. response = self._middleware_chain(request)
  1439. # This block is only needed for legacy MIDDLEWARE_CLASSES; if
  1440. # MIDDLEWARE is used, self._response_middleware will be empty.
  1441. try:
  1442. # !!! 应用 _response_middleware 类的中间件
  1443. # Apply response middleware, regardless of the response
  1444. for middleware_method in self._response_middleware:
  1445. # 应用 _response_middleware 类的中间件
  1446. response = middleware_method(request, response)
  1447. # Complain if the response middleware returned None (a common error).
  1448. if response is None:
  1449. raise ValueError(
  1450. "%s.process_response didn't return an "
  1451. "HttpResponse object. It returned None instead."
  1452. % (middleware_method.__self__.__class__.__name__))
  1453. except Exception: # Any exception should be gathered and handled
  1454. signals.got_request_exception.send(sender=self.__class__, request=request)
  1455. response = self.handle_uncaught_exception(request, get_resolver(get_urlconf()), sys.exc_info())
  1458. response._closable_objects.append(request)
  1460. # --------- response 对象中有 render 方法 ---------
  1461. # If the exception handler returns a TemplateResponse that has not
  1462. # been rendered, force it to be rendered.
  1463. if not getattr(response, 'is_rendered', True) and callable(getattr(response, 'render', None)):
  1464. response = response.render() # 调用 render 方法
  1466. # 响应状态码
  1467. if response.status_code == 404:
  1468. logger.warning(
  1469. 'Not Found: %s', request.path,
  1470. extra={'status_code': 404, 'request': request},
  1471. )
  1473. return response
  1474. }
  1475. # response._handler_class === django.core.handlers.wsgi.WSGIHandler
  1476. response._handler_class = self.__class__
  1478. # 响应状态信息
  1479. status = '%d %s' % (response.status_code, response.reason_phrase)
  1480. # 响应头
  1481. response_headers = [(str(k), str(v)) for k, v in response.items()]
  1482. # 在响应头中添加cookie信息
  1483. for c in response.cookies.values():
  1484. response_headers.append((str('Set-Cookie'), str(c.output(header=''))))
  1486. # !!! django.core.handlers.wsgi.WSGIHandler.start_response(...)
  1487. start_response(force_str(status), response_headers)
  1488. {
  1489. def start_response(self, status, headers,exc_info=None):
  1490. # 'start_response()' callable as specified by PEP 333
  1492. if exc_info:
  1493. try:
  1494. if self.headers_sent:
  1495. # Re-raise original exception if headers sent
  1496. raise exc_info[0], exc_info[1], exc_info[2]
  1497. finally:
  1498. exc_info = None # avoid dangling circular ref
  1499. elif self.headers is not None:
  1500. raise AssertionError("Headers already set!")
  1502. assert type(status) is StringType,"Status must be a string"
  1503. assert len(status)>=4,"Status must be at least 4 characters"
  1504. assert int(status[:3]),"Status message must begin w/3-digit code"
  1505. assert status[3]==" ", "Status message must have a space after code"
  1506. if __debug__:
  1507. for name,val in headers:
  1508. assert type(name) is StringType,"Header names must be strings"
  1509. assert type(val) is StringType,"Header values must be strings"
  1510. assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
  1511. self.status = status
  1512. # ！！！ 响应头 headers_class === Headers
  1513. self.headers = self.headers_class(headers)
  1514. return self.write
  1515. }
  1516. if getattr(response, 'file_to_stream', None) is not None and environ.get('wsgi.file_wrapper'):
  1517. response = environ['wsgi.file_wrapper'](response.file_to_stream)
  1518. return response
  1520. }
  1522. # django.core.servers.basehttp.ServerHandler.finish_response()
  1523. self.finish_response()
  1524. {
  1525. def finish_response(self):
  1526. # Send any iterable data, then close self and the iterable
  1527. # Subclasses intended for use in asynchronous servers will
  1528. # want to redefine this method, such that it sets up callbacks
  1529. # in the event loop to iterate over the data, and to call
  1530. # 'self.close()' once the response is finished.
  1531. try:
  1532. if not self.result_is_file() or not self.sendfile():
  1533. # 处理执行结果 self.result
  1534. for data in self.result:
  1535. self.write(data)
  1536. {
  1537. assert type(data) is StringType,"write() argument must be string"
  1539. if not self.status:
  1540. raise AssertionError("write() before start_response()")
  1542. elif not self.headers_sent:
  1543. # Before the first output, send the stored headers
  1544. self.bytes_sent = len(data) # make sure we know content-length
  1545. self.send_headers()
  1546. {
  1547. def send_headers(self):
  1548. # Transmit headers to the client, via self._write()
  1549. self.cleanup_headers()
  1550. self.headers_sent = True
  1551. if not self.origin_server or self.client_is_modern():
  1552. self.send_preamble()
  1553. # 发送 header 数据
  1554. self._write(str(self.headers))
  1555. {
  1556. def _write(self,data):
  1557. self.stdout.write(data)
  1558. self._write = self.stdout.write
  1559. }
  1560. }
  1561. else:
  1562. self.bytes_sent += len(data)
  1564. # 发送 body 数据
  1565. # XXX check Content-Length and truncate if too many bytes written?
  1566. self._write(data)
  1567. {
  1568. def _write(self,data):
  1569. self.stdout.write(data)
  1570. self._write = self.stdout.write
  1571. }
  1572. self._flush()
  1574. }
  1575. self.finish_content()
  1576. finally:
  1577. self.close()
  1578. }
  1579. except:
  1580. try:
  1581. self.handle_error()
  1582. except:
  1583. # If we get an error handling an error, just give up already!
  1584. self.close()
  1585. raise # ...and let the actual server figure it out.
  1586. }
  1587. }
  1588. finally:
  1589. # 完成请求 === django.core.servers.basehttp.WSGIRequestHandler.finish()
  1590. self.finish()
  1591. {
  1592. # SocketServer.StreamRequestHandler
  1593. def finish(self):
  1594. if not self.wfile.closed:
  1595. try:
  1596. self.wfile.flush()
  1597. except socket.error:
  1598. # An final socket error may have occurred here, such as
  1599. # the local error ECONNABORTED.
  1600. pass
  1601. self.wfile.close()
  1602. self.rfile.close()
  1603. }
  1604. }
  1605. }
  1606. self.shutdown_request(request)
  1607. }
  1608. except:
  1609. self.handle_error(request, client_address)
  1610. self.shutdown_request(request)
  1611. }
  1612. finally:
  1613. self.__shutdown_request = False
  1614. self.__is_shut_down.set()
  1615. }
  1616. }
  1617. except socket.error as e:
  1618. # Use helpful error messages instead of ugly tracebacks.
  1619. ERRORS = {
  1620. errno.EACCES: "You don't have permission to access that port.",
  1621. errno.EADDRINUSE: "That port is already in use.",
  1622. errno.EADDRNOTAVAIL: "That IP address can't be assigned to.",
  1623. }
  1624. try:
  1625. error_text = ERRORS[e.errno]
  1626. except KeyError:
  1627. error_text = force_text(e)
  1628. self.stderr.write("Error: %s" % error_text)
  1629. # Need to use an OS exit because sys.exit doesn't work in a thread
  1630. os._exit(1)
  1631. except KeyboardInterrupt:
  1632. if shutdown_message:
  1633. self.stdout.write(shutdown_message)
  1634. sys.exit(0)
  1635. }
  1636. }
  1637. }
  1639. if output:
  1640. if self.output_transaction:
  1641. connection = connections[options.get('database', DEFAULT_DB_ALIAS)]
  1642. output = '%s\n%s\n%s' % (
  1643. self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()),
  1644. output,
  1645. self.style.SQL_KEYWORD(connection.ops.end_transaction_sql()),
  1646. )
  1647. self.stdout.write(output)
  1648. finally:
  1649. if saved_locale is not None:
  1650. translation.activate(saved_locale)
  1651. return output
  1652. }
  1654. # 调用父类 execute - end
  1655. }
  1656. except Exception as e:
  1657. if options.traceback or not isinstance(e, CommandError):
  1658. raise
  1660. # SystemCheckError takes care of its own formatting.
  1661. if isinstance(e, SystemCheckError):
  1662. self.stderr.write(str(e), lambda x: x)
  1663. else:
  1664. self.stderr.write('%s: %s' % (e.__class__.__name__, e))
  1665. sys.exit(1)
  1666. finally:
  1667. try:
  1668. connections.close_all()
  1669. except ImproperlyConfigured:
  1670. # Ignore if connections aren't setup at this point (e.g. no
  1671. # configured settings).
  1672. pass
  1673. }
  1674. }
  1675. }

Tags：

猜你喜欢

本文暂时没有评论，来添加一个吧(●'◡'●)

欢迎 你 发表评论:

最近发表
标签列表