use std::collections::HashMap;
use super::MAX_BLOCKS;
use crate::buildcache::Upload;
#[derive(Debug)]
pub(in crate::buildcache) struct Save {
key: String,
version: String,
max_size: u64,
state: SaveState,
}
#[derive(Debug)]
enum SaveState {
Receiving {
blocks: HashMap<String, Upload>,
archive: Option<Upload>,
},
Finalized { archive: Upload },
Dropped,
}
pub(super) enum Part {
Block(String),
Archive,
}
pub(super) enum Finished {
Archived,
WrongSize,
Nothing,
}
impl Save {
pub(super) fn new(key: String, version: String, max_size: u64) -> Save {
Save {
key,
version,
max_size,
state: SaveState::Receiving {
blocks: HashMap::new(),
archive: None,
},
}
}
pub(super) fn key(&self) -> &str {
&self.key
}
pub(super) fn version(&self) -> &str {
&self.version
}
pub(super) fn max_size(&self) -> u64 {
self.max_size
}
pub(super) fn is_open(&self) -> bool {
matches!(self.state, SaveState::Receiving { .. })
}
pub(super) fn is_dropped(&self) -> bool {
matches!(self.state, SaveState::Dropped)
}
pub(super) fn is_finalized(&self) -> bool {
matches!(self.state, SaveState::Finalized { .. })
}
pub(super) fn answers_finalize(&self, key: &str, version: &str) -> bool {
self.key == key
&& self.version == version
&& match &self.state {
SaveState::Receiving { archive, .. } => archive.is_some(),
SaveState::Finalized { .. } => false,
SaveState::Dropped => true,
}
}
pub(super) fn finalize(&mut self, size: Option<u64>, gone: &mut Vec<Upload>) -> Finished {
match std::mem::replace(&mut self.state, SaveState::Dropped) {
SaveState::Receiving { blocks, archive } => {
gone.extend(blocks.into_values());
match archive {
Some(archive) if size.is_none_or(|size| size == archive.bytes) => {
self.state = SaveState::Finalized { archive };
Finished::Archived
}
Some(archive) => {
gone.push(archive);
Finished::WrongSize
}
None => Finished::Nothing,
}
}
other => {
self.state = other;
Finished::Nothing
}
}
}
pub(super) fn keep(&mut self, received: Option<Upload>, part: Part, gone: &mut Vec<Upload>) {
let SaveState::Receiving { blocks, archive } = &mut self.state else {
gone.extend(received);
return;
};
match (received, part) {
(Some(upload), Part::Block(block)) if fits(blocks, &upload, &block, self.max_size) => {
gone.extend(blocks.insert(block, upload));
}
(Some(upload), Part::Archive) => gone.extend(archive.replace(upload)),
(received, _) => {
gone.extend(received);
self.drop_uploads(gone);
}
}
}
pub(super) fn take_blocks(&mut self) -> HashMap<String, Upload> {
match &mut self.state {
SaveState::Receiving { blocks, .. } => std::mem::take(blocks),
SaveState::Finalized { .. } | SaveState::Dropped => HashMap::new(),
}
}
pub(super) fn drop_uploads(&mut self, gone: &mut Vec<Upload>) {
gone.extend(std::mem::replace(&mut self.state, SaveState::Dropped).into_uploads());
}
pub(super) fn into_archive(self) -> Option<Upload> {
match self.state {
SaveState::Finalized { archive } => Some(archive),
SaveState::Receiving { .. } | SaveState::Dropped => None,
}
}
pub(in crate::buildcache) fn into_uploads(self) -> Vec<Upload> {
self.state.into_uploads()
}
}
impl SaveState {
fn into_uploads(self) -> Vec<Upload> {
match self {
SaveState::Receiving { blocks, archive } => {
blocks.into_values().chain(archive).collect()
}
SaveState::Finalized { archive } => vec![archive],
SaveState::Dropped => Vec::new(),
}
}
}
fn fits(blocks: &HashMap<String, Upload>, upload: &Upload, block: &str, max_size: u64) -> bool {
let others: u64 = blocks
.iter()
.filter(|(id, _)| id.as_str() != block)
.map(|(_, upload)| upload.bytes)
.sum();
(blocks.len() < MAX_BLOCKS || blocks.contains_key(block))
&& others + upload.bytes <= max_size / 4
}