remap-badblocks 0.8__py3-none-any.whl → 0.8.1__py3-none-any.whl

src/badblocks/badblocks.py

@@ -1,40 +0,0 @@
-from dataclasses import dataclass
-from typing import Iterable, Iterator
-
-from remap_badblocks.src.utils._iterable_bytes_converter import (
-    iterable_from_bytes, iterable_to_bytes)
-
-
-@dataclass
-class Badblocks(Iterable[int]):
-    badblocks: set[int]
-
-    INT_LENGTH: int = 8
-
-    def __init__(self, badblocks: Iterable[int]):
-        self.badblocks = set(badblocks)
-
-    def __bytes__(self) -> bytes:
-        """
-        Convert the Badblocks to bytes for storage.
-        """
-        return iterable_to_bytes(self.badblocks, length=self.INT_LENGTH)
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "Badblocks":
-        """
-        Create a Badblocks instance from bytes.
-        """
-        return cls(badblocks=set(iterable_from_bytes(data, length=cls.INT_LENGTH)))
-
-    def __len__(self) -> int:
-        """
-        Get the number of bad blocks.
-        """
-        return len(self.badblocks)
-
-    def __iter__(self) -> Iterator[int]:
-        """
-        Iterate over the bad blocks.
-        """
-        return iter(self.badblocks)

src/devices/device_config.py

@@ -1,62 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Iterable, Optional, Union
-
-from remap_badblocks.src.badblocks.badblocks import Badblocks
-from remap_badblocks.src.mapping import Mapping
-
-
-@dataclass
-class DeviceConfig:
-    id: int
-    path: Path
-    name: str
-    sector_size: int
-    badblocks: Badblocks
-    depends_on: set[int]
-    logical_range: tuple[int, int]
-    apply_at_startup: bool = False
-    spare_sectors: Optional[int] = None
-    mapping: Optional[Mapping] = None
-
-    def __init__(
-        self,
-        id: int,
-        path: Union[Path, str],
-        name: str,
-        sector_size: int,
-        badblocks: Iterable[int],
-        logical_range: tuple[int, int],
-        apply_at_startup: bool = False,
-        depends_on: Iterable[int] = set(),
-        spare_sectors: Optional[int] = None,
-        mapping: Optional[Mapping] = None,
-    ):
-        if isinstance(path, str):
-            path = Path(path)
-        self.id = id
-        self.path = path
-        self.name = name
-        self.sector_size = sector_size
-        self.badblocks = Badblocks(badblocks)
-        self.mapping = mapping if mapping is not None else None
-        self.spare_sectors = spare_sectors
-        self.depends_on = set(depends_on)
-        self.logical_range = logical_range
-        self.apply_at_startup = apply_at_startup
-
-    def __str__(self) -> str:
-        return (
-            "DeviceConfig("
-            f"   id={self.id}, path={self.path}, name={self.name},"
-            f"   sector_size={self.sector_size}, badblocks={len(self.badblocks)}, spare_sectors={self.spare_sectors},"
-            f"   mapping={'Undefined' if self.mapping is None else 'Defined'},"
-            f"   depends_on={self.depends_on}, logical_range={self.logical_range}"
-            ")"
-        )
-
-    def get_applied_path(self) -> Path:
-        return Path("/dev/mapper/", self.name)
-
-    def __hash__(self) -> int:
-        return self.id

src/devices/devices_config.py

