taler-rust

main.rs (5347B)

---

 /*
   This file is part of TALER
   Copyright (C) 2025 Taler Systems SA
 
   TALER 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.
 
   TALER 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
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use anyhow::bail;
 use clap::Parser;
 use taler_api::config::{ApiCfg, AuthCfg};
 use taler_build::long_version;
 use taler_common::{
     CommonArgs,
     cli::ConfigCmd,
     config::Config,
     db::{dbinit, pool},
     taler_main,
 };
 use taler_magnet_bank::{
     config::{ServeCfg, WorkerCfg, parse_account_payto, parse_db_cfg},
     constants::CONFIG_SOURCE,
     dev::{self, DevCmd},
     run_serve, run_worker, setup,
 };
 
 #[derive(clap::Parser, Debug)]
 #[command(long_version = long_version(), about, long_about = None)]
 struct Args {
     #[clap(flatten)]
     common: CommonArgs,
 
     #[command(subcommand)]
     cmd: Command,
 }
 
 #[derive(clap::Subcommand, Debug)]
 enum Command {
     /// Initialize taler-magnet-bank database
     Dbinit {
         /// Reset database (DANGEROUS: All existing data is lost)
         #[clap(long, short)]
         reset: bool,
     },
     /// Setup taler-magnet-bank auth token and account settings for Wire Gateway use
     Setup {
         /// Reset connection info and overwrite keys file
         #[clap(long, short)]
         reset: bool,
     },
     /// Run taler-magnet-bank worker
     Worker {
         /// Execute once and return
         #[clap(long, short)]
         transient: bool,
     },
     /// Run taler-magnet-bank HTTP server
     Serve {
         /// Check whether an API is in use (if it's useful to start the HTTP
         /// server). Exit with 0 if at least one API is enabled, otherwise 1
         #[clap(long)]
         check: bool,
     },
     #[command(subcommand)]
     TalerDeployment(TalerDeployment),
     /// Hidden dev commands
     #[command(subcommand, hide(true))]
     Dev(DevCmd),
     #[command(subcommand)]
     Config(ConfigCmd),
 }
 
 /// Helpers to integrate taler-magnet-bank with taler-exchange
 #[derive(clap::Subcommand, Debug)]
 enum TalerDeployment {
     /// Output the exchange payto
     ExchangePayto,
     /// Output the wire gateway credentials configuration
     WireGatewayCredentials,
 }
 
 async fn run(cmd: Command, cfg: &Config) -> anyhow::Result<()> {
     match cmd {
         Command::Dbinit { reset } => {
             let cfg = parse_db_cfg(cfg)?;
             let pool = pool(cfg.cfg, "magnet_bank").await?;
             let mut conn = pool.acquire().await?;
             dbinit(&mut conn, cfg.sql_dir.as_ref(), "magnet-bank", reset).await?;
         }
         Command::Setup { reset } => {
             let cfg = WorkerCfg::parse(cfg)?;
             setup::setup(cfg, reset).await?
         }
         Command::Serve { check } => {
             if check {
                 let cfg = ServeCfg::parse(cfg)?;
                 if cfg.revenue.is_none() && cfg.wire_gateway.is_none() {
                     std::process::exit(1);
                 }
             } else {
                 let db = parse_db_cfg(cfg)?;
                 let pool = pool(db.cfg, "magnet_bank").await?;
                 run_serve(cfg, pool).await?;
             }
         }
         Command::Worker { transient: _ } => {
             let db = parse_db_cfg(cfg)?;
             let pool = pool(db.cfg, "magnet_bank").await?;
             let client = reqwest::Client::new();
             run_worker(cfg, &pool, &client).await?;
         }
         Command::Config(cfg_cmd) => cfg_cmd.run(cfg)?,
         Command::Dev(dev_cmd) => dev::dev(cfg, dev_cmd).await?,
         Command::TalerDeployment(cmd) => match cmd {
             TalerDeployment::ExchangePayto => {
                 let payto = parse_account_payto(cfg)?;
                 println!("{payto}");
             }
             TalerDeployment::WireGatewayCredentials => {
                 let wire_gateway =
                     ApiCfg::parse(cfg.section("magnet-bank-httpd-wire-gateway-api"))?;
                 let Some(wire_gateway) = wire_gateway else {
                     bail!("Wire Gateway API is disabled");
                 };
 
                 match wire_gateway.auth {
                     AuthCfg::Basic { username, password } => {
                         println!("WIRE_GATEWAY_AUTH_METHOD = basic");
                         println!("USERNAME = {username}");
                         println!("PASSWORD = {password}");
                     }
                     AuthCfg::Bearer(token) => {
                         println!("WIRE_GATEWAY_AUTH_METHOD = bearer");
                         println!("AUTH_TOKEN = {token}");
                     }
                     AuthCfg::None => {
                         println!("WIRE_GATEWAY_AUTH_METHOD = none");
                     }
                 }
             }
         },
     }
     Ok(())
 }
 
 fn main() {
     let args = Args::parse();
     taler_main(CONFIG_SOURCE, args.common, |cfg| async move {
         run(args.cmd, &cfg).await
     });
 }