229003122

Build Type

push

github

Committed by Unrud

Commit Message

Add handlers for more signals we might encounter

Run Details

1191 of 1533 branches covered (77.69%)

Branch coverage included in aggregate %.

5 of 6 new or added lines in 1 file covered. (83.33%)

16 existing lines in 2 files now uncovered.

2872 of 3412 relevant lines covered (84.17%)

12.61 hits per line

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

78.29

/radicale/__main__.py

# This file is part of Radicale Server - Calendar Server
# Copyright © 2011-2017 Guillaume Ayoub
# Copyright © 2017-2019 Unrud <unrud@outlook.com>
#
# This library is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Radicale.  If not, see <http://www.gnu.org/licenses/>.

"""
Radicale executable module.

This module can be executed from a command line with ``$python -m radicale``.
Uses the built-in WSGI server.

"""

import argparse
import contextlib
import os
import signal
import sys

from radicale import VERSION, config, log, server, storage
from radicale.log import logger


def run():
    """Run Radicale as a standalone server."""

    # Raise SystemExit when signal arrives to run cleanup code
    # (like destructors, try-finish etc.), otherwise the process exits
    # without running any of them
    def signal_handler(signal_number, stack_frame):
        sys.exit(1)
    signal.signal(signal.SIGTERM, signal_handler)
    signal.signal(signal.SIGINT, signal_handler)
    if os.name == "nt":
        signal.signal(signal.SIGBREAK, signal_handler)
    elif os.name == "posix":
        signal.signal(signal.SIGHUP, signal_handler)
        signal.signal(signal.SIGUSR1, signal_handler)
        signal.signal(signal.SIGUSR2, signal_handler)

    log.setup()

    # Get command-line arguments
    parser = argparse.ArgumentParser(
        prog="radicale", usage="%(prog)s [OPTIONS]")

    parser.add_argument("--version", action="version", version=VERSION)
    parser.add_argument("--verify-storage", action="store_true",
                        help="check the storage for errors and exit")
    parser.add_argument(
        "-C", "--config", help="use specific configuration files", nargs="*")
    parser.add_argument("-D", "--debug", action="store_true",
                        help="print debug information")

    groups = {}
    for section, values in config.DEFAULT_CONFIG_SCHEMA.items():
        if section.startswith("_"):
            continue
        group = parser.add_argument_group(section)
        groups[group] = []
        for option, data in values.items():
            if option.startswith("_"):
                continue
            kwargs = data.copy()
            long_name = "--%s-%s" % (section, option.replace("_", "-"))
            args = kwargs.pop("aliases", [])
            args.append(long_name)
            kwargs["dest"] = "%s_%s" % (section, option)
            groups[group].append(kwargs["dest"])
            del kwargs["value"]
            with contextlib.suppress(KeyError):
                del kwargs["internal"]

            if kwargs["type"] == bool:
                del kwargs["type"]
                kwargs["action"] = "store_const"
                kwargs["const"] = "True"
                opposite_args = kwargs.pop("opposite", [])
                opposite_args.append("--no%s" % long_name[1:])
                group.add_argument(*args, **kwargs)

                kwargs["const"] = "False"
                kwargs["help"] = "do not %s (opposite of %s)" % (
                    kwargs["help"], long_name)
                group.add_argument(*opposite_args, **kwargs)
            else:
                del kwargs["type"]
                group.add_argument(*args, **kwargs)

    args = parser.parse_args()

    # Preliminary configure logging
    if args.debug:
        args.logging_level = "debug"
    with contextlib.suppress(ValueError):
        log.set_level(config.DEFAULT_CONFIG_SCHEMA["logging"]["level"]["type"](
            args.logging_level))

    # Update Radicale configuration according to arguments
    arguments_config = {}
    for group, actions in groups.items():
        section = group.title
        section_config = {}
        for action in actions:
            value = getattr(args, action)
            if value is not None:
                section_config[action.split('_', 1)[1]] = value
        if section_config:
            arguments_config[section] = section_config

    try:
        configuration = config.load(config.parse_compound_paths(
            config.DEFAULT_CONFIG_PATH,
            os.environ.get("RADICALE_CONFIG"),
            os.pathsep.join(args.config) if args.config else None))
        if arguments_config:
            configuration.update(arguments_config, "arguments")
    except Exception as e:
        logger.fatal("Invalid configuration: %s", e, exc_info=True)
        sys.exit(1)

    # Configure logging
    log.set_level(configuration.get("logging", "level"))

    # Log configuration after logger is configured
    for source, miss in configuration.sources():
        logger.info("%s %s", "Skipped missing" if miss else "Loaded", source)

    if args.verify_storage:
        logger.info("Verifying storage")
        try:
            storage_ = storage.load(configuration)
            with storage_.acquire_lock("r"):
                if not storage_.verify():
                    logger.fatal("Storage verifcation failed")
                    sys.exit(1)
        except Exception as e:
            logger.fatal("An exception occurred during storage verification: "
                         "%s", e, exc_info=True)
            sys.exit(1)
        return

    try:
        server.serve(configuration)
    except Exception as e:
        logger.fatal("An exception occurred during server startup: %s", e,
                     exc_info=True)
        sys.exit(1)


