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
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

use crate::{bounded_reader::error::BoundedReaderErr, ContentAddressableArchive};

use ciborium::ser::Error as CborSerErr;
use std::{
	convert::Infallible,
	io::{self, IntoInnerError, Read, Seek},
	path::{Path, PathBuf},
	sync::{MutexGuard, PoisonError},
};
#[cfg(feature = "vfs")]
use vfs::error::{VfsError, VfsErrorKind};

mod not_found;
pub use not_found::NotFoundErr;
mod not_supported;
pub use not_supported::NotSupportedErr;
mod invalid;
pub use invalid::InvalidErr;
mod dag_pb;
pub use dag_pb::{DagPbErr, DagPbResult, UnixFsErr};
mod loop_detected;
pub use loop_detected::LoopDetectedErr;

pub type Result<T> = std::result::Result<T, Error>;

#[cfg_attr(feature = "std", derive(Debug))]
#[derive(thiserror::Error)]
pub enum Error {
	#[error("More than one block ({0}) on path `{1:?}`")]
	MoreThanOneMatchOnPath(usize, PathBuf),
	#[error("File too large")]
	FileTooLarge,
	#[error("CAR lock is poisoned")]
	Poison,
	#[error("CID codec `{0}` is not supported")]
	CodecNotSupported(u64),

	#[error(transparent)]
	LoopDetected(#[from] LoopDetectedErr),
	#[error(transparent)]
	Hasher(#[from] libipld::multihash::Error),
	#[error(transparent)]
	NotFound(#[from] NotFoundErr),
	#[error(transparent)]
	NotSupported(#[from] NotSupportedErr),
	#[error(transparent)]
	Invalid(#[from] InvalidErr),
	#[error(transparent)]
	Io(#[from] io::Error),
	#[error(transparent)]
	BoundedReader(#[from] BoundedReaderErr),
	#[error(transparent)]
	DagPb(#[from] DagPbErr),
}

impl Error {
	pub fn more_than_one(matches: usize, path: &Path) -> Self {
		Self::MoreThanOneMatchOnPath(matches, path.to_owned())
	}
}

#[cfg(feature = "vfs")]
impl From<Error> for VfsError {
	fn from(ce: Error) -> Self {
		match ce {
			Error::NotSupported(not_supported) => not_supported.into(),
			Error::Io(io_err) => VfsErrorKind::IoError(io_err).into(),
			Error::NotFound(not_found) => not_found.into(),
			Error::Invalid(invalid) => invalid.into(),
			e => VfsErrorKind::Other(e.to_string()).into(),
		}
	}
}

impl From<Infallible> for Error {
	fn from(_: Infallible) -> Self {
		unreachable!("Infallible error");
	}
}

impl<T> From<IntoInnerError<T>> for Error {
	fn from(inner_err: IntoInnerError<T>) -> Self {
		Self::Io(inner_err.into())
	}
}

impl From<CborSerErr<io::Error>> for Error {
	fn from(e: CborSerErr<io::Error>) -> Self {
		match e {
			CborSerErr::Io(io_err) => Error::Io(io_err),
			CborSerErr::Value(msg) => Error::Invalid(InvalidErr::CborEnc(msg)),
		}
	}
}

impl<T: Read + Seek> From<PoisonError<MutexGuard<'_, ContentAddressableArchive<T>>>> for Error {
	#[inline]
	fn from(_: PoisonError<MutexGuard<'_, ContentAddressableArchive<T>>>) -> Self {
		Self::Poison
	}
}

/// Creates a `VfsError` using `kind` and `context`.
#[cfg(feature = "vfs")]
pub(crate) fn vfs_err<S>(kind: VfsErrorKind, context: S) -> VfsError
where
	S: std::fmt::Display + Send + Sync + 'static,
{
	VfsError::from(kind).with_context(move || context.to_string())
}