gitten.rs

use axum::{ Router, serve };
use axum::extract::{ State };
use axum::http::{ StatusCode };
use axum::response::{ Html, IntoResponse, Response };
use axum::routing::{ get };
use clap::{ Parser };
use config::{ Config };
use serde::{ Serialize };
use tera::{ Context, Tera };
use tracing_subscriber::layer::{ SubscriberExt };
use tracing_subscriber::util::{ SubscriberInitExt };
use tokio::net::{ TcpListener };
use tower_http::services::{ ServeDir };
use tower_http::trace::{ TraceLayer };

use std::fmt;
use std::fs;
use std::io;
use std::path::{ PathBuf };
use std::process::{ ExitCode };
use std::str::{ FromStr };
use std::sync::{ Arc };

// -------------------------------------------------------------------------------------------------
// Error handling ----------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

type Result<T> = ::std::result::Result<T, Error>;

#[derive(Debug)]
enum Error {
	ConfigError(config::ConfigError),
	IoError(io::Error),
	TeraError(tera::Error),
	InvalidGitRoot(io::Error),
}

impl fmt::Display for Error {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		use Error::*;

		match *self {
			ConfigError(ref e) => write!(f, "Config error: {}", e),
			IoError(ref e) => write!(f, "IO error: {}", e),
			TeraError(ref e) => write!(f, "Tera error: {}", e),
			InvalidGitRoot(ref e) => write!(f, "Invalid git.root: {}", e),
		}
	}
}

impl From<config::ConfigError> for Error {
	fn from(e: config::ConfigError) -> Error {
		Error::ConfigError(e)
	}
}

impl From<io::Error> for Error {
	fn from(e: io::Error) -> Error {
		Error::IoError(e)
	}
}

impl From<tera::Error> for Error {
	fn from(e: tera::Error) -> Error {
		Error::TeraError(e)
	}
}

impl IntoResponse for Error {
	fn into_response(self) -> Response {
		use Error::*;

		tracing::error!("Error when building response: {}", &self);

		let body = match self {
			ConfigError(..) => "The server encountered an unexpected error",
			IoError(..) => "The server encountered an unexpected error",
			TeraError(..) => "The server encountered an unexpected error",
			InvalidGitRoot(..) => "The server encountered an unexpected error",
		};

		(StatusCode::INTERNAL_SERVER_ERROR, body).into_response()
	}
}

// -------------------------------------------------------------------------------------------------
// Argument parsing --------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

#[derive(Parser)]
#[command(author, version, about)]
struct Arguments {
	/// Additional configuration files to load (may be passed multiple times)
	#[arg(id="configuration_file", short, long)]
	configuration_files: Vec<String>,

	/// Additional configuration parameters to use (may be passed multiple times; overrides configuration files)
	#[arg(id="set_parameter", short, long)]
	configuration_parameters: Vec<ArgumentPair>,
}

#[derive(Debug, Clone)]
struct ArgumentPair(String, String);

impl FromStr for ArgumentPair {
	type Err = clap::Error;

	fn from_str(s: &str) -> ::std::result::Result<ArgumentPair, clap::Error> {
		let parts: Vec<&str> = s.splitn(2, "=").collect();

		if parts.len() != 2 {
			return Err(clap::Error::new(clap::error::ErrorKind::WrongNumberOfValues));
		}

		Ok(ArgumentPair(parts[0].to_string(), parts[1].to_string()))
	}
}

// -------------------------------------------------------------------------------------------------
// Application -------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

struct ApplicationState {
	application_name: String,
	repositories: Vec<Repository>,
	tera: Tera,
}

struct Repository {
	name: String,
	path: PathBuf,
}

impl Repository {
	fn new(name: String, path: PathBuf) -> Repository {
		Repository {
			name,
			path
		}
	}
}

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

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

