2196805551

Build # 2196805551

Build Type

push

github

Committed by Unrud

Commit Message

Fix random href fallback

Run Details

1704 of 2077 branches covered (82.04%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

2 existing lines in 1 file now uncovered.

3435 of 3924 relevant lines covered (87.54%)

16.08 hits per line

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

82.14

/radicale/server.py

# This file is part of Radicale - CalDAV and CardDAV server
# Copyright © 2008 Nicolas Kandel
# Copyright © 2008 Pascal Halter
# Copyright © 2008-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/>.

"""
Built-in WSGI server.

"""

import errno
import http
import select
import socket
import socketserver
import ssl
import sys
import wsgiref.simple_server
from typing import (Any, Callable, Dict, List, MutableMapping, Optional, Set,
                    Tuple, Union)
from urllib.parse import unquote

from radicale import Application, config
from radicale.log import logger

COMPAT_EAI_ADDRFAMILY: int
if hasattr(socket, "EAI_ADDRFAMILY"):
    COMPAT_EAI_ADDRFAMILY = socket.EAI_ADDRFAMILY  # type:ignore[attr-defined]
elif hasattr(socket, "EAI_NONAME"):
    # Windows and BSD don't have a special error code for this
    COMPAT_EAI_ADDRFAMILY = socket.EAI_NONAME
COMPAT_EAI_NODATA: int
if hasattr(socket, "EAI_NODATA"):
    COMPAT_EAI_NODATA = socket.EAI_NODATA
elif hasattr(socket, "EAI_NONAME"):
    # Windows and BSD don't have a special error code for this
    COMPAT_EAI_NODATA = socket.EAI_NONAME
COMPAT_IPPROTO_IPV6: int
if hasattr(socket, "IPPROTO_IPV6"):
    COMPAT_IPPROTO_IPV6 = socket.IPPROTO_IPV6
elif sys.platform == "win32":
    # HACK: https://bugs.python.org/issue29515
    COMPAT_IPPROTO_IPV6 = 41


# IPv4 (host, port) and IPv6 (host, port, flowinfo, scopeid)
ADDRESS_TYPE = Union[Tuple[str, int], Tuple[str, int, int, int]]


def format_address(address: ADDRESS_TYPE) -> str:
    return "[%s]:%d" % address[:2]


class ParallelHTTPServer(socketserver.ThreadingMixIn,
                         wsgiref.simple_server.WSGIServer):

    configuration: config.Configuration
    worker_sockets: Set[socket.socket]
    _timeout: float

    # We wait for child threads ourself (ThreadingMixIn)
    block_on_close: bool = False
    daemon_threads: bool = True

    def __init__(self, configuration: config.Configuration, family: int,
                 address: Tuple[str, int], RequestHandlerClass:
                 Callable[..., http.server.BaseHTTPRequestHandler]) -> None:
        self.configuration = configuration
        self.address_family = family
        super().__init__(address, RequestHandlerClass)
        self.worker_sockets = set()
        self._timeout = configuration.get("server", "timeout")

    def server_bind(self) -> None:
        if self.address_family == socket.AF_INET6:
            # Only allow IPv6 connections to the IPv6 socket
            self.socket.setsockopt(COMPAT_IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
        super().server_bind()

    def get_request(  # type:ignore[override]
            self) -> Tuple[socket.socket, Tuple[ADDRESS_TYPE, socket.socket]]:
        # Set timeout for client
        request: socket.socket
        client_address: ADDRESS_TYPE
        request, client_address = super().get_request()  # type:ignore[misc]
        if self._timeout > 0:
            request.settimeout(self._timeout)
        worker_socket, worker_socket_out = socket.socketpair()
        self.worker_sockets.add(worker_socket_out)
        # HACK: Forward `worker_socket` via `client_address` return value
        # to worker thread.
        # The super class calls `verify_request`, `process_request` and
        # `handle_error` with modified `client_address` value.
        return request, (client_address, worker_socket)

    def verify_request(  # type:ignore[override]
            self, request: socket.socket, client_address_and_socket:
            Tuple[ADDRESS_TYPE, socket.socket]) -> bool:
        return True

    def process_request(  # type:ignore[override]
            self, request: socket.socket, client_address_and_socket:
            Tuple[ADDRESS_TYPE, socket.socket]) -> None:
        # HACK: Super class calls `finish_request` in new thread with
        # `client_address_and_socket`
        return super().process_request(
            request, client_address_and_socket)  # type:ignore[arg-type]

    def finish_request(  # type:ignore[override]
            self, request: socket.socket, client_address_and_socket:
            Tuple[ADDRESS_TYPE, socket.socket]) -> None:
        # HACK: Unpack `client_address_and_socket` and call super class
        # `finish_request` with original `client_address`
        client_address, worker_socket = client_address_and_socket
        try:
            return self.finish_request_locked(request, client_address)
        finally:
            worker_socket.close()

    def finish_request_locked(self, request: socket.socket,
                              client_address: ADDRESS_TYPE) -> None:
        return super().finish_request(
            request, client_address)  # type:ignore[arg-type]

    def handle_error(  # type:ignore[override]
            self, request: socket.socket,
            client_address_or_client_address_and_socket:
            Union[ADDRESS_TYPE, Tuple[ADDRESS_TYPE, socket.socket]]) -> None:
        # HACK: This method can be called with the modified
        # `client_address_and_socket` or the original `client_address` value
        e = sys.exc_info()[1]
        assert e is not None
        if isinstance(e, socket.timeout):
            logger.info("Client timed out", exc_info=True)
        else:
            logger.error("An exception occurred during request: %s",
                         sys.exc_info()[1], exc_info=True)


class ParallelHTTPSServer(ParallelHTTPServer):

    def server_bind(self) -> None:
        super().server_bind()
        # Wrap the TCP socket in an SSL socket
        certfile: str = self.configuration.get("server", "certificate")
        keyfile: str = self.configuration.get("server", "key")
        cafile: str = self.configuration.get("server", "certificate_authority")
        # Test if the files can be read
        for name, filename in [("certificate", certfile), ("key", keyfile),
                               ("certificate_authority", cafile)]:
            type_name = config.DEFAULT_CONFIG_SCHEMA["server"][name][
                "type"].__name__
            source = self.configuration.get_source("server", name)
            if name == "certificate_authority" and not filename:
                continue
            try:
                open(filename, "r").close()
            except OSError as e:
                raise RuntimeError(
                    "Invalid %s value for option %r in section %r in %s: %r "
                    "(%s)" % (type_name, name, "server", source, filename,
                              e)) from e
        context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        context.load_cert_chain(certfile=certfile, keyfile=keyfile)
        if cafile:
            context.load_verify_locations(cafile=cafile)
            context.verify_mode = ssl.CERT_REQUIRED
        self.socket = context.wrap_socket(
            self.socket, server_side=True, do_handshake_on_connect=False)

    def finish_request_locked(  # type:ignore[override]
            self, request: ssl.SSLSocket, client_address: ADDRESS_TYPE
            ) -> None:
        try:
            try:
                request.do_handshake()
            except socket.timeout:
                raise
            except Exception as e:
                raise RuntimeError("SSL handshake failed: %s" % e) from e
        except Exception:
            try:
                self.handle_error(request, client_address)
            finally:
                self.shutdown_request(request)  # type:ignore[attr-defined]
            return
        return super().finish_request_locked(request, client_address)


class ServerHandler(wsgiref.simple_server.ServerHandler):

    # Don't pollute WSGI environ with OS environment
    os_environ: MutableMapping[str, str] = {}

    def log_exception(self, exc_info: "wsgiref.handlers._exc_info") -> None:
        logger.error("An exception occurred during request: %s",
                     exc_info[1], exc_info=exc_info)  # type:ignore[arg-type]


class RequestHandler(wsgiref.simple_server.WSGIRequestHandler):
    """HTTP requests handler."""

    # HACK: Assigned in `socketserver.StreamRequestHandler`
    connection: socket.socket

    def log_request(self, code: Union[int, str] = "-",
                    size: Union[int, str] = "-") -> None:
        pass  # Disable request logging.

    def log_error(self, format_: str, *args: Any) -> None:
        logger.error("An error occurred during request: %s", format_ % args)

    def get_environ(self) -> Dict[str, Any]:
        env = super().get_environ()
        if isinstance(self.connection, ssl.SSLSocket):
            # The certificate can be evaluated by the auth module
            env["REMOTE_CERTIFICATE"] = self.connection.getpeercert()
        # Parent class only tries latin1 encoding
        env["PATH_INFO"] = unquote(self.path.split("?", 1)[0])
        return env

    def handle(self) -> None:
        """Copy of WSGIRequestHandler.handle with different ServerHandler"""

        self.raw_requestline = self.rfile.readline(65537)
        if len(self.raw_requestline) > 65536:
            self.requestline = ""
            self.request_version = ""
            self.command = ""
            self.send_error(414)
            return

        if not self.parse_request():
            return

        handler = ServerHandler(
            self.rfile, self.wfile, self.get_stderr(), self.get_environ()
        )
        handler.request_handler = self  # type:ignore[attr-defined]
        app = self.server.get_app()  # type:ignore[attr-defined]
        handler.run(app)


def serve(configuration: config.Configuration,
          shutdown_socket: Optional[socket.socket] = None) -> None:
    """Serve radicale from configuration.

    `shutdown_socket` can be used to gracefully shutdown the server.
    The socket can be created with `socket.socketpair()`, when the other socket
    gets closed the server stops accepting new requests by clients and the
    function returns after all active requests are finished.

    """

    logger.info("Starting Radicale")
    # Copy configuration before modifying
    configuration = configuration.copy()
    configuration.update({"server": {"_internal_server": "True"}}, "server",
                         privileged=True)

    use_ssl: bool = configuration.get("server", "ssl")
    server_class = ParallelHTTPSServer if use_ssl else ParallelHTTPServer
    application = Application(configuration)
    servers = {}
    try:
        hosts: List[Tuple[str, int]] = configuration.get("server", "hosts")
        for address in hosts:
            # Try to bind sockets for IPv4 and IPv6
            possible_families = (socket.AF_INET, socket.AF_INET6)
            bind_ok = False
            for i, family in enumerate(possible_families):
                is_last = i == len(possible_families) - 1
                try:
                    server = server_class(configuration, family, address,
                                          RequestHandler)
                except OSError as e:
                    # Ignore unsupported families (only one must work)
                    if ((bind_ok or not is_last) and (
                            isinstance(e, socket.gaierror) and (
                                # Hostname does not exist or doesn't have
                                # address for address family
                                # macOS: IPv6 address for INET address family
                                e.errno == socket.EAI_NONAME or
                                # Address not for address family
                                e.errno == COMPAT_EAI_ADDRFAMILY or
                                e.errno == COMPAT_EAI_NODATA) or
                            # Workaround for PyPy
                            str(e) == "address family mismatched" or
                            # Address family not available (e.g. IPv6 disabled)
                            # macOS: IPv4 address for INET6 address family with
                            #        IPV6_V6ONLY set
                            e.errno == errno.EADDRNOTAVAIL or
                            # Address family not supported
                            e.errno == errno.EAFNOSUPPORT or
                            # Protocol not supported
                            e.errno == errno.EPROTONOSUPPORT)):
                        continue
                    raise RuntimeError("Failed to start server %r: %s" % (
                                           format_address(address), e)) from e
                servers[server.socket] = server
                bind_ok = True
                server.set_app(application)
                logger.info("Listening on %r%s",
                            format_address(server.server_address),
                            " with SSL" if use_ssl else "")
        if not servers:
            raise RuntimeError("No servers started")

        # Mainloop
        select_timeout = None
        if sys.platform == "win32":
            # Fallback to busy waiting. (select(...) blocks SIGINT on Windows.)
            select_timeout = 1.0
        max_connections: int = configuration.get("server", "max_connections")
        logger.info("Radicale server ready")
        while True:
            rlist: List[socket.socket] = []
            # Wait for finished clients
            for server in servers.values():
                rlist.extend(server.worker_sockets)
            # Accept new connections if max_connections is not reached
            if max_connections <= 0 or len(rlist) < max_connections:
                rlist.extend(servers)
            # Use socket to get notified of program shutdown
            if shutdown_socket is not None:
                rlist.append(shutdown_socket)
            rlist, _, _ = select.select(rlist, [], [], select_timeout)
            rset = set(rlist)
            if shutdown_socket in rset:
                logger.info("Stopping Radicale")
                break
            for server in servers.values():
                finished_sockets = server.worker_sockets.intersection(rset)
                for s in finished_sockets:
                    s.close()
                    server.worker_sockets.remove(s)
                    rset.remove(s)
                if finished_sockets:
                    server.service_actions()
            if rset:
                active_server = servers.get(rset.pop())
                if active_server:
                    active_server.handle_request()
    finally:
        # Wait for clients to finish and close servers
        for server in servers.values():
            for s in server.worker_sockets:
                s.recv(1)
                s.close()
            server.server_close()

1	# This file is part of Radicale - CalDAV and CardDAV server
2	# Copyright © 2008 Nicolas Kandel
3	# Copyright © 2008 Pascal Halter
4	# Copyright © 2008-2017 Guillaume Ayoub
5	# Copyright © 2017-2019 Unrud <unrud@outlook.com>
6	#
7	# This library is free software: you can redistribute it and/or modify
8	# it under the terms of the GNU General Public License as published by
9	# the Free Software Foundation, either version 3 of the License, or
10	# (at your option) any later version.
11	#
12	# This library is distributed in the hope that it will be useful,
13	# but WITHOUT ANY WARRANTY; without even the implied warranty of
14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	# GNU General Public License for more details.
16	#
17	# You should have received a copy of the GNU General Public License
18	# along with Radicale. If not, see <http://www.gnu.org/licenses/>.
19
20	"""	19✔
21	Built-in WSGI server.
22
23	"""
24
25	import errno	19✔
26	import http	19✔
27	import select	19✔
28	import socket	19✔
29	import socketserver	19✔
30	import ssl	19✔
31	import sys	19✔
32	import wsgiref.simple_server	19✔
33	from typing import (Any, Callable, Dict, List, MutableMapping, Optional, Set,	19✔
34	Tuple, Union)
35	from urllib.parse import unquote	19✔
36
37	from radicale import Application, config	19✔
38	from radicale.log import logger	19✔
39
40	COMPAT_EAI_ADDRFAMILY: int	19✔
41	if hasattr(socket, "EAI_ADDRFAMILY"):	19✔
42	COMPAT_EAI_ADDRFAMILY = socket.EAI_ADDRFAMILY # type:ignore[attr-defined]	14✔
43	elif hasattr(socket, "EAI_NONAME"):	5!
44	# Windows and BSD don't have a special error code for this
45	COMPAT_EAI_ADDRFAMILY = socket.EAI_NONAME	5✔
46	COMPAT_EAI_NODATA: int	19✔
47	if hasattr(socket, "EAI_NODATA"):	19!
48	COMPAT_EAI_NODATA = socket.EAI_NODATA	19✔
49	elif hasattr(socket, "EAI_NONAME"):	×
50	# Windows and BSD don't have a special error code for this
51	COMPAT_EAI_NODATA = socket.EAI_NONAME	×
52	COMPAT_IPPROTO_IPV6: int	19✔
53	if hasattr(socket, "IPPROTO_IPV6"):	19✔
54	COMPAT_IPPROTO_IPV6 = socket.IPPROTO_IPV6	17✔
55	elif sys.platform == "win32":	2!
56	# HACK: https://bugs.python.org/issue29515
57	COMPAT_IPPROTO_IPV6 = 41	2✔
58
59
60	# IPv4 (host, port) and IPv6 (host, port, flowinfo, scopeid)
61	ADDRESS_TYPE = Union[Tuple[str, int], Tuple[str, int, int, int]]	19✔
62
63
64	def format_address(address: ADDRESS_TYPE) -> str:	19✔
65	return "[%s]:%d" % address[:2]	19✔
66
67
68	class ParallelHTTPServer(socketserver.ThreadingMixIn,	19✔
69	wsgiref.simple_server.WSGIServer):
70
71	configuration: config.Configuration	19✔
72	worker_sockets: Set[socket.socket]	19✔
73	_timeout: float	19✔
74
75	# We wait for child threads ourself (ThreadingMixIn)
76	block_on_close: bool = False	19✔
77	daemon_threads: bool = True	19✔
78
79	def __init__(self, configuration: config.Configuration, family: int,	19✔
80	address: Tuple[str, int], RequestHandlerClass:
81	Callable[..., http.server.BaseHTTPRequestHandler]) -> None:
82	self.configuration = configuration	19✔
83	self.address_family = family	19✔
84	super().__init__(address, RequestHandlerClass)	19✔
85	self.worker_sockets = set()	19✔
86	self._timeout = configuration.get("server", "timeout")	19✔
87
88	def server_bind(self) -> None:	19✔
89	if self.address_family == socket.AF_INET6:	19✔
90	# Only allow IPv6 connections to the IPv6 socket
91	self.socket.setsockopt(COMPAT_IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)	19✔
92	super().server_bind()	19✔
93
94	def get_request( # type:ignore[override]	19✔
95	self) -> Tuple[socket.socket, Tuple[ADDRESS_TYPE, socket.socket]]:
96	# Set timeout for client
97	request: socket.socket
98	client_address: ADDRESS_TYPE
99	request, client_address = super().get_request() # type:ignore[misc]	19✔
100	if self._timeout > 0:	19!
101	request.settimeout(self._timeout)	19✔
102	worker_socket, worker_socket_out = socket.socketpair()	19✔
103	self.worker_sockets.add(worker_socket_out)	19✔
104	# HACK: Forward `worker_socket` via `client_address` return value
105	# to worker thread.
106	# The super class calls `verify_request`, `process_request` and
107	# `handle_error` with modified `client_address` value.
108	return request, (client_address, worker_socket)	19✔
109
110	def verify_request( # type:ignore[override]	19✔
111	self, request: socket.socket, client_address_and_socket:
112	Tuple[ADDRESS_TYPE, socket.socket]) -> bool:
113	return True	19✔
114
115	def process_request( # type:ignore[override]	19✔
116	self, request: socket.socket, client_address_and_socket:
117	Tuple[ADDRESS_TYPE, socket.socket]) -> None:
118	# HACK: Super class calls `finish_request` in new thread with
119	# `client_address_and_socket`
120	return super().process_request(	19✔
121	request, client_address_and_socket) # type:ignore[arg-type]
122
123	def finish_request( # type:ignore[override]	19✔
124	self, request: socket.socket, client_address_and_socket:
125	Tuple[ADDRESS_TYPE, socket.socket]) -> None:
126	# HACK: Unpack `client_address_and_socket` and call super class
127	# `finish_request` with original `client_address`
128	client_address, worker_socket = client_address_and_socket	19✔
129	try:	19✔
130	return self.finish_request_locked(request, client_address)	19✔
131	finally:
132	worker_socket.close()	19✔
133
134	def finish_request_locked(self, request: socket.socket,	19✔
135	client_address: ADDRESS_TYPE) -> None:
136	return super().finish_request(	19✔
137	request, client_address) # type:ignore[arg-type]
138
139	def handle_error( # type:ignore[override]	19✔
140	self, request: socket.socket,
141	client_address_or_client_address_and_socket:
142	Union[ADDRESS_TYPE, Tuple[ADDRESS_TYPE, socket.socket]]) -> None:
143	# HACK: This method can be called with the modified
144	# `client_address_and_socket` or the original `client_address` value
145	e = sys.exc_info()[1]	×
146	assert e is not None	×
147	if isinstance(e, socket.timeout):	×
148	logger.info("Client timed out", exc_info=True)	×
149	else:
150	logger.error("An exception occurred during request: %s",	3✔
151	sys.exc_info()[1], exc_info=True)
152
153
154	class ParallelHTTPSServer(ParallelHTTPServer):	19✔
155
156	def server_bind(self) -> None:	19✔
157	super().server_bind()	19✔
158	# Wrap the TCP socket in an SSL socket
159	certfile: str = self.configuration.get("server", "certificate")	19✔
160	keyfile: str = self.configuration.get("server", "key")	19✔
161	cafile: str = self.configuration.get("server", "certificate_authority")	19✔
162	# Test if the files can be read
163	for name, filename in [("certificate", certfile), ("key", keyfile),	19✔
164	("certificate_authority", cafile)]:
165	type_name = config.DEFAULT_CONFIG_SCHEMA["server"][name][	19✔
166	"type"].__name__
167	source = self.configuration.get_source("server", name)	19✔
168	if name == "certificate_authority" and not filename:	19✔
169	continue	19✔
170	try:	19✔
171	open(filename, "r").close()	19✔
172	except OSError as e:	×
173	raise RuntimeError(	×
174	"Invalid %s value for option %r in section %r in %s: %r "
175	"(%s)" % (type_name, name, "server", source, filename,
176	e)) from e
177	context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)	19✔
178	context.load_cert_chain(certfile=certfile, keyfile=keyfile)	19✔
179	if cafile:	19!
180	context.load_verify_locations(cafile=cafile)	×
181	context.verify_mode = ssl.CERT_REQUIRED	×
182	self.socket = context.wrap_socket(	19✔
183	self.socket, server_side=True, do_handshake_on_connect=False)
184
185	def finish_request_locked( # type:ignore[override]	19✔
186	self, request: ssl.SSLSocket, client_address: ADDRESS_TYPE
187	) -> None:
188	try:	19✔
189	try:	19✔
190	request.do_handshake()	19✔
191	except socket.timeout:	×
192	raise	×
193	except Exception as e:	×
194	raise RuntimeError("SSL handshake failed: %s" % e) from e	×
195	except Exception:	×
196	try:	×
197	self.handle_error(request, client_address)	×
198	finally:
199	self.shutdown_request(request) # type:ignore[attr-defined]	×
200	return	×
201	return super().finish_request_locked(request, client_address)	19✔
202
203
204	class ServerHandler(wsgiref.simple_server.ServerHandler):	19✔
205
206	# Don't pollute WSGI environ with OS environment
207	os_environ: MutableMapping[str, str] = {}	19✔
208
209	def log_exception(self, exc_info: "wsgiref.handlers._exc_info") -> None:	19✔
210	logger.error("An exception occurred during request: %s",	3✔
211	exc_info[1], exc_info=exc_info) # type:ignore[arg-type]
212
213
214	class RequestHandler(wsgiref.simple_server.WSGIRequestHandler):	19✔
215	"""HTTP requests handler."""
216
217	# HACK: Assigned in `socketserver.StreamRequestHandler`
218	connection: socket.socket	19✔
219
220	def log_request(self, code: Union[int, str] = "-",	19✔
221	size: Union[int, str] = "-") -> None:
222	pass # Disable request logging.	19✔
223
224	def log_error(self, format_: str, *args: Any) -> None:	19✔
225	logger.error("An error occurred during request: %s", format_ % args)	×
226
227	def get_environ(self) -> Dict[str, Any]:	19✔
228	env = super().get_environ()	19✔
229	if isinstance(self.connection, ssl.SSLSocket):	19✔
230	# The certificate can be evaluated by the auth module
231	env["REMOTE_CERTIFICATE"] = self.connection.getpeercert()	19✔
232	# Parent class only tries latin1 encoding
233	env["PATH_INFO"] = unquote(self.path.split("?", 1)[0])	19✔
234	return env	19✔
235
236	def handle(self) -> None:	19✔
237	"""Copy of WSGIRequestHandler.handle with different ServerHandler"""
238
239	self.raw_requestline = self.rfile.readline(65537)	19✔
240	if len(self.raw_requestline) > 65536:	19!
241	self.requestline = ""	×
242	self.request_version = ""	×
243	self.command = ""	×
244	self.send_error(414)	×
245	return	×
246
247	if not self.parse_request():	19!
248	return	×
249
250	handler = ServerHandler(	19✔
251	self.rfile, self.wfile, self.get_stderr(), self.get_environ()
252	)
253	handler.request_handler = self # type:ignore[attr-defined]	19✔
254	app = self.server.get_app() # type:ignore[attr-defined]	19✔
255	handler.run(app)	19✔
256
257
258	def serve(configuration: config.Configuration,	19✔
259	shutdown_socket: Optional[socket.socket] = None) -> None:
260	"""Serve radicale from configuration.
261
262	`shutdown_socket` can be used to gracefully shutdown the server.
263	The socket can be created with `socket.socketpair()`, when the other socket
264	gets closed the server stops accepting new requests by clients and the
265	function returns after all active requests are finished.
266
267	"""
268
269	logger.info("Starting Radicale")	19✔
270	# Copy configuration before modifying
271	configuration = configuration.copy()	19✔
272	configuration.update({"server": {"_internal_server": "True"}}, "server",	19✔
273	privileged=True)
274
275	use_ssl: bool = configuration.get("server", "ssl")	19✔
276	server_class = ParallelHTTPSServer if use_ssl else ParallelHTTPServer	19✔
277	application = Application(configuration)	19✔
278	servers = {}	19✔
279	try:	19✔
280	hosts: List[Tuple[str, int]] = configuration.get("server", "hosts")	19✔
281	for address in hosts:	19✔
282	# Try to bind sockets for IPv4 and IPv6
283	possible_families = (socket.AF_INET, socket.AF_INET6)	19✔
284	bind_ok = False	19✔
285	for i, family in enumerate(possible_families):	19✔
286	is_last = i == len(possible_families) - 1	19✔
287	try:	19✔
288	server = server_class(configuration, family, address,	19✔
289	RequestHandler)
290	except OSError as e:	19✔
291	# Ignore unsupported families (only one must work)
292	if ((bind_ok or not is_last) and (	19!
293	isinstance(e, socket.gaierror) and (
294	# Hostname does not exist or doesn't have
295	# address for address family
296	# macOS: IPv6 address for INET address family
297	e.errno == socket.EAI_NONAME or
298	# Address not for address family
299	e.errno == COMPAT_EAI_ADDRFAMILY or
300	e.errno == COMPAT_EAI_NODATA) or
301	# Workaround for PyPy
302	str(e) == "address family mismatched" or
303	# Address family not available (e.g. IPv6 disabled)
304	# macOS: IPv4 address for INET6 address family with
305	# IPV6_V6ONLY set
306	e.errno == errno.EADDRNOTAVAIL or
307	# Address family not supported
308	e.errno == errno.EAFNOSUPPORT or
309	# Protocol not supported
310	e.errno == errno.EPROTONOSUPPORT)):
311	continue	19✔
312	raise RuntimeError("Failed to start server %r: %s" % (	×
313	format_address(address), e)) from e
314	servers[server.socket] = server	19✔
315	bind_ok = True	19✔
316	server.set_app(application)	19✔
317	logger.info("Listening on %r%s",	19✔
318	format_address(server.server_address),
319	" with SSL" if use_ssl else "")
320	if not servers:	19!
321	raise RuntimeError("No servers started")	×
322
323	# Mainloop
324	select_timeout = None	19✔
325	if sys.platform == "win32":	19✔
326	# Fallback to busy waiting. (select(...) blocks SIGINT on Windows.)
327	select_timeout = 1.0	5✔
328	max_connections: int = configuration.get("server", "max_connections")	19✔
329	logger.info("Radicale server ready")	19✔
330	while True:	11✔
331	rlist: List[socket.socket] = []	19✔
332	# Wait for finished clients
333	for server in servers.values():	19✔
334	rlist.extend(server.worker_sockets)	19✔
335	# Accept new connections if max_connections is not reached
336	if max_connections <= 0 or len(rlist) < max_connections:	19!
337	rlist.extend(servers)	19✔
338	# Use socket to get notified of program shutdown
339	if shutdown_socket is not None:	19!
340	rlist.append(shutdown_socket)	19✔
341	rlist, _, _ = select.select(rlist, [], [], select_timeout)	19✔
342	rset = set(rlist)	19✔
343	if shutdown_socket in rset:	19✔
344	logger.info("Stopping Radicale")	19✔
345	break	19✔
346	for server in servers.values():	19✔
347	finished_sockets = server.worker_sockets.intersection(rset)	19✔
348	for s in finished_sockets:	19✔
349	s.close()	19✔
350	server.worker_sockets.remove(s)	19✔
351	rset.remove(s)	19✔
352	if finished_sockets:	19✔
353	server.service_actions()	19✔
354	if rset:	19✔
355	active_server = servers.get(rset.pop())	19✔
356	if active_server:	19!
357	active_server.handle_request()	19✔
358	finally:
359	# Wait for clients to finish and close servers
360	for server in servers.values():	19✔
361	for s in server.worker_sockets:	19!
UNCOV 362	s.recv(1)	×
UNCOV 363	s.close()	×
364	server.server_close()	19✔

Kozea / Radicale / 2196805551

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