libeufin

config.rs (7263B)

---

 /*
 * This file is part of LibEuFin.
 * Copyright (C) 2026 Taler Systems S.A.
 
 * LibEuFin is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation; either version 3, or
 * (at your option) any later version.
 
 * LibEuFin is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
 * Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
 * License along with LibEuFin; see the file COPYING.  If not, see
 * <http://www.gnu.org/licenses/>
 */
 
 use std::{cell::OnceCell, time::Duration};
 
 use compact_str::CompactString;
 use jiff::civil::Time;
 use libeufin_ebics::{
     config::{EbicsHostCfg, EbicsKeysCfg, EbicsSetupCfg},
     keys::{BankKeys, ClientKeys},
 };
 use reqwest::Url;
 use taler_api::{
     Serve,
     config::{AuthCfg, DbCfg},
 };
 use taler_common::{
     config::{CfgErr, Config, Section},
     map_config,
 };
 
 pub fn parse_db_cfg(cfg: &Config) -> Result<DbCfg, CfgErr> {
     DbCfg::parse(cfg.section("ebisyncdb-postgres"))
 }
 
 pub struct EbisyncSetupCfg {
     pub enc: Option<Vec<u8>>,
     pub auth: Option<Vec<u8>>,
 }
 
 impl EbisyncSetupCfg {
     pub fn parse(cfg: &Config) -> Result<Self, CfgErr> {
         let s = cfg.section("ebisync-setup");
         Ok(Self {
             enc: s.hex("bank_encryption_pub_key_hash").opt()?,
             auth: s.hex("bank_authentication_pub_key_hash").opt()?,
         })
     }
 }
 
 pub enum Destination {
     None,
     AzureBlobStorage {
         api: Url,
         name: String,
         key: String,
         container: String,
     },
 }
 
 pub enum Source {
     None,
     SyncAPI(AuthCfg),
 }
 
 pub struct EbisyncFetchCfg {
     pub frequency: Duration,
     pub frequency_raw: String,
     pub checkpoint_time: Time,
     pub destination: Destination,
 }
 
 impl EbisyncFetchCfg {
     pub fn parse(cfg: &Config) -> Result<Self, CfgErr> {
         let s = cfg.section("ebisync-fetch");
         Ok(Self {
             frequency: s.duration("frequency").require()?,
             frequency_raw: s.str("frequency").require()?,
             checkpoint_time: s.time("checkpoint_time_of_day").require()?,
             destination: map_config!(s, "ebics file destination", "destination",
                 "none" => { Destination::None },
                 "azure-blob-storage" => {
                     Destination::AzureBlobStorage { api:  s.base_url("azure_api_url").require()?, name: s.str("azure_account_name").require()?, key: s.str("azure_account_key").require()?, container: s.str("azure_container").require()? }
                 }
             ).require()?
         })
     }
 }
 
 pub struct EbisyncSubmitCfg {
     pub source: Source,
 }
 
 impl EbisyncSubmitCfg {
     pub fn parse(cfg: &Config) -> Result<Self, CfgErr> {
         let s = cfg.section("ebisync-submit");
         Ok(Self {
             source: map_config!(s, "ebics file source", "source",
                 "none" => { Source::None },
                 "ebisync-api" => { Source::SyncAPI(AuthCfg::parse(&s)?) }
             )
             .require()?,
         })
     }
 }
 
 pub struct EbisyncServeCfg {
     pub serve: Serve,
     pub spa_path: String,
 }
 
 impl EbisyncServeCfg {
     pub fn parse(cfg: &Config) -> Result<Self, CfgErr> {
         let s = cfg.section("ebisync-httpd");
         Ok(Self {
             serve: Serve::parse(&s)?,
             spa_path: s.path("spa").require()?,
         })
     }
 }
 
 #[derive(Clone)]
 pub struct EbisyncHostCfg {
     pub base_url: Url,
     pub unix_path: Option<String>,
     pub host_id: CompactString,
     pub user_id: CompactString,
     pub partner_id: CompactString,
 }
 
 impl EbisyncHostCfg {
     pub fn parse(s: &Section) -> Result<Self, CfgErr> {
         Ok(Self {
             base_url: s.url("host_base_url").require()?,
             unix_path: s.path("UNIXPATH").opt()?,
             host_id: s.cstr("host_id").require()?,
             user_id: s.cstr("user_id").require()?,
             partner_id: s.cstr("partner_id").require()?,
         })
     }
 
     pub fn ebics<'a>(&'a self) -> EbicsHostCfg<'a> {
         EbicsHostCfg {
             base_url: self.base_url.as_str(),
             unix_path: self.unix_path.as_deref(),
             host_id: &self.host_id,
             user_id: &self.user_id,
             partner_id: &self.partner_id,
         }
     }
 }
 
 pub struct EbisyncCfg<'a> {
     pub bank: String,
     pub client: String,
     pub host: EbisyncHostCfg,
     pub fetch: OnceCell<EbisyncFetchCfg>,
     pub submit: OnceCell<EbisyncSubmitCfg>,
     pub setup: OnceCell<EbisyncSetupCfg>,
     pub serve: OnceCell<EbisyncServeCfg>,
     pub db_cfg: DbCfg,
     pub cfg: &'a Config,
 }
 
 impl<'a> EbisyncCfg<'a> {
     pub fn parse(cfg: &'a Config) -> Result<Self, CfgErr> {
         let s = cfg.section("ebisync");
         Ok(Self {
             host: EbisyncHostCfg::parse(&s)?,
             bank: s.path("bank_public_keys_file").require()?,
             client: s.path("client_private_keys_file").require()?,
             fetch: OnceCell::new(),
             submit: OnceCell::new(),
             setup: OnceCell::new(),
             serve: OnceCell::new(),
             db_cfg: parse_db_cfg(cfg)?,
             cfg,
         })
     }
 
     pub fn fetch(&self) -> Result<&EbisyncFetchCfg, CfgErr> {
         // TODO use get_or_try_init when stable
         if let Some(fetch) = self.fetch.get() {
             return Ok(fetch);
         }
         let fetch = EbisyncFetchCfg::parse(self.cfg)?;
         self.fetch.set(fetch).ok();
         Ok(self.fetch.get().unwrap())
     }
 
     pub fn submit(&self) -> Result<&EbisyncSubmitCfg, CfgErr> {
         // TODO use get_or_try_init when stable
         if let Some(submit) = self.submit.get() {
             return Ok(submit);
         }
         let submit = EbisyncSubmitCfg::parse(self.cfg)?;
         self.submit.set(submit).ok();
         Ok(self.submit.get().unwrap())
     }
 
     pub fn serve(&self) -> Result<&EbisyncServeCfg, CfgErr> {
         // TODO use get_or_try_init when stable
         if let Some(serve) = self.serve.get() {
             return Ok(serve);
         }
         let serve = EbisyncServeCfg::parse(self.cfg)?;
         self.serve.set(serve).ok();
         Ok(self.serve.get().unwrap())
     }
 
     pub fn ebics_setup(&'a self) -> Result<EbicsSetupCfg<'a>, CfgErr> {
         let setup = {
             if let Some(setup) = self.setup.get() {
                 setup
             } else {
                 let setup = EbisyncSetupCfg::parse(self.cfg)?;
                 self.setup.set(setup).ok();
                 self.setup.get().unwrap()
             }
         };
         Ok(EbicsSetupCfg {
             keys: EbicsKeysCfg {
                 bank: &self.bank,
                 client: &self.client,
             },
             host: self.host.ebics(),
             enc: setup.enc.as_deref(),
             auth: setup.auth.as_deref(),
         })
     }
 
     pub fn expect_full_keys(&self) -> Result<(ClientKeys, BankKeys), CfgErr> {
         libeufin_ebics::keys::expect_full_keys(
             &EbicsKeysCfg {
                 bank: &self.bank,
                 client: &self.client,
             },
             "libeufin-ebisync setup",
         )
     }
 }