async fn run_server() -> Result<()> {
	let arguments = Arguments::parse();

	// Set up default configuration values
	let mut builder = Config::builder()
		.set_default("application.name", "Gitten")?
		.set_default("network.host", "localhost")?
		.set_default("network.port", 8080)?;

	// Read any configuration files
	for path in arguments.configuration_files {
		builder = builder.add_source(config::File::with_name(&path));
	}

	// Apply configuration parameters specified on the command line
	for parameter in arguments.configuration_parameters {
		builder = builder.set_override(parameter.0, parameter.1)?;
	}

	let config = builder.build()?;

	// Retrieve any configuration values we need
	let application_name = config.get_string("application.name")?;
	let git_root = config.get_string("git.root")?;
	let network_host = config.get_string("network.host")?;
	let network_port = config.get_int("network.port")?;

	// Configure tracing
	tracing_subscriber::registry()
		.with(tracing_subscriber::fmt::layer())
		.init();

	// Scan the git root for repositories
	let repositories = discover_git_repositories(&git_root)?;

	// Configure Tera (the templating engine)
	let tera = Tera::new("templates/**/*.tera.html")?;

	// Configure the shared server state object
	let application_state = ApplicationState {
		application_name: application_name.clone(),
		repositories,
		tera,
	};

	// Configure the router
	let router = Router::new()
		.layer(TraceLayer::new_for_http())
		.route("/", get(index))
		.nest_service("/static", ServeDir::new("static"))
		.with_state(Arc::new(application_state));

	// Bind to an address and start the server
	let address = format!("{}:{}", network_host, network_port);
	let listener = TcpListener::bind(address).await?;
	tracing::debug!("{} v0.1.0 now listening on {}", application_name, listener.local_addr()?);

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

// -------------------------------------------------------------------------------------------------
// Git repositories --------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

fn discover_git_repositories(git_root: &str) -> Result<Vec<Repository>> {
	let iterator = match fs::read_dir(git_root) {
		Ok(it) => Ok(it),
		Err(e) => Err(Error::InvalidGitRoot(e)),
	}?;

	let mut repositories = Vec::new();

	for entry in iterator {
		let repo_path = entry?.path();

		if !repo_path.is_dir() {
			tracing::debug!("{} is not a directory", repo_path.display());
			continue;
		}

		if repo_path.extension() != Some(std::ffi::OsStr::new("git")) {
			tracing::debug!("{} is not a git repository", repo_path.display());
			continue;
		}

		let Some(repo_name) = repo_path.file_stem() else {
			tracing::debug!("{} doesn't have a file stem", repo_path.display());
			continue;
		};

		let Some(repo_name) = repo_name.to_str() else {
			tracing::debug!("{} isn't valid UTF-8", repo_path.display());
			continue;
		};

		tracing::debug!("Detected git repository {} at {}", repo_name, repo_path.display());
		let repository = Repository::new(repo_name.to_string(), repo_path);
		repositories.push(repository);
	}

	Ok(repositories)
}

// -------------------------------------------------------------------------------------------------
// Route handlers ----------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

async fn index(State(application_state): State<Arc<ApplicationState>>) -> Result<Html<String>> {
	let context = page_context(&application_state)?;
	let html = application_state.tera.render("index.tera.html", &context)?;
	Ok(Html(html))
}

// -------------------------------------------------------------------------------------------------
// Template contexts -------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------

#[derive(Serialize)]
struct ApplicationContext {
	name: String,
}

#[derive(Serialize)]
struct IndexContext {
	repositories: Vec<RepositoryContext>,
}

#[derive(Serialize)]
struct RepositoryContext {
	name: String,
	link: String,
}

fn page_context(application_state: &ApplicationState) -> Result<Context> {
	let mut context = Context::new();
	let application_context = ApplicationContext {
		name: application_state.application_name.clone(),
	};
	let index_context = IndexContext {
		repositories: application_state.repositories.iter().map(|r| { RepositoryContext { name: r.name.clone(), link: "/".to_string() } }).collect(),
	};
	context.insert("application", &application_context);
	context.insert("index", &index_context);
	Ok(context)
}