Enum PackError 

pub enum PackError {
    Io(Error),
    Walk(Error),
    NotADirectory(PathBuf),
    BadPattern {
        pattern: String,
        message: String,
    },
    ManifestSerialize(Error),
    ManifestParse(Error),
    ManifestTooLarge {
        limit: u64,
    },
    MissingManifest,
    UnsupportedFormat {
        found: u32,
        supported: u32,
    },
    DestinationExists(PathBuf),
    EscapingArchivePath(String),
    EscapingManifestPath {
        field: String,
        value: String,
    },
    UnusableArchiveEntry {
        path: String,
        kind: String,
    },
    WriteThroughSymlink {
        path: String,
        via: PathBuf,
    },
}

Errors produced by the pack module.

Variants

Io(Error)

An I/O error while reading the project or writing the archive.

Walk(Error)

The tree walk failed (permission denied, vanished directory, cycle).

NotADirectory(PathBuf)

The given path is not a directory.

BadPattern

A configured glob could not be compiled.

Carries the offending pattern so a typo in [pack] points at itself rather than silently matching nothing.

Fields

pattern: String

The pattern as written in configuration.

message: String

Why it failed to compile.

ManifestSerialize(Error)

The manifest could not be serialized.

ManifestParse(Error)

The manifest could not be parsed.

ManifestTooLarge

The manifest is larger than this build will read into memory.

Reading is what happens before the archive has been judged, so the archive cannot be the one deciding how much memory that takes. Compression makes the difference enormous: a small file expands into as much filler as its author cares to write.

Fields

limit: u64

The largest manifest this build reads, in bytes.

MissingManifest

The archive did not begin with a pack.toml entry.

UnsupportedFormat

The archive was written by a newer pack format than this build reads.

Fields

found: u32

Version recorded in the archive.

supported: u32

Highest version this build understands.

DestinationExists(PathBuf)

The restore destination already exists and would be overwritten.

EscapingArchivePath(String)

An archive entry names a path that would land outside the restore destination (.. or an absolute component).

A pack produced by this crate never contains such an entry, so one that does is not a pack with a blemish — it is not trustworthy at all, and the restore stops rather than extracting the rest of it.

EscapingManifestPath

A manifest field names a path that would land outside the restore destination.

The manifest travels in the archive, so its paths are the archive’s claims about the project just as much as the entry names are — worktree locations and symlink paths are all joined onto the destination. Checked with the same rule and refused the same way; the field is named because the value alone does not say which claim carried it.

Fields

field: String

The manifest key that carried the path.

value: String

The path as the manifest wrote it.

UnusableArchiveEntry

An archive entry is of a type a restore will not materialize.

This crate’s writer produces directories, regular files and symlinks and nothing else, so any other type came from another producer. Device nodes and fifos are not project content, and a hard link names a file the pack does not carry — see crate::restore::HardLinkRecord for why that one is reported rather than followed.

Fields

path: String

The entry as the archive names it.

kind: String

What it is, in the words the report uses.

WriteThroughSymlink

An archive entry would be written through a symlink, which would land it outside the restore destination.

The scan never descends into a symlinked directory, so a legitimate pack has no file entries underneath a link. An archive that routes a write through one is crafted, and the restore stops.

Fields

path: String

The entry that would have been written.

via: PathBuf

The symlink it would have been written through.

Trait Implementations

impl Debug for PackError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for PackError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for PackError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for PackError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for PackError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for PackError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for PackError

fn from(source: Error) -> Self

Converts to this type from the input type.