diff --git a/.kiro/specs/latest-version-calculation/design.md b/.kiro/specs/latest-version-calculation/design.md deleted file mode 100644 index 4f467de..0000000 --- a/.kiro/specs/latest-version-calculation/design.md +++ /dev/null @@ -1,226 +0,0 @@ -# 設計書 - -## 概要 - -この機能は、既存のgenesis追跡機能を活用して、永続化なしで最新バージョンを効率的に計算します。DAG構造を分析し、リーフノード（子を持たないノード）を特定することで、任意のコンテンツの最新バージョンを動的に取得します。 - -## アーキテクチャ - -### 全体構成 - -``` -┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ -│ CLI Layer │ │ Repo Layer │ │ DAG Layer │ -│ │ │ │ │ │ -│ show command │───▶│ latest() │───▶│ calculate_latest│ -│ │ │ │ │ │ -└─────────────────┘ └─────────────────┘ └─────────────────┘ - │ │ - ▼ ▼ - ┌─────────────────┐ ┌─────────────────┐ - │ CRDT State │ │ Node Storage │ - │ │ │ │ - │ get_state() │ │ get_node_map() │ - │ │ │ get() │ - └─────────────────┘ └─────────────────┘ -``` - -### 計算フロー - -1. **Genesis関連ノード取得**: 全ノードからgenesis情報でフィルタ -2. **親子関係分析**: 各ノードの親情報から子を持つノードを特定 -3. **リーフノード特定**: 子を持たないノードを収集 -4. **最新選択**: タイムスタンプで最新のリーフノードを選択 - -## コンポーネントと インターフェース - -### DagGraph の拡張 - -```rust -impl DagGraph -where - S: NodeStorage, - P: serde::Serialize + serde::de::DeserializeOwned, - M: serde::Serialize + serde::de::DeserializeOwned, -{ - /// Genesis IDから最新バージョンを計算 - pub fn calculate_latest(&self, genesis_id: &Cid) -> Result>; - - /// Genesis IDに関連する全ノードを取得 - fn get_all_versions_for_genesis(&self, genesis_id: &Cid) -> Result>; -} -``` - -### Repo の修正 - -```rust -impl Repo { - /// 最新バージョンを取得（毎回計算） - pub fn latest(&self, genesis_id: &Cid) -> Option; - - /// 既存のcommit_operationは変更なし（headsは使わない） - pub fn commit_operation(&mut self, op: Operation) -> Result; -} -``` - -### CLI の拡張 - -```rust -Commands::Show { content_id } => { - // 基本情報表示 - // 最新バージョン情報追加 - // Genesis情報表示 -} -``` - -## データモデル - -### 既存のNode構造（変更なし） - -```rust -pub struct Node { - pub payload: P, - pub parents: Vec, - pub genesis: Option, // ← これを活用 - pub timestamp: u64, - pub metadata: M, -} -``` - -## エラーハンドリング - -### エラーの種類と対応 - -1. **Genesis ID不存在**: `Ok(None)` を返す（正常ケース） -2. **ノード取得エラー**: `GraphError` を伝播 -3. **リーフノードなし**: `GraphError::Internal` （理論上発生しない） - -### エラーハンドリング戦略 - -```rust -pub fn calculate_latest(&self, genesis_id: &Cid) -> Result> { - // Genesis存在確認（存在しない場合はNone） - let versions = self.get_all_versions_for_genesis(genesis_id)?; - if versions.is_empty() { - return Ok(None); - } - - // 実際のエラーのみ伝播 - // ... -} -``` - -## テスト戦略 - -### 単体テスト - -1. **DagGraph::calculate_latest()** - - 単一バージョン（genesis のみ） - - 線形履歴（複数バージョン） - - 分岐履歴（複数リーフ） - - 存在しないgenesis ID - -2. **DagGraph::get_all_versions_for_genesis()** - - Genesis自身の検出 - - 子ノードの検出 - - 無関係ノードの除外 - -3. **Repo::latest()** - - 正常ケース - - エラーケース - - 空の履歴 - -### テストデータ - -```rust -// テスト用のDAG構造例 -// Genesis -> V1 -> V2 -> V3 (linear) -// Genesis -> V1 -> V2a, V2b (branched) -``` - -## 実装の詳細 - -### アルゴリズムの実装 - -```rust -pub fn calculate_latest(&self, genesis_id: &Cid) -> Result> { - // Step 1: Genesis IDに関連する全ノードを取得 - let versions = self.get_all_versions_for_genesis(genesis_id)?; - - if versions.is_empty() { - return Ok(None); - } - - // 単一ノードの場合は即座に返す - if versions.len() == 1 { - return Ok(Some(versions[0])); - } - - // Step 2: 親として参照されているノードを特定 - let mut has_children = HashSet::new(); - - for &node_cid in &versions { - if let Some(node) = self.storage.get(&node_cid)? { - for parent_cid in node.parents() { - if versions.contains(parent_cid) { - has_children.insert(*parent_cid); - } - } - } - } - - // Step 3: リーフノード（子を持たないノード）を収集 - let mut leaf_nodes = Vec::new(); - - for &node_cid in &versions { - if !has_children.contains(&node_cid) { - if let Some(node) = self.storage.get(&node_cid)? { - leaf_nodes.push((node_cid, node.timestamp())); - } - } - } - - // Step 4: 最新のリーフノードを返す - leaf_nodes.sort_by_key(|(_, timestamp)| std::cmp::Reverse(*timestamp)); - Ok(leaf_nodes.first().map(|(cid, _)| *cid)) -} -``` - -### Genesis関連ノード取得の実装 - -```rust -fn get_all_versions_for_genesis(&self, genesis_id: &Cid) -> Result> { - let mut versions = Vec::new(); - let node_map = self.storage.get_node_map()?; - - // 全ノードを確認してgenesis情報でフィルタ - for (cid, _) in node_map { - if let Some(node) = self.storage.get(&cid)? { - // ノード自身がgenesisか、またはgenesisを参照している - if cid == *genesis_id || node.genesis == Some(*genesis_id) { - versions.push(cid); - } - } - } - - Ok(versions) -} -``` - -### パフォーマンス最適化 - -1. **早期リターン**: 単一ノードの場合は即座に返す -2. **効率的なフィルタリング**: genesis情報による事前フィルタ -3. **メモリ効率**: 一時的なデータ構造のみ使用 - -## セキュリティ考慮事項 - -1. **入力検証**: CID形式の検証 -2. **リソース制限**: 大量ノードでのメモリ使用量制限 -3. **エラー情報**: 内部構造を露出しないエラーメッセージ - -## 運用考慮事項 - -1. **ログ出力**: 計算時間とノード数のログ -2. **メトリクス**: パフォーマンス監視用メトリクス -3. **デバッグ**: 計算過程の可視化機能 \ No newline at end of file diff --git a/.kiro/specs/latest-version-calculation/requirements.md b/.kiro/specs/latest-version-calculation/requirements.md deleted file mode 100644 index b2f5622..0000000 --- a/.kiro/specs/latest-version-calculation/requirements.md +++ /dev/null @@ -1,68 +0,0 @@ -# 要件定義書 - -## 概要 - -この機能は、HEADの永続化を必要とせずに、任意のコンテンツの最新バージョンを効率的に取得することを可能にします。ノードに既存のgenesis追跡機能を活用することで、DAG構造を分析し、特定のコンテンツのバージョン履歴内でリーフノード（子を持たないノード）を特定することで、任意のコンテンツの最新バージョンを動的に計算できます。 -a -## 要件 - -### 要件1 - -**ユーザーストーリー:** CRSLライブラリを使用する開発者として、genesis IDによって任意のコンテンツの最新バージョンを取得したい。これにより、バージョン履歴を手動で追跡することなく、最新の状態にアクセスできるようになる。 - -#### 受け入れ基準 - -1. `repo.latest(genesis_id)`を呼び出した時、システムはそのコンテンツの最新バージョンCIDを返すこと -2. genesis IDが存在しない時、システムはエラーを投げることなくNoneを返すこと -3. バージョンが1つしかない（genesisノード）時、システムはgenesis CID自体を返すこと -4. 線形履歴に複数のバージョンがある時、システムはリーフノードのCIDを返すこと - -### 要件2 - -**ユーザーストーリー:** 開発者として、最新バージョンの計算が永続化ストレージなしで動作することを望む。これにより、システムがシンプルに保たれ、追加のストレージ管理が不要になる。 - -#### 受け入れ基準 - -1. アプリケーションが再起動した時、システムは依然として最新バージョンを正しく計算できること -2. 最新バージョンを計算する時、システムは永続的なHEADストレージを必要としないこと -3. 複数のプロセスが同じデータにアクセスする時、それぞれが独立して正しい最新バージョンを計算できること - -### 要件3 - -**ユーザーストーリー:** 開発者として、最新バージョンの計算が効率的であることを望む。これにより、適度なバージョン履歴があってもアプリケーションのパフォーマンスに影響しない。 - -#### 受け入れ基準 - -1. kバージョンを持つコンテンツの最新バージョンを計算する時、アルゴリズムはO(N)時間計算量で完了すること（Nは全ノード数、genesisでフィルタ） -2. 複数のコンテンツがある時、1つのコンテンツの最新バージョン計算は関連のないコンテンツバージョンをスキャンしないこと -3. バージョン履歴が線形の時、この一般的なケースに対して計算が最適化されること - -### 要件4 - -**ユーザーストーリー:** 開発者として、分岐したバージョン履歴の適切な処理を望む。これにより、コンテンツが並行して編集された時にシステムが予測可能に動作する。 - -#### 受け入れ基準 - -1. 複数のリーフノード（分岐）がある時、システムは最新のタイムスタンプを持つものを返すこと -2. 2つのリーフノードが同じタイムスタンプを持つ時、システムは一貫して1つを返すこと（決定的な動作） -3. 最新バージョンを計算する時、システムは親子関係をチェックしてリーフノードを正しく特定すること - -### 要件5 - -**ユーザーストーリー:** CLIユーザーとして、コンテンツを表示する時に最新バージョン情報を見たい。これにより、データの現在の状態を理解できる。 - -#### 受け入れ基準 - -1. `show `コマンドを実行した時、出力に最新バージョンCIDが含まれること -2. コンテンツに複数のバージョンがある時、コマンドは要求されたバージョンと最新バージョンの両方を表示すること -3. 要求されたcontent_idが既に最新バージョンの時、コマンドはこれを明確に示すこと - -### 要件6 - -**ユーザーストーリー:** 開発者として、既存コードとの後方互換性を望む。これにより、現在のアプリケーションが変更なしで動作し続ける。 - -#### 受け入れ基準 - -1. 既存コードが`repo.latest()`を呼び出す時、同じインターフェースで動作し続けること -2. システムに既存のインメモリHEAD情報がある時、パフォーマンスのためのフォールバックとして使用されること -3. メモリベースから計算ベースのアプローチに移行する時、既存の機能は変更されないこと \ No newline at end of file diff --git a/.kiro/specs/latest-version-calculation/tasks.md b/.kiro/specs/latest-version-calculation/tasks.md deleted file mode 100644 index ca54935..0000000 --- a/.kiro/specs/latest-version-calculation/tasks.md +++ /dev/null @@ -1,63 +0,0 @@ -# 実装計画 - -- [ ] 1. DagGraphに最新バージョン計算機能を実装 - - `calculate_latest()`メソッドを追加してgenesis IDから最新バージョンを計算する - - `get_all_versions_for_genesis()`ヘルパーメソッドを実装してgenesis関連ノードを取得する - - リーフノード特定アルゴリズムを実装して子を持たないノードを見つける - - _要件: 1.1, 1.4, 3.1, 4.1, 4.3_ - -- [ ] 2. DagGraphの単体テストを作成 - - 単一バージョン（genesisのみ）のテストケースを作成する - - 線形履歴（複数バージョン）のテストケースを作成する - - 分岐履歴（複数リーフ）のテストケースを作成する - - 存在しないgenesis IDのテストケースを作成する - - _要件: 1.2, 4.1, 4.2_ - -- [ ] 3. Repoレイヤーのlatest()メソッドを更新 - - `latest()`メソッドを計算ベースに変更してDAGから最新バージョンを取得する - - 既存のインターフェースを維持して後方互換性を保つ - - エラーハンドリングを実装してNoneとエラーを適切に処理する - - _要件: 1.1, 2.1, 6.1_ - -- [ ] 4. commit_operationメソッドを更新 - - headsフィールドへの保存を削除して計算ベースに移行する - - 親ノード取得を`latest()`メソッド経由に変更する - - 既存の動作を維持してCreate/Update/Delete操作が正常に動作することを確認する - - _要件: 2.2, 6.3_ - -- [ ] 5. Repoレイヤーの単体テストを作成 - - `latest()`メソッドの正常ケースをテストする - - 存在しないgenesis IDでのNone返却をテストする - - `commit_operation()`の動作確認テストを作成する - - _要件: 1.1, 1.2, 2.3_ - -- [ ] 6. CLIのshowコマンドを拡張 - - 最新バージョンCIDの表示機能を追加する - - Genesis情報の表示機能を追加する - - 要求されたバージョンと最新バージョンの関係を明確に表示する - - _要件: 5.1, 5.2, 5.3_ - -- [ ] 7. CLI統合テストを作成 - - `show`コマンドでの最新バージョン表示をテストする - - 複数バージョンがある場合の表示をテストする - - エラーケースでの適切な表示をテストする - - _要件: 5.1, 5.2, 5.3_ - -- [ ] 8. パフォーマンステストを実装 - - 大量ノード（1000+）での計算時間を測定するテストを作成する - - メモリ使用量を監視するテストを作成する - - 複数コンテンツでの独立性を確認するテストを作成する - - _要件: 3.1, 3.2, 3.3_ - -- [ ] 9. エラーハンドリングの統合テスト - - ノード取得エラー時の適切な伝播をテストする - - Genesis ID不存在時のNone返却をテストする - - 各レイヤーでのエラー処理の一貫性をテストする - - _要件: 1.2, 2.1_ - -- [ ] 10. 全体統合テストとドキュメント更新 - - 全機能の統合動作テストを実行する - - READMEに新機能の使用例を追加する - - APIドキュメントを更新して新しいメソッドを説明する - - パフォーマンス特性をドキュメント化する - - _要件: 6.1, 6.3_ \ No newline at end of file diff --git a/Makefile b/Makefile index 4041a65..7079884 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: help test fmt clippy check clean cli-init cli-create cli-update cli-show cli-history cli-history-from-version cli-genesis demo dev-setup +.PHONY: help test fmt clippy check clean clean-data cli-init cli-create cli-update cli-show cli-history demo dev-setup help: @echo "CRSL Development Commands:" @@ -14,9 +14,7 @@ help: @echo " make cli-create - Create sample content" @echo " make cli-update - Update content (requires GENESIS_ID)" @echo " make cli-show - Show content (requires ID)" - @echo " make cli-history - Show history from genesis (requires GENESIS_ID)" - @echo " make cli-history-from-version - Show history from version (requires VERSION_ID)" - @echo " make cli-genesis - Get genesis from version (requires VERSION_ID)" + @echo " make cli-history - Show history from genesis (requires GENESIS_ID, optional MODE=linear)" @echo " make demo - Run complete demo workflow" @echo " make dev-setup - Setup development environment" @@ -41,6 +39,9 @@ clean-data: rm -rf crsl_data/ rm -rf test_db/ +# Default history mode for CLI targets (tree | linear) +MODE ?= tree + # CLI Commands cli-init: cargo run --example cli -- init @@ -82,33 +83,12 @@ ifndef GENESIS_ID @echo "Error: GENESIS_ID is required" @echo "Usage: make cli-history GENESIS_ID=" @echo "" + @echo "Optional: MODE=linear" @echo "Example:" - @echo " make cli-history GENESIS_ID=QmExample123" - @exit 1 -endif - cargo run --example cli -- history -g $(GENESIS_ID) - -cli-history-from-version: -ifndef VERSION_ID - @echo "Error: VERSION_ID is required" - @echo "Usage: make cli-history-from-version VERSION_ID=" - @echo "" - @echo "Example:" - @echo " make cli-history-from-version VERSION_ID=QmExample123" - @exit 1 -endif - cargo run --example cli -- history-from-version -v $(VERSION_ID) - -cli-genesis: -ifndef VERSION_ID - @echo "Error: VERSION_ID is required" - @echo "Usage: make cli-genesis VERSION_ID=" - @echo "" - @echo "Example:" - @echo " make cli-genesis VERSION_ID=QmExample123" + @echo " make cli-history GENESIS_ID=QmExample123 MODE=linear" @exit 1 endif - cargo run --example cli -- genesis -v $(VERSION_ID) + cargo run --example cli -- history -g $(GENESIS_ID) --mode $(MODE) # Development setup dev-setup: cli-init cli-create @@ -123,70 +103,48 @@ dev-setup: cli-init cli-create # Demo workflow demo: clean-data cli-init - @echo "" - @echo "=== CRSL Version History Demo ===" - @echo "This demo will create one content, update it multiple times, and show all versions with latest verification." - @echo "" - @echo "📝 Step 1: Creating initial content..." - @CONTENT_GENESIS=$$(cargo run --example cli -- create -c "Initial Document v1.0" -a "alice" 2>/dev/null | grep "Content ID:" | awk '{print $$3}'); \ - echo "Created content with Genesis ID: $$CONTENT_GENESIS"; \ - echo ""; \ - echo "🔄 Step 2: Updating content multiple times..."; \ - echo " Updating to v1.1..."; \ - VERSION_1=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Updated Document v1.1 - Added introduction" -a "alice" 2>/dev/null | grep "New Version:" | awk '{print $$3}'); \ - echo " Updating to v1.2..."; \ - VERSION_2=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Updated Document v1.2 - Added API documentation" -a "alice" 2>/dev/null | grep "New Version:" | awk '{print $$3}'); \ - echo " Updating to v1.3..."; \ - VERSION_3=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Updated Document v1.3 - Added deployment guide" -a "alice" 2>/dev/null | grep "New Version:" | awk '{print $$3}'); \ - echo " Updating to v1.4..."; \ - VERSION_4=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Updated Document v1.4 - Added troubleshooting section" -a "alice" 2>/dev/null | grep "New Version:" | awk '{print $$3}'); \ - echo " Updating to v1.5..."; \ - VERSION_5=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Updated Document v1.5 - Final version with complete documentation" -a "alice" 2>/dev/null | grep "New Version:" | awk '{print $$3}'); \ - echo " Content now has 6 versions (including genesis)"; \ - echo ""; \ - echo "📊 Step 3: Displaying complete version history..."; \ - echo ""; \ - echo "=== Complete Version History ==="; \ - cargo run --example cli -- history -g $$CONTENT_GENESIS; \ + @set -e; \ echo ""; \ - echo "🔍 Step 4: Verifying latest version for each version..."; \ + echo "=== CRSL Version History Demo ==="; \ + echo "This demo seeds a branching storyline and inspects it from two perspectives."; \ echo ""; \ - echo "=== Version Verification ==="; \ - echo "Getting version list from history..."; \ - VERSION_LIST=$$(cargo run --example cli -- history -g $$CONTENT_GENESIS 2>/dev/null | grep -E "🌱|📝|✨" | awk '{print $$3}'); \ - echo "Version list: $$VERSION_LIST"; \ + echo "📝 Step 1: Preparing sample history..."; \ + CONTENT_GENESIS=$$(cargo run --example cli -- create -c "Initial draft by Alice" -a "alice" 2>/dev/null | grep "Genesis:" | awk '{print $$2}'); \ + if [ -z "$$CONTENT_GENESIS" ]; then \ + echo " ! Failed to create sample content"; \ + exit 1; \ + fi; \ + echo " > Genesis CID: $$CONTENT_GENESIS"; \ + A1=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Chapter A" -a "alice" 2>/dev/null | grep "Version" | awk '{print $$3}'); \ + echo " > Alice adds Chapter A: $$A1"; \ + B1=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Chapter B" -a "bob" 2>/dev/null | grep "Version" | awk '{print $$3}'); \ + echo " > Bob adds Chapter B (linear): $$B1"; \ + B_BRANCH=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Bob's branch revisited" -a "bob" --parent $$A1 2>/dev/null | grep "New Version" | awk '{print $$3}'); \ + echo " > Bob branches from Chapter A: $$B_BRANCH"; \ + MERGE_TRIGGER=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Merged storyline" -a "carol" 2>/dev/null | grep "Version" | awk '{print $$3}'); \ + echo " > Carol pushes merge-friendly update: $$MERGE_TRIGGER"; \ + AUTO_MERGE=$$(cargo run --example cli -- history -g $$CONTENT_GENESIS --mode linear 2>/dev/null | grep "🔀" | awk '{print $$3}' | head -1); \ + if [ -n "$$AUTO_MERGE" ]; then \ + echo " > 🤖 Auto-merge produced merge node: $$AUTO_MERGE"; \ + else \ + echo " > ⚠️ Auto-merge node not detected"; \ + fi; \ + FINAL=$$(cargo run --example cli -- update -g $$CONTENT_GENESIS -c "Conclusion" -a "alice" 2>/dev/null | grep "Version" | awk '{print $$3}'); \ + echo " > Alice writes conclusion: $$FINAL"; \ echo ""; \ - echo "Checking Genesis (v1.0):"; \ - cargo run --example cli -- show $$CONTENT_GENESIS; \ + echo "📊 Step 2: Inspecting history views..."; \ echo ""; \ - echo "Checking Version 1 (v1.1):"; \ - VERSION_1=$$(echo "$$VERSION_LIST" | head -1); \ - cargo run --example cli -- show $$VERSION_1; \ - echo ""; \ - echo "Checking Version 2 (v1.2):"; \ - VERSION_2=$$(echo "$$VERSION_LIST" | head -2 | tail -1); \ - cargo run --example cli -- show $$VERSION_2; \ - echo ""; \ - echo "Checking Version 3 (v1.3):"; \ - VERSION_3=$$(echo "$$VERSION_LIST" | head -3 | tail -1); \ - cargo run --example cli -- show $$VERSION_3; \ - echo ""; \ - echo "Checking Version 4 (v1.4):"; \ - VERSION_4=$$(echo "$$VERSION_LIST" | head -4 | tail -1); \ - cargo run --example cli -- show $$VERSION_4; \ - echo ""; \ - echo "Checking Version 5 (v1.5):"; \ - VERSION_5=$$(echo "$$VERSION_LIST" | head -5 | tail -1); \ - cargo run --example cli -- show $$VERSION_5; \ + echo "=== Branching History (node list) ==="; \ + cargo run --example cli -- history -g $$CONTENT_GENESIS; \ echo ""; \ - echo "🎯 Step 5: Latest version summary..."; \ + echo "=== Linear Timeline (version list) ==="; \ + cargo run --example cli -- history -g $$CONTENT_GENESIS --mode linear; \ echo ""; \ - echo "Latest version: $$VERSION_5"; \ - echo "Total versions: 6 (1 genesis + 5 updates)"; \ + echo "=== Version CIDs ==="; \ + VERSION_LIST=$$(cargo run --example cli -- history -g $$CONTENT_GENESIS --mode linear 2>/dev/null | grep -E "🌱|🧩|🔀|✨" | awk '{print $$3}'); \ + echo "$$VERSION_LIST" | tr ' ' '\n'; \ echo ""; \ echo "=== Demo completed successfully! ==="; \ - echo "✓ Created 1 content with 6 versions"; \ - echo "✓ Applied 5 sequential updates"; \ - echo "✓ Demonstrated latest version calculation for each version"; \ - echo "✓ Verified that only the last version is marked as latest"; \ - echo ""; \ \ No newline at end of file + echo "✓ Sample storyline created"; \ + echo "✓ Branching nodes and ordered versions displayed"; \ + echo "" \ No newline at end of file diff --git a/examples/cli.rs b/examples/cli.rs index cbb7eae..d103d8f 100644 --- a/examples/cli.rs +++ b/examples/cli.rs @@ -1,5 +1,6 @@ use cid::Cid; -use clap::{Parser, Subcommand}; +use clap::{Parser, Subcommand, ValueEnum}; +use crsl_lib::convergence::metadata::ContentMetadata; use crsl_lib::crdt::{ crdt_state::CrdtState, operation::{Operation, OperationType}, @@ -8,9 +9,16 @@ use crsl_lib::crdt::{ use crsl_lib::dasl::cid::ContentId; use crsl_lib::graph::{dag::DagGraph, storage::LeveldbNodeStorage}; use crsl_lib::repo::Repo; +use crsl_lib::storage::SharedLeveldb; +use std::collections::{HashMap, HashSet}; use std::error::Error; use std::path::{Path, PathBuf}; +type CliRepo = + Repo, LeveldbNodeStorage, String>; + +const DEFAULT_REPO_PATH: &str = "./crsl_data"; + #[derive(clap::Parser, Clone)] struct Cli { #[command(subcommand)] @@ -36,6 +44,8 @@ enum Commands { content: String, #[arg(short, long)] author: Option, + #[arg(long)] + parent: Option, }, Show { content_id: String, @@ -43,14 +53,8 @@ enum Commands { History { #[arg(short, long)] genesis_id: String, - }, - HistoryFromVersion { - #[arg(short, long)] - version_id: String, - }, - Genesis { - #[arg(short, long)] - version_id: String, + #[arg(long, value_enum, default_value_t = HistoryMode::Tree)] + mode: HistoryMode, }, } @@ -60,26 +64,21 @@ fn main() -> Result<(), Box> { match cli.cmd { Commands::Init { path } => { std::fs::create_dir_all(&path)?; - std::fs::create_dir_all(path.join("ops"))?; - std::fs::create_dir_all(path.join("nodes"))?; + std::fs::create_dir_all(path.join("store"))?; std::fs::write(path.join(".crsl"), "")?; - println!("Initialized CRSL repository at {path:?}"); + println!("Initialized CRSL repository at {path:?} (single LevelDB store)"); } other_command => { - let repo_path = Path::new("./crsl_data"); + let repo_path = Path::new(DEFAULT_REPO_PATH); if !repo_path.join(".crsl").exists() { eprintln!("Repository not found. Run 'init' first."); return Ok(()); } - let op_storage = LeveldbStorage::open(repo_path.join("ops"))?; - let node_storage = LeveldbNodeStorage::open(repo_path.join("nodes")); - let state = CrdtState::new(op_storage); - let dag = DagGraph::new(node_storage); - let mut repo = Repo::new(state, dag); + let mut repo = open_repo(repo_path)?; match other_command { Commands::Create { content, author } => { @@ -96,39 +95,48 @@ fn main() -> Result<(), Box> { println!(" Content ID: {cid}"); println!(" Genesis: {version_cid}"); println!(" Version: {version_cid}"); - println!( - "🔍 Debug: Latest head for genesis {}: {:?}", - version_cid, - repo.latest(&version_cid) - ); } Commands::Update { genesis_id, content, author, + parent, } => { - let genesis_cid = Cid::try_from(genesis_id.as_str())?; - let author = author.unwrap_or_else(|| "anonymous".to_string()); + let genesis_cid = Cid::try_from(genesis_id.as_str())?; - let op = Operation::new_with_genesis( - genesis_cid, + let mut op = Operation::new( genesis_cid, OperationType::Update(content.clone()), - author, + author.clone(), ); - let version_cid = repo.commit_operation(op)?; + if let Some(parent) = parent { + let parent_cid = Cid::try_from(parent.as_str())?; + op.parents.push(parent_cid); + println!("📝 Branched update:"); + println!(" Parent Version: {parent_cid}"); + } else { + println!("📝 Updated content:"); + } - println!("📝 Updated content:"); + let version_cid = repo.commit_operation(op)?; println!(" Genesis ID: {genesis_id}"); println!(" New Version: {version_cid}"); + + if let Some(latest) = repo.latest(&genesis_cid) { + if latest == version_cid { + println!(" ✅ This is now the latest head"); + } else { + println!(" ℹ️ Latest head remains: {latest}"); + } + } } Commands::Show { content_id } => { let cid = Cid::try_from(content_id.as_str())?; // First try to get content from CRDT state - let content = repo.state.get_state(&cid, &cid); + let content = repo.state.get_state(&cid); // Determine the genesis ID let genesis_cid = if content.is_some() { @@ -160,7 +168,7 @@ fn main() -> Result<(), Box> { if latest_version == cid { println!(" Latest version: {latest_version} ✅ (this is the latest)"); } else { - println!(" Latest version: {latest_version} ⚠️ (this is not the latest)"); + println!(" Latest version: {latest_version} ⚠️ (not the latest version)"); } } else { println!(" Latest version: Not found"); @@ -179,7 +187,7 @@ fn main() -> Result<(), Box> { if latest_version == cid { println!(" Latest version: {latest_version} ✅ (this is the latest)"); } else { - println!(" Latest version: {latest_version} ⚠️ (this is not the latest)"); + println!(" Latest version: {latest_version} ⚠️ (not the latest version)"); } } else { println!(" Latest version: Not found"); @@ -187,71 +195,198 @@ fn main() -> Result<(), Box> { } } } - Commands::History { genesis_id } => { + Commands::History { genesis_id, mode } => { let genesis_cid = Cid::try_from(genesis_id.as_str())?; + let result = match mode { + HistoryMode::Tree => display_branching_history(&repo, &genesis_cid), + HistoryMode::Linear => display_linear_history(&repo, &genesis_cid), + }; - match repo.get_history(&genesis_cid) { - Ok(history) => { - println!("📜 History for genesis: {genesis_id}"); - if history.is_empty() { - println!(" No history found (genesis only)"); - } else { - for (i, version_cid) in history.iter().enumerate() { - let marker = if i == 0 { - "🌱" - } else if i == history.len() - 1 { - "✨" - } else { - "📝" - }; - println!(" {} {}: {}", marker, i + 1, version_cid); - } - } - } - Err(e) => { - eprintln!("❌ Error getting history: {e}"); - } - } - } - Commands::HistoryFromVersion { version_id } => { - let version_cid = Cid::try_from(version_id.as_str())?; - - match repo.dag.get_history_from_version(&version_cid) { - Ok(history) => { - println!("📜 History from version: {version_id}"); - for (i, version_cid) in history.iter().enumerate() { - let marker = if i == 0 { - "🌱" - } else if i == history.len() - 1 { - "✨" - } else { - "📝" - }; - println!(" {} {}: {}", marker, i + 1, version_cid); - } - } - Err(e) => { - eprintln!("❌ Error getting history from version: {e}"); - } - } - } - Commands::Genesis { version_id } => { - let version_cid = Cid::try_from(version_id.as_str())?; - - match repo.get_genesis(&version_cid) { - Ok(genesis_cid) => { - println!("🌱 Genesis for version: {version_id}"); - println!(" Genesis CID: {genesis_cid}"); - } - Err(e) => { - eprintln!("❌ Error getting genesis: {e}"); - } + if let Err(e) = result { + eprintln!("❌ Error rendering history: {e}"); } } - _ => unreachable!(), + Commands::Init { .. } => unreachable!("init should be handled before repo setup"), } } } Ok(()) } + +fn open_repo(repo_path: &Path) -> Result> { + let shared = SharedLeveldb::open(repo_path.join("store"))?; + let state = CrdtState::new(LeveldbStorage::new(shared.clone())); + let dag = DagGraph::new(LeveldbNodeStorage::new(shared)); + Ok(Repo::new(state, dag)) +} + +#[derive(Copy, Clone, Debug, ValueEnum)] +enum HistoryMode { + Tree, + Linear, +} + +fn display_branching_history(repo: &CliRepo, genesis: &Cid) -> Result<(), Box> { + let adjacency = repo + .branching_history(genesis) + .map_err(Box::::from)?; + println!("📜 Branching history for genesis: {genesis}"); + + let mut visited = HashSet::new(); + let mut counter = 1; + print_branching_node( + repo, + &adjacency, + genesis, + "", + true, + &mut visited, + &mut counter, + )?; + Ok(()) +} + +fn print_branching_node( + repo: &CliRepo, + adjacency: &HashMap>, + current: &Cid, + prefix: &str, + is_last: bool, + visited: &mut HashSet, + counter: &mut usize, +) -> Result<(), crsl_lib::crdt::error::CrdtError> { + if !visited.insert(*current) { + return Ok(()); + } + + let node = repo + .dag + .get_node(current) + .map_err(crsl_lib::crdt::error::CrdtError::Graph)?; + + let (marker, detail) = match node { + Some(ref n) => { + let marker = if n.parents().is_empty() { + "🌱" + } else if n.parents().len() > 1 { + "🔀" + } else { + "🧩" + }; + let summary = clean_payload_summary(n.payload()); + let label = format!("node{}", *counter); + *counter += 1; + (marker, format!("{label}: {current} | {summary}")) + } + None => { + let label = format!("node{}", *counter); + *counter += 1; + ("❓", format!("{label}: {current} (missing)")) + } + }; + + let branch_symbol = if prefix.is_empty() { + "" + } else if is_last { + "└── " + } else { + "├── " + }; + println!("{prefix}{branch_symbol}{marker} {detail}"); + + let mut children: Vec<(Cid, u64)> = adjacency + .get(current) + .cloned() + .unwrap_or_default() + .into_iter() + .map(|cid| { + let ts = repo + .dag + .get_node(&cid) + .map_err(crsl_lib::crdt::error::CrdtError::Graph)? + .map(|n| n.timestamp()) + .unwrap_or(0); + Ok::<(Cid, u64), crsl_lib::crdt::error::CrdtError>((cid, ts)) + }) + .collect::>()?; + + children.sort_by_key(|(_, ts)| *ts); + children.dedup_by(|a, b| a.0 == b.0); + let total = children.len(); + + for (index, (child, _)) in children.into_iter().enumerate() { + let child_is_last = index + 1 == total; + let new_prefix = if prefix.is_empty() { + if is_last { + " ".to_string() + } else { + "│ ".to_string() + } + } else if is_last { + format!("{prefix} ") + } else { + format!("{prefix}│ ") + }; + print_branching_node( + repo, + adjacency, + &child, + &new_prefix, + child_is_last, + visited, + counter, + )?; + } + + Ok(()) +} + +fn display_linear_history(repo: &CliRepo, genesis: &Cid) -> Result<(), Box> { + let mut path = repo + .linear_history(genesis) + .map_err(Box::::from)?; + + path.dedup(); + + if path.is_empty() { + println!("(no timeline entries for genesis {genesis})"); + return Ok(()); + } + + println!("🧭 Timeline for genesis: {genesis}"); + for (index, cid) in path.iter().enumerate() { + let node = repo + .dag + .get_node(cid) + .map_err(crsl_lib::crdt::error::CrdtError::Graph)?; + let (marker, info) = match node { + Some(ref n) => { + let marker = if index == 0 { + "🌱" + } else if n.parents().len() > 1 { + "🔀" + } else if index == path.len() - 1 { + "✨" + } else { + "🧩" + }; + let summary = clean_payload_summary(n.payload()); + (marker, format!("node{}: {cid} | {summary}", index + 1)) + } + None => ("❓", format!("node{}: {cid} (missing)", index + 1)), + }; + println!(" {marker} {info}"); + } + + Ok(()) +} + +fn clean_payload_summary(payload: &str) -> String { + let trimmed = payload.trim(); + if trimmed.len() <= 48 { + trimmed.to_string() + } else { + format!("{}…", &trimmed[..45]) + } +} diff --git a/examples/content_versioning.rs b/examples/content_versioning.rs index 0d90c3a..c245246 100644 --- a/examples/content_versioning.rs +++ b/examples/content_versioning.rs @@ -14,6 +14,7 @@ use crsl_lib::{ storage::LeveldbStorage as OpStore, }, graph::{dag::DagGraph, storage::LeveldbNodeStorage as NodeStorage}, + storage::SharedLeveldb, }; use tempfile::tempdir; @@ -23,8 +24,9 @@ type ContentState = CrdtState; fn main() { let tmp = tempdir().expect("tmp dir"); - let op_store = OpStore::open(tmp.path().join("ops")).unwrap(); - let node_store = NodeStorage::open(tmp.path().join("nodes")); + let shared = SharedLeveldb::open(tmp.path().join("store")).unwrap(); + let op_store = OpStore::new(shared.clone()); + let node_store = NodeStorage::new(shared); let state = ContentState::new(op_store); let mut _dag = DagGraph::<_, Content, ()>::new(node_store); @@ -60,8 +62,7 @@ fn main() { // 2. Update (v2) ← HEAD = v1 // ──────────────────────────────────────────────── // todo: find the latest root_id or maybe get root_id from latest node?? - let op_v2 = Operation::new_with_genesis( - cid.clone(), + let op_v2 = Operation::new( cid.clone(), OperationType::Update("Updated content".into()), "user1".into(), @@ -78,8 +79,7 @@ fn main() { // ──────────────────────────────────────────────── // 3. Update (v3a) ← branch A // ──────────────────────────────────────────────── - let op_v3a = Operation::new_with_genesis( - cid.clone(), + let op_v3a = Operation::new( content_id.clone(), OperationType::Update("Updated content 2".to_string()), "user2".to_string(), @@ -96,8 +96,7 @@ fn main() { // ──────────────────────────────────────────────── // 4. Update (v3b) ← branch B (parent = v2) // ──────────────────────────────────────────────── - let op_v3b = Operation::new_with_genesis( - cid.clone(), + let op_v3b = Operation::new( content_id.clone(), OperationType::Update("Updated content B".into()), "userB".into(), diff --git a/readme.md b/readme.md index 7ce426e..5640caa 100644 --- a/readme.md +++ b/readme.md @@ -24,6 +24,7 @@ use crsl_lib::{ }, graph::{dag::DagGraph, storage::LeveldbNodeStorage as NodeStorage}, repo::Repo, + storage::SharedLeveldb, }; use tempfile::tempdir; use cid::Cid; @@ -34,10 +35,9 @@ struct Content(String); fn main() { // Initialize storage let tmp = tempdir().expect("tmp dir"); - let op_store = OpStore::open(tmp.path().join("ops")).unwrap(); - let node_store = NodeStorage::open(tmp.path().join("nodes")); - let state = CrdtState::new(op_store); - let dag = DagGraph::new(node_store); + let shared = SharedLeveldb::open(tmp.path().join("store")).unwrap(); + let state = CrdtState::new(OpStore::new(shared.clone())); + let dag = DagGraph::new(NodeStorage::new(shared)); let mut repo = Repo::new(state, dag); // Create a content ID (in practice, you'd use a proper CID) @@ -55,8 +55,7 @@ fn main() { let genesis_cid = repo.commit_operation(create_op).unwrap(); // 2. Update content - let update_op = Operation::new_with_genesis( - content_id.clone(), + let update_op = Operation::new( genesis_cid, OperationType::Update(Content("Updated content".to_string())), "user1".to_string(), diff --git a/src/convergence/metadata.rs b/src/convergence/metadata.rs new file mode 100644 index 0000000..8fbd514 --- /dev/null +++ b/src/convergence/metadata.rs @@ -0,0 +1,64 @@ +use serde::{Deserialize, Serialize}; + +/// Built-in and custom convergence policy types. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] +pub enum PolicyType { + /// Last-Write-Wins policy. + Lww, + /// Any non-builtin policy, identified by its name. + Custom(String), +} + +impl From<&str> for PolicyType { + fn from(value: &str) -> Self { + match value { + "lww" => PolicyType::Lww, + other => PolicyType::Custom(other.to_string()), + } + } +} + +impl From for PolicyType { + fn from(value: String) -> Self { + PolicyType::from(value.as_str()) + } +} + +/// Metadata that stores information required for convergence policies. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] +pub struct ContentMetadata { + /// Policy type (e.g. Lww, custom named policy). + /// + /// When this is `None`, it falls back to the default policy (currently Lww). + policy_type: Option, +} + +impl ContentMetadata { + /// Create metadata with the default LWW policy. + pub fn new() -> Self { + Self { policy_type: None } + } + + /// Create metadata that uses the specified policy. + /// + /// This accepts either a concrete `PolicyType` or a string like `"lww"` or `"custom-policy"`. + pub fn with_policy(policy_type: impl Into) -> Self { + Self { + policy_type: Some(policy_type.into()), + } + } + + /// Return the configured policy type name; falls back to `"lww"` when unspecified. + pub fn policy_type(&self) -> &str { + match &self.policy_type { + Some(PolicyType::Lww) | None => "lww", + Some(PolicyType::Custom(name)) => name.as_str(), + } + } +} + +impl Default for ContentMetadata { + fn default() -> Self { + Self::new() + } +} diff --git a/src/convergence/mod.rs b/src/convergence/mod.rs new file mode 100644 index 0000000..533e6d9 --- /dev/null +++ b/src/convergence/mod.rs @@ -0,0 +1,4 @@ +pub mod metadata; +pub mod policies; +pub mod policy; +pub mod resolver; diff --git a/src/convergence/policies/lww.rs b/src/convergence/policies/lww.rs new file mode 100644 index 0000000..dc2892e --- /dev/null +++ b/src/convergence/policies/lww.rs @@ -0,0 +1,71 @@ +use crate::convergence::policy::{MergePolicy, ResolveInput}; + +/// A simple last-write-wins merge policy that selects the node with the +/// greatest timestamp. Ties fall back to the last node in the slice, mimicking +/// stable behaviour on equal timestamps. +#[derive(Debug, Default)] +pub struct LwwMergePolicy; + +impl MergePolicy

