135 lines
3.6 KiB
Rust
135 lines
3.6 KiB
Rust
#[macro_use]
|
|
extern crate log;
|
|
|
|
use crate::feed_store::FeedStore;
|
|
use crate::fetcher::Fetcher;
|
|
use anyhow::Result;
|
|
use clap::Parser;
|
|
use serde::Deserialize;
|
|
use simple_entry::SimpleEntry;
|
|
use std::fs;
|
|
use std::path::PathBuf;
|
|
use url::Url;
|
|
|
|
mod feed_store;
|
|
mod fetcher;
|
|
mod simple_entry;
|
|
|
|
#[derive(Parser)]
|
|
#[command(author, version, about, long_about = None)]
|
|
struct Args {
|
|
#[arg(
|
|
short,
|
|
long,
|
|
default_value_t = String::from("mars.toml")
|
|
)]
|
|
config: String,
|
|
#[arg(long, default_value_t = false)]
|
|
no_fetch: bool,
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct Config {
|
|
/// to be used as part of the fetchers username header
|
|
bot_name: String,
|
|
/// where to store downloaded feeds and their metadata
|
|
feed_dir: String,
|
|
/// feeds to be agregated
|
|
feeds: Vec<FeedConfig>,
|
|
/// Email adress to use for the from header when fetching feeds
|
|
from: String,
|
|
/// where to build the output files
|
|
out_dir: String,
|
|
/// templates folder
|
|
templates_dir: String,
|
|
}
|
|
|
|
pub fn to_checked_pathbuf(dir: &str) -> PathBuf {
|
|
let dir: PathBuf = PathBuf::from(dir);
|
|
|
|
let m = dir
|
|
.metadata()
|
|
.unwrap_or_else(|_| panic!("Could not get metadata of dir: {}", dir.display()));
|
|
assert!(m.is_dir(), "Not a dir: {}", dir.display());
|
|
dir
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
struct FeedConfig {
|
|
url: String,
|
|
}
|
|
|
|
fn fetch(config: &Config, feed_store: &FeedStore) -> Result<bool> {
|
|
let fetcher = Fetcher::new(&config.bot_name, &config.from);
|
|
let mut rebuild = false;
|
|
for feed in &config.feeds {
|
|
let url = match Url::parse(&feed.url) {
|
|
Ok(x) => x,
|
|
Err(e) => {
|
|
error!("Error parsing url '{}': {e:?}", feed.url);
|
|
continue;
|
|
}
|
|
};
|
|
rebuild |= fetcher.fetch(url, feed_store);
|
|
}
|
|
info!("Done fetching. Rebuild needed: {rebuild}");
|
|
Ok(rebuild)
|
|
}
|
|
|
|
fn build(config: &Config, feed_store: &FeedStore) -> Result<()> {
|
|
let templates_dir = to_checked_pathbuf(&config.templates_dir);
|
|
let out_dir = to_checked_pathbuf(&config.out_dir);
|
|
|
|
let mut tera = match tera::Tera::new(&format!("{}/*", &templates_dir.display())) {
|
|
Ok(t) => t,
|
|
Err(e) => {
|
|
println!("Parsing error(s): {}", e);
|
|
::std::process::exit(1);
|
|
}
|
|
};
|
|
// disable autoescape as this would corrupt urls or the entriy contents. todo check this!
|
|
tera.autoescape_on(vec![]);
|
|
|
|
let mut context = tera::Context::new();
|
|
let entries: Vec<SimpleEntry> = feed_store
|
|
.collect(&config.feeds)
|
|
.into_iter()
|
|
.map(SimpleEntry::from_feed_entry)
|
|
.collect();
|
|
context.insert("entries", &entries);
|
|
|
|
for name in tera.get_template_names() {
|
|
debug!("Processing template {name}");
|
|
let file = fs::File::create(format!("{}/{name}", out_dir.display()))?;
|
|
tera.render_to(name, &context, file)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
env_logger::init();
|
|
info!("starting up");
|
|
|
|
let args = Args::parse();
|
|
let config_path = &args.config;
|
|
if !fs::exists(config_path)? {
|
|
panic!("Configuration file {config_path} does not exist!");
|
|
}
|
|
let config: Config = toml::from_str(&fs::read_to_string(config_path)?)?;
|
|
// only check here to avoid fetching with broken config
|
|
// todo: get a config lib that provides validation!
|
|
let _ = to_checked_pathbuf(&config.templates_dir);
|
|
let _ = to_checked_pathbuf(&config.out_dir);
|
|
|
|
let feed_store = FeedStore::new(&config.feed_dir);
|
|
let should_build = if args.no_fetch {
|
|
true
|
|
} else {
|
|
fetch(&config, &feed_store)?
|
|
};
|
|
|
|
if should_build {
|
|
build(&config, &feed_store)?;
|
|
}
|
|
Ok(())
|
|
}
|