ipld-car 0.1.0

DAG-PB serialization/deserialization library for IPFS CAR v1 archives
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

#[cfg(feature = "vfs")]
use crate::error::vfs_err;

use libipld::Cid;
use std::{
	io,
	path::{Path, PathBuf},
};
use thiserror::Error;
#[cfg(feature = "vfs")]
use vfs::error::{VfsError, VfsErrorKind};

#[cfg_attr(feature = "std", derive(Debug))]
#[derive(Error)]
pub enum InvalidErr {
	#[error("Path `{0:?}` is NOT a directory")]
	NotADirectory(PathBuf),
	#[error("Path `{0:?}` IS a directory")]
	IsADirectory(PathBuf),
	#[error("Invalid file name in path `{0:?}`")]
	FileName(PathBuf),
	#[error("Path is not an utf-8: `{0:?}`")]
	NotUtf8Path(PathBuf),
	#[error("Directory `{0:?}` already exists")]
	AlreadyExists(PathBuf),
	#[error("Path `{0:?}` points to unavailable block (cid={1}) in this CAR")]
	IsAMissingBlock(PathBuf, String),

	#[error("Header length is invalid")]
	HeaderLen,
	#[error("Block length is invalid")]
	BlockLen,
	#[error("Invalid CBOR header: {0}")]
	CborDec(#[from] ciborium::de::Error<io::Error>),
	#[error("Invalid CBOR value: {0}")]
	CborEnc(String),
	#[error("Invalid CID: {0}")]
	Cid(#[from] libipld::cid::Error),
	#[error("Config builder failed: {0}")]
	ConfigBuilder(String),
}

impl InvalidErr {
	pub fn not_a_dir<P: AsRef<Path>>(path: P) -> Self {
		Self::NotADirectory(path.as_ref().to_owned())
	}

	pub fn is_a_dir<P: AsRef<Path>>(path: P) -> Self {
		Self::IsADirectory(path.as_ref().to_owned())
	}

	pub fn file_name<P: AsRef<Path>>(path: P) -> Self {
		Self::FileName(path.as_ref().to_owned())
	}

	pub fn not_utf8_path<P: AsRef<Path>>(path: P) -> Self {
		Self::NotUtf8Path(path.as_ref().to_owned())
	}

	pub fn exists<P: AsRef<Path>>(path: P) -> Self {
		Self::AlreadyExists(path.as_ref().to_owned())
	}

	pub fn is_a_miss_block<P: AsRef<Path>>(path: P, cid: &Cid) -> Self {
		Self::IsAMissingBlock(path.as_ref().to_owned(), cid.to_string())
	}
}

#[cfg(feature = "vfs")]
impl From<InvalidErr> for VfsError {
	fn from(ci: InvalidErr) -> Self {
		match ci {
			InvalidErr::AlreadyExists(..) => VfsErrorKind::DirectoryExists.into(),
			InvalidErr::CborDec(cbor) => VfsErrorKind::Other(cbor.to_string()).into(),
			InvalidErr::CborEnc(cbor) => VfsErrorKind::Other(cbor).into(),
			InvalidErr::Cid(cid) => VfsErrorKind::Other(cid.to_string()).into(),
			e => vfs_err(VfsErrorKind::NotSupported, e),
		}
	}
}