110 lines
3.5 KiB
Rust
110 lines
3.5 KiB
Rust
#[cfg(feature = "ssr")]
|
|
pub(crate) mod beacons {
|
|
#[allow(dead_code)]
|
|
pub const LINUX_BEACON: &'static [u8] = include_bytes!(std::env!("SPARSE_BEACON_LINUX"));
|
|
#[allow(dead_code)]
|
|
pub const FREEBSD_BEACON: &'static [u8] = include_bytes!(std::env!("SPARSE_BEACON_FREEBSD"));
|
|
#[allow(dead_code)]
|
|
pub const WINDOWS_BEACON: &'static [u8] = include_bytes!(std::env!("SPARSE_BEACON_WINDOWS"));
|
|
|
|
#[allow(dead_code)]
|
|
pub const LINUX_INSTALLER: &'static [u8] = include_bytes!(std::env!("SPARSE_INSTALLER_LINUX"));
|
|
#[allow(dead_code)]
|
|
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")]
|
|
pub mod users;
|
|
|
|
pub mod error;
|
|
|
|
pub mod db;
|
|
|
|
#[cfg(feature = "ssr")]
|
|
#[tokio::main]
|
|
async fn main() -> anyhow::Result<std::process::ExitCode> {
|
|
use std::{path::PathBuf, process::ExitCode, str::FromStr};
|
|
|
|
use structopt::StructOpt;
|
|
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
|
|
use sqlx::sqlite::{SqlitePool, SqliteConnectOptions};
|
|
|
|
tracing_subscriber::registry()
|
|
.with(
|
|
tracing_subscriber::EnvFilter::try_from_default_env()
|
|
.unwrap_or_else(|_| format!("{}=debug,tower_http=trace", env!("CARGO_CRATE_NAME")).into()),
|
|
)
|
|
.with(tracing_subscriber::fmt::layer())
|
|
.init();
|
|
|
|
let options = cli::Options::from_args();
|
|
|
|
let db_location = options.db_location.clone()
|
|
.or(std::env::var("DATABASE_URL")
|
|
.map(|p| p.replace("sqlite://", ""))
|
|
.map(PathBuf::from)
|
|
.ok())
|
|
.unwrap_or(PathBuf::from("./db.sqlite"));
|
|
|
|
tracing::info!("Using database {}", db_location.display());
|
|
|
|
let db_exists = std::fs::metadata(&db_location);
|
|
|
|
let run_init = if let Err(e) = db_exists {
|
|
if !options.init_ok {
|
|
tracing::error!("Database doesn't exist, and initialization not allowed!");
|
|
tracing::error!("{:?}", e);
|
|
return Ok(ExitCode::FAILURE)
|
|
}
|
|
|
|
tracing::info!("Database doesn't exist, readying initialization");
|
|
true
|
|
} else {
|
|
false
|
|
};
|
|
|
|
let pool = SqlitePool::connect_with(
|
|
SqliteConnectOptions::from_str(&format!("sqlite://{}", db_location.to_string_lossy()))?
|
|
.create_if_missing(options.init_ok)
|
|
).await?;
|
|
|
|
tracing::info!("Running database migrations...");
|
|
|
|
sqlx::migrate!()
|
|
.run(&pool)
|
|
.await?;
|
|
|
|
tracing::info!("Done running database migrations!");
|
|
|
|
match options.command.clone() {
|
|
Some(cli::Command::Serve { management_address, bind_address }) => {
|
|
tracing::info!("Performing requested action, acting as web server");
|
|
webserver::serve_web(management_address, bind_address, pool).await
|
|
}
|
|
Some(cli::Command::ExtractPubKey { }) => {
|
|
Ok(ExitCode::SUCCESS)
|
|
}
|
|
Some(cli::Command::User { command }) => {
|
|
cli::user::handle_user_command(command, pool).await
|
|
}
|
|
None => {
|
|
use std::net::{Ipv4Addr, SocketAddrV4};
|
|
|
|
tracing::info!("Performing default action of acting as web server");
|
|
|
|
let default_management_ip = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 3000);
|
|
let default_beacon_ip = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 5000);
|
|
webserver::serve_web(default_management_ip, default_beacon_ip, pool).await
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(not(feature = "ssr"))]
|
|
pub fn main() {}
|