9674894549

Committed 26 Jun 2024 06:50AM UTC coverage: 85.471% (+0.3%) from 85.207%

Build # 9674894549

Build Type

Pull #131

github

Committed by

web-flow

Commit Message

Merge 1e5eee8eb into 99ac07fba

Pull Request Pull Request #131: feat: #128 serve settings refactor ✨

Run Details

299 of 406 branches covered (73.65%)

Branch coverage included in aggregate %.

41 of 42 new or added lines in 1 file covered. (97.62%)

52 existing lines in 2 files now uncovered.

1354 of 1528 relevant lines covered (88.61%)

3.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.78

/hurricane/management/commands/serve.py

import asyncio
import functools
import os
import signal
import time
from concurrent.futures.thread import ThreadPoolExecutor

import tornado.autoreload
import tornado.web
import tornado.wsgi
from django.conf import settings
from django.core.management.base import BaseCommand

from hurricane.management.commands import HURRICANE_DIST_VERSION
from hurricane.server import (
    check_db_and_migrations,
    check_mem_allocations,
    command_task,
    logger,
    make_http_server_and_listen,
    make_probe_server,
    sanitize_probes,
    static_watch,
)
from hurricane.server.debugging import setup_debugging
from hurricane.server.loggers import STRUCTLOG_ENABLED

PROBE_CONFIGURED_EVENT = "Probe configured"
PROMETHEUS_CONFIGURED_EVENT = "Prometheus configured"