for LwwMergePolicy { + fn resolve(&self, nodes: &[ResolveInput

]) -> P { + let winner = nodes + .iter() + .max_by_key(|input| input.timestamp) + .expect("LwwMergePolicy requires at least one candidate node"); + winner.payload.clone() + } + + fn name(&self) -> &str { + "lww" + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::convergence::policy::ResolveInput; + use cid::Cid; + use multihash::Multihash; + + fn create_test_cid(label: &str) -> Cid { + let digest = Multihash::<64>::wrap(0x12, label.as_bytes()).unwrap(); + Cid::new_v1(0x55, digest) + } + + #[test] + fn selects_highest_timestamp() { + let policy = LwwMergePolicy; + let inputs = vec![ + ResolveInput::new(create_test_cid("a"), "older".to_string(), 10), + ResolveInput::new(create_test_cid("b"), "newer".to_string(), 20), + ]; + + let result = policy.resolve(&inputs); + assert_eq!(result, "newer"); + } + + #[test] + fn ties_choose_last_entry() { + let policy = LwwMergePolicy; + let inputs = vec![ + ResolveInput::new(create_test_cid("a"), "first".to_string(), 42), + ResolveInput::new(create_test_cid("b"), "second".to_string(), 42), + ]; + + let result = policy.resolve(&inputs); + assert_eq!(result, "second"); + } + + #[test] + fn selects_highest_timestamp_among_three() { + let policy = LwwMergePolicy; + let inputs = vec![ + ResolveInput::new(create_test_cid("a"), "payload-a".to_string(), 5), + ResolveInput::new(create_test_cid("b"), "payload-b".to_string(), 10), + ResolveInput::new(create_test_cid("c"), "payload-c".to_string(), 8), + ]; + + let result = policy.resolve(&inputs); + assert_eq!(result, "payload-b"); + } +} diff --git a/src/convergence/policies/mod.rs b/src/convergence/policies/mod.rs new file mode 100644 index 0000000..a2c0f6d --- /dev/null +++ b/src/convergence/policies/mod.rs @@ -0,0 +1 @@ +pub mod lww; diff --git a/src/convergence/policy.rs b/src/convergence/policy.rs new file mode 100644 index 0000000..827d105 --- /dev/null +++ b/src/convergence/policy.rs @@ -0,0 +1,28 @@ +use cid::Cid; + +/// Unites metadata about a DAG node that should be considered during merge resolution. +#[derive(Clone, Debug)] +pub struct ResolveInput

{ + pub cid: Cid, + pub payload: P, + pub timestamp: u64, +} + +impl

ResolveInput

{ + pub fn new(cid: Cid, payload: P, timestamp: u64) -> Self { + Self { + cid, + payload, + timestamp, + } + } +} + +/// A merge strategy that produces a converged payload from candidate nodes. +pub trait MergePolicy

: Send + Sync { + /// Resolve competing nodes into a single payload. + fn resolve(&self, nodes: &[ResolveInput

]) -> P; + + /// Return a descriptive name of the policy (e.g. "lww"). + fn name(&self) -> &str; +} diff --git a/src/convergence/resolver.rs b/src/convergence/resolver.rs new file mode 100644 index 0000000..545c124 --- /dev/null +++ b/src/convergence/resolver.rs @@ -0,0 +1,276 @@ +use crate::convergence::policy::{MergePolicy, ResolveInput}; +use crate::crdt::error::{CrdtError, Result as CrdtResult}; +use crate::dasl::node::Node; +use crate::graph::dag::DagGraph; +use crate::graph::storage::NodeStorage; +use cid::Cid; +use std::marker::PhantomData; + +/// Responsible for orchestrating merge operations by delegating +/// DAG traversal and policy selection to dedicated components. +#[derive(Debug, Default, Clone)] +pub struct ConflictResolver { + _marker: PhantomData<(P, M)>, +} + +impl ConflictResolver +where + P: Clone, + M: Clone, +{ + pub fn new() -> Self { + Self { + _marker: PhantomData, + } + } + + pub fn create_merge_node( + &self, + heads: &[Cid], + dag: &DagGraph, + genesis: Cid, + policy: &dyn MergePolicy

, + ) -> CrdtResult> + where + S: NodeStorage, + P: serde::Serialize + for<'de> serde::Deserialize<'de>, + M: serde::Serialize + for<'de> serde::Deserialize<'de>, + { + if heads.is_empty() { + return Err(CrdtError::Internal( + "ConflictResolver requires at least one head to merge".to_string(), + )); + } + + let inputs = self.collect_inputs(heads, dag)?; + let merged_payload = policy.resolve(&inputs); + let metadata = self.merge_metadata(heads, dag)?; + let timestamp = Self::current_timestamp()?; + Ok(Node::new_child( + merged_payload, + heads.to_vec(), + genesis, + timestamp, + metadata, + )) + } + + fn collect_inputs( + &self, + heads: &[Cid], + dag: &DagGraph, + ) -> CrdtResult>> + where + S: NodeStorage, + P: serde::Serialize + for<'de> serde::Deserialize<'de>, + M: serde::Serialize + for<'de> serde::Deserialize<'de>, + { + let mut inputs = Vec::with_capacity(heads.len()); + for &cid in heads { + let node = dag + .get_node(&cid) + .map_err(CrdtError::Graph)? + .ok_or_else(|| CrdtError::Internal(format!("Head node not found: {cid}")))?; + inputs.push(ResolveInput::new( + cid, + node.payload().clone(), + node.timestamp(), + )); + } + Ok(inputs) + } + + fn merge_metadata(&self, heads: &[Cid], dag: &DagGraph) -> CrdtResult + where + S: NodeStorage, + P: serde::Serialize + for<'de> serde::Deserialize<'de>, + M: serde::Serialize + for<'de> serde::Deserialize<'de>, + { + let first_head = heads + .first() + .ok_or_else(|| CrdtError::Internal("No heads provided".to_string()))?; + let node = dag + .get_node(first_head) + .map_err(CrdtError::Graph)? + .ok_or_else(|| CrdtError::Internal(format!("Head node not found: {first_head}")))?; + Ok(node.metadata().clone()) + } + + fn current_timestamp() -> CrdtResult { + use std::time::{SystemTime, UNIX_EPOCH}; + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map_err(|e| CrdtError::Internal(format!("timestamp error: {e}"))) + .map(|duration| duration.as_nanos() as u64) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::convergence::metadata::ContentMetadata; + use crate::convergence::policies::lww::LwwMergePolicy; + use crate::convergence::policy::{MergePolicy, ResolveInput}; + use crate::crdt::error::CrdtError; + use crate::dasl::node::Node; + use crate::graph::error::{GraphError, Result as GraphResult}; + use crate::graph::storage::NodeStorage; + use multihash::Multihash; + use serde::{Deserialize, Serialize}; + use std::cell::RefCell; + use std::collections::HashMap; + use std::rc::Rc; + + #[derive(Clone, Default)] + struct MemoryNodeStorage { + nodes: Rc>>>, + } + + impl MemoryNodeStorage + where + P: Clone + Serialize + for<'de> Deserialize<'de>, + M: Clone + Serialize + for<'de> Deserialize<'de>, + { + fn insert(&self, node: &Node) -> GraphResult<()> { + let cid = node + .content_id() + .map_err(|e| GraphError::NodeOperation(e.to_string()))?; + self.nodes.borrow_mut().insert(cid, node.clone()); + Ok(()) + } + } + + impl NodeStorage for MemoryNodeStorage + where + P: Clone + Serialize + for<'de> Deserialize<'de>, + M: Clone + Serialize + for<'de> Deserialize<'de>, + { + fn get(&self, content_id: &Cid) -> GraphResult>> { + Ok(self.nodes.borrow().get(content_id).cloned()) + } + + fn put(&self, node: &Node) -> GraphResult<()> { + self.insert(node) + } + + fn delete(&self, content_id: &Cid) -> GraphResult<()> { + self.nodes.borrow_mut().remove(content_id); + Ok(()) + } + + fn get_node_map(&self) -> GraphResult>> { + let mut map = HashMap::new(); + for (cid, node) in self.nodes.borrow().iter() { + map.insert(*cid, node.parents().to_vec()); + } + Ok(map) + } + } + + struct AssertingPolicy { + expected: Vec<(Cid, String, u64)>, + result: String, + } + + impl MergePolicy for AssertingPolicy { + fn resolve(&self, nodes: &[ResolveInput]) -> String { + assert_eq!(nodes.len(), self.expected.len()); + for (input, expected) in nodes.iter().zip(&self.expected) { + assert_eq!(input.cid, expected.0); + assert_eq!(input.payload, expected.1); + assert_eq!(input.timestamp, expected.2); + } + self.result.clone() + } + + fn name(&self) -> &str { + "assert" + } + } + + fn create_test_cid(label: &str) -> Cid { + let digest = Multihash::<64>::wrap(0x12, label.as_bytes()).unwrap(); + Cid::new_v1(0x55, digest) + } + + #[test] + fn create_merge_node_merges_heads() { + let storage = MemoryNodeStorage::::default(); + let dag = DagGraph::new(storage.clone()); + + let metadata = ContentMetadata::with_policy("custom"); + let genesis_node = Node::new_genesis("genesis".to_string(), 1, metadata.clone()); + let genesis_cid = genesis_node.content_id().unwrap(); + dag.storage.put(&genesis_node).unwrap(); + + let head_a = Node::new_child( + "payload-a".to_string(), + vec![genesis_cid], + genesis_cid, + 10, + metadata.clone(), + ); + let head_a_cid = head_a.content_id().unwrap(); + dag.storage.put(&head_a).unwrap(); + + let head_b = Node::new_child( + "payload-b".to_string(), + vec![genesis_cid], + genesis_cid, + 20, + metadata.clone(), + ); + let head_b_cid = head_b.content_id().unwrap(); + dag.storage.put(&head_b).unwrap(); + + let policy = AssertingPolicy { + expected: vec![ + (head_a_cid, "payload-a".to_string(), 10), + (head_b_cid, "payload-b".to_string(), 20), + ], + result: "merged".to_string(), + }; + + let resolver = ConflictResolver::::new(); + let merge_node = resolver + .create_merge_node(&[head_a_cid, head_b_cid], &dag, genesis_cid, &policy) + .unwrap(); + + assert_eq!(merge_node.payload(), "merged"); + assert_eq!(merge_node.parents(), &vec![head_a_cid, head_b_cid]); + assert_eq!(merge_node.metadata(), &metadata); + assert_eq!(merge_node.genesis, Some(genesis_cid)); + assert!(merge_node.timestamp() > 0); + } + + #[test] + fn create_merge_node_requires_non_empty_heads() { + let dag = DagGraph::new(MemoryNodeStorage::::default()); + let resolver = ConflictResolver::::new(); + let policy = LwwMergePolicy; + let genesis = create_test_cid("genesis"); + + let result = resolver.create_merge_node(&[], &dag, genesis, &policy); + + assert!(matches!( + result, + Err(CrdtError::Internal(message)) if message.contains("requires at least one head") + )); + } + + #[test] + fn create_merge_node_fails_when_head_missing() { + let dag = DagGraph::new(MemoryNodeStorage::::default()); + let resolver = ConflictResolver::::new(); + let policy = LwwMergePolicy; + let missing_head = create_test_cid("missing-head"); + let genesis = create_test_cid("genesis"); + + let result = resolver.create_merge_node(&[missing_head], &dag, genesis, &policy); + + assert!(matches!( + result, + Err(CrdtError::Internal(message)) if message.contains("Head node not found") + )); + } +} diff --git a/src/crdt/crdt_state.rs b/src/crdt/crdt_state.rs index cac5e00..dab1708 100644 --- a/src/crdt/crdt_state.rs +++ b/src/crdt/crdt_state.rs @@ -4,6 +4,7 @@ use crate::crdt::reducer::Reducer; use crate::crdt::storage::OperationStorage; use std::fmt::Debug; use std::marker::PhantomData; +use ulid::Ulid; /// A generic CRDT state container that manages operations on content. /// /// `CrdtState` provides a high-level interface for applying operations to content @@ -39,6 +40,10 @@ where _marker: PhantomData, } } + + pub fn storage(&self) -> &S { + &self.storage + } /// Applies an operation to the CRDT state without validation. /// /// This method directly saves the operation to storage without checking its validity. @@ -68,12 +73,12 @@ where self.apply(op) } else { Err(CrdtError::Validation(ValidationError::MissingCreate( - format!("No create operation found for target: {:?}", op.target), + format!("No create operation found for genesis: {:?}", op.genesis), ))) } } - pub fn get_state(&self, target: &ContentId, genesis: &ContentId) -> Option { - let ops = self.storage.load_operations(target, genesis).ok()?; + pub fn get_state(&self, genesis: &ContentId) -> Option { + let ops = self.storage.load_operations(genesis).ok()?; R::reduce(&ops) } @@ -81,7 +86,15 @@ where &self, genesis: &ContentId, ) -> Result>> { - self.storage.load_operations_by_genesis(genesis) + self.storage.load_operations(genesis) + } + + pub fn get_operation(&self, op_id: &Ulid) -> Result>> { + self.storage.get_operation(op_id) + } + + pub fn delete_operation(&self, op_id: &Ulid) -> Result<()> { + self.storage.delete_operation(op_id) } /// Validates whether an operation is logically valid to apply. @@ -100,8 +113,8 @@ where /// * `false` - If the operation would violate logical constraints pub fn validate_operation(&self, op: &Operation) -> Result { match &op.kind { - OperationType::Update(_) | OperationType::Delete => { - let ops = self.storage.load_operations(&op.target, &op.genesis)?; + OperationType::Update(_) | OperationType::Delete | OperationType::Merge(_) => { + let ops = self.storage.load_operations(&op.genesis)?; Ok(ops .iter() .any(|o| matches!(o.kind, OperationType::Create(_)))) @@ -124,17 +137,13 @@ mod tests { #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] struct DummyPayload(String); + /// Helper for constructing operations with deterministic timestamps. fn make_op( id: u64, ts: u64, kind: OperationType, ) -> Operation { - let mut op = Operation::new_with_genesis( - DummyContentId(id.to_string()), - DummyContentId(id.to_string()), - kind, - "tester".into(), - ); + let mut op = Operation::new(DummyContentId(id.to_string()), kind, "tester".into()); op.timestamp = ts; op } @@ -151,10 +160,7 @@ mod tests { state.apply(op).unwrap(); assert_eq!( - state.get_state( - &DummyContentId("1".to_string()), - &DummyContentId("1".to_string()) - ), + state.get_state(&DummyContentId("1".to_string())), Some(DummyPayload("A".to_string())) ); } @@ -173,10 +179,7 @@ mod tests { state.apply(op2).unwrap(); assert_eq!( - state.get_state( - &DummyContentId("1".to_string()), - &DummyContentId("1".to_string()) - ), + state.get_state(&DummyContentId("1".to_string())), Some(DummyPayload("B".to_string())) ); } @@ -195,13 +198,7 @@ mod tests { state.apply(op1).unwrap(); state.apply(op2).unwrap(); state.apply(op3).unwrap(); - assert_eq!( - state.get_state( - &DummyContentId("1".to_string()), - &DummyContentId("1".to_string()) - ), - None - ); + assert_eq!(state.get_state(&DummyContentId("1".to_string())), None); } #[test] @@ -234,10 +231,7 @@ mod tests { state.apply_with_validation(op2).unwrap(); assert_eq!( - state.get_state( - &DummyContentId("1".to_string()), - &DummyContentId("1".to_string()) - ), + state.get_state(&DummyContentId("1".to_string())), Some(DummyPayload("B".to_string())) ); } @@ -265,8 +259,7 @@ mod tests { // Simulate an update coming from another genesis (different series) but same target. let fake_genesis = DummyContentId("DIFFERENT".into()); - let update = Operation::new_with_genesis( - DummyContentId("X".into()), + let update = Operation::new( fake_genesis, OperationType::Update(DummyPayload("B".into())), "u1".into(), @@ -275,7 +268,7 @@ mod tests { // Should only get operations with matching genesis, so expect "A" assert_eq!( - state.get_state(&DummyContentId("X".into()), &DummyContentId("X".into())), + state.get_state(&DummyContentId("X".into())), Some(DummyPayload("A".into())) ); } @@ -288,40 +281,32 @@ mod tests { .unwrap(); let state: CrdtState = CrdtState::new(storage); - let target = DummyContentId("X".into()); let primary_genesis = DummyContentId("X".into()); let alt_genesis = DummyContentId("ALT".into()); - let mut primary_create = Operation::new_with_genesis( - target.clone(), + let mut primary_create = Operation::new( primary_genesis.clone(), OperationType::Create(DummyPayload("A".into())), "u1".into(), ); primary_create.timestamp = 100; - let mut alt_create = Operation::new_with_genesis( - target.clone(), + let mut alt_create = Operation::new( alt_genesis.clone(), OperationType::Create(DummyPayload("B".into())), "u2".into(), ); alt_create.timestamp = 150; - let mut alt_update = Operation::new_with_genesis( - target.clone(), + let mut alt_update = Operation::new( alt_genesis.clone(), OperationType::Update(DummyPayload("C".into())), "u2".into(), ); alt_update.timestamp = 300; - let mut primary_delete = Operation::new_with_genesis( - target.clone(), - primary_genesis.clone(), - OperationType::Delete, - "u1".into(), - ); + let mut primary_delete = + Operation::new(primary_genesis.clone(), OperationType::Delete, "u1".into()); primary_delete.timestamp = 400; state.apply(primary_create).unwrap(); @@ -329,10 +314,10 @@ mod tests { state.apply(alt_update.clone()).unwrap(); state.apply(primary_delete).unwrap(); - assert_eq!(state.get_state(&target, &primary_genesis), None); + assert_eq!(state.get_state(&primary_genesis), None); assert_eq!( - state.get_state(&target, &alt_genesis), + state.get_state(&alt_genesis), Some(DummyPayload("C".into())) ); diff --git a/src/crdt/operation.rs b/src/crdt/operation.rs index d4a04c1..4ec622e 100644 --- a/src/crdt/operation.rs +++ b/src/crdt/operation.rs @@ -15,6 +15,7 @@ pub enum OperationKind { Create, Update, Delete, + Merge, } /// Enum representing the type of operation @@ -27,6 +28,7 @@ pub enum OperationType { Create(T), Update(T), Delete, + Merge(T), } /// Helper methods to check the operation type @@ -36,6 +38,7 @@ impl OperationType { OperationType::Create(_) => OperationKind::Create, OperationType::Update(_) => OperationKind::Update, OperationType::Delete => OperationKind::Delete, + OperationType::Merge(_) => OperationKind::Merge, } } } @@ -52,11 +55,12 @@ impl OperationType { #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct Operation { pub id: OperationId, - pub target: ContentId, pub genesis: ContentId, pub kind: OperationType, pub timestamp: Timestamp, pub author: Author, + #[serde(default = "Vec::new")] + pub parents: Vec, } impl Operation @@ -75,42 +79,16 @@ where /// # Returns /// /// A newly created operation object - pub fn new(target: ContentId, kind: OperationType, author: Author) -> Self { + pub fn new(genesis: ContentId, kind: OperationType, author: Author) -> Self { let timestamp = next_monotonic_timestamp(); let id = Ulid::new(); - let genesis = target.clone(); Self { id, - target, genesis, kind, timestamp, author, - } - } - - /// Creates a new operation with a genesis content - /// - /// # Arguments - /// - /// * `target` - ID of the content being operated on - /// * `root_id` - ID of the genesis content - /// * `kind` - Type of operation and its payload - pub fn new_with_genesis( - target: ContentId, - root_id: ContentId, - kind: OperationType, - author: Author, - ) -> Self { - let timestamp = next_monotonic_timestamp(); - let id = Ulid::new(); - Self { - id, - target, - genesis: root_id, - kind, - timestamp, - author, + parents: Vec::new(), } } @@ -129,7 +107,9 @@ where /// or `None` for delete operations pub fn payload(&self) -> Option<&T> { match &self.kind { - OperationType::Create(v) | OperationType::Update(v) => Some(v), + OperationType::Create(v) | OperationType::Update(v) | OperationType::Merge(v) => { + Some(v) + } OperationType::Delete => None, } } @@ -147,42 +127,18 @@ mod tests { #[test] fn test_operation_new_create() { - let target = DummyContentId("test".into()); + let genesis = DummyContentId("test".into()); let payload = DummyPayload("test".into()); let author = "Alice".to_string(); let op = Operation::new( - target.clone(), - OperationType::Create(payload.clone()), - author.clone(), - ); - - assert!(op.id != Ulid::nil()); - assert_eq!(op.target, target); - assert_eq!(op.kind, OperationType::Create(payload.clone())); - assert!(op.timestamp > 0); - assert_eq!(op.author, author); - assert_eq!(op.payload(), Some(&payload)); - assert!(op.is_type(OperationKind::Create)); - assert!(!op.is_type(OperationKind::Update)); - assert!(!op.is_type(OperationKind::Delete)); - } - #[test] - fn test_operation_create_with_genesis() { - let target = DummyContentId("test".into()); - let genesis = DummyContentId("genesis".into()); - let payload = DummyPayload("test".into()); - let author = "Alice".to_string(); - - let op = Operation::new_with_genesis( - target.clone(), genesis.clone(), OperationType::Create(payload.clone()), author.clone(), ); assert!(op.id != Ulid::nil()); - assert_eq!(op.target, target); + assert_eq!(op.genesis, genesis); assert_eq!(op.kind, OperationType::Create(payload.clone())); assert!(op.timestamp > 0); assert_eq!(op.author, author); @@ -190,48 +146,42 @@ mod tests { assert!(op.is_type(OperationKind::Create)); assert!(!op.is_type(OperationKind::Update)); assert!(!op.is_type(OperationKind::Delete)); + assert!(!op.is_type(OperationKind::Merge)); } - #[test] fn test_operation_update() { - let target = DummyContentId("test".into()); let genesis = DummyContentId("genesis".into()); let payload = DummyPayload("updated".into()); let author = "Alice".to_string(); - let op = Operation::new_with_genesis( - target.clone(), + let op = Operation::new( genesis.clone(), OperationType::Update(payload.clone()), - author.clone(), + author, ); assert!(op.id != Ulid::nil()); - assert_eq!(op.target, target); assert_eq!(op.kind, OperationType::Update(payload.clone())); assert!(op.timestamp > 0); - assert_eq!(op.author, author); assert_eq!(op.payload(), Some(&payload)); assert!(op.is_type(OperationKind::Update)); assert!(!op.is_type(OperationKind::Create)); assert!(!op.is_type(OperationKind::Delete)); + assert!(!op.is_type(OperationKind::Merge)); } #[test] fn test_operation_delete() { - let target = DummyContentId("test".into()); let genesis = DummyContentId("genesis".into()); let author = "Alice".to_string(); - let op = Operation::::new_with_genesis( - target.clone(), + let op = Operation::::new( genesis.clone(), OperationType::Delete, author.clone(), ); assert!(op.id != Ulid::nil()); - assert_eq!(op.target, target); assert_eq!(op.kind, OperationType::Delete); assert!(op.timestamp > 0); assert_eq!(op.author, author); @@ -239,4 +189,25 @@ mod tests { assert!(!op.is_type(OperationKind::Create)); assert!(op.is_type(OperationKind::Delete)); } + + #[test] + fn test_operation_merge() { + let genesis = DummyContentId("merge-genesis".into()); + let payload = DummyPayload("merged".into()); + let author = "auto".to_string(); + + let op = Operation::new( + genesis.clone(), + OperationType::Merge(payload.clone()), + author.clone(), + ); + + assert!(op.id != Ulid::nil()); + assert_eq!(op.genesis, genesis); + assert_eq!(op.kind, OperationType::Merge(payload.clone())); + assert!(op.timestamp > 0); + assert_eq!(op.author, author); + assert_eq!(op.payload(), Some(&payload)); + assert!(op.is_type(OperationKind::Merge)); + } } diff --git a/src/crdt/reducer.rs b/src/crdt/reducer.rs index 14d6690..24403cb 100644 --- a/src/crdt/reducer.rs +++ b/src/crdt/reducer.rs @@ -19,7 +19,9 @@ where .then(a.id.to_bytes().cmp(&b.id.to_bytes())) }) .and_then(|op| match &op.kind { - OperationType::Create(v) | OperationType::Update(v) => Some(v.clone()), + OperationType::Create(v) | OperationType::Update(v) | OperationType::Merge(v) => { + Some(v.clone()) + } OperationType::Delete => None, }) } @@ -45,11 +47,11 @@ mod tests { ) -> Operation { Operation { id: Ulid::new(), - target: DummyContentId(id.to_string()), genesis: DummyContentId(id.to_string()), kind, timestamp: ts, author: "test".into(), + parents: Vec::new(), } } @@ -62,11 +64,11 @@ mod tests { let ulid = Ulid::from_string(ulid_str).unwrap(); Operation { id: ulid, - target: DummyContentId(id.to_string()), genesis: DummyContentId(id.to_string()), kind, timestamp: ts, author: "test".into(), + parents: Vec::new(), } } diff --git a/src/crdt/storage.rs b/src/crdt/storage.rs index 5e6182e..42c8409 100644 --- a/src/crdt/storage.rs +++ b/src/crdt/storage.rs @@ -1,50 +1,91 @@ use crate::crdt::error::{CrdtError, Result}; use crate::crdt::operation::Operation; +use crate::storage::{BatchError, LeveldbBatchGuard, SharedLeveldb, SharedLeveldbAccess}; use bincode; -use rusty_leveldb::{LdbIterator, Options, DB as Database}; -use std::cell::RefCell; +use rusty_leveldb::LdbIterator; use std::marker::PhantomData; use std::path::Path; +use std::rc::Rc; use ulid::Ulid; +/// Abstraction over the persistent storage used by `CrdtState`. pub trait OperationStorage { fn save_operation(&self, op: &Operation) -> Result<()>; - fn load_operations( - &self, - target: &ContentId, - genesis: &ContentId, - ) -> Result>>; - fn load_operations_by_genesis( - &self, - genesis: &ContentId, - ) -> Result>>; + fn load_operations(&self, genesis: &ContentId) -> Result>>; fn get_operation(&self, op_id: &Ulid) -> Result>>; + fn delete_operation(&self, op_id: &Ulid) -> Result<()>; + fn begin_batch(&self) -> std::result::Result, BatchError> { + Err(BatchError::Unsupported) + } } +/// LevelDB-backed implementation of [`OperationStorage`]. +#[derive(Clone)] pub struct LeveldbStorage { - db: RefCell, + shared: Rc, _marker: PhantomData<(ContentId, T)>, } impl LeveldbStorage { pub fn open>(path: P) -> Result { - let opts = Options { - create_if_missing: true, - ..Default::default() - }; - let db = Database::open(path, opts).map_err(CrdtError::Storage)?; - Ok(LeveldbStorage { - db: RefCell::new(db), + let shared = SharedLeveldb::open(path).map_err(CrdtError::Storage)?; + Ok(Self::new(shared)) + } + + pub fn new(shared: Rc) -> Self { + Self { + shared, _marker: PhantomData, - }) + } } + /// Builds the LevelDB key prefix used for operations (`0x01` namespace). fn make_key(id: &Ulid) -> Vec { let mut key = Vec::with_capacity(1 + 16); key.push(0x01); key.extend_from_slice(id.to_bytes().as_ref()); key } + + /// Serialises an operation into the binary format persisted in LevelDB. + fn encode_operation(op: &Operation) -> Result> + where + ContentId: serde::Serialize, + T: serde::Serialize, + { + let value = bincode::serde::encode_to_vec(op, bincode::config::standard())?; + Ok(value) + } + + /// Writes value bytes either to the active batch or directly to the DB. + fn put_bytes(&self, key: &[u8], value: &[u8]) -> Result<()> { + if self + .shared + .with_active_batch(|batch| batch.put(key, value)) + .is_none() + { + self.shared.db().borrow_mut().put(key, value)?; + } + Ok(()) + } + + /// Deletes the given key, respecting an active batch if present. + fn delete_key(&self, key: &[u8]) -> Result<()> { + if self + .shared + .with_active_batch(|batch| batch.delete(key)) + .is_none() + { + self.shared.db().borrow_mut().delete(key)?; + } + Ok(()) + } +} + +impl SharedLeveldbAccess for LeveldbStorage { + fn shared_leveldb(&self) -> Option> { + Some(self.shared.clone()) + } } impl OperationStorage for LeveldbStorage @@ -52,59 +93,28 @@ where ContentId: serde::Serialize + for<'de> serde::Deserialize<'de> + PartialEq + std::fmt::Debug, T: serde::Serialize + for<'de> serde::Deserialize<'de> + std::fmt::Debug, { + fn begin_batch(&self) -> std::result::Result, BatchError> { + self.shared.begin_batch() + } + fn save_operation(&self, op: &Operation) -> Result<()> { let key = Self::make_key(&op.id); - let value = bincode::serde::encode_to_vec(op, bincode::config::standard())?; - self.db.borrow_mut().put(&key, &value)?; - Ok(()) + let value = Self::encode_operation(op)?; + self.put_bytes(&key, &value) } - fn load_operations( - &self, - target: &ContentId, - genesis: &ContentId, - ) -> Result>> { + fn load_operations(&self, genesis: &ContentId) -> Result>> { let mut result = Vec::new(); let mut iter = self - .db + .shared + .db() .borrow_mut() .new_iter() .map_err(CrdtError::Storage)?; - // todo: Implement efficient search methods iter.seek_to_first(); - let mut key = Vec::new(); - let mut value = Vec::new(); - - while iter.valid() { - iter.current(&mut key, &mut value); - if let Ok((op, _)) = bincode::serde::decode_from_slice::, _>( - &value, - bincode::config::standard(), - ) { - if op.target == *target && op.genesis == *genesis { - result.push(op); - } - } - iter.advance(); - } - Ok(result) - } - - fn load_operations_by_genesis( - &self, - genesis: &ContentId, - ) -> Result>> { - let mut result = Vec::new(); - let mut iter = self - .db - .borrow_mut() - .new_iter() - .map_err(CrdtError::Storage)?; - iter.seek_to_first(); let mut key = Vec::new(); let mut value = Vec::new(); - while iter.valid() { iter.current(&mut key, &mut value); if let Ok((op, _)) = bincode::serde::decode_from_slice::, _>( @@ -123,7 +133,7 @@ where fn get_operation(&self, op_id: &Ulid) -> Result>> { let key = Self::make_key(op_id); - match self.db.borrow_mut().get(&key) { + match self.shared.db().borrow_mut().get(&key) { Some(raw) => { let (op, _) = bincode::serde::decode_from_slice::, _>( &raw, @@ -134,201 +144,93 @@ where None => Ok(None), } } + + fn delete_operation(&self, op_id: &Ulid) -> Result<()> { + let key = Self::make_key(op_id); + self.delete_key(&key) + } } #[cfg(test)] mod tests { use super::*; - use crate::crdt::operation::{Operation, OperationType}; + use crate::crdt::operation::OperationType; + use crate::storage::SharedLeveldb; use serde::{Deserialize, Serialize}; use tempfile::tempdir; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] - struct DummyContentId(String); + struct DummyContentId(u64); - #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] + #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] struct DummyPayload(String); - fn setup_test_storage() -> ( + fn make_op(id: u64, payload: &str) -> Operation { + Operation::new( + DummyContentId(id), + OperationType::Update(DummyPayload(payload.to_string())), + "tester".into(), + ) + } + + fn setup_storage() -> ( LeveldbStorage, tempfile::TempDir, ) { let dir = tempdir().unwrap(); - let storage = LeveldbStorage::open(dir.path()).unwrap(); - (storage, dir) + let shared = SharedLeveldb::open(dir.path()).unwrap(); + (LeveldbStorage::new(shared), dir) } #[test] - fn test_save_operation() { - let (storage, _dir) = setup_test_storage(); - let target = DummyContentId("test".into()); - let payload = DummyPayload("test".into()); - let author = "Alice".to_string(); - let op = Operation::new( - target.clone(), - OperationType::Create(payload.clone()), - author.clone(), - ); - + fn save_and_load_roundtrip() { + let (storage, _dir) = setup_storage(); + let op = make_op(1, "hello"); storage.save_operation(&op).unwrap(); - let retrieved_op = storage.get_operation(&op.id); - assert!(retrieved_op.is_ok()); - assert_eq!(retrieved_op.unwrap(), Some(op)); + let retrieved = storage + .get_operation(&op.id) + .unwrap() + .expect("operation should exist"); + assert_eq!(retrieved, op); + + let all = storage.load_operations(&DummyContentId(1)).unwrap(); + assert_eq!(all.len(), 1); + assert_eq!(all[0], op); } #[test] - fn test_get_operation() { - let (storage, _dir) = setup_test_storage(); - let target = DummyContentId("test".into()); - let payload = DummyPayload("test".into()); - let author = "Alice".to_string(); - let op = Operation::new( - target.clone(), - OperationType::Create(payload.clone()), - author.clone(), - ); + fn delete_operation_removes_entry() { + let (storage, _dir) = setup_storage(); + let op = make_op(7, "bye"); storage.save_operation(&op).unwrap(); - let retrieved_op = storage.get_operation(&op.id); - - assert!(retrieved_op.is_ok()); - assert_eq!(retrieved_op.unwrap(), Some(op)); + storage.delete_operation(&op.id).unwrap(); + assert!(storage.get_operation(&op.id).unwrap().is_none()); } #[test] - fn test_save_and_get_multiple_operations() { - let (storage, _dir) = setup_test_storage(); - let target = DummyContentId("test".into()); - let payload = DummyPayload("test".into()); - let author = "Alice".to_string(); - let op1 = Operation::new( - target.clone(), - OperationType::Create(payload.clone()), - author.clone(), - ); - let op2 = Operation::new_with_genesis( - target.clone(), - target.clone(), - OperationType::Update(payload.clone()), - author.clone(), - ); - storage.save_operation(&op1).unwrap(); - storage.save_operation(&op2).unwrap(); - - let retrieved_ops = storage.get_operation(&op1.id); - let retrieved_ops2 = storage.get_operation(&op2.id); - - assert!(retrieved_ops.is_ok()); - assert_eq!(retrieved_ops.unwrap(), Some(op1)); - assert!(retrieved_ops2.is_ok()); - assert_eq!(retrieved_ops2.unwrap(), Some(op2)); - } + fn batch_commit_persists_operations() { + let (storage, _dir) = setup_storage(); - #[test] - fn test_load_operations() { - let (storage, _dir) = setup_test_storage(); - let target = DummyContentId("test".into()); - let target2 = DummyContentId("test2".into()); - let genesis = DummyContentId("genesis".into()); - let payload = DummyPayload("test".into()); - let author = "Alice".to_string(); - let op1 = Operation::new( - target.clone(), - OperationType::Create(payload.clone()), - author.clone(), - ); - let op2 = Operation::new_with_genesis( - target2.clone(), - target.clone(), - OperationType::Update(payload.clone()), - author.clone(), - ); - let op3 = Operation::new_with_genesis( - genesis.clone(), - genesis.clone(), - OperationType::Update(payload.clone()), - author.clone(), - ); - storage.save_operation(&op1).unwrap(); - storage.save_operation(&op2).unwrap(); - storage.save_operation(&op3).unwrap(); - - let retrieved_ops = storage.load_operations(&target, &target); - - assert!(retrieved_ops.is_ok()); - let ops = retrieved_ops.unwrap(); - assert_eq!(ops.len(), 1); - assert!(ops.contains(&op1)); - } + let guard = storage.begin_batch().unwrap(); + let op_a = make_op(10, "a"); + let op_b = make_op(10, "b"); - /// Demonstrates that an Update with different genesis is **not** returned when querying by target. - #[test] - fn test_same_target_different_genesis_ignored() { - let (storage, _dir) = setup_test_storage(); - let target = DummyContentId("shared".into()); - let payload = DummyPayload("one".into()); - // Create (genesis = target) - let create = Operation::new( - target.clone(), - OperationType::Create(payload.clone()), - "u1".into(), - ); - storage.save_operation(&create).unwrap(); - - // Update with DIFFERENT genesis but same target - let update = Operation::new_with_genesis( - target.clone(), - DummyContentId("DIFF".into()), - OperationType::Update(DummyPayload("two".into())), - "u1".into(), - ); - storage.save_operation(&update).unwrap(); - - let ops = storage.load_operations(&target, &target).unwrap(); - // Should only get operations with matching genesis - assert_eq!(ops.len(), 1); - assert!(ops.contains(&create)); - } + storage.save_operation(&op_a).unwrap(); + storage.save_operation(&op_b).unwrap(); - #[test] - fn test_load_operations_by_genesis() { - let (storage, _dir) = setup_test_storage(); - let root = DummyContentId("root".into()); - let child_a = DummyContentId("child_a".into()); - let child_b = DummyContentId("child_b".into()); - let other_root = DummyContentId("other_root".into()); - let payload = DummyPayload("payload".into()); - - let create_root = Operation::new( - root.clone(), - OperationType::Create(payload.clone()), - "author".into(), - ); - let update_child_a = Operation::new_with_genesis( - child_a.clone(), - root.clone(), - OperationType::Update(payload.clone()), - "author".into(), - ); - let update_other = Operation::new_with_genesis( - child_b.clone(), - other_root.clone(), - OperationType::Update(payload.clone()), - "author".into(), - ); - - storage.save_operation(&create_root).unwrap(); - storage.save_operation(&update_child_a).unwrap(); - storage.save_operation(&update_other).unwrap(); - - let ops = storage - .load_operations_by_genesis(&root) - .expect("load by genesis should succeed"); - - assert_eq!(ops.len(), 2); - assert!(ops.contains(&create_root)); - assert!(ops.contains(&update_child_a)); - assert!(!ops.contains(&update_other)); + // Operations are not visible before commit. + assert!(storage.get_operation(&op_a.id).unwrap().is_none()); + + guard.commit().unwrap(); + + assert!(storage.get_operation(&op_a.id).unwrap().is_some()); + assert!(storage.get_operation(&op_b.id).unwrap().is_some()); + + let all = storage.load_operations(&DummyContentId(10)).unwrap(); + assert_eq!(all.len(), 2); + assert!(all.contains(&op_a)); + assert!(all.contains(&op_b)); } } diff --git a/src/dasl/node.rs b/src/dasl/node.rs index 9b371fe..7de932c 100644 --- a/src/dasl/node.rs +++ b/src/dasl/node.rs @@ -21,7 +21,7 @@ const RAW_CODE: u64 = 0x55; /// * `payload` - The main content/data of the entry. /// * `parents` - A vector of content ids (Content Identifiers) pointing to parent entries. /// * `genesis` - The genesis CID that this node belongs to (None for genesis nodes, Some(genesis_cid) for child nodes). -/// * `timestamp` - Unix timestamp representing when the entry was created. +/// * `timestamp` - Unix timestamp in nanoseconds representing when the entry was created. /// * `metadata` - Additional information about the entry (e.g., author, tags, or other attributes). #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] #[serde(bound = "P: Serialize + for<'a> Deserialize<'a>, M: Serialize + for<'a> Deserialize<'a>")] diff --git a/src/graph/dag.rs b/src/graph/dag.rs index 587597a..a952ef6 100644 --- a/src/graph/dag.rs +++ b/src/graph/dag.rs @@ -2,7 +2,7 @@ use crate::dasl::node::Node; use crate::graph::error::{GraphError, Result}; use crate::graph::storage::NodeStorage; use cid::Cid; -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use std::marker::PhantomData; use std::time::{SystemTime, UNIX_EPOCH}; @@ -39,108 +39,162 @@ where } } - /// Add an edge to the graph - /// - /// # Arguments - /// - /// * `payload` - The payload - /// * `parents` - The parent content Ids - /// * `metadata` - The metadata - /// - /// # Returns - /// - /// * `Cid` - The content Id of the new node - /// pub fn add_node(&mut self, payload: P, parents: Vec, metadata: M) -> Result { - let timestamp = Self::current_timestamp()?; - let node = Node::new_genesis(payload, timestamp, metadata); - let new_cid = node.content_id()?; - if self.would_create_cycle_with(&new_cid, &parents)? { - return Err(GraphError::CycleDetected); + if parents.is_empty() { + let (cid, node) = self.prepare_genesis_node(payload, metadata)?; + return self.persist_and_cache(cid, node); } - self.storage.put(&node)?; - - // Update cache incrementally for the new node - self.ensure_subgraph_cached(&parents)?; - for &parent in &parents { - self.edges_forward.entry(parent).or_default().push(new_cid); + let mut inferred_genesis: Option = None; + for parent in &parents { + let node = self + .storage + .get(parent)? + .ok_or(GraphError::NodeNotFound(*parent))?; + let candidate = node.genesis.unwrap_or(*parent); + match inferred_genesis { + Some(existing) if existing != candidate => { + return Err(GraphError::InvalidParent(format!( + "parents belong to different genesis series ({existing:?} vs {candidate:?})" + ))); + } + None => inferred_genesis = Some(candidate), + _ => {} + } } - self.edges_forward.entry(new_cid).or_default(); + let genesis = inferred_genesis.ok_or_else(|| { + GraphError::Internal("child node requires at least one parent".to_string()) + })?; - Ok(new_cid) + let (cid, node) = self.prepare_child_node(payload, parents, genesis, metadata)?; + self.persist_and_cache(cid, node) } - /// Add a genesis node (first version of content) - /// - /// # Arguments - /// - /// * `payload` - The payload - /// * `metadata` - The metadata - /// - /// # Returns - /// - /// * `Cid` - The content Id of the new genesis node - /// pub fn add_genesis_node(&mut self, payload: P, metadata: M) -> Result { + let (cid, node) = self.prepare_genesis_node(payload, metadata)?; + self.persist_and_cache(cid, node) + } + + pub fn add_child_node( + &mut self, + payload: P, + parents: Vec, + genesis: Cid, + metadata: M, + ) -> Result { + let (cid, node) = self.prepare_child_node(payload, parents, genesis, metadata)?; + self.persist_and_cache(cid, node) + } + + pub fn prepare_genesis_node(&mut self, payload: P, metadata: M) -> Result<(Cid, Node)> { let timestamp = Self::current_timestamp()?; let node = Node::new_genesis(payload, timestamp, metadata); let cid = node.content_id()?; - - self.storage.put(&node)?; - - // Initialize cache entry for genesis node - self.edges_forward.entry(cid).or_default(); - - Ok(cid) + Ok((cid, node)) } - /// Add a version node (subsequent version of content) - /// - /// # Arguments - /// - /// * `payload` - The payload - /// * `parents` - The parent content Ids - /// * `genesis` - The genesis CID that this node belongs to - /// * `metadata` - The metadata - /// - /// # Returns - /// - /// * `Cid` - The content Id of the new version node - /// - pub fn add_version_node( + pub fn prepare_child_node( &mut self, payload: P, parents: Vec, genesis: Cid, metadata: M, - ) -> Result { + ) -> Result<(Cid, Node)> { let timestamp = Self::current_timestamp()?; let node = Node::new_child(payload, parents.clone(), genesis, timestamp, metadata); let cid = node.content_id()?; - // Use optimized genesis-based cycle detection if self.would_create_cycle_with(&cid, &parents)? { return Err(GraphError::CycleDetected); } + Ok((cid, node)) + } + + /// Persists the prepared node and updates the adjacency cache. + fn persist_and_cache(&mut self, cid: Cid, node: Node) -> Result { self.storage.put(&node)?; + self.register_prepared_node(cid, &node)?; + Ok(cid) + } + + pub fn register_prepared_node(&mut self, cid: Cid, node: &Node) -> Result<()> { + let parents = node.parents(); + if parents.is_empty() { + self.edges_forward.entry(cid).or_default(); + return Ok(()); + } - // Update cache incrementally for the new node - self.ensure_subgraph_cached(&parents)?; - for &parent in &parents { + self.ensure_subgraph_cached(parents)?; + for &parent in parents { self.edges_forward.entry(parent).or_default().push(cid); } self.edges_forward.entry(cid).or_default(); + Ok(()) + } - Ok(cid) + pub fn rollback_pending_node(&mut self, cid: &Cid, parents: &[Cid]) { + if let Some(children) = self.edges_forward.get_mut(cid) { + children.clear(); + } + self.edges_forward.remove(cid); + + for parent in parents { + if let Some(children) = self.edges_forward.get_mut(parent) { + children.retain(|child| child != cid); + } + } + } + + pub fn remove_node(&mut self, cid: &Cid) -> Result<()> { + let node = self + .storage + .get(cid)? + .ok_or(GraphError::NodeNotFound(*cid))?; + + if let Some(children) = self.edges_forward.get(cid) { + if !children.is_empty() { + return Err(GraphError::Internal(format!( + "cannot remove node {cid:?} with existing children" + ))); + } + } + + for parent in node.parents() { + if let Some(children) = self.edges_forward.get_mut(parent) { + children.retain(|child| child != cid); + } + } + + self.edges_forward.remove(cid); + self.storage.delete(cid)?; + + Ok(()) + } + + pub fn get_node(&self, cid: &Cid) -> Result>> { + self.storage.get(cid) + } + + pub fn get_nodes_by_genesis(&self, genesis_id: &Cid) -> Result> { + let mut result = Vec::new(); + let node_map = self.storage.get_node_map()?; + for (cid, _) in node_map { + if let Some(node) = self.storage.get(&cid)? { + if cid == *genesis_id || node.genesis == Some(*genesis_id) { + result.push(cid); + } + } + } + Ok(result) } + /// Returns the current time in nanoseconds since the Unix epoch. fn current_timestamp() -> Result { SystemTime::now() .duration_since(UNIX_EPOCH) .map_err(GraphError::Timestamp) - .map(|d| d.as_secs()) + .map(|d| d.as_nanos() as u64) } /// Check if adding an edge (new node with parents) would create a cycle @@ -164,17 +218,14 @@ where /// Ensure a subgraph is cached for the given parents and their ancestors /// This implements lazy, incremental cache building fn ensure_subgraph_cached(&mut self, parents: &[Cid]) -> Result<()> { - let mut to_process = Vec::new(); - - // First, check which parents need caching - for &parent in parents { - if !self.edges_forward.contains_key(&parent) { - to_process.push(parent); - } - } + let mut to_process: Vec = parents + .iter() + .copied() + .filter(|parent| !self.edges_forward.contains_key(parent)) + .collect(); // Process nodes that aren't cached yet - let mut processed = std::collections::HashSet::new(); + let mut processed = HashSet::new(); while let Some(current) = to_process.pop() { if processed.contains(¤t) || self.edges_forward.contains_key(¤t) { continue; @@ -206,7 +257,7 @@ where return true; } let mut stack = vec![start]; - let mut visited = std::collections::HashSet::new(); + let mut visited = HashSet::new(); while let Some(node) = stack.pop() { if node == target { return true; @@ -229,7 +280,7 @@ where node_map.insert(*new_cid, parents.to_vec()); let mut to_process = parents.to_vec(); - let mut processed = std::collections::HashSet::new(); + let mut processed = HashSet::new(); while let Some(current_cid) = to_process.pop() { if processed.contains(¤t_cid) { @@ -250,8 +301,8 @@ where pub fn detect_cycle_cid(node_map: &HashMap>) -> Result { let graph = Self::build_adjacency_list(node_map); - let mut visited = std::collections::HashSet::new(); - let mut rec_stack = std::collections::HashSet::new(); + let mut visited = HashSet::new(); + let mut rec_stack = HashSet::new(); for node in graph.keys() { if !visited.contains(node) @@ -285,8 +336,8 @@ where fn has_cycle( node: Cid, graph: &HashMap>, - visited: &mut std::collections::HashSet, - rec_stack: &mut std::collections::HashSet, + visited: &mut HashSet, + rec_stack: &mut HashSet, ) -> bool { visited.insert(node); rec_stack.insert(node); @@ -317,48 +368,17 @@ where /// /// * `Cid` - The genesis CID /// - pub fn get_genesis(&self, version_cid: &Cid) -> Result { - match self.storage.get(version_cid)? { + pub fn get_genesis(&self, node_cid: &Cid) -> Result { + match self.storage.get(node_cid)? { Some(node) => match node.genesis { Some(genesis_cid) => Ok(genesis_cid), - None => Ok(*version_cid), + None => Ok(*node_cid), }, - None => Err(GraphError::NodeNotFound(*version_cid)), + None => Err(GraphError::NodeNotFound(*node_cid)), } } - /// Get history from a specific version - /// - /// # Arguments - /// - /// * `version_cid` - The version CID to get history from - /// - /// # Returns - /// - /// * `Vec` - History from oldest to newest - /// - pub fn get_history_from_version(&self, version_cid: &Cid) -> Result> { - let mut history = vec![]; - let mut current = *version_cid; - - loop { - let node = match self.storage.get(¤t)? { - Some(node) => node, - None => return Err(GraphError::NodeNotFound(current)), - }; - history.push(current); - - if node.parents().is_empty() { - break; - } - current = node.parents()[0]; - } - - history.reverse(); - Ok(history) - } - - /// Calculates the latest version CID for a given genesis ID by finding the leaf node(s) with the most recent timestamp. + /// Calculates the latest node CID for a given genesis ID by finding the leaf node(s) with the most recent timestamp. /// /// # Arguments /// @@ -372,29 +392,26 @@ where /// /// Returns an error if node retrieval fails or an internal error occurs. pub fn calculate_latest(&self, genesis_id: &Cid) -> Result> { - let versions = self.get_all_versions_for_genesis(genesis_id)?; - if versions.is_empty() { + let nodes = self.get_nodes_by_genesis(genesis_id)?; + if nodes.is_empty() { return Ok(None); } - if versions.len() == 1 { - return Ok(Some(versions[0])); + if nodes.len() == 1 { + return Ok(Some(nodes[0])); } - let has_children = self.collect_nodes_with_children(&versions)?; - let mut leaf_nodes = self.collect_leaf_nodes(&versions, &has_children)?; + let has_children = self.collect_nodes_with_children(&nodes)?; + let mut leaf_nodes = self.collect_leaf_nodes(&nodes, &has_children)?; leaf_nodes.sort_by_key(|(_, timestamp)| std::cmp::Reverse(*timestamp)); Ok(leaf_nodes.first().map(|(cid, _)| *cid)) } // Returns the set of nodes (CIDs) that are referenced as parents (i.e., nodes that have children) among the given versions. - fn collect_nodes_with_children( - &self, - versions: &[Cid], - ) -> Result> { - let mut has_children = std::collections::HashSet::new(); - for &node_cid in versions { + fn collect_nodes_with_children(&self, nodes: &[Cid]) -> Result> { + let mut has_children = HashSet::new(); + for &node_cid in nodes { if let Some(node) = self.storage.get(&node_cid)? { for parent_cid in node.parents() { - if versions.contains(parent_cid) { + if nodes.contains(parent_cid) { has_children.insert(*parent_cid); } } @@ -406,11 +423,11 @@ where // Returns a list of leaf nodes (nodes without children) and their timestamps among the given versions. fn collect_leaf_nodes( &self, - versions: &[Cid], - has_children: &std::collections::HashSet, + nodes: &[Cid], + has_children: &HashSet, ) -> Result> { let mut leaf_nodes = Vec::new(); - for &node_cid in versions { + for &node_cid in nodes { if !has_children.contains(&node_cid) { if let Some(node) = self.storage.get(&node_cid)? { leaf_nodes.push((node_cid, node.timestamp())); @@ -419,27 +436,15 @@ where } Ok(leaf_nodes) } - - // Collects all CIDs of nodes related to the given genesis ID. - fn get_all_versions_for_genesis(&self, genesis_id: &Cid) -> Result> { - let mut versions = Vec::new(); - let node_map = self.storage.get_node_map()?; - for (cid, _) in node_map { - if let Some(node) = self.storage.get(&cid)? { - if cid == *genesis_id || node.genesis == Some(*genesis_id) { - versions.push(cid); - } - } - } - Ok(versions) - } } #[cfg(test)] mod tests { use super::*; + use crate::graph::storage::LeveldbNodeStorage; use std::cell::RefCell; use std::collections::BTreeMap; + use tempfile::tempdir; type TestDag = DagGraph>; @@ -735,7 +740,7 @@ mod tests { } #[test] - fn test_latest_head() { + fn test_calculate_latest_basic() { let cid_a = create_test_content_id(b"node_a"); let cid_b = create_test_content_id(b"node_b"); @@ -759,19 +764,19 @@ mod tests { } #[test] - fn test_add_version_node() { + fn test_add_child_node() { let mut dag = DagGraph::new(MockStorage::new()); let genesis_cid = dag.add_genesis_node("genesis".to_string(), ()).unwrap(); - let version_cid = dag - .add_version_node("version".to_string(), vec![genesis_cid], genesis_cid, ()) + let child_cid = dag + .add_child_node("child".to_string(), vec![genesis_cid], genesis_cid, ()) .unwrap(); let latest = dag.calculate_latest(&genesis_cid).unwrap(); - assert_eq!(latest, Some(version_cid)); + assert_eq!(latest, Some(child_cid)); } #[test] - fn test_empty_latest_head() { + fn test_calculate_latest_empty() { let dag = TestDag::new(MockStorage::new()); let cid_a = create_test_content_id(b"node_a"); @@ -889,60 +894,6 @@ mod tests { assert!(result.is_err()); } - #[test] - fn test_get_history_from_version_simple_path() { - let mut storage = MockStorage::new(); - let cid_a = create_test_content_id(b"node_a"); - let cid_b = create_test_content_id(b"node_b"); - let cid_c = create_test_content_id(b"node_c"); - storage.setup_graph(&[(cid_a, cid_b), (cid_b, cid_c)]); - let dag = DagGraph::>::new(storage); - - let history = dag.get_history_from_version(&cid_c).unwrap(); - assert_eq!(history, vec![cid_a, cid_b, cid_c]); - } - - #[test] - fn test_get_history_from_version_genesis_only() { - let storage = MockStorage::new(); - let genesis_cid = create_test_content_id(b"genesis"); - storage.edges.borrow_mut().entry(genesis_cid).or_default(); - let dag = DagGraph::>::new(storage); - - let history = dag.get_history_from_version(&genesis_cid).unwrap(); - assert_eq!(history, vec![genesis_cid]); - } - - #[test] - fn test_get_history_from_version_long_path() { - let mut storage = MockStorage::new(); - let cid_a = create_test_content_id(b"node_a"); - let cid_b = create_test_content_id(b"node_b"); - let cid_c = create_test_content_id(b"node_c"); - let cid_d = create_test_content_id(b"node_d"); - let cid_e = create_test_content_id(b"node_e"); - storage.setup_graph(&[ - (cid_a, cid_b), - (cid_b, cid_c), - (cid_c, cid_d), - (cid_d, cid_e), - ]); - let dag = DagGraph::>::new(storage); - - let history = dag.get_history_from_version(&cid_e).unwrap(); - assert_eq!(history, vec![cid_a, cid_b, cid_c, cid_d, cid_e]); - } - - #[test] - fn test_get_history_from_version_node_not_found() { - let storage = MockStorage::new(); - let dag = DagGraph::>::new(storage); - let non_existent_cid = create_test_content_id(b"non_existent"); - - let result = dag.get_history_from_version(&non_existent_cid); - assert!(result.is_err()); - } - #[test] fn test_calculate_latest_genesis_only() { let storage = MockStorage::new(); @@ -989,24 +940,24 @@ mod tests { } #[test] - fn test_get_all_versions_genesis_only() { + fn test_get_nodes_by_genesis_genesis_only() { let storage = MockStorage::new(); let genesis_cid = create_test_content_id(b"genesis"); storage.edges.borrow_mut().entry(genesis_cid).or_default(); let dag = DagGraph::>::new(storage); - let result = dag.get_all_versions_for_genesis(&genesis_cid).unwrap(); + let result = dag.get_nodes_by_genesis(&genesis_cid).unwrap(); assert_eq!(result, vec![genesis_cid]); } #[test] - fn test_get_all_versions_with_children() { + fn test_get_nodes_by_genesis_with_children() { let mut storage = MockStorage::new(); let genesis_cid = create_test_content_id(b"genesis"); let v1_cid = create_test_content_id(b"v1"); let v2_cid = create_test_content_id(b"v2"); storage.setup_graph(&[(genesis_cid, v1_cid), (v1_cid, v2_cid)]); let dag = DagGraph::>::new(storage); - let mut result = dag.get_all_versions_for_genesis(&genesis_cid).unwrap(); + let mut result = dag.get_nodes_by_genesis(&genesis_cid).unwrap(); result.sort(); let mut expected = vec![genesis_cid, v1_cid, v2_cid]; expected.sort(); @@ -1014,7 +965,7 @@ mod tests { } #[test] - fn test_get_all_versions_excludes_unrelated() { + fn test_get_nodes_by_genesis_excludes_unrelated() { let mut storage = MockStorage::new(); let genesis1_cid = create_test_content_id(b"genesis1"); let v1_cid = create_test_content_id(b"v1"); @@ -1022,7 +973,7 @@ mod tests { storage.setup_graph(&[(genesis1_cid, v1_cid)]); storage.edges.borrow_mut().entry(unrelated_cid).or_default(); let dag = DagGraph::>::new(storage); - let mut result = dag.get_all_versions_for_genesis(&genesis1_cid).unwrap(); + let mut result = dag.get_nodes_by_genesis(&genesis1_cid).unwrap(); result.sort(); let mut expected = vec![genesis1_cid, v1_cid]; expected.sort(); @@ -1030,4 +981,74 @@ mod tests { // unrelated_cid should not be included assert!(!result.contains(&unrelated_cid)); } + + #[test] + fn test_remove_node_without_children() { + let temp_dir = tempdir().unwrap(); + let storage = LeveldbNodeStorage::>::open(temp_dir.path()); + let mut dag = DagGraph::new(storage); + + let genesis = dag + .add_genesis_node("payload".to_string(), BTreeMap::new()) + .unwrap(); + + dag.remove_node(&genesis).unwrap(); + assert!(dag.get_node(&genesis).unwrap().is_none()); + } + + #[test] + fn test_remove_node_with_children_fails() { + let temp_dir = tempdir().unwrap(); + let storage = LeveldbNodeStorage::>::open(temp_dir.path()); + let mut dag = DagGraph::new(storage); + + let genesis = dag + .add_genesis_node("payload".to_string(), BTreeMap::new()) + .unwrap(); + dag.add_child_node("child".to_string(), vec![genesis], genesis, BTreeMap::new()) + .unwrap(); + + let err = dag.remove_node(&genesis); + assert!(err.is_err()); + } + + #[test] + fn test_prepare_register_and_rollback_node() { + let temp_dir = tempdir().unwrap(); + let storage = LeveldbNodeStorage::>::open(temp_dir.path()); + let mut dag = DagGraph::new(storage); + + let (genesis_cid, genesis_node) = dag + .prepare_genesis_node("payload".to_string(), BTreeMap::new()) + .unwrap(); + dag.storage.put(&genesis_node).unwrap(); + dag.register_prepared_node(genesis_cid, &genesis_node) + .unwrap(); + assert!(dag.edges_forward.contains_key(&genesis_cid)); + + let (child_cid, child_node) = dag + .prepare_child_node( + "child".to_string(), + vec![genesis_cid], + genesis_cid, + BTreeMap::new(), + ) + .unwrap(); + + dag.register_prepared_node(child_cid, &child_node).unwrap(); + assert!(dag.edges_forward.contains_key(&child_cid)); + + dag.rollback_pending_node(&child_cid, child_node.parents()); + + assert!( + !dag.edges_forward.contains_key(&child_cid), + "rollback should remove pending child" + ); + if let Some(children) = dag.edges_forward.get(&genesis_cid) { + assert!( + !children.contains(&child_cid), + "rollback should detach child from parent adjacency" + ); + } + } } diff --git a/src/graph/storage.rs b/src/graph/storage.rs index cb13af5..508c6b4 100644 --- a/src/graph/storage.rs +++ b/src/graph/storage.rs @@ -1,12 +1,13 @@ use crate::dasl::node::Node; use crate::graph::error::{GraphError, Result}; +use crate::storage::{SharedLeveldb, SharedLeveldbAccess}; use cid::Cid; -use rusty_leveldb::{LdbIterator, Options, DB as Database}; -use std::cell::RefCell; +use rusty_leveldb::LdbIterator; use std::collections::HashMap; use std::path::Path; -use std::path::PathBuf; +use std::rc::Rc; +/// Minimal interface required for persisting DAG nodes. pub trait NodeStorage { fn get(&self, content_id: &Cid) -> Result>>; fn put(&self, node: &Node) -> Result<()>; @@ -14,46 +15,81 @@ pub trait NodeStorage { fn get_node_map(&self) -> Result>>; } +/// [`NodeStorage`] implementation backed by a shared LevelDB instance. pub struct LeveldbNodeStorage { - db: RefCell, - path: PathBuf, + shared: Rc, _marker: std::marker::PhantomData<(P, M)>, } impl Clone for LeveldbNodeStorage { fn clone(&self) -> Self { - let opts = Options { - create_if_missing: true, - ..Default::default() - }; - let db = Database::open(&self.path, opts).expect("Failed to clone database"); Self { - db: RefCell::new(db), - path: self.path.clone(), + shared: self.shared.clone(), _marker: std::marker::PhantomData, } } } impl LeveldbNodeStorage { + /// Opens LevelDB and wraps it in a shared handle. pub fn open>(path: Pth) -> Self { - let opts = Options { - create_if_missing: true, - ..Default::default() - }; - let db = Database::open(path.as_ref(), opts).unwrap(); + let shared = SharedLeveldb::open(path).expect("Failed to open LevelDB"); + Self::new(shared) + } + + /// Creates the storage from an existing [`SharedLeveldb`] handle. + pub fn new(shared: Rc) -> Self { Self { - db: RefCell::new(db), - path: path.as_ref().to_path_buf(), + shared, _marker: std::marker::PhantomData, } } + + /// Builds the LevelDB key for nodes, prefixed with the `0x10` namespace. fn make_key(cid: &Cid) -> Vec { let mut v = Vec::with_capacity(1 + cid.to_bytes().len()); v.push(0x10); v.extend_from_slice(&cid.to_bytes()); v } + + /// Writes either into the active batch, or directly into the DB if no batch is active. + fn write_bytes(&self, key: &[u8], value: &[u8]) -> Result<()> { + if self + .shared + .with_active_batch(|batch| batch.put(key, value)) + .is_none() + { + self.shared + .db() + .borrow_mut() + .put(key, value) + .map_err(GraphError::Storage)?; + } + Ok(()) + } + + /// Deletes the given key, falling back to the DB when no batch is active. + fn delete_key(&self, key: &[u8]) -> Result<()> { + if self + .shared + .with_active_batch(|batch| batch.delete(key)) + .is_none() + { + self.shared + .db() + .borrow_mut() + .delete(key) + .map_err(GraphError::Storage)?; + } + Ok(()) + } +} + +impl SharedLeveldbAccess for LeveldbNodeStorage { + fn shared_leveldb(&self) -> Option> { + Some(self.shared.clone()) + } } impl NodeStorage for LeveldbNodeStorage @@ -63,7 +99,7 @@ where { fn get(&self, cid: &Cid) -> Result>> { let key = Self::make_key(cid); - match self.db.borrow_mut().get(&key) { + match self.shared.db().borrow_mut().get(&key) { Some(raw) => { let node = Node::from_bytes(&raw).map_err(|e| GraphError::NodeOperation(e.to_string()))?; @@ -81,26 +117,20 @@ where .content_id() .map_err(|e| GraphError::NodeOperation(e.to_string()))?; let key = Self::make_key(&cid); - self.db - .borrow_mut() - .put(&key, &bytes) - .map_err(GraphError::Storage)?; - Ok(()) + self.write_bytes(&key, &bytes) } fn delete(&self, cid: &Cid) -> Result<()> { let key = Self::make_key(cid); - self.db - .borrow_mut() - .delete(&key) - .map_err(GraphError::Storage)?; - Ok(()) + self.delete_key(&key) } + /// Walks all nodes and constructs an adjacency map (parent → children). fn get_node_map(&self) -> Result>> { let mut node_map = HashMap::new(); let mut iter = self - .db + .shared + .db() .borrow_mut() .new_iter() .map_err(GraphError::Storage)?; @@ -111,17 +141,12 @@ where while iter.valid() { iter.current(&mut key, &mut value); if !key.is_empty() && key[0] == 0x10 { - match Node::::from_bytes(&value) { - Ok(node) => { - let node_cid = node - .content_id() - .map_err(|e| GraphError::NodeOperation(e.to_string()))?; - node_map.insert(node_cid, node.parents().to_vec()); - } - Err(e) => { - println!("Error deserializing node: {e}"); - } - } + let node = Node::::from_bytes(&value) + .map_err(|e| GraphError::NodeOperation(e.to_string()))?; + let node_cid = node + .content_id() + .map_err(|e| GraphError::NodeOperation(e.to_string()))?; + node_map.insert(node_cid, node.parents().to_vec()); } iter.advance(); } @@ -136,11 +161,12 @@ mod tests { use std::time::{SystemTime, UNIX_EPOCH}; use tempfile::tempdir; + /// Creates a simple test node helper. fn create_test_node(payload: &str) -> Node { let timestamp = SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap_or_default() - .as_secs(); + .as_nanos() as u64; Node::new_genesis(payload.to_string(), timestamp, "metadata".to_string()) } diff --git a/src/lib.rs b/src/lib.rs index 01eb03a..0e98d05 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,7 @@ +pub mod convergence; pub mod crdt; pub mod dasl; pub mod graph; pub mod masl; pub mod repo; +pub mod storage; diff --git a/src/repo.rs b/src/repo.rs index 7a0f590..807dc0b 100644 --- a/src/repo.rs +++ b/src/repo.rs @@ -1,4 +1,9 @@ -use crate::crdt::error::Result; +use crate::convergence::{ + metadata::ContentMetadata, policies::lww::LwwMergePolicy, policy::MergePolicy, + resolver::ConflictResolver, +}; +use crate::crdt::error::{CrdtError, Result}; +use crate::storage::{BatchError, LeveldbBatchGuard, SharedLeveldb, SharedLeveldbAccess}; use crate::{ crdt::{ crdt_state::CrdtState, @@ -6,104 +11,482 @@ use crate::{ reducer::LwwReducer, storage::OperationStorage, }, + dasl::node::Node, graph::{dag::DagGraph, storage::NodeStorage}, }; use cid::Cid; use serde::{Deserialize, Serialize}; +use std::collections::{HashMap, HashSet}; use std::fmt::Debug; +use std::rc::Rc; + +struct PendingNode { + cid: Cid, + parents: Vec, + metadata: ContentMetadata, +} pub struct Repo where - OpStore: OperationStorage, - NodeStore: NodeStorage, + OpStore: OperationStorage + SharedLeveldbAccess, + NodeStore: NodeStorage + SharedLeveldbAccess, Payload: Clone + Serialize + for<'de> Deserialize<'de> + Debug, { pub state: CrdtState, - pub dag: DagGraph, + pub dag: DagGraph, + resolver: ConflictResolver, } impl Repo where - OpStore: OperationStorage, - NodeStore: NodeStorage, + OpStore: OperationStorage + SharedLeveldbAccess, + NodeStore: NodeStorage + SharedLeveldbAccess, Payload: Clone + Serialize + for<'de> Deserialize<'de> + Debug, { pub fn new( state: CrdtState, - dag: DagGraph, + dag: DagGraph, ) -> Self { - Self { state, dag } + Self { + state, + dag, + resolver: ConflictResolver::new(), + } + } + + pub fn commit_operation(&mut self, op: Operation) -> Result { + // Recently, Merge operations cannot be manually committed + if matches!(op.kind, OperationType::Merge(_)) { + return Err(CrdtError::Internal( + "Merge operations cannot be manually committed".to_string(), + )); + } + + self.commit_operation_internal(op, false) + } + + pub fn latest(&self, genesis_id: &Cid) -> Option { + self.dag.calculate_latest(genesis_id).ok().flatten() + } + + /// Convenience wrapper around `DagGraph::get_genesis` + pub fn get_genesis(&self, cid: &Cid) -> Result { + self.dag.get_genesis(cid).map_err(CrdtError::Graph) + } + + pub fn get_operations_with_index( + &self, + genesis: &Cid, + ) -> Result)>> { + let mut ops = self.state.get_operations_by_genesis(genesis)?; + ops.sort_by_key(|op| op.timestamp); + Ok(ops + .into_iter() + .enumerate() + .map(|(idx, op)| (idx + 1, op)) + .collect()) + } + + /// Return parent -> children adjacency for the specified genesis (DAG structure). + pub fn branching_history(&self, genesis: &Cid) -> Result>> { + let nodes = self + .dag + .get_nodes_by_genesis(genesis) + .map_err(CrdtError::Graph)?; + + let mut adjacency: HashMap> = HashMap::new(); + for &cid in &nodes { + if let Some(node) = self.dag.get_node(&cid).map_err(CrdtError::Graph)? { + for parent in node.parents() { + adjacency.entry(*parent).or_default().insert(cid); + } + adjacency.entry(cid).or_default(); + } + } + + Ok(adjacency + .into_iter() + .map(|(cid, set)| { + let mut children: Vec = set.into_iter().collect(); + children.sort(); + (cid, children) + }) + .collect()) + } + + /// Find a linear path from genesis to the latest head. + pub fn linear_history(&self, genesis: &Cid) -> Result> { + let adjacency = self.branching_history(genesis)?; + let mut path = Vec::new(); + let mut current = *genesis; + let mut visited = HashSet::new(); + + while visited.insert(current) { + path.push(current); + let children = adjacency.get(¤t).cloned().unwrap_or_default(); + + if children.is_empty() { + break; + } + + let mut best: Option<(Cid, (bool, u64))> = None; + for child in children { + let info = self.node_characteristics(&child)?; + if let Some((_, best_info)) = &best { + if info > *best_info { + best = Some((child, info)); + } + } else { + best = Some((child, info)); + } + } + + let Some((next, _)) = best else { + break; + }; + + current = next; + } + + Ok(path) } - pub fn commit_operation(&mut self, mut op: Operation) -> Result { - let cid = match &op.kind { + fn shared_leveldb(&self) -> Result> { + let op_db = self.state.storage().shared_leveldb().ok_or_else(|| { + CrdtError::Internal("operation storage does not support batching".into()) + })?; + let node_db = + self.dag.storage.shared_leveldb().ok_or_else(|| { + CrdtError::Internal("node storage does not support batching".into()) + })?; + + if !Rc::ptr_eq(&op_db, &node_db) { + return Err(CrdtError::Internal( + "operation and node storage must share the same LevelDB instance for transactions" + .into(), + )); + } + + Ok(op_db) + } + + fn commit_operation_internal( + &mut self, + op: Operation, + skip_auto_merge: bool, + ) -> Result { + let mut op = op; + let shared = self.shared_leveldb()?; + let batch_guard = Self::begin_shared_batch(&shared)?; + let mut pending_nodes: Vec = Vec::new(); + + if !skip_auto_merge { + self.ensure_parent_context(&mut op, &mut pending_nodes)?; + } + + let cid = match op.kind.clone() { OperationType::Create(payload) => { - let genesis_cid = self.dag.add_genesis_node(payload.clone(), ())?; - op.genesis = genesis_cid; - genesis_cid + self.stage_create(payload, &mut op, &mut pending_nodes)? } OperationType::Update(payload) => { - let parents = self.get_latest_parents(&op.genesis); - self.dag - .add_version_node(payload.clone(), parents, op.genesis, ())? + self.stage_update(payload, &op, &mut pending_nodes)? } - OperationType::Delete => { - let parents = self.get_latest_parents(&op.genesis); - - // For delete operations, find the latest payload in the original genesis chain - let ops = self - .state - .get_operations_by_genesis(&op.genesis) - .expect("Failed to load operations for delete"); - let last_payload = ops - .iter() - .filter(|o| o.payload().is_some()) - .max_by_key(|o| o.timestamp) - .expect("content must exist for delete operation") - .payload() - .unwrap() - .clone(); - - self.dag - .add_version_node(last_payload, parents, op.genesis, ())? + OperationType::Delete => self.stage_delete(&op, &mut pending_nodes)?, + OperationType::Merge(_) => { + return Err(CrdtError::Internal( + "Merge operations must be committed via auto-merge".to_string(), + )) } }; - self.state.apply(op)?; + if let Err(err) = self.state.apply(op) { + self.rollback_pending_nodes(&pending_nodes); + return Err(err); + } + + if let Err(status) = batch_guard.commit() { + self.rollback_pending_nodes(&pending_nodes); + return Err(CrdtError::Storage(status)); + } Ok(cid) } - pub fn latest(&self, genesis_id: &Cid) -> Option { - self.dag.calculate_latest(genesis_id).ok().flatten() + fn begin_shared_batch(shared: &SharedLeveldb) -> Result> { + shared.begin_batch().map_err(|err| match err { + BatchError::Unsupported => CrdtError::Internal( + "current storage backend does not support transactions".to_string(), + ), + BatchError::AlreadyActive => CrdtError::Internal( + "a transaction is already active on the shared LevelDB".to_string(), + ), + BatchError::Commit(status) => CrdtError::Storage(status), + }) } - /// Get the complete history from genesis - pub fn get_history(&self, genesis: &Cid) -> Result> { - if let Some(latest) = self.latest(genesis) { - self.dag - .get_history_from_version(&latest) - .map_err(crate::crdt::error::CrdtError::Graph) - } else { - Ok(vec![]) + fn rollback_pending_nodes(&mut self, pending: &[PendingNode]) { + for node in pending.iter().rev() { + self.dag.rollback_pending_node(&node.cid, &node.parents); + } + } + + fn ensure_parent_context( + &mut self, + op: &mut Operation, + pending_nodes: &mut Vec, + ) -> Result<()> { + match &op.kind { + OperationType::Update(_) | OperationType::Delete => { + if op.parents.is_empty() { + let merged_head = self + .check_and_merge(&op.genesis, pending_nodes)? + .or_else(|| self.dag.calculate_latest(&op.genesis).ok().flatten()) + .ok_or_else(|| { + CrdtError::Internal(format!( + "No head available for genesis {} to attach operation", + op.genesis + )) + })?; + + op.parents = vec![merged_head]; + } else { + self.validate_parent_genesis(&op.genesis, &op.parents)?; + } + } + OperationType::Merge(_) => { + if op.parents.is_empty() { + op.parents = self.find_heads(&op.genesis)?; + } + self.validate_parent_genesis(&op.genesis, &op.parents)?; + } + OperationType::Create(_) => {} } + Ok(()) } - /// Get genesis from any version - pub fn get_genesis(&self, version: &Cid) -> Result { + fn stage_create( + &mut self, + payload: Payload, + op: &mut Operation, + pending_nodes: &mut Vec, + ) -> Result { + let (genesis_cid, node) = self + .dag + .prepare_genesis_node(payload, ContentMetadata::default())?; + let cid = self.stage_prepared_node(genesis_cid, node, pending_nodes)?; + op.genesis = cid; + Ok(cid) + } + + fn stage_update( + &mut self, + payload: Payload, + op: &Operation, + pending_nodes: &mut Vec, + ) -> Result { + let metadata = + self.resolve_metadata_for_commit(&op.genesis, &op.parents, pending_nodes.as_slice())?; + let (cid, node) = + self.dag + .prepare_child_node(payload, op.parents.clone(), op.genesis, metadata)?; + self.stage_prepared_node(cid, node, pending_nodes) + } + + fn stage_delete( + &mut self, + op: &Operation, + pending_nodes: &mut Vec, + ) -> Result { + let ops = self.state.get_operations_by_genesis(&op.genesis)?; + let last_payload = ops + .iter() + .filter_map(|operation| { + operation + .payload() + .cloned() + .map(|payload| (operation.timestamp, payload)) + }) + .max_by_key(|(timestamp, _)| *timestamp) + .map(|(_, payload)| payload) + .ok_or_else(|| { + CrdtError::Internal(format!( + "content must exist for delete operation: {}", + op.genesis + )) + })?; + + let metadata = + self.resolve_metadata_for_commit(&op.genesis, &op.parents, pending_nodes.as_slice())?; + let (cid, node) = + self.dag + .prepare_child_node(last_payload, op.parents.clone(), op.genesis, metadata)?; + self.stage_prepared_node(cid, node, pending_nodes) + } + + fn stage_prepared_node( + &mut self, + cid: Cid, + node: Node, + pending_nodes: &mut Vec, + ) -> Result { + let pending = self.persist_prepared_node(cid, &node)?; + pending_nodes.push(pending); + Ok(cid) + } + + fn persist_prepared_node( + &mut self, + cid: Cid, + node: &Node, + ) -> Result { + self.dag.storage.put(node).map_err(CrdtError::Graph)?; self.dag - .get_genesis(version) - .map_err(crate::crdt::error::CrdtError::Graph) + .register_prepared_node(cid, node) + .map_err(CrdtError::Graph)?; + Ok(PendingNode { + cid, + parents: node.parents().to_vec(), + metadata: node.metadata().clone(), + }) } /// Get the latest parent nodes for the given genesis - fn get_latest_parents(&self, genesis: &Cid) -> Vec { - self.dag - .calculate_latest(genesis) - .ok() - .flatten() - .map(|head| vec![head]) - .unwrap_or_default() + fn validate_parent_genesis(&self, genesis: &Cid, parents: &[Cid]) -> Result<()> { + for parent in parents { + let parent_genesis = self.dag.get_genesis(parent).map_err(CrdtError::Graph)?; + if &parent_genesis != genesis { + return Err(CrdtError::Internal(format!( + "Parent {parent} does not belong to genesis {genesis}" + ))); + } + } + Ok(()) + } + + fn check_and_merge( + &mut self, + genesis: &Cid, + pending_nodes: &mut Vec, + ) -> Result> { + let heads = self.find_heads(genesis)?; + + if heads.len() <= 1 { + return Ok(None); + } + + let genesis_node = self + .dag + .get_node(genesis) + .map_err(CrdtError::Graph)? + .ok_or_else(|| CrdtError::Internal(format!("Genesis not found: {genesis}")))?; + let policy_type = genesis_node.metadata().policy_type(); + let policy = self.create_policy(policy_type)?; + + let merge_node = + self.resolver + .create_merge_node(&heads, &self.dag, *genesis, policy.as_ref())?; + + self.validate_parent_genesis(genesis, &heads)?; + + let (merge_cid, node) = self + .dag + .prepare_child_node( + merge_node.payload().clone(), + heads.clone(), + *genesis, + merge_node.metadata().clone(), + ) + .map_err(CrdtError::Graph)?; + let pending = self.persist_prepared_node(merge_cid, &node)?; + + let mut merge_op = Operation::new( + *genesis, + OperationType::Merge(merge_node.payload().clone()), + "auto-merge".to_string(), + ); + merge_op.parents = heads; + if let Err(err) = self.state.apply(merge_op) { + self.dag + .rollback_pending_node(&pending.cid, &pending.parents); + return Err(err); + } + + pending_nodes.push(pending); + + Ok(Some(merge_cid)) + } + + fn find_heads(&self, genesis: &Cid) -> Result> { + let nodes = self + .dag + .get_nodes_by_genesis(genesis) + .map_err(CrdtError::Graph)?; + if nodes.is_empty() { + return Ok(vec![]); + } + + let node_set: HashSet = nodes.iter().copied().collect(); + let mut parents_within = HashSet::new(); + + for cid in &nodes { + if let Some(node) = self.dag.get_node(cid).map_err(CrdtError::Graph)? { + for parent in node.parents() { + if node_set.contains(parent) { + parents_within.insert(*parent); + } + } + } + } + + Ok(nodes + .into_iter() + .filter(|cid| !parents_within.contains(cid)) + .collect()) + } + + fn create_policy(&self, policy_type: &str) -> Result>> { + match policy_type { + "lww" => Ok(Box::new(LwwMergePolicy)), + other => Err(CrdtError::Internal(format!("Unknown policy type: {other}"))), + } + } + + fn resolve_metadata_for_commit( + &self, + genesis: &Cid, + parents: &[Cid], + pending_nodes: &[PendingNode], + ) -> Result { + if let Some(parent) = parents.first() { + if let Some(pending) = pending_nodes.iter().find(|pending| &pending.cid == parent) { + return Ok(pending.metadata.clone()); + } + let node = self + .dag + .get_node(parent) + .map_err(CrdtError::Graph)? + .ok_or_else(|| CrdtError::Internal(format!("Parent node not found: {parent}")))?; + Ok(node.metadata().clone()) + } else { + if let Some(pending) = pending_nodes.iter().find(|pending| &pending.cid == genesis) { + return Ok(pending.metadata.clone()); + } + let genesis_node = self + .dag + .get_node(genesis) + .map_err(CrdtError::Graph)? + .ok_or_else(|| CrdtError::Internal(format!("Genesis not found: {genesis}")))?; + Ok(genesis_node.metadata().clone()) + } + } + fn node_characteristics(&self, cid: &Cid) -> Result<(bool, u64)> { + let node = self + .dag + .get_node(cid) + .map_err(CrdtError::Graph)? + .ok_or_else(|| CrdtError::Internal(format!("Node not found: {cid}")))?; + let is_merge = node.parents().len() > 1; + Ok((is_merge, node.timestamp())) } } @@ -112,20 +495,28 @@ mod tests { use super::*; use crate::crdt::operation::{Operation, OperationType}; use crate::crdt::storage::LeveldbStorage; + use crate::graph::error::GraphError; use crate::graph::storage::LeveldbNodeStorage; + use rusty_leveldb::{Status, StatusCode}; + use std::cell::Cell; use tempfile::tempdir; + use ulid::Ulid; #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(transparent)] struct TestPayload(String); - type TestRepo = - Repo, LeveldbNodeStorage, TestPayload>; + type TestRepo = Repo< + LeveldbStorage, + LeveldbNodeStorage, + TestPayload, + >; fn setup_test_repo() -> (TestRepo, tempfile::TempDir) { let dir = tempdir().unwrap(); - let op_storage = LeveldbStorage::open(dir.path().join("ops")).unwrap(); - let node_storage = LeveldbNodeStorage::open(dir.path().join("nodes")); + let shared = SharedLeveldb::open(dir.path().join("store")).unwrap(); + let op_storage = LeveldbStorage::new(shared.clone()); + let node_storage = LeveldbNodeStorage::new(shared); let state = CrdtState::new(op_storage); let dag = DagGraph::new(node_storage); let repo = Repo::new(state, dag); @@ -133,28 +524,142 @@ mod tests { } fn make_test_operation( - target: Cid, - kind: OperationType, - ) -> Operation { - Operation::new(target, kind, "test".into()) - } - fn make_test_operation_with_genesis( - target: Cid, genesis: Cid, kind: OperationType, ) -> Operation { - Operation::new_with_genesis(target, genesis, kind, "test".into()) + Operation::new(genesis, kind, "test".into()) + } + + fn sleep_for_ordering() { + std::thread::sleep(std::time::Duration::from_millis(1)); + } + + struct FailingOperationStorage { + inner: S, + fail_next: Cell, + } + + impl FailingOperationStorage { + fn new(inner: S) -> Self { + Self { + inner, + fail_next: Cell::new(false), + } + } + + fn fail_on_first(inner: S) -> Self { + Self { + inner, + fail_next: Cell::new(true), + } + } + + fn fail_on_next(&self) { + self.fail_next.set(true); + } + } + + impl OperationStorage for FailingOperationStorage + where + S: OperationStorage, + { + fn save_operation(&self, op: &Operation) -> crate::crdt::error::Result<()> { + if self.fail_next.replace(false) { + Err(CrdtError::Internal( + "forced failure for testing".to_string(), + )) + } else { + self.inner.save_operation(op) + } + } + + fn load_operations( + &self, + genesis: &ContentId, + ) -> crate::crdt::error::Result>> { + self.inner.load_operations(genesis) + } + + fn get_operation( + &self, + op_id: &Ulid, + ) -> crate::crdt::error::Result>> { + self.inner.get_operation(op_id) + } + + fn delete_operation(&self, op_id: &Ulid) -> crate::crdt::error::Result<()> { + self.inner.delete_operation(op_id) + } + } + + impl SharedLeveldbAccess for FailingOperationStorage + where + S: SharedLeveldbAccess, + { + fn shared_leveldb(&self) -> Option> { + self.inner.shared_leveldb() + } + } + + struct FailingNodeStorage { + inner: S, + fail_next_put: Cell, + } + + impl FailingNodeStorage { + fn fail_on_first_put(inner: S) -> Self { + Self { + inner, + fail_next_put: Cell::new(true), + } + } + } + + impl NodeStorage for FailingNodeStorage + where + S: NodeStorage, + { + fn get(&self, content_id: &Cid) -> crate::graph::error::Result>> { + self.inner.get(content_id) + } + + fn put(&self, node: &Node) -> crate::graph::error::Result<()> { + if self.fail_next_put.replace(false) { + Err(GraphError::Internal( + "injected node storage failure".to_string(), + )) + } else { + self.inner.put(node) + } + } + + fn delete(&self, content_id: &Cid) -> crate::graph::error::Result<()> { + self.inner.delete(content_id) + } + + fn get_node_map(&self) -> crate::graph::error::Result>> { + self.inner.get_node_map() + } + } + + impl SharedLeveldbAccess for FailingNodeStorage + where + S: SharedLeveldbAccess, + { + fn shared_leveldb(&self) -> Option> { + self.inner.shared_leveldb() + } } #[test] fn test_create_operation() { let (mut repo, _) = setup_test_repo(); - let target = Cid::new_v1( + let initial_genesis = Cid::new_v1( 0x55, multihash::Multihash::<64>::wrap(0x12, b"test").unwrap(), ); let payload = TestPayload("test content".to_string()); - let op = make_test_operation(target, OperationType::Create(payload.clone())); + let op = make_test_operation(initial_genesis, OperationType::Create(payload.clone())); let cid = repo.commit_operation(op).unwrap(); @@ -162,25 +667,63 @@ mod tests { assert_eq!(repo.latest(&cid).unwrap(), cid); } + #[test] + fn test_create_operation_fails_when_node_storage_errors() { + let dir = tempdir().unwrap(); + let shared = SharedLeveldb::open(dir.path().join("store")).unwrap(); + let op_storage = LeveldbStorage::new(shared.clone()); + let node_storage = + FailingNodeStorage::fail_on_first_put(LeveldbNodeStorage::new(shared.clone())); + let state = CrdtState::new(op_storage); + let dag = DagGraph::new(node_storage); + let mut repo = Repo::new(state, dag); + + let initial_genesis = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"create-fail").unwrap(), + ); + let op = make_test_operation( + initial_genesis, + OperationType::Create(TestPayload("should fail".to_string())), + ); + let op_id = op.id; + + let err = repo.commit_operation(op).unwrap_err(); + match err { + CrdtError::Graph(GraphError::Internal(message)) => { + assert!(message.contains("injected node storage failure")); + } + other => panic!("unexpected error: {other:?}"), + } + + assert!( + repo.state.get_operation(&op_id).unwrap().is_none(), + "operation should not be persisted on failure" + ); + assert!( + repo.dag.storage.get_node_map().unwrap().is_empty(), + "dag should remain empty when node storage fails" + ); + } + #[test] fn test_update_operation() { let (mut repo, _) = setup_test_repo(); - let target = Cid::new_v1( + let initial_genesis = Cid::new_v1( 0x55, multihash::Multihash::<64>::wrap(0x12, b"test").unwrap(), ); let create_op = make_test_operation( - target, + initial_genesis, OperationType::Create(TestPayload("initial".to_string())), ); let create_cid = repo.commit_operation(create_op).unwrap(); - let update_op = make_test_operation_with_genesis( - target, + let update_op = make_test_operation( create_cid, OperationType::Update(TestPayload("updated".to_string())), ); - std::thread::sleep(std::time::Duration::from_millis(1)); + sleep_for_ordering(); let update_cid = repo.commit_operation(update_op).unwrap(); assert!(repo.latest(&create_cid).is_some()); @@ -188,21 +731,317 @@ mod tests { assert_ne!(create_cid, update_cid); } + #[test] + fn test_update_operation_without_existing_head_fails() { + let (mut repo, _) = setup_test_repo(); + let initial_genesis = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"update-no-head").unwrap(), + ); + let op = make_test_operation( + initial_genesis, + OperationType::Update(TestPayload("orphaned".to_string())), + ); + + let err = repo.commit_operation(op).unwrap_err(); + match err { + CrdtError::Internal(message) => { + assert!(message.contains("No head available")); + } + other => panic!("unexpected error: {other:?}"), + } + + let stored_ops = repo + .state + .get_operations_by_genesis(&initial_genesis) + .unwrap(); + assert!( + stored_ops.is_empty(), + "update should not persist when no head exists" + ); + } + + #[test] + fn test_create_operation_rolls_back_on_state_failure() { + let dir = tempdir().unwrap(); + let shared = SharedLeveldb::open(dir.path().join("store")).unwrap(); + let op_storage = + FailingOperationStorage::fail_on_first(LeveldbStorage::new(shared.clone())); + let node_storage = LeveldbNodeStorage::new(shared); + let state = CrdtState::new(op_storage); + let dag = DagGraph::new(node_storage); + let mut repo = Repo::new(state, dag); + + let initial_genesis = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"rollback-test").unwrap(), + ); + let op = make_test_operation( + initial_genesis, + OperationType::Create(TestPayload("should not persist".to_string())), + ); + let op_id = op.id; + + let result = repo.commit_operation(op); + assert!(result.is_err()); + + let node_map = repo.dag.storage.get_node_map().unwrap(); + assert!( + node_map.is_empty(), + "expected DAG to be empty after rollback, found {node_map:?}" + ); + assert!( + repo.state.get_operation(&op_id).unwrap().is_none(), + "operation was persisted despite failure" + ); + } + + #[test] + fn test_create_operation_rolls_back_when_batch_commit_fails() { + let (mut repo, _) = setup_test_repo(); + let shared = repo + .state + .storage() + .shared_leveldb() + .expect("shared leveldb instance"); + shared.inject_commit_failure(Status::new(StatusCode::IOError, "forced commit failure")); + + let initial_genesis = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"batch-failure").unwrap(), + ); + let op = make_test_operation( + initial_genesis, + OperationType::Create(TestPayload("batch-fail".to_string())), + ); + let op_id = op.id; + + let err = repo.commit_operation(op).unwrap_err(); + match err { + CrdtError::Storage(status) => { + assert_eq!(status.code, StatusCode::IOError); + assert!(status.err.contains("forced commit failure")); + } + other => panic!("unexpected error: {other:?}"), + } + + assert!( + repo.state.get_operation(&op_id).unwrap().is_none(), + "operation should not persist when batch commit fails" + ); + assert!( + repo.dag.storage.get_node_map().unwrap().is_empty(), + "dag should be rolled back when batch commit fails" + ); + } + + #[test] + fn test_rollback_pending_nodes_restores_heads_after_failure() { + let dir = tempdir().unwrap(); + let shared = SharedLeveldb::open(dir.path().join("store")).unwrap(); + let op_storage = FailingOperationStorage::new(LeveldbStorage::new(shared.clone())); + let node_storage = LeveldbNodeStorage::new(shared); + let state = CrdtState::new(op_storage); + let dag = DagGraph::new(node_storage); + let mut repo = Repo::new(state, dag); + + let seed = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"rollback-pending").unwrap(), + ); + let create = make_test_operation(seed, OperationType::Create(TestPayload("root".into()))); + let genesis = repo.commit_operation(create).unwrap(); + + let mut branch1 = make_test_operation( + genesis, + OperationType::Update(TestPayload("branch-1".into())), + ); + branch1.parents.push(genesis); + let branch1_cid = repo.commit_operation(branch1).unwrap(); + sleep_for_ordering(); + + let mut branch2 = make_test_operation( + genesis, + OperationType::Update(TestPayload("branch-2".into())), + ); + branch2.parents.push(genesis); + let branch2_cid = repo.commit_operation(branch2).unwrap(); + + let original_heads = repo.find_heads(&genesis).unwrap(); + assert_eq!(original_heads.len(), 2); + assert!(original_heads.contains(&branch1_cid)); + assert!(original_heads.contains(&branch2_cid)); + + repo.state.storage().fail_on_next(); + + let update = make_test_operation( + genesis, + OperationType::Update(TestPayload("should-rollback".into())), + ); + let err = repo.commit_operation(update).unwrap_err(); + match err { + CrdtError::Internal(message) => { + assert!(message.contains("forced failure for testing")); + } + other => panic!("unexpected error: {other:?}"), + } + + let heads_after = repo.find_heads(&genesis).unwrap(); + assert_eq!(heads_after.len(), 2); + assert!(heads_after.contains(&branch1_cid)); + assert!(heads_after.contains(&branch2_cid)); + + let ops = repo.state.get_operations_by_genesis(&genesis).unwrap(); + assert_eq!( + ops.len(), + 3, + "rollback should leave only the original create and two branch updates" + ); + + let node_map = repo.dag.storage.get_node_map().unwrap(); + assert!(node_map.contains_key(&genesis)); + assert!(node_map.contains_key(&branch1_cid)); + assert!(node_map.contains_key(&branch2_cid)); + assert_eq!( + node_map.len(), + 3, + "no additional DAG nodes should remain after rollback" + ); + } + #[test] + fn test_update_with_explicit_parent_is_respected() { + let (mut repo, _) = setup_test_repo(); + let initial_genesis = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"explicit-parent").unwrap(), + ); + let create_op = make_test_operation( + initial_genesis, + OperationType::Create(TestPayload("root".to_string())), + ); + let genesis = repo.commit_operation(create_op).unwrap(); + + let update_auto = make_test_operation( + genesis, + OperationType::Update(TestPayload("child-1".to_string())), + ); + sleep_for_ordering(); + let auto_cid = repo.commit_operation(update_auto).unwrap(); + + let mut update_branch = make_test_operation( + genesis, + OperationType::Update(TestPayload("branch-from-genesis".to_string())), + ); + update_branch.parents.push(genesis); + sleep_for_ordering(); + let branch_cid = repo.commit_operation(update_branch).unwrap(); + + let branch_node = repo + .dag + .get_node(&branch_cid) + .unwrap() + .expect("branch node"); + assert_eq!(branch_node.parents(), &[genesis]); + + let auto_node = repo.dag.get_node(&auto_cid).unwrap().expect("auto node"); + assert_eq!(auto_node.parents(), &[genesis]); + } + + #[test] + fn test_update_rejects_parent_from_other_genesis() { + let (mut repo, _) = setup_test_repo(); + let seed_a = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"genesis-a").unwrap(), + ); + let seed_b = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"genesis-b").unwrap(), + ); + + let genesis_a = repo + .commit_operation(make_test_operation( + seed_a, + OperationType::Create(TestPayload("A".into())), + )) + .unwrap(); + let genesis_b = repo + .commit_operation(make_test_operation( + seed_b, + OperationType::Create(TestPayload("B".into())), + )) + .unwrap(); + + let mut bad_update = + make_test_operation(genesis_a, OperationType::Update(TestPayload("bad".into()))); + bad_update.parents.push(genesis_b); + + let err = repo.commit_operation(bad_update).unwrap_err(); + match err { + CrdtError::Internal(message) => { + assert!(message.contains("does not belong")); + } + other => panic!("unexpected error: {other:?}"), + } + } + + #[test] + fn test_multiple_children_from_same_parent() { + let (mut repo, _) = setup_test_repo(); + let seed = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"shared-parent").unwrap(), + ); + + let genesis = repo + .commit_operation(make_test_operation( + seed, + OperationType::Create(TestPayload("root".into())), + )) + .unwrap(); + + let mut child_a = make_test_operation( + genesis, + OperationType::Update(TestPayload("child-a".into())), + ); + child_a.parents.push(genesis); + let child_a_cid = repo.commit_operation(child_a).unwrap(); + + let mut child_b = make_test_operation( + genesis, + OperationType::Update(TestPayload("child-b".into())), + ); + child_b.parents.push(genesis); + sleep_for_ordering(); + let child_b_cid = repo.commit_operation(child_b).unwrap(); + + let node_a = repo.dag.get_node(&child_a_cid).unwrap().expect("child_a"); + assert_eq!(node_a.parents(), &[genesis]); + + let node_b = repo.dag.get_node(&child_b_cid).unwrap().expect("child_b"); + assert_eq!(node_b.parents(), &[genesis]); + + let heads = repo.find_heads(&genesis).unwrap(); + assert_eq!(heads.len(), 2); + assert!(heads.contains(&child_a_cid)); + assert!(heads.contains(&child_b_cid)); + } + #[test] fn test_delete_operation() { let (mut repo, _) = setup_test_repo(); - let target = Cid::new_v1( + let initial_genesis = Cid::new_v1( 0x55, multihash::Multihash::<64>::wrap(0x12, b"test").unwrap(), ); let create_op = make_test_operation( - target, + initial_genesis, OperationType::Create(TestPayload("initial".to_string())), ); let create_cid = repo.commit_operation(create_op).unwrap(); - let delete_op = make_test_operation_with_genesis(target, create_cid, OperationType::Delete); - std::thread::sleep(std::time::Duration::from_millis(1)); + let delete_op = make_test_operation(create_cid, OperationType::Delete); + sleep_for_ordering(); let delete_cid = repo.commit_operation(delete_op).unwrap(); assert!(repo.latest(&create_cid).is_some()); @@ -211,26 +1050,69 @@ mod tests { } #[test] - fn test_multiple_targets() { + fn test_delete_operation_without_existing_payload_fails() { let (mut repo, _) = setup_test_repo(); - let target1 = Cid::new_v1( + let (genesis_cid, genesis_node) = repo + .dag + .prepare_genesis_node( + TestPayload("dangling".to_string()), + ContentMetadata::default(), + ) + .unwrap(); + repo.dag.storage.put(&genesis_node).unwrap(); + repo.dag + .register_prepared_node(genesis_cid, &genesis_node) + .unwrap(); + + let op = make_test_operation(genesis_cid, OperationType::Delete); + let op_id = op.id; + + let err = repo.commit_operation(op).unwrap_err(); + match err { + CrdtError::Internal(message) => { + assert!(message.contains("content must exist")); + } + other => panic!("unexpected error: {other:?}"), + } + + assert!( + repo.state.get_operation(&op_id).unwrap().is_none(), + "delete operation should not be stored when payload is missing" + ); + assert!( + repo.state + .get_operations_by_genesis(&genesis_cid) + .unwrap() + .is_empty(), + "operation history should remain empty on failure" + ); + assert!( + repo.dag.get_node(&genesis_cid).unwrap().is_some(), + "existing genesis node should remain after failed delete" + ); + } + + #[test] + fn test_multiple_genesis_entries() { + let (mut repo, _) = setup_test_repo(); + let genesis1 = Cid::new_v1( 0x55, multihash::Multihash::<64>::wrap(0x12, b"test1").unwrap(), ); - let target2 = Cid::new_v1( + let genesis2 = Cid::new_v1( 0x55, multihash::Multihash::<64>::wrap(0x12, b"test2").unwrap(), ); let create1_op = make_test_operation( - target1, - OperationType::Create(TestPayload("target1".to_string())), + genesis1, + OperationType::Create(TestPayload("entry1".to_string())), ); let create1_cid = repo.commit_operation(create1_op).unwrap(); let create2_op = make_test_operation( - target2, - OperationType::Create(TestPayload("target2".to_string())), + genesis2, + OperationType::Create(TestPayload("entry2".to_string())), ); let create2_cid = repo.commit_operation(create2_op).unwrap(); @@ -244,80 +1126,379 @@ mod tests { #[test] fn test_update_keeps_series_isolated() { let (mut repo, _) = setup_test_repo(); - let shared_target = Cid::new_v1( + let placeholder_genesis = Cid::new_v1( 0x55, multihash::Multihash::<64>::wrap(0x12, b"update_shared").unwrap(), ); // Series A let create_a = make_test_operation( - shared_target, + placeholder_genesis, OperationType::Create(TestPayload("A1".into())), ); let genesis_a = repo.commit_operation(create_a).unwrap(); // Series B let create_b = make_test_operation( - shared_target, + placeholder_genesis, OperationType::Create(TestPayload("B1".into())), ); let genesis_b = repo.commit_operation(create_b).unwrap(); // Update only series A - let update_a = make_test_operation_with_genesis( - shared_target, - genesis_a, - OperationType::Update(TestPayload("A2".into())), - ); - std::thread::sleep(std::time::Duration::from_millis(1)); + let update_a = + make_test_operation(genesis_a, OperationType::Update(TestPayload("A2".into()))); + sleep_for_ordering(); let latest_a = repo.commit_operation(update_a).unwrap(); - // 確認: series A の latest は更新され、series B は変わらない assert_eq!(repo.latest(&genesis_a).unwrap(), latest_a); assert_eq!(repo.latest(&genesis_b).unwrap(), genesis_b); } - /// Failing test: Delete on one series still uses `target` and may fetch wrong payload. + /// Failing test: Delete on one series still uses the legacy lookup and may fetch the wrong payload. #[test] - fn test_delete_mixes_series_due_to_target_lookup() { + fn test_delete_mixes_series_due_to_legacy_lookup() { let (mut repo, _) = setup_test_repo(); - let shared_target = Cid::new_v1( + let placeholder_genesis = Cid::new_v1( 0x55, multihash::Multihash::<64>::wrap(0x12, b"shared").unwrap(), ); // User1: Create let create1 = make_test_operation( - shared_target, + placeholder_genesis, OperationType::Create(TestPayload("u1".into())), ); let cid1 = repo.commit_operation(create1).unwrap(); // User2: parallel series let create2 = make_test_operation( - shared_target, + placeholder_genesis, OperationType::Create(TestPayload("u2".into())), ); let cid2 = repo.commit_operation(create2).unwrap(); // User2 update in its own series - let update2 = make_test_operation_with_genesis( - shared_target, + let update2 = make_test_operation( cid2, OperationType::Update(TestPayload("u2_updated".into())), ); - std::thread::sleep(std::time::Duration::from_millis(1)); + sleep_for_ordering(); repo.commit_operation(update2).unwrap(); - // User1 delete - let del_op = make_test_operation_with_genesis(shared_target, cid1, OperationType::Delete); - std::thread::sleep(std::time::Duration::from_millis(1)); + let del_op = make_test_operation(cid1, OperationType::Delete); + sleep_for_ordering(); repo.commit_operation(del_op).unwrap(); - assert_eq!(repo.state.get_state(&shared_target, &cid1), None); + assert_eq!(repo.state.get_state(&cid1), None); assert_eq!( - repo.state.get_state(&shared_target, &cid2), + repo.state.get_state(&cid2), Some(TestPayload("u2_updated".into())) ); } + + #[test] + fn test_manual_merge_operations_are_rejected() { + let (mut repo, _) = setup_test_repo(); + let initial_genesis = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"merge").unwrap(), + ); + let create = make_test_operation( + initial_genesis, + OperationType::Create(TestPayload("base".into())), + ); + let genesis = repo.commit_operation(create).unwrap(); + + let merge_op = make_test_operation( + genesis, + OperationType::Merge(TestPayload("should-fail".into())), + ); + + let err = repo.commit_operation(merge_op).unwrap_err(); + match err { + CrdtError::Internal(message) => { + assert!(message.contains("Merge operations cannot be manually committed")) + } + other => panic!("unexpected error: {other:?}"), + } + } + + #[test] + fn test_auto_merge_creates_merge_operation() { + let (mut repo, _) = setup_test_repo(); + let initial_genesis = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"autoMerge").unwrap(), + ); + let create = make_test_operation( + initial_genesis, + OperationType::Create(TestPayload("root".into())), + ); + let genesis = repo.commit_operation(create).unwrap(); + + // Create two explicit branches from the same genesis using commit_operation + let mut branch1_op = make_test_operation( + genesis, + OperationType::Update(TestPayload("branch-1".into())), + ); + branch1_op.parents.push(genesis); + let branch1_cid = repo.commit_operation(branch1_op).unwrap(); + sleep_for_ordering(); + let mut branch2_op = make_test_operation( + genesis, + OperationType::Update(TestPayload("branch-2".into())), + ); + branch2_op.parents.push(genesis); + let branch2_cid = repo.commit_operation(branch2_op).unwrap(); + sleep_for_ordering(); + + // Committing a regular update should trigger auto-merge + let update = + make_test_operation(genesis, OperationType::Update(TestPayload("latest".into()))); + repo.commit_operation(update).unwrap(); + + let ops = repo.state.get_operations_by_genesis(&genesis).unwrap(); + assert!(ops + .iter() + .any(|op| matches!(op.kind, OperationType::Merge(_)))); + + // After auto-merge, the content should converge to a single head + let heads_after_merge = repo.find_heads(&genesis).unwrap(); + assert_eq!(heads_after_merge.len(), 1); + assert!(!heads_after_merge.contains(&branch1_cid)); + assert!(!heads_after_merge.contains(&branch2_cid)); + } + + #[test] + fn test_auto_merge_from_intermediate_branch() { + let (mut repo, _) = setup_test_repo(); + let seed = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"intermediate-merge").unwrap(), + ); + + // genesis a + let genesis = repo + .commit_operation(make_test_operation( + seed, + OperationType::Create(TestPayload("a".into())), + )) + .unwrap(); + + // main chain: a -> b -> d -> e -> f + let mut last_main = genesis; + let mut d_cid = genesis; + for label in ["b", "d", "e", "f"] { + let mut op = + make_test_operation(genesis, OperationType::Update(TestPayload((*label).into()))); + op.parents.push(last_main); + sleep_for_ordering(); + let cid = repo.commit_operation(op).unwrap(); + if label == "d" { + d_cid = cid; + } + last_main = cid; + } + let f_cid = last_main; + + // branch from d: g -> h + let mut g_op = make_test_operation(genesis, OperationType::Update(TestPayload("g".into()))); + g_op.parents.push(d_cid); + sleep_for_ordering(); + let g_cid = repo.commit_operation(g_op).unwrap(); + + let mut h_op = make_test_operation(genesis, OperationType::Update(TestPayload("h".into()))); + h_op.parents.push(g_cid); + sleep_for_ordering(); + let h_cid = repo.commit_operation(h_op).unwrap(); + + // auto-merge will trigger when committing a new update without explicit parents + sleep_for_ordering(); + + let latest_op = + make_test_operation(genesis, OperationType::Update(TestPayload("latest".into()))); + let latest_cid = repo.commit_operation(latest_op).unwrap(); + + let heads = repo.find_heads(&genesis).unwrap(); + assert_eq!(heads.len(), 1); + assert_eq!(heads[0], latest_cid); + + let latest_node = repo + .dag + .get_node(&latest_cid) + .unwrap() + .expect("latest node"); + let latest_parents = latest_node.parents(); + assert_eq!(latest_parents.len(), 1); + let merge_cid = latest_parents[0]; + + let merge_node = repo.dag.get_node(&merge_cid).unwrap().expect("merge node"); + let merge_parents = merge_node.parents(); + assert_eq!(merge_parents.len(), 2); + assert!(merge_parents.contains(&f_cid)); + assert!(merge_parents.contains(&h_cid)); + } + + #[test] + fn test_branching_history_returns_adjacency() { + let (mut repo, _) = setup_test_repo(); + let genesis_seed = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"branching").unwrap(), + ); + let create = make_test_operation( + genesis_seed, + OperationType::Create(TestPayload("root".into())), + ); + let genesis = repo.commit_operation(create).unwrap(); + + let branch_a_payload = TestPayload("branch-a".into()); + let branch_a = repo + .dag + .add_child_node( + branch_a_payload.clone(), + vec![genesis], + genesis, + ContentMetadata::default(), + ) + .unwrap(); + repo.state + .apply(Operation::new( + genesis, + OperationType::Update(branch_a_payload), + "manual".into(), + )) + .unwrap(); + + let branch_b_payload = TestPayload("branch-b".into()); + let branch_b = repo + .dag + .add_child_node( + branch_b_payload.clone(), + vec![genesis], + genesis, + ContentMetadata::default(), + ) + .unwrap(); + repo.state + .apply(Operation::new( + genesis, + OperationType::Update(branch_b_payload), + "manual".into(), + )) + .unwrap(); + + let adjacency = repo.branching_history(&genesis).unwrap(); + let children = adjacency.get(&genesis).cloned().unwrap_or_default(); + + assert!(children.contains(&branch_a)); + assert!(children.contains(&branch_b)); + assert!(adjacency.contains_key(&branch_a)); + assert!(adjacency.contains_key(&branch_b)); + } + + #[test] + fn test_linear_history_prefers_merge_path() { + let (mut repo, _) = setup_test_repo(); + let genesis_seed = Cid::new_v1( + 0x55, + multihash::Multihash::<64>::wrap(0x12, b"linear").unwrap(), + ); + let create = make_test_operation( + genesis_seed, + OperationType::Create(TestPayload("root".into())), + ); + let genesis = repo.commit_operation(create).unwrap(); + + let branch_a_payload = TestPayload("A".into()); + let branch_a = repo + .dag + .add_child_node( + branch_a_payload.clone(), + vec![genesis], + genesis, + ContentMetadata::default(), + ) + .unwrap(); + repo.state + .apply(Operation::new( + genesis, + OperationType::Update(branch_a_payload), + "manual".into(), + )) + .unwrap(); + + sleep_for_ordering(); + + let branch_b_payload = TestPayload("B".into()); + let branch_b = repo + .dag + .add_child_node( + branch_b_payload.clone(), + vec![genesis], + genesis, + ContentMetadata::default(), + ) + .unwrap(); + repo.state + .apply(Operation::new( + genesis, + OperationType::Update(branch_b_payload), + "manual".into(), + )) + .unwrap(); + + let merge_payload = TestPayload("merged".into()); + let merge_cid = repo + .dag + .add_child_node( + merge_payload.clone(), + vec![branch_a, branch_b], + genesis, + ContentMetadata::default(), + ) + .unwrap(); + repo.state + .apply(Operation::new( + genesis, + OperationType::Merge(merge_payload.clone()), + "auto-merge".into(), + )) + .unwrap(); + + sleep_for_ordering(); + + let latest_payload = TestPayload("latest".into()); + let latest_cid = repo + .dag + .add_child_node( + latest_payload.clone(), + vec![merge_cid], + genesis, + ContentMetadata::default(), + ) + .unwrap(); + repo.state + .apply(Operation::new( + genesis, + OperationType::Update(latest_payload), + "manual".into(), + )) + .unwrap(); + + let path = repo.linear_history(&genesis).unwrap(); + assert_eq!(path.last(), Some(&latest_cid)); + assert!(path.contains(&merge_cid)); + assert!(path.iter().any(|cid| cid == &branch_a || cid == &branch_b)); + if let (Some(branch_pos), Some(merge_pos)) = ( + path.iter() + .position(|cid| cid == &branch_a || cid == &branch_b), + path.iter().position(|cid| cid == &merge_cid), + ) { + assert!(branch_pos < merge_pos); + } else { + panic!("branch or merge node missing from linear history"); + } + } } diff --git a/src/storage/mod.rs b/src/storage/mod.rs new file mode 100644 index 0000000..b36909c --- /dev/null +++ b/src/storage/mod.rs @@ -0,0 +1,3 @@ +mod shared_leveldb; + +pub use shared_leveldb::{BatchError, LeveldbBatchGuard, SharedLeveldb, SharedLeveldbAccess}; diff --git a/src/storage/shared_leveldb.rs b/src/storage/shared_leveldb.rs new file mode 100644 index 0000000..12b112f --- /dev/null +++ b/src/storage/shared_leveldb.rs @@ -0,0 +1,175 @@ +use rusty_leveldb::{Options, Status, WriteBatch, DB as Database}; +use std::cell::RefCell; +use std::path::Path; +use std::rc::Rc; + +#[derive(Debug)] +pub enum BatchError { + Unsupported, + AlreadyActive, + Commit(Status), +} + +pub struct SharedLeveldb { + db: RefCell, + active_batch: RefCell>, + #[cfg(test)] + commit_fail_status: RefCell>, +} + +impl SharedLeveldb { + pub fn open>(path: P) -> Result, Status> { + let opts = Options { + create_if_missing: true, + ..Default::default() + }; + let db = Database::open(path, opts)?; + Ok(Rc::new(Self { + db: RefCell::new(db), + active_batch: RefCell::new(None), + #[cfg(test)] + commit_fail_status: RefCell::new(None), + })) + } + + pub fn begin_batch(&self) -> Result, BatchError> { + let mut slot = self.active_batch.borrow_mut(); + if slot.is_some() { + return Err(BatchError::AlreadyActive); + } + *slot = Some(WriteBatch::default()); + Ok(LeveldbBatchGuard { + shared: self, + committed: false, + }) + } + + fn commit_batch(&self) -> Result<(), Status> { + let mut slot = self.active_batch.borrow_mut(); + let Some(batch) = slot.take() else { + return Ok(()); + }; + #[cfg(test)] + if let Some(status) = self.commit_fail_status.borrow_mut().take() { + return Err(status); + } + self.db.borrow_mut().write(batch, true) + } + + fn abort_batch(&self) { + self.active_batch.borrow_mut().take(); + } + + pub fn with_active_batch(&self, f: F) -> Option + where + F: FnOnce(&mut WriteBatch) -> R, + { + let mut slot = self.active_batch.borrow_mut(); + slot.as_mut().map(f) + } + + pub fn db(&self) -> &RefCell { + &self.db + } +} + +pub struct LeveldbBatchGuard<'a> { + shared: &'a SharedLeveldb, + committed: bool, +} + +impl<'a> LeveldbBatchGuard<'a> { + pub fn commit(mut self) -> Result<(), Status> { + self.shared.commit_batch()?; + self.committed = true; + Ok(()) + } +} + +impl Drop for LeveldbBatchGuard<'_> { + fn drop(&mut self) { + if !self.committed { + self.shared.abort_batch(); + } + } +} + +pub trait SharedLeveldbAccess { + fn shared_leveldb(&self) -> Option>; +} + +#[cfg(test)] +impl SharedLeveldb { + pub fn inject_commit_failure(&self, status: Status) { + self.commit_fail_status.borrow_mut().replace(status); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use tempfile::tempdir; + + #[test] + fn begin_batch_prevents_nested_batches() { + let dir = tempdir().unwrap(); + let shared = SharedLeveldb::open(dir.path()).expect("open shared db"); + + let guard = shared.begin_batch().expect("begin first batch"); + match shared.begin_batch() { + Err(BatchError::AlreadyActive) => {} + Ok(_) => panic!("expected AlreadyActive error, got Ok"), + Err(err) => panic!("unexpected batch error: {err:?}"), + } + drop(guard); + + shared + .begin_batch() + .expect("batch should be available after guard drop") + .commit() + .expect("commit empty batch"); + } + + #[test] + fn commit_batch_persists_operations() { + let dir = tempdir().unwrap(); + let shared = SharedLeveldb::open(dir.path()).expect("open shared db"); + + let guard = shared.begin_batch().expect("begin batch"); + let key = b"test-key"; + let value = b"test-value"; + + let inserted = shared.with_active_batch(|batch| batch.put(key, value)); + assert!(inserted.is_some(), "expected active batch to exist"); + + guard.commit().expect("commit batch"); + + let stored = shared + .db() + .borrow_mut() + .get(key) + .expect("value should exist after commit"); + assert_eq!(stored.as_slice(), value); + } + + #[test] + fn dropping_guard_discards_pending_operations() { + let dir = tempdir().unwrap(); + let shared = SharedLeveldb::open(dir.path()).expect("open shared db"); + let key = b"discard-key"; + let value = b"discard-value"; + + { + let _guard = shared.begin_batch().expect("begin batch"); + let inserted = shared.with_active_batch(|batch| batch.put(key, value)); + assert!(inserted.is_some(), "expected active batch to exist"); + // guard dropped here without commit + } + + let result = shared.db().borrow_mut().get(key); + assert!( + result.is_none(), + "value should not be persisted when batch guard is dropped without commit" + ); + } +}