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
21pub const FILE_DESCRIPTOR_SET: &[u8] = tonic::include_file_descriptor_set!("snix.castore.v1");
25
26#[cfg(test)]
27mod tests;
28
29#[derive(Debug, PartialEq, Eq, thiserror::Error)]
31pub enum ValidateStatBlobResponseError {
32 #[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 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 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 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 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 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 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 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 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}