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

src/badblocks/_find_badblocks.py

@@ -1,76 +0,0 @@
-from itertools import chain
-from pathlib import Path
-from typing import Iterable, Optional, Union
-
-from remap_badblocks.src.utils._run_command import run_command_realtime
-
-
-def parse_badblocks(lines: Iterable[str]) -> Iterable[int]:
-    """Parse badblocks output and return a set of bad sector numbers."""
-    lines = map(lambda line: line.strip(), lines)
-    lines = filter(lambda line: line.isdigit(), lines)
-    return map(int, lines)
-
-
-def read_known_badblocks(known_badblocks_file: Union[Path, str]) -> Iterable[int]:
-    """Merge badblocks with known badblocks from a file."""
-    with open(known_badblocks_file, "r") as f:
-        known_badblocks = parse_badblocks(f.readlines())
-    return known_badblocks
-
-
-def build_badblocks_command(
-    device: Union[Path, str],
-    sector_size: int,
-    mode: str,
-    known_badblocks_file: Optional[Union[Path, str]],
-    blocks_range: Optional[tuple[int, int]],
-) -> list[str]:
-    """
-    Build the badblocks command based on the mode and optional known badblocks file.
-    blocks_range is a right-open interval
-    """
-    if mode == "read":
-        cmd = ["badblocks", "-sv"]
-    elif mode == "write":
-        cmd = ["badblocks", "-wsv"]
-    else:
-        raise ValueError("Invalid mode. Use 'read' or 'write'.")
-
-    cmd += ["-b", str(sector_size)]
-
-    if known_badblocks_file:
-        cmd += ["-i", str(known_badblocks_file)]
-
-    cmd += [str(device)]
-
-    if blocks_range:
-        start_block, end_block = blocks_range
-        cmd += [str(end_block), str(start_block)]
-
-    return cmd
-
-
-def get_all_badblocks(
-    device: Path,
-    sector_size: int,
-    mode: str = "read",
-    known_badblocks_file: Optional[Path] = None,
-    block_range: Optional[tuple[int, int]] = None,
-) -> Iterable[int]:
-    """
-    Run badblocks on a device and return the results as a set of bad sectors.
-    block_range is a right-open interval
-    """
-    badblocks: Iterable[int] = set()
-
-    if known_badblocks_file:
-        badblocks = read_known_badblocks(known_badblocks_file)
-
-    cmd = build_badblocks_command(
-        device, sector_size, mode, known_badblocks_file, block_range
-    )
-    badblocks_lines = run_command_realtime(cmd)
-    badblocks = chain(badblocks, parse_badblocks(badblocks_lines))
-
-    return badblocks

src/badblocks/_mapping_generation.py

@@ -1,12 +0,0 @@
-from typing import Generator, Iterable
-
-
-def generate_mapping(
-    ranges: Iterable[tuple[int, int]],
-) -> Generator[tuple[int, int, int], None, None]:
-    """Generate a mapping from good ranges."""
-    offset = 0
-    for start, end in ranges:
-        length = end - start
-        yield (offset, start, length)  # (start_id_virtual, start_id_real, length)
-        offset += length

src/badblocks/_remap_badblocks.py

@@ -1,114 +0,0 @@
-import itertools
-from typing import Iterable, Iterator, Optional, Union
-
-from remap_badblocks.src.devices.devices_config import Mapping
-
-
-def remap_badblocks(
-    mapping: Iterable[tuple[int, int, int]],
-    badblocks: Iterable[int],
-    spare_sectors: Iterator[int],
-) -> Iterable[tuple[int, int, int]]:
-    sorted_badblocks = sorted(badblocks)
-
-    for start_virtual, start_real, length in mapping:
-        end_real = start_real + length - 1
-        sorted_to_remap: list[int] = []
-        sorted_to_remap_virtual: list[int] = []
-        for badblock in sorted_badblocks:
-            if start_real <= badblock <= end_real:
-                sorted_to_remap.append(badblock)
-        if not sorted_to_remap:
-            # nothing to remap
-            yield start_virtual, start_real, length
-        else:
-            current_start_virtual = start_virtual
-            current_start_real = start_real
-            for badblock in sorted_to_remap:
-                if current_start_real < badblock:
-                    # pieces to keep
-                    yield current_start_virtual, current_start_real, badblock - current_start_real
-                step = badblock - current_start_real + 1
-                current_start_virtual += step
-                current_start_real += step
-                sorted_to_remap_virtual.append(current_start_virtual - 1)
-            if current_start_real < end_real:
-                # pieces to keep
-                yield current_start_virtual, current_start_real, end_real - current_start_real + 1
-            for virt_to_remap in sorted_to_remap_virtual:
-                try:
-                    while (spare_sector := next(spare_sectors)) in badblocks:
-                        pass
-                except StopIteration:
-                    raise RuntimeError
-                # remap
-                yield virt_to_remap, spare_sector, 1
-
-
-def identify_simplifiable_couple_in_mapping(
-    mapping: list[tuple[int, int, int]],
-) -> Optional[tuple[int, int]]:
-    for i, (start_virtual_0, start_real_0, length_0) in enumerate(mapping[:-1]):
-        end_virtual_0 = start_virtual_0 + length_0
-        end_real_0 = start_real_0 + length_0
-        for _j, (start_virtual_1, start_real_1, length_1) in enumerate(
-            mapping[i + 1 :]
-        ):
-            j = _j + i + 1
-            end_virtual_1 = start_virtual_1 + length_1
-            end_real_1 = start_real_1 + length_1
-            if (start_virtual_0 == end_virtual_1) and (start_real_0 == end_real_1):
-                return j, i
-            if (start_virtual_1 == end_virtual_0) and (start_real_1 == end_real_0):
-                return i, j
-    return None
-
-
-def simplify_mapping(
-    mapping: list[tuple[int, int, int]],
-) -> Iterable[tuple[int, int, int]]:
-    while (to_simplify := identify_simplifiable_couple_in_mapping(mapping)) is not None:
-        i, j = to_simplify
-        element_i = mapping[i]
-        element_j = mapping[j]
-
-        simplified_element = element_i[0], element_i[1], element_i[2] + element_j[2]
-
-        _i = min(i, j)
-        _j = max(i, j)
-
-        mapping = (
-            mapping[:_i]
-            + mapping[_i + 1 : _j]
-            + mapping[_j + 1 :]
-            + [simplified_element]
-        )
-
-    return mapping
-
-
-def iter_all_spare_sectors(
-    n_spare_sectors: int, first_spare_sector: int
-) -> Iterator[int]:
-    return iter(range(first_spare_sector, first_spare_sector + n_spare_sectors))
-
-
-def iter_free_spare_sectors(
-    spare_sectors: Iterable[int], n_used_spare_sectors: int
-) -> Iterator[int]:
-    return itertools.islice(spare_sectors, n_used_spare_sectors, None)
-
-
-def count_used_spare_sectors(
-    mapping: Union[Iterable[tuple[int, int, int]], Mapping],
-    spare_sectors: Iterable[int],
-) -> int:
-    spare_sectors = set(spare_sectors)
-    used = 0
-    for _, start, length in mapping:
-        end = start + length
-        for s in spare_sectors:
-            if start <= s < end:
-                used += 1
-
-    return used

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")