8661297721

Committed 12 Apr 2024 11:23AM UTC coverage: 85.471% (+0.3%) from 85.207%

Build # 8661297721

Build Type

Pull #131

github

Committed by

web-flow

Commit Message

Merge bbcc4a8fc into 45bf94fb2

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%)

15 existing lines in 1 file 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(os.environ.get(option_descriptor))})
            except TypeError:
                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)
        self.merge_option("media", "HURRICANE_MEDIA", options)
        self.merge_option("autoreload", "HURRICANE_AUTORELOAD", options)
        self.merge_option("debug", "HURRICANE_DEBUG", options)
        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)
        self.merge_option("no_metrics", "HURRICANE_NO_METRICS", options)
        self.merge_option("command", "HURRICANE_COMMAND", options, optional=True)
        self.merge_option("check_migrations", "HURRICANE_CHECK_MIGRATIONS", options)
        self.merge_option(
            "check_migrations_apply", "HURRICANE_CHECK_MIGRATIONS_APPLY", options
        )
        self.merge_option("debugger", "HURRICANE_DEBUGGER", options)
        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({option_name: int(os.environ.get(option_descriptor))})	4✔
225	except TypeError:	4✔
226	options.update(	4✔
227	{
228	option_name: os.environ.get(option_descriptor)
229	if option_descriptor in os.environ
230	else options[option_name]
231	}
232	)
233
234	def merge_options(self, options: dict):	4✔
235	"""
236	Merges options with django settings. Precedence is the following:
237	- ENV variables
238	- Django settings
239	- Command line arguments
240	"""
241	self.merge_option("static", "HURRICANE_STATIC", options)	4✔
242	self.merge_option("media", "HURRICANE_MEDIA", options)	4✔
243	self.merge_option("autoreload", "HURRICANE_AUTORELOAD", options)	4✔
244	self.merge_option("debug", "HURRICANE_DEBUG", options)	4✔
245	self.merge_option("port", "HURRICANE_PORT", options, default=8000)	4✔
246	self.merge_option(	4✔
247	"metrics_path", "HURRICANE_METRICS", options, default="/metrics"
248	)
249	self.merge_option(	4✔
250	"liveness_probe", "HURRICANE_LIVENESS_PROBE", options, default="/alive"
251	)
252	self.merge_option(	4✔
253	"readiness_probe", "HURRICANE_READINESS_PROBE", options, default="/ready"
254	)
255	self.merge_option(	4✔
256	"startup_probe", "HURRICANE_STARTUP_PROBE", options, default="/startup"
257	)
258	self.merge_option("probe_port", "HURRICANE_PROBE_PORT", options, optional=True)	4✔
259	self.merge_option(	4✔
260	"req_queue_len", "HURRICANE_REQ_QUEUE_LEN", options, default=10
261	)
262	self.merge_option("no_probe", "HURRICANE_NO_PROBE", options)	4✔
263	self.merge_option("no_metrics", "HURRICANE_NO_METRICS", options)	4✔
264	self.merge_option("command", "HURRICANE_COMMAND", options, optional=True)	4✔
265	self.merge_option("check_migrations", "HURRICANE_CHECK_MIGRATIONS", options)	4✔
266	self.merge_option(	4✔
267	"check_migrations_apply", "HURRICANE_CHECK_MIGRATIONS_APPLY", options
268	)
269	self.merge_option("debugger", "HURRICANE_DEBUGGER", options)	4✔
270	self.merge_option(	4✔
271	"debugger_port", "HURRICANE_DEBUGGER_PORT", options, default=5678
272	)
273	self.merge_option(	4✔
274	"webhook_url", "HURRICANE_WEBHOOK_URL", options, optional=True
275	)
276	self.merge_option(	4✔
277	"max_lifetime",
278	"HURRICANE_MAX_LIFETIME",
279	options,
280	optional=True,
281	default=None,
282	)
283	self.merge_option(	4✔
284	"max_memory", "HURRICANE_MAX_MEMORY", options, optional=True, default=None
285	)
286	self.merge_option(	4✔
287	"workers", "HURRICANE_WORKERS", options, optional=True, default=None
288	)
289	self.merge_option(	4✔
290	"static_watch", "HURRICANE_STATIC_WATCH", options, optional=True
291	)
292	self.merge_option(	4✔
293	"pycharm_host",
294	"HURRICANE_PYCHARM_HOST",
295	options,
296	optional=True,
297	default=None,
298	)
299	self.merge_option(	4✔
300	"pycharm_port",
301	"HURRICANE_PYCHARM_PORT",
302	options,
303	optional=True,
304	default=None,
305	)
306
307	def handle(self, args, *options):	4✔
308	"""
309	Defines functionalities for different arguments. After all arguments were processed, it starts the async event
310	loop.
311	"""
312	self.merge_options(options)	4✔
313	start_time = time.time()	4✔
314	if STRUCTLOG_ENABLED:	4!
UNCOV 315	logger.info(	×
316	"Tornado-powered Django web server.",
317	hurricane=HURRICANE_DIST_VERSION,
318	)
319	else:
320	logger.info(	4✔
321	f"Tornado-powered Django web server. Version: {HURRICANE_DIST_VERSION}"
322	)
323
324	if options["autoreload"]:	4✔
325	tornado.autoreload.start()	4✔
326	if options["static_watch"] and len(options["static_watch"]):	4✔
327	logger.info("Watching static files for any changes")	4✔
328	for path in options["static_watch"]:	4✔
329	if os.path.exists(path):	4✔
330	logger.info("Watching path {}.".format(path))	4✔
331	tornado.autoreload.watch(path)	4✔
332	else:
333	logger.error(	4✔
334	"Tried to watch {}, but it does not exist.".format(path)
335	)
336	tornado.autoreload.add_reload_hook(static_watch)	4✔
337	logger.info("Autoreload was performed")	4✔
338
339	# set the probe port
340	# the probe port by default is supposed to run the next port of the application
341	probe_port = (	4✔
342	options["probe_port"] if options["probe_port"] else options["port"] + 1
343	)
344	options["probe_port"] = probe_port	4✔
345
346	# sanitize probes: returns regexps for probes in options and their representations for logging
347	options, probe_representations = sanitize_probes(options)	4✔
348
349	# set the probe routes
350	# if probe port is set to the application's port, add it to the application's routes
351	include_probe = False	4✔
352	if not options["no_probe"]:	4✔
353	if probe_port != options["port"]:	4✔
354	if STRUCTLOG_ENABLED:	4!
UNCOV 355	self.structlog_probe_configured(	×
356	probe_port, probe_representations, options
357	)
358	else:
359	logger.info(	4✔
360	f"Starting probe application running on port {probe_port} with route liveness-probe: "
361	f"{probe_representations['liveness_probe']}, "
362	f"readiness-probe: {probe_representations['readiness_probe']}, "
363	f"startup-probe: {probe_representations['startup_probe']}"
364	)
365	self.log_prometheus(options, probe_port)	4✔
366	probe_application = make_probe_server(options, self.check)	4✔
367	probe_application.listen(probe_port)	4✔
368	else:
369	include_probe = True	4✔
370	if STRUCTLOG_ENABLED:	4!
UNCOV 371	self.structlog_probe_configured(	×
372	probe_port, probe_representations, options
373	)
374	else:
375	logger.info(	4✔
376	f"Starting probe application with routes "
377	f"liveness-probe: {probe_representations['liveness_probe']}, "
378	f"readiness-probe: {probe_representations['readiness_probe']}, "
379	f"startup-probe: {probe_representations['startup_probe']} "
380	f"running integrated on port {probe_port}"
381	)
382	self.log_prometheus(options, probe_port)	4✔
383
384	else:
385	if STRUCTLOG_ENABLED:	4!
UNCOV 386	logger.info("Probes configured", active=False)	×
UNCOV 387	logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)	×
388	else:
389	logger.info("No probe application running")	4✔
390	logger.info(	4✔
391	"Running without Prometheus exporter, because --no-probe flag was set"
392	)
393	options["no_metrics"] = True	4✔
394
395	setup_debugging(options)	4✔
396
397	loop = asyncio.get_event_loop()	4✔
398
399	make_http_server_wrapper = functools.partial(	4✔
400	make_http_server_and_listen,
401	start_time=start_time,
402	options=options,
403	check=self.check,
404	include_probe=include_probe,
405	)
406
407	# all commands, that should be executed before starting http server should be added to this list
408	exec_list = []	4✔
409	if options["command"]:	4✔
410	# wrap function to use additional variables
411	management_commands_wrapper = functools.partial(	4✔
412	command_task,
413	commands=options["command"],
414	webhook_url=options["webhook_url"] or None,
415	loop=loop,
416	)
417	exec_list.append(management_commands_wrapper)	4✔
418	if options["check_migrations"] or options["check_migrations_apply"]:	4✔
419	check_db_and_migrations_wrapper = functools.partial(	4✔
420	check_db_and_migrations,
421	webhook_url=options["webhook_url"] or None,
422	loop=loop,
423	apply_migration=True if options["check_migrations_apply"] else False,
424	)
425	exec_list.append(check_db_and_migrations_wrapper)	4✔
426
427	def bundle_func(exec_list, loop, make_http_server_wrapper):	4✔
428	# executes functions from exec_list sequentially
UNCOV 429	for func in exec_list:	×
UNCOV 430	func(*args)	×
431	# after all functions were executed http server is started in the main thread
432	# call_soon_threadsafe puts http server into the main loop of the program
UNCOV 433	loop.call_soon_threadsafe(make_http_server_wrapper)	×
434
435	executor = ThreadPoolExecutor(max_workers=1)	4✔
436	# bundle_func is executed in a separate thread. Main thread has an active probe server, which should not be
437	# interrupted
438	loop.run_in_executor(	4✔
439	executor, bundle_func, exec_list, loop, make_http_server_wrapper
440	)
441	if options["max_memory"]:	4!
UNCOV 442	if STRUCTLOG_ENABLED:	×
UNCOV 443	logger.info(	×
444	"Memory allocation check",
445	max_memory_mb=options["max_memory"],
446	active=True,
447	)
448	else:
449	logger.info(	×
450	f"Starting memory allocation check with maximum memory set to {options['max_memory']} Mb"
451	)
UNCOV 452	loop.create_task(check_mem_allocations(options["max_memory"]))	×
453	else:
454	if STRUCTLOG_ENABLED:	4!
UNCOV 455	logger.warning("Memory allocation check", active=False)	×
456	else:
457	logger.warning("Starting without memory allocation check")	4✔
458
459	def ask_exit(signame):	4✔
460	logger.info(f"Received signal {signame}. Shutting down now.")	4✔
461	loop.stop()	4✔
462
463	for signame in ("SIGINT", "SIGTERM"):	4✔
464	loop.add_signal_handler(	4✔
465	getattr(signal, signame), functools.partial(ask_exit, signame)
466	)
467
468	loop.run_forever()	4✔
469
470	def structlog_probe_configured(self, probe_port, probe_representations, options):	4✔
UNCOV 471	logger.info(	×
472	PROBE_CONFIGURED_EVENT,
473	port=probe_port,
474	active=True,
475	liveness=probe_representations["liveness_probe"],
476	readiness=probe_representations["readiness_probe"],
477	startup=probe_representations["startup_probe"],
478	integrated=probe_port == options["port"],
479	)
480
481	def log_prometheus(self, options, probe_port):	4✔
482	if "no_metrics" not in options or not options["no_metrics"]:	4✔
483	if STRUCTLOG_ENABLED:	4!
UNCOV 484	logger.info(	×
485	PROMETHEUS_CONFIGURED_EVENT,
486	port=probe_port,
487	route=options["metrics_path"],
488	active=True,
489	)
490	else:
491	logger.info(	4✔
492	f"Starting Prometheus metrics exporter on port {probe_port} with "
493	f"route {options['metrics_path']}"
494	)
495	else:
496	if STRUCTLOG_ENABLED:	4!
UNCOV 497	logger.info(PROMETHEUS_CONFIGURED_EVENT, active=False)	×
498	else:
499	logger.info(	4✔
500	"Running without Prometheus exporter, because --no-metrics flag was set"
501	)

django-hurricane / django-hurricane / 8661297721

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