diff --git a/swh/objstorage/backends/pathslicing.py b/swh/objstorage/backends/pathslicing.py index 151944f..12fb14d 100644 --- a/swh/objstorage/backends/pathslicing.py +++ b/swh/objstorage/backends/pathslicing.py @@ -1,394 +1,429 @@ # Copyright (C) 2015-2019 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information from collections.abc import Iterator from contextlib import contextmanager from itertools import islice import os import random import tempfile +from typing import List from swh.model import hashutil from swh.objstorage.exc import Error, ObjNotFoundError from swh.objstorage.objstorage import ( DEFAULT_CHUNK_SIZE, DEFAULT_LIMIT, ID_HASH_ALGO, ID_HASH_LENGTH, ObjStorage, compressors, compute_hash, decompressors, ) BUFSIZ = 1048576 DIR_MODE = 0o755 FILE_MODE = 0o644 -@contextmanager -def _write_obj_file(hex_obj_id, objstorage): - """ Context manager for writing object files to the object storage. +class PathSlicer: + """Helper class to compute a path based on a hash. - During writing, data are written to a temporary file, which is atomically - renamed to the right file name after closing. + Used to compute a directory path based on the object hash according to a + given slicing. Each slicing correspond to a directory that is named + according to the hash of its content. + + For instance a file with SHA1 34973274ccef6ab4dfaaf86599792fa9c3fe4689 + will have the following computed path: - Usage sample: - with _write_obj_file(hex_obj_id, objstorage): - f.write(obj_data) + - 0:2/2:4/4:6 : 34/97/32/34973274ccef6ab4dfaaf86599792fa9c3fe4689 + - 0:1/0:5/ : 3/34973/34973274ccef6ab4dfaaf86599792fa9c3fe4689 - Yields: - a file-like object open for writing bytes. + Args: + root (str): path to the root directory of the storage on the disk. + slicing (str): the slicing configuration. """ - # Get the final paths and create the directory if absent. - dir = objstorage._obj_dir(hex_obj_id) - if not os.path.isdir(dir): - os.makedirs(dir, DIR_MODE, exist_ok=True) - path = os.path.join(dir, hex_obj_id) - # Create a temporary file. - (tmp, tmp_path) = tempfile.mkstemp(suffix=".tmp", prefix="hex_obj_id.", dir=dir) + def __init__(self, root: str, slicing: str): + self.root = root + # Make a list of tuples where each tuple contains the beginning + # and the end of each slicing. + try: + self.bounds = [ + slice(*(int(x) if x else None for x in sbounds.split(":"))) + for sbounds in slicing.split("/") + if sbounds + ] + except TypeError: + raise ValueError( + "Invalid slicing declaration; " + "it should be a of the form ':[/:]..." + ) + + def check_config(self): + """Check the slicing configuration is valid. + + Raises: + ValueError: if the slicing configuration is invalid. + """ + if len(self): + max_char = max( + max(bound.start or 0, bound.stop or 0) for bound in self.bounds + ) + if ID_HASH_LENGTH < max_char: + raise ValueError( + "Algorithm %s has too short hash for slicing to char %d" + % (ID_HASH_ALGO, max_char) + ) + + def get_directory(self, hex_obj_id: str) -> str: + """ Compute the storage directory of an object. - # Open the file and yield it for writing. - tmp_f = os.fdopen(tmp, "wb") - yield tmp_f + See also: PathSlicer::get_path - # Make sure the contents of the temporary file are written to disk - tmp_f.flush() - if objstorage.use_fdatasync: - os.fdatasync(tmp) - else: - os.fsync(tmp) + Args: + hex_obj_id: object id as hexlified string. - # Then close the temporary file and move it to the right path. - tmp_f.close() - os.chmod(tmp_path, FILE_MODE) - os.rename(tmp_path, path) + Returns: + Absolute path (including root) to the directory that contains + the given object id. + """ + return os.path.join(self.root, *self.get_slices(hex_obj_id)) + def get_path(self, hex_obj_id: str) -> str: + """ Compute the full path to an object into the current storage. -def _read_obj_file(hex_obj_id, objstorage): - """ Context manager for reading object file in the object storage. + See also: PathSlicer::get_directory - Usage sample: - with _read_obj_file(hex_obj_id, objstorage) as f: - b = f.read() + Args: + hex_obj_id(str): object id as hexlified string. - Yields: - a file-like object open for reading bytes. - """ - path = objstorage._obj_path(hex_obj_id) + Returns: + Absolute path (including root) to the object corresponding + to the given object id. + """ + return os.path.join(self.get_directory(hex_obj_id), hex_obj_id) + + def get_slices(self, hex_obj_id: str) -> List[str]: + """Compute the path elements for the given hash. + + Args: + hex_obj_id(str): object id as hexlified string. + + Returns: + Relative path to the actual object corresponding to the given id as + a list. + """ + + assert len(hex_obj_id) == ID_HASH_LENGTH + return [hex_obj_id[bound] for bound in self.bounds] - return open(path, "rb") + def __len__(self) -> int: + """Number of slices of the slicer""" + return len(self.bounds) class PathSlicingObjStorage(ObjStorage): """Implementation of the ObjStorage API based on the hash of the content. On disk, an object storage is a directory tree containing files named after their object IDs. An object ID is a checksum of its content, depending on the value of the ID_HASH_ALGO constant (see swh.model.hashutil for its meaning). To avoid directories that contain too many files, the object storage has a given slicing. Each slicing correspond to a directory that is named according to the hash of its content. So for instance a file with SHA1 34973274ccef6ab4dfaaf86599792fa9c3fe4689 will be stored in the given object storages : - 0:2/2:4/4:6 : 34/97/32/34973274ccef6ab4dfaaf86599792fa9c3fe4689 - 0:1/0:5/ : 3/34973/34973274ccef6ab4dfaaf86599792fa9c3fe4689 The files in the storage are stored in gzipped compressed format. - Attributes: - root (string): path to the root directory of the storage on the disk. - bounds: list of tuples that indicates the beginning and the end of - each subdirectory for a content. + Args: + root (str): path to the root directory of the storage on + the disk. + slicing (str): string that indicates the slicing to perform + on the hash of the content to know the path where it should + be stored (see the documentation of the PathSlicer class). """ def __init__(self, root, slicing, compression="gzip", **kwargs): - """ Create an object to access a hash-slicing based object storage. - - Args: - root (string): path to the root directory of the storage on - the disk. - slicing (string): string that indicates the slicing to perform - on the hash of the content to know the path where it should - be stored. - """ super().__init__(**kwargs) self.root = root - # Make a list of tuples where each tuple contains the beginning - # and the end of each slicing. - self.bounds = [ - slice(*map(int, sbounds.split(":"))) - for sbounds in slicing.split("/") - if sbounds - ] + self.slicer = PathSlicer(root, slicing) self.use_fdatasync = hasattr(os, "fdatasync") self.compression = compression self.check_config(check_write=False) def check_config(self, *, check_write): """Check whether this object storage is properly configured""" - root = self.root + self.slicer.check_config() - if not os.path.isdir(root): + if not os.path.isdir(self.root): raise ValueError( - 'PathSlicingObjStorage root "%s" is not a directory' % root - ) - - max_endchar = max(map(lambda bound: bound.stop, self.bounds)) - if ID_HASH_LENGTH < max_endchar: - raise ValueError( - "Algorithm %s has too short hash for slicing to char %d" - % (ID_HASH_ALGO, max_endchar) + 'PathSlicingObjStorage root "%s" is not a directory' % self.root ) if check_write: if not os.access(self.root, os.W_OK): raise PermissionError( - 'PathSlicingObjStorage root "%s" is not writable' % root + 'PathSlicingObjStorage root "%s" is not writable' % self.root ) if self.compression not in compressors: raise ValueError( 'Unknown compression algorithm "%s" for ' "PathSlicingObjStorage" % self.compression ) return True def __contains__(self, obj_id): hex_obj_id = hashutil.hash_to_hex(obj_id) - return os.path.isfile(self._obj_path(hex_obj_id)) + return os.path.isfile(self.slicer.get_path(hex_obj_id)) def __iter__(self): """Iterate over the object identifiers currently available in the storage. Warning: with the current implementation of the object storage, this method will walk the filesystem to list objects, meaning that listing all objects will be very slow for large storages. You almost certainly don't want to use this method in production. Return: Iterator over object IDs """ def obj_iterator(): # XXX hackish: it does not verify that the depth of found files # matches the slicing depth of the storage for root, _dirs, files in os.walk(self.root): _dirs.sort() for f in sorted(files): yield bytes.fromhex(f) return obj_iterator() def __len__(self): """Compute the number of objects available in the storage. Warning: this currently uses `__iter__`, its warning about bad performances applies Return: number of objects contained in the storage """ return sum(1 for i in self) - def _obj_dir(self, hex_obj_id): - """ Compute the storage directory of an object. - - See also: PathSlicingObjStorage::_obj_path - - Args: - hex_obj_id: object id as hexlified string. - - Returns: - Path to the directory that contains the required object. - """ - slices = [hex_obj_id[bound] for bound in self.bounds] - return os.path.join(self.root, *slices) - - def _obj_path(self, hex_obj_id): - """ Compute the full path to an object into the current storage. - - See also: PathSlicingObjStorage::_obj_dir - - Args: - hex_obj_id: object id as hexlified string. - - Returns: - Path to the actual object corresponding to the given id. - """ - return os.path.join(self._obj_dir(hex_obj_id), hex_obj_id) - def add(self, content, obj_id=None, check_presence=True): if obj_id is None: obj_id = compute_hash(content) if check_presence and obj_id in self: # If the object is already present, return immediately. return obj_id hex_obj_id = hashutil.hash_to_hex(obj_id) if not isinstance(content, Iterator): content = [content] compressor = compressors[self.compression]() - with _write_obj_file(hex_obj_id, self) as f: + with self._write_obj_file(hex_obj_id) as f: for chunk in content: f.write(compressor.compress(chunk)) f.write(compressor.flush()) return obj_id def get(self, obj_id): if obj_id not in self: raise ObjNotFoundError(obj_id) # Open the file and return its content as bytes hex_obj_id = hashutil.hash_to_hex(obj_id) d = decompressors[self.compression]() - with _read_obj_file(hex_obj_id, self) as f: + with open(self.slicer.get_path(hex_obj_id), "rb") as f: out = d.decompress(f.read()) if d.unused_data: raise Error("Corrupt object %s: trailing data found" % hex_obj_id,) return out def check(self, obj_id): try: data = self.get(obj_id) except OSError: hex_obj_id = hashutil.hash_to_hex(obj_id) raise Error("Corrupt object %s: not a proper compressed file" % hex_obj_id,) checksums = hashutil.MultiHash.from_data( data, hash_names=[ID_HASH_ALGO] ).digest() actual_obj_id = checksums[ID_HASH_ALGO] hex_obj_id = hashutil.hash_to_hex(obj_id) if hex_obj_id != hashutil.hash_to_hex(actual_obj_id): raise Error( "Corrupt object %s should have id %s" % (hashutil.hash_to_hex(obj_id), hashutil.hash_to_hex(actual_obj_id)) ) def delete(self, obj_id): super().delete(obj_id) # Check delete permission if obj_id not in self: raise ObjNotFoundError(obj_id) hex_obj_id = hashutil.hash_to_hex(obj_id) try: - os.remove(self._obj_path(hex_obj_id)) + os.remove(self.slicer.get_path(hex_obj_id)) except FileNotFoundError: raise ObjNotFoundError(obj_id) return True # Management methods def get_random(self, batch_size): def get_random_content(self, batch_size): """ Get a batch of content inside a single directory. Returns: a tuple (batch size, batch). """ dirs = [] - for level in range(len(self.bounds)): + for level in range(len(self.slicer)): path = os.path.join(self.root, *dirs) dir_list = next(os.walk(path))[1] if "tmp" in dir_list: dir_list.remove("tmp") dirs.append(random.choice(dir_list)) path = os.path.join(self.root, *dirs) content_list = next(os.walk(path))[2] length = min(batch_size, len(content_list)) return ( length, map(hashutil.hash_to_bytes, random.sample(content_list, length)), ) while batch_size: length, it = get_random_content(self, batch_size) batch_size = batch_size - length yield from it # Streaming methods @contextmanager def chunk_writer(self, obj_id): hex_obj_id = hashutil.hash_to_hex(obj_id) compressor = compressors[self.compression]() - with _write_obj_file(hex_obj_id, self) as f: + with self._write_obj_file(hex_obj_id) as f: yield lambda c: f.write(compressor.compress(c)) f.write(compressor.flush()) def add_stream(self, content_iter, obj_id, check_presence=True): if check_presence and obj_id in self: return obj_id with self.chunk_writer(obj_id) as writer: for chunk in content_iter: writer(chunk) return obj_id def get_stream(self, obj_id, chunk_size=DEFAULT_CHUNK_SIZE): if obj_id not in self: raise ObjNotFoundError(obj_id) hex_obj_id = hashutil.hash_to_hex(obj_id) decompressor = decompressors[self.compression]() - with _read_obj_file(hex_obj_id, self) as f: + with open(self.slicer.get_path(hex_obj_id), "rb") as f: while True: raw = f.read(chunk_size) if not raw: break r = decompressor.decompress(raw) if not r: continue yield r def list_content(self, last_obj_id=None, limit=DEFAULT_LIMIT): if last_obj_id: it = self.iter_from(last_obj_id) else: it = iter(self) return islice(it, limit) def iter_from(self, obj_id, n_leaf=False): hex_obj_id = hashutil.hash_to_hex(obj_id) - slices = [hex_obj_id[bound] for bound in self.bounds] + slices = self.slicer.get_slices(hex_obj_id) rlen = len(self.root.split("/")) i = 0 for root, dirs, files in os.walk(self.root): if not dirs: i += 1 level = len(root.split("/")) - rlen dirs.sort() if dirs and root == os.path.join(self.root, *slices[:level]): cslice = slices[level] for d in dirs[:]: if d < cslice: dirs.remove(d) for f in sorted(files): if f > hex_obj_id: yield bytes.fromhex(f) if n_leaf: yield i + + @contextmanager + def _write_obj_file(self, hex_obj_id): + """ Context manager for writing object files to the object storage. + + During writing, data are written to a temporary file, which is atomically + renamed to the right file name after closing. + + Usage sample: + with objstorage._write_obj_file(hex_obj_id): + f.write(obj_data) + + Yields: + a file-like object open for writing bytes. + """ + # Get the final paths and create the directory if absent. + dir = self.slicer.get_directory(hex_obj_id) + if not os.path.isdir(dir): + os.makedirs(dir, DIR_MODE, exist_ok=True) + path = os.path.join(dir, hex_obj_id) + + # Create a temporary file. + (tmp, tmp_path) = tempfile.mkstemp(suffix=".tmp", prefix="hex_obj_id.", dir=dir) + + # Open the file and yield it for writing. + tmp_f = os.fdopen(tmp, "wb") + yield tmp_f + + # Make sure the contents of the temporary file are written to disk + tmp_f.flush() + if self.use_fdatasync: + os.fdatasync(tmp) + else: + os.fsync(tmp) + + # Then close the temporary file and move it to the right path. + tmp_f.close() + os.chmod(tmp_path, FILE_MODE) + os.rename(tmp_path, path) diff --git a/swh/objstorage/tests/test_objstorage_pathslicing.py b/swh/objstorage/tests/test_objstorage_pathslicing.py index 47cc0e8..72ac0f1 100644 --- a/swh/objstorage/tests/test_objstorage_pathslicing.py +++ b/swh/objstorage/tests/test_objstorage_pathslicing.py @@ -1,163 +1,163 @@ # Copyright (C) 2015-2020 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information import shutil import tempfile import unittest from unittest.mock import DEFAULT, patch from swh.model import hashutil from swh.objstorage import exc from swh.objstorage.factory import get_objstorage from swh.objstorage.objstorage import ID_HASH_LENGTH from .objstorage_testing import ObjStorageTestFixture class TestPathSlicingObjStorage(ObjStorageTestFixture, unittest.TestCase): compression = "none" def setUp(self): super().setUp() self.slicing = "0:2/2:4/4:6" self.tmpdir = tempfile.mkdtemp() self.storage = get_objstorage( "pathslicing", { "root": self.tmpdir, "slicing": self.slicing, "compression": self.compression, }, ) def tearDown(self): super().tearDown() shutil.rmtree(self.tmpdir) def content_path(self, obj_id): hex_obj_id = hashutil.hash_to_hex(obj_id) - return self.storage._obj_path(hex_obj_id) + return self.storage.slicer.get_path(hex_obj_id) def test_iter(self): content, obj_id = self.hash_content(b"iter") self.assertEqual(list(iter(self.storage)), []) self.storage.add(content, obj_id=obj_id) self.assertEqual(list(iter(self.storage)), [obj_id]) def test_len(self): content, obj_id = self.hash_content(b"len") self.assertEqual(len(self.storage), 0) self.storage.add(content, obj_id=obj_id) self.assertEqual(len(self.storage), 1) def test_check_ok(self): content, obj_id = self.hash_content(b"check_ok") self.storage.add(content, obj_id=obj_id) assert self.storage.check(obj_id) is None assert self.storage.check(obj_id.hex()) is None def test_check_id_mismatch(self): content, obj_id = self.hash_content(b"check_id_mismatch") self.storage.add(b"unexpected content", obj_id=obj_id) with self.assertRaises(exc.Error) as error: self.storage.check(obj_id) self.assertEqual( ( "Corrupt object %s should have id " "12ebb2d6c81395bcc5cab965bdff640110cb67ff" % obj_id.hex(), ), error.exception.args, ) def test_get_random_contents(self): content, obj_id = self.hash_content(b"get_random_content") self.storage.add(content, obj_id=obj_id) random_contents = list(self.storage.get_random(1)) self.assertEqual(1, len(random_contents)) self.assertIn(obj_id, random_contents) def test_iterate_from(self): all_ids = [] for i in range(100): content, obj_id = self.hash_content(b"content %d" % i) self.storage.add(content, obj_id=obj_id) all_ids.append(obj_id) all_ids.sort() ids = list(self.storage.iter_from(b"\x00" * (ID_HASH_LENGTH // 2))) self.assertEqual(len(ids), len(all_ids)) self.assertEqual(ids, all_ids) ids = list(self.storage.iter_from(all_ids[0])) self.assertEqual(len(ids), len(all_ids) - 1) self.assertEqual(ids, all_ids[1:]) ids = list(self.storage.iter_from(all_ids[-1], n_leaf=True)) n_leaf = ids[-1] ids = ids[:-1] self.assertEqual(n_leaf, 1) self.assertEqual(len(ids), 0) ids = list(self.storage.iter_from(all_ids[-2], n_leaf=True)) n_leaf = ids[-1] ids = ids[:-1] self.assertEqual(n_leaf, 2) # beware, this depends on the hash algo self.assertEqual(len(ids), 1) self.assertEqual(ids, all_ids[-1:]) def test_fdatasync_default(self): content, obj_id = self.hash_content(b"check_fdatasync") with patch.multiple("os", fsync=DEFAULT, fdatasync=DEFAULT) as patched: self.storage.add(content, obj_id=obj_id) if self.storage.use_fdatasync: assert patched["fdatasync"].call_count == 1 assert patched["fsync"].call_count == 0 else: assert patched["fdatasync"].call_count == 0 assert patched["fsync"].call_count == 1 def test_fdatasync_forced_on(self): self.storage.use_fdatasync = True content, obj_id = self.hash_content(b"check_fdatasync") with patch.multiple("os", fsync=DEFAULT, fdatasync=DEFAULT) as patched: self.storage.add(content, obj_id=obj_id) assert patched["fdatasync"].call_count == 1 assert patched["fsync"].call_count == 0 def test_fdatasync_forced_off(self): self.storage.use_fdatasync = False content, obj_id = self.hash_content(b"check_fdatasync") with patch.multiple("os", fsync=DEFAULT, fdatasync=DEFAULT) as patched: self.storage.add(content, obj_id=obj_id) assert patched["fdatasync"].call_count == 0 assert patched["fsync"].call_count == 1 def test_check_not_compressed(self): content, obj_id = self.hash_content(b"check_not_compressed") self.storage.add(content, obj_id=obj_id) with open(self.content_path(obj_id), "ab") as f: # Add garbage. f.write(b"garbage") with self.assertRaises(exc.Error) as error: self.storage.check(obj_id) if self.compression == "none": self.assertIn("Corrupt object", error.exception.args[0]) else: self.assertIn("trailing data found", error.exception.args[0]) class TestPathSlicingObjStorageGzip(TestPathSlicingObjStorage): compression = "gzip" class TestPathSlicingObjStorageZlib(TestPathSlicingObjStorage): compression = "zlib" class TestPathSlicingObjStorageBz2(TestPathSlicingObjStorage): compression = "bz2" class TestPathSlicingObjStorageLzma(TestPathSlicingObjStorage): compression = "lzma" diff --git a/swh/objstorage/tests/test_pathslicer.py b/swh/objstorage/tests/test_pathslicer.py new file mode 100644 index 0000000..465ec92 --- /dev/null +++ b/swh/objstorage/tests/test_pathslicer.py @@ -0,0 +1,85 @@ +# Copyright (C) 2021 The Software Heritage developers +# See the AUTHORS file at the top-level directory of this distribution +# License: GNU General Public License version 3, or any later version +# See top-level LICENSE file for more information +import pytest + +from swh.objstorage.backends.pathslicing import PathSlicer + + +def test_pathslicer(): + slicer = PathSlicer("/", "0:2/2:4/4:6") + assert len(slicer) == 3 + assert slicer.check_config() is None + assert ( + slicer.get_path("34973274ccef6ab4dfaaf86599792fa9c3fe4689") + == "/34/97/32/34973274ccef6ab4dfaaf86599792fa9c3fe4689" + ) + assert ( + slicer.get_directory("34973274ccef6ab4dfaaf86599792fa9c3fe4689") == "/34/97/32" + ) + assert slicer.get_slices("34973274ccef6ab4dfaaf86599792fa9c3fe4689") == [ + "34", + "97", + "32", + ] + + slicer = PathSlicer("/", "/0:1/0:5/") # trailing '/' are ignored + assert slicer.check_config() is None + assert len(slicer) == 2 + assert ( + slicer.get_path("34973274ccef6ab4dfaaf86599792fa9c3fe4689") + == "/3/34973/34973274ccef6ab4dfaaf86599792fa9c3fe4689" + ) + assert ( + slicer.get_directory("34973274ccef6ab4dfaaf86599792fa9c3fe4689") == "/3/34973" + ) + assert slicer.get_slices("34973274ccef6ab4dfaaf86599792fa9c3fe4689") == [ + "3", + "34973", + ] + + # funny one, with steps + slicer = PathSlicer("/", "0:6:2/1:7:2") + assert slicer.check_config() is None + assert slicer.get_slices("123456789".ljust(40, "0")) == ["135", "246"] + + # reverse works too! + slicer = PathSlicer("/", "-1::-1") + assert slicer.check_config() is None + assert slicer.get_slices("34973274ccef6ab4dfaaf86599792fa9c3fe4689") == [ + "34973274ccef6ab4dfaaf86599792fa9c3fe4689"[::-1] + ] + + +def test_pathslicer_noop(): + "test the 'empty' pathslicer" + slicer = PathSlicer("/", "") + assert len(slicer) == 0 + assert slicer.check_config() is None + assert ( + slicer.get_path("34973274ccef6ab4dfaaf86599792fa9c3fe4689") + == "/34973274ccef6ab4dfaaf86599792fa9c3fe4689" + ) + + +def test_pathslicer_bad_hash(): + slicer = PathSlicer("/", "0:2/2:4/4:6") + for hexhash in ("0" * 39, "0" * 41, ""): + with pytest.raises(AssertionError): + slicer.get_path(hexhash) + + +def test_pathslicer_check_config(): + with pytest.raises(ValueError): + PathSlicer("/", "toto") + + with pytest.raises(ValueError): + PathSlicer("/", "/1:2/a:b/") + + assert PathSlicer("/", "0:40").check_config() is None + with pytest.raises(ValueError): + PathSlicer("/", "0:41").check_config() + assert PathSlicer("/", "40:").check_config() is None + with pytest.raises(ValueError): + PathSlicer("/", "41:").check_config()