brokkr-broker::dal::diagnostic_requests

Rust

Data Access Layer for DiagnosticRequest operations.

This module provides functionality to interact with the diagnostic_requests table. It includes methods for creating, claiming, completing, and querying diagnostic requests.

Structs

struct DiagnosticRequestsDAL<'a>

pub

Data Access Layer for DiagnosticRequest operations.

Fields

Name	Type	Description
dal	&'a DAL	Reference to the main DAL instance.

Methods

create

pub

fn create(
    &self,
    new_request: &NewDiagnosticRequest,
) -> Result<DiagnosticRequest, diesel::result::Error>

Creates a new diagnostic request.

Parameters:

Name	Type	Description
new_request	&NewDiagnosticRequest	The diagnostic request to create.

Returns:

Returns the created DiagnosticRequest record.

Source

    pub fn create(
        &self,
        new_request: &NewDiagnosticRequest,
    ) -> Result<DiagnosticRequest, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        diesel::insert_into(diagnostic_requests::table)
            .values(new_request)
            .get_result(conn)
    }

get

pub

fn get(
    &self,
    id: Uuid,
) -> Result<Option<DiagnosticRequest>, diesel::result::Error>

Gets a diagnostic request by ID.

Parameters:

Name	Type	Description
id	Uuid	The diagnostic request UUID.

Returns:

Returns the diagnostic request if found.

Source

    pub fn get(&self, id: Uuid) -> Result<Option<DiagnosticRequest>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        diagnostic_requests::table
            .filter(diagnostic_requests::id.eq(id))
            .first(conn)
            .optional()
    }

get_​pending_​for_​agent

pub

fn get_pending_for_agent(
    &self,
    agent_id: Uuid,
) -> Result<Vec<DiagnosticRequest>, diesel::result::Error>

Gets all pending diagnostic requests for a specific agent.

Parameters:

Name	Type	Description
agent_id	Uuid	The agent UUID.

Returns:

Returns a list of pending diagnostic requests for the agent.

Source

    pub fn get_pending_for_agent(
        &self,
        agent_id: Uuid,
    ) -> Result<Vec<DiagnosticRequest>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        diagnostic_requests::table
            .filter(diagnostic_requests::agent_id.eq(agent_id))
            .filter(diagnostic_requests::status.eq("pending"))
            .filter(diagnostic_requests::expires_at.gt(Utc::now()))
            .order(diagnostic_requests::created_at.asc())
            .load(conn)
    }

claim

pub

fn claim(
    &self,
    id: Uuid,
) -> Result<DiagnosticRequest, diesel::result::Error>

Claims a diagnostic request for processing.

Parameters:

Name	Type	Description
id	Uuid	The diagnostic request UUID.

Returns:

Returns the updated diagnostic request if successful.

Source

    pub fn claim(&self, id: Uuid) -> Result<DiagnosticRequest, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        let update = UpdateDiagnosticRequest {
            status: Some("claimed".to_string()),
            claimed_at: Some(Utc::now()),
            completed_at: None,
        };

        diesel::update(diagnostic_requests::table.filter(diagnostic_requests::id.eq(id)))
            .set(&update)
            .get_result(conn)
    }

complete

pub

fn complete(
    &self,
    id: Uuid,
) -> Result<DiagnosticRequest, diesel::result::Error>

Marks a diagnostic request as completed.

Parameters:

Name	Type	Description
id	Uuid	The diagnostic request UUID.

Returns:

Returns the updated diagnostic request if successful.

Source

    pub fn complete(&self, id: Uuid) -> Result<DiagnosticRequest, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        let update = UpdateDiagnosticRequest {
            status: Some("completed".to_string()),
            claimed_at: None,
            completed_at: Some(Utc::now()),
        };

        diesel::update(diagnostic_requests::table.filter(diagnostic_requests::id.eq(id)))
            .set(&update)
            .get_result(conn)
    }

fail

pub

fn fail(
    &self,
    id: Uuid,
) -> Result<DiagnosticRequest, diesel::result::Error>

Marks a diagnostic request as failed.

Parameters:

Name	Type	Description
id	Uuid	The diagnostic request UUID.

Returns:

Returns the updated diagnostic request if successful.

Source

    pub fn fail(&self, id: Uuid) -> Result<DiagnosticRequest, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        let update = UpdateDiagnosticRequest {
            status: Some("failed".to_string()),
            claimed_at: None,
            completed_at: Some(Utc::now()),
        };

        diesel::update(diagnostic_requests::table.filter(diagnostic_requests::id.eq(id)))
            .set(&update)
            .get_result(conn)
    }

list_​by_​deployment_​object

