wnfs 0.3.0

WebNative filesystem core implementation
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::{
    error::AccessKeyError,
    private::{PrivateRef, SnapshotKey, TemporalKey},
};
use anyhow::{Result, bail};
use serde::{Deserialize, Serialize};
use wnfs_common::{Cid, HashOutput};

//--------------------------------------------------------------------------------------------------
// Type Definitions
//--------------------------------------------------------------------------------------------------

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum AccessKey {
    #[serde(rename = "wnfs/share/temporal")]
    Temporal(TemporalAccessKey),
    #[serde(rename = "wnfs/share/snapshot")]
    Snapshot(SnapshotAccessKey),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct TemporalAccessKey {
    #[serde(with = "serde_byte_array")]
    pub(crate) label: HashOutput,
    pub(crate) content_cid: Cid,
    pub(crate) temporal_key: TemporalKey,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct SnapshotAccessKey {
    #[serde(with = "serde_byte_array")]
    pub label: HashOutput,
    pub content_cid: Cid,
    pub snapshot_key: SnapshotKey,
}

//--------------------------------------------------------------------------------------------------
// Implementations
//--------------------------------------------------------------------------------------------------

impl AccessKey {
    pub fn parse(bytes: impl AsRef<[u8]>) -> Result<Self> {
        Ok(serde_ipld_dagcbor::from_slice(bytes.as_ref())?)
    }

    pub fn to_bytes(&self) -> Result<Vec<u8>> {
        Ok(serde_ipld_dagcbor::to_vec(self)?)
    }

    pub fn get_label(&self) -> &HashOutput {
        match self {
            Self::Temporal(key) => &key.label,
            Self::Snapshot(key) => &key.label,
        }
    }

    pub fn get_temporal_key(&self) -> Result<&TemporalKey> {
        let Self::Temporal(key) = self else {
            bail!(AccessKeyError::UnsupportedSnapshotPrivateRefDerive)
        };

        Ok(&key.temporal_key)
    }

    pub fn get_snapshot_key(&self) -> SnapshotKey {
        match self {
            Self::Temporal(t) => t.temporal_key.derive_snapshot_key(),
            Self::Snapshot(s) => s.snapshot_key.clone(),
        }
    }

    pub fn get_content_cid(&self) -> &Cid {
        match self {
            Self::Temporal(key) => &key.content_cid,
            Self::Snapshot(key) => &key.content_cid,
        }
    }

    pub(crate) fn derive_private_ref(&self) -> Result<PrivateRef> {
        // TODO(appcypher): SnapshotAccessKey currently not supported for PrivateRef.
        let Self::Temporal(key) = self else {
            bail!(AccessKeyError::UnsupportedSnapshotPrivateRefDerive)
        };

        Ok(PrivateRef::with_temporal_key(
            key.label,
            key.temporal_key.clone(),
            key.content_cid,
        ))
    }
}

impl From<&PrivateRef> for TemporalAccessKey {
    fn from(private_ref: &PrivateRef) -> Self {
        Self {
            label: private_ref.label,
            content_cid: private_ref.content_cid,
            temporal_key: private_ref.temporal_key.clone(),
        }
    }
}

impl From<&PrivateRef> for SnapshotAccessKey {
    fn from(private_ref: &PrivateRef) -> Self {
        Self {
            label: private_ref.label,
            content_cid: private_ref.content_cid,
            snapshot_key: private_ref.temporal_key.derive_snapshot_key(),
        }
    }
}

//--------------------------------------------------------------------------------------------------
// Tests
//--------------------------------------------------------------------------------------------------

#[cfg(test)]
mod snapshot_tests {
    use super::*;
    use rand::Rng;
    use rand_chacha::ChaCha12Rng;
    use rand_core::SeedableRng;
    use testresult::TestResult;

    #[async_std::test]
    async fn test_access_key() -> TestResult {
        let rng = &mut ChaCha12Rng::seed_from_u64(0);

        let private_ref =
            PrivateRef::with_temporal_key(rng.r#gen(), TemporalKey(rng.r#gen()), Cid::default());

        let temporal_access_key = AccessKey::Temporal(TemporalAccessKey::from(&private_ref));
        let snapshot_access_key = AccessKey::Snapshot(SnapshotAccessKey::from(&private_ref));

        let temp_key = as_dag_json_value(&temporal_access_key)?;
        let snap_key = as_dag_json_value(&snapshot_access_key)?;

        insta::assert_json_snapshot!(temp_key);
        insta::assert_json_snapshot!(snap_key);

        Ok(())
    }

    fn as_dag_json_value(s: impl Serialize) -> Result<serde_json::Value> {
        let dag_json = serde_ipld_dagjson::to_vec(&s)?;
        let value = serde_json::from_slice(&dag_json)?;
        Ok(value)
    }
}