feat: prep work for web UI

sparse-server/.cargo/config.toml

@@ -0,0 +1,5 @@
+[target.x86_64-unknown-linux-musl]
+rustflags = ["-C", "link-arg=-fuse-ld=mold"]
+
+[target.x86_64-unknown-linux-gnu]
+rustflags = ["-C", "link-arg=-fuse-ld=mold"]

sparse-server/Cargo.toml

@@ -19,6 +19,10 @@ tower-http = { version = "0.5", features = ["fs"], optional = true }
 wasm-bindgen = "=0.2.95"
 thiserror = "1"
 http = "1"
+axum-server = { version = "0.7.1", features = ["tokio-rustls"], optional = true }
+tracing-subscriber = { version = "0.3.19", features = ["chrono", "env-filter", "serde", "tracing", "tracing-serde"], optional = true }
+structopt = { version = "0.3", optional = true }
+anyhow = "1.0.95"
 
 [features]
 hydrate = ["leptos/hydrate"]
@@ -28,6 +32,9 @@ ssr = [
   "dep:tower",
   "dep:tower-http",
   "dep:leptos_axum",
+  "dep:axum-server",
+  "dep:tracing-subscriber",
+  "dep:structopt",
   "leptos/ssr",
   "leptos_meta/ssr",
   "leptos_router/ssr",

sparse-server/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    include!("../build_common.rs");
+}

sparse-server/src/cli.rs

@@ -0,0 +1,16 @@
+use std::path::PathBuf;
+use structopt::StructOpt;
+
+#[derive(StructOpt, Debug, Clone)]
+#[structopt(name = "sparse-server")]
+pub struct Options {
+    #[structopt(subcommand)]
+    pub command: Option<Command>,
+}
+
+#[derive(StructOpt, Debug, Clone)]
+#[structopt()]
+pub enum Command {
+    Serve {},
+    Init {},
+}

sparse-server/src/main.rs

@@ -1,39 +1,40 @@
+#[cfg(feature = "ssr")]
+pub(crate) mod beacons {
+    pub const LINUX_BEACON: &'static [u8] = include_bytes!(std::env!("SPARSE_BEACON_LINUX"));
+    pub const FREEBSD_BEACON: &'static [u8] = include_bytes!(std::env!("SPARSE_BEACON_FREEBSD"));
+    pub const WINDOWS_BEACON: &'static [u8] = include_bytes!(std::env!("SPARSE_BEACON_WINDOWS"));
+
+    pub const LINUX_INSTALLER: &'static [u8] = include_bytes!(std::env!("SPARSE_INSTALLER_LINUX"));
+    pub const FREEBSD_INSTALLER: &'static [u8] = include_bytes!(std::env!("SPARSE_INSTALLER_FREEBSD"));
+}
+
+#[cfg(feature = "ssr")]
+mod cli;
+
+#[cfg(feature = "ssr")]
+mod webserver;
 
 #[cfg(feature = "ssr")]
 #[tokio::main]
-async fn main() {
-    use axum::Router;
-    use leptos::logging::log;
-    use leptos::prelude::*;
-    use leptos_axum::{generate_route_list, LeptosRoutes};
-    use sparse_server::app::*;
+async fn main() -> anyhow::Result<()> {
+    use structopt::StructOpt;
 
-    let conf = get_configuration(None).unwrap();
-    let addr = conf.leptos_options.site_addr;
-    let leptos_options = conf.leptos_options;
-    // Generate the list of routes in your Leptos App
-    let routes = generate_route_list(App);
+    let options = cli::Options::from_args();
 
-    let app = Router::new()
-        .leptos_routes(&leptos_options, routes, {
-            let leptos_options = leptos_options.clone();
-            move || shell(leptos_options.clone())
-        })
-        .fallback(leptos_axum::file_and_error_handler(shell))
-        .with_state(leptos_options);
+    match options.command.clone() {
+        Some(cli::Command::Serve { }) => {
+            webserver::serve_web(options).await?;
+        }
+        Some(cli::Command::Init {  }) => {
 
-    // run our app with hyper
-    // `axum::Server` is a re-export of `hyper::Server`
-    log!("listening on http://{}", &addr);
-    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
-    axum::serve(listener, app.into_make_service())
-        .await
-        .unwrap();
+        }
+        None => {
+            webserver::serve_web(options).await?;
+        }
+    }
+
+    Ok(())
 }
 
 #[cfg(not(feature = "ssr"))]
-pub fn main() {
-    // no client-side main function
-    // unless we want this to work with e.g., Trunk for pure client-side testing
-    // see lib.rs for hydration function instead
-}
+pub fn main() {}

sparse-server/src/webserver.rs

@@ -0,0 +1,38 @@
+pub async fn serve_web(options: crate::cli::Options) -> anyhow::Result<()> {
+    use axum::Router;
+    use leptos::logging::log;
+    use leptos::prelude::*;
+    use leptos_axum::{generate_route_list, LeptosRoutes};
+    use sparse_server::app::*;
+    use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+    tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| format!("{}=debug", env!("CARGO_CRATE_NAME")).into()),
+        )
+        .with(tracing_subscriber::fmt::layer())
+        .init();
+
+    let conf = get_configuration(None).unwrap();
+    let addr = conf.leptos_options.site_addr;
+    let leptos_options = conf.leptos_options;
+    // Generate the list of routes in your Leptos App
+    let routes = generate_route_list(App);
+
+    let app = Router::new()
+        .leptos_routes(&leptos_options, routes, {
+            let leptos_options = leptos_options.clone();
+            move || shell(leptos_options.clone())
+        })
+        .fallback(leptos_axum::file_and_error_handler(shell))
+        .with_state(leptos_options);
+
+    // run our app with hyper
+    // `axum::Server` is a re-export of `hyper::Server`
+    log!("listening on http://{}", &addr);
+    let listener = tokio::net::TcpListener::bind(&addr).await?;
+    axum::serve(listener, app.into_make_service()).await?;
+
+    Ok(())
+}