use std::time::{Duration, Instant};
pub const UT_METADATA_REQUEST_TIMEOUT: Duration = Duration::from_secs(20);
pub const MAX_OUTSTANDING_REQUESTS: usize = 1;
#[derive(Debug)]
struct RequestEntry {
index: u32,
dispatched_at: Instant,
}
impl RequestEntry {
fn new(index: u32) -> Self {
Self {
index,
dispatched_at: Instant::now(),
}
}
fn is_timed_out(&self, timeout: Duration) -> bool {
self.dispatched_at.elapsed() >= timeout
}
}
impl PartialEq for RequestEntry {
fn eq(&self, other: &Self) -> bool {
self.index == other.index
}
}
#[derive(Debug)]
pub struct UTMetadataRequestTracker {
tracked: Vec<RequestEntry>,
timeout: Duration,
}
impl UTMetadataRequestTracker {
pub fn new() -> Self {
Self {
tracked: Vec::new(),
timeout: UT_METADATA_REQUEST_TIMEOUT,
}
}
pub fn with_timeout(timeout: Duration) -> Self {
Self {
tracked: Vec::new(),
timeout,
}
}
pub fn add(&mut self, index: u32) {
self.tracked.push(RequestEntry::new(index));
}
pub fn tracks(&self, index: u32) -> bool {
self.tracked.iter().any(|e| e.index == index)
}
pub fn remove(&mut self, index: u32) {
self.tracked.retain(|e| e.index != index);
}
pub fn all_tracked_indices(&self) -> Vec<u32> {
self.tracked.iter().map(|e| e.index).collect()
}
pub fn remove_timeout_entries(&mut self) -> Vec<u32> {
let mut timed_out = Vec::new();
self.tracked.retain(|e| {
if e.is_timed_out(self.timeout) {
tracing::debug!(index = e.index, "ut_metadata request timed out");
timed_out.push(e.index);
false
} else {
true
}
});
timed_out
}
pub fn count(&self) -> usize {
self.tracked.len()
}
pub fn avail(&self) -> usize {
MAX_OUTSTANDING_REQUESTS.saturating_sub(self.tracked.len())
}
pub fn request_piece(&mut self, index: u32) -> bool {
if self.avail() > 0 {
self.add(index);
true
} else {
false
}
}
pub fn has_timeouts(&self) -> bool {
self.tracked.iter().any(|e| e.is_timed_out(self.timeout))
}
}
impl Default for UTMetadataRequestTracker {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_new_tracker_is_empty() {
let tracker = UTMetadataRequestTracker::new();
assert_eq!(tracker.count(), 0);
assert_eq!(tracker.avail(), MAX_OUTSTANDING_REQUESTS);
assert!(!tracker.tracks(0));
assert!(tracker.all_tracked_indices().is_empty());
}
#[test]
fn test_add_and_tracks() {
let mut tracker = UTMetadataRequestTracker::new();
tracker.add(0);
assert!(tracker.tracks(0));
assert_eq!(tracker.count(), 1);
assert!(!tracker.tracks(1));
}
#[test]
fn test_remove() {
let mut tracker = UTMetadataRequestTracker::new();
tracker.add(0);
tracker.add(1);
assert_eq!(tracker.count(), 2);
tracker.remove(0);
assert!(!tracker.tracks(0));
assert!(tracker.tracks(1));
assert_eq!(tracker.count(), 1);
}
#[test]
fn test_remove_nonexistent() {
let mut tracker = UTMetadataRequestTracker::new();
tracker.add(0);
tracker.remove(99); assert_eq!(tracker.count(), 1);
}
#[test]
fn test_avail_limits() {
let mut tracker = UTMetadataRequestTracker::new();
assert_eq!(tracker.avail(), 1);
tracker.add(0);
assert_eq!(tracker.avail(), 0);
tracker.add(1);
assert_eq!(tracker.avail(), 0); }
#[test]
fn test_request_piece() {
let mut tracker = UTMetadataRequestTracker::new();
assert!(tracker.request_piece(0));
assert!(!tracker.request_piece(1)); assert!(tracker.tracks(0));
assert!(!tracker.tracks(1));
}
#[test]
fn test_all_tracked_indices() {
let mut tracker = UTMetadataRequestTracker::new();
tracker.add(2);
tracker.add(5);
let indices = tracker.all_tracked_indices();
assert!(indices.contains(&2));
assert!(indices.contains(&5));
}
#[test]
fn test_timeout_with_custom_duration() {
let mut tracker = UTMetadataRequestTracker::with_timeout(Duration::from_millis(1));
tracker.add(0);
assert!(!tracker.has_timeouts());
std::thread::sleep(Duration::from_millis(5));
assert!(tracker.has_timeouts());
let timed_out = tracker.remove_timeout_entries();
assert_eq!(timed_out, vec![0]);
assert_eq!(tracker.count(), 0);
}
#[test]
fn test_remove_timeout_preserves_not_timed_out() {
let mut tracker = UTMetadataRequestTracker::with_timeout(Duration::from_millis(1));
tracker.add(0);
std::thread::sleep(Duration::from_millis(5));
tracker.add(1);
let timed_out = tracker.remove_timeout_entries();
assert_eq!(timed_out, vec![0]);
assert!(tracker.tracks(1));
assert_eq!(tracker.count(), 1);
}
#[test]
fn test_default_trait() {
let tracker = UTMetadataRequestTracker::default();
assert_eq!(tracker.count(), 0);
}
}