Struct Request 

pub struct Request<T: RequestState> {
    pub state: T,
    pub data: RequestData,
}

A request to be processed by the fusillade system.

Uses the typestate pattern to ensure type-safe state transitions. The generic parameter T represents the current state of the request.

Example

let pending_request = Request {
    state: Pending {},
    data: request_data,
};
// Can only call operations valid for Pending state

Fields

state: T

The current state of the request.

data: RequestData

The user-supplied request data.

Implementations

impl Request<Pending>

pub async fn claim<S: Storage + ?Sized>( self, daemon_id: DaemonId, storage: &S, ) -> Result<Request<Claimed>>

pub async fn cancel<S: Storage + ?Sized>( self, storage: &S, ) -> Result<Request<Canceled>>

impl Request<Claimed>

pub async fn unclaim<S: Storage + ?Sized>( self, storage: &S, ) -> Result<Request<Pending>>

pub async fn cancel<S: Storage + ?Sized>( self, storage: &S, ) -> Result<Request<Canceled>>

pub async fn process<H: HttpClient + 'static, S: Storage>( self, http_client: H, timeout_ms: u64, storage: &S, ) -> Result<Request<Processing>>

impl Request<Failed>

pub fn can_retry( self, retry_attempt: u32, config: RetryConfig, ) -> Result<Request<Pending>, Box<Self>>

Attempt to retry this failed request.

If retries are available, transitions the request back to Pending with:

• Incremented retry_attempt
• Calculated not_before timestamp for exponential backoff

If no retries remain, returns None and the request stays Failed.

The retry logic considers:

• max_retries: Hard cap on total retry attempts
• stop_before_deadline_ms: Deadline-aware retry (stops before batch expiration)

impl Request<Processing>

pub async fn complete<S, F, Fut>( self, storage: &S, should_retry: F, cancellation: Fut, ) -> Result<RequestCompletionResult>

where S: Storage + ?Sized, F: Fn(&HttpResponse) -> bool, Fut: Future<Output = CancellationReason>,

Wait for the HTTP request to complete.

This method awaits the result from the spawned HTTP task and transitions the request to one of three terminal states: Completed, Failed, or Canceled.

The should_retry predicate determines whether a response should be considered a failure (and thus eligible for retry) or a success.

The cancellation future allows external cancellation of the request. It should resolve to a CancellationReason:

• CancellationReason::User: User-initiated cancellation (persists Canceled state)
• CancellationReason::Shutdown: Daemon shutdown (aborts HTTP but doesn’t persist)
• CancellationReason::Superseded: Request superseded by racing pair (aborts HTTP but doesn’t persist)

Returns:

• RequestCompletionResult::Completed if the HTTP request succeeded
• RequestCompletionResult::Failed if the HTTP request failed or should be retried
• RequestCompletionResult::Canceled if the request was canceled by user
• Err(FusilladeError::Shutdown) if the daemon is shutting down or request was superseded

pub async fn cancel<S: Storage + ?Sized>( self, storage: &S, ) -> Result<Request<Canceled>>

Trait Implementations

impl<T: Clone + RequestState> Clone for Request<T>

fn clone(&self) -> Request<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + RequestState> Debug for Request<T>

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

Formats the value using the given formatter.

impl From<Request<Canceled>> for AnyRequest

fn from(r: Request<Canceled>) -> Self

Converts to this type from the input type.

impl From<Request<Claimed>> for AnyRequest

fn from(r: Request<Claimed>) -> Self

Converts to this type from the input type.

impl From<Request<Completed>> for AnyRequest

fn from(r: Request<Completed>) -> Self

Converts to this type from the input type.

impl From<Request<Failed>> for AnyRequest

fn from(r: Request<Failed>) -> Self

Converts to this type from the input type.

impl From<Request<Pending>> for AnyRequest

fn from(r: Request<Pending>) -> Self

Converts to this type from the input type.

impl From<Request<Processing>> for AnyRequest

fn from(r: Request<Processing>) -> Self

Converts to this type from the input type.

impl From<Request<Superseded>> for AnyRequest

fn from(r: Request<Superseded>) -> Self

Converts to this type from the input type.

impl<T> Serialize for Request<T>

where T: Serialize + RequestState,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.