pub

fn list_by_deployment_object(
    &self,
    deployment_object_id: Uuid,
) -> Result<Vec<DiagnosticRequest>, diesel::result::Error>

Lists all diagnostic requests for a specific deployment object.

Parameters:

Name	Type	Description
deployment_object_id	Uuid	The deployment object UUID.

Returns:

Returns a list of diagnostic requests.

Source

    pub fn list_by_deployment_object(
        &self,
        deployment_object_id: Uuid,
    ) -> Result<Vec<DiagnosticRequest>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        diagnostic_requests::table
            .filter(diagnostic_requests::deployment_object_id.eq(deployment_object_id))
            .order(diagnostic_requests::created_at.desc())
            .load(conn)
    }

expire_​old_​requests

pub

fn expire_old_requests(
    &self,
) -> Result<ExpirySweep, diesel::result::Error>

Sweeps every non-terminal request that has passed its expiry time into a terminal state (BROKKR-T-0300).

Two distinct transitions, deliberately kept distinct:

• pending → expired — the request sat in the queue until its deadline and no agent ever claimed it (the agent is offline, is not polling, or was never going to answer).
• claimed → failed — an agent took the request and never submitted a result, because it crashed, was evicted, lost its PAK, or its pod was rescheduled. completed_at is stamped to match Self::fail, and claimed_at is left intact so the operator can still see which agent accepted the work and when.

Before this sweep existed a claimed request had no reachable terminal state at all: it was never expired, never failed, and therefore never eligible for Self::cleanup_old_requests.

Returns:

Returns the per-transition counts as an ExpirySweep.

Source

    pub fn expire_old_requests(&self) -> Result<ExpirySweep, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        let now = Utc::now();

        let expired = diesel::update(
            diagnostic_requests::table
                .filter(diagnostic_requests::status.eq("pending"))
                .filter(diagnostic_requests::expires_at.lt(now)),
        )
        .set(diagnostic_requests::status.eq("expired"))
        .execute(conn)?;

        let failed = diesel::update(
            diagnostic_requests::table
                .filter(diagnostic_requests::status.eq("claimed"))
                .filter(diagnostic_requests::expires_at.lt(now)),
        )
        .set((
            diagnostic_requests::status.eq("failed"),
            diagnostic_requests::completed_at.eq(now),
        ))
        .execute(conn)?;

        Ok(ExpirySweep { expired, failed })
    }

cleanup_​old_​requests

pub

fn cleanup_old_requests(
    &self,
    max_age_hours: i64,
) -> Result<usize, diesel::result::Error>

Deletes terminal requests older than the given age in hours.

Reaps expired, completed, and failed requests — which is every terminal state Self::expire_old_requests can produce, so nothing the sweep touches is left behind. Associated results cascade on delete.

Parameters:

Name	Type	Description
max_age_hours	i64	Maximum age in hours for completed/expired/failed requests.

Returns:

Returns the number of requests deleted.

Source

    pub fn cleanup_old_requests(&self, max_age_hours: i64) -> Result<usize, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        let cutoff = Utc::now() - chrono::Duration::hours(max_age_hours);

        diesel::delete(
            diagnostic_requests::table
                .filter(
                    diagnostic_requests::status
                        .eq("expired")
                        .or(diagnostic_requests::status.eq("completed"))
                        .or(diagnostic_requests::status.eq("failed")),
                )
                .filter(diagnostic_requests::created_at.lt(cutoff)),
        )
        .execute(conn)
    }

delete

pub

fn delete(&self, id: Uuid) -> Result<usize, diesel::result::Error>

Deletes a diagnostic request by ID.

Parameters:

Name	Type	Description
id	Uuid	The diagnostic request UUID.

Returns:

Returns the number of records deleted.

Source

    pub fn delete(&self, id: Uuid) -> Result<usize, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;

        diesel::delete(diagnostic_requests::table.filter(diagnostic_requests::id.eq(id)))
            .execute(conn)
    }

struct ExpirySweep

pub

Derives: Debug, Clone, Copy, Default, PartialEq, Eq

The outcome of one expiry sweep (BROKKR-T-0300).

The two counts are kept apart because they describe different operational events: expired means nobody ever picked the request up, failed means an agent claimed it and never came back.

Fields

Name	Type	Description
expired	usize	pending requests past expires_at that no agent ever claimed, transitioned to expired.
failed	usize	claimed requests past expires_at whose agent never submitted a result, transitioned to failed.

Methods

total

pub

fn total(&self) -> usize

Total number of requests moved to a terminal state by the sweep.

Source

    pub fn total(&self) -> usize {
        self.expired + self.failed
    }