Lines
30.77 %
Functions
13.73 %
Branches
100 %
mod dataset;
mod fetch;
use self::{
dataset::{load_datasets, Dataset, DatasetVersion},
fetch::fetch_all,
};
use crate::{server_config::ServerConfig, server_error::MyError};
use axum::{
body::HttpBody,
extract::{Path, State},
response::Html,
routing::get,
Router,
use chrono::{DateTime, Utc};
use serde::Serialize;
use std::{
error::Error,
path::PathBuf,
sync::{Arc, RwLock},
use tera::{Context, Tera};
#[derive(Serialize)]
struct DatasetSummary<'a> {
id: &'a str,
latest_version: Option<DateTime<Utc>>,
number_of_versions: usize,
}
impl<'a> From<&'a Dataset> for DatasetSummary<'a> {
fn from(dataset: &'a Dataset) -> Self {
DatasetSummary {
id: &dataset.id,
latest_version: dataset.latest_version(),
number_of_versions: dataset.versions.len(),
async fn route_get_index(State(state): State<SharedState>) -> Result<Html<String>, MyError> {
let state = &mut state.read().unwrap();
let mut context = Context::new();
let datasets: Vec<_> = state.datasets.iter().map(DatasetSummary::from).collect();
context.insert("datasets", &datasets);
let html = state.tera.render("index.html", &context)?;
Ok(Html(html))
struct DatasetVersionSummary {
date: DateTime<Utc>,
number_of_quads: usize,
impl<'a> From<&'a DatasetVersion> for DatasetVersionSummary {
fn from(version: &'a DatasetVersion) -> Self {
DatasetVersionSummary {
date: version.date,
number_of_quads: version.number_of_quads(),
fn get_dataset<'a>(datasets: &'a [Dataset], id: &str) -> Result<&'a Dataset, MyError> {
if let Some(dataset) = datasets.iter().find(|d| d.id == id) {
Ok(dataset)
} else {
Err(MyError::NotFound(format!("No dataset with id {}", id)))
fn get_dataset_version<'a>(
datasets: &'a [Dataset],
id: &str,
) -> Result<(&'a Dataset, &'a DatasetVersion), MyError> {
let dataset = get_dataset(datasets, id)?;
if let Some(version) = dataset.versions.iter().find(|v| v.date == date) {
Ok((dataset, version))
Err(MyError::NotFound(format!(
"No dataset with id {} and version {}",
id, date
)))
async fn route_get_dataset(
State(state): State<SharedState>,
Path(id): Path<String>,
) -> Result<Html<String>, MyError> {
let dataset = get_dataset(&state.datasets, &id)?;
let summary = DatasetSummary::from(dataset);
context.insert("dataset", &summary);
let versions: Vec<_> = dataset
.versions
.iter()
.map(DatasetVersionSummary::from)
.collect();
context.insert("versions", &versions);
Ok(Html(state.tera.render("dataset.html", &context)?))
async fn route_get_dataset_version(
Path((id, version)): Path<(String, DateTime<Utc>)>,
let (dataset, version) = get_dataset_version(&state.datasets, &id, version)?;
let subjects = version.subjects();
let dataset = DatasetSummary::from(dataset);
let version = DatasetVersionSummary::from(version);
context.insert("dataset", &dataset);
context.insert("version", &version);
context.insert("subjects", &subjects);
Ok(Html(state.tera.render("version.html", &context)?))
async fn route_get_dataset_version_subject(
Path((id, version, subject)): Path<(String, DateTime<Utc>, String)>,
let pos = version.pos(&subject);
context.insert("subject", &subject);
context.insert("pos", &pos);
Ok(Html(state.tera.render("subject.html", &context)?))
async fn route_get_crawl(State(state): State<SharedState>) -> Result<Html<String>, MyError> {
let dataset_configs: Vec<_>;
{
dataset_configs = state.config.datasets.clone();
fetch_all(dataset_configs, &PathBuf::from("datasets")).await?;
Ok(Html("Ok".into()))
type SharedState = Arc<RwLock<AppState>>;
struct AppState {
config: ServerConfig,
datasets: Vec<Dataset>,
tera: Tera,
fn init_dataset(config: &ServerConfig) -> Result<(), Box<dyn Error>> {
let dir = PathBuf::from("datasets");
for c in &config.datasets {
std::fs::create_dir_all(dir.join(&c.name))?;
Ok(())
pub fn create_app<B: HttpBody + Send + 'static>(
) -> Result<axum::routing::IntoMakeService<Router<(), B>>, Box<dyn Error>>
where
<B as HttpBody>::Error: Sync + Send + std::error::Error,
<B as HttpBody>::Data: Send,
init_dataset(&config)?;
let tera = Tera::new("templates/**/[a-zA-Z0-9]*")?;
let datasets = load_datasets("datasets")?;
let shared_state = Arc::new(RwLock::new(AppState {
datasets,
tera,
config,
}));
Ok(Router::new()
.route("/", get(route_get_index))
.route("/dataset/", get(route_get_index))
.route("/dataset/:id", get(route_get_dataset))
.route("/dataset/:id/:version", get(route_get_dataset_version))
.route(
"/dataset/:id/:version/:subject",
get(route_get_dataset_version_subject),
)
.route("/crawl", get(route_get_crawl))
.with_state(Arc::clone(&shared_state))
.into_make_service())
#[cfg(test)]
mod test {
use axum_test::TestServer;
use crate::server_config::ServerConfig;
#[tokio::test]
async fn create_server() {
let my_app = super::create_app(ServerConfig { datasets: vec![] }).unwrap();
let server = TestServer::new(my_app).unwrap();
let response = server.get("/").await;
assert_eq!(response.status_code(), 200);