holochain_data 0.7.0-dev.10

Database abstraction layer for Holochain using sqlx
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Database kind types for identifying different database instances.
//!
//! This module provides typed identifiers for the different kinds of databases
//! used in Holochain. Each kind implements [`DatabaseIdentifier`] to provide
//! a unique string identifier for the database file.

use crate::DatabaseIdentifier;
use holo_hash::{AgentPubKey, DnaHash};
use holochain_zome_types::cell::CellId;
use std::sync::Arc;

/// Specifies the database used for authoring data by a specific cell.
///
/// Each cell (DNA/Agent pair) has its own authored database.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Authored {
    cell_id: Arc<CellId>,
    id: String,
}

impl DatabaseIdentifier for Authored {
    fn database_id(&self) -> &str {
        &self.id
    }
}

impl Authored {
    /// Create a new authored database identifier for a cell.
    pub fn new(cell_id: Arc<CellId>) -> Self {
        let id = format!("authored-{}-{}", cell_id.dna_hash(), cell_id.agent_pubkey());
        Self { cell_id, id }
    }

    /// Get the DNA hash for this authored database.
    pub fn dna_hash(&self) -> &DnaHash {
        self.cell_id.dna_hash()
    }

    /// Get the agent public key for this authored database.
    pub fn agent_pubkey(&self) -> &AgentPubKey {
        self.cell_id.agent_pubkey()
    }
}

/// Specifies the database used for DHT data for a specific DNA.
///
/// All cells on the same DNA share the same DHT database.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Dht {
    dna_hash: Arc<DnaHash>,
    id: String,
}

impl DatabaseIdentifier for Dht {
    fn database_id(&self) -> &str {
        &self.id
    }
}

impl Dht {
    /// Create a new DHT database identifier for a DNA.
    pub fn new(dna_hash: Arc<DnaHash>) -> Self {
        let id = format!("dht-{dna_hash}");
        Self { dna_hash, id }
    }

    /// Get the DNA hash for this DHT database.
    pub fn dna_hash(&self) -> &DnaHash {
        &self.dna_hash
    }

    /// Get an Arc reference to the DNA hash.
    pub fn to_dna_hash(&self) -> Arc<DnaHash> {
        self.dna_hash.clone()
    }
}

/// Specifies the database used by the Conductor.
///
/// There is only one conductor database per Holochain instance.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Conductor;

impl DatabaseIdentifier for Conductor {
    fn database_id(&self) -> &str {
        "conductor"
    }
}

/// Specifies the database used to save Wasm code.
///
/// There is only one wasm database per Holochain instance.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Wasm;

impl DatabaseIdentifier for Wasm {
    fn database_id(&self) -> &str {
        "wasm"
    }
}

/// Database for storing peer metadata.
///
/// Each DNA has its own peer metadata database.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct PeerMetaStore {
    dna_hash: Arc<DnaHash>,
    id: String,
}

impl DatabaseIdentifier for PeerMetaStore {
    fn database_id(&self) -> &str {
        &self.id
    }
}

impl PeerMetaStore {
    /// Create a new peer metadata database identifier for a DNA.
    pub fn new(dna_hash: Arc<DnaHash>) -> Self {
        let id = format!("p2p-peer-meta-{dna_hash}");
        Self { dna_hash, id }
    }

    /// Get the DNA hash for this peer metadata database.
    pub fn dna_hash(&self) -> &DnaHash {
        &self.dna_hash
    }

    /// Get an Arc reference to the DNA hash.
    pub fn to_dna_hash(&self) -> Arc<DnaHash> {
        self.dna_hash.clone()
    }
}