brokkr-broker::dal::generators

Rust

Structs

struct GeneratorsDAL<'a>

pub

Data Access Layer for Generator operations.

This module provides a set of methods to interact with the generators table in the database. It includes operations for creating, retrieving, updating, and deleting generators, as well as specialized queries for filtering and updating specific fields.

Fields

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

Methods

create

pub

fn create(
    &self,
    new_generator: &NewGenerator,
) -> Result<Generator, diesel::result::Error>

Creates a new generator in the database.

Parameters:

Name	Type	Description
new_generator	&NewGenerator	A reference to the NewGenerator struct containing the generator details.

Returns:

A Result containing the created Generator on success, or a diesel::result::Error on failure.

Source

    pub fn create(&self, new_generator: &NewGenerator) -> Result<Generator, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        diesel::insert_into(generators::table)
            .values(new_generator)
            .get_result(conn)
    }

get

pub

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

Retrieves a non-deleted generator by its UUID.

Parameters:

Name	Type	Description
generator_uuid	Uuid	The UUID of the generator to retrieve.

Returns:

A Result containing an Option if found (and not deleted), or a diesel::result::Error on failure.

Source

    pub fn get(&self, generator_uuid: Uuid) -> Result<Option<Generator>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::id.eq(generator_uuid))
            .filter(generators::deleted_at.is_null())
            .first(conn)
            .optional()
    }

get_​including_​deleted

pub

fn get_including_deleted(
    &self,
    generator_uuid: Uuid,
) -> Result<Option<Generator>, diesel::result::Error>

Retrieves a generator by its UUID, including deleted generators.

Parameters:

Name	Type	Description
generator_uuid	Uuid	The UUID of the generator to retrieve.

Returns:

A Result containing an Option if found (including deleted generators), or a diesel::result::Error on failure.

Source

    pub fn get_including_deleted(
        &self,
        generator_uuid: Uuid,
    ) -> Result<Option<Generator>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::id.eq(generator_uuid))
            .first(conn)
            .optional()
    }

list

pub

fn list(&self) -> Result<Vec<Generator>, diesel::result::Error>

Lists all non-deleted, non-system generators.

The system generator is an internal implementation detail and is excluded from the public listing. Use get_system_generator_id() to retrieve it.

Source

    pub fn list(&self) -> Result<Vec<Generator>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::deleted_at.is_null())
            .filter(generators::is_system.eq(false))
            .load::<Generator>(conn)
    }

get_​names_​by_​ids

pub

fn get_names_by_ids(
    &self,
    ids: &[Uuid],
) -> Result<Vec<(Uuid, String)>, diesel::result::Error>

Resolves generator names for a set of IDs in one query (audit-log actor enrichment, BROKKR-T-0271). Includes deleted and system generators so historical audit entries still resolve.

Source

    pub fn get_names_by_ids(
        &self,
        ids: &[Uuid],
    ) -> Result<Vec<(Uuid, String)>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::id.eq_any(ids))
            .select((generators::id, generators::name))
            .load::<(Uuid, String)>(conn)
    }

list_​all

pub

fn list_all(&self) -> Result<Vec<Generator>, diesel::result::Error>

Lists all non-system generators from the database, including deleted ones.

Source

    pub fn list_all(&self) -> Result<Vec<Generator>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::is_system.eq(false))
            .load::<Generator>(conn)
    }

update

pub

fn update(
    &self,
    generator_uuid: Uuid,
    updated_generator: &Generator,
) -> Result<Generator, diesel::result::Error>

Updates an existing generator in the database.

Parameters:

Name	Type	Description
generator_uuid	Uuid	The UUID of the generator to update.
updated_generator	&Generator	A reference to the Generator struct containing the updated details.

Returns:

A Result containing the updated Generator on success, or a diesel::result::Error on failure.

Source

    pub fn update(
        &self,
        generator_uuid: Uuid,
        updated_generator: &Generator,
    ) -> Result<Generator, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        diesel::update(generators::table.filter(generators::id.eq(generator_uuid)))
            .set(updated_generator)
            .get_result(conn)
    }

soft_​delete

pub

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

Soft deletes a generator by setting its deleted_at timestamp to the current time.

Parameters:

Name	Type	Description
generator_id	Uuid	The UUID of the generator to soft delete.

Returns:

A Result containing the number of affected rows (0 or 1) on success, or a diesel::result::Error on failure.

Source

    pub fn soft_delete(&self, generator_id: Uuid) -> Result<usize, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        diesel::update(generators::table.filter(generators::id.eq(generator_id)))
            .set(generators::deleted_at.eq(Utc::now()))
            .execute(conn)
    }

hard_​delete

pub

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

Hard deletes a generator from the database.

Parameters:

Name	Type	Description
generator_uuid	Uuid	The UUID of the generator to hard delete.

Returns:

A Result containing the number of affected rows (0 or 1) on success, or a diesel::result::Error on failure.

Source

    pub fn hard_delete(&self, generator_uuid: Uuid) -> Result<usize, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        diesel::delete(generators::table.filter(generators::id.eq(generator_uuid))).execute(conn)
    }

update_​pak_​hash

pub

fn update_pak_hash(
    &self,
    generator_uuid: Uuid,
    new_pak_hash: String,
) -> Result<Generator, diesel::result::Error>

