brokkr-broker::dal::agent_generator_registrations

Rust

Structs

struct AgentGeneratorRegistrationsDAL<'a>

pub

Fields

Name	Type	Description
dal	&'a DAL

Methods

create

pub

fn create(
    &self,
    agent_id: Uuid,
    generator_id: Uuid,
) -> Result<AgentGeneratorRegistration, diesel::result::Error>

Inserts a registration. Returns the created row. Callers should treat a UniqueViolation error as a 409 (already registered).

Source

    pub fn create(
        &self,
        agent_id: Uuid,
        generator_id: Uuid,
    ) -> Result<AgentGeneratorRegistration, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        let new = NewAgentGeneratorRegistration {
            agent_id,
            generator_id,
        };
        diesel::insert_into(agent_generator_registrations::table)
            .values(&new)
            .get_result(conn)
    }

is_​registered

pub

fn is_registered(
    &self,
    agent_id: Uuid,
    generator_id: Uuid,
) -> Result<bool, diesel::result::Error>

O(1) existence check backed by the UNIQUE (agent_id, generator_id) index.

Source

    pub fn is_registered(
        &self,
        agent_id: Uuid,
        generator_id: Uuid,
    ) -> Result<bool, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        diesel::select(exists(
            agent_generator_registrations::table
                .filter(agent_generator_registrations::agent_id.eq(agent_id))
                .filter(agent_generator_registrations::generator_id.eq(generator_id)),
        ))
        .get_result(conn)
    }

list_​for_​agent

pub

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

All generators an agent is registered with.

Source

    pub fn list_for_agent(
        &self,
        agent_id: Uuid,
    ) -> Result<Vec<AgentGeneratorRegistration>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        agent_generator_registrations::table
            .filter(agent_generator_registrations::agent_id.eq(agent_id))
            .load::<AgentGeneratorRegistration>(conn)
    }

list_​for_​generator

pub

fn list_for_generator(
    &self,
    generator_id: Uuid,
) -> Result<Vec<AgentGeneratorRegistration>, diesel::result::Error>

All agents registered with a generator.

Source

    pub fn list_for_generator(
        &self,
        generator_id: Uuid,
    ) -> Result<Vec<AgentGeneratorRegistration>, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        agent_generator_registrations::table
            .filter(agent_generator_registrations::generator_id.eq(generator_id))
            .load::<AgentGeneratorRegistration>(conn)
    }

delete

pub

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

Removes one registration. Returns rows deleted (0 or 1).

Source

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

delete_​agent_​targets_​for_​generator

pub

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

Removes all agent_targets rows for the given agent where the target stack belongs to the given generator. Used as part of the deregistration cascade in DELETE /generators/:id/register.

Source

    pub fn delete_agent_targets_for_generator(
        &self,
        agent_id: Uuid,
        generator_id: Uuid,
    ) -> Result<usize, diesel::result::Error> {
        let conn = &mut self.dal.conn()?;
        let stack_ids: Vec<Uuid> = stacks::table
            .filter(stacks::generator_id.eq(generator_id))
            .filter(stacks::deleted_at.is_null())
            .select(stacks::id)
            .load(conn)?;

        diesel::delete(
            agent_targets::table
                .filter(agent_targets::agent_id.eq(agent_id))
                .filter(agent_targets::stack_id.eq_any(stack_ids)),
        )
        .execute(conn)
    }