123 lines
3.2 KiB
Rust
123 lines
3.2 KiB
Rust
// use hammond_data::Episode;
|
|
use hammond_data::dbqueries;
|
|
use hammond_downloader::downloader::get_episode;
|
|
|
|
use std::collections::HashSet;
|
|
use std::sync::{Arc, Mutex};
|
|
// use std::path::PathBuf;
|
|
use std::thread;
|
|
|
|
// struct DonwloadInstance {
|
|
// uri: String,
|
|
// // FIXME: MAKE ME A PATHBUF
|
|
// local_uri: Option<String>,
|
|
// downloaded_bytes: u64,
|
|
// total_bytes: u64,
|
|
// }
|
|
|
|
// impl DonwloadInstance {
|
|
// fn new(url: &str, total_bytes: u64) -> Self {
|
|
// DonwloadInstance {
|
|
// uri: url.into(),
|
|
// local_uri: None,
|
|
// downloaded_bytes: 0,
|
|
// total_bytes,
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
#[derive(Debug, Clone)]
|
|
// FIXME: privacy stuff
|
|
pub struct Manager {
|
|
pub active: Arc<Mutex<HashSet<i32>>>,
|
|
}
|
|
|
|
impl Default for Manager {
|
|
fn default() -> Self {
|
|
Manager {
|
|
active: Arc::new(Mutex::new(HashSet::new())),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Manager {
|
|
pub fn new() -> Self {
|
|
Manager::default()
|
|
}
|
|
|
|
pub fn add(&self, id: i32, directory: &str) {
|
|
{
|
|
let mut m = self.active.lock().unwrap();
|
|
m.insert(id);
|
|
}
|
|
|
|
let dir = directory.to_owned();
|
|
let list = self.active.clone();
|
|
thread::spawn(move || {
|
|
let episode = dbqueries::get_episode_from_rowid(id).unwrap();
|
|
let e = get_episode(&mut episode.into(), dir.as_str());
|
|
if let Err(err) = e {
|
|
error!("Error: {}", err);
|
|
};
|
|
|
|
let mut m = list.lock().unwrap();
|
|
m.remove(&id);
|
|
});
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use hammond_downloader::downloader;
|
|
|
|
use diesel::Identifiable;
|
|
|
|
use hammond_data::database;
|
|
use hammond_data::feed::*;
|
|
use hammond_data::{Episode, Source};
|
|
use hammond_data::dbqueries;
|
|
|
|
use std::path::Path;
|
|
use std::{thread, time};
|
|
|
|
#[test]
|
|
// This test inserts an rss feed to your `XDG_DATA/hammond/hammond.db` so we make it explicit
|
|
// to run it.
|
|
#[ignore]
|
|
// THIS IS NOT A RELIABLE TEST
|
|
// Just quick sanity check
|
|
fn test_start_dl() {
|
|
let url = "http://www.newrustacean.com/feed.xml";
|
|
|
|
// Create and index a source
|
|
let source = Source::from_url(url).unwrap();
|
|
// Copy it's id
|
|
let sid = source.id().clone();
|
|
|
|
// Convert Source it into a Feed and index it
|
|
let feed = source.into_feed(true).unwrap();
|
|
index(&feed);
|
|
|
|
// Get the Podcast
|
|
let pd = dbqueries::get_podcast_from_source_id(sid).unwrap();
|
|
// Get an episode
|
|
let episode: Episode = {
|
|
let con = database::connection();
|
|
dbqueries::get_episode_from_pk(&*con.get().unwrap(), "e000: Hello, world!", *pd.id())
|
|
.unwrap()
|
|
};
|
|
|
|
let manager = Manager::new();
|
|
let download_fold = downloader::get_download_folder(&pd.title()).unwrap();
|
|
manager.add(episode.rowid(), download_fold.as_str());
|
|
|
|
// Give it soem time to download the file
|
|
thread::sleep(time::Duration::from_secs(20));
|
|
|
|
let final_path = format!("{}/{}.unknown", &download_fold, episode.rowid());
|
|
println!("{}", &final_path);
|
|
assert!(Path::new(&final_path).exists());
|
|
}
|
|
}
|