use std::collections::BTreeSet;
use futures_util::{StreamExt, TryStreamExt, stream};
use crate::adapters::files::constants::{LOADED_FOLDER, LOADED_SUFFIX, RECORD_READS};
use crate::adapters::files::errors::FilesDestinationError;
use crate::file_store::main::list_files::list_files;
use crate::file_store::main::read_file::read_file;
use crate::file_store::models::OpenFolder;
use crate::files_source::models::LoadedFile;
use crate::store_paths::models::Location;
pub(crate) fn loaded_key(file_id: &str) -> String {
format!("{LOADED_FOLDER}{file_id}{LOADED_SUFFIX}")
}
pub(crate) fn loaded_folder(folder: &OpenFolder) -> OpenFolder {
OpenFolder {
store: folder.store.clone(),
location: Location {
store: folder.location.store.clone(),
prefix: format!("{}{LOADED_FOLDER}", folder.location.prefix),
},
}
}
pub(crate) fn record_commit(name: &str) -> Option<&str> {
name.strip_suffix(LOADED_SUFFIX)
.filter(|commit| !commit.is_empty() && !commit.contains('/'))
}
pub(crate) fn loaded_text(files: &[LoadedFile]) -> Result<String, String> {
let rows: Vec<[&str; 2]> = files
.iter()
.map(|file| [file.name.as_str(), file.version.as_str()])
.collect();
serde_json::to_string(&rows).map_err(|error| error.to_string())
}
pub(crate) fn parse_loaded(text: &str) -> Result<Vec<LoadedFile>, String> {
let rows: Vec<[String; 2]> = serde_json::from_str(text).map_err(|error| error.to_string())?;
Ok(rows
.into_iter()
.map(|[name, version]| LoadedFile { name, version })
.collect())
}
pub(crate) async fn loaded_records(
folder: &OpenFolder,
commits: &BTreeSet<String>,
) -> Result<(Vec<LoadedFile>, Vec<String>), FilesDestinationError> {
let records = loaded_folder(folder);
let mut live: Vec<String> = Vec::new();
let mut stale: Vec<String> = Vec::new();
for file in list_files(&records).await? {
match record_commit(&file.relative_key).map(|commit| commits.contains(commit)) {
Some(true) => live.push(file.relative_key),
Some(false) => stale.push(format!("{LOADED_FOLDER}{}", file.relative_key)),
None => {}
}
}
let read = stream::iter(live.iter())
.map(|key| read_record(&records, key))
.buffer_unordered(RECORD_READS)
.try_collect::<Vec<Vec<LoadedFile>>>()
.await?;
Ok((read.into_iter().flatten().collect(), stale))
}
async fn read_record(
records: &OpenFolder,
key: &str,
) -> Result<Vec<LoadedFile>, FilesDestinationError> {
let text = read_file(records, key).await?;
parse_loaded(&String::from_utf8_lossy(&text)).map_err(|reason| FilesDestinationError::Write {
key: format!("{}{key}", records.location),
reason,
})
}