peach-workspace/peach-web/src/main.rs

//! # 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 Rouille (Rust
//! micro-web-framework), Maud (an HTML template engine for Rust), HTML and
//! CSS.

//mod context;
pub mod error;
//mod router;
//pub mod routes;
//#[cfg(test)]
//mod tests;
mod templates;
pub mod utils;

use std::sync::RwLock;

use lazy_static::lazy_static;
//use log::{debug, error, info};
use log::info;
//use peach_lib::{config_manager, config_manager::YAML_PATH as PEACH_CONFIG};
//use rocket::{fairing::AdHoc, serde::Deserialize, Build, Rocket};

use rouille::{router, Response};

use utils::Theme;

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,
}
*/

lazy_static! {
    static ref THEME: RwLock<Theme> = RwLock::new(Theme::Light);
}

//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>())
}
*/

const HOSTNAME_AND_PORT: &str = "localhost:8000";

/// Launch the peach-web server.
fn main() {
    // initialize logger
    env_logger::init();

    /*
    // check if /var/lib/peachcloud/config.yml exists
    if !std::path::Path::new(PEACH_CONFIG).exists() {
        info!("PeachCloud configuration file not found; loading default values");
        // since we're in the intialisation phase, panic if the loading fails
        let config =
            config_manager::load_peach_config().expect("peachcloud configuration loading failed");

        info!("Saving default PeachCloud configuration values to file");
        // this ensures a config file is created if it does not already exist
        config_manager::save_peach_config(config).expect("peachcloud configuration saving failed");
    }
    */

    info!("Launching web server...");

    // the `start_server` starts listening forever on the given address.
    rouille::start_server(HOSTNAME_AND_PORT, move |request| {
        info!("Now listening on {}", HOSTNAME_AND_PORT);

        // static file server
        // matches on assets in the `static` directory
        let response = rouille::match_assets(&request, "static");
        if response.is_success() {
            return response;
        }

        router!(request,
            (GET) (/) => {
                Response::html(templates::home::build())
            },

            // The code block is called if none of the other blocks matches the request.
            // We return an empty response with a 404 status code.
            _ => Response::empty_404()
        )
    });
}