Enum FatalStorageError

pub enum FatalStorageError {
    CreateDatabaseDirectory(PathBuf, Error),
    DuplicateEraIdIndex {
        era_id: EraId,
        first: BlockHash,
        second: BlockHash,
    },
    FailedToOverwriteBlock,
    DatabaseNotFound(RecordId),
    UnableToMoveFile {
        source_path: PathBuf,
        dest_path: PathBuf,
        original_error: Error,
    },
    MissingStorageFiles {
        missing_files: Vec<PathBuf>,
    },
    BlockValidation(BlockValidationError),
    BlockHeaderNotStoredUnderItsHash {
        queried_block_hash_bytes: Vec<u8>,
        found_block_header_hash: BlockHash,
        block_header: Box<BlockHeader>,
    },
    NoBlockHeaderForBlockBody {
        block_body_hash: Digest,
        block_body: Box<BlockBody>,
    },
    SignatureVerification(Error),
    CorruptedBlockSignatureIndex {
        raw_key: Vec<u8>,
        block_hash_bytes: Vec<u8>,
    },
    InvalidSwitchBlock(Box<BlockHeader>),
    UnexpectedBlockBodyPart {
        block_body_hash: Digest,
        part_hash: Digest,
    },
    StoredItemSerializationFailure(Error),
    UnexpectedFinalizedApprovals {
        transaction_hash: TransactionHash,
    },
    UnexpectedSerializationFailure(Error),
    UnexpectedDeserializationFailure(Error),
    ApprovalsHashesLengthMismatch {
        block_hash: BlockHash,
        expected: usize,
        actual: usize,
    },
    InvalidExecutionResultsV1Length {
        deploy_hash: DeployHash,
        results_length: usize,
    },
    Prometheus(Error),
    VariantMismatch(VariantMismatch),
    BlockStoreError(BlockStoreError),
    UnexpectedRecordId(RecordId),
}

A fatal storage component error.

An error of this kinds indicates that storage is corrupted or otherwise irrecoverably broken, at least for the moment. It should usually be followed by swift termination of the node.

Variants

CreateDatabaseDirectory(PathBuf, Error)

Failure to create the root database directory.

DuplicateEraIdIndex

Found a duplicate switch-block-at-era-id index entry.

Fields

era_id: EraId

Era ID at which duplicate was found.

first: BlockHash

First block hash encountered at era_id.

second: BlockHash

Second block hash encountered at era_id.

FailedToOverwriteBlock

An internal DB error - blocks should be overwritten.

DatabaseNotFound(RecordId)

Record specified in raw request has not been found in the storage module.

UnableToMoveFile

Filesystem error while trying to move file.

Fields

source_path: PathBuf

The path to the file that should have been moved.

dest_path: PathBuf

The path where the file should have been moved to.

original_error: Error

The original io::Error from fs::rename.

MissingStorageFiles

Mix of missing and found storage files.

Fields

missing_files: Vec<PathBuf>

The files that were not be found in the storage directory.

BlockValidation(BlockValidationError)

Error when validating a block.

BlockHeaderNotStoredUnderItsHash

A block header was not stored under its hash.

Fields

queried_block_hash_bytes: Vec<u8>

The queried block hash.

found_block_header_hash: BlockHash

The actual header of the block hash.

block_header: Box<BlockHeader>

The block header found in storage.

NoBlockHeaderForBlockBody

Block body did not have a block header.

Fields

block_body_hash: Digest

The block body hash.

block_body: Box<BlockBody>

The block body.

SignatureVerification(Error)

Could not verify finality signatures for block.

CorruptedBlockSignatureIndex

Corrupted block signature index.

Fields

raw_key: Vec<u8>

The key in the block signature index.

block_hash_bytes: Vec<u8>

The block hash of the signatures found in the index.

InvalidSwitchBlock(Box<BlockHeader>)

Switch block does not contain era end.

UnexpectedBlockBodyPart

A block body was found to have more parts than expected.

Fields

block_body_hash: Digest

The block body with the issue.

part_hash: Digest

The hash of the superfluous body part.

StoredItemSerializationFailure(Error)

Failed to serialize an item that was found in local storage.

UnexpectedFinalizedApprovals

We tried to store finalized approvals for a nonexistent transaction.

Fields

transaction_hash: TransactionHash

The missing transaction hash.

UnexpectedSerializationFailure(Error)

ToBytes serialization failure of an item that should never fail to serialize.

UnexpectedDeserializationFailure(Error)

ToBytes deserialization failure of an item that should never fail to serialize.

ApprovalsHashesLengthMismatch

Stored finalized approvals hashes count doesn’t match number of deploys.

Fields

block_hash: BlockHash

The block hash.

expected: usize

The number of deploys in the block.

actual: usize

The number of approvals hashes.

InvalidExecutionResultsV1Length

V1 execution results hashmap doesn’t have exactly one entry.

Fields

deploy_hash: DeployHash

The deploy hash.

results_length: usize

The number of execution results.

Prometheus(Error)

Error initializing metrics.

VariantMismatch(VariantMismatch)

Type mismatch indicating programmer error.

BlockStoreError(BlockStoreError)

BlockStoreError

UnexpectedRecordId(RecordId)

BlockStoreError

Trait Implementations

impl Debug for FatalStorageError

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

Formats the value using the given formatter.

impl Display for FatalStorageError

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

Formats the value using the given formatter.

impl Error for FatalStorageError

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<BlockStoreError> for FatalStorageError

fn from(source: BlockStoreError) -> Self

Converts to this type from the input type.

impl From<BlockValidationError> for FatalStorageError

fn from(source: BlockValidationError) -> Self

Converts to this type from the input type.

impl From<Box<BlockValidationError>> for FatalStorageError

fn from(err: Box<BlockValidationError>) -> Self

Converts to this type from the input type.

impl From<Error> for FatalStorageError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<VariantMismatch> for FatalStorageError

fn from(source: VariantMismatch) -> Self

Converts to this type from the input type.