_ Git - ldk-sample/blob - src/disk.rs

   1 use crate::cli;
   2 use bitcoin::secp256k1::key::PublicKey;
   3 use lightning::util::logger::{Logger, Record};
   4 use lightning::util::ser::Writer;
   5 use std::collections::HashMap;
   6 use std::fs;
   7 use std::fs::File;
   8 use std::io::{BufRead, BufReader};
   9 use std::net::SocketAddr;
  10 use std::path::Path;
  11 use time::OffsetDateTime;
  12
  13 pub(crate) struct FilesystemLogger {
  14         data_dir: String,
  15 }
  16 impl FilesystemLogger {
  17         pub(crate) fn new(data_dir: String) -> Self {
  18                 let logs_path = format!("{}/logs", data_dir);
  19                 fs::create_dir_all(logs_path.clone()).unwrap();
  20                 Self { data_dir: logs_path }
  21         }
  22 }
  23 impl Logger for FilesystemLogger {
  24         fn log(&self, record: &Record) {
  25                 let raw_log = record.args.to_string();
  26                 let log = format!(
  27                         "{} {:<5} [{}:{}] {}\n",
  28                         OffsetDateTime::now_utc().format("%F %T"),
  29                         record.level.to_string(),
  30                         record.module_path,
  31                         record.line,
  32                         raw_log
  33                 );
  34                 let logs_file_path = format!("{}/logs.txt", self.data_dir.clone());
  35                 fs::OpenOptions::new()
  36                         .create(true)
  37                         .append(true)
  38                         .open(logs_file_path)
  39                         .unwrap()
  40                         .write_all(log.as_bytes())
  41                         .unwrap();
  42         }
  43 }
  44 pub(crate) fn persist_channel_peer(path: &Path, peer_info: &str) -> std::io::Result<()> {
  45         let mut file = fs::OpenOptions::new().create(true).append(true).open(path)?;
  46         file.write_all(format!("{}\n", peer_info).as_bytes())
  47 }
  48
  49 pub(crate) fn read_channel_peer_data(
  50         path: &Path,
  51 ) -> Result<HashMap<PublicKey, SocketAddr>, std::io::Error> {
  52         let mut peer_data = HashMap::new();
  53         if !Path::new(&path).exists() {
  54                 return Ok(HashMap::new());
  55         }
  56         let file = File::open(path)?;
  57         let reader = BufReader::new(file);
  58         for line in reader.lines() {
  59                 match cli::parse_peer_info(line.unwrap()) {
  60                         Ok((pubkey, socket_addr)) => {
  61                                 peer_data.insert(pubkey, socket_addr);
  62                         }
  63                         Err(e) => return Err(e),
  64                 }
  65         }
  66         Ok(peer_data)
  67 }