Radish alpha
r
radicle-ci-broker
Radicle CI broker
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
refactor: add RunBuilder to build a Run
Lars Wirzenius committed 1 year ago
commit f42ea5cb9ce2dc7a9b87834ccee5b9bb3867db90
parent e431a10f359e03e117c7ccf549f07c74551b4713
4 files changed +88 -34
modified src/adapter.rs
@@ -273,7 +273,7 @@ mod test {
        adapter::AdapterError,

        msg::{MessageError, Response, RunId, RunResult},

        notif::NotificationChannel,
- 
        run::Whence,
+ 
        run::{RunBuilder, Whence},

        test::{mock_adapter, trigger_request, TestResult},

    };
@@ -286,17 +286,17 @@ mod test {
    }



    fn run() -> anyhow::Result<Run> {
- 
        Ok(Run::new(
- 
            RunId::default(),
- 
            RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8")?,
- 
            "test.repo",
- 
            Whence::branch(
+ 
        Ok(RunBuilder::default()
+ 
            .broker_run_id(RunId::default())
+ 
            .repo_id(RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8")?)
+ 
            .repo_name("test.repo")
+ 
            .whence(Whence::branch(

                "main",

                Oid::try_from("ff3099ba5de28d954c41d0b5a84316f943794ea4")?,

                Some("J. Random Hacker <random@example.com>"),
- 
            ),
- 
            "2024-02-29T12:58:12+02:00".into(),
- 
        ))
+ 
            ))
+ 
            .timestamp("2024-02-29T12:58:12+02:00".into())
+ 
            .build())

    }



    #[test]
modified src/bin/cibtoolcmd/run.rs
@@ -1,3 +1,5 @@
+ 
use radicle_ci_broker::run::RunBuilder;
+ 


use super::*;



#[derive(Parser)]
@@ -63,7 +65,13 @@ impl Leaf for AddRun {
            commit: oid,

            who: self.who.clone(),

        };
- 
        let mut run = Run::new(RunId::default(), rid, &repo_name, whence, ts);
+ 
        let mut run = RunBuilder::default()
+ 
            .broker_run_id(RunId::default())
+ 
            .repo_id(rid)
+ 
            .repo_name(&repo_name)
+ 
            .whence(whence)
+ 
            .timestamp(ts)
+ 
            .build();



        let id = self.id.clone().unwrap_or_default();

        run.set_adapter_run_id(id);
modified src/broker.rs
@@ -20,7 +20,7 @@ use crate::{
    logger,

    msg::{PatchEvent, PushEvent, Request, RunId},

    notif::NotificationSender,
- 
    run::{Run, Whence},
+ 
    run::{Run, RunBuilder, Whence},

};



/// A CI broker.
@@ -118,8 +118,13 @@ impl Broker {
                        panic!("neither push not patch event");

                    };
- 
                    let mut run =
- 
                        Run::new(broker_run_id, *rid, &common.repository.name, whence, now()?);
+ 
                    let mut run = RunBuilder::default()
+ 
                        .broker_run_id(broker_run_id)
+ 
                        .repo_id(*rid)
+ 
                        .repo_name(&common.repository.name)
+ 
                        .whence(whence)
+ 
                        .timestamp(now()?)
+ 
                        .build();

                    self.db.push_run(&run)?;



                    // We run the adapter, but if that fails, we just
modified src/run.rs
@@ -7,6 +7,68 @@ use radicle::prelude::RepoId;


use crate::msg::{Revision, RunId, RunResult};
+ 
#[derive(Debug, Default)]
+ 
pub struct RunBuilder {
+ 
    broker_run_id: Option<RunId>,
+ 
    repo_id: Option<RepoId>,
+ 
    repo_name: Option<String>,
+ 
    whence: Option<Whence>,
+ 
    timestamp: Option<String>,
+ 
}
+
+ 
impl RunBuilder {
+ 
    pub fn broker_run_id(mut self, run_id: RunId) -> Self {
+ 
        self.broker_run_id = Some(run_id);
+ 
        self
+ 
    }
+
+ 
    pub fn repo_id(mut self, repo_id: RepoId) -> Self {
+ 
        self.repo_id = Some(repo_id);
+ 
        self
+ 
    }
+
+ 
    pub fn repo_name(mut self, name: &str) -> Self {
+ 
        self.repo_name = Some(name.into());
+ 
        self
+ 
    }
+
+ 
    pub fn whence(mut self, whence: Whence) -> Self {
+ 
        self.whence = Some(whence);
+ 
        self
+ 
    }
+
+ 
    pub fn timestamp(mut self, ts: String) -> Self {
+ 
        self.timestamp = Some(ts);
+ 
        self
+ 
    }
+
+ 
    pub fn build(self) -> Run {
+ 
        let broker_run_id = self
+ 
            .broker_run_id
+ 
            .unwrap_or_else(|| panic!("missing: broker_run_id"));
+ 
        let repo_id = self.repo_id.unwrap_or_else(|| panic!("missing: repo_id"));
+ 
        let repo_name = self
+ 
            .repo_name
+ 
            .unwrap_or_else(|| panic!("missing: repo_name"));
+ 
        let whence = self.whence.unwrap_or_else(|| panic!("missing: whence"));
+ 
        let timestamp = self
+ 
            .timestamp
+ 
            .unwrap_or_else(|| panic!("missing: timestamp"));
+
+ 
        Run {
+ 
            broker_run_id,
+ 
            adapter_run_id: None,
+ 
            adapter_info_url: None,
+ 
            repo_id,
+ 
            repo_name,
+ 
            timestamp,
+ 
            whence,
+ 
            state: RunState::Triggered,
+ 
            result: None,
+ 
        }
+ 
    }
+ 
}
+ 


#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]

pub struct Run {

    broker_run_id: RunId,
@@ -22,27 +84,6 @@ pub struct Run {
}



impl Run {
- 
    /// Create a new run.
- 
    pub fn new(
- 
        broker_run_id: RunId,
- 
        repo_id: RepoId,
- 
        name: &str,
- 
        whence: Whence,
- 
        timestamp: String,
- 
    ) -> Self {
- 
        Self {
- 
            broker_run_id,
- 
            adapter_run_id: None,
- 
            adapter_info_url: None,
- 
            repo_id,
- 
            repo_name: name.into(),
- 
            timestamp,
- 
            whence,
- 
            state: RunState::Triggered,
- 
            result: None,
- 
        }
- 
    }
- 


    /// Return the repo alias.

    pub fn repo_alias(&self) -> &str {

        &self.repo_name