630d49b7cfd04b0e3f963adb838b87563cf040d0

Build # 630d49b7cfd04b0e3f963adb838b87563cf040d0

Build Type

push

github-actions

Committed by Unrud

Commit Message

Fix file permissions in storage folder

Run Details

1180 of 1529 branches covered (77.17%)

Branch coverage included in aggregate %.

9 of 9 new or added lines in 1 file covered. (100.0%)

39 existing lines in 3 files now uncovered.

2856 of 3409 relevant lines covered (83.78%)

12.56 hits per line

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

72.5

/radicale/storage/multifilesystem/upload.py

# This file is part of Radicale Server - Calendar Server
# Copyright © 2014 Jean-Marc Martins
# Copyright © 2012-2017 Guillaume Ayoub
# Copyright © 2017-2018 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 os
import pickle

from radicale import item as radicale_item
from radicale import pathutils


class CollectionUploadMixin:
    def upload(self, href, item):
        if not pathutils.is_safe_filesystem_path_component(href):
            raise pathutils.UnsafePathError(href)
        try:
            self._store_item_cache(href, item)
        except Exception as e:
            raise ValueError("Failed to store item %r in collection %r: %s" %
                             (href, self.path, e)) from e
        path = pathutils.path_to_filesystem(self._filesystem_path, href)
        with self._atomic_write(path, newline="") as fd:
            fd.write(item.serialize())
        # Clean the cache after the actual item is stored, or the cache entry
        # will be removed again.
        self._clean_item_cache()
        # Track the change
        self._update_history_etag(href, item)
        self._clean_history()
        return self._get(href, verify_href=False)

    def _upload_all_nonatomic(self, items, suffix=""):
        """Upload a new set of items.

        This takes a list of vobject items and
        uploads them nonatomic and without existence checks.

        """
        cache_folder = os.path.join(self._filesystem_path,
                                    ".Radicale.cache", "item")
        self._storage._makedirs_synced(cache_folder)
        hrefs = set()
        for item in items:
            uid = item.uid
            try:
                cache_content = self._item_cache_content(item)
            except Exception as e:
                raise ValueError(
                    "Failed to store item %r in temporary collection %r: %s" %
                    (uid, self.path, e)) from e
            href_candidate_funtions = []
            if os.name in ("nt", "posix"):
                href_candidate_funtions.append(
                    lambda: uid if uid.lower().endswith(suffix.lower())
                    else uid + suffix)
            href_candidate_funtions.extend((
                lambda: radicale_item.get_etag(uid).strip('"') + suffix,
                lambda: radicale_item.find_available_uid(hrefs.__contains__,
                                                         suffix)))
            href = f = None
            while href_candidate_funtions:
                href = href_candidate_funtions.pop(0)()
                if href in hrefs:
                    continue
                if not pathutils.is_safe_filesystem_path_component(href):
                    if not href_candidate_funtions:
                        raise pathutils.UnsafePathError(href)
                    continue
                try:
                    f = open(pathutils.path_to_filesystem(
                        self._filesystem_path, href),
                        "w", newline="", encoding=self._encoding)
                    break
                except OSError as e:
                    if href_candidate_funtions and (
                            os.name == "posix" and e.errno == 22 or
                            os.name == "nt" and e.errno == 123):
                        continue
                    raise
            with f:
                f.write(item.serialize())
                f.flush()
                self._storage._fsync(f)
            hrefs.add(href)
            with open(os.path.join(cache_folder, href), "wb") as f:
                pickle.dump(cache_content, f)
                f.flush()
                self._storage._fsync(f)
        self._storage._sync_directory(cache_folder)
        self._storage._sync_directory(self._filesystem_path)

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-2018 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 os	15✔
20	import pickle	15✔
21
22	from radicale import item as radicale_item	15✔
23	from radicale import pathutils	15✔
24
25
26	class CollectionUploadMixin:	15✔
27	def upload(self, href, item):	15✔
28	if not pathutils.is_safe_filesystem_path_component(href):	15!
29	raise pathutils.UnsafePathError(href)	×
30	try:	15✔
31	self._store_item_cache(href, item)	15✔
32	except Exception as e:	×
33	raise ValueError("Failed to store item %r in collection %r: %s" %	×
34	(href, self.path, e)) from e
35	path = pathutils.path_to_filesystem(self._filesystem_path, href)	15✔
36	with self._atomic_write(path, newline="") as fd:	15✔
37	fd.write(item.serialize())	15✔
38	# Clean the cache after the actual item is stored, or the cache entry
39	# will be removed again.
40	self._clean_item_cache()	15✔
41	# Track the change
42	self._update_history_etag(href, item)	15✔
43	self._clean_history()	15✔
44	return self._get(href, verify_href=False)	15✔
45
46	def _upload_all_nonatomic(self, items, suffix=""):	15✔
47	"""Upload a new set of items.
48
49	This takes a list of vobject items and
50	uploads them nonatomic and without existence checks.
51
52	"""
53	cache_folder = os.path.join(self._filesystem_path,	15✔
54	".Radicale.cache", "item")
55	self._storage._makedirs_synced(cache_folder)	15✔
56	hrefs = set()	15✔
57	for item in items:	15✔
58	uid = item.uid	15✔
59	try:	15✔
60	cache_content = self._item_cache_content(item)	15✔
61	except Exception as e:	×
62	raise ValueError(	×
63	"Failed to store item %r in temporary collection %r: %s" %
64	(uid, self.path, e)) from e
65	href_candidate_funtions = []	15✔
66	if os.name in ("nt", "posix"):	15!
67	href_candidate_funtions.append(	15✔
68	lambda: uid if uid.lower().endswith(suffix.lower())
69	else uid + suffix)
70	href_candidate_funtions.extend((	15!
71	lambda: radicale_item.get_etag(uid).strip('"') + suffix,
72	lambda: radicale_item.find_available_uid(hrefs.__contains__,
73	suffix)))
74	href = f = None	15✔
75	while href_candidate_funtions:	15!
76	href = href_candidate_funtions.pop(0)()	15✔
77	if href in hrefs:	15!
UNCOV 78	continue	×
79	if not pathutils.is_safe_filesystem_path_component(href):	15!
UNCOV 80	if not href_candidate_funtions:	×
UNCOV 81	raise pathutils.UnsafePathError(href)	×
82	continue	×
83	try:	15✔
84	f = open(pathutils.path_to_filesystem(	15✔
85	self._filesystem_path, href),
86	"w", newline="", encoding=self._encoding)
87	break	15✔
UNCOV 88	except OSError as e:	×
UNCOV 89	if href_candidate_funtions and (	×
90	os.name == "posix" and e.errno == 22 or
91	os.name == "nt" and e.errno == 123):
UNCOV 92	continue	×
UNCOV 93	raise	×
94	with f:	15✔
95	f.write(item.serialize())	15✔
96	f.flush()	15✔
97	self._storage._fsync(f)	15✔
98	hrefs.add(href)	15✔
99	with open(os.path.join(cache_folder, href), "wb") as f:	15✔
100	pickle.dump(cache_content, f)	15✔
101	f.flush()	15✔
102	self._storage._fsync(f)	15✔
103	self._storage._sync_directory(cache_folder)	15✔
104	self._storage._sync_directory(self._filesystem_path)	15✔

Kozea / Radicale / 630d49b7cfd04b0e3f963adb838b87563cf040d0

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