Skip to main content

snix_castore/proto/
mod.rs

1use prost::Message;
2
3use std::cmp::Ordering;
4
5mod grpc_blobstore_wrapper;
6mod grpc_chunkstore_wrapper;
7mod grpc_directoryservice_wrapper;
8
9mod blobstore;
10mod chunkstore;
11mod url;
12
13use crate::{B3Digest, DirectoryError, path::PathComponent};
14pub use grpc_blobstore_wrapper::GRPCBlobStoreWrapper;
15pub use grpc_chunkstore_wrapper::GRPCChunkStoreWrapper;
16pub use grpc_directoryservice_wrapper::GRPCDirectoryServiceWrapper;
17pub use url::{parse_infused_nar_path, parse_urlsafe_proto, write_infused_nar_path};
18
19tonic::include_proto!("snix.castore.v1");
20
21/// Compiled file descriptors for implementing [gRPC
22/// reflection](https://github.com/grpc/grpc/blob/master/doc/server-reflection.md) with e.g.
23/// [`tonic_reflection`](https://docs.rs/tonic-reflection).
24pub const FILE_DESCRIPTOR_SET: &[u8] = tonic::include_file_descriptor_set!("snix.castore.v1");
25
26#[cfg(test)]
27mod tests;
28
29/// Errors that occur during StatBlobResponse validation
30#[derive(Debug, PartialEq, Eq, thiserror::Error)]
31pub enum ValidateStatBlobResponseError {
32    /// Invalid digest length encountered
33    #[error("Invalid digest length {0} for chunk #{1}")]
34    InvalidDigestLen(usize, usize),
35}
36
37fn checked_sum(iter: impl IntoIterator<Item = u64>) -> Option<u64> {
38    iter.into_iter().try_fold(0u64, |acc, i| acc.checked_add(i))
39}
40
41impl Directory {
42    /// The size of a directory is the number of all regular and symlink elements,
43    /// the number of directory elements (counted twice for historical reasons),
44    /// and their size fields.
45    pub fn size(&self) -> u64 {
46        if cfg!(debug_assertions) {
47            self.size_checked()
48                .expect("Directory::size exceeds u64::MAX")
49        } else {
50            self.size_checked().unwrap_or(u64::MAX)
51        }
52    }
53
54    fn size_checked(&self) -> Option<u64> {
55        checked_sum([
56            self.files.len().try_into().ok()?,
57            self.symlinks.len().try_into().ok()?,
58            self.directories.len().try_into().ok()?,
59            checked_sum(self.directories.iter().map(|e| e.size))?,
60        ])
61    }
62
63    /// Calculates the digest of a Directory, which is the blake3 hash of a
64    /// Directory protobuf message, serialized in protobuf canonical form.
65    pub fn digest(&self) -> B3Digest {
66        let mut hasher = blake3::Hasher::new();
67
68        hasher
69            .update(&self.encode_to_vec())
70            .finalize()
71            .as_bytes()
72            .into()
73    }
74}
75
76impl TryFrom<Directory> for crate::Directory {
77    type Error = DirectoryError;
78
79    fn try_from(value: Directory) -> Result<Self, Self::Error> {
80        // Check directories, files and symlinks are sorted
81        // We'll notice duplicates across all three fields when constructing the Directory.
82        // FUTUREWORK: use is_sorted() once stable, and/or implement the producer for
83        // [crate::Directory::try_from_iter] iterating over all three and doing all checks inline.
84        value
85            .directories
86            .iter()
87            .try_fold(&b""[..], |prev_name, e| {
88                match e.name.as_ref().cmp(prev_name) {
89                    Ordering::Less => Err(DirectoryError::WrongSorting(e.name.to_owned())),
90                    Ordering::Equal => Err(DirectoryError::DuplicateName(
91                        e.name
92                            .to_owned()
93                            .try_into()
94                            .map_err(DirectoryError::InvalidName)?,
95                    )),
96                    Ordering::Greater => Ok(e.name.as_ref()),
97                }
98            })?;
99        value.files.iter().try_fold(&b""[..], |prev_name, e| {
100            match e.name.as_ref().cmp(prev_name) {
101                Ordering::Less => Err(DirectoryError::WrongSorting(e.name.to_owned())),
102                Ordering::Equal => Err(DirectoryError::DuplicateName(
103                    e.name
104                        .to_owned()
105                        .try_into()
106                        .map_err(DirectoryError::InvalidName)?,
107                )),
108                Ordering::Greater => Ok(e.name.as_ref()),
109            }
110        })?;
111        value.symlinks.iter().try_fold(&b""[..], |prev_name, e| {
112            match e.name.as_ref().cmp(prev_name) {
113                Ordering::Less => Err(DirectoryError::WrongSorting(e.name.to_owned())),
114                Ordering::Equal => Err(DirectoryError::DuplicateName(
115                    e.name
116                        .to_owned()
117                        .try_into()
118                        .map_err(DirectoryError::InvalidName)?,
119                )),
120                Ordering::Greater => Ok(e.name.as_ref()),
121            }
122        })?;
123
124        // FUTUREWORK: use is_sorted() once stable, and/or implement the producer for
125        // [crate::Directory::try_from_iter] iterating over all three and doing all checks inline.
126        let mut elems: Vec<(PathComponent, crate::Node)> =
127            Vec::with_capacity(value.directories.len() + value.files.len() + value.symlinks.len());
128
129        for e in value.directories {
130            elems.push(
131                Entry {
132                    entry: Some(entry::Entry::Directory(e)),
133                }
134                .try_into_name_and_node()?,
135            );
136        }
137
138        for e in value.files {
139            elems.push(
140                Entry {
141                    entry: Some(entry::Entry::File(e)),
142                }
143                .try_into_name_and_node()?,
144            )
145        }
146
147        for e in value.symlinks {
148            elems.push(
149                Entry {
150                    entry: Some(entry::Entry::Symlink(e)),
151                }
152                .try_into_name_and_node()?,
153            )
154        }
155
156        crate::Directory::try_from_iter(elems)
157    }
158}
159
160impl From<crate::Directory> for Directory {
161    fn from(value: crate::Directory) -> Self {
162        let mut directories = vec![];
163        let mut files = vec![];
164        let mut symlinks = vec![];
165
166        for (name, node) in value.into_nodes() {
167            match node {
168                crate::Node::File {
169                    digest,
170                    size,
171                    executable,
172                } => files.push(FileEntry {
173                    name: name.into(),
174                    digest: digest.into(),
175                    size,
176                    executable,
177                }),
178                crate::Node::Directory { digest, size } => directories.push(DirectoryEntry {
179                    name: name.into(),
180                    digest: digest.into(),
181                    size,
182                }),
183                crate::Node::Symlink { target } => {
184                    symlinks.push(SymlinkEntry {
185                        name: name.into(),
186                        target: target.into(),
187                    });
188                }
189            }
190        }
191
192        Directory {
193            directories,
194            files,
195            symlinks,
196        }
197    }
198}
199
200impl Entry {
201    /// Converts a proto [Entry] to a [crate::Node], and splits off the name as a [PathComponent].
202    pub fn try_into_name_and_node(self) -> Result<(PathComponent, crate::Node), DirectoryError> {
203        let (name_bytes, node) = self.try_into_unchecked_name_and_checked_node()?;
204        Ok((
205            name_bytes.try_into().map_err(DirectoryError::InvalidName)?,
206            node,
207        ))
208    }
209
210    /// Converts a proto [Entry] to a [crate::Node], and splits off the name as a
211    /// [bytes::Bytes] without doing any checking of it.
212    fn try_into_unchecked_name_and_checked_node(
213        self,
214    ) -> Result<(bytes::Bytes, crate::Node), DirectoryError> {
215        match self.entry.ok_or_else(|| DirectoryError::NoEntrySet)? {
216            entry::Entry::Directory(n) => {
217                let digest = B3Digest::try_from(n.digest)
218                    .map_err(|e| DirectoryError::InvalidNode(n.name.clone(), e.into()))?;
219
220                let node = crate::Node::Directory {
221                    digest,
222                    size: n.size,
223                };
224
225                Ok((n.name, node))
226            }
227            entry::Entry::File(n) => {
228                let digest = B3Digest::try_from(n.digest)
229                    .map_err(|e| DirectoryError::InvalidNode(n.name.clone(), e.into()))?;
230
231                let node = crate::Node::File {
232                    digest,
233                    size: n.size,
234                    executable: n.executable,
235                };
236
237                Ok((n.name, node))
238            }
239
240            entry::Entry::Symlink(n) => {
241                let node = crate::Node::Symlink {
242                    target: n.target.try_into().map_err(|e| {
243                        DirectoryError::InvalidNode(
244                            n.name.clone(),
245                            crate::ValidateNodeError::InvalidSymlinkTarget(e),
246                        )
247                    })?,
248                };
249
250                Ok((n.name, node))
251            }
252        }
253    }
254
255    /// Converts a proto [Entry] to a [crate::Node], and splits off the name and returns it as a
256    /// [bytes::Bytes].
257    ///
258    /// The name must be empty.
259    pub fn try_into_anonymous_node(self) -> Result<crate::Node, DirectoryError> {
260        let (name, node) = Self::try_into_unchecked_name_and_checked_node(self)?;
261
262        if !name.is_empty() {
263            return Err(DirectoryError::NameInAnonymousNode);
264        }
265
266        Ok(node)
267    }
268
269    /// Constructs an [Entry] from a name and [crate::Node].
270    /// The name is a [bytes::Bytes], not a [PathComponent], as we have use an
271    /// empty name in some places.
272    pub fn from_name_and_node(name: bytes::Bytes, n: crate::Node) -> Self {
273        match n {
274            crate::Node::Directory { digest, size } => Self {
275                entry: Some(entry::Entry::Directory(DirectoryEntry {
276                    name,
277                    digest: digest.into(),
278                    size,
279                })),
280            },
281            crate::Node::File {
282                digest,
283                size,
284                executable,
285            } => Self {
286                entry: Some(entry::Entry::File(FileEntry {
287                    name,
288                    digest: digest.into(),
289                    size,
290                    executable,
291                })),
292            },
293            crate::Node::Symlink { target } => Self {
294                entry: Some(entry::Entry::Symlink(SymlinkEntry {
295                    name,
296                    target: target.into(),
297                })),
298            },
299        }
300    }
301}