use std::io::Cursor;
use std::path::{Path, PathBuf};
use chrono::Utc;
use tokio::sync::watch;
use tracing::Instrument;
use crate::clipboard::{RgbaImage, encode_png};
use crate::config::AfterSend;
use crate::encryption::EncryptionError;
use crate::model::{ContentHasher, ItemId, NewItem};
use crate::random::StdRandom;
use crate::serve::drop_watcher::unique_target;
use crate::serve::retry::Backoff;
use crate::serve::{Job, StoreOpener, stopped};
use crate::store::{Store, StoreError};
use crate::telemetry;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum JobOutcome {
Sent(ItemId),
AlreadyPresent,
Skipped,
Abandoned,
Denied(String),
}
enum Failure {
Local(String),
Store(StoreError),
}
pub struct Uploader {
store: Box<dyn Store>,
open_store: StoreOpener,
device: String,
after_send: AfterSend,
sent_dir: PathBuf,
rng: StdRandom,
}
impl Uploader {
pub fn new(
store: Box<dyn Store>,
open_store: StoreOpener,
device: String,
after_send: AfterSend,
sent_dir: PathBuf,
) -> Self {
Self {
store,
open_store,
device,
after_send,
sent_dir,
rng: StdRandom::new(),
}
}
pub async fn handle(&mut self, job: Job, shutdown: &mut watch::Receiver<bool>) -> JobOutcome {
let span = telemetry::op_span("serve", &mut self.rng);
self.handle_with_retries(job, shutdown)
.instrument(span)
.await
}
async fn handle_with_retries(
&mut self,
job: Job,
shutdown: &mut watch::Receiver<bool>,
) -> JobOutcome {
let mut backoff = Backoff::default();
let mut attempt: u64 = 1;
let mut waiting_for_rewrite = false;
loop {
let result = tokio::select! {
result = self.attempt(&job) => result,
() = stopped(shutdown) => {
tracing::info!("stopping: upload abandoned");
return JobOutcome::Abandoned;
}
};
match result {
Ok(outcome) => {
if waiting_for_rewrite {
tracing::info!("the store's re-encryption has ended; sending resumed");
}
return outcome;
}
Err(Failure::Local(message)) => {
tracing::warn!(
error = message.as_str(),
"cannot send; skipping until serve restarts"
);
return JobOutcome::Skipped;
}
Err(Failure::Store(StoreError::Denied(message))) => {
tracing::error!(error = message.as_str(), "the store refuses this device");
return JobOutcome::Denied(message);
}
Err(Failure::Store(err)) => {
let delay = backoff.next_delay();
if matches!(
err,
StoreError::Encryption(EncryptionError::Rewriting { .. })
) {
if !waiting_for_rewrite {
tracing::info!(error = %err, "waiting for the store's re-encryption to end");
waiting_for_rewrite = true;
}
} else {
tracing::warn!(attempt, error = %err, "upload failed; retrying in {} s", delay.as_secs());
}
tokio::select! {
() = tokio::time::sleep(delay) => {}
() = stopped(shutdown) => return JobOutcome::Abandoned,
}
match (self.open_store)().await {
Ok(store) => self.store = store,
Err(StoreError::Denied(message)) => {
tracing::error!(
error = message.as_str(),
"the store refuses this device"
);
return JobOutcome::Denied(message);
}
Err(err) => tracing::warn!(attempt, error = %err, "reconnecting failed"),
}
attempt += 1;
}
}
}
}
async fn attempt(&self, job: &Job) -> Result<JobOutcome, Failure> {
match job {
Job::Text(text) => self.send_text(text).await,
Job::File(path) => self.send_file(path).await,
Job::Image(image) => self.send_image(image).await,
}
}
async fn send_image(&self, image: &RgbaImage) -> Result<JobOutcome, Failure> {
let png =
encode_png(image).map_err(|err| Failure::Local(format!("clipboard image: {err}")))?;
let mut hasher = ContentHasher::new();
hasher.update(&png);
let key = self.store.content_key(&hasher.finalize());
if let Some(existing) = self
.store
.find_by_content_key(&key)
.await
.map_err(Failure::Store)?
{
tracing::debug!(id = %existing.id, "clipboard image is already stored");
return Ok(JobOutcome::AlreadyPresent);
}
let outcome = self
.store
.put(
NewItem::clipboard_image(self.device.clone(), Utc::now()),
Box::new(Cursor::new(png)),
)
.await
.map_err(Failure::Store)?;
tracing::info!(id = %outcome.meta.id, size = outcome.meta.size, "sent clipboard image");
Ok(if outcome.created {
JobOutcome::Sent(outcome.meta.id)
} else {
JobOutcome::AlreadyPresent
})
}
async fn send_text(&self, text: &str) -> Result<JobOutcome, Failure> {
let mut hasher = ContentHasher::new();
hasher.update(text.as_bytes());
let key = self.store.content_key(&hasher.finalize());
if let Some(existing) = self
.store
.find_by_content_key(&key)
.await
.map_err(Failure::Store)?
{
tracing::debug!(id = %existing.id, "clipboard text is already stored");
return Ok(JobOutcome::AlreadyPresent);
}
let content = Box::new(Cursor::new(text.as_bytes().to_vec()));
let outcome = self
.store
.put(NewItem::text(self.device.clone()), content)
.await
.map_err(Failure::Store)?;
tracing::info!(id = %outcome.meta.id, size = outcome.meta.size, "sent clipboard text");
Ok(if outcome.created {
JobOutcome::Sent(outcome.meta.id)
} else {
JobOutcome::AlreadyPresent
})
}
async fn send_file(&self, path: &Path) -> Result<JobOutcome, Failure> {
let shown = path.display();
let local = |message: String| Failure::Local(format!("{shown}: {message}"));
let name = path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.ok_or_else(|| local("no file name".to_owned()))?;
let file = tokio::fs::File::open(path)
.await
.map_err(|err| local(err.to_string()))?;
let outcome = match self
.store
.put(NewItem::file(name, self.device.clone()), Box::new(file))
.await
{
Ok(outcome) => outcome,
Err(StoreError::Content(message)) => return Err(local(message)),
Err(err) => return Err(Failure::Store(err)),
};
tracing::info!(id = %outcome.meta.id, size = outcome.meta.size, path = %shown, "sent file");
self.finish_file(path).await;
Ok(if outcome.created {
JobOutcome::Sent(outcome.meta.id)
} else {
JobOutcome::AlreadyPresent
})
}
async fn finish_file(&self, path: &Path) {
let result = match self.after_send {
AfterSend::Move => {
let name = path
.file_name()
.map(|n| n.to_string_lossy().into_owned())
.unwrap_or_default();
let target = unique_target(&self.sent_dir, &name);
tokio::fs::rename(path, &target)
.await
.map(|()| Some(target))
}
AfterSend::Delete => tokio::fs::remove_file(path).await.map(|()| None),
};
match result {
Ok(Some(target)) => {
tracing::debug!(path = %target.display(), "moved to the sent folder")
}
Ok(None) => tracing::debug!(path = %path.display(), "deleted after sending"),
Err(err) => {
tracing::warn!(path = %path.display(), error = %err, "sent, but could not move or delete the file")
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::clock::SystemClock;
use crate::config::AfterSend;
use crate::fs::{BoxRead, LocalFs};
use crate::model::{ContentKey, ItemId, ItemMeta, NewItem};
use crate::random::StdRandom;
use crate::serve::{Job, StoreOpener};
use crate::store::{FsStore, PutOutcome, Store, StoreError};
use async_trait::async_trait;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Duration;
use tempfile::TempDir;
use tokio::sync::watch;
struct Flaky {
inner: FsStore<LocalFs>,
failures: Arc<AtomicUsize>,
puts: Arc<AtomicUsize>,
error: fn() -> StoreError,
}
fn went_away() -> StoreError {
StoreError::Backend("server went away".into())
}
#[async_trait]
impl Store for Flaky {
async fn put(&self, item: NewItem, content: BoxRead) -> Result<PutOutcome, StoreError> {
self.puts.fetch_add(1, Ordering::SeqCst);
if self.failures.load(Ordering::SeqCst) > 0 {
self.failures.fetch_sub(1, Ordering::SeqCst);
return Err((self.error)());
}
self.inner.put(item, content).await
}
async fn list(&self) -> Result<Vec<ItemMeta>, StoreError> {
self.inner.list().await
}
async fn list_after(&self, after: Option<&ItemId>) -> Result<Vec<ItemMeta>, StoreError> {
self.inner.list_after(after).await
}
async fn get(&self, id: &ItemId) -> Result<(ItemMeta, BoxRead), StoreError> {
self.inner.get(id).await
}
async fn exists(&self, id: &ItemId) -> Result<bool, StoreError> {
self.inner.exists(id).await
}
async fn find_by_content_key(
&self,
key: &ContentKey,
) -> Result<Option<ItemMeta>, StoreError> {
self.inner.find_by_content_key(key).await
}
async fn resolve(&self, input: &str) -> Result<ItemId, StoreError> {
self.inner.resolve(input).await
}
async fn delete(&self, id: &ItemId) -> Result<ItemMeta, StoreError> {
self.inner.delete(id).await
}
async fn clean_staging(&self, older_than: Duration) -> Result<usize, StoreError> {
self.inner.clean_staging(older_than).await
}
}
struct CountingSealed {
inner: FsStore<LocalFs>,
puts: Arc<AtomicUsize>,
}
#[async_trait]
impl Store for CountingSealed {
async fn put(&self, item: NewItem, content: BoxRead) -> Result<PutOutcome, StoreError> {
self.puts.fetch_add(1, Ordering::SeqCst);
self.inner.put(item, content).await
}
async fn list(&self) -> Result<Vec<ItemMeta>, StoreError> {
self.inner.list().await
}
async fn list_after(&self, after: Option<&ItemId>) -> Result<Vec<ItemMeta>, StoreError> {
self.inner.list_after(after).await
}
async fn get(&self, id: &ItemId) -> Result<(ItemMeta, BoxRead), StoreError> {
self.inner.get(id).await
}
async fn exists(&self, id: &ItemId) -> Result<bool, StoreError> {
self.inner.exists(id).await
}
async fn find_by_content_key(
&self,
key: &ContentKey,
) -> Result<Option<ItemMeta>, StoreError> {
self.inner.find_by_content_key(key).await
}
async fn resolve(&self, input: &str) -> Result<ItemId, StoreError> {
self.inner.resolve(input).await
}
async fn delete(&self, id: &ItemId) -> Result<ItemMeta, StoreError> {
self.inner.delete(id).await
}
async fn clean_staging(&self, older_than: Duration) -> Result<usize, StoreError> {
self.inner.clean_staging(older_than).await
}
fn key_id(&self) -> Option<crate::crypto::KeyId> {
self.inner.key_id()
}
fn content_key(&self, digest: &crate::model::ContentDigest) -> ContentKey {
self.inner.content_key(digest)
}
}
#[tokio::test]
async fn text_already_in_an_encrypted_store_is_not_uploaded_again() {
let dir = TempDir::new().unwrap();
let sealer = crate::crypto::Sealer::new(crate::crypto::DataKey::generate().unwrap());
let inner = FsStore::sealed(
LocalFs::new(dir.path()),
Arc::new(SystemClock),
Box::new(StdRandom::new()),
sealer,
);
inner
.put(
NewItem::text("load"),
Box::new(std::io::Cursor::new(b"from load".to_vec())),
)
.await
.unwrap();
let puts = Arc::new(AtomicUsize::new(0));
let store = CountingSealed {
inner,
puts: puts.clone(),
};
let opener: StoreOpener = Arc::new(|| -> crate::store::BackendFuture<'static> {
Box::pin(async { Err(StoreError::Backend("not reopened".into())) })
});
let mut uploader = Uploader::new(
Box::new(store),
opener,
"box".into(),
AfterSend::Move,
dir.path().join("sent"),
);
let (_stop, mut stopped) = watch::channel(false);
let outcome = uploader
.handle(Job::Text("from load".into()), &mut stopped)
.await;
assert!(matches!(outcome, JobOutcome::AlreadyPresent));
assert_eq!(puts.load(Ordering::SeqCst), 0, "nothing was uploaded");
}
#[tokio::test]
async fn a_file_sent_across_a_rotation_is_kept_for_the_retry() {
use crate::crypto::{KDF_SALT_LEN, KdfParams, Words};
use crate::encryption::{open_with_key, rotate, set_up};
use crate::testing::{FsOp, PausingFs};
let dir = TempDir::new().unwrap();
let root = dir.path().join("store");
std::fs::create_dir_all(&root).unwrap();
let kdf = || KdfParams {
m_kib: 64,
t: 1,
p: 1,
salt: [6; KDF_SALT_LEN],
};
let old = set_up(
&LocalFs::new(root.clone()),
&Words::parse("abacus zoom abdomen abacus zoom abdomen").unwrap(),
kdf(),
)
.await
.unwrap();
let paused = Arc::new(PausingFs::new(LocalFs::new(root.clone())));
let store = open_with_key(
Arc::clone(&paused),
Some(old.clone()),
Arc::new(SystemClock),
Box::new(StdRandom::new()),
)
.await
.unwrap();
let opener: StoreOpener = Arc::new(|| -> crate::store::BackendFuture<'static> {
Box::pin(async { Err(StoreError::Backend("not reopened".into())) })
});
let uploader = Uploader::new(
store,
opener,
"box".into(),
AfterSend::Delete,
dir.path().join("sent"),
);
let file = dir.path().join("report.txt");
std::fs::write(&file, "the only copy").unwrap();
paused.pause_at(FsOp::OpenWrite, 1);
let job = Job::File(file.clone());
let send = uploader.attempt(&job);
let rotation = async {
paused.reached().await;
rotate(
&LocalFs::new(root.clone()),
&old,
&Words::parse("zoom zoom zoom zoom zoom zoom").unwrap(),
kdf(),
Arc::new(SystemClock),
)
.await
.unwrap();
paused.release();
};
let (sent, ()) = tokio::join!(send, rotation);
assert!(matches!(sent, Err(Failure::Store(_))));
assert_eq!(std::fs::read_to_string(&file).unwrap(), "the only copy");
}
struct Rig {
dir: TempDir,
failures: Arc<AtomicUsize>,
puts: Arc<AtomicUsize>,
opens: Arc<AtomicUsize>,
error: fn() -> StoreError,
}
impl Rig {
fn new(failures: usize) -> Self {
Self::failing_with(failures, went_away)
}
fn failing_with(failures: usize, error: fn() -> StoreError) -> Self {
let dir = TempDir::new().unwrap();
std::fs::create_dir_all(dir.path().join("store")).unwrap();
std::fs::create_dir_all(dir.path().join("drop/sent")).unwrap();
Self {
dir,
failures: Arc::new(AtomicUsize::new(failures)),
puts: Arc::new(AtomicUsize::new(0)),
opens: Arc::new(AtomicUsize::new(0)),
error,
}
}
fn flaky(&self) -> Box<dyn Store> {
Box::new(Flaky {
inner: FsStore::new(
LocalFs::new(self.dir.path().join("store")),
Arc::new(SystemClock),
Box::new(StdRandom::new()),
),
failures: self.failures.clone(),
puts: self.puts.clone(),
error: self.error,
})
}
fn opener(&self) -> StoreOpener {
let (root, failures, puts, opens, error) = (
self.dir.path().join("store"),
self.failures.clone(),
self.puts.clone(),
self.opens.clone(),
self.error,
);
Arc::new(move || -> crate::store::BackendFuture<'static> {
opens.fetch_add(1, Ordering::SeqCst);
let store: Box<dyn Store> = Box::new(Flaky {
inner: FsStore::new(
LocalFs::new(root.clone()),
Arc::new(SystemClock),
Box::new(StdRandom::new()),
),
failures: failures.clone(),
puts: puts.clone(),
error,
});
Box::pin(async move { Ok(store) })
})
}
fn uploader(&self, after_send: AfterSend) -> Uploader {
Uploader::new(
self.flaky(),
self.opener(),
"box".into(),
after_send,
self.drop("sent"),
)
}
fn drop(&self, name: &str) -> PathBuf {
self.dir.path().join("drop").join(name)
}
async fn items(&self) -> Vec<ItemMeta> {
self.flaky().list().await.unwrap()
}
}
fn quiet() -> (watch::Sender<bool>, watch::Receiver<bool>) {
watch::channel(false)
}
#[tokio::test(start_paused = true)]
async fn failed_uploads_are_retried_with_a_fresh_store() {
let rig = Rig::new(2);
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
let started = tokio::time::Instant::now();
let outcome = uploader.handle(Job::Text("hello".into()), &mut rx).await;
assert!(matches!(outcome, JobOutcome::Sent(_)), "{outcome:?}");
assert_eq!(
rig.opens.load(Ordering::SeqCst),
2,
"one reconnect per retry"
);
assert_eq!(rig.puts.load(Ordering::SeqCst), 3);
assert_eq!(
started.elapsed(),
Duration::from_secs(3),
"waited 1 s then 2 s"
);
assert_eq!(rig.items().await.len(), 1);
}
#[tokio::test(start_paused = true)]
async fn a_refused_device_gives_up_at_once() {
let rig = Rig::failing_with(5, || StoreError::Denied("the key was revoked".into()));
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
let file = rig.drop("keep.txt");
std::fs::write(&file, "the only copy").unwrap();
let started = tokio::time::Instant::now();
assert_eq!(
uploader.handle(Job::File(file.clone()), &mut rx).await,
JobOutcome::Denied("the key was revoked".into())
);
assert_eq!(rig.puts.load(Ordering::SeqCst), 1, "never retried");
assert_eq!(started.elapsed(), Duration::ZERO);
assert!(file.exists(), "the file stays in the drop folder");
}
#[tokio::test(start_paused = true)]
async fn a_reconnect_the_store_refuses_gives_up_too() {
let rig = Rig::new(1);
let opener: StoreOpener = Arc::new(|| -> crate::store::BackendFuture<'static> {
Box::pin(async { Err(StoreError::Denied("the key expired".into())) })
});
let mut uploader = Uploader::new(
rig.flaky(),
opener,
"box".into(),
AfterSend::Move,
rig.drop("sent"),
);
let (_tx, mut rx) = quiet();
assert_eq!(
uploader.handle(Job::Text("x".into()), &mut rx).await,
JobOutcome::Denied("the key expired".into())
);
}
#[tokio::test(start_paused = true)]
async fn a_rewrite_is_waited_out_and_the_job_sent_after_it() {
let rig = Rig::failing_with(4, || EncryptionError::Rewriting { started: None }.into());
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
let outcome = uploader.handle(Job::Text("later".into()), &mut rx).await;
assert!(matches!(outcome, JobOutcome::Sent(_)), "{outcome:?}");
assert_eq!(rig.puts.load(Ordering::SeqCst), 5);
assert_eq!(rig.items().await.len(), 1);
}
#[tokio::test(start_paused = true)]
async fn a_failed_reconnect_keeps_retrying() {
let rig = Rig::new(1);
let opens = Arc::new(AtomicUsize::new(0));
let good = rig.opener();
let counted = opens.clone();
let opener: StoreOpener = Arc::new(move || -> crate::store::BackendFuture<'static> {
if counted.fetch_add(1, Ordering::SeqCst) == 0 {
Box::pin(async { Err(StoreError::Backend("still down".into())) })
} else {
good()
}
});
let mut uploader = Uploader::new(
rig.flaky(),
opener,
"box".into(),
AfterSend::Move,
rig.drop("sent"),
);
let (_tx, mut rx) = quiet();
assert!(matches!(
uploader.handle(Job::Text("x".into()), &mut rx).await,
JobOutcome::Sent(_)
));
assert_eq!(
opens.load(Ordering::SeqCst),
1,
"the first reconnect failed; the old store was retried"
);
}
#[tokio::test]
async fn text_already_on_the_server_is_not_uploaded_again() {
let rig = Rig::new(0);
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
assert!(matches!(
uploader.handle(Job::Text("hello".into()), &mut rx).await,
JobOutcome::Sent(_)
));
assert!(matches!(
uploader.handle(Job::Text("hello".into()), &mut rx).await,
JobOutcome::AlreadyPresent
));
assert_eq!(rig.puts.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn sent_files_move_into_sent() {
let rig = Rig::new(0);
std::fs::write(rig.drop("a.txt"), b"body").unwrap();
std::fs::write(rig.drop("sent/a.txt"), b"older").unwrap();
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
assert!(matches!(
uploader.handle(Job::File(rig.drop("a.txt")), &mut rx).await,
JobOutcome::Sent(_)
));
assert!(!rig.drop("a.txt").exists());
assert_eq!(std::fs::read(rig.drop("sent/a (1).txt")).unwrap(), b"body");
assert_eq!(rig.items().await[0].name.as_deref(), Some("a.txt"));
}
#[tokio::test]
async fn sent_files_can_be_deleted_instead() {
let rig = Rig::new(0);
std::fs::write(rig.drop("b.txt"), b"body").unwrap();
let mut uploader = rig.uploader(AfterSend::Delete);
let (_tx, mut rx) = quiet();
assert!(matches!(
uploader.handle(Job::File(rig.drop("b.txt")), &mut rx).await,
JobOutcome::Sent(_)
));
assert!(!rig.drop("b.txt").exists());
assert!(!rig.drop("sent/b.txt").exists());
}
#[tokio::test]
async fn duplicate_files_are_still_moved_out_of_the_drop_folder() {
let rig = Rig::new(0);
std::fs::write(rig.drop("c.txt"), b"same").unwrap();
std::fs::write(rig.drop("d.txt"), b"same").unwrap();
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
uploader.handle(Job::File(rig.drop("c.txt")), &mut rx).await;
assert!(matches!(
uploader.handle(Job::File(rig.drop("d.txt")), &mut rx).await,
JobOutcome::AlreadyPresent
));
assert!(rig.drop("sent/d.txt").exists());
}
#[tokio::test]
async fn vanished_files_are_skipped_without_retrying() {
let rig = Rig::new(5);
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
let outcome = uploader
.handle(Job::File(rig.drop("gone.txt")), &mut rx)
.await;
assert!(matches!(outcome, JobOutcome::Skipped), "{outcome:?}");
assert_eq!(rig.opens.load(Ordering::SeqCst), 0);
assert_eq!(rig.puts.load(Ordering::SeqCst), 0);
let _: &Path = rig.dir.path();
}
#[tokio::test(start_paused = true)]
async fn shutdown_interrupts_retrying() {
let rig = Rig::new(usize::MAX);
let mut uploader = rig.uploader(AfterSend::Move);
let (tx, mut rx) = quiet();
let stopper = tokio::spawn(async move {
tokio::time::sleep(Duration::from_secs(100)).await;
tx.send(true).unwrap();
tx
});
let outcome = uploader.handle(Job::Text("never".into()), &mut rx).await;
assert!(matches!(outcome, JobOutcome::Abandoned), "{outcome:?}");
drop(stopper.await.unwrap());
assert!(rig.items().await.is_empty());
}
#[tokio::test]
async fn clipboard_images_are_stored_as_png_once() {
use crate::clipboard::{RgbaImage, decode_png};
use tokio::io::AsyncReadExt;
let rig = Rig::new(0);
let mut uploader = rig.uploader(AfterSend::Move);
let (_tx, mut rx) = quiet();
let image = RgbaImage::new(2, 1, vec![1, 2, 3, 255, 4, 5, 6, 255]).unwrap();
let id = match uploader.handle(Job::Image(image.clone()), &mut rx).await {
JobOutcome::Sent(id) => id,
other => panic!("unexpected {other:?}"),
};
let items = rig.items().await;
assert_eq!(items.len(), 1);
assert!(items[0].is_clipboard_image());
assert_eq!(items[0].device, "box");
let (_, mut content) = rig.flaky().get(&id).await.unwrap();
let mut png = Vec::new();
content.read_to_end(&mut png).await.unwrap();
assert_eq!(decode_png(&png).unwrap(), image);
assert_eq!(
uploader.handle(Job::Image(image), &mut rx).await,
JobOutcome::AlreadyPresent
);
assert_eq!(rig.puts.load(Ordering::SeqCst), 1);
}
}