global: one big snapshot

crates/brk_cli/src/config.rs

@@ -4,14 +4,16 @@ use std::{
 };
 
 use bitcoincore_rpc::{self, Auth, Client};
-use brk_core::{default_bitcoin_path, default_brk_path, default_on_error, dot_brk_path};
 use brk_fetcher::Fetcher;
 use brk_server::Website;
-use brk_vecs::{Computation, Format};
 use clap::Parser;
 use clap_derive::Parser;
 use color_eyre::eyre::eyre;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
+
+use crate::{default_bitcoin_path, default_brk_path, dot_brk_path};
+
+const DOWNLOADS: &str = "downloads";
 
 #[derive(Parser, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize)]
 #[command(version, about)]
@@ -31,16 +33,6 @@ pub struct Config {
     #[arg(long, value_name = "PATH")]
     brkdir: Option<String>,
 
-    /// Computation of computed datasets, `lazy` computes data whenever requested without saving it, `eager` computes the data once and saves it to disk, default: `lazy`, saved
-    #[serde(default, deserialize_with = "default_on_error")]
-    #[arg(short, long)]
-    computation: Option<Computation>,
-
-    /// Format of computed datasets, `compressed` to save disk space (experimental), `raw` to prioritize speed, default: `raw`, saved
-    #[serde(default, deserialize_with = "default_on_error")]
-    #[arg(short, long)]
-    format: Option<Format>,
-
     /// Activate fetching prices from exchanges APIs and the computation of all related datasets, default: true, saved
     #[serde(default, deserialize_with = "default_on_error")]
     #[arg(short = 'F', long, value_name = "BOOL")]
@@ -122,18 +114,10 @@ impl Config {
                 config_saved.brkdir = Some(brkdir);
             }
 
-            if let Some(computation) = config_args.computation.take() {
-                config_saved.computation = Some(computation);
-            }
-
             if let Some(fetch) = config_args.fetch.take() {
                 config_saved.fetch = Some(fetch);
             }
 
-            if let Some(format) = config_args.format.take() {
-                config_saved.format = Some(format);
-            }
-
             if let Some(website) = config_args.website.take() {
                 config_saved.website = Some(website);
             }
@@ -291,6 +275,10 @@ impl Config {
         self.brkdir().join("hars")
     }
 
+    pub fn downloads_dir(&self) -> PathBuf {
+        dot_brk_path().join(DOWNLOADS)
+    }
+
     fn path_cookiefile(&self) -> PathBuf {
         self.rpccookiefile.as_ref().map_or_else(
             || self.bitcoindir().join(".cookie"),
@@ -329,14 +317,6 @@ impl Config {
             .then(|| Fetcher::import(Some(self.harsdir().as_path())).unwrap())
     }
 
-    pub fn computation(&self) -> Computation {
-        self.computation.unwrap_or_default()
-    }
-
-    pub fn format(&self) -> Format {
-        self.format.unwrap_or_default()
-    }
-
     pub fn check_collisions(&self) -> bool {
         self.check_collisions.is_some_and(|b| b)
     }
@@ -349,3 +329,14 @@ impl Config {
         self.watch.is_some_and(|b| b)
     }
 }
+
+fn default_on_error<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+where
+    D: Deserializer<'de>,
+    T: Deserialize<'de> + Default,
+{
+    match T::deserialize(deserializer) {
+        Ok(v) => Ok(v),
+        Err(_) => Ok(T::default()),
+    }
+}

crates/brk_cli/src/lib.rs

@@ -2,11 +2,11 @@
 
 use std::{fs, thread};
 
-use brk_core::{dot_brk_log_path, dot_brk_path};
-
 mod config;
+mod paths;
 mod run;
 
+pub use paths::*;
 use run::*;
 
 pub fn main() -> color_eyre::Result<()> {

crates/brk_cli/src/paths.rs

@@ -0,0 +1,36 @@
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+pub fn dot_brk_path() -> PathBuf {
+    let home = std::env::var("HOME").unwrap();
+    Path::new(&home).join(".brk")
+}
+
+pub fn dot_brk_log_path() -> PathBuf {
+    dot_brk_path().join("log")
+}
+
+pub fn default_brk_path() -> PathBuf {
+    dot_brk_path()
+}
+
+pub fn default_bitcoin_path() -> PathBuf {
+    if env::consts::OS == "macos" {
+        default_mac_bitcoin_path()
+    } else {
+        default_linux_bitcoin_path()
+    }
+}
+
+pub fn default_linux_bitcoin_path() -> PathBuf {
+    Path::new(&std::env::var("HOME").unwrap()).join(".bitcoin")
+}
+
+pub fn default_mac_bitcoin_path() -> PathBuf {
+    Path::new(&std::env::var("HOME").unwrap())
+        .join("Library")
+        .join("Application Support")
+        .join("Bitcoin")
+}

crates/brk_cli/src/run.rs

@@ -2,9 +2,9 @@ use std::{thread::sleep, time::Duration};
 
 use bitcoincore_rpc::{self, RpcApi};
 use brk_computer::Computer;
-use brk_exit::Exit;
 use brk_indexer::Indexer;
 use brk_server::Server;
+use brk_vecs::Exit;
 use log::info;
 
 use crate::config::Config;
@@ -13,10 +13,11 @@ pub fn run() -> color_eyre::Result<()> {
     let config = Config::import()?;
 
     let rpc = config.rpc()?;
-    let exit = Exit::new();
-    let parser = brk_parser::Parser::new(config.blocksdir(), config.brkdir(), rpc);
 
-    let format = config.format();
+    let exit = Exit::new();
+    exit.set_ctrlc_handler();
+
+    let parser = brk_parser::Parser::new(config.blocksdir(), config.brkdir(), rpc);
 
     let mut indexer = Indexer::forced_import(&config.brkdir())?;
 
@@ -36,13 +37,7 @@ pub fn run() -> color_eyre::Result<()> {
         Ok(())
     };
 
-    let mut computer = Computer::forced_import(
-        &config.brkdir(),
-        &indexer,
-        config.computation(),
-        config.fetcher(),
-        format,
-    )?;
+    let mut computer = Computer::forced_import(&config.brkdir(), &indexer, config.fetcher())?;
 
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()
@@ -51,7 +46,12 @@ pub fn run() -> color_eyre::Result<()> {
             let served_indexer = indexer.clone();
             let served_computer = computer.clone();
 
-            let server = Server::new(served_indexer, served_computer, config.website())?;
+            let server = Server::new(
+                served_indexer,
+                served_computer,
+                config.website(),
+                &config.downloads_dir(),
+            )?;
 
             let watch = config.watch();
             let mcp = config.mcp();
@@ -72,7 +72,7 @@ pub fn run() -> color_eyre::Result<()> {
                 let starting_indexes =
                     indexer.index(&parser, rpc, &exit, config.check_collisions())?;
 
-                computer.compute(&mut indexer, starting_indexes, &exit)?;
+                computer.compute(&indexer, starting_indexes, &exit)?;
 
                 if let Some(delay) = config.delay() {
                     sleep(Duration::from_secs(delay))