if __name__ == "__main__":
    run()

1	# This file is part of Radicale Server - Calendar Server
2	# Copyright © 2011-2017 Guillaume Ayoub
3	# Copyright © 2017-2019 Unrud <unrud@outlook.com>
4	#
5	# This library is free software: you can redistribute it and/or modify
6	# it under the terms of the GNU General Public License as published by
7	# the Free Software Foundation, either version 3 of the License, or
8	# (at your option) any later version.
9	#
10	# This library is distributed in the hope that it will be useful,
11	# but WITHOUT ANY WARRANTY; without even the implied warranty of
12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	# GNU General Public License for more details.
14	#
15	# You should have received a copy of the GNU General Public License
16	# along with Radicale. If not, see <http://www.gnu.org/licenses/>.
17
18	"""	15✔
19	Radicale executable module.
20
21	This module can be executed from a command line with ``$python -m radicale``.
22	Uses the built-in WSGI server.
23
24	"""
25
26	import argparse	15✔
27	import contextlib	15✔
28	import os	15✔
29	import signal	15✔
30	import sys	15✔
31
32	from radicale import VERSION, config, log, server, storage	15✔
33	from radicale.log import logger	15✔
34
35
36	def run():	15✔
37	"""Run Radicale as a standalone server."""
38
39	# Raise SystemExit when signal arrives to run cleanup code
40	# (like destructors, try-finish etc.), otherwise the process exits
41	# without running any of them
42	def signal_handler(signal_number, stack_frame):	15✔
43	sys.exit(1)	15✔
44	signal.signal(signal.SIGTERM, signal_handler)	15✔
45	signal.signal(signal.SIGINT, signal_handler)	15✔
46	if os.name == "nt":	15!
NEW 47	signal.signal(signal.SIGBREAK, signal_handler)	×
48	elif os.name == "posix":	15!
49	signal.signal(signal.SIGHUP, signal_handler)	15✔
50	signal.signal(signal.SIGUSR1, signal_handler)	15✔
51	signal.signal(signal.SIGUSR2, signal_handler)	15✔
52
53	log.setup()	15✔
54
55	# Get command-line arguments
56	parser = argparse.ArgumentParser(	15✔
57	prog="radicale", usage="%(prog)s [OPTIONS]")
58
59	parser.add_argument("--version", action="version", version=VERSION)	15✔
60	parser.add_argument("--verify-storage", action="store_true",	15✔
61	help="check the storage for errors and exit")
62	parser.add_argument(	15✔
63	"-C", "--config", help="use specific configuration files", nargs="*")
64	parser.add_argument("-D", "--debug", action="store_true",	15✔
65	help="print debug information")
66
67	groups = {}	15✔
68	for section, values in config.DEFAULT_CONFIG_SCHEMA.items():	15✔
69	if section.startswith("_"):	15!
UNCOV 70	continue	×
71	group = parser.add_argument_group(section)	15✔
72	groups[group] = []	15✔
73	for option, data in values.items():	15✔
74	if option.startswith("_"):	15✔
75	continue	15✔
76	kwargs = data.copy()	15✔
77	long_name = "--%s-%s" % (section, option.replace("_", "-"))	15✔
78	args = kwargs.pop("aliases", [])	15✔
79	args.append(long_name)	15✔
80	kwargs["dest"] = "%s_%s" % (section, option)	15✔
81	groups[group].append(kwargs["dest"])	15✔
82	del kwargs["value"]	15✔
83	with contextlib.suppress(KeyError):	15✔
84	del kwargs["internal"]	15✔
85
86	if kwargs["type"] == bool:	15✔
87	del kwargs["type"]	15✔
88	kwargs["action"] = "store_const"	15✔
89	kwargs["const"] = "True"	15✔
90	opposite_args = kwargs.pop("opposite", [])	15✔
91	opposite_args.append("--no%s" % long_name[1:])	15✔
92	group.add_argument(args, *kwargs)	15✔
93
94	kwargs["const"] = "False"	15✔
95	kwargs["help"] = "do not %s (opposite of %s)" % (	15✔
96	kwargs["help"], long_name)
97	group.add_argument(opposite_args, *kwargs)	15✔
98	else:
99	del kwargs["type"]	15✔
100	group.add_argument(args, *kwargs)	15✔
101
102	args = parser.parse_args()	15✔
103
104	# Preliminary configure logging
105	if args.debug:	15!
UNCOV 106	args.logging_level = "debug"	×
107	with contextlib.suppress(ValueError):	15✔
108	log.set_level(config.DEFAULT_CONFIG_SCHEMA["logging"]["level"]["type"](	15✔
109	args.logging_level))
110
111	# Update Radicale configuration according to arguments
112	arguments_config = {}	15✔
113	for group, actions in groups.items():	15✔
114	section = group.title	15✔
115	section_config = {}	15✔
116	for action in actions:	15✔
117	value = getattr(args, action)	15✔
118	if value is not None:	15!
119	section_config[action.split('_', 1)[1]] = value	15✔
120	if section_config:	15✔
121	arguments_config[section] = section_config	15✔
122
123	try:	15✔
124	configuration = config.load(config.parse_compound_paths(	15✔
125	config.DEFAULT_CONFIG_PATH,
126	os.environ.get("RADICALE_CONFIG"),
127	os.pathsep.join(args.config) if args.config else None))
128	if arguments_config:	15!
129	configuration.update(arguments_config, "arguments")	15✔
UNCOV 130	except Exception as e:	×
UNCOV 131	logger.fatal("Invalid configuration: %s", e, exc_info=True)	×
UNCOV 132	sys.exit(1)	×
133
134	# Configure logging
135	log.set_level(configuration.get("logging", "level"))	15✔
136
137	# Log configuration after logger is configured
138	for source, miss in configuration.sources():	15✔
139	logger.info("%s %s", "Skipped missing" if miss else "Loaded", source)	15✔
140
141	if args.verify_storage:	15!
UNCOV 142	logger.info("Verifying storage")	×
143	try:	×
144	storage_ = storage.load(configuration)	×
UNCOV 145	with storage_.acquire_lock("r"):	×
UNCOV 146	if not storage_.verify():	×
UNCOV 147	logger.fatal("Storage verifcation failed")	×
UNCOV 148	sys.exit(1)	×
UNCOV 149	except Exception as e:	×
UNCOV 150	logger.fatal("An exception occurred during storage verification: "	×
151	"%s", e, exc_info=True)
UNCOV 152	sys.exit(1)	×
UNCOV 153	return	×
154
155	try:	15✔
156	server.serve(configuration)	15✔
157	except Exception as e:	15✔
158	logger.fatal("An exception occurred during server startup: %s", e,	×
159	exc_info=True)
160	sys.exit(1)	×
161
162
163	if __name__ == "__main__":
164	run()

Kozea / Radicale / 229003122

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