141 lines
3.8 KiB
Rust
141 lines
3.8 KiB
Rust
use std::{
|
|
collections::VecDeque,
|
|
fs,
|
|
io::{self, Write},
|
|
path::{Path, PathBuf},
|
|
};
|
|
|
|
use log::{debug, trace};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use super::{
|
|
cli::Cli,
|
|
sharry::{Alias, ChunkState, FileChecked, FileUploading, Share, UploadError},
|
|
};
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
pub struct AppState {
|
|
#[serde(skip)]
|
|
file_name: PathBuf,
|
|
|
|
alias: Alias,
|
|
share: Share,
|
|
files: VecDeque<FileState>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
enum FileState {
|
|
C(FileChecked),
|
|
U(FileUploading),
|
|
}
|
|
|
|
impl AppState {
|
|
fn cache_dir() -> PathBuf {
|
|
let dir_name = dirs_next::cache_dir()
|
|
.expect("could not determine cache directory")
|
|
.join("shrupl");
|
|
|
|
trace!("cachedir: {:?}", dir_name.display());
|
|
dir_name
|
|
}
|
|
|
|
fn cache_file(args: &Cli) -> PathBuf {
|
|
let file_name = Self::cache_dir().join(format!("{}.json", args.get_hash()));
|
|
|
|
trace!("cachefile: {:?}", file_name.display());
|
|
file_name
|
|
}
|
|
|
|
fn load(file_name: impl AsRef<Path>) -> io::Result<Self> {
|
|
let content = fs::read_to_string(file_name)?;
|
|
serde_json::from_str(&content).map_err(io::Error::other)
|
|
}
|
|
|
|
pub fn try_resume(args: &Cli) -> Option<Self> {
|
|
let file_name = Self::cache_file(args);
|
|
|
|
Self::load(&file_name)
|
|
.inspect_err(|e| debug!("could not resume from {:?}: {e}", file_name.display()))
|
|
.map(|state| {
|
|
debug!("successfully loaded AppState");
|
|
|
|
Self {
|
|
file_name,
|
|
alias: state.alias,
|
|
share: state.share,
|
|
files: state.files,
|
|
}
|
|
})
|
|
.ok()
|
|
}
|
|
|
|
pub fn from_args(args: &Cli, http: &ureq::Agent) -> Result<Self, String> {
|
|
let file_name = Self::cache_file(args);
|
|
let alias = args.get_alias();
|
|
|
|
let share = Share::create(http, &alias, args.get_share_request())
|
|
.map_err(|e| format!("could not create share: {e}"))?;
|
|
|
|
let files: VecDeque<_> = args.files.clone().into_iter().map(FileState::C).collect();
|
|
|
|
Ok(Self {
|
|
file_name,
|
|
alias,
|
|
share,
|
|
files,
|
|
})
|
|
}
|
|
|
|
pub fn upload_chunk(
|
|
&mut self,
|
|
http: &ureq::Agent,
|
|
chunk_size: usize,
|
|
) -> Result<Option<()>, UploadError> {
|
|
let uploading = match self.files.pop_front() {
|
|
Some(FileState::C(checked)) => checked
|
|
.start_upload(http, &self.alias, &self.share)
|
|
.unwrap(),
|
|
Some(FileState::U(uploading)) => uploading,
|
|
None => {
|
|
self.share.notify(http, &self.alias).unwrap();
|
|
|
|
return Ok(None);
|
|
}
|
|
};
|
|
|
|
debug!("{uploading} chunk {chunk_size}");
|
|
|
|
match uploading.upload_chunk(http, &self.alias, chunk_size) {
|
|
ChunkState::Ok(upl) => {
|
|
self.files.push_front(FileState::U(upl));
|
|
Ok(Some(()))
|
|
}
|
|
ChunkState::Err(upl, e) => {
|
|
self.files.push_front(FileState::U(upl));
|
|
Err(e)
|
|
}
|
|
ChunkState::Finished(path) => {
|
|
debug!("Finished {:?}!", path.display());
|
|
Ok(Some(()))
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn save(&self) -> io::Result<()> {
|
|
fs::create_dir_all(Self::cache_dir())?;
|
|
|
|
let json = serde_json::to_string_pretty(self).map_err(io::Error::other)?;
|
|
let mut file = fs::File::create(&self.file_name)?;
|
|
file.write_all(json.as_bytes())?;
|
|
|
|
trace!("successfully saved AppState");
|
|
Ok(())
|
|
}
|
|
|
|
pub fn clear(self) -> io::Result<()> {
|
|
fs::remove_file(self.file_name)?;
|
|
|
|
trace!("successfully cleared AppState");
|
|
Ok(())
|
|
}
|
|
}
|