class Command(BaseCommand):

    """
    Start a Tornado-powered Django web server by using ``python manage.py serve <arguments>``.

    It can run Django management commands with the ``--command`` flag, that will be executed asynchronously.
    The application server will only be started upon successful execution of management commands. During execution
    of management commands the startup probe responds with a status 400.

    Arguments:
        - ``--static`` - serve collected static files
        - ``--media`` - serve media files
        - ``--autoreload`` - reload code on change
        - ``--debug`` - set Tornado's Debug flag
        - ``--port`` - the port for Tornado to listen on
        - ``--metrics`` - the exposed path (default is /metrics) to export Prometheus metrics
        - ``--startup-probe`` - the exposed path (default is /startup) for probes to check startup
        - ``--readiness-probe`` - the exposed path (default is /ready) for probes to check readiness
        - ``--liveness-probe`` - the exposed path (default is /alive) for probes to check liveness
        - ``--probe-port`` - the port for Tornado probe route to listen on
        - ``--req-queue-len`` - threshold of length of queue of request, which is considered for readiness probe
        - ``--no-probe`` - disable probe endpoint
        - ``--no-metrics`` - disable metrics collection
        - ``--command`` - repetitive command for adding execution of management commands before serving
        - ``--check-migrations`` - check if all migrations were applied before starting application
        - ``--check-migrations-apply`` - same as --check-migrations but also applies them if needed
        - ``--webhook-url``- If specified, webhooks will be sent to this url
        - ``--max-lifetime``- If specified,  maximum requests after which pod is restarted
        - ``--max-memory``- If specified, process reloads after exceeding maximum memory (RSS) usage (in Mb)
        - ``--static-watch`` - If specified, static files will be watched for changes and recollected
    """

    help = "Start a Tornado-powered Django web server"

    def add_arguments(self, parser):
        """
        Defines arguments, that can be accepted with ``serve`` command.
        """
        parser.add_argument(
            "--static", action="store_true", help="Serve collected static files"
        )
        parser.add_argument("--media", action="store_true", help="Serve media files")
        parser.add_argument(
            "--autoreload", action="store_true", help="Reload code on change"
        )
        parser.add_argument(
            "--debug", action="store_true", help="Set Tornado's Debug flag"
        )
        parser.add_argument(
            "--port", type=int, default=8000, help="The port for Tornado to listen on"
        )
        parser.add_argument(
            "--metrics",
            type=str,
            dest="metrics_path",
            default="/metrics",
            help="The exposed path (default is /metrics) to export Prometheus metrics",
        )
        parser.add_argument(
            "--liveness-probe",
            type=str,
            default="/alive",
            help="The exposed path (default is /alive) for probes to check liveness",
        )
        parser.add_argument(
            "--readiness-probe",
            type=str,
            default="/ready",
            help="The exposed path (default is /ready) for probes to check readiness",
        )
        parser.add_argument(
            "--startup-probe",
            type=str,
            default="/startup",
            help="The exposed path (default is /startup) for probes to check startup",
        )
        parser.add_argument(
            "--probe-port",
            type=int,
            help="The port for Tornado probe route to listen on",
        )
        parser.add_argument(
            "--req-queue-len", type=int, default=10, help="Length of the request queue"
        )
        parser.add_argument(
            "--no-probe", action="store_true", help="Disable probe endpoint"
        )
        parser.add_argument(
            "--no-metrics", action="store_true", help="Disable metrics collection"
        )
        parser.add_argument("--command", type=str, action="append", nargs="+")
        parser.add_argument(
            "--check-migrations",
            action="store_true",
            help="Check if migrations were applied",
        )
        parser.add_argument(
            "--check-migrations-apply",
            action="store_true",
            help="Check if migrations were applied and apply them if needed",
        )
        parser.add_argument(
            "--debugger",
            action="store_true",
            help="Open a debugger port according to the Debug Adapter Protocol",
        )
        parser.add_argument(
            "--debugger-port",
            type=int,
            default=5678,
            help="The port for the debug client to attach",
        )
        parser.add_argument(
            "--webhook-url",
            type=str,
            help="Url for webhooks",
        )
        parser.add_argument(
            "--max-lifetime",
            type=int,
            default=None,
            help="Maximum requests after which pod is restarted (default = None)",
        )
        parser.add_argument(
            "--max-memory",
            type=int,
            default=None,
            help="Maximum memory (Resident Set Size) in Mb before process reloads (default = None, no reload)",
        )
        parser.add_argument(
            "--workers",
            type=int,
            default=None,
            help="Number of thread workers to be used for the server (default = Number of CPUs + 4)",
        )
        parser.add_argument(
            "--static-watch",
            type=str,
            action="append",
            help="Watch files and run collectstatic if any file changed",
        )
        parser.add_argument(
            "--pycharm-host",
            type=str,
            default=None,
            help="The host of the pycharm debug server",
        )
        parser.add_argument(
            "--pycharm-port",
            type=int,
            default=None,
            help="The port of the pycharm debug server",
        )

    def merge_option(
        self,
        option_name: str,
        option_descriptor: str,
        options: dict,
        optional=False,
        default=None,
    ):
        """
        Merges a single option into the given option dictionary

        Args:
            option_name (str): Name of the option in the options dictionary
            option_descriptor (str): Name of the option as env variable
        """
        # leave early if option is already set via cli argument - highest precedence
        if options[option_name] is not None and options[option_name] != default:
            return
        try:  # first try to add option from django settings - second highest precedence
            options.update(
                {
                    option_name: getattr(
                        settings, option_descriptor.removeprefix("HURRICANE_")
                    )
                }
            )
        except AttributeError:  # then add from env variables - lowest precedence
            if option_descriptor not in os.environ and options[option_name] is None:
                if optional:  # if optional, just return and do not raise an error
                    return
                raise ValueError(
                    (
                        f"Option {option_descriptor} must be set as environment variable,"
                        " in django settings or as a command line argument."
                    )
                )
            # try parsing int in general because we can't know the type of env vars
            try:
                options.update(
                    {option_name: int(str(os.environ.get(option_descriptor)))}
                )
            except (TypeError, ValueError):
                options.update(
                    {
                        option_name: os.environ.get(option_descriptor)
                        if option_descriptor in os.environ
                        else options[option_name]
                    }
                )

    def merge_options(self, options: dict):
        """
        Merges options with django settings. Precedence is the following:
        - ENV variables
        - Django settings
        - Command line arguments
        """
        self.merge_option("static", "HURRICANE_STATIC", options, default=False)
        self.merge_option("media", "HURRICANE_MEDIA", options, default=False)
        self.merge_option("autoreload", "HURRICANE_AUTORELOAD", options, default=False)
        self.merge_option("debug", "HURRICANE_DEBUG", options, default=False)
        self.merge_option("port", "HURRICANE_PORT", options, default=8000)
        self.merge_option(
            "metrics_path", "HURRICANE_METRICS", options, default="/metrics"
        )
        self.merge_option(
            "liveness_probe", "HURRICANE_LIVENESS_PROBE", options, default="/alive"
        )
        self.merge_option(
            "readiness_probe", "HURRICANE_READINESS_PROBE", options, default="/ready"
        )
        self.merge_option(
            "startup_probe", "HURRICANE_STARTUP_PROBE", options, default="/startup"
        )
        self.merge_option("probe_port", "HURRICANE_PROBE_PORT", options, optional=True)
        self.merge_option(
            "req_queue_len", "HURRICANE_REQ_QUEUE_LEN", options, default=10
        )
        self.merge_option("no_probe", "HURRICANE_NO_PROBE", options, default=False)
        self.merge_option("no_metrics", "HURRICANE_NO_METRICS", options, default=False)
        self.merge_option("command", "HURRICANE_COMMAND", options, optional=True)
        self.merge_option(
            "check_migrations", "HURRICANE_CHECK_MIGRATIONS", options, default=False
        )
        self.merge_option(
            "check_migrations_apply",
            "HURRICANE_CHECK_MIGRATIONS_APPLY",
            options,
            default=False,
        )
        self.merge_option("debugger", "HURRICANE_DEBUGGER", options, default=False)
        self.merge_option(
            "debugger_port", "HURRICANE_DEBUGGER_PORT", options, default=5678
        )
        self.merge_option(
            "webhook_url", "HURRICANE_WEBHOOK_URL", options, optional=True
        )
        self.merge_option(
            "max_lifetime",
            "HURRICANE_MAX_LIFETIME",
            options,
            optional=True,
            default=None,
        )
        self.merge_option(
            "max_memory", "HURRICANE_MAX_MEMORY", options, optional=True, default=None
        )
        self.merge_option(
            "workers", "HURRICANE_WORKERS", options, optional=True, default=None
        )
        self.merge_option(
            "static_watch", "HURRICANE_STATIC_WATCH", options, optional=True
        )
        self.merge_option(
            "pycharm_host",
            "HURRICANE_PYCHARM_HOST",
            options,
            optional=True,
            default=None,
        )
        self.merge_option(
            "pycharm_port",
            "HURRICANE_PYCHARM_PORT",
            options,
            optional=True,
            default=None,
        )

    def handle(self, *args, **options):
        """
        Defines functionalities for different arguments. After all arguments were processed, it starts the async event
        loop.
        """
        self.merge_options(options)
        start_time = time.time()
        if STRUCTLOG_ENABLED:
            logger.info(
                "Tornado-powered Django web server.",
                hurricane=HURRICANE_DIST_VERSION,
            )
        else:
            logger.info(
                f"Tornado-powered Django web server. Version: {HURRICANE_DIST_VERSION}"
            )

        if options["autoreload"]:
            tornado.autoreload.start()
            if options["static_watch"] and len(options["static_watch"]):
                logger.info("Watching static files for any changes")
                for path in options["static_watch"]:
                    if os.path.exists(path):
                        logger.info("Watching path {}.".format(path))
                        tornado.autoreload.watch(path)
                    else:
                        logger.error(
                            "Tried to watch {}, but it does not exist.".format(path)
                        )
                tornado.autoreload.add_reload_hook(static_watch)
            logger.info("Autoreload was performed")

        # set the probe port
        # the probe port by default is supposed to run the next port of the application
        probe_port = (
            options["probe_port"] if options["probe_port"] else options["port"] + 1
        )
        options["probe_port"] = probe_port

        # sanitize probes: returns regexps for probes in options and their representations for logging
        options, probe_representations = sanitize_probes(options)

        # set the probe routes
        # if probe port is set to the application's port, add it to the application's routes
        include_probe = False
        if not options["no_probe"]:
            if probe_port != options["port"]:
                if STRUCTLOG_ENABLED:
                    self.structlog_probe_configured(
                        probe_port, probe_representations, options
                    )
                else:
                    logger.info(
                        f"Starting probe application running on port {probe_port} with route liveness-probe: "
                        f"{probe_representations['liveness_probe']}, "
                        f"readiness-probe: {probe_representations['readiness_probe']}, "
                        f"startup-probe: {probe_representations['startup_probe']}"
                    )
                self.log_prometheus(options, probe_port)
                probe_application = make_probe_server(options, self.check)
                probe_application.listen(probe_port)
            else:
                include_probe = True
                if STRUCTLOG_ENABLED:
                    self.structlog_probe_configured(
                        probe_port, probe_representations, options
                    )
                else:
                    logger.info(
                        f"Starting probe application with routes "
                        f"liveness-probe: {probe_representations['liveness_probe']}, "
                        f"readiness-probe: {probe_representations['readiness_probe']}, "
                        f"startup-probe: {probe_representations['startup_probe']} "
                        f"running integrated on port {probe_port}"
                    )
                    self.log_prometheus(options, probe_port)

        else:
            if STRUCTLOG_ENABLED:
                logger.info("Probes configured", active=False)
                logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)
            else:
                logger.info("No probe application running")
                logger.info(
                    "Running without Prometheus exporter, because --no-probe flag was set"
                )
            options["no_metrics"] = True

        setup_debugging(options)

        loop = asyncio.get_event_loop()

        make_http_server_wrapper = functools.partial(
            make_http_server_and_listen,
            start_time=start_time,
            options=options,
            check=self.check,
            include_probe=include_probe,
        )

        # all commands, that should be executed before starting http server should be added to this list
        exec_list = []
        if options["command"]:
            # wrap function to use additional variables
            management_commands_wrapper = functools.partial(
                command_task,
                commands=options["command"],
                webhook_url=options["webhook_url"] or None,
                loop=loop,
            )
            exec_list.append(management_commands_wrapper)
        if options["check_migrations"] or options["check_migrations_apply"]:
            check_db_and_migrations_wrapper = functools.partial(
                check_db_and_migrations,
                webhook_url=options["webhook_url"] or None,
                loop=loop,
                apply_migration=True if options["check_migrations_apply"] else False,
            )
            exec_list.append(check_db_and_migrations_wrapper)

        def bundle_func(exec_list, loop, make_http_server_wrapper):
            # executes functions from exec_list sequentially
            for func in exec_list:
                func(*args)
            # after all functions were executed http server is started in the main thread
            # call_soon_threadsafe puts http server into the main loop of the program
            loop.call_soon_threadsafe(make_http_server_wrapper)

        executor = ThreadPoolExecutor(max_workers=1)
        # bundle_func is executed in a separate thread. Main thread has an active probe server, which should not be
        # interrupted
        loop.run_in_executor(
            executor, bundle_func, exec_list, loop, make_http_server_wrapper
        )
        if options["max_memory"]:
            if STRUCTLOG_ENABLED:
                logger.info(
                    "Memory allocation check",
                    max_memory_mb=options["max_memory"],
                    active=True,
                )
            else:
                logger.info(
                    f"Starting memory allocation check with maximum memory set to {options['max_memory']} Mb"
                )
            loop.create_task(check_mem_allocations(options["max_memory"]))
        else:
            if STRUCTLOG_ENABLED:
                logger.warning("Memory allocation check", active=False)
            else:
                logger.warning("Starting without memory allocation check")

        def ask_exit(signame):
            logger.info(f"Received signal {signame}. Shutting down now.")
            loop.stop()

        for signame in ("SIGINT", "SIGTERM"):
            loop.add_signal_handler(
                getattr(signal, signame), functools.partial(ask_exit, signame)
            )

        loop.run_forever()

    def structlog_probe_configured(self, probe_port, probe_representations, options):
        logger.info(
            PROBE_CONFIGURED_EVENT,
            port=probe_port,
            active=True,
            liveness=probe_representations["liveness_probe"],
            readiness=probe_representations["readiness_probe"],
            startup=probe_representations["startup_probe"],
            integrated=probe_port == options["port"],
        )

    def log_prometheus(self, options, probe_port):
        if "no_metrics" not in options or not options["no_metrics"]:
            if STRUCTLOG_ENABLED:
                logger.info(
                    PROMETHEUS_CONFIGURED_EVENT,
                    port=probe_port,
                    route=options["metrics_path"],
                    active=True,
                )
            else:
                logger.info(
                    f"Starting Prometheus metrics exporter on port {probe_port} with "
                    f"route {options['metrics_path']}"
                )
        else:
            if STRUCTLOG_ENABLED:
                logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)
            else:
                logger.info(
                    "Running without Prometheus exporter, because --no-metrics flag was set"
                )