Updates the pak_hash for a generator.

Parameters:

Name	Type	Description
generator_uuid	Uuid	The UUID of the generator to update.
new_pak_hash	String	The new pak_hash value.

Returns:

A Result containing the updated Generator on success, or a diesel::result::Error on failure.

Source

    pub fn update_pak_hash(
        &self,
        generator_uuid: Uuid,
        new_pak_hash: String,
    ) -> Result<Generator, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        diesel::update(generators::table.filter(generators::id.eq(generator_uuid)))
            .set(generators::pak_hash.eq(new_pak_hash))
            .get_result(conn)
    }

update_​last_​active

pub

fn update_last_active(
    &self,
    generator_uuid: Uuid,
) -> Result<Generator, diesel::result::Error>

Updates the last_active_at timestamp for a generator and sets is_active to true.

Parameters:

Name	Type	Description
generator_uuid	Uuid	The UUID of the generator to update.

Returns:

A Result containing the updated Generator on success, or a diesel::result::Error on failure.

Source

    pub fn update_last_active(
        &self,
        generator_uuid: Uuid,
    ) -> Result<Generator, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        diesel::update(generators::table.filter(generators::id.eq(generator_uuid)))
            .set((
                generators::last_active_at.eq(Utc::now()),
                generators::is_active.eq(true),
            ))
            .get_result(conn)
    }

get_​by_​name

pub

fn get_by_name(
    &self,
    generator_name: &str,
) -> Result<Option<Generator>, diesel::result::Error>

Retrieves a non-deleted generator by its name.

Parameters:

Name	Type	Description
generator_name	&str	The name of the generator to retrieve.

Returns:

A Result containing an Option if found, or a diesel::result::Error on failure.

Source

    pub fn get_by_name(
        &self,
        generator_name: &str,
    ) -> Result<Option<Generator>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::name.eq(generator_name))
            .filter(generators::deleted_at.is_null())
            .first(conn)
            .optional()
    }

get_​by_​active_​status

pub

fn get_by_active_status(
    &self,
    active: bool,
) -> Result<Vec<Generator>, diesel::result::Error>

Retrieves non-deleted generators by their active status.

Parameters:

Name	Type	Description
active	bool	The active status to filter by.

Returns:

A Result containing a Vec of matching Generators on success, or a diesel::result::Error on failure.

Source

    pub fn get_by_active_status(
        &self,
        active: bool,
    ) -> Result<Vec<Generator>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::is_active.eq(active))
            .filter(generators::deleted_at.is_null())
            .filter(generators::is_system.eq(false))
            .load::<Generator>(conn)
    }

provision_​system_​generator

pub

fn provision_system_generator(
    &self,
) -> Result<Uuid, diesel::result::Error>

Provisions the system generator idempotently.

If no system generator exists, creates one and registers all current agents with it. If one already exists, returns its UUID immediately. Safe to call on every broker startup.

Source

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

        // Check for an existing system generator.
        let existing: Option<Uuid> = generators::table
            .filter(generators::is_system.eq(true))
            .filter(generators::deleted_at.is_null())
            .select(generators::id)
            .first(conn)
            .optional()?;

        if let Some(id) = existing {
            return Ok(id);
        }

        // Create the system generator.
        let system_id: Uuid = diesel::insert_into(generators::table)
            .values((
                generators::name.eq("__system__"),
                generators::description
                    .eq("System generator — reserved for fleet-management stacks"),
                generators::is_system.eq(true),
            ))
            .returning(generators::id)
            .get_result(conn)?;

        // Register every existing agent with the new system generator.
        let agent_ids: Vec<Uuid> = agents::table.select(agents::id).load(conn)?;
        let registrations: Vec<NewAgentGeneratorRegistration> = agent_ids
            .into_iter()
            .map(|agent_id| NewAgentGeneratorRegistration {
                agent_id,
                generator_id: system_id,
            })
            .collect();

        if !registrations.is_empty() {
            diesel::insert_into(agent_generator_registrations::table)
                .values(&registrations)
                .on_conflict_do_nothing()
                .execute(conn)?;
        }

        tracing::info!(system_generator_id = %system_id, "system generator provisioned");
        Ok(system_id)
    }

get_​system_​generator_​id

pub

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

Returns the system generator UUID, or None if not yet provisioned.

Source

    pub fn get_system_generator_id(&self) -> Result<Option<Uuid>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::is_system.eq(true))
            .filter(generators::deleted_at.is_null())
            .select(generators::id)
            .first(conn)
            .optional()
    }

get_​by_​pak_​hash

pub

fn get_by_pak_hash(
    &self,
    pak_hash: &str,
) -> Result<Option<Generator>, diesel::result::Error>

Retrieves a generator by its PAK hash.

This method uses the indexed pak_hash column for O(1) lookups instead of scanning the entire table.

Parameters:

Name	Type	Description
pak_hash	&str	The hashed PAK to search for.

Returns:

Returns a Result containing an Option<Generator> if found, or a diesel::result::Error on failure.

Source

    pub fn get_by_pak_hash(
        &self,
        pak_hash: &str,
    ) -> Result<Option<Generator>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        generators::table
            .filter(generators::pak_hash.eq(pak_hash))
            .filter(generators::deleted_at.is_null())
            .first(conn)
            .optional()
    }