mod composite;
mod pending;
use crate::config::user_agent::OperationFeatures;
use crate::error;
use crate::scheduler::concurrency::ErrorKind;
use std::any::Any;
use std::fmt;
use std::future::Future;
use std::pin::Pin;
use std::sync::atomic::{AtomicBool, AtomicU64, AtomicU8, Ordering};
use std::sync::{Arc, Mutex};
use std::task::{Wake, Waker};
pub(crate) use composite::{CompositePendingReason, CompositeTransferSummary};
use pending::TransferPendingState;
pub(crate) use pending::{
emit_pending_details, PendingCategory, PendingCause, TransferPendingStats,
};
pub(crate) mod wake_flag {
use crate::runtime::sync::sync::atomic::{AtomicBool, Ordering};
pub(crate) struct WakeFlag {
pending: AtomicBool,
}
impl WakeFlag {
pub(crate) fn new() -> Self {
Self {
pending: AtomicBool::new(false),
}
}
pub(crate) fn set_pending(&self) {
self.pending.store(true, Ordering::Release);
}
pub(crate) fn take_pending(&self) -> bool {
self.pending.swap(false, Ordering::AcqRel)
}
}
}
pub(crate) trait Transfer: Send + Sync + std::fmt::Debug {
fn ctx(&self) -> &TransferContext;
fn poll_work(&self) -> PollWork;
fn execute<'a>(
&'a self,
work: &'a mut IoRequest,
) -> Pin<Box<dyn Future<Output = WorkOutcome> + Send + 'a>>;
fn on_terminal(&self) {}
}
pub(crate) type BoxTransfer = Box<dyn Transfer>;
pub(crate) trait WorkData: Any + Send + std::fmt::Debug {
fn as_any_mut(&mut self) -> &mut dyn Any;
}
impl<T: Any + Send + std::fmt::Debug> WorkData for T {
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct TransferId {
pub(crate) id: u64,
pub(crate) parent: Option<u64>,
}
impl std::fmt::Display for TransferId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self.parent {
Some(parent) => write!(f, "{}-{}", self.id, parent),
None => write!(f, "{}", self.id),
}
}
}
#[derive(Debug)]
pub(crate) struct IoRequest {
pub(crate) data: Option<Box<dyn WorkData>>,
}
impl IoRequest {
pub(crate) fn data_mut<T: 'static>(&mut self) -> &mut T {
(**self.data.as_mut().expect("work item has no data"))
.as_any_mut()
.downcast_mut::<T>()
.expect("work data type mismatch")
}
pub(crate) fn take_data<T: 'static>(&mut self) -> T {
let data: Box<dyn Any> = self.data.take().expect("work item has no data");
*data.downcast::<T>().expect("work data type mismatch")
}
}
#[derive(Debug)]
pub(crate) enum PollWork {
Ready { io: IoRequest, spawned: bool },
Spawned,
Pending,
Done,
}
impl PollWork {
pub(crate) fn ready(io: IoRequest) -> Self {
PollWork::Ready { io, spawned: false }
}
}
pub(crate) enum WorkOutcome {
Success { data: Option<Box<dyn WorkData>> },
Yielded,
Failed { classification: Option<ErrorKind> },
Cancelled,
}
impl std::fmt::Debug for WorkOutcome {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
WorkOutcome::Success { data } => f
.debug_struct("Success")
.field("has_data", &data.is_some())
.finish(),
WorkOutcome::Yielded => write!(f, "Yielded"),
WorkOutcome::Failed { classification } => f
.debug_struct("Failed")
.field("classification", classification)
.finish(),
WorkOutcome::Cancelled => write!(f, "Cancelled"),
}
}
}
static NEXT_TRANSFER_ID: AtomicU64 = AtomicU64::new(1);
pub(crate) fn next_transfer_id() -> TransferId {
TransferId {
id: NEXT_TRANSFER_ID.fetch_add(1, Ordering::Relaxed),
parent: None,
}
}
pub(crate) type StateMachineTerminalSender = tokio::sync::oneshot::Sender<()>;
pub(crate) type StateMachineTerminalReceiver = tokio::sync::oneshot::Receiver<()>;
#[derive(Clone)]
pub(crate) struct StateMachineStatus(Arc<AtomicU8>);
const STATUS_ACTIVE: u8 = 0;
const STATUS_COMPLETED: u8 = 1;
const STATUS_FAILED: u8 = 2;
const STATUS_CANCELLED: u8 = 3;
impl StateMachineStatus {
#[inline]
pub(crate) fn new() -> Self {
Self(Arc::new(AtomicU8::new(STATUS_ACTIVE)))
}
#[inline]
pub(crate) fn set_completed(&self) -> bool {
self.0
.compare_exchange(
STATUS_ACTIVE,
STATUS_COMPLETED,
Ordering::AcqRel,
Ordering::Acquire,
)
.is_ok()
}
#[inline]
pub(crate) fn set_failed(&self) -> bool {
self.0
.compare_exchange(
STATUS_ACTIVE,
STATUS_FAILED,
Ordering::AcqRel,
Ordering::Acquire,
)
.is_ok()
}
#[inline]
pub(crate) fn set_cancelled(&self) -> bool {
self.0
.compare_exchange(
STATUS_ACTIVE,
STATUS_CANCELLED,
Ordering::AcqRel,
Ordering::Acquire,
)
.is_ok()
}
#[inline]
pub(crate) fn is_active(&self) -> bool {
self.0.load(Ordering::Acquire) == STATUS_ACTIVE
}
#[inline]
pub(crate) fn is_completed(&self) -> bool {
self.0.load(Ordering::Acquire) == STATUS_COMPLETED
}
#[inline]
pub(crate) fn is_failed(&self) -> bool {
self.0.load(Ordering::Acquire) == STATUS_FAILED
}
#[inline]
pub(crate) fn is_cancelled(&self) -> bool {
self.0.load(Ordering::Acquire) == STATUS_CANCELLED
}
fn as_str(&self) -> &'static str {
match self.0.load(Ordering::Acquire) {
STATUS_ACTIVE => "Active",
STATUS_COMPLETED => "Completed",
STATUS_FAILED => "Failed",
STATUS_CANCELLED => "Cancelled",
_ => "Unknown",
}
}
}
impl fmt::Display for StateMachineStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl fmt::Debug for StateMachineStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("StateMachineStatus")
.field(&self.as_str())
.finish()
}
}
pub(crate) struct MetricsState {
network_tx: AtomicU64,
network_rx: AtomicU64,
disk_read: AtomicU64,
disk_write: AtomicU64,
total_bytes: std::sync::OnceLock<u64>,
started_at: std::time::Instant,
finished_at: std::sync::OnceLock<std::time::Instant>,
terminal_reported: AtomicBool,
request_metrics: crate::metrics::RequestMetricsState,
}
impl MetricsState {
pub(crate) fn new() -> Self {
Self {
network_tx: AtomicU64::new(0),
network_rx: AtomicU64::new(0),
disk_read: AtomicU64::new(0),
disk_write: AtomicU64::new(0),
total_bytes: std::sync::OnceLock::new(),
started_at: std::time::Instant::now(),
finished_at: std::sync::OnceLock::new(),
terminal_reported: AtomicBool::new(false),
request_metrics: crate::metrics::RequestMetricsState::default(),
}
}
pub(crate) fn record_io(&self, sample: &crate::metrics::IoSample) {
self.network_tx
.fetch_add(sample.network_tx, Ordering::Relaxed);
self.network_rx
.fetch_add(sample.network_rx, Ordering::Relaxed);
self.disk_read
.fetch_add(sample.disk_read, Ordering::Relaxed);
self.disk_write
.fetch_add(sample.disk_write, Ordering::Relaxed);
}
pub(crate) fn set_total_bytes(&self, n: u64) {
let _ = self.total_bytes.set(n);
}
pub(crate) fn set_finished(&self) {
let _ = self.finished_at.set(std::time::Instant::now());
}
pub(crate) fn claim_terminal_report(&self) -> bool {
!self.terminal_reported.swap(true, Ordering::AcqRel)
}
pub(crate) fn record_request(&self, metrics: &crate::metrics::RequestMetrics) {
self.request_metrics.record(metrics);
}
pub(crate) fn request_metrics(&self) -> crate::metrics::RequestMetrics {
self.request_metrics.snapshot()
}
pub(crate) fn snapshot(&self) -> crate::metrics::TransferMetrics {
crate::metrics::TransferMetrics {
network_tx: self.network_tx.load(Ordering::Relaxed),
network_rx: self.network_rx.load(Ordering::Relaxed),
disk_read: self.disk_read.load(Ordering::Relaxed),
disk_write: self.disk_write.load(Ordering::Relaxed),
total_bytes: self.total_bytes.get().copied(),
elapsed: self.elapsed(),
}
}
fn elapsed(&self) -> std::time::Duration {
match self.finished_at.get() {
Some(finished_at) => finished_at.saturating_duration_since(self.started_at),
None => self.started_at.elapsed(),
}
}
}
impl std::fmt::Debug for MetricsState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MetricsState")
.field("network_tx", &self.network_tx.load(Ordering::Relaxed))
.field("network_rx", &self.network_rx.load(Ordering::Relaxed))
.field("disk_read", &self.disk_read.load(Ordering::Relaxed))
.field("disk_write", &self.disk_write.load(Ordering::Relaxed))
.field("request_metrics", &self.request_metrics())
.finish()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum TerminalOutcome {
Completed,
Failed,
Cancelled,
}
impl TerminalOutcome {
pub(crate) fn from_status(status: crate::types::TransferStatus) -> Option<Self> {
use crate::types::TransferStatus;
match status {
TransferStatus::Completed => Some(Self::Completed),
TransferStatus::Failed => Some(Self::Failed),
TransferStatus::Cancelled => Some(Self::Cancelled),
TransferStatus::Active => None,
}
}
pub(crate) const fn as_str(self) -> &'static str {
match self {
Self::Completed => "completed",
Self::Failed => "failed",
Self::Cancelled => "cancelled",
}
}
}
#[derive(Clone)]
pub(crate) struct TransferContext {
pub(crate) id: TransferId,
pub(crate) handle: Arc<crate::client::Handle>,
status: StateMachineStatus,
error: Arc<Mutex<Option<Box<error::Error>>>>,
completion_tx: Arc<Mutex<Option<StateMachineTerminalSender>>>,
wake_flag: Arc<wake_flag::WakeFlag>,
pending_state: Option<Arc<TransferPendingState>>,
pub(crate) metrics: Arc<MetricsState>,
features: OperationFeatures,
}
#[derive(Debug)]
pub(crate) struct RequestMeasurement {
ctx: TransferContext,
accrued: std::time::Duration,
running_since: Option<tokio::time::Instant>,
metrics: crate::metrics::RequestMetrics,
published: bool,
}
impl RequestMeasurement {
fn new(ctx: TransferContext) -> Self {
Self {
ctx,
accrued: std::time::Duration::ZERO,
running_since: Some(tokio::time::Instant::now()),
metrics: crate::metrics::RequestMetrics::default(),
published: false,
}
}
pub(crate) fn metrics_mut(&mut self) -> &mut crate::metrics::RequestMetrics {
&mut self.metrics
}
pub(crate) fn pause(&mut self) {
if let Some(since) = self.running_since.take() {
self.accrued += since.elapsed();
}
}
pub(crate) fn resume(&mut self) {
if self.running_since.is_none() {
self.running_since = Some(tokio::time::Instant::now());
}
}
fn elapsed(&self) -> std::time::Duration {
self.accrued
+ self
.running_since
.map_or(std::time::Duration::ZERO, |s| s.elapsed())
}
pub(crate) fn finish(mut self) -> crate::metrics::RequestMetrics {
self.publish();
self.metrics
}
fn publish(&mut self) {
if self.published {
return;
}
self.metrics.record_request(self.elapsed());
self.ctx.record_request_metrics(&self.metrics);
self.published = true;
}
}
impl Drop for RequestMeasurement {
fn drop(&mut self) {
self.publish();
}
}
pub(crate) trait RequestMetricsAttribution: Clone {
type Kind: Copy + std::fmt::Debug;
fn record_request_metrics(&self, kind: Self::Kind, metrics: &crate::metrics::RequestMetrics);
}
pub(crate) struct AttributedRequestMeasurement<A: RequestMetricsAttribution> {
measurement: Option<RequestMeasurement>,
attribution: A,
kind: A::Kind,
}
impl<A: RequestMetricsAttribution> AttributedRequestMeasurement<A> {
pub(crate) fn new(ctx: &TransferContext, attribution: A, kind: A::Kind) -> Self {
Self {
measurement: Some(ctx.start_request_metrics()),
attribution,
kind,
}
}
pub(crate) fn metrics_mut(&mut self) -> &mut crate::metrics::RequestMetrics {
self.measurement
.as_mut()
.expect("request measurement already finished")
.metrics_mut()
}
pub(crate) fn pause(&mut self) {
self.measurement
.as_mut()
.expect("request measurement already finished")
.pause();
}
pub(crate) fn resume(&mut self) {
self.measurement
.as_mut()
.expect("request measurement already finished")
.resume();
}
pub(crate) fn finish(mut self) -> crate::metrics::RequestMetrics {
self.publish()
}
fn publish(&mut self) -> crate::metrics::RequestMetrics {
let measurement = self
.measurement
.take()
.expect("request measurement already finished");
let metrics = measurement.finish();
self.attribution.record_request_metrics(self.kind, &metrics);
metrics
}
}
impl<A: RequestMetricsAttribution> std::fmt::Debug for AttributedRequestMeasurement<A> {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("AttributedRequestMeasurement")
.field("kind", &self.kind)
.field("finished", &self.measurement.is_none())
.finish()
}
}
impl<A: RequestMetricsAttribution> Drop for AttributedRequestMeasurement<A> {
fn drop(&mut self) {
if self.measurement.is_some() {
let _ = self.publish();
}
}
}
struct SchedulerWake {
scheduler: crate::scheduler::Scheduler,
id: TransferId,
}
impl Wake for SchedulerWake {
fn wake(self: Arc<Self>) {
self.wake_by_ref();
}
fn wake_by_ref(self: &Arc<Self>) {
self.scheduler.wake(self.id);
}
}
impl fmt::Display for TransferContext {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Transfer(id={}, status={})", self.id.id, self.status)
}
}
impl fmt::Debug for TransferContext {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TransferContext")
.field("id", &self.id)
.field("status", &self.status)
.finish_non_exhaustive()
}
}
impl TransferContext {
pub(crate) fn new(handle: Arc<crate::client::Handle>) -> (Self, StateMachineTerminalReceiver) {
Self::new_inner(handle, next_transfer_id())
}
pub(crate) fn new_child(
handle: Arc<crate::client::Handle>,
parent_id: u64,
) -> (Self, StateMachineTerminalReceiver) {
let mut id = next_transfer_id();
id.parent = Some(parent_id);
Self::new_inner(handle, id)
}
fn new_inner(
handle: Arc<crate::client::Handle>,
id: TransferId,
) -> (Self, StateMachineTerminalReceiver) {
let (completion_tx, completion_rx) = tokio::sync::oneshot::channel();
let diagnostics = handle.config.diagnostics().transfer();
let pending_state = diagnostics
.enable_summaries()
.then(|| Arc::new(TransferPendingState::new(diagnostics.events_enabled())));
let ctx = Self {
id,
metrics: Arc::new(MetricsState::new()),
handle,
status: StateMachineStatus::new(),
error: Arc::new(Mutex::new(None)),
completion_tx: Arc::new(Mutex::new(Some(completion_tx))),
wake_flag: Arc::new(wake_flag::WakeFlag::new()),
pending_state,
features: OperationFeatures::default(),
};
(ctx, completion_rx)
}
pub(crate) fn with_features(mut self, features: OperationFeatures) -> Self {
self.features = features;
self
}
pub(crate) fn bucket_partition_override(
&self,
bucket: Option<&str>,
) -> aws_sdk_s3::config::Builder {
self.features
.apply(self.handle.bucket_partition_override(bucket))
}
pub(crate) fn download_get_override(
&self,
bucket: Option<&str>,
) -> aws_sdk_s3::config::Builder {
self.features
.apply(self.handle.download_get_override(bucket))
}
pub(crate) fn upload_override(&self, bucket: Option<&str>) -> aws_sdk_s3::config::Builder {
self.features.apply(self.handle.upload_override(bucket))
}
#[cfg(test)]
pub(crate) fn with_id(
id: TransferId,
handle: Arc<crate::client::Handle>,
) -> (Self, StateMachineTerminalReceiver) {
Self::new_inner(handle, id)
}
#[inline]
pub(crate) fn set_pending(&self, cause: impl Into<PendingCause>) {
let cause = cause.into();
self.wake_flag.set_pending();
if let Some(pending) = &self.pending_state {
pending.record_pending(self.id, cause);
}
tracing::trace!(
target: crate::telemetry::TARGET_SCHEDULING,
tid = %self.id,
category = cause.category.as_str(),
reason = cause.reason,
"ctx.set_pending",
);
}
#[inline]
pub(crate) fn try_wake(&self) {
if self.wake_flag.take_pending() {
tracing::trace!(
target: crate::telemetry::TARGET_SCHEDULING,
tid = %self.id,
"ctx.try_wake.fired",
);
self.wake();
} else {
tracing::trace!(
target: crate::telemetry::TARGET_SCHEDULING,
tid = %self.id,
"ctx.try_wake.skipped",
);
}
}
#[inline]
pub(crate) fn wake(&self) {
self.handle.scheduler.wake(self.id);
}
pub(crate) fn waker(&self) -> Waker {
Waker::from(Arc::new(SchedulerWake {
scheduler: self.handle.scheduler.clone(),
id: self.id,
}))
}
pub(crate) fn begin_poll(&self) {
self.wake_flag.take_pending();
if let Some(pending) = &self.pending_state {
pending.record_poll_started(self.id);
}
}
pub(crate) fn record_wake(&self) {
if let Some(pending) = &self.pending_state {
pending.record_wake(self.id);
}
}
pub(crate) fn pending_stats(&self) -> Option<TransferPendingStats> {
self.pending_state
.as_ref()
.map(|pending| pending.snapshot())
}
pub(crate) fn s3_client(&self) -> &aws_sdk_s3::Client {
&self.handle.s3_client
}
pub(crate) fn set_failed(&self, err: impl Into<error::Error>) -> bool {
if self.status.set_failed() {
*self.error.lock().unwrap() = Some(Box::new(err.into()));
true
} else {
false
}
}
#[inline]
pub(crate) fn set_completed(&self) -> bool {
self.status.set_completed()
}
#[inline]
pub(crate) fn set_cancelled(&self) -> bool {
self.status.set_cancelled()
}
pub(crate) fn take_error(&self) -> Option<error::Error> {
if self.status.is_failed() {
self.error.lock().unwrap().take().map(|e| *e)
} else {
None
}
}
pub(crate) fn amend_error(&self, f: impl FnOnce(error::Error) -> error::Error) {
let mut stored = self.error.lock().unwrap();
*stored = stored.take().map(|err| Box::new(f(*err)));
}
pub(crate) fn error_kind(&self) -> Option<error::ErrorKind> {
if self.status.is_failed() {
self.error
.lock()
.unwrap()
.as_ref()
.map(|e| e.kind().clone())
} else {
None
}
}
#[inline]
pub(crate) fn is_failed(&self) -> bool {
self.status.is_failed()
}
#[inline]
pub(crate) fn is_cancelled(&self) -> bool {
self.status.is_cancelled()
}
#[inline]
pub(crate) fn is_active(&self) -> bool {
self.status.is_active()
}
#[inline]
pub(crate) fn is_completed(&self) -> bool {
self.status.is_completed()
}
pub(crate) fn signal_terminal(&self) {
self.finalize_terminal_metrics();
if let Some(tx) = self.completion_tx.lock().unwrap().take() {
let _ = tx.send(());
}
if let Some(parent_id) = self.id.parent {
self.handle.scheduler.wake(TransferId {
id: parent_id,
parent: None,
});
}
}
pub(crate) fn finalize_terminal_metrics(&self) {
if let Some(pending) = &self.pending_state {
pending.record_terminal(self.id);
}
self.wake_flag.take_pending();
self.metrics.set_finished();
}
pub(crate) fn record_io(&self, sample: &crate::metrics::IoSample) {
self.metrics.record_io(sample);
self.handle.telemetry.io_counters.record(sample);
}
pub(crate) fn record_request_metrics(&self, metrics: &crate::metrics::RequestMetrics) {
self.metrics.record_request(metrics);
}
pub(crate) fn start_request_metrics(&self) -> RequestMeasurement {
RequestMeasurement::new(self.clone())
}
pub(crate) fn set_total_bytes(&self, n: u64) {
self.metrics.set_total_bytes(n);
}
pub(crate) fn transfer_status(&self) -> crate::types::TransferStatus {
use crate::types::TransferStatus;
if self.status.is_cancelled() {
TransferStatus::Cancelled
} else if self.is_failed() {
TransferStatus::Failed
} else if !self.is_active() {
TransferStatus::Completed
} else {
TransferStatus::Active
}
}
pub(crate) fn claim_terminal_report(&self) -> bool {
self.metrics.claim_terminal_report()
}
pub(crate) fn metrics(&self) -> crate::metrics::TransferMetrics {
self.metrics.snapshot()
}
pub(crate) fn scheduling(&self) -> SchedulingCtl<'_> {
SchedulingCtl { ctx: self }
}
}
#[derive(Debug)]
pub struct SchedulingCtl<'a> {
ctx: &'a TransferContext,
}
impl SchedulingCtl<'_> {
pub fn set_priority(&self, priority: u8) {
self.ctx
.handle
.scheduler
.set_priority(self.ctx.id, priority);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn metrics_elapsed_stops_at_recorded_finish() {
let metrics = MetricsState::new();
let before = metrics.snapshot().elapsed;
std::thread::sleep(std::time::Duration::from_millis(5));
let active = metrics.snapshot().elapsed;
assert!(
active > before,
"elapsed must advance while the transfer is active"
);
metrics.set_finished();
let finished = metrics.snapshot().elapsed;
assert!(finished >= active);
std::thread::sleep(std::time::Duration::from_millis(5));
assert_eq!(
metrics.snapshot().elapsed,
finished,
"elapsed must stop advancing at the recorded finish"
);
}
mod state_machine_status {
use super::*;
#[test]
fn starts_active() {
let s = StateMachineStatus::new();
assert!(s.is_active());
assert!(!s.is_failed());
assert!(!s.is_cancelled());
}
#[test]
fn set_completed_from_active() {
let s = StateMachineStatus::new();
assert!(s.set_completed());
assert!(!s.is_active());
assert!(!s.is_failed());
assert!(!s.is_cancelled());
}
#[test]
fn set_failed_from_active() {
let s = StateMachineStatus::new();
assert!(s.set_failed());
assert!(!s.is_active());
assert!(s.is_failed());
}
#[test]
fn set_cancelled_from_active() {
let s = StateMachineStatus::new();
assert!(s.set_cancelled());
assert!(!s.is_active());
assert!(s.is_cancelled());
}
#[test]
fn only_first_transition_wins() {
let s = StateMachineStatus::new();
assert!(s.set_failed());
assert!(!s.set_completed());
assert!(!s.set_cancelled());
assert!(s.is_failed());
}
#[test]
fn completed_blocks_other_transitions() {
let s = StateMachineStatus::new();
assert!(s.set_completed());
assert!(!s.set_failed());
assert!(!s.set_cancelled());
}
#[test]
fn display() {
let s = StateMachineStatus::new();
assert_eq!(s.to_string(), "Active");
s.set_failed();
assert_eq!(s.to_string(), "Failed");
}
}
mod transfer_status {
use crate::types::TransferStatus;
#[test]
fn is_terminal() {
assert!(!TransferStatus::Active.is_terminal());
assert!(TransferStatus::Completed.is_terminal());
assert!(TransferStatus::Failed.is_terminal());
assert!(TransferStatus::Cancelled.is_terminal());
}
}
mod transfer_context_status_and_metrics {
use super::*;
use std::sync::Arc;
fn test_handle() -> Arc<crate::client::Handle> {
let s3_client = aws_smithy_mocks::mock_client!(aws_sdk_s3, []);
let config = crate::Config::builder()
.sdk_client(s3_client)
.build()
.expect("valid config");
crate::client::Handle::new_for_test(config, 4)
}
fn test_handle_with_diagnostics(detail: u64) -> Arc<crate::client::Handle> {
let s3_client = aws_smithy_mocks::mock_client!(aws_sdk_s3, []);
let config = crate::Config::builder()
.sdk_client(s3_client)
.diagnostics_for_test(crate::config::MemoryDiagnosticsConfig::default(), detail)
.build()
.expect("valid config");
crate::client::Handle::new_for_test(config, 4)
}
#[derive(Clone, Default)]
struct TestRequestAttribution {
records: Arc<Mutex<Vec<(u8, crate::metrics::RequestMetrics)>>>,
}
impl RequestMetricsAttribution for TestRequestAttribution {
type Kind = u8;
fn record_request_metrics(
&self,
kind: Self::Kind,
metrics: &crate::metrics::RequestMetrics,
) {
self.records.lock().unwrap().push((kind, *metrics));
}
}
#[cfg_attr(miri, ignore)]
#[test]
fn status_transitions() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle.clone());
assert_eq!(ctx.transfer_status(), crate::types::TransferStatus::Active);
ctx.set_completed();
ctx.signal_terminal();
assert_eq!(
ctx.transfer_status(),
crate::types::TransferStatus::Completed
);
let (ctx, _rx) = TransferContext::new(handle.clone());
ctx.set_failed(crate::error::Error::new(
crate::error::ErrorKind::InputInvalid,
"test",
));
ctx.signal_terminal();
assert_eq!(ctx.transfer_status(), crate::types::TransferStatus::Failed);
let (ctx, _rx) = TransferContext::new(handle);
ctx.set_cancelled();
ctx.signal_terminal();
assert_eq!(
ctx.transfer_status(),
crate::types::TransferStatus::Cancelled
);
}
#[cfg_attr(miri, ignore)]
#[test]
fn amend_error_rewrites_only_a_stored_error() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle);
let with_id = |err: crate::error::Error| err.with_upload_id("id".to_owned());
ctx.amend_error(with_id);
assert!(ctx.is_active());
assert!(ctx.take_error().is_none());
ctx.set_failed(crate::error::Error::new(
crate::error::ErrorKind::RuntimeError,
"test",
));
ctx.amend_error(with_id);
let err = ctx.take_error().expect("the failure is stored");
assert_eq!(err.kind(), &crate::error::ErrorKind::RuntimeError);
assert_eq!(err.upload_id(), Some("id"));
ctx.amend_error(|_| panic!("a taken error must not be amended"));
assert!(ctx.take_error().is_none());
}
#[cfg_attr(miri, ignore)]
#[test]
fn stats_initial_values() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle);
let stats = ctx.metrics();
assert_eq!(stats.network_tx, 0);
assert_eq!(stats.network_rx, 0);
assert_eq!(stats.disk_read, 0);
assert_eq!(stats.disk_write, 0);
assert_eq!(stats.total_bytes, None);
assert!(stats.elapsed.as_secs() < 1);
}
#[cfg_attr(miri, ignore)]
#[test]
fn stats_record_io() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle);
ctx.record_io(&crate::metrics::IoSample {
network_tx: 100,
network_rx: 200,
disk_read: 300,
disk_write: 400,
});
ctx.record_io(&crate::metrics::IoSample {
network_tx: 10,
network_rx: 20,
disk_read: 30,
disk_write: 40,
});
let stats = ctx.metrics();
assert_eq!(stats.network_tx, 110);
assert_eq!(stats.network_rx, 220);
assert_eq!(stats.disk_read, 330);
assert_eq!(stats.disk_write, 440);
}
#[cfg_attr(miri, ignore)]
#[test]
fn request_metrics_merge_into_transfer_aggregate() {
let handle = test_handle();
assert!(!handle.config.diagnostics().transfer().enable_summaries());
let (ctx, _rx) = TransferContext::new(handle);
let req_metrics = crate::metrics::RequestMetrics {
requests: 1,
elapsed: std::time::Duration::from_millis(15),
max_elapsed: std::time::Duration::from_millis(15),
retry_reissues: 2,
throttle_reissues: 3,
hedge_reissues: 1,
retry_exhaustions: 1,
backoff_duration: std::time::Duration::from_millis(9),
};
ctx.record_request_metrics(&req_metrics);
assert_eq!(ctx.metrics.request_metrics(), req_metrics);
}
#[cfg_attr(miri, ignore)]
#[test]
fn request_measurement_publishes_once_on_finish_or_drop() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle);
ctx.start_request_metrics().finish();
drop(ctx.start_request_metrics());
assert_eq!(ctx.metrics.request_metrics().requests, 2);
}
#[cfg_attr(miri, ignore)]
#[tokio::test(start_paused = true)]
async fn request_measurement_excludes_paused_time() {
use std::time::Duration;
let (ctx, _rx) = TransferContext::new(test_handle());
let mut measurement = ctx.start_request_metrics();
tokio::time::advance(Duration::from_secs(1)).await;
measurement.pause();
tokio::time::advance(Duration::from_secs(10)).await;
measurement.resume();
tokio::time::advance(Duration::from_secs(2)).await;
let metrics = measurement.finish();
assert_eq!(metrics.elapsed, Duration::from_secs(3));
assert_eq!(metrics.max_elapsed, Duration::from_secs(3));
assert_eq!(
ctx.metrics.request_metrics().elapsed,
Duration::from_secs(3)
);
}
#[cfg_attr(miri, ignore)]
#[tokio::test(start_paused = true)]
async fn request_measurement_repeated_pause_and_resume_are_noops() {
use std::time::Duration;
let (ctx, _rx) = TransferContext::new(test_handle());
let mut measurement = ctx.start_request_metrics();
tokio::time::advance(Duration::from_secs(1)).await;
measurement.pause();
tokio::time::advance(Duration::from_secs(5)).await;
measurement.pause();
tokio::time::advance(Duration::from_secs(5)).await;
measurement.resume();
tokio::time::advance(Duration::from_secs(1)).await;
measurement.resume();
tokio::time::advance(Duration::from_secs(1)).await;
assert_eq!(measurement.finish().elapsed, Duration::from_secs(3));
}
#[cfg_attr(miri, ignore)]
#[tokio::test(start_paused = true)]
async fn request_measurement_published_while_paused_counts_active_time() {
use std::time::Duration;
let (ctx, _rx) = TransferContext::new(test_handle());
let mut finished = ctx.start_request_metrics();
tokio::time::advance(Duration::from_secs(2)).await;
finished.pause();
tokio::time::advance(Duration::from_secs(10)).await;
assert_eq!(finished.finish().elapsed, Duration::from_secs(2));
let mut dropped = ctx.start_request_metrics();
tokio::time::advance(Duration::from_secs(3)).await;
dropped.pause();
tokio::time::advance(Duration::from_secs(10)).await;
drop(dropped);
let total = ctx.metrics.request_metrics();
assert_eq!(total.requests, 2);
assert_eq!(total.elapsed, Duration::from_secs(5));
assert_eq!(total.max_elapsed, Duration::from_secs(3));
}
#[cfg_attr(miri, ignore)]
#[tokio::test(start_paused = true)]
async fn attributed_request_measurement_forwards_pause_and_resume() {
use std::time::Duration;
let (ctx, _rx) = TransferContext::new(test_handle());
let attribution = TestRequestAttribution::default();
let mut measurement = AttributedRequestMeasurement::new(&ctx, attribution.clone(), 1);
tokio::time::advance(Duration::from_secs(1)).await;
measurement.pause();
tokio::time::advance(Duration::from_secs(10)).await;
measurement.resume();
tokio::time::advance(Duration::from_secs(1)).await;
drop(measurement);
let records = attribution.records.lock().unwrap();
assert_eq!(records.len(), 1);
assert_eq!(records[0].1.elapsed, Duration::from_secs(2));
assert_eq!(
ctx.metrics.request_metrics().elapsed,
Duration::from_secs(2)
);
}
#[cfg_attr(miri, ignore)]
#[test]
fn attributed_request_measurement_publishes_to_both_aggregates() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle);
let attribution = TestRequestAttribution::default();
let mut finished = AttributedRequestMeasurement::new(&ctx, attribution.clone(), 7);
finished
.metrics_mut()
.record_retry_reissue(std::time::Duration::from_millis(3));
let finished_metrics = finished.finish();
drop(AttributedRequestMeasurement::new(
&ctx,
attribution.clone(),
9,
));
let records = attribution.records.lock().unwrap();
assert_eq!(records.len(), 2);
assert_eq!(records[0], (7, finished_metrics));
assert_eq!(records[1].0, 9);
assert_eq!(records[1].1.requests, 1);
assert_eq!(ctx.metrics.request_metrics().requests, 2);
assert_eq!(ctx.metrics.request_metrics().retry_reissues, 1);
}
#[cfg_attr(miri, ignore)]
#[test]
fn disabled_diagnostics_do_not_allocate_pending_stats() {
let (ctx, _rx) = TransferContext::new(test_handle());
ctx.set_pending(PendingCause::new(PendingCategory::Memory, "test"));
ctx.record_wake();
ctx.begin_poll();
assert_eq!(ctx.pending_stats(), None);
}
#[cfg_attr(miri, ignore)]
#[test]
fn pending_cause_is_accounted_across_wake_and_next_poll() {
let (ctx, _rx) = TransferContext::new(test_handle_with_diagnostics(1));
ctx.set_pending(PendingCause::new(PendingCategory::Memory, "test"));
ctx.record_wake();
ctx.record_wake();
ctx.begin_poll();
let stats = ctx.pending_stats().expect("summary diagnostics enabled");
let memory = stats.category(PendingCategory::Memory);
assert_eq!(memory.count, 1);
assert_eq!(stats.terminal_cause, None);
}
#[cfg_attr(miri, ignore)]
#[test]
fn terminal_signal_closes_pending_interval_once() {
let (ctx, _rx) = TransferContext::new(test_handle_with_diagnostics(1));
let cause = PendingCause::in_flight_work("test");
ctx.set_pending(cause);
ctx.set_cancelled();
ctx.signal_terminal();
ctx.signal_terminal();
let stats = ctx.pending_stats().expect("summary diagnostics enabled");
assert_eq!(stats.terminal_cause, Some(cause));
assert_eq!(stats.category(PendingCategory::InFlightWork).count, 1);
}
#[cfg_attr(miri, ignore)]
#[test]
fn terminal_report_can_be_claimed_once() {
let (ctx, _rx) = TransferContext::new(test_handle());
assert!(ctx.claim_terminal_report());
assert!(!ctx.claim_terminal_report());
}
#[cfg_attr(miri, ignore)]
#[test]
fn signal_terminal_stops_elapsed() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle);
let before = ctx.metrics().elapsed;
std::thread::sleep(std::time::Duration::from_millis(5));
assert!(
ctx.metrics().elapsed > before,
"elapsed must advance before the transfer finishes"
);
ctx.set_completed();
ctx.signal_terminal();
let finished = ctx.metrics().elapsed;
std::thread::sleep(std::time::Duration::from_millis(5));
assert_eq!(
ctx.metrics().elapsed,
finished,
"signal_terminal must record the finish"
);
}
#[cfg_attr(miri, ignore)]
#[test]
fn set_total_bytes() {
let handle = test_handle();
let (ctx, _rx) = TransferContext::new(handle);
assert_eq!(ctx.metrics().total_bytes, None);
ctx.set_total_bytes(42);
assert_eq!(ctx.metrics().total_bytes, Some(42));
}
}
}
#[cfg(all(test, s3_tm_loom))]
mod loom_tests {
use super::wake_flag::WakeFlag;
use loom::sync::atomic::{AtomicBool, Ordering};
use loom::sync::{Arc, Mutex};
use loom::thread;
struct Harness {
flag: WakeFlag,
state: Mutex<u32>,
wake_fired: AtomicBool,
}
impl Harness {
fn new() -> Self {
Self {
flag: WakeFlag::new(),
state: Mutex::new(0),
wake_fired: AtomicBool::new(false),
}
}
fn try_wake(&self) {
if self.flag.take_pending() {
self.wake_fired.store(true, Ordering::Release);
}
}
}
#[test]
fn set_pending_then_try_wake_no_lost_wake() {
loom::model(|| {
let harness = Arc::new(Harness::new());
let h2 = harness.clone();
let poller = thread::spawn(move || {
let guard = h2.state.lock().unwrap();
h2.flag.set_pending();
let blocked = *guard == 0;
drop(guard);
blocked
});
let h3 = harness.clone();
let mutator = thread::spawn(move || {
{
let mut guard = h3.state.lock().unwrap();
*guard = 1;
}
h3.try_wake();
});
let poller_returned_pending = poller.join().unwrap();
mutator.join().unwrap();
let mutated = *harness.state.lock().unwrap() == 1;
let wake_fired = harness.wake_fired.load(Ordering::Acquire);
if poller_returned_pending && mutated {
assert!(
wake_fired,
"lost wake: poller returned Pending, state was mutated, but wake did not fire"
);
}
});
}
}