refactor: use ergo module to load profile — radicle-ci-broker

refactor: CiEventSource gets a reference to a profile instead of owning it

refactor: make Worker::NAME be a static string

refactor: drop Worker::name, now unnecessary

refactor: QueueAdder holds an ergo::Radicle

This still loads the profile, because Worker needs a ’static lifetime and this is the easiest way to achieve that.

refactor: add ergo::Oid export

Use this consistently to reduce confusion between Oid types from Radicle.

     use tempfile::{NamedTempFile, TempDir, tempdir};
     use radicle::git::Oid;
     use radicle::prelude::RepoId;
     use super::{Adapter, Db, Run};
     use crate::{
         adapter::AdapterError,
         cob::KnownJobCobs,
         ergo::Oid,
         msg::{MessageError, Response, RunId, RunResult},
         notif::NotificationChannel,
         run::{RunBuilder, Whence},

 };
 use clap::Parser;
 use radicle::Profile;
 use radicle_ci_broker::{
     adapter::AdapterError,
     broker::{Broker, BrokerError},
     config::{Config, ConfigError},
     db::{Db, DbError},
     ergo,
     logger::{self, LogLevel},
     notif::{NotificationChannel, NotificationError},
     pages::{PageError, StatusPage},

 impl QueuedCmd {
     fn run(&self, args: &Args, config: &Config) -> Result<(), CibError> {
         let profile = Profile::load().map_err(CibError::profile)?;
         let adapters = config.to_adapters().map_err(CibError::Adapters)?;
         logger::adapter_config(config);

         let db = args.open_db(config)?;
         let mut page = StatusPage::new(
             run_notifications.rx().map_err(CibError::notification)?,
             profile,
             ergo::Radicle::new().map_err(CibError::ergo)?,
             db,
             true,
         );

             .map_err(CibError::QueueAdder)?;
         let adder = start_thread(adder);
         let profile = Profile::load().map_err(CibError::profile)?;
         let db = args.open_db(config)?;
         let mut page = StatusPage::new(
             run_notification.rx().map_err(CibError::notification)?,
             profile,
             ergo::Radicle::new().map_err(CibError::ergo)?,
             db,
             false,
         );

 #[derive(Debug, thiserror::Error)]
 enum CibError {
     #[error("failed to load ergonomic Radicle wrapper")]
     Ergo(#[source] ergo::ErgoError),
     #[error("failed to read configuration file {0}")]
     ReadConfig(PathBuf, #[source] ConfigError),

     #[error("failed to convert adapters as JSON")]
     AdaptersToJson(PathBuf, #[source] AdapterError),
     #[error("failed to look up node profile")]
     Profile(#[source] radicle::profile::Error),
     #[error("failed to use SQLite database")]
     Db(#[source] DbError),

         Self::AdaptersToJson(filename.into(), e)
     }
     fn profile(e: radicle::profile::Error) -> Self {
         Self::Profile(e)
     fn ergo(e: ergo::ErgoError) -> Self {
         Self::Ergo(e)
     }
     fn db(e: DbError) -> Self {

 use clap::Parser;
 use radicle::{Profile, git::Oid, prelude::NodeId};
 use radicle::prelude::NodeId;
 use radicle_ci_broker::{
     broker::BrokerError,
     ci_event::{CiEvent, CiEventError, CiEventV1},
     db::{Db, DbError, QueueId, QueuedCiEvent},
     ergo::{self, Oid},
     logger,
     msg::{RunId, RunResult},
     notif::{NotificationChannel, NotificationError},

 use url::Url;
 use radicle::{git::Oid, identity::RepoId};
 use radicle::identity::RepoId;
 use radicle_ci_broker::cob::*;
 use radicle_ci_broker::{cob::*, ergo::Oid};
 use super::*;

     fn run(&self, args: &Args) -> Result<(), CibToolError> {
         let r = ergo::Radicle::new().map_err(EventError::Ergonomic)?;
         let profile = r.profile();
         let nid = *profile.id();
         let radicle = ergo::Radicle::new().map_err(CibToolError::Ergo)?;
         let nid = *radicle.profile().id();
         let repo = r
             .repository_by_name(&self.repo)

 impl Leaf for RecordEvents {
     fn run(&self, _args: &Args) -> Result<(), CibToolError> {
         let profile = util::load_profile()?;
         let mut source = NodeEventSource::new(&profile).map_err(CibToolError::EventSubscribe)?;
         let radicle = ergo::Radicle::new().map_err(CibToolError::Ergo)?;
         let mut source =
             NodeEventSource::new(radicle.profile()).map_err(CibToolError::EventSubscribe)?;
         let mut file = if let Some(filename) = &self.output {
             Some(
                 std::fs::File::create(filename)

 impl Leaf for CiEvents {
     fn run(&self, _args: &Args) -> Result<(), CibToolError> {
         let profile = Profile::load().map_err(CibToolError::Profile)?;
         let radicle = ergo::Radicle::new().map_err(CibToolError::Ergo)?;
         let bytes = std::fs::read(&self.input)
             .map_err(|e| CibToolError::ReadEvents(self.input.clone(), e))?;

         let mut ci_events: Vec<CiEvent> = vec![];
         for node_event in node_events.iter() {
             if let Ok(mut cevs) = CiEvent::from_node_event(node_event, &profile) {
             if let Ok(mut cevs) = CiEvent::from_node_event(node_event, radicle.profile()) {
                 ci_events.append(&mut cevs);
             }
         }

 use radicle_ci_broker::{pages::StatusPage, worker::start_thread};
 use radicle_ci_broker::{ergo, pages::StatusPage, worker::start_thread};
 use super::*;

 impl Leaf for ReportCmd {
     fn run(&self, args: &Args) -> Result<(), CibToolError> {
         let profile = Profile::load().map_err(CibToolError::Profile)?;
         let db = args.open_db()?;
         let mut run_notification = NotificationChannel::new_run();
         let mut page = StatusPage::new(
             run_notification.rx().map_err(CibToolError::Notification)?,
             profile,
             ergo::Radicle::new().map_err(CibToolError::Ergo)?,
             db,
             true,
         );

     node_event_source::{NodeEventError, NodeEventSource},
 };
 pub struct CiEventSource {
 pub struct CiEventSource<'a> {
     source: NodeEventSource,
     profile: Profile,
     profile: &'a Profile,
 }
 impl CiEventSource {
     pub fn new(profile: Profile) -> Result<Self, CiEventSourceError> {
 impl<'a> CiEventSource<'a> {
     pub fn new(profile: &'a Profile) -> Result<Self, CiEventSourceError> {
         let source = Self {
             source: NodeEventSource::new(&profile).map_err(CiEventSourceError::Subscribe)?,
             source: NodeEventSource::new(profile).map_err(CiEventSourceError::Subscribe)?,
             profile,
         };
         logger::ci_event_source_created(&source);

                 Ok(None)
             }
             Ok(Some(event)) => {
                 let ci_events = CiEvent::from_node_event(&event, &self.profile)
                 let ci_events = CiEvent::from_node_event(&event, self.profile)
                     .map_err(CiEventSourceError::CiEvent)?;
                 if !ci_events.is_empty() {
                     logger::ci_event_source_got_events(&ci_events);

     }
 }
 impl fmt::Debug for CiEventSource {
 impl<'a> fmt::Debug for CiEventSource<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "CiEventSource<path={:?}", self.source)
     }

 use uuid::Uuid;
 use radicle::{
     git::Oid,
     node::{
         Handle, Node,
         sync::{Announcer, AnnouncerConfig, ReplicationFactor},

 };
 use radicle_job::*;
 use crate::{logger, msg::RunId};
 use crate::{ergo::Oid, logger, msg::RunId};
 /// Lookup cache for job COBs.
 ///

 use radicle::{
     cob::patch::{Patch, PatchId, cache::Patches},
     git::Oid,
     identity::{Project, RepoId},
     profile::Profile,
     storage::{ReadStorage, RepositoryInfo, git::Repository},
 };
 pub use radicle::git::Oid;
 /// A Radicle node.
 ///
 /// This type represents a Radicle node, and exists to cache some

 use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
 use uuid::Uuid;
 use radicle::{git::Oid, identity::RepoId, node::Event, patch::PatchId};
 use radicle::{identity::RepoId, node::Event, patch::PatchId};
 use radicle_job::{JobId, Reason};
 use crate::{

     ci_event_source::{CiEventSource, CiEventSourceError},
     config::Config,
     db::{QueueId, QueuedCiEvent},
     ergo::Oid,
     filter::{Decision, EventFilter},
     msg::{Request, RunId},
     node_event_source::NodeEventSource,

 };
 pub use radicle::{
     cob::patch::PatchId,
     git::Oid,
     prelude::{NodeId, RepoId},
 };
 pub use radicle_surf::Commit;
 use crate::{
     ci_event::{CiEvent, CiEventV1},
     ergo::Oid,
     logger,
 };

 struct PageArgs {
     run_rx: NotificationReceiver,
     profile: Profile,
     radicle: ergo::Radicle,
     db: Db,
     once: bool,
     desc_snippet: Option<String>,

         self.dirname = Some(dirname.into());
     }
     pub fn new(run_rx: NotificationReceiver, profile: Profile, db: Db, once: bool) -> Self {
     pub fn new(run_rx: NotificationReceiver, radicle: ergo::Radicle, db: Db, once: bool) -> Self {
         Self {
             node_alias: "".into(),
             dirname: None,
             args: PageArgs {
                 run_rx,
                 profile,
                 radicle,
                 db,
                 once,
                 desc_snippet: None,

                         | CiEvent::V1(CiEventV1::BranchUpdated { repo, .. })
                         | CiEvent::V1(CiEventV1::PatchCreated { repo, .. })
                         | CiEvent::V1(CiEventV1::PatchUpdated { repo, .. }) => {
                             if Self::is_public_repo(&self.args.profile, repo) {
                             if Self::is_public_repo(self.args.radicle.profile(), repo) {
                                 Some(Ok(event))
                             } else {
                                 None

 use radicle::Profile;
 use crate::{
     ci_event::CiEvent,
     ci_event_source::{CiEventSource, CiEventSourceError},
     db::{Db, DbError, QueueId},
     logger,
     ergo, logger,
     notif::NotificationSender,
     worker::Worker,
 };

         Ok(QueueAdder {
             db: self.db.ok_or(AdderError::Missing("db"))?,
             events_tx: self.events_tx.ok_or(AdderError::Missing("events_tx"))?,
             radicle: ergo::Radicle::new().map_err(AdderError::Ergo)?,
         })
     }

 pub struct QueueAdder {
     db: Db,
     events_tx: NotificationSender,
     radicle: ergo::Radicle,
 }
 impl QueueAdder {
     fn add_events(&self) -> Result<(), AdderError> {
         let profile = Profile::load().map_err(AdderError::profile)?;
         let mut source = CiEventSource::new(profile)?;
         let mut source = CiEventSource::new(self.radicle.profile())?;
         // This loop ends when there's an error, e.g., failure to read an
         // event from the node.

 }
 impl Worker for QueueAdder {
     const NAME: &str = "queue-adder";
     const NAME: &'static str = "queue-adder";
     type Error = AdderError;
     fn work(&mut self) -> Result<(), Self::Error> {

     #[error("programming error: QueueAdderBuilder field {0} was not set")]
     Missing(&'static str),
     #[error(transparent)]
     Profile(#[from] Box<radicle::profile::Error>),
     #[error("failed to load ergonomic Radicle wrapper")]
     Ergo(#[source] ergo::ErgoError),
     #[error(transparent)]
     CiEvent(#[from] CiEventSourceError),

     #[error("failed to notify other thread about database change")]
     Send,
 }
 impl AdderError {
     fn profile(err: radicle::profile::Error) -> Self {
         Self::Profile(Box::new(err))
     }
 }

 use serde::{Deserialize, Serialize};
 use radicle::git::Oid;
 use radicle::prelude::RepoId;
 use radicle_job::JobId;
 use crate::msg::{Revision, RunId, RunResult};
 use crate::{
     ergo::Oid,
     msg::{Revision, RunId, RunResult},
 };
 #[derive(Debug, Default)]
 pub struct RunBuilder {