use super::ConcurrentSegmentManager;
use super::types::SegmentStatus;
impl ConcurrentSegmentManager {
pub fn complete_segment(&mut self, index: u32, len: usize) -> bool {
if let Some(seg) = self.segments.get_mut(index as usize) {
if seg.status == SegmentStatus::Done || len as u64 != seg.length {
return false;
}
seg.status = SegmentStatus::Done;
if let Some(mi) = seg.assigned_mirror
&& let Some(m) = self.mirrors.get_mut(mi)
{
m.active_segments = m.active_segments.saturating_sub(1);
m.consecutive_failures = 0;
}
self.completed_bytes += seg.length;
true
} else {
false
}
}
pub fn fail_segment(&mut self, index: u32) -> Option<usize> {
let (prev_mirror, new_retry) = {
let seg = self.segments.get(index as usize)?;
(seg.assigned_mirror, seg.retry_count + 1)
};
if let Some(mi) = prev_mirror
&& let Some(m) = self.mirrors.get_mut(mi)
{
m.active_segments = m.active_segments.saturating_sub(1);
m.consecutive_failures += 1;
if m.consecutive_failures >= self.max_mirror_failures {
m.disabled = true;
}
}
if self.max_retries_per_segment != 0 && new_retry >= self.max_retries_per_segment {
if let Some(seg) = self.segments.get_mut(index as usize) {
seg.status = SegmentStatus::Failed;
seg.retry_count = new_retry;
}
None
} else {
let reassign = self.find_available_mirror_for_reassignment(prev_mirror.unwrap_or(0));
if let Some(seg) = self.segments.get_mut(index as usize) {
seg.status = SegmentStatus::Pending;
seg.assigned_mirror = reassign;
seg.retry_count = new_retry;
}
reassign
}
}
fn find_available_mirror_for_reassignment(&self, exclude: usize) -> Option<usize> {
self.mirrors
.iter()
.enumerate()
.filter(|(i, m)| *i != exclude && m.is_available())
.map(|(i, _)| i)
.next()
}
}