Enum ExecError 

#[non_exhaustive]
pub enum ExecError {
    ConsentRequired,
    UnsupportedNetworkPolicy,
    WorktreeNotReadOnly,
    InvalidAnalyzerId(String),
    AnalyzerMismatch {
        requested: String,
        reported: String,
    },
    UnsupportedSchema {
        found: String,
        expected: &'static str,
    },
    MalformedReport(String),
    TooManyFindings {
        count: usize,
        max: usize,
    },
    DuplicateFinding(String),
    PathEscapesWorktree(String),
    Identity(FindingsError),
    UnknownAnalyzer {
        requested: String,
        known: String,
    },
    Json(Error),
}

Errors an analyzer backend can raise.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ConsentRequired

The request did not carry explicit user consent. Running an analyzer is never implicit, whatever the backend.

UnsupportedNetworkPolicy

The request asked for a network policy this backend will not honour. Egress is denied; an analyzer’s inputs are pre-provisioned, never fetched mid-run.

WorktreeNotReadOnly

The request asked for a writable worktree. Analyzers parse source, manifests and lockfiles; none of them needs to write to the tree.

InvalidAnalyzerId(String)

The requested analyzer id is not well-formed: an analyzer id is 1..=MAX_ANALYZER_ID characters of lowercase [a-z0-9._-].

The message is produced by rto_graph::analyzer_id_error, the same function rto-graph’s own rejection uses, so an id refused here reads exactly as it would had the store caught it — and it names the rule that was broken, not just the contract.

AnalyzerMismatch

The report describes a different analyzer than the one requested — a mixed-up file, or a report substituted for another.

Fields

requested: String

The analyzer the caller asked for.

reported: String

The analyzer the report claims to be from.

UnsupportedSchema

The report’s schema tag is not one this build understands.

Fields

found: String

The tag the report carried.

expected: &'static str

The tag this build accepts.

MalformedReport(String)

The report is structurally valid JSON but does not describe a usable run.

TooManyFindings

The report declares more findings than will be accepted in one run.

Fields

count: usize

How many the report declared.

max: usize

The accepted ceiling.

DuplicateFinding(String)

Two findings in one report share an identity, so one would silently shadow the other.

PathEscapesWorktree(String)

A finding claimed a path outside the analyzed worktree.

Identity(FindingsError)

A finding’s identity components were not usable as a stable key.

UnknownAnalyzer

This build has no adapter for the requested analyzer, so it can neither run it nor read its native output.

Fields

requested: String

The analyzer the caller asked for.

known: String

The analyzer ids this build does know, comma-separated.

Json(Error)

The report was not valid JSON.

Trait Implementations

impl Debug for ExecError

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

Formats the value using the given formatter.

impl Display for ExecError

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

Formats the value using the given formatter.

impl Error for ExecError

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 ExecError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FindingsError> for ExecError

fn from(source: FindingsError) -> Self

Converts to this type from the input type.