105 lines
2.9 KiB
Rust
105 lines
2.9 KiB
Rust
use std::{
|
|
io::{BufReader, BufWriter, Read, Write},
|
|
path::{Path, PathBuf},
|
|
};
|
|
|
|
use anyhow::{Error, Result};
|
|
use futures_util::{poll, StreamExt};
|
|
use kordophone::APIInterface;
|
|
use thiserror::Error;
|
|
use tokio::pin;
|
|
|
|
mod target {
|
|
pub static ATTACHMENTS: &str = "attachments";
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Attachment {
|
|
pub guid: String,
|
|
pub path: PathBuf,
|
|
pub downloaded: bool,
|
|
}
|
|
|
|
#[derive(Debug, Error)]
|
|
enum AttachmentStoreError {
|
|
#[error("attachment has already been downloaded")]
|
|
AttachmentAlreadyDownloaded,
|
|
|
|
#[error("Client error: {0}")]
|
|
APIClientError(String),
|
|
}
|
|
|
|
pub struct AttachmentStore {
|
|
store_path: PathBuf,
|
|
}
|
|
|
|
impl AttachmentStore {
|
|
pub fn new(data_dir: &PathBuf) -> AttachmentStore {
|
|
let store_path = data_dir.join("attachments");
|
|
log::info!(target: target::ATTACHMENTS, "Attachment store path: {}", store_path.display());
|
|
|
|
// Create the attachment store if it doesn't exist
|
|
std::fs::create_dir_all(&store_path)
|
|
.expect("Wasn't able to create the attachment store path");
|
|
|
|
AttachmentStore {
|
|
store_path: store_path,
|
|
}
|
|
}
|
|
|
|
pub fn get_attachment(&self, guid: &String) -> Attachment {
|
|
let path = self.store_path.join(guid);
|
|
let path_exists = std::fs::exists(&path).expect(
|
|
format!(
|
|
"Wasn't able to check for the existence of an attachment file path at {}",
|
|
&path.display()
|
|
)
|
|
.as_str(),
|
|
);
|
|
|
|
Attachment {
|
|
guid: guid.to_owned(),
|
|
path: path,
|
|
downloaded: path_exists,
|
|
}
|
|
}
|
|
|
|
pub async fn download_attachent<C, F>(
|
|
&mut self,
|
|
attachment: &Attachment,
|
|
mut client_factory: F,
|
|
) -> Result<()>
|
|
where
|
|
C: APIInterface,
|
|
F: AsyncFnMut() -> Result<C>,
|
|
{
|
|
if attachment.downloaded {
|
|
log::error!(target: target::ATTACHMENTS, "Attempted to download existing attachment.");
|
|
return Err(AttachmentStoreError::AttachmentAlreadyDownloaded.into());
|
|
}
|
|
|
|
// Create temporary file first, we'll atomically swap later.
|
|
assert!(!std::fs::exists(&attachment.path).unwrap());
|
|
let file = std::fs::File::create(&attachment.path)?;
|
|
let mut writer = BufWriter::new(&file);
|
|
|
|
log::trace!(target: target::ATTACHMENTS, "Created attachment file at {}", &attachment.path.display());
|
|
|
|
let mut client = (client_factory)().await?;
|
|
let stream = client
|
|
.fetch_attachment_data(&attachment.guid)
|
|
.await
|
|
.map_err(|e| AttachmentStoreError::APIClientError(format!("{:?}", e)))?;
|
|
|
|
// Since we're async, we need to pin this.
|
|
pin!(stream);
|
|
|
|
log::trace!(target: target::ATTACHMENTS, "Writing attachment data to disk");
|
|
while let Some(Ok(data)) = stream.next().await {
|
|
writer.write(data.as_ref())?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|