98 lines
3.2 KiB
Rust
98 lines
3.2 KiB
Rust
//! # peach-web
|
|
//!
|
|
//! `peach-web` provides a web interface for monitoring and interacting with the
|
|
//! PeachCloud device. This allows administration of the single-board computer
|
|
//! (ie. Raspberry Pi) running PeachCloud, as well as the ssb-server and related
|
|
//! plugins.
|
|
//!
|
|
//! ## Design
|
|
//!
|
|
//! `peach-web` is written primarily in Rust and presents a web interface for
|
|
//! interacting with the device. The stack currently consists of Rocket (Rust
|
|
//! web framework), Tera (Rust template engine inspired by Jinja2 and the Django
|
|
//! template language), HTML, CSS and JavaScript. Additional functionality is
|
|
//! provided by JSON-RPC clients for the `peach-network` and `peach-stats`
|
|
//! microservices.
|
|
//!
|
|
//! HTML is rendered server-side. Request handlers call JSON-RPC microservices
|
|
//! and serve HTML and assets. A JSON API is exposed for remote calls and
|
|
//! dynamic client-side content updates via vanilla JavaScript following
|
|
//! unobstructive design principles. Each Tera template is passed a context
|
|
//! object. In the case of Rust, this object is a `struct` and must implement
|
|
//! `Serialize`. The fields of the context object are available in the context
|
|
//! of the template to be rendered.
|
|
|
|
#![feature(proc_macro_hygiene, decl_macro)]
|
|
|
|
mod context;
|
|
pub mod error;
|
|
mod router;
|
|
pub mod routes;
|
|
#[cfg(test)]
|
|
mod tests;
|
|
pub mod utils;
|
|
|
|
use std::process;
|
|
|
|
use log::{debug, error, info};
|
|
use rocket::{fairing::AdHoc, serde::Deserialize, Build, Rocket};
|
|
|
|
pub type BoxError = Box<dyn std::error::Error>;
|
|
|
|
/// Application configuration parameters.
|
|
/// These values are extracted from Rocket's default configuration provider:
|
|
/// `Config::figment()`. As such, the values are drawn from `Rocket.toml` or
|
|
/// the TOML file path in the `ROCKET_CONFIG` environment variable. The TOML
|
|
/// file parameters are automatically overruled by any `ROCKET_` variables
|
|
/// which might be set.
|
|
#[derive(Debug, Deserialize)]
|
|
pub struct RocketConfig {
|
|
disable_auth: bool,
|
|
standalone_mode: bool,
|
|
}
|
|
|
|
static WLAN_IFACE: &str = "wlan0";
|
|
static AP_IFACE: &str = "ap0";
|
|
|
|
pub fn init_rocket() -> Rocket<Build> {
|
|
info!("Initializing Rocket");
|
|
// build a basic rocket instance
|
|
let rocket = rocket::build();
|
|
|
|
// return the default provider figment used by `rocket::build()`
|
|
let figment = rocket.figment();
|
|
|
|
// deserialize configuration parameters into our `RocketConfig` struct (defined above)
|
|
// since we're in the intialisation phase, panic if the extraction fails
|
|
let config: RocketConfig = figment.extract().expect("configuration extraction failed");
|
|
|
|
debug!("{:?}", config);
|
|
|
|
info!("Mounting Rocket routes");
|
|
let mounted_rocket = if config.standalone_mode {
|
|
router::mount_peachpub_routes(rocket)
|
|
} else {
|
|
router::mount_peachcloud_routes(rocket)
|
|
};
|
|
|
|
info!("Attaching application configuration to managed state");
|
|
mounted_rocket.attach(AdHoc::config::<RocketConfig>())
|
|
}
|
|
|
|
/// Launch the peach-web rocket server.
|
|
#[rocket::main]
|
|
async fn main() {
|
|
// initialize logger
|
|
env_logger::init();
|
|
|
|
// initialize rocket
|
|
let rocket = init_rocket();
|
|
|
|
// launch rocket
|
|
info!("Launching Rocket");
|
|
if let Err(e) = rocket.launch().await {
|
|
error!("Error in Rocket application: {}", e);
|
|
process::exit(1);
|
|
}
|
|
}
|