refactor: prevent direct access to struct Config fields — radicle-ci-broker

Make struct Config fields private and introduces getter methods to access them. This will make it easier to change the CI broker to be able to run different adapters for different changes.

Signed-off-by: Lars Wirzenius liw@liw.fi

     }
     fn open_db(&self, config: &Config) -> Result<Db, CibError> {
         let db = Db::new(&config.db).map_err(CibError::db)?;
         let db = Db::new(config.db()).map_err(CibError::db)?;
         let events = db.queued_events().map_err(CibError::Db)?;
         if events.is_empty() {
             Ok(db)

         let adder = QueueAdderBuilder::default()
             .events_tx(events_notification.tx().map_err(CibError::notification)?)
             .db(args.open_db(config)?)
             .filters(&config.filters)
             .filters(config.filters())
             .build()
             .map_err(CibError::QueueAdder)?;
         let thread = adder.add_events_in_thread();

         let mut broker =
             Broker::new(config.db(), config.max_run_time()).map_err(CibError::new_broker)?;
         let spec =
             config
                 .adapter(&config.default_adapter)
                 .ok_or(CibError::UnknownDefaultAdapter(
                     config.default_adapter.clone(),
                 ))?;
         let spec = config
             .default_adapter()
             .ok_or(CibError::UnknownDefaultAdapter(
                 config.default_adapter_name().into(),
             ))?;
         let adapter = Adapter::new(&spec.command)
             .with_environment(spec.envs())
             .with_sensitive_environment(spec.sensitive_envs());

             .events_rx(event_notifications.rx().map_err(CibError::notification)?)
             .run_tx(run_notifications.tx().map_err(CibError::notification)?)
             .db(db)
             .queue_len_interval(config.queue_len_interval)
             .queue_len_interval(config.queue_len_interval())
             .broker(broker)
             .build()
             .map_err(CibError::process_queue)?;

         let db = args.open_db(config)?;
         let mut page = StatusPage::default();
         if let Some(dirname) = &config.report_dir {
         if let Some(dirname) = config.report_dir() {
             page.set_output_dir(dirname);
         }
         let page_updater = page.update_in_thread(

 #[derive(Debug, Serialize, Deserialize)]
 pub struct Config {
     pub default_adapter: String,
     pub adapters: HashMap<String, Adapter>,
     pub filters: Vec<EventFilter>,
     pub report_dir: Option<PathBuf>,
     pub status_update_interval_seconds: Option<u64>,
     pub db: PathBuf,
     default_adapter: String,
     adapters: HashMap<String, Adapter>,
     filters: Vec<EventFilter>,
     report_dir: Option<PathBuf>,
     status_update_interval_seconds: Option<u64>,
     db: PathBuf,
     #[serde(deserialize_with = "deserialize_duration")]
     #[serde(default = "default_max_run_time")]
     pub max_run_time: Duration,
     max_run_time: Duration,
     #[serde(deserialize_with = "deserialize_duration")]
     #[serde(default = "default_queue_len_interval")]
     pub queue_len_interval: Duration,
     queue_len_interval: Duration,
 }
 fn default_max_run_time() -> Duration {

         serde_yml::from_slice(&config).map_err(|e| ConfigError::ParseConfig(filename.into(), e))
     }
     pub fn report_dir(&self) -> Option<&Path> {
         self.report_dir.as_deref()
     }
     pub fn filters(&self) -> &[EventFilter] {
         &self.filters
     }
     pub fn default_adapter_name(&self) -> &str {
         &self.default_adapter
     }
     pub fn default_adapter(&self) -> Option<&Adapter> {
         self.adapter(&self.default_adapter)
     }
     pub fn adapter(&self, name: &str) -> Option<&Adapter> {
         self.adapters.get(name)
     }

         self.max_run_time
     }
     pub fn queue_len_interval(&self) -> Duration {
         self.queue_len_interval
     }
     pub fn db(&self) -> &Path {
         &self.db
     }