diff --git a/.gitignore b/.gitignore index 8fdd0e2..4a32f36 100644 --- a/.gitignore +++ b/.gitignore @@ -15,4 +15,4 @@ cdcdb-test-* *.obj *.lst bin -lib +/lib diff --git a/CHANGELOG.md b/CHANGELOG.md index 458646b..90ee81e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,18 +1,13 @@ # Changelog -## [0.1.1] - 2025-09-14 +## [0.1.0] — 2025-09-14 ### Added -- Table `labels` for snapshot labels. -### Fixed -- Improved data integrity with label normalization. - -## [0.1.0] — 2025-09-13 -### Added -- SQLite-backed snapshot library with content-defined chunking (FastCDC). -- Deduplication by SHA-256 of chunks; optional Zstd compression. -- End-to-end integrity checks: per-chunk hash and final file hash. -- Transactions (WAL), basic integrity constraints, and triggers. -- High-level API: - - `Storage`: `newSnapshot`, `getSnapshots`, `getSnapshot`, `removeSnapshots`, `setupCDC`, `getVersion`. - - `Snapshot`: `data()` (buffered) and streaming `data(void delegate(const(ubyte)[]))`, `remove()`, properties (`id`, `label`, `created`, `length`, `sha256`, `status`, `description`). -- Tool to generate a Gear table for FastCDC (`tools/gen.d`). +- Библиотека для хранения и управления снимками данных на базе SQLite с контентно-зависимым разбиением (FastCDC). +- Дедупликация по SHA-256 чанков, опциональная компрессия Zstd. +- Сквозная проверка целостности: хеш каждого чанка и итогового файла. +- Поддержка транзакций (WAL), ограничения целостности и триггеры в БД. +- Высокоуровневый API: + - `Storage`: `newSnapshot`, `getSnapshots`, `getSnapshot`, `removeSnapshots`, `removeSnapshot`, `setupCDC`, `getVersion`. + - `Snapshot`: `data()` (возврат буфера) и потоковый `data(void delegate(const(ubyte)[]))`, `remove()`, свойства (`id`, `file`, `created`, `length`, `sha256`, `status`, `description`, `algoMin`, `algoNormal`, `algoMax`, `maskS`, `maskL`, `uid`, `ruid`, `uidName`, `ruidName`, `process`, `isReady`, `isPending`). + - `Context`: структура для передачи UID, RUID, имён пользователей и процесса при создании снимка. +- Инструмент для генерации Gear-таблицы для FastCDC (`tools/gen.d`). diff --git a/CHANGELOG.ru.md b/CHANGELOG.ru.md deleted file mode 100644 index f1ec152..0000000 --- a/CHANGELOG.ru.md +++ /dev/null @@ -1,18 +0,0 @@ -# Changelog - -## [0.1.1] - 2025-09-14 -### Added -- Таблица `labels` для меток снимков. -### Fixed -- Улучшена целостность данных при нормализации меток. - -## [0.1.0] - 2025-09-13 -### Added -- Библиотека для снимков данных на базе SQLite с контентно-зависимым разбиением (FastCDC). -- Дедупликация по SHA-256 чанков, опциональная компрессия Zstd. -- Сквозная проверка целостности: хеш каждого чанка и итогового файла. -- Транзакции (WAL), базовые ограничения целостности и триггеры. -- Высокоуровневый API: - - `Storage`: `newSnapshot`, `getSnapshots`, `getSnapshot`, `removeSnapshots`, `setupCDC`, `getVersion`. - - `Snapshot`: `data()` (буфер) и потоковый `data(void delegate(const(ubyte)[]))`, `remove()`, свойства (`id`, `label`, `created`, `length`, `sha256`, `status`, `description`). -- Инструмент для генерации Gear-таблицы для FastCDC (`tools/gen.d`). diff --git a/README.md b/README.md index f490306..51bcb32 100644 --- a/README.md +++ b/README.md @@ -1,66 +1,42 @@ # cdcdb -A library for storing and managing snapshots of textual data in an SQLite database. It uses content-defined chunking (CDC) based on the FastCDC algorithm to split data into variable-size chunks for efficient deduplication. Supports optional Zstd compression, transactions, and end-to-end integrity verification via SHA-256. Primary use cases: backups and versioning of text files while minimizing storage footprint. +Библиотека для версионирования и хранения данных в SQLite с опорой на content-defined chunking (CDC). Алгоритм **FastCDC** используется для разбиения входного потока на чанки переменного размера, что обеспечивает эффективную дедупликацию и экономию места. Поддерживаются опциональное сжатие **Zstd**, транзакции и проверка целостности на основе **SHA-256**. Дополнительно фиксируется контекст выполнения при создании снимков (UID, RUID, процесс). Основные сценарии применения — резервное копирование и контроль версий файлов. -## FastCDC algorithm -FastCDC splits data into variable-size chunks using content hashing. A Gear table is used to compute rolling “fingerprints” and choose cut points while respecting minimum, target, and maximum chunk sizes. This efficiently detects changes and stores only unique chunks, reducing storage usage. +## Алгоритм FastCDC +**FastCDC** — это алгоритм разделения данных на чанки переменной длины, основанный на скользящем хэшировании содержимого. Он использует таблицу **Gear** для вычисления "отпечатков" данных и выбирает точки разреза с учётом минимального, целевого и максимального размеров чанка. Такой подход позволяет эффективно выявлять изменения и сохранять только уникальные части данных. -## Core classes +## Архитектура и основные компоненты -### Storage -High-level API for the SQLite store and snapshot management. +Библиотека разделена на несколько уровней: -- **Constructor**: Initializes a connection to SQLite. -- **Methods**: - - `newSnapshot`: Creates a snapshot. Returns a `Snapshot` object or `null` if the data matches the latest snapshot. - - `getSnapshots`: Returns a list of snapshots (all, or filtered by label). Returns an array of `Snapshot`. - - `getSnapshot`: Fetches a snapshot by ID. Returns a `Snapshot`. - - `setupCDC`: Configures CDC splitting parameters. Returns nothing. - - `removeSnapshots`: Deletes snapshots by label, ID, or a `Snapshot` object. Returns the number of deleted snapshots (for label) or `true`/`false` (for ID or object). - - `getVersion`: Returns the library version string. +- **Storage** — фасад для работы с БД SQLite. Отвечает за разбиение данных (FastCDC), сохранение/удаление снимков, управление блобами и транзакциями. +- **Snapshot** — объект-ссылка на конкретный снимок. Предоставляет доступ к данным (буфером или потоково), а также к метаданным и операциям удаления. +- **Context** — структура с параметрами окружения (UID, RUID, имена пользователей, процесс), передаваемыми при создании снимка. -### Snapshot -Work with an individual snapshot. - -- **Constructor**: Creates a snapshot handle by its ID. -- **Methods**: - - `data`: Restores full snapshot data. Returns a byte array (`ubyte[]`). - - `data`: Streams restored data via a delegate sink. Returns nothing. - - `remove`: Deletes the snapshot from the database. Returns `true` on success, otherwise `false`. - -- **Properties**: - - `id`: Snapshot ID (`long`). - - `label`: Snapshot label (`string`). - - `created`: Creation timestamp (UTC, `DateTime`). - - `length`: Original data length (`long`). - - `sha256`: Data SHA-256 hash (`ubyte[32]`). - - `status`: Snapshot status (`"pending"` or `"ready"`). - - `description`: Snapshot description (`string`). - -## Example +## Пример использования ```d import cdcdb; - import std.stdio : writeln, File; -import std.file : exists, remove; void main() { - // Create DB string dbPath = "example.db"; - // Initialize Storage with Zstd compression + // Storage с Zstd-сжатием auto storage = new Storage(dbPath, true, 22); - // Create a snapshot + // Контекст + Context ctx = Context(1000, 1000, "user", "user", "example"); + + // Новый снимок ubyte[] data = cast(ubyte[]) "Hello, cdcdb!".dup; - auto snap = storage.newSnapshot("example_file", data, "Version 1.0"); + auto snap = storage.newSnapshot("example_file", data, ctx, "Версия 1.0"); if (snap) { - writeln("Snapshot created: ID=", snap.id, ", Label=", snap.label); + writeln("Создан снимок: ID=", snap.id, ", Файл=", snap.file); } - // Restore data + // Восстановление через потоковую запись auto snapshots = storage.getSnapshots("example_file"); if (snapshots.length > 0) { @@ -68,35 +44,25 @@ void main() File outFile = File("restored.txt", "wb"); lastSnap.data((const(ubyte)[] chunk) => outFile.rawWrite(chunk)); outFile.close(); - writeln("Data restored to restored.txt"); + writeln("Данные восстановлены в restored.txt"); } - // Delete snapshots + // Удаление long deleted = storage.removeSnapshots("example_file"); - writeln("Deleted snapshots: ", deleted); + writeln("Удалено снимков: ", deleted); } ``` -## Tools +## Инструменты -The `tools` directory contains a small D script for generating a Gear table used by FastCDC. It lets you build custom hash tables to tune splitting behavior. To generate a new table: +В директории `tools` есть скрипт на D для генерации таблицы Gear, используемой FastCDC. +Чтобы создать новую таблицу: ```bash chmod +x ./tools/gen.d ./tools/gen.d > ./source/gear.d ``` -## Installation - -* **In `dub.json`**: - - ```json - "dependencies": { - "cdcdb": "~>0.1" - } - ``` -* **Build**: `dub build`. - -## License +## Лицензия Boost Software License 1.0 (BSL-1.0). diff --git a/README.ru.md b/README.ru.md deleted file mode 100644 index f05a400..0000000 --- a/README.ru.md +++ /dev/null @@ -1,98 +0,0 @@ -# cdcdb - -Библиотека для хранения и управления снимками текстовых данных в базе SQLite. Использует механизм content-defined chunking (CDC) на основе алгоритма FastCDC для разделения данных на чанки переменного размера, что обеспечивает эффективную дедупликацию. Поддерживает опциональную компрессию Zstd, транзакции и проверку целостности данных через SHA-256. Основное применение — резервное копирование и версионирование текстовых файлов с минимизацией занимаемого пространства. - -## Алгоритм FastCDC -FastCDC — это алгоритм разделения данных на чанки переменного размера, основанный на хэшировании содержимого. Он использует таблицу Gear для вычисления "отпечатков" данных, определяя точки разделения с учетом минимального, целевого и максимального размеров чанка. Это позволяет эффективно выявлять изменения в данных и хранить только уникальные чанки, снижая объем хранилища. - -## Основные классы - -### Storage -Класс для работы с базой SQLite и управления снимками. - -- **Конструктор**: Инициализирует подключение к базе SQLite. -- **Методы**: - - `newSnapshot`: Создает снимок данных. Возвращает объект `Snapshot` или `null`, если данные совпадают с последним снимком. - - `getSnapshots`: Получает список снимков (все или по метке). Возвращает массив объектов `Snapshot`. - - `getSnapshot`: Получает снимок по ID. Возвращает объект `Snapshot`. - - `setupCDC`: Настраивает параметры разделения данных CDC. Ничего не возвращает. - - `removeSnapshots`: Удаляет снимки по метке, ID или объекту Snapshot. Возвращает количество удаленных снимков (для метки) или `true`/`false` (для ID или объекта). - - `getVersion`: Возвращает строку с версией библиотеки. - -### Snapshot -Класс для работы с отдельным снимком данных. - -- **Конструктор**: Создает объект снимка для работы с данными по его ID. -- **Методы**: - - `data`: Извлекает полные данные снимка. Возвращает массив байтов (`ubyte[]`). - - `data`: Извлекает данные снимка потоково через делегат. Ничего не возвращает. - - `remove`: Удаляет снимок из базы. Возвращает `true` при успешном удалении, иначе `false`. - -- **Свойства**: - - `id`: ID снимка (long). - - `label`: Метка снимка (string). - - `created`: Временная метка создания (UTC, `DateTime`). - - `length`: Длина исходных данных (long). - - `sha256`: Хэш SHA-256 данных (ubyte[32]). - - `status`: Статус снимка ("pending" или "ready"). - - `description`: Описание снимка (string). - -## Пример использования -```d -import cdcdb; - -import std.stdio : writeln, File; -import std.file : exists, remove; - -void main() -{ - // Создаем базу - string dbPath = "example.db"; - - // Инициализация Storage с компрессией Zstd - auto storage = new Storage(dbPath, true, 22); - - // Создание снимка - ubyte[] data = cast(ubyte[]) "Hello, cdcdb!".dup; - auto snap = storage.newSnapshot("example_file", data, "Версия 1.0"); - if (snap) - { - writeln("Создан снимок: ID=", snap.id, ", Метка=", snap.label); - } - - // Восстановление данных - auto snapshots = storage.getSnapshots("example_file"); - if (snapshots.length > 0) - { - auto lastSnap = snapshots[0]; - File outFile = File("restored.txt", "wb"); - lastSnap.data((const(ubyte)[] chunk) => outFile.rawWrite(chunk)); - outFile.close(); - writeln("Данные восстановлены в restored.txt"); - } - - // Удаление снимков - long deleted = storage.removeSnapshots("example_file"); - writeln("Удалено снимков: ", deleted); -} -``` - -## Инструменты -В директории `tools` находится скрипт на D для создания таблицы Gear, используемой в алгоритме FastCDC. Он позволяет генерировать пользовательские таблицы хэшей для настройки разделения данных. Для создания новой таблицы выполните: - -```bash -chmod +x ./tools/gen.d -./tools/gen.d > ./source/gear.d -``` - -## Установка -- **В `dub.json`**: - ```json - "dependencies": { - "cdcdb": "~>0.1" - } - ``` -- **Сборка**: `dub build`. - -## Лицензия -Boost Software License 1.0 (BSL-1.0). diff --git a/dub.json b/dub.json index ac9ccba..d435e7f 100644 --- a/dub.json +++ b/dub.json @@ -7,7 +7,7 @@ "license": "BSL-1.0", "name": "cdcdb", "dependencies": { - "arsd-official:sqlite": "~>12.0.0", + "d2sqlite3": "~>1.0.0", "zstd": "~>0.2.1" }, "stringImportPaths": [ diff --git a/dub.selections.json b/dub.selections.json index caa3e75..25dd8d4 100644 --- a/dub.selections.json +++ b/dub.selections.json @@ -2,6 +2,7 @@ "fileVersion": 1, "versions": { "arsd-official": "12.0.0", + "d2sqlite3": "1.0.0", "zstd": "0.2.1" } } diff --git a/source/cdcdb/core.d b/source/cdcdb/core.d index 5ea8b4a..853de51 100644 --- a/source/cdcdb/core.d +++ b/source/cdcdb/core.d @@ -1,24 +1,45 @@ +/// Модуль базовых структур и алгоритмов CDC (content-defined chunking). module cdcdb.core; import std.digest.sha : SHA256, digest; +/// Описание чанка данных. +/// +/// Поля: +/// - `index` — порядковый номер чанка, начиная с 1. +/// - `offset` — смещение чанка в исходном буфере (в байтах). +/// - `size` — размер чанка (в байтах). +/// - `sha256` — SHA-256 содержимого (сырые 32 байта). struct Chunk { - size_t index; // 1..N - size_t offset; // offset in the source buffer - size_t size; // chunk size - immutable(ubyte)[32] sha256; // hex(SHA-256) of the content + size_t index; + size_t offset; + size_t size; + immutable(ubyte)[32] sha256; } -// Change Data Capture (CDC) +/// Change Data Capture (CDC) — алгоритм нарезки потока на чанки по содержимому. +/// +/// Класс реализует скользящее шифрование (rolling hash) с двумя масками: +/// строгой (`_maskS`) до «нормального» размера и более слабой (`_maskL`) до «максимального». final class CDC { private: size_t _minSize, _normalSize, _maxSize; ulong _maskS, _maskL; - // _gear + // Таблица случайных значений Gear (должна быть сгенерирована отдельно в "gear.d") mixin(import("gear.d")); + /// Вычисляет длину следующего чанка, начиная с начала `src`. + /// + /// Параметры: + /// - `src` — оставшийся участок данных. + /// + /// Возвращает: длину чанка в байтах. + /// + /// Детали: + /// - Если данных меньше либо равно минимальному размеру — возвращает их длину. + /// - Сначала ищется граница по строгой маске до `_normalSize`, затем по слабой до `_maxSize`. size_t cut(const(ubyte)[] src) pure nothrow @safe @nogc { size_t size = src.length; @@ -36,13 +57,13 @@ private: ulong fingerprint = 0; size_t index; - // initialization without a cut-check + // Инициализация без проверки на разрез while (index < _minSize) { fingerprint = (fingerprint << 1) + _gear[src[index]]; ++index; } - // strict mask + // Строгая маска while (index < normalSize) { fingerprint = (fingerprint << 1) + _gear[src[index]]; @@ -50,7 +71,7 @@ private: return index; ++index; } - // weak mask + // Слабая маска while (index < size) { fingerprint = (fingerprint << 1) + _gear[src[index]]; @@ -62,10 +83,21 @@ private: } public: + /// Создаёт экземпляр CDC. + /// + /// Параметры: + /// - `minSize` — минимальный размер чанка. + /// - `normalSize` — целевой (нормальный) размер чанка. + /// - `maxSize` — максимальный размер чанка. + /// - `maskS` — строгая маска (для поиска границы до `normalSize`). + /// - `maskL` — слабая маска (для поиска границы до `maxSize`). + /// + /// Замечания: + /// - Требуется `0 < minSize < normalSize < maxSize`. this(size_t minSize, size_t normalSize, size_t maxSize, ulong maskS, ulong maskL) @safe @nogc nothrow { assert(minSize > 0 && minSize < normalSize && normalSize < maxSize, - "Invalid sizes: require min < normal < max and min > 0"); + "Некорректные размеры: требуется 0 < min < normal < max"); _minSize = minSize; _normalSize = normalSize; _maxSize = maxSize; @@ -73,6 +105,12 @@ public: _maskL = maskL; } + /// Разбивает буфер `data` на последовательность чанков. + /// + /// Параметры: + /// - `data` — исходные байты. + /// + /// Возвращает: массив `Chunk` в порядке следования. Chunk[] split(const(ubyte)[] data) @safe nothrow { Chunk[] chunks; diff --git a/source/cdcdb/dblite.d b/source/cdcdb/dblite.d index 173627f..b0514e1 100644 --- a/source/cdcdb/dblite.d +++ b/source/cdcdb/dblite.d @@ -1,13 +1,33 @@ module cdcdb.dblite; -import arsd.sqlite : Sqlite, SqliteResult, DatabaseException; +import d2sqlite3; -import std.datetime : DateTime; import std.string : join, replace, toLower; import std.algorithm : canFind; import std.conv : to; import std.format : format; import std.exception : enforce; +import std.uuid : UUID, randomUUID; + +import cdcdb.lib; + +struct DBFile { + Identifier id; + string path; + + @trusted pure nothrow @nogc @property bool empty() const { + return id.empty(); + } +} + +struct DBProcess { + Identifier id; + string name; + + @trusted pure nothrow @nogc @property bool empty() const { + return id.empty(); + } +} enum SnapshotStatus : ubyte { @@ -16,64 +36,84 @@ enum SnapshotStatus : ubyte } struct DBSnapshot { - long id; - string label; - ubyte[32] sha256; - string description; - DateTime createdUtc; - long sourceLength; - long algoMin; - long algoNormal; - long algoMax; - long maskS; - long maskL; - SnapshotStatus status; + Identifier id; /// Идентификатор снимка. + DBFile file; /// Файл (таблица `files`). + ubyte[32] sha256; /// Хеш всего файла (SHA-256, 32 байта). + string description; /// Описание/комментарий (может быть пустым). + UTS createdUtc; /// Время создания (UTC). + long sourceLength; /// Длина исходного файла (байт). + long algoMin; /// FastCDC: минимальный размер чанка. + long algoNormal; /// FastCDC: нормальный (целевой) размер чанка. + long algoMax; /// FastCDC: максимальный размер чанка. + long maskS; /// Строгая маска FastCDC. + long maskL; /// Слабая маска FastCDC. + SnapshotStatus status; /// Статус снимка. + long uid; /// UID процесса (effective). + long ruid; /// Real UID процесса. + string uidName; /// Имя пользователя для `uid`. + string ruidName; /// Имя пользователя для `ruid`. + DBProcess process; /// Процесс (таблица `processes`). + + @trusted pure nothrow @nogc @property bool empty() const { + return id.empty(); + } } struct DBSnapshotChunk { - long snapshotId; - long chunkIndex; - long offset; - ubyte[32] sha256; + Identifier snapshotId; /// ID снимка. + long chunkIndex; /// Порядковый номер чанка в снимке. + long offset; /// Смещение чанка в файле. + ubyte[32] sha256; /// Хеш чанка (SHA-256, 32 байта). } struct DBBlob { - ubyte[32] sha256; - ubyte[32] zSha256; - long size; - long zSize; - ubyte[] content; - DateTime createdUtc; - DateTime lastSeenUtc; - long refcount; - bool zstd; + ubyte[32] sha256; /// Хеш исходного содержимого. + ubyte[32] zSha256; /// Хеш сжатого содержимого (если zstd=true). + long size; /// Размер исходного содержимого. + long zSize; /// Размер сжатого содержимого. + ubyte[] content; /// Контент (если хранится в БД). + UTS createdUtc; /// Время создания (UTC). + UTS lastSeenUtc; /// Последний доступ (UTC). + long refcount; /// Ссылки на блоб (сколькими снимками используется). + bool zstd; /// Признак, что `content` хранится в сжатом виде. } struct DBSnapshotChunkData { - long chunkIndex; - long offset; - long size; - ubyte[] content; - bool zstd; - long zSize; - ubyte[32] sha256; - ubyte[32] zSha256; + long chunkIndex; /// Порядковый номер чанка. + long offset; /// Смещение в файле. + long size; /// Размер исходного чанка. + ubyte[] content; /// Содержимое (может быть пустым, если хранится вне БД). + bool zstd; /// Сжат ли контент Zstd. + long zSize; /// Размер сжатого контента. + ubyte[32] sha256; /// Хеш исходного содержимого. + ubyte[32] zSha256; /// Хеш сжатого содержимого. } -final class DBLite : Sqlite +final class DBLite { private: - string _dbPath; - size_t _maxRetries; - // _scheme + string _dbPath; /// Путь к файлу БД. + size_t _maxRetries; /// Максимум повторов при `busy/locked`. + Database _db; /// Соединение с БД (d2sqlite3). + + // SQL-схема (массив строковых запросов). mixin(import("scheme.d")); - SqliteResult sql(T...)(string queryText, T args) + /// Выполняет SQL с повторными попытками при `locked/busy`. + ResultRange sql(T...)(string queryText, T args) { + // Готовим стейтмент сами, чтобы bindAll() работал и для BLOB. + auto attempt = () { + auto st = _db.prepare(queryText); + static if (T.length > 0) + st.bindAll(args); + return st.execute(); + }; + if (_maxRetries == 0) { - return cast(SqliteResult) query(queryText, args); + return attempt(); } string msg; @@ -81,30 +121,34 @@ private: while (tryNo) { try { - return cast(SqliteResult) query(queryText, args); - } catch (DatabaseException e) { + return attempt(); + } catch (SqliteException e) { msg = e.msg; - if (msg.toLower.canFind("locked", "busy")) { + const code = e.code; + if (code == SQLITE_BUSY || code == SQLITE_LOCKED) { if (--tryNo == 0) { throw new Exception( - "Failed to connect to the database after %d failed attempts: %s" + "Не удалось выполнить запрос к базе данных после %d неудачных попыток: %s" .format(_maxRetries, msg) ); } continue; } - break; + break; // другие ошибки — дальше по стеку } } - throw new Exception(msg); + // До сюда не дойдём, но для формальной полноты: + throw new Exception(msg.length ? msg : "SQLite error"); } - // Check that the database contains the required tables; otherwise create them + /// Проверяет наличие обязательных таблиц. + /// Если все отсутствуют — создаёт схему; если отсутствует часть — бросает ошибку. void check() { - SqliteResult queryResult = sql( + auto queryResult = sql( q{ - WITH required(name) AS (VALUES ("snapshots"), ("blobs"), ("snapshot_chunks"), ("labels")) + WITH required(name) + AS (VALUES ("snapshots"), ("blobs"), ("snapshot_chunks"), ("users"), ("processes"), ("files")) SELECT name AS missing_table FROM required WHERE NOT EXISTS ( @@ -119,14 +163,14 @@ private: foreach (row; queryResult) { - missingTables ~= row["missing_table"].to!string; + missingTables ~= row["missing_table"].as!string; } - enforce(missingTables.length == 0 || missingTables.length == 4, - "Database is corrupted. Missing tables: " ~ missingTables.join(", ") + enforce(missingTables.length == 0 || missingTables.length == 6, + "База данных повреждена. Отсутствуют таблицы: " ~ missingTables.join(", ") ); - if (missingTables.length == 4) + if (missingTables.length == 6) { foreach (schemeQuery; _scheme) { @@ -135,74 +179,336 @@ private: } } - DateTime toDateTime(string sqliteDate) - { - string isoDate = sqliteDate.replace(" ", "T"); - return DateTime.fromISOExtString(isoDate); - } - public: this(string database, size_t busyTimeout, size_t maxRetries) { _dbPath = database; - super(database); + _db = Database(database); check(); _maxRetries = maxRetries; - query("PRAGMA journal_mode=WAL"); - query("PRAGMA synchronous=NORMAL"); - query("PRAGMA foreign_keys=ON"); - query("PRAGMA busy_timeout=%d".format(busyTimeout)); + _db.execute("PRAGMA journal_mode=WAL"); + _db.execute("PRAGMA synchronous=NORMAL"); + _db.execute("PRAGMA foreign_keys=ON"); + _db.execute("PRAGMA busy_timeout=%d".format(busyTimeout)); } + /// BEGIN IMMEDIATE. void beginImmediate() { - sql("BEGIN IMMEDIATE"); + _db.execute("BEGIN IMMEDIATE"); } + /// COMMIT. void commit() { - sql("COMMIT"); + _db.commit(); } + /// ROLLBACK. void rollback() { - sql("ROLLBACK"); + _db.rollback(); } - bool isLast(string label, ubyte[] sha256) { + /************************************************* + **************** Работа с файлом ***************** + *************************************************/ + + DBFile[] getFiles() { + auto queryResult = sql( + q{ + SELECT id, name FROM files + } + ); + + DBFile[] files; + + foreach (row; queryResult) + { + DBFile file; + + file.id = row["id"].as!Blob(Blob.init); + file.path = row["name"].as!string; + + files ~= file; + } + + return files; + } + + DBFile getFile(string path) { + auto queryResult = sql( + q{ + SELECT id FROM files WHERE name = ?1 + }, path + ); + + DBFile file; + + if (!queryResult.empty) { + auto data = queryResult.front; + + file.id = data["id"].as!Blob(Blob.init); + file.path = path; + } + + return file; + } + + DBFile getFile(Identifier id) { + auto queryResult = sql( + q{ + SELECT id, name + FROM files + WHERE id = ?1 + }, id[] + ); + + DBFile file; + + if (!queryResult.empty) { + auto data = queryResult.front; + + file.id = id; + file.path = data["name"].as!string; + } + + return file; + } + + DBFile addFile(string path) { + ResultRange queryResult; + UUID uuid; + + // Исключение одинакового UUID первичного ключа + do { + uuid = randomUUID(); + queryResult = sql( + q{ + SELECT id FROM files WHERE id = ?1 + }, uuid.data[] + ); + } while (!queryResult.empty); + + queryResult = sql( + q{ + INSERT INTO files(id, name) + VALUES(?1, ?2) + RETURNING id, name + }, uuid.data[], path + ); + + enforce(!queryResult.empty, "Не удалось добавить новый файл в базу данных"); + + return DBFile(Identifier(uuid.data), path); + } + + DBFile[] findFile(string pattern) { + auto queryResult = sql( + q{ + SELECT id, name FROM files WHERE name LIKE ?1 + }, '%' ~ pattern ~ '%' + ); + + DBFile[] files; + + foreach (row; queryResult) + { + DBFile file; + + file.id = row["id"].as!Blob(Blob.init); + file.path = row["name"].as!string; + + files ~= file; + } + + return files; + } + + // Функция производит поиск по хешу + // Если младший ниббл является нулевым (0000), то ищем позицию вхождения подстроки в строку + // Иначе ищем по подстроке + DBFile[] findFile(Identifier id) { + auto queryResult = sql( + q{ + SELECT id, name + FROM files + WHERE length(?1) BETWEEN 1 AND 16 + AND CASE + WHEN substr(hex(?1), 2 * length(?1), 1) = '0' + THEN instr(hex(id), substr(hex(?1), 1, 2 * length(?1) - 1)) > 0 + ELSE substr(id, 1, length(?1)) = ?1 + END + }, id[] + ); + + DBFile[] files; + + foreach (row; queryResult) + { + DBFile file; + + file.id = row["id"].as!Blob(Blob.init); + file.path = row["name"].as!string; + + files ~= file; + } + + return files; + } + + bool deleteFile(Identifier id) { + auto queryResult = sql("DELETE FROM files WHERE id = ?1 RETURNING id", id[]); + return !queryResult.empty; + } + + bool deleteFile(string path) { + auto queryResult = sql("DELETE FROM files WHERE name = ?1 RETURNING id", path); + return !queryResult.empty; + } + + ///////////////////////////////////////////////////////////////////// + + bool isLast(Identifier id, ubyte[] sha256) { auto queryResult = sql( q{ SELECT COALESCE( ( - SELECT (s.sha256 = ?2) - FROM snapshots s - JOIN labels l ON l.id = s.label - WHERE l.name = ?1 - ORDER BY s.created_utc DESC + SELECT (sha256 = ?2) + FROM snapshots + WHERE file = ?1 + ORDER BY created_utc DESC LIMIT 1 ), 0 ) AS is_last; - }, label, sha256 + }, id[], sha256[] ); - if (!queryResult.empty()) - return queryResult.front()["is_last"].to!long > 0; + if (!queryResult.empty) + return queryResult.front["is_last"].as!long > 0; return false; } - long addSnapshot(DBSnapshot snapshot) + bool addUser(long uid, string name) { auto queryResult = sql( + q{ + INSERT INTO users (uid, name) + SELECT ?1,?2 + WHERE NOT EXISTS ( + SELECT 1 FROM users WHERE uid = ?1 + ) + }, uid, name + ); + + return !queryResult.empty; + } + + DBProcess getProcess(string name) { + auto queryResult = sql( + q{ + SELECT id FROM processes WHERE name = ?1 + }, name + ); + + DBProcess process; + + if (!queryResult.empty) { + auto data = queryResult.front; + + process.id = data["id"].as!Blob(Blob.init); + process.name = name; + } + + return process; + } + + DBProcess getProcess(Identifier id) { + auto queryResult = sql( + q{ + SELECT id, name + FROM processes + WHERE id = ?1 + }, id[] + ); + + DBProcess process; + + if (!queryResult.empty) { + auto data = queryResult.front; + + process.id = id; + process.name = data["name"].as!string; + } + + return process; + } + + DBProcess addProcess(string name) { + ResultRange queryResult; + UUID uuid; + + // Исключение одинакового UUID первичного ключа + do { + uuid = randomUUID(); + queryResult = sql( + q{ + SELECT id FROM processes WHERE id = ?1 + }, uuid.data[] + ); + } while (!queryResult.empty); + + queryResult = sql( + q{ + INSERT INTO processes (id, name) + VALUES (?1, ?2) + RETURNING id, name + }, uuid.data[], name + ); + + enforce(!queryResult.empty, "Не удалось добавить новый файл в базу данных"); + + return DBProcess(Identifier(uuid.data), name); + } + + ///////////////////////////////////////////////////////////////////// + + bool addSnapshot(ref DBSnapshot snapshot) + { + ResultRange queryResult; + UUID uuid; + + // Исключение одинакового UUID первичного ключа + do { + uuid = randomUUID(); + queryResult = sql( + q{ + SELECT id FROM snapshots WHERE id = ?1 + }, uuid.data[] + ); + } while (!queryResult.empty); + + import std.datetime : Clock; + + snapshot.createdUtc = UTS(Clock.currTime()); + snapshot.id = Identifier(uuid.data); + + queryResult = sql( q{ INSERT INTO snapshots( - label, + id, + file, sha256, description, + created_utc, source_length, + uid, + ruid, + process, algo_min, algo_normal, algo_max, @@ -210,60 +516,67 @@ public: mask_l, status ) - SELECT - (SELECT id FROM labels WHERE name = ?), - ?,?,?,?,?,?,?,?,? + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15) RETURNING id }, - snapshot.label, - snapshot.sha256[], - snapshot.description.length ? snapshot.description : null, - snapshot.sourceLength, - snapshot.algoMin, - snapshot.algoNormal, - snapshot.algoMax, - snapshot.maskS, - snapshot.maskL, - snapshot.status.to!int + snapshot.id[], // ?1 + snapshot.file.id[], // ?2 + snapshot.sha256[], // ?3 + snapshot.description.length ? snapshot.description : null, // ?4 + snapshot.createdUtc.unix, // ?5 + snapshot.sourceLength, // ?6 + snapshot.uid, // ?7 + snapshot.ruid, // ?8 + snapshot.process.id[], // ?9 + snapshot.algoMin, // ?10 + snapshot.algoNormal, // ?11 + snapshot.algoMax, // ?12 + snapshot.maskS, // ?13 + snapshot.maskL, // ?14 + snapshot.status.to!int // ?15 ); - if (queryResult.empty()) { - throw new Exception("Error adding a new snapshot to the database"); - } - - return queryResult.front()["id"].to!long; + return !queryResult.empty; } - bool addBlob(DBBlob blob) + ///////////////////////////////////////////////////////////////////// + + bool addBlob(ref DBBlob blob) { + import std.datetime : Clock; + + blob.createdUtc = UTS(Clock.currTime()); + blob.lastSeenUtc = UTS(Clock.currTime()); + auto queryResult = sql( q{ - INSERT INTO blobs (sha256, z_sha256, size, z_size, content, zstd) - VALUES (?,?,?,?,?,?) - ON CONFLICT (sha256) DO NOTHING + INSERT INTO blobs ( + sha256, + z_sha256, + size, + z_size, + content, + created_utc, + last_seen_utc, + zstd + ) + SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8 + WHERE NOT EXISTS ( + SELECT 1 FROM blobs WHERE sha256 = ?1 + ) RETURNING sha256 }, - blob.sha256[], - blob.zstd ? blob.zSha256[] : null, - blob.size, - blob.zSize, - blob.content, - blob.zstd.to!int + blob.sha256[], // ?1 + blob.zstd ? blob.zSha256[] : null, // ?2 + blob.size, // ?3 + blob.zSize, // ?4 + blob.content, // ?5 + blob.createdUtc.unix, // ?6 + blob.lastSeenUtc.unix, // ?7 + blob.zstd.to!int // ?8 ); - return !queryResult.empty(); - } - - bool addLabel(string name) - { - auto queryResult = sql( - q{ - INSERT INTO labels (name) VALUES (?) - ON CONFLICT(name) DO NOTHING - }, name - ); - - return !queryResult.empty(); + return !queryResult.empty; } bool addSnapshotChunk(DBSnapshotChunk snapshotChunk) @@ -271,113 +584,19 @@ public: auto queryResult = sql( q{ INSERT INTO snapshot_chunks (snapshot_id, chunk_index, offset, sha256) - VALUES(?,?,?,?) + VALUES (?1, ?2, ?3, ?4) RETURNING snapshot_id }, - snapshotChunk.snapshotId, + snapshotChunk.snapshotId[], snapshotChunk.chunkIndex, snapshotChunk.offset, snapshotChunk.sha256[] ); - return !queryResult.empty(); + return !queryResult.empty; } - DBSnapshot getSnapshot(long id) - { - auto queryResult = sql( - q{ - SELECT - s.id, - l.name label, - s.sha256, - s.description, - s.created_utc, - s.source_length, - s.algo_min, - s.algo_normal, - s.algo_max, - s.mask_s, - s.mask_l, - s.status - FROM snapshots s - JOIN labels l ON l.id = s.label - WHERE s.id = ? - }, id - ); - - DBSnapshot snapshot; - - if (!queryResult.empty()) - { - auto data = queryResult.front(); - - snapshot.id = data["id"].to!long; - snapshot.label = data["label"].to!string; - snapshot.sha256 = cast(ubyte[]) data["sha256"].dup; - snapshot.description = data["description"].to!string; - snapshot.createdUtc = toDateTime(data["created_utc"].to!string); - snapshot.sourceLength = data["source_length"].to!long; - snapshot.algoMin = data["algo_min"].to!long; - snapshot.algoNormal = data["algo_normal"].to!long; - snapshot.algoMax = data["algo_max"].to!long; - snapshot.maskS = data["mask_s"].to!long; - snapshot.maskL = data["mask_l"].to!long; - snapshot.status = cast(SnapshotStatus) data["status"].to!int; - } - - return snapshot; - } - - DBSnapshot[] getSnapshots(string label) - { - auto queryResult = sql( - q{ - SELECT - s.id, - l.name label, - s.sha256, - s.description, - s.created_utc, - s.source_length, - s.algo_min, - s.algo_normal, - s.algo_max, - s.mask_s, - s.mask_l, - s.status - FROM snapshots s - JOIN labels l ON l.id = s.label AND (length(?) = 0 OR l.name = ?1) - ORDER BY s.created_utc, s.id; - }, label - ); - - DBSnapshot[] snapshots; - - foreach (row; queryResult) - { - DBSnapshot snapshot; - - snapshot.id = row["id"].to!long; - snapshot.label = row["label"].to!string; - snapshot.sha256 = cast(ubyte[]) row["sha256"].dup; - snapshot.description = row["description"].to!string; - snapshot.createdUtc = toDateTime(row["created_utc"].to!string); - snapshot.sourceLength = row["source_length"].to!long; - snapshot.algoMin = row["algo_min"].to!long; - snapshot.algoNormal = row["algo_normal"].to!long; - snapshot.algoMax = row["algo_max"].to!long; - snapshot.maskS = row["mask_s"].to!long; - snapshot.maskL = row["mask_l"].to!long; - snapshot.status = cast(SnapshotStatus) row["status"].to!int; - - snapshots ~= snapshot; - } - - return snapshots; - } - - DBSnapshotChunkData[] getChunks(long snapshotId) + DBSnapshotChunkData[] getChunks(Identifier id) { auto queryResult = sql( q{ @@ -387,7 +606,7 @@ public: JOIN blobs b ON b.sha256 = sc.sha256 WHERE sc.snapshot_id = ? ORDER BY sc.chunk_index - }, snapshotId + }, id[] ); DBSnapshotChunkData[] sdchs; @@ -396,14 +615,22 @@ public: { DBSnapshotChunkData sdch; - sdch.chunkIndex = row["chunk_index"].to!long; - sdch.offset = row["offset"].to!long; - sdch.size = row["size"].to!long; - sdch.content = cast(ubyte[]) row["content"].dup; - sdch.zstd = cast(bool) row["zstd"].to!int; - sdch.zSize = row["z_size"].to!long; - sdch.sha256 = cast(ubyte[]) row["sha256"].dup; - sdch.zSha256 = cast(ubyte[]) row["z_sha256"].dup; + sdch.chunkIndex = row["chunk_index"].as!long; + sdch.offset = row["offset"].as!long; + sdch.size = row["size"].as!long; + + // content может быть NULL + auto contentBlob = cast(ubyte[]) row["content"].as!Blob(Blob.init); + sdch.content = contentBlob.length ? contentBlob.dup : null; + + sdch.zstd = row["zstd"].as!int != 0; + sdch.zSize = row["z_size"].as!long; + + auto sha = cast(ubyte[]) row["sha256"].as!Blob(Blob.init); + if (sha.length) sdch.sha256[] = sha; + + auto zsha = cast(ubyte[]) row["z_sha256"].as!Blob(Blob.init); + if (zsha.length) sdch.zSha256[] = zsha; sdchs ~= sdch; } @@ -411,27 +638,289 @@ public: return sdchs; } - long deleteSnapshot(long id) { - auto queryResult = sql("DELETE FROM snapshots WHERE id = ? RETURNING id", id); - - if (!queryResult.empty()) { - return queryResult.front()["id"].to!long; - } - return 0; - } - - long deleteSnapshot(string label) { + DBSnapshot[] getSnapshots(string file) + { auto queryResult = sql( q{ - DELETE FROM snapshots - WHERE label = (SELECT id FROM labels WHERE name = ?) - RETURNING 1; - }, label); + SELECT + s.id, + f.id file_id, + f.name file_name, + s.sha256, + s.description, + s.created_utc, + s.source_length, + s.uid, + s.ruid, + u.name uid_name, + r.name ruid_name, + p.id process_id, + p.name process_name, + s.algo_min, + s.algo_normal, + s.algo_max, + s.mask_s, + s.mask_l, + s.status + FROM snapshots s + JOIN processes p ON p.id = s.process + JOIN users u ON u.uid = s.uid + JOIN users r ON r.uid = s.ruid + JOIN files f ON f.id = s.file AND (length(?) = 0 OR f.name = ?1) + ORDER BY s.created_utc + }, file + ); - if (!queryResult.empty()) { - return queryResult.length.to!long; + DBSnapshot[] snapshots; + + foreach (row; queryResult) + { + DBSnapshot snapshot; + + snapshot.id = row["id"].as!Blob(Blob.init); + snapshot.file = DBFile( + Identifier(row["file_id"].as!Blob(Blob.init)), + row["file_name"].as!string + ); + snapshot.sha256 = row["sha256"].as!Blob(Blob.init); + snapshot.description = row["description"].as!string(""); // может быть NULL + snapshot.createdUtc = row["created_utc"].as!long; + snapshot.sourceLength = row["source_length"].as!long; + snapshot.algoMin = row["algo_min"].as!long; + snapshot.algoNormal = row["algo_normal"].as!long; + snapshot.algoMax = row["algo_max"].as!long; + snapshot.maskS = row["mask_s"].as!long; + snapshot.maskL = row["mask_l"].as!long; + snapshot.status = cast(SnapshotStatus) row["status"].as!int; + snapshot.uid = row["uid"].as!long; + snapshot.ruid = row["ruid"].as!long; + snapshot.uidName = row["uid_name"].as!string; + snapshot.ruidName = row["ruid_name"].as!string; + snapshot.process = DBProcess( + Identifier(row["process_id"].as!Blob(Blob.init)), + row["process_name"].as!string + ); + + snapshots ~= snapshot; } - return 0; + return snapshots; + } + + DBSnapshot[] getSnapshots(Identifier id) + { + auto queryResult = sql( + q{ + SELECT + s.id, + f.id file_id, + f.name file_name, + s.sha256, + s.description, + s.created_utc, + s.source_length, + s.uid, + s.ruid, + u.name uid_name, + r.name ruid_name, + p.id process_id, + p.name process_name, + s.algo_min, + s.algo_normal, + s.algo_max, + s.mask_s, + s.mask_l, + s.status + FROM snapshots s + JOIN processes p ON p.id = s.process + JOIN users u ON u.uid = s.uid + JOIN users r ON r.uid = s.ruid + JOIN files f ON f.id = s.file + WHERE s.id = ?1 + ORDER BY s.created_utc + }, id[] + ); + + DBSnapshot[] snapshots; + + foreach (row; queryResult) + { + DBSnapshot snapshot; + + snapshot.id = row["id"].as!Blob(Blob.init); + snapshot.file = DBFile( + Identifier(row["file_id"].as!Blob(Blob.init)), + row["file_name"].as!string + ); + snapshot.sha256 = row["sha256"].as!Blob(Blob.init); + snapshot.description = row["description"].as!string(""); + snapshot.createdUtc = row["created_utc"].as!long; + snapshot.sourceLength = row["source_length"].as!long; + snapshot.algoMin = row["algo_min"].as!long; + snapshot.algoNormal = row["algo_normal"].as!long; + snapshot.algoMax = row["algo_max"].as!long; + snapshot.maskS = row["mask_s"].as!long; + snapshot.maskL = row["mask_l"].as!long; + snapshot.status = cast(SnapshotStatus) row["status"].as!int; + snapshot.uid = row["uid"].as!long; + snapshot.ruid = row["ruid"].as!long; + snapshot.uidName = row["uid_name"].as!string; + snapshot.ruidName = row["ruid_name"].as!string; + snapshot.process = DBProcess( + Identifier(row["process_id"].as!Blob(Blob.init)), + row["process_name"].as!string + ); + snapshots ~= snapshot; + } + + return snapshots; + } + + DBSnapshot getSnapshot(Identifier id) + { + auto queryResult = sql( + q{ + SELECT + s.id, + f.id file_id, + f.name file_name, + s.sha256, + s.description, + s.created_utc, + s.source_length, + s.uid, + s.ruid, + u.name uid_name, + r.name ruid_name, + p.id process_id, + p.name process_name, + s.algo_min, + s.algo_normal, + s.algo_max, + s.mask_s, + s.mask_l, + s.status + FROM snapshots s + JOIN processes p ON p.id = s.process + JOIN users u ON u.uid = s.uid + JOIN users r ON r.uid = s.ruid + JOIN files f ON f.id = s.file + WHERE f.id = ?1 + ORDER BY s.created_utc + }, id[] + ); + + DBSnapshot snapshot; + + if (!queryResult.empty) { + auto data = queryResult.front; + + snapshot.id = data["id"].as!Blob(Blob.init); + snapshot.file = DBFile( + Identifier(data["file_id"].as!Blob(Blob.init)), + data["file_name"].as!string + ); + snapshot.sha256 = data["sha256"].as!Blob(Blob.init); + snapshot.description = data["description"].as!string(""); + snapshot.createdUtc = data["created_utc"].as!long; + snapshot.sourceLength = data["source_length"].as!long; + snapshot.algoMin = data["algo_min"].as!long; + snapshot.algoNormal = data["algo_normal"].as!long; + snapshot.algoMax = data["algo_max"].as!long; + snapshot.maskS = data["mask_s"].as!long; + snapshot.maskL = data["mask_l"].as!long; + snapshot.status = cast(SnapshotStatus) data["status"].as!int; + snapshot.uid = data["uid"].as!long; + snapshot.ruid = data["ruid"].as!long; + snapshot.uidName = data["uid_name"].as!string; + snapshot.ruidName = data["ruid_name"].as!string; + snapshot.process = DBProcess( + Identifier(data["process_id"].as!Blob(Blob.init)), + data["process_name"].as!string + ); + } + + return snapshot; + } + + // Функция производит поиск по хешу + // Если младший ниббл является нулевым (0000), то ищем позицию вхождения подстроки в строку + // Иначе ищем по подстроке + DBSnapshot[] findSnapshot(Identifier id) { + auto queryResult = sql( + q{ + SELECT + s.id, + f.id file_id, + f.name file_name, + s.sha256, + s.description, + s.created_utc, + s.source_length, + s.uid, + s.ruid, + u.name uid_name, + r.name ruid_name, + p.id process_id, + p.name process_name, + s.algo_min, + s.algo_normal, + s.algo_max, + s.mask_s, + s.mask_l, + s.status + FROM snapshots s + JOIN processes p ON p.id = s.process + JOIN users u ON u.uid = s.uid + JOIN users r ON r.uid = s.ruid + JOIN files f ON f.id = s.file + WHERE length(?1) BETWEEN 1 AND 16 + AND CASE + WHEN substr(hex(?1), 2 * length(?1), 1) = '0' + THEN instr(hex(s.id), substr(hex(?1), 1, 2 * length(?1) - 1)) > 0 + ELSE substr(s.id, 1, length(?1)) = ?1 + END + }, id[] + ); + + DBSnapshot[] snapshots; + + foreach (row; queryResult) + { + DBSnapshot snapshot; + + snapshot.id = row["id"].as!Blob(Blob.init); + snapshot.file = DBFile( + Identifier(row["file_id"].as!Blob(Blob.init)), + row["file_name"].as!string + ); + snapshot.sha256 = row["sha256"].as!Blob(Blob.init); + snapshot.description = row["description"].as!string(""); + snapshot.createdUtc = row["created_utc"].as!long; + snapshot.sourceLength = row["source_length"].as!long; + snapshot.algoMin = row["algo_min"].as!long; + snapshot.algoNormal = row["algo_normal"].as!long; + snapshot.algoMax = row["algo_max"].as!long; + snapshot.maskS = row["mask_s"].as!long; + snapshot.maskL = row["mask_l"].as!long; + snapshot.status = cast(SnapshotStatus) row["status"].as!int; + snapshot.uid = row["uid"].as!long; + snapshot.ruid = row["ruid"].as!long; + snapshot.uidName = row["uid_name"].as!string; + snapshot.ruidName = row["ruid_name"].as!string; + snapshot.process = DBProcess( + Identifier(row["process_id"].as!Blob(Blob.init)), + row["process_name"].as!string + ); + + snapshots ~= snapshot; + } + + return snapshots; + } + + bool deleteSnapshot(Identifier id) { + auto queryResult = sql("DELETE FROM snapshots WHERE id = ? RETURNING id", id[]); + return !queryResult.empty; } } diff --git a/source/cdcdb/lib/hash.d b/source/cdcdb/lib/hash.d new file mode 100644 index 0000000..ed58887 --- /dev/null +++ b/source/cdcdb/lib/hash.d @@ -0,0 +1,110 @@ +module cdcdb.lib.hash; + +import std.format : format; + +struct Identifier +{ +private: + ubyte[] _data; + + ubyte hxc(ref const char c) const + { + auto lc = cast(char)(c | 32); + if (lc >= '0' && lc <= '9') + return cast(ubyte)(lc - '0'); + if (lc >= 'a' && lc <= 'f') + return cast(ubyte)(10 + lc - 'a'); + throw new Exception("Некорректный символ hex"); + } + + ubyte[] fromHex(ref const string hash) const + { + import std.exception : enforce; + + enforce(hash.length > 0, "Hex-строка не может быть пустой."); + enforce(hash.length <= 32, "Длина hex-строки не должна превышать 32 символа."); + + size_t byteLen = (hash.length + 1) / 2; // Округление вверх для нечётной длины + ubyte[] data = new ubyte[byteLen]; + + foreach (i; 0 .. hash.length / 2) + { + data[i] = cast(ubyte)((hxc(hash[2 * i]) << 4) | hxc(hash[2 * i + 1])); + } + + if (hash.length % 2 != 0) + { + // Для нечётной длины: последний ниббл в старший разряд, младший = 0 + data[$ - 1] = cast(ubyte)(hxc(hash[$ - 1]) << 4); + } + + return data; + } + +public: + // alias _data this; + + this(const string hex) + { + _data = fromHex(hex); + } + + void opAssign(const string hex) + { + _data = fromHex(hex); + } + + this(ubyte[] data) + { + assert(data.length <= 16); + _data = data; + } + + this(immutable(ubyte[]) data) + { + assert(data.length <= 16); + _data = data.dup; + } + + this(ref const ubyte[16] data) + { + assert(data.length <= 16); + _data = data.dup; + } + + void opAssign(immutable(ubyte[]) data) + { + assert(data.length <= 16); + _data = data.dup; + } + + void opAssign(ubyte[] data) + { + assert(data.length <= 16); + _data = data; + } + + string toString() const @safe pure + { + return format("%(%02x%)", _data); + } + + string compact(int size = 4) const @safe pure + { + auto length = _data.length >= size && size > 0 ? size : _data.length; + return format("%(%02x%)", _data[0 .. length]); + } + + ubyte[] data() + { + return _data; + } + + ubyte[] opIndex() { + return _data; + } + + @trusted pure nothrow @nogc @property bool empty() const { + return _data.length == 0; + } +} diff --git a/source/cdcdb/lib/package.d b/source/cdcdb/lib/package.d new file mode 100644 index 0000000..d5aaabf --- /dev/null +++ b/source/cdcdb/lib/package.d @@ -0,0 +1,4 @@ +module cdcdb.lib; + +public import cdcdb.lib.hash; +public import cdcdb.lib.uts; diff --git a/source/cdcdb/lib/uts.d b/source/cdcdb/lib/uts.d new file mode 100644 index 0000000..f699aa6 --- /dev/null +++ b/source/cdcdb/lib/uts.d @@ -0,0 +1,61 @@ +module cdcdb.lib.uts; + +import std.datetime : SysTime, msecs; + +// 2050-01-01 00:00:00 UTC +private enum UTS_LAST_TS = 0x967a7600; // 2524608000L +// Extended +private enum UTS_LAST_TS_EXT = UTS_LAST_TS * 1_000L; + +// Unix Timestamp с миллисекундами +struct UTS +{ +private: + long _ts; + + long calc(SysTime systime) { + long millis = systime.toUnixTime() * 1000L + systime.fracSecs.total!"msecs"; + return millis; + } + +public: + this(long ts) { + assert(ts < UTS_LAST_TS_EXT); + _ts = ts; + } + + this(SysTime systime) { + _ts = calc(systime); + } + + void opAssign(SysTime systime) { + _ts = calc(systime); + } + + void opAssign(long ts) { + assert(ts < UTS_LAST_TS_EXT); + _ts = ts; + } + + string toString() const + { + import std.format : format; + + string formatStr = "%04d-%02d-%02d %02d:%02d:%02d.%03d"; + long seconds = _ts / 1_000L; + long millis = _ts % 1_000L; + auto sysTime = SysTime.fromUnixTime(seconds) + msecs(millis); + return format(formatStr, + sysTime.year, sysTime.month, sysTime.day, + sysTime.hour, sysTime.minute, sysTime.second, + sysTime.fracSecs.total!"msecs"); + } + + @property const(SysTime) sys() const @safe { + return SysTime.fromUnixTime(_ts / 1_000L); + } + + @property long unix() const @safe { + return _ts; + } +} diff --git a/source/cdcdb/package.d b/source/cdcdb/package.d index 167d305..72dc0e6 100644 --- a/source/cdcdb/package.d +++ b/source/cdcdb/package.d @@ -1,4 +1,6 @@ module cdcdb; +public import cdcdb.lib; public import cdcdb.storage; +public import cdcdb.storagefile; public import cdcdb.snapshot; diff --git a/source/cdcdb/scheme.d b/source/cdcdb/scheme.d index 1527ea1..0a70b42 100644 --- a/source/cdcdb/scheme.d +++ b/source/cdcdb/scheme.d @@ -1,19 +1,51 @@ auto _scheme = [ q{ -- ------------------------------------------------------------ - -- Таблица labels + -- Таблица users -- ------------------------------------------------------------ - CREATE TABLE IF NOT EXISTS labels ( - -- идентификатор метки - id INTEGER PRIMARY KEY AUTOINCREMENT, - -- имя метки + CREATE TABLE IF NOT EXISTS users ( + -- Linux UID + uid INTEGER PRIMARY KEY, + -- текстовое представление пользователя name TEXT NOT NULL UNIQUE ) }, q{ - -- Индекс по имени метки - CREATE INDEX IF NOT EXISTS idx_labels_name - ON labels(name) + -- Индекс по имени пользователя + CREATE INDEX IF NOT EXISTS idx_users_name + ON users(name) + }, + q{ + -- ------------------------------------------------------------ + -- Таблица processes + -- ------------------------------------------------------------ + CREATE TABLE IF NOT EXISTS processes ( + -- идентификатор процесса + id BLOB PRIMARY KEY, + -- имя процесса + name TEXT NOT NULL UNIQUE + ) WITHOUT ROWID + }, + q{ + -- Индекс по имени процесса + CREATE INDEX IF NOT EXISTS idx_processes_name + ON processes(name) + }, + q{ + -- ------------------------------------------------------------ + -- Таблица files + -- ------------------------------------------------------------ + CREATE TABLE IF NOT EXISTS files ( + -- идентификатор файла + id BLOB PRIMARY KEY, + -- имя файла + name TEXT NOT NULL UNIQUE + ) WITHOUT ROWID + }, + q{ + -- Индекс по имени файла + CREATE INDEX IF NOT EXISTS idx_files_name + ON files(name) }, q{ -- ------------------------------------------------------------ @@ -21,17 +53,23 @@ auto _scheme = [ -- ------------------------------------------------------------ CREATE TABLE IF NOT EXISTS snapshots ( -- идентификатор снимка - id INTEGER PRIMARY KEY AUTOINCREMENT, - -- метка/название снимка - label INTEGER NOT NULL, + id BLOB PRIMARY KEY, + -- Файл + file BLOB NOT NULL, -- SHA-256 всего файла (BLOB(32)) sha256 BLOB NOT NULL CHECK (length(sha256) = 32), -- Комментарий/описание description TEXT DEFAULT NULL, -- время создания (UTC) - created_utc TEXT NOT NULL DEFAULT (CURRENT_TIMESTAMP), + created_utc INTEGER NOT NULL, -- длина исходного файла в байтах source_length INTEGER NOT NULL, + -- UID пользователя (эффективный) + uid INTEGER NOT NULL, + -- RUID пользователя (реальный) + ruid INTEGER NOT NULL, + -- Процесс + process BLOB NOT NULL, -- FastCDC: минимальный размер чанка algo_min INTEGER NOT NULL, -- FastCDC: целевой размер чанка @@ -45,11 +83,24 @@ auto _scheme = [ -- 0=pending, 1=ready status INTEGER NOT NULL DEFAULT 0 CHECK (status IN (0,1)), - FOREIGN KEY (label) - REFERENCES labels(id) + -- Внешние ключи + FOREIGN KEY (uid) + REFERENCES users(uid) + ON UPDATE RESTRICT + ON DELETE RESTRICT, + FOREIGN KEY (ruid) + REFERENCES users(uid) + ON UPDATE RESTRICT + ON DELETE RESTRICT, + FOREIGN KEY (process) + REFERENCES processes(id) + ON UPDATE RESTRICT + ON DELETE RESTRICT + FOREIGN KEY (file) + REFERENCES files(id) ON UPDATE CASCADE ON DELETE CASCADE - ) + ) WITHOUT ROWID }, q{ -- ------------------------------------------------------------ @@ -67,9 +118,9 @@ auto _scheme = [ -- байты (сжатые при zstd=1, иначе исходные) content BLOB NOT NULL, -- время создания записи (UTC) - created_utc TEXT NOT NULL DEFAULT (CURRENT_TIMESTAMP), + created_utc INTEGER NOT NULL, -- время последней ссылки (UTC) - last_seen_utc TEXT NOT NULL DEFAULT (CURRENT_TIMESTAMP), + last_seen_utc INTEGER NOT NULL, -- число ссылок из snapshot_chunks refcount INTEGER NOT NULL DEFAULT 0, -- 0=нет сжатия, 1=zstd @@ -81,7 +132,7 @@ auto _scheme = [ (zstd = 0 AND length(content) = size) ), CHECK (z_sha256 IS NULL OR length(z_sha256) = 32) - ) + ) WITHOUT ROWID }, q{ -- ------------------------------------------------------------ @@ -89,7 +140,7 @@ auto _scheme = [ -- ------------------------------------------------------------ CREATE TABLE IF NOT EXISTS snapshot_chunks ( -- FK -> snapshots.id - snapshot_id INTEGER NOT NULL, + snapshot_id BLOB NOT NULL, -- порядковый номер чанка в снимке chunk_index INTEGER NOT NULL, -- смещение чанка в исходном файле, байт @@ -105,12 +156,12 @@ auto _scheme = [ REFERENCES blobs(sha256) ON UPDATE RESTRICT ON DELETE RESTRICT - ) + ) WITHOUT ROWID }, q{ - -- Индекс для запросов вида: WHERE label=? AND sha256=? + -- Индекс для запросов вида: WHERE file=? AND sha256=? CREATE INDEX IF NOT EXISTS idx_snapshots_path_sha - ON snapshots(label, sha256) + ON snapshots(file, sha256) }, q{ -- Индекс для обратного поиска использования blob по sha256 @@ -127,7 +178,7 @@ auto _scheme = [ BEGIN UPDATE blobs SET refcount = refcount + 1, - last_seen_utc = CURRENT_TIMESTAMP + last_seen_utc = cast(unixepoch("subsecond") * 1000 as int) WHERE sha256 = NEW.sha256; END }, @@ -162,7 +213,7 @@ auto _scheme = [ UPDATE blobs SET refcount = refcount + 1, - last_seen_utc = CURRENT_TIMESTAMP + last_seen_utc = cast(unixepoch("subsecond") * 1000 as int) WHERE sha256 = NEW.sha256; END }, @@ -235,11 +286,14 @@ auto _scheme = [ FOR EACH ROW WHEN NEW.id IS NOT OLD.id OR - NEW.label IS NOT OLD.label OR + NEW.file IS NOT OLD.file OR NEW.sha256 IS NOT OLD.sha256 OR NEW.description IS NOT OLD.description OR NEW.created_utc IS NOT OLD.created_utc OR NEW.source_length IS NOT OLD.source_length OR + NEW.uid IS NOT OLD.uid OR + NEW.ruid IS NOT OLD.ruid OR + NEW.process IS NOT OLD.process OR NEW.algo_min IS NOT OLD.algo_min OR NEW.algo_normal IS NOT OLD.algo_normal OR NEW.algo_max IS NOT OLD.algo_max OR @@ -272,16 +326,16 @@ auto _scheme = [ }, q{ -- ------------------------------------------------------------ - -- Удаление записи из labels, если удалён последний snapshot + -- Удаление записи из files, если удалён последний snapshot -- ------------------------------------------------------------ - CREATE TRIGGER IF NOT EXISTS trg_snapshots_delete_label + CREATE TRIGGER IF NOT EXISTS trg_snapshots_delete_file AFTER DELETE ON snapshots FOR EACH ROW BEGIN - DELETE FROM labels - WHERE id = OLD.label + DELETE FROM files + WHERE id = OLD.file AND NOT EXISTS ( - SELECT 1 FROM snapshots WHERE label = OLD.label + SELECT 1 FROM snapshots WHERE file = OLD.file ); END; } diff --git a/source/cdcdb/snapshot.d b/source/cdcdb/snapshot.d index 49d6d33..8cd534e 100644 --- a/source/cdcdb/snapshot.d +++ b/source/cdcdb/snapshot.d @@ -1,90 +1,43 @@ module cdcdb.snapshot; import cdcdb.dblite; +import cdcdb.lib; import zstd : uncompress; import std.digest.sha : SHA256, digest; -import std.datetime : DateTime; import std.exception : enforce; +import std.datetime : SysTime; -/** - * Snapshot reader and lifecycle helper. - * - * This class reconstructs full file content from chunked storage persisted - * via `DBLite`, verifies integrity (per-chunk SHA-256 and final file hash), - * and provides a safe way to remove a snapshot record. - * - * Usage: - * --- - * auto s1 = new Snapshot(db, snapshotId); - * auto bytes = s1.data(); // materialize full content in memory - * - * // or stream into a sink to avoid large allocations: - * s1.data((const(ubyte)[] part) { - * // consume part - * }); - * --- - * - * Notes: - * - All integrity checks are enforced; any mismatch throws. - * - `data(void delegate(...))` is preferred for very large files. - */ final class Snapshot { private: DBLite _db; DBSnapshot _snapshot; + // Возвращает исходные байты чанка с учётом возможного сжатия и проверкой хеша. const(ubyte)[] getBytes(const ref DBSnapshotChunkData chunk) { ubyte[] bytes; if (chunk.zstd) { - enforce(chunk.zSize == chunk.content.length, "Compressed chunk size does not match the expected value"); + enforce(chunk.zSize == chunk.content.length, + "Размер сжатого чанка не совпадает с ожидаемым значением"); bytes = cast(ubyte[]) uncompress(chunk.content); } else { bytes = chunk.content.dup; } - enforce(chunk.size == bytes.length, "Original size does not match the expected value"); - enforce(chunk.sha256 == digest!SHA256(bytes), "Chunk hash does not match"); + enforce(chunk.size == bytes.length, "Исходный размер чанка не совпадает с ожидаемым значением"); + enforce(chunk.sha256 == digest!SHA256(bytes), "Хеш чанка не совпадает"); return bytes; } public: - /// Construct a `Snapshot` from an already fetched `DBSnapshot` row. - /// - /// Params: - /// dblite = database handle - /// dbSnapshot = snapshot row (metadata) previously retrieved - this(DBLite dblite, DBSnapshot dbSnapshot) - { - _db = dblite; - _snapshot = dbSnapshot; - } + this(DBLite dblite, DBSnapshot dbSnapshot) { _db = dblite; _snapshot = dbSnapshot; } - /// Construct a `Snapshot` by loading metadata from the database. - /// - /// Params: - /// dblite = database handle - /// idSnapshot = snapshot id to load - this(DBLite dblite, long idSnapshot) - { - _db = dblite; - _snapshot = _db.getSnapshot(idSnapshot); - } - - /// Materialize the full file content in memory. - /// - /// Reassembles all chunks in order, validates each chunk SHA-256 and the - /// final file SHA-256 (`snapshots.sha256`). - /// - /// Returns: full file content as a newly allocated `ubyte[]` - /// - /// Throws: Exception on any integrity check failure ubyte[] data() { auto chunks = _db.getChunks(_snapshot.id); @@ -100,20 +53,11 @@ public: fctx.put(bytes); } - enforce(_snapshot.sha256 == fctx.finish(), "File hash does not match"); + enforce(_snapshot.sha256 == fctx.finish(), "Хеш итогового файла не совпадает"); return content; } - /// Stream the full file content into a caller-provided sink. - /// - /// This variant avoids allocating a single large buffer. Chunks are - /// decoded, verified, and passed to `sink` in order. - /// - /// Params: - /// sink = delegate invoked for each verified chunk (may be called many times) - /// - /// Throws: Exception on any integrity check failure void data(void delegate(const(ubyte)[]) sink) { auto chunks = _db.getChunks(_snapshot.id); @@ -126,81 +70,49 @@ public: fctx.put(bytes); } - enforce(_snapshot.sha256 == fctx.finish(), "File hash does not match"); + enforce(_snapshot.sha256 == fctx.finish(), "Хеш итогового файла не совпадает"); } - /// Remove this snapshot from the database inside a transaction. - /// - /// Starts an IMMEDIATE transaction, deletes the snapshot row, and commits. - /// On any failure it rolls back. - /// - /// Returns: `true` if the snapshot row was deleted, `false` otherwise - /// - /// Note: Does not garbage-collect unreferenced blobs; perform that separately. - bool remove() - { - _db.beginImmediate(); + // ----------------------------- + // Доступ к метаданным снимка + // ----------------------------- - bool ok; - - scope (exit) - { - if (!ok) - _db.rollback(); - } - scope (success) - { - _db.commit(); - } - - long idDeleted = _db.deleteSnapshot(_snapshot.id); - - ok = true; - - return _snapshot.id == idDeleted; - } - - /// Snapshot id (primary key). - @property long id() const nothrow @safe - { - return _snapshot.id; - } - - /// User-defined label. - @property string label() const @safe - { - return _snapshot.label; - } - - /// Creation timestamp (UTC) from the database. - @property DateTime created() const @safe - { - return _snapshot.createdUtc; - } - - /// Original file length in bytes. - @property long length() const nothrow @safe - { - return _snapshot.sourceLength; - } - - /// Expected SHA-256 of the full file (32 raw bytes). - @property ubyte[32] sha256() const nothrow @safe - { - return _snapshot.sha256; - } - - /// Snapshot status as a string (enum to string). - @property string status() const - { - import std.conv : to; - - return _snapshot.status.to!string; - } - - /// Optional human-readable description. - @property string description() const nothrow @safe - { - return _snapshot.description; - } + /// ID снимка (PRIMARY KEY). + @property Identifier id() nothrow @safe { return _snapshot.id; } + /// Имя файла (из таблицы `files`). + @property string file() const nothrow @safe { return _snapshot.file.path; } + /// Время создания (UTC). + @property const(SysTime) created() const @safe { return _snapshot.createdUtc.sys; } + /// Длина исходного файла (байты). + @property long length() const nothrow @safe { return _snapshot.sourceLength; } + /// Ожидаемый SHA-256 всего файла (сырые 32 байта). + @property ubyte[32] sha256() const nothrow @safe { return _snapshot.sha256; } + /// Статус снимка (строкой). + @property string status() const { import std.conv : to; return _snapshot.status.to!string; } + /// Необязательное описание. + @property string description() const nothrow @safe { return _snapshot.description; } + /// FastCDC: минимальный размер чанка. + @property long algoMin() const nothrow @safe { return _snapshot.algoMin; } + /// FastCDC: целевой (нормальный) размер чанка. + @property long algoNormal() const nothrow @safe { return _snapshot.algoNormal; } + /// FastCDC: максимальный размер чанка. + @property long algoMax() const nothrow @safe { return _snapshot.algoMax; } + /// FastCDC: строгая маска. + @property long maskS() const nothrow @safe { return _snapshot.maskS; } + /// FastCDC: слабая маска. + @property long maskL() const nothrow @safe { return _snapshot.maskL; } + /// UID процесса (effective). + @property long uid() const nothrow @safe { return _snapshot.uid; } + /// Real UID процесса. + @property long ruid() const nothrow @safe { return _snapshot.ruid; } + /// Имя пользователя для `uid`. + @property string uidName() const nothrow @safe { return _snapshot.uidName; } + /// Имя пользователя для `ruid`. + @property string ruidName() const nothrow @safe { return _snapshot.ruidName; } + /// Имя процесса (из таблицы `processes`). + @property string process() const nothrow @safe { return _snapshot.process.name; } + /// Удобный флаг: снимок «готов». + @property bool isReady() const nothrow @safe { return _snapshot.status == SnapshotStatus.ready; } + /// Удобный флаг: снимок «в процессе». + @property bool isPending() const nothrow @safe { return _snapshot.status == SnapshotStatus.pending; } } diff --git a/source/cdcdb/storage.d b/source/cdcdb/storage.d index ee7424b..5002057 100644 --- a/source/cdcdb/storage.d +++ b/source/cdcdb/storage.d @@ -1,40 +1,32 @@ module cdcdb.storage; import cdcdb.dblite; -import cdcdb.core; +import cdcdb.storagefile; import cdcdb.snapshot; +import cdcdb.core; +import cdcdb.lib : Identifier; import zstd : compress, Level; -/** - * High-level storage facade: splits data into CDC chunks, stores chunks/blobs - * into SQLite via `DBLite`, links them into snapshots, and returns `Snapshot` - * objects for retrieval and deletion. - * - * Features: - * - FastCDC-based content-defined chunking (configurable sizes/masks) - * - Optional Zstandard compression (level configurable) - * - Idempotent snapshot creation: skips if identical to the latest for label - * - * Typical usage: - * --- - * auto store = new Storage("cdc.sqlite", true, Level.default_); - * store.setupCDC(4096, 8192, 16384, 0x3FFF, 0x03FF); - * - * auto snap = store.newSnapshot("my.txt", data, "initial import"); - * auto bytes = snap.data(); // retrieve - * - * auto removed = store.removeSnapshots("my.txt"); // remove by label - * --- - */ +import std.exception : enforce; + +struct Context +{ + long uid; /// UID процесса (effective). + long ruid; /// Real UID процесса. + string uidName; /// Имя пользователя для UID. + string ruidName; /// Имя пользователя для RUID. + string process; /// Имя процесса. +} + final class Storage { private: - // Database parameters + // Параметры БД DBLite _db; bool _zstd; int _level; - // CDC settings + // Настройки CDC CDC _cdc; size_t _minSize; size_t _normalSize; @@ -42,6 +34,7 @@ private: size_t _maskS; size_t _maskL; + /// Инициализация параметров FastCDC. void initCDC(size_t minSize = 256, size_t normalSize = 512, size_t maxSize = 1024, size_t maskS = 0xFF, size_t maskL = 0x0F) { @@ -50,20 +43,13 @@ private: _maxSize = maxSize; _maskS = maskS; _maskL = maskL; - // CDC holds no dynamically allocated state; reinitialization is safe + // CDC не хранит динамического состояния, переинициализация безопасна _cdc = new CDC(_minSize, _normalSize, _maxSize, _maskS, _maskL); } public: - /// Construct the storage facade and open (or create) the database. - /// - /// Params: - /// database = path to SQLite file - /// zstd = enable Zstandard compression for stored blobs - /// level = Zstd compression level (see `zstd.Level`) - /// busyTimeout = SQLite busy timeout in milliseconds - /// maxRetries = max retries on SQLITE_BUSY/LOCKED errors - this(string database, bool zstd = false, int level = Level.base, size_t busyTimeout = 3000, size_t maxRetries = 3) + this(string database, bool zstd = false, int level = Level.base, + size_t busyTimeout = 3000, size_t maxRetries = 3) { _db = new DBLite(database, busyTimeout, maxRetries); _zstd = zstd; @@ -71,49 +57,29 @@ public: initCDC(); } - /// Reconfigure CDC parameters (takes effect for subsequent snapshots). - /// - /// Params: - /// minSize, normalSize, maxSize, maskS, maskL = FastCDC parameters - void setupCDC(size_t minSize, size_t normalSize, size_t maxSize, size_t maskS, size_t maskL) + void setupCDC(size_t minSize, size_t normalSize, size_t maxSize, + size_t maskS, size_t maskL) { initCDC(minSize, normalSize, maxSize, maskS, maskL); } - /// Create a new snapshot from raw data. - /// - /// - Splits data with FastCDC using current settings. - /// - Optionally compresses chunks with Zstd. - /// - Stores unique blobs and links them to the created snapshot. - /// - If the latest snapshot for `label` already has the same file SHA-256, - /// returns `null` (idempotent). - /// - /// Params: - /// label = user-provided snapshot label (file identifier) - /// data = raw file bytes - /// description = optional human-readable description - /// - /// Returns: a `Snapshot` instance for the created snapshot, or `null` - /// - /// Throws: - /// Exception if `data` is empty or on database/storage errors - Snapshot newSnapshot(string label, const(ubyte)[] data, string description = string.init) + Snapshot newSnapshot(string file, const(ubyte)[] data, Context context, string description = string.init) { - if (data.length == 0) - { - throw new Exception("Data has zero length"); - } + enforce(data.length > 0, "Данные имеют нулевую длину"); + + auto dbFile = _db.getFile(file); import std.digest.sha : SHA256, digest; ubyte[32] sha256 = digest!SHA256(data); - // If the last snapshot for the label matches current content - if (_db.isLast(label, sha256)) + if (dbFile.empty) { + dbFile = _db.addFile(file); + } else if (_db.isLast(dbFile.id, sha256)) { return null; + } _db.beginImmediate(); - bool ok; scope (exit) @@ -126,11 +92,22 @@ public: _db.commit(); } - _db.addLabel(label); + _db.addUser(context.uid, context.uidName); + if (context.uid != context.ruid) + { + _db.addUser(context.ruid, context.ruidName); + } + auto dbProcess = _db.getProcess(context.process); + + if (dbProcess.empty) { + dbProcess = _db.addProcess(context.process); + } + + // Метаданные снимка DBSnapshot dbSnapshot; - dbSnapshot.label = label; + dbSnapshot.file = dbFile; dbSnapshot.sha256 = sha256; dbSnapshot.description = description; dbSnapshot.sourceLength = data.length; @@ -139,18 +116,19 @@ public: dbSnapshot.algoMax = _maxSize; dbSnapshot.maskS = _maskS; dbSnapshot.maskL = _maskL; + dbSnapshot.uid = context.uid; + dbSnapshot.ruid = context.ruid; + dbSnapshot.process = dbProcess; - auto idSnapshot = _db.addSnapshot(dbSnapshot); + enforce(_db.addSnapshot(dbSnapshot), "Не удалось добавить новый снимок в базу данных"); + // Чанки и блобы DBSnapshotChunk dbSnapshotChunk; DBBlob dbBlob; - dbBlob.zstd = _zstd; - // Split into chunks Chunk[] chunks = _cdc.split(data); - // Write chunks to DB foreach (chunk; chunks) { dbBlob.sha256 = chunk.sha256; @@ -158,7 +136,8 @@ public: auto content = data[chunk.offset .. chunk.offset + chunk.size]; - if (_zstd) { + if (_zstd) + { ubyte[] zBytes = compress(content, _level); size_t zSize = zBytes.length; ubyte[32] zHash = digest!SHA256(zBytes); @@ -166,88 +145,107 @@ public: dbBlob.zSize = zSize; dbBlob.zSha256 = zHash; dbBlob.content = zBytes; - } else { + } + else + { dbBlob.content = content.dup; } - // Store/ensure blob _db.addBlob(dbBlob); - dbSnapshotChunk.snapshotId = idSnapshot; + dbSnapshotChunk.snapshotId = dbSnapshot.id; dbSnapshotChunk.chunkIndex = chunk.index; dbSnapshotChunk.offset = chunk.offset; dbSnapshotChunk.sha256 = chunk.sha256; - // Link chunk to snapshot - _db.addSnapshotChunk(dbSnapshotChunk); + enforce(_db.addSnapshotChunk(dbSnapshotChunk), "Не удалось привязать снимок к данным"); } ok = true; - - Snapshot snapshot = new Snapshot(_db, idSnapshot); - - return snapshot; + return new Snapshot(_db, dbSnapshot); } - /// Delete snapshots by label. - /// - /// Params: - /// label = snapshot label - /// - /// Returns: number of deleted snapshots - long removeSnapshots(string label) { - return _db.deleteSnapshot(label); + StorageFile getFile(string path) { + auto dbFile = _db.getFile(path); + if (dbFile.empty) return null; + return new StorageFile(_db, dbFile); } - /// Delete a specific snapshot instance. - /// - /// Params: - /// snapshot = `Snapshot` to remove - /// - /// Returns: `true` on success, `false` otherwise - bool removeSnapshots(Snapshot snapshot) { - return removeSnapshots(snapshot.id); + StorageFile getFile(Identifier id) { + auto dbFile = _db.getFile(id); + if (dbFile.empty) return null; + return new StorageFile(_db, dbFile); } - /// Delete a snapshot by id. - /// - /// Params: - /// idSnapshot = snapshot id - /// - /// Returns: `true` if the row was deleted - bool removeSnapshots(long idSnapshot) { - return _db.deleteSnapshot(idSnapshot) == idSnapshot; - } - - /// Get a `Snapshot` object by id. - /// - /// Params: - /// idSnapshot = snapshot id - /// - /// Returns: `Snapshot` handle (metadata loaded lazily via constructor) - Snapshot getSnapshot(long idSnapshot) { - return new Snapshot(_db, idSnapshot); - } - - /// List snapshots (optionally filtered by label). - /// - /// Params: - /// label = filter by exact label; empty string returns all - /// - /// Returns: array of `Snapshot` handles - Snapshot[] getSnapshots(string label = string.init) { - Snapshot[] snapshots; - - foreach (snapshot; _db.getSnapshots(label)) { - snapshots ~= new Snapshot(_db, snapshot); + StorageFile[] getFiles() { + StorageFile[] storageFiles; + foreach (dbFile; _db.getFiles()) { + storageFiles ~= new StorageFile(_db, dbFile); } + return storageFiles; + } + StorageFile[] findFile(string pattern) { + StorageFile[] storageFiles; + foreach (dbFile; _db.findFile(pattern)) { + storageFiles ~= new StorageFile(_db, dbFile); + } + return storageFiles; + } + + StorageFile[] findFile(Identifier id) { + StorageFile[] storageFiles; + foreach (dbFile; _db.findFile(id)) { + storageFiles ~= new StorageFile(_db, dbFile); + } + return storageFiles; + } + + Snapshot getSnapshot(Identifier id) { + DBSnapshot dbSnapshot = _db.getSnapshot(id); + if (dbSnapshot.empty) + return null; + return new Snapshot(_db, dbSnapshot); + } + + Snapshot[] getSnapshots(Identifier id) { + Snapshot[] snapshots; + foreach (dbSnapshot; _db.getSnapshots(id)) + { + snapshots ~= new Snapshot(_db, dbSnapshot); + } return snapshots; } - /// Library version string. - /// - /// Returns: semantic version of the `cdcdb` library + Snapshot[] getSnapshots(string file) { + Snapshot[] snapshots; + foreach (dbSnapshot; _db.getSnapshots(file)) + { + snapshots ~= new Snapshot(_db, dbSnapshot); + } + return snapshots; + } + + Snapshot[] findSnapshot(Identifier id) { + Snapshot[] snapshots; + foreach (dbSnapshot; _db.findSnapshot(id)) { + snapshots ~= new Snapshot(_db, dbSnapshot); + } + return snapshots; + } + + bool deleteFile(Identifier id) { + return _db.deleteFile(id); + } + + bool deleteFile(string name) { + return _db.deleteFile(name); + } + + bool deleteSnapshot(Identifier id) { + return _db.deleteSnapshot(id); + } + string getVersion() const @safe nothrow { import cdcdb.version_ : cdcdbVersion; diff --git a/source/cdcdb/storagefile.d b/source/cdcdb/storagefile.d new file mode 100644 index 0000000..a2c8101 --- /dev/null +++ b/source/cdcdb/storagefile.d @@ -0,0 +1,25 @@ +module cdcdb.storagefile; + +import cdcdb.snapshot; +import cdcdb.lib; +import cdcdb.dblite; + +final class StorageFile { +private: + DBLite _db; + DBFile _dbfile; + +public: + this(DBLite dblite, DBFile dbfile) { _db = dblite; _dbfile = dbfile; } + + @property ref Identifier id() return { return _dbfile.id; } + @property string name() const nothrow @safe { return _dbfile.path; } + + Snapshot[] snapshots() { + Snapshot[] snapshots; + foreach (dbSnapshot; _db.getSnapshots(_dbfile.id)) { + snapshots ~= new Snapshot(_db, dbSnapshot); + } + return snapshots; + } +} diff --git a/source/cdcdb/version_.d b/source/cdcdb/version_.d index 142c1db..b7cd2d0 100644 --- a/source/cdcdb/version_.d +++ b/source/cdcdb/version_.d @@ -1,3 +1,3 @@ module cdcdb.version_; -enum cdcdbVersion = "0.1.1"; +enum cdcdbVersion = "0.2.0"; diff --git a/test/app.d b/test/app.d index f39639e..821aee9 100644 --- a/test/app.d +++ b/test/app.d @@ -3,11 +3,23 @@ import std.stdio : writeln, File; import std.file : exists, remove, read; import zstd : Level; +import core.thread : Thread, msecs, dur; + void main() { // Создаем временную базу для примера string dbPath = "./bin/example.db"; + if (exists(dbPath)) { remove(dbPath); } + + Context context; + + context.uid = 1000; + context.ruid = 1001; + context.uidName = "user1"; + context.ruidName = "user2"; + context.process = "mcedit"; + // Инициализация Storage с компрессией Zstd auto storage = new Storage(dbPath, true, Level.speed); @@ -19,17 +31,20 @@ void main() ubyte[] data2 = cast(ubyte[]) "Hello, updated cdcdb!".dup; // Создание первого снимка - auto snap1 = storage.newSnapshot("example_file", data1, "Версия 1.0"); + Snapshot snap1 = storage.newSnapshot("example_file", data1, context, "Версия 1.0"); if (snap1) { writeln("Создан снимок с ID: ", snap1.id); - writeln("Метка: ", snap1.label); + writeln("Файл: ", snap1.file); writeln("Размер: ", snap1.length, " байт"); writeln("Статус: ", snap1.status); + writeln("Время: ", snap1.created); } + Thread.sleep( dur!("msecs")( 50 ) ); + // Создание второго снимка (обновление) - auto snap2 = storage.newSnapshot("example_file", data2, "Версия 2.0"); + auto snap2 = storage.newSnapshot("example_file", data2, context, "Версия 2.0"); if (snap2) { writeln("Создан обновленный снимок с ID: ", snap2.id); @@ -56,9 +71,9 @@ void main() writeln("Хэш совпадает: ", lastSnap.sha256 == digest!SHA256(restoredData)); } - // Удаление снимков по метке - long deleted = storage.removeSnapshots("example_file"); - writeln("Удалено снимков: ", deleted); + // Удаление файла + if (storage.deleteFile("example_file")) + writeln("Файл example_file удален."); // Проверка: снимки удалены auto remaining = storage.getSnapshots("example_file"); diff --git a/test/unittest.d b/test/unittest.d deleted file mode 100644 index 15fd694..0000000 --- a/test/unittest.d +++ /dev/null @@ -1,72 +0,0 @@ -import cdcdb; - -import std.file : read, write, remove, exists; -import std.path : buildPath; -import std.digest.sha : digest, SHA256; -import std.exception : assertThrown, assertNotThrown; -import std.datetime : DateTime; -import core.thread : Thread; -import core.time : msecs, seconds; - -unittest -{ - const string dbPath = "./bin/test_cdcdb.db"; - - if (exists(dbPath)) { - remove(dbPath); - } - - // Тест конструктора Storage - auto storage = new Storage(dbPath, true, 22); - - // Тест настройки CDC - storage.setupCDC(128, 256, 512, 0xFF, 0x0F); - - // Тест создания снимка - ubyte[] data1 = cast(ubyte[]) "Hello, World!".dup; - auto snap1 = storage.newSnapshot("test_label", data1, "First snapshot"); - assert(snap1 !is null); - assert(snap1.label == "test_label"); - assert(snap1.length == data1.length); - assert(snap1.sha256 == digest!SHA256(data1)); - assert(snap1.status == "ready"); - assert(snap1.description == "First snapshot"); - - // Тест дубликата (не должен создать новый) - auto snapDup = storage.newSnapshot("test_label", data1); - assert(snapDup is null); - - // Тест изменения данных - ubyte[] data2 = cast(ubyte[]) "Hello, Changed World!".dup; - auto snap2 = storage.newSnapshot("test_label", data2); - assert(snap2 !is null); - assert(snap2.sha256 == digest!SHA256(data2)); - - // Тест восстановления данных - auto restored = snap1.data(); - assert(restored == data1); - bool streamedOk = false; - snap2.data((const(ubyte)[] chunk) { - assert(chunk == data2); // Поскольку маленький файл — один фрагмент - streamedOk = true; - }); - assert(streamedOk); - - // Тест getSnapshots - auto snaps = storage.getSnapshots("test_label"); - assert(snaps.length == 2); - assert(snaps[0].id == snap1.id); - assert(snaps[1].id == snap2.id); - - auto allSnaps = storage.getSnapshots(); - assert(allSnaps.length == 2); - - // Тест удаления - assert(snap1.remove()); - snaps = storage.getSnapshots("test_label"); - assert(snaps.length == 1); - assert(snaps[0].id == snap2.id); - - // Тест пустых данных - assertThrown!Exception(storage.newSnapshot("empty", [])); -}