monofs 0.2.1

`monofs` is an immutable distributed file system.
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
152
153
154
155
156

use std::fmt::{self, Debug};

use monoutils_store::{ipld::cid::Cid, IpldStore, Storable, StoreError, StoreResult};

use crate::filesystem::{Dir, File, FsError, FsResult, Metadata, SoftLink};

//--------------------------------------------------------------------------------------------------
// Types
//--------------------------------------------------------------------------------------------------

/// This is an entity in the file system.
#[derive(Clone)]
pub enum Entity<S>
where
    S: IpldStore,
{
    /// A file.
    File(File<S>),

    /// A directory.
    Dir(Dir<S>),

    /// A softlink.
    SoftLink(SoftLink<S>),
}

//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------

impl<S> Entity<S>
where
    S: IpldStore,
{
    /// Returns true if the entity is a file.
    pub fn is_file(&self) -> bool {
        matches!(self, Entity::File(_))
    }

    /// Returns true if the entity is a directory.
    pub fn is_dir(&self) -> bool {
        matches!(self, Entity::Dir(_))
    }

    /// Tries to convert the entity to a file.
    pub fn into_file(self) -> FsResult<File<S>> {
        if let Entity::File(file) = self {
            return Ok(file);
        }
        Err(FsError::NotAFile(String::new()))
    }

    /// Tries to convert the entity to a directory.
    pub fn into_dir(self) -> FsResult<Dir<S>> {
        if let Entity::Dir(dir) = self {
            return Ok(dir);
        }

        Err(FsError::NotADirectory(String::new()))
    }

    /// Tries to convert the entity to a softlink.
    pub fn into_softlink(self) -> FsResult<SoftLink<S>> {
        if let Entity::SoftLink(softlink) = self {
            return Ok(softlink);
        }

        Err(FsError::NotASoftLink(String::new()))
    }

    /// Returns the metadata for the directory.
    pub fn get_metadata(&self) -> &Metadata {
        match self {
            Entity::File(file) => file.get_metadata(),
            Entity::Dir(dir) => dir.get_metadata(),
            Entity::SoftLink(softlink) => softlink.get_metadata(),
        }
    }

    /// Returns the CID of the entity when it was initially loaded from the store.
    pub fn get_initial_load_cid(&self) -> Option<&Cid> {
        match self {
            Entity::File(file) => file.get_initial_load_cid(),
            Entity::Dir(dir) => dir.get_initial_load_cid(),
            Entity::SoftLink(softlink) => softlink.get_initial_load_cid(),
        }
    }

    /// Returns the CID of the previous version of the entity if there is one.
    pub fn get_previous(&self) -> Option<&Cid> {
        match self {
            Entity::File(file) => file.get_previous(),
            Entity::Dir(dir) => dir.get_previous(),
            Entity::SoftLink(softlink) => softlink.get_previous(),
        }
    }

    /// Returns the store used to persist the entity.
    pub fn get_store(&self) -> &S {
        match self {
            Entity::File(file) => file.get_store(),
            Entity::Dir(dir) => dir.get_store(),
            Entity::SoftLink(softlink) => softlink.get_store(),
        }
    }
}

//--------------------------------------------------------------------------------------------------
// Trait Implementations
//--------------------------------------------------------------------------------------------------

impl<S> Storable<S> for Entity<S>
where
    S: IpldStore + Send + Sync,
{
    async fn store(&self) -> StoreResult<Cid> {
        match self {
            Entity::File(file) => file.store().await,
            Entity::Dir(dir) => dir.store().await,
            Entity::SoftLink(softlink) => softlink.store().await,
        }
    }

    async fn load(cid: &Cid, store: S) -> StoreResult<Self> {
        // The order of the following `if let` statements is important because for some reason
        // Directory entity deserializes successfully into a File entity even though they have
        // different structure. This is likely due to the way `serde_ipld_dagcbor` deserializes
        // the entities.
        if let Ok(softlink) = SoftLink::load(cid, store.clone()).await {
            return Ok(Entity::SoftLink(softlink));
        }

        if let Ok(dir) = Dir::load(cid, store.clone()).await {
            return Ok(Entity::Dir(dir));
        }

        if let Ok(file) = File::load(cid, store.clone()).await {
            return Ok(Entity::File(file));
        }

        Err(StoreError::custom(FsError::UnableToLoadEntity(*cid)))
    }
}

impl<S> Debug for Entity<S>
where
    S: IpldStore,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Entity::File(file) => f.debug_tuple("File").field(file).finish(),
            Entity::Dir(dir) => f.debug_tuple("Dir").field(dir).finish(),
            Entity::SoftLink(softlink) => f.debug_tuple("SoftLink").field(softlink).finish(),
        }
    }
}