global: snapshot

crates/brk_cli/src/bridge.rs

@@ -0,0 +1,111 @@
+use std::{fs, io, path::Path};
+
+use brk_interface::{Index, Interface};
+use brk_server::VERSION;
+
+use crate::website::Website;
+
+const SCRIPTS: &str = "scripts";
+
+#[allow(clippy::upper_case_acronyms)]
+pub trait Bridge {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()>;
+}
+
+impl Bridge for Interface<'static> {
+    fn generate_bridge_file(&self, website: Website, websites_path: &Path) -> io::Result<()> {
+        if website.is_none() {
+            return Ok(());
+        }
+
+        let path = websites_path.join(website.to_folder_name());
+
+        if !fs::exists(&path)? {
+            return Ok(());
+        }
+
+        let path = path.join(SCRIPTS);
+
+        fs::create_dir_all(&path)?;
+
+        let path = path.join(Path::new("vecid-to-indexes.js"));
+
+        let indexes = Index::all();
+
+        let mut contents = format!(
+            "//
+// File auto-generated, any modifications will be overwritten
+//
+
+export const VERSION = \"v{VERSION}\";
+
+"
+        );
+
+        contents += &indexes
+            .iter()
+            .enumerate()
+            .map(|(i_of_i, i)| {
+                // let lowered = i.to_string().to_lowercase();
+                format!("/** @typedef {{{i_of_i}}} {i} */",)
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        contents += &format!(
+            "\n\n/** @typedef {{{}}} Index */\n",
+            indexes
+                .iter()
+                .map(|i| i.to_string())
+                .collect::<Vec<_>>()
+                .join(" | ")
+        );
+
+        contents += "
+/** @typedef {ReturnType<typeof createIndexes>} Indexes */
+
+export function createIndexes() {
+  return {
+";
+
+        contents += &indexes
+            .iter()
+            .enumerate()
+            .map(|(i_of_i, i)| {
+                let lowered = i.to_string().to_lowercase();
+                format!("    {lowered}: /** @satisfies {{{i}}} */ ({i_of_i}),",)
+            })
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        contents += "  };\n}\n";
+
+        contents += "
+/** @typedef {ReturnType<typeof createVecIdToIndexes>} VecIdToIndexes
+/** @typedef {keyof VecIdToIndexes} VecId */
+
+/**
+ * @returns {Record<any, number[]>}
+ */
+export function createVecIdToIndexes() {
+  return {
+";
+
+        self.id_to_index_to_vec()
+            .iter()
+            .for_each(|(id, index_to_vec)| {
+                let indexes = index_to_vec
+                    .keys()
+                    .map(|i| (*i as u8).to_string())
+                    // .map(|i| i.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+
+                contents += &format!("    \"{id}\": [{indexes}],\n");
+            });
+
+        contents += "  };\n}\n";
+
+        fs::write(path, contents)
+    }
+}

crates/brk_cli/src/config.rs

@@ -5,13 +5,12 @@ use std::{
 
 use bitcoincore_rpc::{self, Auth, Client};
 use brk_fetcher::Fetcher;
-use brk_server::Website;
 use clap::Parser;
 use clap_derive::Parser;
 use color_eyre::eyre::eyre;
 use serde::{Deserialize, Deserializer, Serialize};
 
-use crate::{default_bitcoin_path, default_brk_path, dot_brk_path};
+use crate::{default_bitcoin_path, default_brk_path, dot_brk_path, website::Website};
 
 const DOWNLOADS: &str = "downloads";
 

crates/brk_cli/src/lib.rs

@@ -1,13 +1,28 @@
 #![doc = include_str!("../README.md")]
 
-use std::{fs, thread};
+use std::{
+    fs,
+    io::Cursor,
+    path::Path,
+    thread::{self, sleep},
+    time::Duration,
+};
 
+use bitcoincore_rpc::{self, RpcApi};
+use brk_bundler::bundle;
+use brk_computer::Computer;
+use brk_indexer::Indexer;
+use brk_interface::Interface;
+use brk_server::{Server, VERSION};
+use brk_vecs::Exit;
+use log::info;
+
+mod bridge;
 mod config;
 mod paths;
-mod run;
+mod website;
 
-pub use paths::*;
-use run::*;
+use crate::{bridge::Bridge, config::Config, paths::*};
 
 pub fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
@@ -22,3 +37,118 @@ pub fn main() -> color_eyre::Result<()> {
         .join()
         .unwrap()
 }
+
+pub fn run() -> color_eyre::Result<()> {
+    let config = Config::import()?;
+
+    let rpc = config.rpc()?;
+
+    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())?;
+
+    let wait_for_synced_node = |rpc_client: &bitcoincore_rpc::Client| -> color_eyre::Result<()> {
+        let is_synced = || -> color_eyre::Result<bool> {
+            let info = rpc_client.get_blockchain_info()?;
+            Ok(info.headers == info.blocks)
+        };
+
+        if !is_synced()? {
+            info!("Waiting for node to be synced...");
+            while !is_synced()? {
+                sleep(Duration::from_secs(1))
+            }
+        }
+
+        Ok(())
+    };
+
+    let mut computer = Computer::forced_import(&config.brkdir(), &indexer, config.fetcher())?;
+
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()?
+        .block_on(async {
+            let interface = Interface::build(&indexer, &computer);
+
+            let website = config.website();
+
+            let downloads_path = config.downloads_dir();
+
+            let bundle_path = if website.is_some() {
+                let websites_dev_path = Path::new("../../websites");
+
+                let websites_path = if fs::exists(websites_dev_path)? {
+                    websites_dev_path.to_path_buf()
+                } else {
+                    let downloaded_websites_path =
+                        downloads_path.join(format!("brk-{VERSION}")).join("websites");
+
+                    if !fs::exists(&downloaded_websites_path)? {
+                        info!("Downloading websites from Github...");
+
+                        let url = format!(
+                            "https://github.com/bitcoinresearchkit/brk/archive/refs/tags/v{VERSION}.zip",
+                        );
+
+                        let response = minreq::get(url).send()?;
+                        let bytes = response.as_bytes();
+                        let cursor = Cursor::new(bytes);
+
+                        let mut zip = zip::ZipArchive::new(cursor).unwrap();
+
+                        zip.extract(downloads_path).unwrap();
+                    }
+
+                    downloaded_websites_path
+                };
+
+                interface.generate_bridge_file(website, websites_path.as_path())?;
+
+                let watch = config.watch();
+
+                Some(bundle(&websites_path, website.to_folder_name(), watch).await?)
+            } else {
+                None
+            };
+
+            let server = Server::new(
+                interface,
+                bundle_path,
+            );
+
+            let mcp = config.mcp();
+
+            tokio::spawn(async move {
+                server.serve(mcp).await.unwrap();
+            });
+
+            sleep(Duration::from_secs(1));
+
+            loop {
+                wait_for_synced_node(rpc)?;
+
+                let block_count = rpc.get_block_count()?;
+
+                info!("{} blocks found.", block_count + 1);
+
+                let starting_indexes =
+                    indexer.index(&parser, rpc, &exit, config.check_collisions())?;
+
+                computer.compute(&indexer, starting_indexes, &exit)?;
+
+                if let Some(delay) = config.delay() {
+                    sleep(Duration::from_secs(delay))
+                }
+
+                info!("Waiting for new blocks...");
+
+                while block_count == rpc.get_block_count()? {
+                    sleep(Duration::from_secs(1))
+                }
+            }
+        })
+}

crates/brk_cli/src/run.rs

@@ -1,88 +0,0 @@
-use std::{thread::sleep, time::Duration};
-
-use bitcoincore_rpc::{self, RpcApi};
-use brk_computer::Computer;
-use brk_indexer::Indexer;
-use brk_server::Server;
-use brk_vecs::Exit;
-use log::info;
-
-use crate::config::Config;
-
-pub fn run() -> color_eyre::Result<()> {
-    let config = Config::import()?;
-
-    let rpc = config.rpc()?;
-
-    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())?;
-
-    let wait_for_synced_node = |rpc_client: &bitcoincore_rpc::Client| -> color_eyre::Result<()> {
-        let is_synced = || -> color_eyre::Result<bool> {
-            let info = rpc_client.get_blockchain_info()?;
-            Ok(info.headers == info.blocks)
-        };
-
-        if !is_synced()? {
-            info!("Waiting for node to be synced...");
-            while !is_synced()? {
-                sleep(Duration::from_secs(1))
-            }
-        }
-
-        Ok(())
-    };
-
-    let mut computer = Computer::forced_import(&config.brkdir(), &indexer, config.fetcher())?;
-
-    tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()?
-        .block_on(async {
-            let served_indexer = indexer.clone();
-            let served_computer = computer.clone();
-
-            let server = Server::new(
-                served_indexer,
-                served_computer,
-                config.website(),
-                &config.downloads_dir(),
-            )?;
-
-            let watch = config.watch();
-            let mcp = config.mcp();
-
-            tokio::spawn(async move {
-                server.serve(watch, mcp).await.unwrap();
-            });
-
-            sleep(Duration::from_secs(1));
-
-            loop {
-                wait_for_synced_node(rpc)?;
-
-                let block_count = rpc.get_block_count()?;
-
-                info!("{} blocks found.", block_count + 1);
-
-                let starting_indexes =
-                    indexer.index(&parser, rpc, &exit, config.check_collisions())?;
-
-                computer.compute(&indexer, starting_indexes, &exit)?;
-
-                if let Some(delay) = config.delay() {
-                    sleep(Duration::from_secs(delay))
-                }
-
-                info!("Waiting for new blocks...");
-
-                while block_count == rpc.get_block_count()? {
-                    sleep(Duration::from_secs(1))
-                }
-            }
-        })
-}

crates/brk_cli/src/website.rs

@@ -0,0 +1,27 @@
+use clap_derive::ValueEnum;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Deserialize, Serialize, ValueEnum)]
+pub enum Website {
+    None,
+    Default,
+    Custom,
+}
+
+impl Website {
+    pub fn is_none(&self) -> bool {
+        self == &Self::None
+    }
+
+    pub fn is_some(&self) -> bool {
+        !self.is_none()
+    }
+
+    pub fn to_folder_name(self) -> &'static str {
+        match self {
+            Self::Custom => "custom",
+            Self::Default => "default",
+            Self::None => unreachable!(),
+        }
+    }
+}