229931441

Build Type

push

github

Committed by Unrud

Commit Message

Kill remaining child processes of hook

Run Details

1195 of 1546 branches covered (77.3%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 1 file covered. (85.71%)

5 existing lines in 1 file now uncovered.

2885 of 3432 relevant lines covered (84.06%)

15.11 hits per line

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

75.61

/radicale/storage/multifilesystem/lock.py

# This file is part of Radicale Server - Calendar Server
# Copyright © 2014 Jean-Marc Martins
# Copyright © 2012-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/>.

import contextlib
import logging
import os
import shlex
import signal
import subprocess

from radicale import pathutils
from radicale.log import logger


class CollectionLockMixin:
    def _acquire_cache_lock(self, ns=""):
        if self._storage._lock.locked == "w":
            return contextlib.ExitStack()
        cache_folder = os.path.join(self._filesystem_path, ".Radicale.cache")
        self._storage._makedirs_synced(cache_folder)
        lock_path = os.path.join(cache_folder,
                                 ".Radicale.lock" + (".%s" % ns if ns else ""))
        lock = pathutils.RwLock(lock_path)
        return lock.acquire("w")


class StorageLockMixin:

    def __init__(self, configuration):
        super().__init__(configuration)
        folder = self.configuration.get("storage", "filesystem_folder")
        lock_path = os.path.join(folder, ".Radicale.lock")
        self._lock = pathutils.RwLock(lock_path)

    @contextlib.contextmanager
    def acquire_lock(self, mode, user=None):
        with self._lock.acquire(mode) as lock_file:
            yield
            # execute hook
            hook = self.configuration.get("storage", "hook")
            if mode == "w" and hook:
                folder = self.configuration.get("storage", "filesystem_folder")
                debug = logger.isEnabledFor(logging.DEBUG)
                popen_kwargs = dict(
                    stdin=subprocess.DEVNULL,
                    stdout=subprocess.PIPE if debug else subprocess.DEVNULL,
                    stderr=subprocess.PIPE if debug else subprocess.DEVNULL,
                    shell=True, universal_newlines=True, cwd=folder)
                if os.name == "posix":
                    # Pass the lock_file to the subprocess to ensure the lock
                    # doesn't get released if this process is killed but the
                    # child process lives on
                    popen_kwargs["pass_fds"] = [lock_file.fileno()]
                # Use new process group for child to prevent terminals
                # from sending SIGINT etc. to it.
                if os.name == "posix":
                    # Process group is also used to identify child processes
                    popen_kwargs["preexec_fn"] = os.setpgrp
                elif os.name == "nt":
                    popen_kwargs["creationflags"] = (
                        subprocess.CREATE_NEW_PROCESS_GROUP)
                command = hook % {"user": shlex.quote(user or "Anonymous")}
                logger.debug("Running hook")
                p = subprocess.Popen(command, **popen_kwargs)
                try:
                    stdout_data, stderr_data = p.communicate()
                except BaseException:
                    # Terminate the process on error (e.g. KeyboardInterrupt)
                    p.terminate()
                    p.wait()
                    raise
                finally:
                    if os.name == "posix":
                        # Try to kill remaning children of process, identified
                        # by process group
                        try:
                            os.killpg(p.pid, signal.SIGKILL)
                        except ProcessLookupError:
                            pass  # No remaning processes found
                        else:
                            logger.warning(
                                "Killed remaining child processes of hook")
                if stdout_data:
                    logger.debug("Captured stdout hook:\n%s", stdout_data)
                if stderr_data:
                    logger.debug("Captured stderr hook:\n%s", stderr_data)
                if p.returncode != 0:
                    raise subprocess.CalledProcessError(p.returncode, p.args)

1	# This file is part of Radicale Server - Calendar Server
2	# Copyright © 2014 Jean-Marc Martins
3	# Copyright © 2012-2017 Guillaume Ayoub
4	# Copyright © 2017-2019 Unrud <unrud@outlook.com>
5	#
6	# This library is free software: you can redistribute it and/or modify
7	# it under the terms of the GNU General Public License as published by
8	# the Free Software Foundation, either version 3 of the License, or
9	# (at your option) any later version.
10	#
11	# This library is distributed in the hope that it will be useful,
12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	# GNU General Public License for more details.
15	#
16	# You should have received a copy of the GNU General Public License
17	# along with Radicale. If not, see <http://www.gnu.org/licenses/>.
18
19	import contextlib	18✔
20	import logging	18✔
21	import os	18✔
22	import shlex	18✔
23	import signal	18✔
24	import subprocess	18✔
25
26	from radicale import pathutils	18✔
27	from radicale.log import logger	18✔
28
29
30	class CollectionLockMixin:	18✔
31	def _acquire_cache_lock(self, ns=""):	18✔
32	if self._storage._lock.locked == "w":	18!
33	return contextlib.ExitStack()	×
34	cache_folder = os.path.join(self._filesystem_path, ".Radicale.cache")	18✔
35	self._storage._makedirs_synced(cache_folder)	18✔
36	lock_path = os.path.join(cache_folder,	18✔
37	".Radicale.lock" + (".%s" % ns if ns else ""))
38	lock = pathutils.RwLock(lock_path)	18✔
39	return lock.acquire("w")	18✔
40
41
42	class StorageLockMixin:	18✔
43
44	def __init__(self, configuration):	18✔
45	super().__init__(configuration)	18✔
46	folder = self.configuration.get("storage", "filesystem_folder")	18✔
47	lock_path = os.path.join(folder, ".Radicale.lock")	18✔
48	self._lock = pathutils.RwLock(lock_path)	18✔
49
50	@contextlib.contextmanager	18✔
51	def acquire_lock(self, mode, user=None):	18✔
52	with self._lock.acquire(mode) as lock_file:	18✔
53	yield	18✔
54	# execute hook
55	hook = self.configuration.get("storage", "hook")	18✔
56	if mode == "w" and hook:	18✔
57	folder = self.configuration.get("storage", "filesystem_folder")	18✔
58	debug = logger.isEnabledFor(logging.DEBUG)	18✔
59	popen_kwargs = dict(	18✔
60	stdin=subprocess.DEVNULL,
61	stdout=subprocess.PIPE if debug else subprocess.DEVNULL,
62	stderr=subprocess.PIPE if debug else subprocess.DEVNULL,
63	shell=True, universal_newlines=True, cwd=folder)
64	if os.name == "posix":	18!
65	# Pass the lock_file to the subprocess to ensure the lock
66	# doesn't get released if this process is killed but the
67	# child process lives on
68	popen_kwargs["pass_fds"] = [lock_file.fileno()]	18✔
69	# Use new process group for child to prevent terminals
70	# from sending SIGINT etc. to it.
71	if os.name == "posix":	18!
72	# Process group is also used to identify child processes
73	popen_kwargs["preexec_fn"] = os.setpgrp	18✔
UNCOV 74	elif os.name == "nt":	×
75	popen_kwargs["creationflags"] = (	×
76	subprocess.CREATE_NEW_PROCESS_GROUP)
77	command = hook % {"user": shlex.quote(user or "Anonymous")}	18✔
78	logger.debug("Running hook")	18✔
79	p = subprocess.Popen(command, **popen_kwargs)	18✔
80	try:	18✔
81	stdout_data, stderr_data = p.communicate()	18✔
82	except BaseException:	×
83	# Terminate the process on error (e.g. KeyboardInterrupt)
UNCOV 84	p.terminate()	×
UNCOV 85	p.wait()	×
UNCOV 86	raise	×
87	finally:
88	if os.name == "posix":	18!
89	# Try to kill remaning children of process, identified
90	# by process group
91	try:	18✔
92	os.killpg(p.pid, signal.SIGKILL)	18✔
93	except ProcessLookupError:	18✔
94	pass # No remaning processes found	18!
95	else:
NEW 96	logger.warning(	×
97	"Killed remaining child processes of hook")
98	if stdout_data:	18!
UNCOV 99	logger.debug("Captured stdout hook:\n%s", stdout_data)	×
100	if stderr_data:	18✔
101	logger.debug("Captured stderr hook:\n%s", stderr_data)	18✔
102	if p.returncode != 0:	18✔
103	raise subprocess.CalledProcessError(p.returncode, p.args)	18✔

Kozea / Radicale / 229931441

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