def inner_run(self, *args, **options): # ------------------------------------------------------------------------ # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. # ------------------------------------------------------------------------ autoreload.raise_last_exception() logger.info('"Performing system checks...\n\n', extra={"emit_to_server": False}) self.check(display_num_errors=True) # ----------------------------------------------------------- # Need to check migrations here, so can't use the # requires_migrations_check attribute. # ----------------------------------------------------------- self.check_migrations() quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-C" serverStartDta = ( f"Django version {self.get_version()}, using settings {settings.SETTINGS_MODULE}\n" f"Starting development async gRPC server at {self.address}\n" f"Quit the server with {quit_command}s.\n") # -------------------------------------------- # --- START ASYNC GRPC SERVER --- # -------------------------------------------- logger.info(serverStartDta, extra={"emit_to_server": False}) asyncio.run(self._serve())
def _serve(self, max_workers, port, *args, **kwargs): from django.conf import settings config = getattr(settings, "GRPCSERVER", dict()) autoreload.raise_last_exception() self.stdout.write("Starting server at %s" % datetime.datetime.now()) if not config.get("authentication"): self.stdout.write("Starting basic grpcserver") server = create_server(max_workers, port) elif config.get("authentication") == "ssl": self.stdout.write("Starting ssl grpcserver") server = create_ssl_server(max_workers, port) server.start() self.stdout.write("Server is listening port %s" % port) if kwargs["list_handlers"] is True: self.stdout.write("Registered handlers:") for handler in extract_handlers(server): self.stdout.write("* %s" % handler) # since server.start() will not block, # a sleep-loop is added to keep alive try: while True: time.sleep(86400) except KeyboardInterrupt: server.stop(0) sys.exit(0)
def restart_celery(*args, **kwargs): print("Restarting celery...") autoreload.raise_last_exception() kill_worker_cmd = "ps aux | grep bin/celery | awk '{print $2}' | xargs kill -9" subprocess.call(kill_worker_cmd, shell=True) start_worker_cmd = "celery -A conf worker -l info" subprocess.call(shlex.split(start_worker_cmd))
def run(self, *args, **options): duration = options.get('duration', 0) sleep = options.get('sleep', 5.0) queue = options.get('queue', None) log_std = options.get('log_std', False) is_dev = options.get('dev', False) sig_manager = self.sig_manager if is_dev: # raise last Exception is exist autoreload.raise_last_exception() if log_std: _configure_log_std() autodiscover() start_time = time.time() while (duration <= 0) or (time.time() - start_time) <= duration: if sig_manager.kill_now: # shutting down gracefully break if not self._tasks.run_next_task(queue): # there were no tasks in the queue, let's recover. close_connection() #logger.debug('waiting for tasks') time.sleep(sleep) else: # there were some tasks to process, let's check if there is more work to do after a little break. time.sleep( random.uniform(sig_manager.time_to_wait[0], sig_manager.time_to_wait[1]))
def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() threading = options["use_threading"] # 'shutdown_message' is a stealth option. shutdown_message = options.get("shutdown_message", "") quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-C" if not options["skip_checks"]: self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() now = datetime.now().strftime("%B %d, %Y - %X") self.stdout.write(now) self.stdout.write( ("Django version %(version)s, using settings %(settings)r\n" "Starting development server at %(protocol)s://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s.") % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": "[%s]" % self.addr if self._raw_ipv6 else self.addr, "port": self.port, "quit_command": quit_command, }) try: handler = self.get_handler(*args, **options) run( self.addr, int(self.port), handler, ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls, ) except OSError 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 = 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 run(self, **options): autoreload.raise_last_exception() self.check(display_num_errors=True) self.stdout.write(self.style.SUCCESS('Server is running!')) run(addr="127.0.0.1", port=8000, wsgi_handler=get_internal_wsgi_application(), threading=True, server_cls=WSGIServer)
def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() try: if sio.async_mode == 'threading': super(Command, self).handle(*args, **options) elif sio.async_mode == 'eventlet': # deploy with eventlet import eventlet import eventlet.wsgi from apsma.wsgi import application eventlet.wsgi.server(eventlet.listen(('', int(self.port))), application) elif sio.async_mode == 'gevent': # deploy with gevent from gevent import pywsgi from apsma.wsgi import application try: from geventwebsocket.handler import WebSocketHandler websocket = True except ImportError: websocket = False if websocket: pywsgi.WSGIServer( ('', 8000), application, handler_class=WebSocketHandler).serve_forever() else: pywsgi.WSGIServer(('', 8000), application).serve_forever() elif sio.async_mode == 'gevent_uwsgi': print( 'Start the application through the uwsgi server. Example:') print('uwsgi --http :5000 --gevent 1000 --http-websockets ' '--master --wsgi-file django_example/wsgi.py --callable ' 'application') else: print('Unknown async_mode: ' + sio.async_mode) 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 = force_text(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: sys.exit(0)
def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() threading = options['use_threading'] # 'shutdown_message' is a stealth option. shutdown_message = options.get('shutdown_message', '') quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() now = datetime.now().strftime('%B %d, %Y - %X') if six.PY2: now = now.decode(get_system_encoding()) self.stdout.write(now) self.stdout.write(( "Django version %(version)s, using settings %(settings)r\n" "Starting development server at %(protocol)s://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s.\n" ) % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr, "port": self.port, "quit_command": quit_command, }) try: handler = self.get_handler(*args, **options) run(self.addr, int(self.port), handler, ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls) 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 = force_text(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 inner_run(self, *args, **options): # pylint: disable=unused-argument autoreload.raise_last_exception() for pidfile in (options['celery_pidfile'], options['celerybeat_pidfile']): if os.path.exists(pidfile): with open(pidfile, 'r') as f: pid = f.read().strip() with settings(warn_only=True), hide('commands'): # pylint: disable=not-context-manager local('kill -9 {}'.format(pid)) local('rm -f {}'.format(pidfile)) call_command('startcelery', silent=True, pipe='', **options) self.stdout.write(self.style.SUCCESS("Successfully reloaded celery and celerybeat."))
def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() 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("Performing system checks...\n\n") self.check(display_num_errors=True) self.check_migrations() now = datetime.now().strftime('%B %d, %Y - %X') if six.PY2: now = now.decode(get_system_encoding()) self.stdout.write(now) self.stdout.write( ("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") % { "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, }) 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 = force_text(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 test_raises_exception(self): class MyException(Exception): pass # Create an exception try: raise MyException('Test Message') except MyException: exc_info = sys.exc_info() with mock.patch('django.utils.autoreload._exception', exc_info): with self.assertRaisesMessage(MyException, 'Test Message'): autoreload.raise_last_exception()
def test_raises_exception(self): class MyException(Exception): pass # Create an exception try: raise MyException('Test Message') except MyException: exc_info = sys.exc_info() with mock.patch('django.utils.autoreload._exception', exc_info): with self.assertRaisesMessage(MyException, 'Test Message'): autoreload.raise_last_exception()
def inner_run(self, *args: Any, **options: Any) -> None: # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() threading = options['use_threading'] # 'shutdown_message' is a stealth option. shutdown_message = options.get('shutdown_message', '') quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.check(display_num_errors=False) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() self.stdout.write( ("Django process (re)started. Quit the server with %(quit_command)s.\n" ) % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr, "port": self.port, "quit_command": quit_command, }) try: handler = self.get_handler(*args, **options) run(self.addr, int(self.port), handler, ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls) 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 test_raises_custom_exception(self): class MyException(Exception): def __init__(self, msg, extra_context): super().__init__(msg) self.extra_context = extra_context # Create an exception. try: raise MyException('Test Message', 'extra context') except MyException: exc_info = sys.exc_info() with mock.patch('django.utils.autoreload._exception', exc_info): with self.assertRaisesMessage(MyException, 'Test Message'): autoreload.raise_last_exception()
def test_raises_custom_exception(self): class MyException(Exception): def __init__(self, msg, extra_context): super().__init__(msg) self.extra_context = extra_context # Create an exception. try: raise MyException('Test Message', 'extra context') except MyException: exc_info = sys.exc_info() with mock.patch('django.utils.autoreload._exception', exc_info): with self.assertRaisesMessage(MyException, 'Test Message'): autoreload.raise_last_exception()
def test_raises_exception_with_context(self): try: raise Exception(2) except Exception as e: try: raise Exception(1) from e except Exception: exc_info = sys.exc_info() with mock.patch('django.utils.autoreload._exception', exc_info): with self.assertRaises(Exception) as cm: autoreload.raise_last_exception() self.assertEqual(cm.exception.args[0], 1) self.assertEqual(cm.exception.__cause__.args[0], 2)
def test_raises_exception_with_context(self): try: raise Exception(2) except Exception as e: try: raise Exception(1) from e except Exception: exc_info = sys.exc_info() with mock.patch('django.utils.autoreload._exception', exc_info): with self.assertRaises(Exception) as cm: autoreload.raise_last_exception() self.assertEqual(cm.exception.args[0], 1) self.assertEqual(cm.exception.__cause__.args[0], 2)
def inner_run(self, *args, **options): autoreload.raise_last_exception() quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write(( "Starting file watcher...\n\n" "Quit with {}.\n" ).format(quit_command)) try: self.watch() except KeyboardInterrupt: sys.exit(0)
def _serve(self, max_workers, port, *args, **kwargs): autoreload.raise_last_exception() self.stdout.write("Starting server at %s" % datetime.datetime.now()) server = create_server(max_workers, port) server.start() self.stdout.write("Server is listening port %s" % port) if kwargs['list_handlers'] is True: self.stdout.write("Registered handlers:") for handler in extract_handlers(server): self.stdout.write("* %s" % handler) server.wait_for_termination()
def inner_run(self, *args, **options): # ------------------------------------------------------------------------ # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. # ------------------------------------------------------------------------ autoreload.raise_last_exception() logger.info('"Performing system checks...\n\n') self.check(display_num_errors=True) # ----------------------------------------------------------- # Need to check migrations here, so can't use the # requires_migrations_check attribute. # ----------------------------------------------------------- self.check_migrations() quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-C" serverStartDta = ( f"Django version {self.get_version()}, using settings {settings.SETTINGS_MODULE}\n" f"Starting development gRPC server at {self.address}\n" f"Quit the server with {quit_command}s.\n" ) # -------------------------------------------- # --- START GRPC SERVER --- # -------------------------------------------- logger.info(serverStartDta) try: self._serve() except OSError 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 = e errorData = f"Error: {error_text}" logger.error(errorData) # Need to use an OS exit because sys.exit doesn't work in a thread os._exit(1) # --------------------------------------- # ---- EXIT OF GRPC SERVER --- except KeyboardInterrupt: logger.warning("Exit gRPC Server") sys.exit(0)
def run_server(self, host, port): """Runs the RPC server locally :param host: str Host to use :param port: int port to use """ autoreload.raise_last_exception() quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write(f"Django Manifold version {get_manifold_version()}\n" f"Django version {self.get_version()}, " f"using settings {settings.SETTINGS_MODULE}\n" f"Starting development RPC server at {host}:{port}\n" f"Quit the server with {quit_command}.\n") server = rpc.make_server() server.serve()
def run(self): autoreload.raise_last_exception() self.stdout.write(datetime.now().strftime('%B %d, %Y - %X')) self.stdout.write( ("Django version %(version)s, using settings %(settings)r\n" "Starting race bot (PID: %(pid)d)\n") % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "pid": os.getpid(), }) try: bot = RaceBot(os.getpid()) while True: bot.handle() except KeyboardInterrupt: sys.exit(0)
def run(self, *args, **options): duration = options.get('duration', 0) sleep = options.get('sleep', 5.0) queue = options.get('queue', None) log_std = options.get('log_std', False) is_dev = options.get('dev', False) sig_manager = self.sig_manager if is_dev: # raise last Exception is exist autoreload.raise_last_exception() if log_std: _configure_log_std() autodiscover() start_time = time.time() while (duration <= 0) or ( time.time() - start_time) <= duration or TaskCount.count > 0: is_past_duration = duration > 0 and (time.time() - start_time) > duration if sig_manager.kill_now: # shutting down gracefully break # if is_past_duration, we don't want to run any more tasks. We're just waiting for what's running # to complete so we can exit. if is_past_duration: logger.debug( 'waiting for %s tasks to finish before exiting. %s', TaskCount.count, TaskCount.task_guids) time.sleep(sleep) elif not self._tasks.run_next_task(queue): # there were no tasks in the queue, let's recover. close_connection() logger.debug('waiting for tasks') time.sleep(sleep) else: # there were some tasks to process, let's check if there is more work to do after a little break. time.sleep( random.uniform(sig_manager.time_to_wait[0], sig_manager.time_to_wait[1]))
def run(self, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() self.stdout.write('Performing system checks...\n\n') self.check(display_num_errors=True) self.check_migrations() now = datetime.now().strftime('%B %d, %Y - %X') self.stdout.write(now) try: self.stop_celery() self.start_celery(app=options['app_name']) except KeyboardInterrupt: self.stop_celery() sys.exit(0)
def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() now = datetime.now().strftime('%B %d, %Y - %X') self.stdout.write(now) quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write(( "Django version %(version)s, using settings %(settings)r\n" "Starting development gRPC server at %(address)s\n" "Quit the server with %(quit_command)s.\n" ) % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "address": self.address, "quit_command": quit_command, }) try: self._serve() except OSError 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 = 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: sys.exit(0)
def _serve(self, max_workers, port, *args, **kwargs): autoreload.raise_last_exception() self.stdout.write("Starting server at %s" % datetime.datetime.now()) server = create_server(max_workers, port) server.start() self.stdout.write("Server is listening port %s" % port) if kwargs['list_handlers'] is True: self.stdout.write("Registered handlers:") for handler in extract_handlers(server): self.stdout.write("* %s" % handler) # since server.start() will not block, # a sleep-loop is added to keep alive try: while True: time.sleep(86400) except KeyboardInterrupt: server.stop(0) sys.exit(0)
def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. import threading ct = threading.current_thread() print( '【django.core.management.commands.runserver.Command.inner_run】当前线程:', ct.name, ct.ident) autoreload.raise_last_exception() threading = options['use_threading'] # 'shutdown_message' is a stealth option. shutdown_message = options.get('shutdown_message', '') quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' #self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. # 检查数据库版本迁移,需要在终端执行 python manage.py migrate 之类的命令 self.check_migrations() print('【django.core.management.commands.runserver.Command.inner_run】', end='') print( f"Starting development server at {self.protocol}://{self.addr}:{self.port}" ) """ now = datetime.now().strftime('%B %d, %Y - %X') self.stdout.write(now) self.stdout.write(( "Django version %(version)s, using settings %(settings)r\n" "Starting development server at %(protocol)s://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s." ) % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr, "port": self.port, "quit_command": quit_command, }) """ try: # 这里 self 是「命令处理对象」 # 下面的 handle 是 django.core.handlers.wsgi.WSGIHandler 类的实例 # 此实例就相当于 Flask 中的 app 应用对象 handler = self.get_handler(*args, **options) # 这个 run 方法是核心,定义在 django.core.servers.basehttp 模块中 # 在方法内部会创建服务器对象并启动监听 # 参数 handler 是应用对象,server_cls 是服务器类,其实例就是携带 TCP 套接字的对象 run(self.addr, int(self.port), handler, ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls) except OSError 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 = 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 inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() max_workers = options.get('max_workers', 5) # Handle certificate ssl, server_kwargs = False, {} certificate_chain_pairs = options.get('certificate_chain_pairs', '') root_certificates = options.get('root_certificates', '') if certificate_chain_pairs: ssl = True certificate_chain_pairs = load_credential_from_args( certificate_chain_pairs) if root_certificates: root_certificates = load_credential_from_file( root_certificates) server_kwargs['root_certificate'] = root_certificates server_kwargs['certificate_key'] = certificate_chain_pairs[0] server_kwargs['certificate'] = certificate_chain_pairs[1] # 'shutdown_message' is a stealth option. shutdown_message = options.get('shutdown_message', '') quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() now = datetime.now().strftime('%B %d, %Y - %X') self.stdout.write(now) self.stdout.write( ( "Django version %(version)s, using settings %(settings)r\n" # noqa "Starting development server at %(protocol)s:%(addr)s:%(port)s\n" "Quit the server with %(quit_command)s.\n") % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": '%s' % self.addr, "port": self.port, "quit_command": quit_command, }) try: server = self.server_cls(max_workers=max_workers, ssl=ssl) with server.start(self.addr, self.port, **server_kwargs) as ser: ser.wait_for_termination() except OSError 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 = 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)
from __future__ import unicode_literals
def test_no_exception(self): # Should raise no exception if _exception is None autoreload.raise_last_exception()
def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() threading = options['use_threading'] # 'shutdown_message' is a stealth option. shutdown_message = options.get('shutdown_message', '') quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write("Performing system checks...\n") #======================================================================= # Added by Adam Nieto # Gathering xss suppression file path user_current_directory = os.path.dirname(os.path.abspath(sys.argv[0])) suppression_file_path = os.path.join(user_current_directory, "xss_detector_suppressions.txt") rule_file_path = os.path.join(user_current_directory, "additional_xss_detector_rules.txt") # Checking if xss suppression file should be created if not self.check_suppression_file_exists(suppression_file_path): self.create_suppression_file(suppression_file_path) # Checking if xss rule file should be created if not self.check_rule_file_exists(rule_file_path): self.create_rule_file(rule_file_path) self.stdout.write("Performing xss vulnerability checks...\n\n") xss_warnings_are_silenced = options["silence_xss_warnings"] self.check_xss_vulnerabilities(xss_warnings_are_silenced, suppression_file_path, rule_file_path) #======================================================================= self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() now = datetime.now().strftime('%B %d, %Y - %X') if six.PY2: now = now.decode(get_system_encoding()) self.stdout.write(now) self.stdout.write( ("Django version %(version)s, using settings %(settings)r\n" "Starting development server at %(protocol)s://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s.\n") % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr, "port": self.port, "quit_command": quit_command, }) try: handler = self.get_handler(*args, **options) run(self.addr, int(self.port), handler, ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls) 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 = force_text(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 test_no_exception(self): # Should raise no exception if _exception is None autoreload.raise_last_exception()
def inner_run(self, *args, **options): from django.conf import settings from django.utils import translation # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() 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("Performing system checks...\n\n") self.validate(display_num_errors=True) try: self.check_migrations() except ImproperlyConfigured: pass 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 = force_text(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 inner_run(self, *args, **options): # 非常重要 的 方法 """ self = <django.contrib.staticfiles.management.commands.runserver.Command object at 0x0365E150> :param args: () :param options: 为命令解析 结果 :return: """ # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() # 作用不理解 threading = options['use_threading'] # True # 'shutdown_message' is a stealth option. shutdown_message = options.get('shutdown_message', '') # "" quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' # "CTRL-BREAK" self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # 不理解 # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() # 不理解 now = datetime.now().strftime('%B %d, %Y - %X') self.stdout.write(now) self.stdout.write(( "Django version %(version)s, using settings %(settings)r\n" "Starting development server at %(protocol)s://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s.\n" ) % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr, "port": self.port, "quit_command": quit_command, }) try: # 关键代码 handler = self.get_handler(*args, **options) # 返回了 静态文件 句柄 对象 # handler == <django.contrib.staticfiles.handlers.StaticFilesHandler object at 0x000001D13A0C7308> """ 作用: 1. 加载 wsgi.py 中 的 application 2. 解析 静态 ulr, settings.STATIC_URL 3. 加载 中间件 , settings.MIDDLEWARE """ # 关键代码 run(self.addr, int(self.port), handler, # 开启 wsgi Web 服务 ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls) 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 = 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 inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() shutdown_message = options.get('shutdown_message', '') quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) self.check_migrations() now = datetime.datetime.now().strftime('%B %d, %Y - %X') self.stdout.write(now) self.stdout.write( ("Django version %(version)s, using settings %(settings)r\n" "Starting aidjango server at http://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s.\n") % { "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, }) if options.get('use_reloader'): loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) else: loop = asyncio.get_event_loop() app = self.get_handler(*args, **options) log = logging.getLogger('aiodjango.runserver') log.propagate = False log.setLevel(logging.INFO) stdout = logging.StreamHandler(stream=self.stdout) log.addHandler(stdout) handler = app.make_handler(access_log=log, access_log_format='%t "%r" %s %b %D') server = None try: server = loop.run_until_complete( loop.create_server(handler, self.addr, int(self.port))) loop.run_forever() 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 = force_text(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) finally: loop.run_until_complete(handler.finish_connections(1.0)) if server is not None: server.close() loop.run_until_complete(server.wait_closed()) loop.run_until_complete(app.finish()) loop.close()
def inner_run(self, *args, **options): # 1 配置工作 # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. MY('Running', '\n\t开启运行(child线程)') autoreload.raise_last_exception() # django 默认开启threading, 允许在开发服务器中使用多线程 # 可以通过选项: --nothreading关闭 threading = options['use_threading'] # 'shutdown_message' is a stealth option. shutdown_message = options.get('shutdown_message', '') quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C' self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() now = datetime.now().strftime('%B %d, %Y - %X') self.stdout.write(now) self.stdout.write( ("Django version %(version)s, using settings %(settings)r\n" "Starting development server at %(protocol)s://%(addr)s:%(port)s/\n" "Quit the server with %(quit_command)s.\n") % { "version": self.get_version(), "settings": settings.SETTINGS_MODULE, "protocol": self.protocol, "addr": '[%s]' % self.addr if self._raw_ipv6 else self.addr, "port": self.port, "quit_command": quit_command, }) # 2 主要处理逻辑 try: # 2.1 获取handler, 实际获取get_internal_wsgi_application 返回application # 类型: WSGIHandler(实现WSGI 协议的对象) # 功能: 处理 Request/Resonse, 见WSGIHandler类(可调用) # 调用: 其中handler调用: handler(environ, start_response) handler = self.get_handler(*args, **options) # 2.2 runserver启动 # 开始正式进入core.servers.basehttp.run # HTTP, 其中server_cls=WSGIServer使用wsgiref模块来实现HTTP # 功能, 类: wsgiref.simple_server.WSGIServer # 最终会通过handler来处理每一个请求 run(self.addr, int(self.port), handler, ipv6=self.use_ipv6, threading=threading, server_cls=self.server_cls) 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 = 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)