1	import asyncio	4✔
2	import functools	4✔
3	import os	4✔
4	import signal	4✔
5	import time	4✔
6	from concurrent.futures.thread import ThreadPoolExecutor	4✔
7
8	import tornado.autoreload	4✔
9	import tornado.web	4✔
10	import tornado.wsgi	4✔
11	from django.conf import settings	4✔
12	from django.core.management.base import BaseCommand	4✔
13
14	from hurricane.management.commands import HURRICANE_DIST_VERSION	4✔
15	from hurricane.server import (	4✔
16	check_db_and_migrations,
17	check_mem_allocations,
18	command_task,
19	logger,
20	make_http_server_and_listen,
21	make_probe_server,
22	sanitize_probes,
23	static_watch,
24	)
25	from hurricane.server.debugging import setup_debugging	4✔
26	from hurricane.server.loggers import STRUCTLOG_ENABLED	4✔
27
28	PROBE_CONFIGURED_EVENT = "Probe configured"	4✔
29	PROMETHEUS_CONFIGURED_EVENT = "Prometheus configured"	4✔
30
31
32	class Command(BaseCommand):	4✔
33
34	"""
35	Start a Tornado-powered Django web server by using ``python manage.py serve <arguments>``.
36
37	It can run Django management commands with the ``--command`` flag, that will be executed asynchronously.
38	The application server will only be started upon successful execution of management commands. During execution
39	of management commands the startup probe responds with a status 400.
40
41	Arguments:
42	- ``--static`` - serve collected static files
43	- ``--media`` - serve media files
44	- ``--autoreload`` - reload code on change
45	- ``--debug`` - set Tornado's Debug flag
46	- ``--port`` - the port for Tornado to listen on
47	- ``--metrics`` - the exposed path (default is /metrics) to export Prometheus metrics
48	- ``--startup-probe`` - the exposed path (default is /startup) for probes to check startup
49	- ``--readiness-probe`` - the exposed path (default is /ready) for probes to check readiness
50	- ``--liveness-probe`` - the exposed path (default is /alive) for probes to check liveness
51	- ``--probe-port`` - the port for Tornado probe route to listen on
52	- ``--req-queue-len`` - threshold of length of queue of request, which is considered for readiness probe
53	- ``--no-probe`` - disable probe endpoint
54	- ``--no-metrics`` - disable metrics collection
55	- ``--command`` - repetitive command for adding execution of management commands before serving
56	- ``--check-migrations`` - check if all migrations were applied before starting application
57	- ``--check-migrations-apply`` - same as --check-migrations but also applies them if needed
58	- ``--webhook-url``- If specified, webhooks will be sent to this url
59	- ``--max-lifetime``- If specified, maximum requests after which pod is restarted
60	- ``--max-memory``- If specified, process reloads after exceeding maximum memory (RSS) usage (in Mb)
61	- ``--static-watch`` - If specified, static files will be watched for changes and recollected
62	"""
63
64	help = "Start a Tornado-powered Django web server"	4✔
65
66	def add_arguments(self, parser):	4✔
67	"""
68	Defines arguments, that can be accepted with ``serve`` command.
69	"""
70	parser.add_argument(	4✔
71	"--static", action="store_true", help="Serve collected static files"
72	)
73	parser.add_argument("--media", action="store_true", help="Serve media files")	4✔
74	parser.add_argument(	4✔
75	"--autoreload", action="store_true", help="Reload code on change"
76	)
77	parser.add_argument(	4✔
78	"--debug", action="store_true", help="Set Tornado's Debug flag"
79	)
80	parser.add_argument(	4✔
81	"--port", type=int, default=8000, help="The port for Tornado to listen on"
82	)
83	parser.add_argument(	4✔
84	"--metrics",
85	type=str,
86	dest="metrics_path",
87	default="/metrics",
88	help="The exposed path (default is /metrics) to export Prometheus metrics",
89	)
90	parser.add_argument(	4✔
91	"--liveness-probe",
92	type=str,
93	default="/alive",
94	help="The exposed path (default is /alive) for probes to check liveness",
95	)
96	parser.add_argument(	4✔
97	"--readiness-probe",
98	type=str,
99	default="/ready",
100	help="The exposed path (default is /ready) for probes to check readiness",
101	)
102	parser.add_argument(	4✔
103	"--startup-probe",
104	type=str,
105	default="/startup",
106	help="The exposed path (default is /startup) for probes to check startup",
107	)
108	parser.add_argument(	4✔
109	"--probe-port",
110	type=int,
111	help="The port for Tornado probe route to listen on",
112	)
113	parser.add_argument(	4✔
114	"--req-queue-len", type=int, default=10, help="Length of the request queue"
115	)
116	parser.add_argument(	4✔
117	"--no-probe", action="store_true", help="Disable probe endpoint"
118	)
119	parser.add_argument(	4✔
120	"--no-metrics", action="store_true", help="Disable metrics collection"
121	)
122	parser.add_argument("--command", type=str, action="append", nargs="+")	4✔
123	parser.add_argument(	4✔
124	"--check-migrations",
125	action="store_true",
126	help="Check if migrations were applied",
127	)
128	parser.add_argument(	4✔
129	"--check-migrations-apply",
130	action="store_true",
131	help="Check if migrations were applied and apply them if needed",
132	)
133	parser.add_argument(	4✔
134	"--debugger",
135	action="store_true",
136	help="Open a debugger port according to the Debug Adapter Protocol",
137	)
138	parser.add_argument(	4✔
139	"--debugger-port",
140	type=int,
141	default=5678,
142	help="The port for the debug client to attach",
143	)
144	parser.add_argument(	4✔
145	"--webhook-url",
146	type=str,
147	help="Url for webhooks",
148	)
149	parser.add_argument(	4✔
150	"--max-lifetime",
151	type=int,
152	default=None,
153	help="Maximum requests after which pod is restarted (default = None)",
154	)
155	parser.add_argument(	4✔
156	"--max-memory",
157	type=int,
158	default=None,
159	help="Maximum memory (Resident Set Size) in Mb before process reloads (default = None, no reload)",
160	)
161	parser.add_argument(	4✔
162	"--workers",
163	type=int,
164	default=None,
165	help="Number of thread workers to be used for the server (default = Number of CPUs + 4)",
166	)
167	parser.add_argument(	4✔
168	"--static-watch",
169	type=str,
170	action="append",
171	help="Watch files and run collectstatic if any file changed",
172	)
173	parser.add_argument(	4✔
174	"--pycharm-host",
175	type=str,
176	default=None,
177	help="The host of the pycharm debug server",
178	)
179	parser.add_argument(	4✔
180	"--pycharm-port",
181	type=int,
182	default=None,
183	help="The port of the pycharm debug server",
184	)
185
186	def merge_option(	4✔
187	self,
188	option_name: str,
189	option_descriptor: str,
190	options: dict,
191	optional=False,
192	default=None,
193	):
194	"""
195	Merges a single option into the given option dictionary
196
197	Args:
198	option_name (str): Name of the option in the options dictionary
199	option_descriptor (str): Name of the option as env variable
200	"""
201	# leave early if option is already set via cli argument - highest precedence
202	if options[option_name] is not None and options[option_name] != default:	4✔
203	return	4✔
204	try: # first try to add option from django settings - second highest precedence	4✔
205	options.update(	4✔
206	{
207	option_name: getattr(
208	settings, option_descriptor.removeprefix("HURRICANE_")
209	)
210	}
211	)
212	except AttributeError: # then add from env variables - lowest precedence	4✔
213	if option_descriptor not in os.environ and options[option_name] is None:	4✔
214	if optional: # if optional, just return and do not raise an error	4!
215	return	4✔
NEW 216	raise ValueError(	×
217	(
218	f"Option {option_descriptor} must be set as environment variable,"
219	" in django settings or as a command line argument."
220	)
221	)
222	# try parsing int in general because we can't know the type of env vars
223	try:	4✔
224	options.update(	4✔
225	{option_name: int(str(os.environ.get(option_descriptor)))}
226	)
227	except (TypeError, ValueError):	4✔
228	options.update(	4✔
229	{
230	option_name: os.environ.get(option_descriptor)
231	if option_descriptor in os.environ
232	else options[option_name]
233	}
234	)
235
236	def merge_options(self, options: dict):	4✔
237	"""
238	Merges options with django settings. Precedence is the following:
239	- ENV variables
240	- Django settings
241	- Command line arguments
242	"""
243	self.merge_option("static", "HURRICANE_STATIC", options, default=False)	4✔
244	self.merge_option("media", "HURRICANE_MEDIA", options, default=False)	4✔
245	self.merge_option("autoreload", "HURRICANE_AUTORELOAD", options, default=False)	4✔
246	self.merge_option("debug", "HURRICANE_DEBUG", options, default=False)	4✔
247	self.merge_option("port", "HURRICANE_PORT", options, default=8000)	4✔
248	self.merge_option(	4✔
249	"metrics_path", "HURRICANE_METRICS", options, default="/metrics"
250	)
251	self.merge_option(	4✔
252	"liveness_probe", "HURRICANE_LIVENESS_PROBE", options, default="/alive"
253	)
254	self.merge_option(	4✔
255	"readiness_probe", "HURRICANE_READINESS_PROBE", options, default="/ready"
256	)
257	self.merge_option(	4✔
258	"startup_probe", "HURRICANE_STARTUP_PROBE", options, default="/startup"
259	)
260	self.merge_option("probe_port", "HURRICANE_PROBE_PORT", options, optional=True)	4✔
261	self.merge_option(	4✔
262	"req_queue_len", "HURRICANE_REQ_QUEUE_LEN", options, default=10
263	)
264	self.merge_option("no_probe", "HURRICANE_NO_PROBE", options, default=False)	4✔
265	self.merge_option("no_metrics", "HURRICANE_NO_METRICS", options, default=False)	4✔
266	self.merge_option("command", "HURRICANE_COMMAND", options, optional=True)	4✔
267	self.merge_option(	4✔
268	"check_migrations", "HURRICANE_CHECK_MIGRATIONS", options, default=False
269	)
270	self.merge_option(	4✔
271	"check_migrations_apply",
272	"HURRICANE_CHECK_MIGRATIONS_APPLY",
273	options,
274	default=False,
275	)
276	self.merge_option("debugger", "HURRICANE_DEBUGGER", options, default=False)	4✔
277	self.merge_option(	4✔
278	"debugger_port", "HURRICANE_DEBUGGER_PORT", options, default=5678
279	)
280	self.merge_option(	4✔
281	"webhook_url", "HURRICANE_WEBHOOK_URL", options, optional=True
282	)
283	self.merge_option(	4✔
284	"max_lifetime",
285	"HURRICANE_MAX_LIFETIME",
286	options,
287	optional=True,
288	default=None,
289	)
290	self.merge_option(	4✔
291	"max_memory", "HURRICANE_MAX_MEMORY", options, optional=True, default=None
292	)
293	self.merge_option(	4✔
294	"workers", "HURRICANE_WORKERS", options, optional=True, default=None
295	)
296	self.merge_option(	4✔
297	"static_watch", "HURRICANE_STATIC_WATCH", options, optional=True
298	)
299	self.merge_option(	4✔
300	"pycharm_host",
301	"HURRICANE_PYCHARM_HOST",
302	options,
303	optional=True,
304	default=None,
305	)
306	self.merge_option(	4✔
307	"pycharm_port",
308	"HURRICANE_PYCHARM_PORT",
309	options,
310	optional=True,
311	default=None,
312	)
313
314	def handle(self, args, *options):	4✔
315	"""
316	Defines functionalities for different arguments. After all arguments were processed, it starts the async event
317	loop.
318	"""
319	self.merge_options(options)	4✔
320	start_time = time.time()	4✔
321	if STRUCTLOG_ENABLED:	4!
322	logger.info(	×
323	"Tornado-powered Django web server.",
324	hurricane=HURRICANE_DIST_VERSION,
325	)
326	else:
327	logger.info(	4✔
328	f"Tornado-powered Django web server. Version: {HURRICANE_DIST_VERSION}"
329	)
330
331	if options["autoreload"]:	4✔
332	tornado.autoreload.start()	4✔
333	if options["static_watch"] and len(options["static_watch"]):	4✔
334	logger.info("Watching static files for any changes")	4✔
335	for path in options["static_watch"]:	4✔
336	if os.path.exists(path):	4✔
337	logger.info("Watching path {}.".format(path))	4✔
338	tornado.autoreload.watch(path)	4✔
339	else:
340	logger.error(	4✔
341	"Tried to watch {}, but it does not exist.".format(path)
342	)
343	tornado.autoreload.add_reload_hook(static_watch)	4✔
344	logger.info("Autoreload was performed")	4✔
345
346	# set the probe port
347	# the probe port by default is supposed to run the next port of the application
348	probe_port = (	4✔
349	options["probe_port"] if options["probe_port"] else options["port"] + 1
350	)
351	options["probe_port"] = probe_port	4✔
352
353	# sanitize probes: returns regexps for probes in options and their representations for logging
354	options, probe_representations = sanitize_probes(options)	4✔
355
356	# set the probe routes
357	# if probe port is set to the application's port, add it to the application's routes
358	include_probe = False	4✔
359	if not options["no_probe"]:	4✔
360	if probe_port != options["port"]:	4✔
361	if STRUCTLOG_ENABLED:	4!
UNCOV 362	self.structlog_probe_configured(	×
363	probe_port, probe_representations, options
364	)
365	else:
366	logger.info(	4✔
367	f"Starting probe application running on port {probe_port} with route liveness-probe: "
368	f"{probe_representations['liveness_probe']}, "
369	f"readiness-probe: {probe_representations['readiness_probe']}, "
370	f"startup-probe: {probe_representations['startup_probe']}"
371	)
372	self.log_prometheus(options, probe_port)	4✔
373	probe_application = make_probe_server(options, self.check)	4✔
374	probe_application.listen(probe_port)	4✔
375	else:
376	include_probe = True	4✔
377	if STRUCTLOG_ENABLED:	4!
UNCOV 378	self.structlog_probe_configured(	×
379	probe_port, probe_representations, options
380	)
381	else:
382	logger.info(	4✔
383	f"Starting probe application with routes "
384	f"liveness-probe: {probe_representations['liveness_probe']}, "
385	f"readiness-probe: {probe_representations['readiness_probe']}, "
386	f"startup-probe: {probe_representations['startup_probe']} "
387	f"running integrated on port {probe_port}"
388	)
389	self.log_prometheus(options, probe_port)	4✔
390
391	else:
392	if STRUCTLOG_ENABLED:	4!
UNCOV 393	logger.info("Probes configured", active=False)	×
UNCOV 394	logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)	×
395	else:
396	logger.info("No probe application running")	4✔
397	logger.info(	4✔
398	"Running without Prometheus exporter, because --no-probe flag was set"
399	)
400	options["no_metrics"] = True	4✔
401
402	setup_debugging(options)	4✔
403
404	loop = asyncio.get_event_loop()	4✔
405
406	make_http_server_wrapper = functools.partial(	4✔
407	make_http_server_and_listen,
408	start_time=start_time,
409	options=options,
410	check=self.check,
411	include_probe=include_probe,
412	)
413
414	# all commands, that should be executed before starting http server should be added to this list
415	exec_list = []	4✔
416	if options["command"]:	4✔
417	# wrap function to use additional variables
418	management_commands_wrapper = functools.partial(	4✔
419	command_task,
420	commands=options["command"],
421	webhook_url=options["webhook_url"] or None,
422	loop=loop,
423	)
424	exec_list.append(management_commands_wrapper)	4✔
425	if options["check_migrations"] or options["check_migrations_apply"]:	4✔
426	check_db_and_migrations_wrapper = functools.partial(	4✔
427	check_db_and_migrations,
428	webhook_url=options["webhook_url"] or None,
429	loop=loop,
430	apply_migration=True if options["check_migrations_apply"] else False,
431	)
432	exec_list.append(check_db_and_migrations_wrapper)	4✔
433
434	def bundle_func(exec_list, loop, make_http_server_wrapper):	4✔
435	# executes functions from exec_list sequentially
UNCOV 436	for func in exec_list:	×
UNCOV 437	func(*args)	×
438	# after all functions were executed http server is started in the main thread
439	# call_soon_threadsafe puts http server into the main loop of the program
UNCOV 440	loop.call_soon_threadsafe(make_http_server_wrapper)	×
441
442	executor = ThreadPoolExecutor(max_workers=1)	4✔
443	# bundle_func is executed in a separate thread. Main thread has an active probe server, which should not be
444	# interrupted
445	loop.run_in_executor(	4✔
446	executor, bundle_func, exec_list, loop, make_http_server_wrapper
447	)
448	if options["max_memory"]:	4!
UNCOV 449	if STRUCTLOG_ENABLED:	×
UNCOV 450	logger.info(	×
451	"Memory allocation check",
452	max_memory_mb=options["max_memory"],
453	active=True,
454	)
455	else:
UNCOV 456	logger.info(	×
457	f"Starting memory allocation check with maximum memory set to {options['max_memory']} Mb"
458	)
UNCOV 459	loop.create_task(check_mem_allocations(options["max_memory"]))	×
460	else:
461	if STRUCTLOG_ENABLED:	4!
462	logger.warning("Memory allocation check", active=False)	×
463	else:
464	logger.warning("Starting without memory allocation check")	4✔
465
466	def ask_exit(signame):	4✔
467	logger.info(f"Received signal {signame}. Shutting down now.")	4✔
468	loop.stop()	4✔
469
470	for signame in ("SIGINT", "SIGTERM"):	4✔
471	loop.add_signal_handler(	4✔
472	getattr(signal, signame), functools.partial(ask_exit, signame)
473	)
474
475	loop.run_forever()	4✔
476
477	def structlog_probe_configured(self, probe_port, probe_representations, options):	4✔
UNCOV 478	logger.info(	×
479	PROBE_CONFIGURED_EVENT,
480	port=probe_port,
481	active=True,
482	liveness=probe_representations["liveness_probe"],
483	readiness=probe_representations["readiness_probe"],
484	startup=probe_representations["startup_probe"],
485	integrated=probe_port == options["port"],
486	)
487
488	def log_prometheus(self, options, probe_port):	4✔
489	if "no_metrics" not in options or not options["no_metrics"]:	4✔
490	if STRUCTLOG_ENABLED:	4!
UNCOV 491	logger.info(	×
492	PROMETHEUS_CONFIGURED_EVENT,
493	port=probe_port,
494	route=options["metrics_path"],
495	active=True,
496	)
497	else:
498	logger.info(	4✔
499	f"Starting Prometheus metrics exporter on port {probe_port} with "
500	f"route {options['metrics_path']}"
501	)
502	else:
503	if STRUCTLOG_ENABLED:	4!
504	logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)	×
505	else:
506	logger.info(	4✔
507	"Running without Prometheus exporter, because --no-metrics flag was set"
508	)

django-hurricane / django-hurricane / 9674894549

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous