2082780010

Build # 2082780010

Build Type

push

github

Committed by Unrud

Commit Message

Check if files exist when uploading items non-atomic

Run Details

1695 of 2058 branches covered (82.36%)

Branch coverage included in aggregate %.

10 of 13 new or added lines in 1 file covered. (76.92%)

3 existing lines in 2 files now uncovered.

3417 of 3901 relevant lines covered (87.59%)

16.12 hits per line

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

80.22

/radicale/storage/multifilesystem/upload.py

# This file is part of Radicale - CalDAV and CardDAV 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 errno
import os
import pickle
import sys
from typing import Iterable, Iterator, TextIO, cast

import radicale.item as radicale_item
from radicale import pathutils
from radicale.storage.multifilesystem.base import CollectionBase
from radicale.storage.multifilesystem.cache import CollectionPartCache
from radicale.storage.multifilesystem.get import CollectionPartGet
from radicale.storage.multifilesystem.history import CollectionPartHistory


class CollectionPartUpload(CollectionPartGet, CollectionPartCache,
                           CollectionPartHistory, CollectionBase):

    def upload(self, href: str, item: radicale_item.Item
               ) -> radicale_item.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 fo:
            f = cast(TextIO, fo)
            f.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()
        uploaded_item = self._get(href, verify_href=False)
        if uploaded_item is None:
            raise RuntimeError("Storage modified externally")
        return uploaded_item

    def _upload_all_nonatomic(self, items: Iterable[radicale_item.Item],
                              suffix: str = "") -> None:
        """Upload a new set of items non-atomic"""
        def is_safe_free_href(href: str) -> bool:
            return (pathutils.is_safe_filesystem_path_component(href) and
                    not os.path.lexists(
                        os.path.join(self._filesystem_path, href)))

        def get_safe_free_hrefs(uid: str) -> Iterator[str]:
            for href in [uid if uid.lower().endswith(suffix.lower())
                         else uid + suffix,
                         radicale_item.get_etag(uid).strip('"') + suffix]:
                if is_safe_free_href(href):
                    yield href
            yield radicale_item.find_available_uid(is_safe_free_href, suffix)

        cache_folder = os.path.join(self._filesystem_path,
                                    ".Radicale.cache", "item")
        self._storage._makedirs_synced(cache_folder)
        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
            for href in get_safe_free_hrefs(uid):
                try:
                    f = open(os.path.join(self._filesystem_path, href),
                             "w", newline="", encoding=self._encoding)
                except OSError as e:
                    if (sys.platform != "win32" and e.errno == errno.EINVAL or
                            sys.platform == "win32" and e.errno == 123):
                        # not a valid filename
                        continue
                    raise
                break
            else:
                raise RuntimeError("No href found for item %r in temporary "
                                   "collection %r" % (uid, self.path))
            with f:
                f.write(item.serialize())
                f.flush()
                self._storage._fsync(f)
            with open(os.path.join(cache_folder, href), "wb") as fb:
                pickle.dump(cache_content, fb)
                fb.flush()
                self._storage._fsync(fb)
        self._storage._sync_directory(cache_folder)
        self._storage._sync_directory(self._filesystem_path)

1	# This file is part of Radicale - CalDAV and CardDAV 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 errno	19✔
20	import os	19✔
21	import pickle	19✔
22	import sys	19✔
23	from typing import Iterable, Iterator, TextIO, cast	19✔
24
25	import radicale.item as radicale_item	19✔
26	from radicale import pathutils	19✔
27	from radicale.storage.multifilesystem.base import CollectionBase	19✔
28	from radicale.storage.multifilesystem.cache import CollectionPartCache	19✔
29	from radicale.storage.multifilesystem.get import CollectionPartGet	19✔
30	from radicale.storage.multifilesystem.history import CollectionPartHistory	19✔
31
32
33	class CollectionPartUpload(CollectionPartGet, CollectionPartCache,	19✔
34	CollectionPartHistory, CollectionBase):
35
36	def upload(self, href: str, item: radicale_item.Item	19✔
37	) -> radicale_item.Item:
38	if not pathutils.is_safe_filesystem_path_component(href):	19!
39	raise pathutils.UnsafePathError(href)	×
40	try:	19✔
41	self._store_item_cache(href, item)	19✔
42	except Exception as e:	×
43	raise ValueError("Failed to store item %r in collection %r: %s" %	×
44	(href, self.path, e)) from e
45	path = pathutils.path_to_filesystem(self._filesystem_path, href)	19✔
46	with self._atomic_write(path, newline="") as fo:	19✔
47	f = cast(TextIO, fo)	19✔
48	f.write(item.serialize())	19✔
49	# Clean the cache after the actual item is stored, or the cache entry
50	# will be removed again.
51	self._clean_item_cache()	19✔
52	# Track the change
53	self._update_history_etag(href, item)	19✔
54	self._clean_history()	19✔
55	uploaded_item = self._get(href, verify_href=False)	19✔
56	if uploaded_item is None:	19!
57	raise RuntimeError("Storage modified externally")	×
58	return uploaded_item	19✔
59
60	def _upload_all_nonatomic(self, items: Iterable[radicale_item.Item],	19✔
61	suffix: str = "") -> None:
62	"""Upload a new set of items non-atomic"""
63	def is_safe_free_href(href: str) -> bool:	19✔
64	return (pathutils.is_safe_filesystem_path_component(href) and	19✔
65	not os.path.lexists(
66	os.path.join(self._filesystem_path, href)))
67
68	def get_safe_free_hrefs(uid: str) -> Iterator[str]:	19✔
69	for href in [uid if uid.lower().endswith(suffix.lower())	19!
70	else uid + suffix,
71	radicale_item.get_etag(uid).strip('"') + suffix]:
72	if is_safe_free_href(href):	19✔
73	yield href	19✔
NEW 74	yield radicale_item.find_available_uid(is_safe_free_href, suffix)	×
75
76	cache_folder = os.path.join(self._filesystem_path,	19✔
77	".Radicale.cache", "item")
78	self._storage._makedirs_synced(cache_folder)	19✔
79	for item in items:	19✔
80	uid = item.uid	19✔
81	try:	19✔
82	cache_content = self._item_cache_content(item)	19✔
83	except Exception as e:	×
84	raise ValueError(	×
85	"Failed to store item %r in temporary collection %r: %s" %
86	(uid, self.path, e)) from e
87	for href in get_safe_free_hrefs(uid):	19!
88	try:	19✔
89	f = open(os.path.join(self._filesystem_path, href),	19✔
90	"w", newline="", encoding=self._encoding)
91	except OSError as e:	×
NEW 92	if (sys.platform != "win32" and e.errno == errno.EINVAL or	×
93	sys.platform == "win32" and e.errno == 123):
94	# not a valid filename
95	continue	×
96	raise	×
97	break	19✔
98	else:
NEW 99	raise RuntimeError("No href found for item %r in temporary "	×
100	"collection %r" % (uid, self.path))
101	with f:	19✔
102	f.write(item.serialize())	19✔
103	f.flush()	19✔
104	self._storage._fsync(f)	19✔
105	with open(os.path.join(cache_folder, href), "wb") as fb:	19✔
106	pickle.dump(cache_content, fb)	19✔
107	fb.flush()	19✔
108	self._storage._fsync(fb)	19✔
109	self._storage._sync_directory(cache_folder)	19✔
110	self._storage._sync_directory(self._filesystem_path)	19✔

Kozea / Radicale / 2082780010

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