@@ -1,300 +0,0 @@
-import os
-import re
-import sqlite3 as sqlite
-from collections import OrderedDict
-from pathlib import Path
-from typing import (Any, Collection, Iterable, Literal, Optional, Union,
-                    overload)
-
-from remap_badblocks.src.badblocks.badblocks import Badblocks
-from remap_badblocks.src.mapping import Mapping
-from remap_badblocks.src.utils._iterable_bytes_converter import (
-    iterable_from_bytes, iterable_to_bytes)
-
-from .device_config import DeviceConfig
-from .exceptions import DeviceNotFoundError
-
-DEFAULT_INT_LENGTH = 8
-DEVICE_INFO_COLUMNS_TYPES = OrderedDict(
-    {
-        "id": "INTEGER PRIMARY KEY AUTOINCREMENT",
-        "path": "TEXT NOT NULL",
-        "name": "TEXT NOT NULL",
-        "sector_size": "INTEGER NOT NULL",
-        "badblocks": "BLOB NOT NULL",
-        "spare_sectors": "INTEGER",
-        "mapping": "BLOB",
-        "depends_on": "BLOB NOT NULL",
-        "logical_range_start": "INTEGER NOT NULL",
-        "logical_range_end": "INTEGER NOT NULL",
-        "apply_at_startup": "BOOLEAN DEFAULT FALSE NOT NULL",
-    }
-)
-
-
-class DevicesConfig:
-    _path: Path
-
-    def __init__(self, path: Union[Path, str]):
-        if isinstance(path, str):
-            path = Path(path)
-        assert not path.is_dir(), "The provided path must not be a directory."
-        self._path = path
-        self.__init_table()
-
-    def __init_table(self) -> None:
-        """
-        Initialize the devices table in the database.
-        """
-        os.makedirs(os.path.dirname(self._path), exist_ok=True)
-        with sqlite.connect(self._path) as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                """
-                CREATE TABLE IF NOT EXISTS devices (
-                """
-                + ",".join(
-                    (
-                        col_name + " " + col_type
-                        for col_name, col_type in DEVICE_INFO_COLUMNS_TYPES.items()
-                    )
-                )
-                + """
-                )
-                """
-            )
-            conn.commit()
-
-    def __check_device_in_db(self, conn: sqlite.Connection, id: int) -> bool:
-        """
-        Check if a device with the given ID exists in the database.
-        """
-        cursor = conn.cursor()
-        cursor.execute("SELECT id FROM devices WHERE id = ? LIMIT 1", (id,))
-        val = cursor.fetchone()
-        return val is not None
-
-    def _assert_depends_on(
-        self, conn: sqlite.Connection, depends_on: Collection[int]
-    ) -> None:
-        missing: set[int] = set()
-        for _id in depends_on:
-            if not self.__check_device_in_db(conn, id=_id):
-                missing.add(_id)
-        if missing:
-            raise DeviceNotFoundError(device_id=missing)
-
-    def __parse_device_from_row(
-        self,
-        id: int,
-        path: Union[Path, str],
-        name: str,
-        sector_size: int,
-        badblocks: bytes,
-        spare_sectors: Optional[int],
-        mapping: Optional[bytes],
-        depends_on: bytes,
-        logical_range_start: int,
-        logical_range_end: int,
-        apply_at_startup: bool,
-    ) -> DeviceConfig:
-        """
-        Parse a device configuration from a database row.
-        """
-        return DeviceConfig(
-            id=id,
-            path=Path(path),
-            name=name,
-            sector_size=sector_size,
-            badblocks=Badblocks.from_bytes(badblocks),
-            spare_sectors=spare_sectors,
-            mapping=Mapping.from_bytes(mapping) if mapping is not None else None,
-            depends_on=set(iterable_from_bytes(depends_on, length=DEFAULT_INT_LENGTH)),
-            logical_range=(logical_range_start, logical_range_end),
-            apply_at_startup=apply_at_startup,
-        )
-
-    def get_devices(self) -> Iterable[DeviceConfig]:
-        """
-        Get the devices configuration as a DataFrame.
-        """
-        with sqlite.connect(self._path) as conn:
-            data = conn.execute(
-                """SELECT """
-                + ",".join(DEVICE_INFO_COLUMNS_TYPES.keys())
-                + """ FROM devices"""
-            ).fetchall()
-
-        data = [
-            self.__parse_device_from_row(
-                **dict(zip(DEVICE_INFO_COLUMNS_TYPES.keys(), row))
-            )
-            for row in data
-        ]
-        return data
-
-    @overload
-    def get_device(self, *, id: int, name: Literal[None] = None) -> DeviceConfig: ...
-    @overload
-    def get_device(self, *, id: Literal[None] = None, name: str) -> DeviceConfig: ...
-
-    def get_device(
-        self, *, id: Optional[int] = None, name: Optional[str] = None
-    ) -> DeviceConfig:
-        if id is not None and name is not None:
-            raise ValueError("Only one of id or name can be provided to get a device.")
-
-        with sqlite.connect(self._path) as conn:
-            cursor = conn.cursor()
-            QUERY = (
-                """SELECT """
-                + ",".join(DEVICE_INFO_COLUMNS_TYPES.keys())
-                + """ FROM devices"""
-            )
-            if id is not None:
-                cursor.execute(QUERY + " WHERE id = ?", (id,))
-            elif name is not None:
-                cursor.execute(QUERY + " WHERE name = ?", (name,))
-            else:
-                raise ValueError("Either id or name must be provided to get a device.")
-            row = cursor.fetchone()
-            if row is None:
-                raise DeviceNotFoundError(device_id=id, device_name=name)
-
-        return self.__parse_device_from_row(
-            **dict(zip(DEVICE_INFO_COLUMNS_TYPES.keys(), row))
-        )
-
-    def __insert_into_devices_table(self, cursor: sqlite.Cursor, row: dict[str, Any]):
-        cols = list(row.keys())
-        cursor.execute(
-            """INSERT INTO devices
-                ("""
-            + ",".join(cols)
-            + """)
-            VALUES ("""
-            + ",".join(("?",) * len(cols))
-            + """)""",
-            tuple(row[col] for col in cols),
-        )
-
-    def add_device(
-        self,
-        path: Union[Path, str],
-        name: str,
-        logical_range: tuple[int, int],
-        *,
-        sector_size: Optional[int] = None,
-        badblocks: Union[set[int], Badblocks] = set(),
-        depends_on: Collection[int] = set(),
-    ) -> None:
-        _path: Path = Path(path)
-        assert _path.exists(), f"The provided device {_path} does not exist."
-
-        assert (
-            re.fullmatch(r"[0-9A-Za-z#+\-\.:=@_]+", name) is not None
-        ), "Name does not match requirements"
-
-        try:
-            existing_dev = self.get_device(name=name)
-            raise ValueError(f"Name {name} is used by device {existing_dev.id}.")
-        except DeviceNotFoundError:
-            pass
-
-        badblocks = Badblocks(badblocks)
-
-        with sqlite.connect(self._path) as conn:
-            self._assert_depends_on(conn, depends_on)
-
-            cursor = conn.cursor()
-            self.__insert_into_devices_table(
-                cursor,
-                {
-                    "path": str(_path),
-                    "name": name,
-                    "sector_size": sector_size,
-                    "badblocks": sqlite.Binary(bytes(badblocks)),
-                    "spare_sectors": None,
-                    "mapping": None,
-                    "depends_on": iterable_to_bytes(
-                        depends_on, length=DEFAULT_INT_LENGTH
-                    ),
-                    "logical_range_start": logical_range[0],
-                    "logical_range_end": logical_range[1],
-                },
-            )
-            conn.commit()
-
-    def remove_device(self, id: int) -> None:
-        with sqlite.connect(self._path) as conn:
-            if not self.__check_device_in_db(conn, id=id):
-                raise DeviceNotFoundError(device_id=id)
-
-            for dev in self.get_devices():
-                if id in dev.depends_on:
-                    raise KeyError(
-                        f"Device {dev.id} depends on device {id}, can't remove the latter."
-                    )
-
-            cursor = conn.cursor()
-            cursor.execute("DELETE FROM devices WHERE id = ?", (id,))
-            conn.commit()
-
-    def update_device(
-        self,
-        id: int,
-        *,
-        path: Optional[Union[Path, str]] = None,
-        name: Optional[str] = None,
-        badblocks: Optional[Iterable[int]] = None,
-        mapping: Optional[Mapping] = None,
-        spare_sectors: Optional[int] = None,
-        depends_on: Optional[Collection[int]] = None,
-    ) -> None:
-        with sqlite.connect(self._path) as conn:
-            if not self.__check_device_in_db(conn, id=id):
-                raise DeviceNotFoundError(device_id=id)
-
-            cursor = conn.cursor()
-            if path is not None:
-                cursor.execute(
-                    "UPDATE devices SET path = ? WHERE id = ?", (str(path), id)
-                )
-            if name is not None:
-                cursor.execute("UPDATE devices SET name = ? WHERE id = ?", (name, id))
-            if badblocks is not None:
-                badblocks = Badblocks(badblocks)
-                cursor.execute(
-                    "UPDATE devices SET badblocks = ? WHERE id = ?",
-                    (sqlite.Binary(bytes(badblocks)), id),
-                )
-            if mapping is not None:
-                cursor.execute(
-                    "UPDATE devices SET mapping = ? WHERE id = ?",
-                    (sqlite.Binary(bytes(mapping)), id),
-                )
-            if spare_sectors is not None:
-                cursor.execute(
-                    "UPDATE devices SET spare_sectors = ? WHERE id = ?",
-                    (spare_sectors, id),
-                )
-            if depends_on is not None:
-                self._assert_depends_on(conn, depends_on)
-                cursor.execute(
-                    "UPDATE devices SET depends_on = ? WHERE id = ?",
-                    (
-                        iterable_to_bytes(depends_on, length=DEFAULT_INT_LENGTH),
-                        id,
-                    ),
-                )
-            conn.commit()
-
-    def __len__(self) -> int:
-        """
-        Get the number of devices in the database.
-        """
-        with sqlite.connect(self._path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT COUNT(*) FROM devices")
-            count = cursor.fetchone()[0]
-        return count

src/devices/exceptions.py

@@ -1,22 +0,0 @@
-from typing import Iterable, Optional, Union
-
-
-class DeviceNotFoundError(KeyError):
-    def __init__(
-        self,
-        *,
-        device_id: Optional[Union[int, Iterable[int]]] = None,
-        device_name: Optional[Union[str, Iterable[str]]] = None,
-    ) -> None:
-        if device_id is not None and device_name is not None:
-            raise ValueError("Only one of device_id or device_name can be provided.")
-        if device_id is not None:
-            message = f"Device(s) with id(s) {device_id} does not exist."
-            args = (message,)
-        elif device_name is not None:
-            message = f"Device(s) with name(s) '{device_name}' does not exist."
-            args = (message,)
-        else:
-            message = "Device(s) not found."
-            args = (message,)
-        super().__init__(*args)

src/devices_config_constants.py

@@ -1,3 +0,0 @@
-from pathlib import Path
-
-DEFAULT_DEVICES_CONFIG_PATH = Path("/etc/remap_badblocks/devices_config.db")

src/mapping.py

@@ -1,109 +0,0 @@
-import sqlite3
-from dataclasses import dataclass
-from typing import Collection, Iterator
-
-from remap_badblocks.src.utils._iterable_bytes_converter import (
-    iterable_from_bytes, iterable_to_bytes)
-
-DEFAULT_INT_LENGTH = 8
-
-
-@dataclass
-class MappingElement:
-    start_id_virtual: int
-    start_id_real: int
-    length: int
-
-    INT_LENGTH: int = DEFAULT_INT_LENGTH
-    BYTES_LENGTH: int = 3 * INT_LENGTH
-
-    def __bytes__(self) -> bytes:
-        """
-        Convert the MappingElement to bytes for storage.
-        """
-        return iterable_to_bytes(
-            (
-                self.start_id_virtual,
-                self.start_id_real,
-                self.length,
-            ),
-            length=self.INT_LENGTH,
-        )
-
-    def __index__(self) -> int:
-        """
-        Convert the MappingElement to an integer for storage.
-        """
-        return int.from_bytes(self.__bytes__(), "big")
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "MappingElement":
-        """
-        Create a MappingElement from bytes.
-        """
-        if len(data) != cls.BYTES_LENGTH:
-            raise ValueError(f"Data must be exactly {cls.BYTES_LENGTH} bytes long.")
-        start_id_virtual, start_id_real, length = iterable_from_bytes(
-            data, length=cls.INT_LENGTH
-        )
-        return cls(start_id_virtual, start_id_real, length)
-
-    def __hash__(self) -> int:
-        """
-        Hash the MappingElement for use in sets or dictionaries.
-        """
-        return self.__index__()
-
-    @classmethod
-    def from_tuple(cls, _tuple: tuple[int, int, int]) -> "MappingElement":
-        """
-        Create a MappingElement from a tuple.
-        """
-        if len(_tuple) != 3:
-            raise ValueError("Tuple must contain exactly three elements.")
-        return cls(
-            start_id_virtual=_tuple[0], start_id_real=_tuple[1], length=_tuple[2]
-        )
-
-    def to_tuple(self) -> tuple[int, int, int]:
-        return self.start_id_virtual, self.start_id_real, self.length
-
-    def __iter__(self) -> Iterator[int]:
-        return iter(self.to_tuple())
-
-
-@dataclass
-class Mapping:
-    elements: Collection[MappingElement]
-
-    def __bytes__(self) -> bytes:
-        """
-        Convert the Mapping to bytes for storage.
-        """
-        return b"".join(bytes(element) for element in self.elements)
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "Mapping":
-        """
-        Create a Mapping from bytes.
-        """
-        if len(data) % MappingElement.BYTES_LENGTH != 0:
-            raise ValueError(
-                "Data length is not a multiple of {} bytes.",
-                MappingElement.BYTES_LENGTH,
-            )
-        elements: list[MappingElement] = []
-        for i in range(0, len(data), MappingElement.BYTES_LENGTH):
-            elements.append(
-                MappingElement.from_bytes(data[i : i + MappingElement.BYTES_LENGTH])
-            )
-        return cls(elements)
-
-    def to_sql_binary(self) -> sqlite3.Binary:
-        """
-        Convert the Mapping to a binary format suitable for SQLite storage.
-        """
-        return sqlite3.Binary(bytes(self))
-
-    def __iter__(self) -> Iterator[MappingElement]:
-        return iter(self.elements)

src/remappers/_check_applied_devices.py

@@ -1,10 +0,0 @@
-from typing import Iterable
-
-from remap_badblocks.src.devices.device_config import DeviceConfig
-
-
-def filter_applied_devices(devices: Iterable[DeviceConfig]):
-    def check_applied(device: DeviceConfig) -> bool:
-        return device.get_applied_path().is_block_device()
-
-    return filter(check_applied, devices)

src/remappers/_generate_dm_table.py

@@ -1,27 +0,0 @@
-from pathlib import Path
-from typing import Generator, Iterable, TypeVar, Union
-
-from remap_badblocks.src.devices.devices_config import Mapping
-
-
-def generate_dm_table(
-    device: Union[Path, str],
-    mapping: Union[Iterable[tuple[int, int, int]], Mapping],
-    block_size: int,
-) -> Generator[str, None, None]:
-    """Generate a device-mapper linear mapping table from good ranges."""
-    block_size_multiplier = block_size / 512
-    assert block_size_multiplier.is_integer(), "Block size must be a multiple of 512"
-    block_size_multiplier = int(block_size_multiplier)
-
-    T = TypeVar("T")
-
-    def get_first(iterable: Iterable[T]) -> T:
-        return next(iter(iterable))
-
-    for start_virtual, start_real, length in sorted(mapping, key=get_first):
-        start_virtual *= block_size_multiplier
-        start_real *= block_size_multiplier
-        length *= block_size_multiplier
-
-        yield f"{start_virtual} {length} linear {device} {start_real}"

src/test_utils.py

@@ -1,18 +0,0 @@
-from random import shuffle
-from typing import Generator, Iterable, TypeVar
-
-T = TypeVar("T")
-
-
-def iter_to_shuffled_generator(_iter: Iterable[T]) -> Generator[T, None, None]:
-    _iter_list = list(_iter)
-    shuffle(_iter_list)
-    for v in _iter_list:
-        yield v
-
-
-def count_sectors_in_ranges(ranges: Iterable[tuple[int, int]]):
-    n_sectors = 0
-    for start, end in ranges:
-        n_sectors += end - start
-    return n_sectors

src/utils/_get_device_info.py

@@ -1,43 +0,0 @@
-import os
-import re
-from pathlib import Path
-
-
-def resolve_device_name(device: Path) -> str:
-    resolved = device.resolve()
-    if not resolved.is_block_device():
-        raise ValueError(f"{device} is not a valid block device.")
-    _resolved = str(resolved)
-    m = re.match(r"^/dev/([a-zA-Z0-9\-]+)$", _resolved)
-    if not m:
-        raise RuntimeError(f"Could not parse '{_resolved}'.")
-    return m.group(1)
-
-
-def get_disk_block_size(device_name: str) -> int:
-    """Get the block size of the disk."""
-    path = os.path.join("/sys/block/", device_name, "queue/physical_block_size")
-    try:
-        with open(path, "r") as f:
-            block_size = f.read()
-            return int(block_size.strip())
-    except Exception as e:
-        raise RuntimeError(f"Could not read block size for {device_name}: {e}") from e
-
-
-def get_disk_number_of_blocks(device_name: str) -> int:
-    """Get the number of blocks on the disk."""
-    block_size = get_disk_block_size(device_name)
-    path = os.path.join("/sys/block/", device_name, "size")
-    try:
-        with open(path, "r") as f:
-            txt = f.read()
-        size_in_blocks = int(txt.strip()) * 512 / block_size
-        assert (
-            size_in_blocks.is_integer()
-        ), f"Size in blocks is not an integer: {size_in_blocks}"
-        return int(size_in_blocks)
-    except Exception as e:
-        raise RuntimeError(
-            f"Could not read size in physical blocks for {device_name}: {e}"
-        ) from e

src/utils/_iterable_bytes_converter.py

@@ -1,19 +0,0 @@
-from typing import Iterable
-
-
-def iterable_to_bytes(iterable: Iterable[int], length: int = 4) -> bytes:
-    """
-    Convert an iterable of integers to bytes.
-    """
-    return b"".join(i.to_bytes(length, "big") for i in iterable)
-
-
-def iterable_from_bytes(data: bytes, length: int = 4) -> Iterable[int]:
-    """
-    Convert bytes to an iterable of integers.
-    """
-    if len(data) % length != 0:
-        raise ValueError(f"Data length must be a multiple of {length} bytes.")
-    return (
-        int.from_bytes(data[i : i + length], "big") for i in range(0, len(data), length)
-    )