initial commit

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "shana-fetcher"
+version = "1.0.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+clap = { version = "~4.5", features = ["derive"] }
+rss = { version = "~2.0", default-features = false }
+slog = "~2.7"
+slog-async = "~2.8"
+slog-scope = "~4.4"
+slog-scope-futures = "~0.1"
+slog-stdlog = "~4.1"
+slog-term = "~2.9"
+tokio = { version = "~1.37", features = ["rt", "macros", "rt-multi-thread"] }
+transmission-rpc = "~0.4"
+ureq = "~2.9"
+xdg = "~2.5"

src/main.rs

@@ -0,0 +1,153 @@
+#[macro_use]
+extern crate slog;
+extern crate slog_async;
+extern crate slog_scope;
+extern crate slog_scope_futures;
+extern crate slog_stdlog;
+extern crate slog_term;
+
+use clap::Parser;
+use slog::{Drain, Logger};
+use slog_scope_futures::FutureExt;
+use transmission_rpc::types::{BasicAuth, TorrentAddArgs};
+use transmission_rpc::TransClient;
+
+use std::io::BufReader;
+use std::path::{Path, PathBuf};
+
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+struct Cli {
+    #[arg(short, long, default_value = "localhost:9091")]
+    rpc_url: String,
+
+    /// url to fetch feed from
+    #[arg(short, long)]
+    feed_url: String,
+
+    /// path to load feed from
+    #[arg(long)]
+    feed_file: Option<PathBuf>,
+
+    #[arg(long, default_value = "")]
+    user: String,
+
+    #[arg(long, default_value = "")]
+    password: String,
+
+    /// dump feed to stdout instead
+    #[arg(long)]
+    dump: bool,
+}
+
+fn setup_logger() -> slog::Logger {
+    let decorator = slog_term::TermDecorator::new().stderr().build();
+    let drain = slog_term::CompactFormat::new(decorator).build().fuse();
+    let drain = slog::LevelFilter(drain, slog::Level::Debug).fuse();
+    let drain = slog_async::Async::new(drain).build().fuse();
+
+    slog::Logger::root(drain, o!())
+}
+
+async fn add_torrent(
+    log: &Logger,
+    rpc_url: &str,
+    torrent_url: &str,
+    user: &str,
+    password: &str,
+) -> Result<(), String> {
+    let auth = BasicAuth {
+        user: user.to_string(),
+        password: password.to_string(),
+    };
+    let mut client = TransClient::with_auth(rpc_url.parse().unwrap(), auth);
+
+    let add = TorrentAddArgs {
+        filename: Some(torrent_url.into()),
+        ..TorrentAddArgs::default()
+    };
+
+    match client.torrent_add(add).with_logger(log).await {
+        Ok(_) => Ok(()),
+        Err(err) => Err((*err).to_string()),
+    }
+}
+
+fn fetch_feed_from_url(log: &Logger, feed_url: &str) -> Result<rss::Channel, String> {
+    info!(log, "fetching {feed_url}");
+    let resp = match ureq::get(feed_url).call() {
+        Ok(resp) => resp,
+        Err(e) => return Err(e.to_string()),
+    };
+    info!(log, "fetch ok");
+
+    info!(log, "parsing feed");
+    let resp_reader = BufReader::new(resp.into_reader());
+    let channel = rss::Channel::read_from(resp_reader).expect("valid stream");
+    info!(log, "parsing ok");
+
+    Ok(channel)
+}
+
+fn load_feed_from_disk(_: &Logger, file_path: &Path) -> Result<rss::Channel, String> {
+    let Ok(file) = std::fs::File::open(file_path) else {
+        return Err("error opening file".to_string());
+    };
+
+    let feed = match rss::Channel::read_from(BufReader::new(file)) {
+        Ok(feed) => feed,
+        Err(e) => return Err(e.to_string()),
+    };
+
+    Ok(feed)
+}
+
+async fn add_torrents<T>(log: &Logger, args: &Cli, torrents: T)
+where
+    T: IntoIterator<Item = rss::Item>,
+{
+    // TODO replace ureq with reqwest as transmission-rpc depends on it anyway
+    for e in torrents.into_iter() {
+        let title = e.title().unwrap_or("<no title>").to_string();
+        let log = log.new(o!("title" => title));
+
+        info!(log, "new entry");
+
+        if let Some(url) = e.link() {
+            info!(log, "adding entry");
+            if let Err(e) = add_torrent(&log, &args.rpc_url, url, &args.user, &args.password).await
+            {
+                error!(log, "error adding torrent: {e}");
+            }
+        } else {
+            error!(log, "no url included, skipping");
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), String> {
+    let log = setup_logger();
+    slog_stdlog::init().map_err(|e| e.to_string())?;
+
+    let args = Cli::parse();
+
+    let feed = if let Some(filepath) = &args.feed_file {
+        load_feed_from_disk(&log, filepath.as_path())?
+    } else {
+        fetch_feed_from_url(&log, &args.feed_url)?
+    };
+
+    info!(log, "received {} new torrents", feed.items().len());
+
+    if args.dump {
+        feed.write_to(std::io::stdout()).map_err(|e| e.to_string())?;
+    } else {
+        let torrents = feed.into_items().into_iter().rev();
+        add_torrents(&log, &args, torrents).await;
+    }
+
+    info!(log, "done");
+
+    Ok(())
+}