libeufin

logger.rs (4846B)

---

 /*
 * This file is part of LibEuFin.
 * Copyright (C) 2024, 2025, 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::{
     fmt::Display,
     io::{BufWriter, Cursor, Write},
     path::{Path, PathBuf},
 };
 
 use jiff::{Zoned, tz::TimeZone};
 use reqwest::Response;
 use tracing::info;
 
 use crate::ebics::{EbicsCtx, EbicsError, EbicsErrorHelper};
 
 /** Log EBICS transactions steps and payload if dir is not null */
 pub struct EbicsLogger {
     dir: Option<PathBuf>,
 }
 
 impl EbicsLogger {
     pub fn new(dir: Option<PathBuf>) -> std::io::Result<Self> {
         if let Some(dir) = &dir {
             // Create logging directory if missing
             std::fs::create_dir_all(dir)?;
             info!(target: "ebics", "Logging EBICS to {dir:?}");
         }
         Ok(Self { dir })
     }
 
     fn log_dir(root: &Path, ctx: &EbicsCtx) -> Result<PathBuf, EbicsError> {
         let now_utc = Zoned::new(ctx.now, TimeZone::UTC).datetime();
         // yyyy-MM-dd per day directory & HH:mm:ss.SSS-name per transaction directory
         let path = root.join(format!(
             "{}/{}-{}",
             now_utc.date(),
             now_utc.strftime("%H:%M:%S.%3f"),
             ctx.order,
         ));
         std::fs::create_dir_all(&path).ctx(ctx)?;
         Ok(path)
     }
 
     fn prefix(ctx: &EbicsCtx) -> impl Display {
         std::fmt::from_fn(|f| match &ctx.phase {
             Some(phase) => write!(f, "{phase}-"),
             None => Ok(()),
         })
     }
 
     /** Log a [content] EBICS transaction payload of [type] */
     pub fn log_payload(&self, ctx: &EbicsCtx, content: &[u8], ty: &str) -> Result<(), EbicsError> {
         if let Some(root) = &self.dir {
             let dir = Self::log_dir(root, ctx)?;
             let ty = ty.to_lowercase();
             if ty == "zip" {
                 let dir = dir.join("payload");
                 std::fs::create_dir_all(&dir).ctx(ctx)?;
                 let mut z = zip::ZipArchive::new(Cursor::new(content)).unwrap();
                 for i in 0..z.len() {
                     let mut from = z.by_index(i).unwrap();
                     let mut to = std::fs::File::create_new(dir.join(from.name())).ctx(ctx)?;
                     std::io::copy(&mut from, &mut to).ctx(ctx)?;
                 }
             } else {
                 std::fs::File::create_new(dir.join(format!("payload.{ty}")))
                     .ctx(ctx)?
                     .write_all(content)
                     .ctx(ctx)?;
             }
         }
         Ok(())
     }
 
     /** Log a protocol step [request] */
     pub fn log_request(&self, ctx: &EbicsCtx, xml: &str) -> Result<(), EbicsError> {
         if let Some(root) = &self.dir {
             let dir = Self::log_dir(root, ctx)?;
             let path = dir.join(format!("{}request.xml", Self::prefix(ctx)));
             std::fs::File::create_new(path)
                 .ctx(ctx)?
                 .write_all(xml.as_bytes())
                 .ctx(ctx)?;
         }
         Ok(())
     }
 
     /** Log a protocol step failure */
     pub async fn log_failure(&self, ctx: &EbicsCtx<'_>, res: Response) -> Result<(), EbicsError> {
         if let Some(root) = &self.dir {
             let dir = Self::log_dir(root, ctx)?;
             let path = dir.join(format!("{}failure.xml", Self::prefix(ctx)));
             let fs = std::fs::File::create_new(path).ctx(ctx)?;
             let mut w = BufWriter::new(fs);
             writeln!(w, "{:?} {}", res.version(), res.status()).ctx(ctx)?;
             for (k, v) in res.headers() {
                 writeln!(w, "{k}:{}", String::from_utf8_lossy(v.as_bytes())).ctx(ctx)?;
             }
             writeln!(w).ctx(ctx)?;
             if let Ok(body) = res.bytes().await {
                 w.write_all(&body).ctx(ctx)?;
             }
         }
         Ok(())
     }
 
     /** Log a protocol step [response] */
     pub fn log_response(&self, ctx: &EbicsCtx, xml: &[u8]) -> Result<(), EbicsError> {
         if let Some(root) = &self.dir {
             let dir = Self::log_dir(root, ctx)?;
             let path = dir.join(format!("{}response.xml", Self::prefix(ctx)));
             std::fs::File::create_new(path)
                 .ctx(ctx)?
                 .write_all(xml)
                 .ctx(ctx)?;
         }
         Ok(())
     }
 }