main.rs

mod content;
mod errors;
mod handlers;
mod renderer;
mod state;

use tracing_subscriber::prelude::{ * };

use crate::errors::{ Result };
use crate::state::{ ServerState };
use axum::{ Router };
use axum::routing::{ get, post };
use axum_messages::{ MessagesManagerLayer };
use clap::{ Parser };
use include_dir::{ Dir, include_dir };
use kdl::{ KdlDocument };
use tokio::net::{ TcpListener };
use tower_http::services::{ ServeDir };
use tower_http::trace::{ TraceLayer };
use tower_sessions::{ Expiry, MemoryStore, SessionManagerLayer };
use tracing_subscriber::filter::{ EnvFilter, LevelFilter };
use std::path::{ PathBuf };
use std::process::{ ExitCode };
use std::sync::{ Arc };
use time::{ Duration };

static DEFAULT_THEME: Dir = include_dir!("themes/simple");

/// The server program for the Limetree CMS.
#[derive(Debug, Parser)]
#[command(about, version)]
struct CommandLine {
  /// Path to the limetree.kdl configuration file.
  #[arg(short, long)]
  configuration_file: PathBuf,

  /// Run in development mode. This is only useful if you are working on Limetree itself.
  #[arg(short, long)]
  development_mode: bool,
}

#[tokio::main]
async fn main() -> ExitCode {
  let result = run_server().await;

  match result {
    Ok(_) => ExitCode::SUCCESS,
    Err(e) => {
      tracing::error!("{}", e);
      ExitCode::FAILURE
    },
  }
}

async fn run_server() -> Result<()> {
  let command_line = CommandLine::parse();
  let configuration_text = std::fs::read_to_string(&command_line.configuration_file)?;
  let configuration = KdlDocument::parse(&configuration_text)?;

  let filter_level = if command_line.development_mode {
    LevelFilter::TRACE
  } else {
    LevelFilter::INFO
  };

  let filter_layer = EnvFilter::builder()
    .with_default_directive(filter_level.into())
    .from_env_lossy();

  tracing_subscriber::registry()
    .with(tracing_subscriber::fmt::layer())
    .with(filter_layer)
    .init();

  let site_title = configuration
    .get("frontend")
    .and_then(|node| node.children())
    .and_then(|document| document.get_arg("title"))
    .and_then(|value| value.as_string())
    .unwrap_or("Limetree CMS")
    .to_string();

  let theme_name = configuration
    .get("frontend")
    .and_then(|node| node.children())
    .and_then(|document| document.get_arg("theme"))
    .and_then(|value| value.as_string())
    .unwrap_or("simple")
    .to_string();

  let limetree_root = configuration
    .get("backend")
    .and_then(|node| node.children())
    .and_then(|document| document.get_arg("root"))
    .and_then(|value| value.as_string())
    .map(PathBuf::from)
    .unwrap_or(std::env::current_dir()?.join("limetree_data"));

  let content_path = configuration
    .get("backend")
    .and_then(|node| node.children())
    .and_then(|document| document.get_arg("content_path"))
    .and_then(|value| value.as_string())
    .map(PathBuf::from)
    .unwrap_or(limetree_root.join("content"));

  let metadata_path = configuration
    .get("backend")
    .and_then(|node| node.children())
    .and_then(|document| document.get_arg("metadata_path"))
    .and_then(|value| value.as_string())
    .map(PathBuf::from)
    .unwrap_or(limetree_root.join("metadata.json"));

  let themes_path = configuration
    .get("backend")
    .and_then(|node| node.children())
    .and_then(|document| document.get_arg("themes_path"))
    .and_then(|value| value.as_string())
    .map(PathBuf::from)
    .unwrap_or(limetree_root.join("themes"));

  let theme_path = themes_path.join(&theme_name);
  let theme_static_path = theme_path.join("static");

  // Avoid having to delete the bundled `simple` theme every time we `cargo run` the development
  // server
  if theme_name == "simple" && command_line.development_mode {
    std::fs::remove_dir_all(&theme_path)?;
  }

  if theme_name == "simple" && !theme_path.is_dir() {
    DEFAULT_THEME.extract(&theme_path)?;
  }

  let session_store = MemoryStore::default();
  let session_layer = SessionManagerLayer::new(session_store)
    .with_secure(false)
    .with_expiry(Expiry::OnInactivity(Duration::seconds(10)));

  let server_state = ServerState::new(&site_title, &content_path, &metadata_path, &theme_path)?;

  let router = Router::new()
    .layer(TraceLayer::new_for_http())
    .route("/", get(handlers::index))
    .route("/api/authenticate", post(handlers::authenticate_api))
    .route("/api/page/new", post(handlers::new_page_api))
    .route("/api/page/edit/{slug}", post(handlers::edit_page_api))
    .route("/authenticate", get(handlers::authenticate))
    .route("/page/new", get(handlers::new_page))
    .route("/page/edit/{slug}", get(handlers::edit_page))
    .route("/page/view/{slug}", get(handlers::view_page))
    .route("/tags/all", get(handlers::all_tags))
    .route("/tags/in/{tag}", get(handlers::in_tags))
    .layer(MessagesManagerLayer)
    .layer(session_layer)
    .with_state(Arc::new(server_state))
    .nest_service("/static", ServeDir::new(theme_static_path));

  const HOST: &str = "localhost";
  const PORT: u16 = 8081;

  let address = format!("{}:{}", HOST, PORT);
  let listener = TcpListener::bind(address).await?;

  let bound_address = listener.local_addr()?;
  tracing::info!("{} now listening on {}", env!("CARGO_BIN_NAME"), bound_address);

  axum::serve(listener, router).await?;
  Ok(())
}