use std::{
backtrace::Backtrace,
borrow::Cow,
collections::{HashSet, VecDeque},
fmt,
num::NonZeroI64,
ops::{Deref, DerefMut},
pin::Pin,
sync::{
Arc, Weak,
atomic::{AtomicI64, Ordering},
},
task::{Context, Poll},
};
use bytes::Bytes;
use futures_core::Stream;
use crate::{
AsRange, LeaseId, Prefix, ResponseHeader, Revision, Version,
client::{Client, ClientInner, record_from_pb},
pb::{
etcdserverpb::{
self, watch_create_request::FilterType as PbFilterType, watch_request::RequestUnion as PbRequestUnion,
},
mvccpb::{self, event::EventType as PbEventType},
},
record::{AsKey, KeyWithMetadata, Metadata, Record},
};
impl Client {
pub fn watch(&self) -> WatchBuilder<Self> {
WatchBuilder {
client: self.clone(),
specs: Vec::new(),
}
}
pub fn watcher(&self, watches: impl IntoIterator<Item = Watch>) -> Watcher {
let mut builder = self.watch();
for watch in watches {
builder = builder.add(watch);
}
builder.start()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct WatchId(NonZeroI64);
impl WatchId {
pub const fn new(source: i64) -> Option<Self> {
if let Some(non_zero) = NonZeroI64::new(source) {
Some(WatchId(non_zero))
} else {
None
}
}
pub fn get(&self) -> i64 {
self.0.get()
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WatchEvent {
Put {
header: ResponseHeader,
watch_id: WatchId,
record: Record,
prev_record: Option<Record>,
created: bool,
},
Delete {
header: ResponseHeader,
watch_id: WatchId,
key: KeyWithMetadata,
prev_record: Option<Record>,
},
Progress {
header: ResponseHeader,
watch_id: Option<WatchId>,
revision: Revision,
},
}
#[must_use = "WatchBuilder does nothing unless you add targets and call `start`"]
pub struct WatchBuilder<C = ()> {
client: C,
specs: Vec<etcdserverpb::WatchCreateRequest>,
}
impl WatchBuilder<()> {
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
Self {
client: (),
specs: Vec::new(),
}
}
}
impl<C> WatchBuilder<C> {
pub fn with_client<C2>(self, client: C2) -> WatchBuilder<C2> {
WatchBuilder {
client,
specs: self.specs,
}
}
pub(crate) fn into_parts(self) -> (C, WatchBuilder<()>) {
(
self.client,
WatchBuilder {
client: (),
specs: self.specs,
},
)
}
#[allow(clippy::should_implement_trait)]
pub fn add<W>(mut self, watch: Watch<W>) -> Self {
self.specs.push(watch.current);
self
}
fn _new_watch(self, lower: Bytes, upper: Bytes) -> Watch<Self> {
Watch {
watcher: self,
current: etcdserverpb::WatchCreateRequest {
key: lower,
range_end: upper,
fragment: true,
..Default::default()
},
}
}
pub fn key(self, key: impl AsKey) -> Watch<Self> {
let key = Bytes::copy_from_slice(key.as_key());
self._new_watch(key, Bytes::new())
}
pub fn prefix(self, prefix: impl AsKey) -> Watch<Self> {
self.range(Prefix(prefix))
}
pub fn range(self, range: impl AsRange) -> Watch<Self> {
let (lower, upper) = range.as_boundaries();
self._new_watch(lower, upper)
}
}
impl<C: crate::driver::WatchDriver> WatchBuilder<C> {
pub fn start(self) -> C::Watcher {
let (client, builder) = self.into_parts();
client.start_watch(builder)
}
}
#[must_use = "Watch does nothing unless you call `start` or pass it to `Watcher::add`"]
pub struct Watch<W = ()> {
watcher: W,
current: etcdserverpb::WatchCreateRequest,
}
impl Watch {
pub fn new(query: impl AsRange) -> Self {
let (lower, upper) = query.as_boundaries();
Watch {
watcher: (),
current: etcdserverpb::WatchCreateRequest {
key: lower,
range_end: upper,
fragment: true,
..Default::default()
},
}
}
}
impl<W> Watch<W> {
pub fn start_revision(mut self, revision: Revision) -> Self {
self.current.start_revision = revision.get();
self
}
pub fn get_previous(mut self) -> Self {
self.current.prev_kv = true;
self
}
pub fn progress_notify(mut self) -> Self {
self.current.progress_notify = true;
self
}
pub fn puts(mut self, enabled: bool) -> Self {
let filter = PbFilterType::Noput as i32;
if enabled {
self.current.filters.retain(|&f| f != filter);
} else if !self.current.filters.contains(&filter) {
self.current.filters.push(filter);
}
self
}
pub fn deletes(mut self, enabled: bool) -> Self {
let filter = PbFilterType::Nodelete as i32;
if enabled {
self.current.filters.retain(|&f| f != filter);
} else if !self.current.filters.contains(&filter) {
self.current.filters.push(filter);
}
self
}
}
impl<C> Watch<WatchBuilder<C>> {
fn _finalize_and_new(self, lower: Bytes, upper: Bytes) -> Self {
let Watch { mut watcher, current } = self;
watcher.specs.push(current);
Watch {
watcher,
current: etcdserverpb::WatchCreateRequest {
key: lower,
range_end: upper,
fragment: true,
..Default::default()
},
}
}
pub fn key(self, key: impl AsKey) -> Self {
let key = Bytes::copy_from_slice(key.as_key());
self._finalize_and_new(key, Bytes::new())
}
pub fn prefix(self, prefix: impl AsKey) -> Self {
self.range(Prefix(prefix))
}
pub fn range(self, range: impl AsRange) -> Self {
let (lower, upper) = range.as_boundaries();
self._finalize_and_new(lower, upper)
}
}
impl Watch<WatchBuilder<()>> {
pub fn with_client(self, client: Client) -> Watch<WatchBuilder<Client>> {
Watch {
watcher: self.watcher.with_client(client),
current: self.current,
}
}
}
impl WatchBuilder<Client> {
pub(crate) fn start_client_watch(self) -> Watcher {
let client = self.client.inner;
let requests = Arc::new(std::sync::Mutex::new(Requests {
attempt: None,
replay: Some(Vec::new()),
}));
let sender = WatchSender {
requests: Arc::downgrade(&requests),
next_id: AtomicI64::new(1),
};
for spec in self.specs {
sender.add(Watch {
watcher: (),
current: spec,
});
}
let inner = async_stream::stream! {
let mut refreshed = false;
'open: loop {
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
let (mut response_stream, unanswered_creates, generation) = loop {
let receiver = requests.lock().unwrap().new_attempt();
let unanswered_creates = Arc::new(std::sync::Mutex::new(VecDeque::new()));
let mut request = tonic::Request::new(ReceiverStream {
inner: receiver,
unanswered_creates: unanswered_creates.clone(),
});
let generation = client.attach_stream_token(&mut request, deadline).await;
let mut watch_client = client.service_client(etcdserverpb::watch_client::WatchClient::new);
match watch_client.watch(request).await {
Ok(resp) => break (resp.into_inner(), unanswered_creates, generation),
Err(status)
if status.code() == tonic::Code::Unavailable
&& std::time::Instant::now() <= deadline =>
{
continue;
}
Err(status) => {
drop(requests);
yield Err(WatchError::from_status(status));
return;
}
}
};
let mut fragments: Option<etcdserverpb::WatchResponse> = None;
let mut canceled_compacted = HashSet::new();
loop {
match response_stream.message().await {
Ok(Some(mut resp)) => {
if resp.created {
resp.watch_id = unanswered_creates.lock().unwrap().pop_front().unwrap_or(resp.watch_id);
if !refreshed
&& ClientInner::is_stale_token_refusal(&resp.cancel_reason)
&& requests.lock().unwrap().replay.is_some()
&& client
.refresh_auth_token_unserialized(
generation,
Some(std::time::Instant::now() + std::time::Duration::from_secs(5)),
)
.await
.is_ok()
{
refreshed = true;
continue 'open;
}
requests.lock().unwrap().replay = None;
if !resp.canceled {
continue;
}
}
if let Some(mut held) = fragments.take() {
if held.watch_id == resp.watch_id && !resp.canceled {
held.events.append(&mut resp.events);
resp.events = held.events;
} else {
yield Err(WatchError::invalid_response("incomplete fragmented watch response"));
}
}
if resp.fragment {
fragments = Some(resp);
continue;
}
if resp.canceled {
if resp.compact_revision != 0 {
requests.lock().unwrap().send(cancel_request(resp.watch_id));
canceled_compacted.insert(resp.watch_id);
} else if canceled_compacted.remove(&resp.watch_id) {
continue;
}
}
if resp.watch_id == -1 && !resp.canceled && !unanswered_creates.lock().unwrap().is_empty() {
continue;
}
for item in convert_response(resp) {
yield item;
}
}
Ok(None) => return,
Err(status) => {
drop(requests);
yield Err(WatchError::from_status(status));
return;
}
}
}
}
};
Watcher {
sender,
stream: WatchStream { inner: Box::new(inner) },
}
}
}
impl<C: crate::driver::WatchDriver> Watch<WatchBuilder<C>> {
pub fn start(self) -> C::Watcher {
let Watch { mut watcher, current } = self;
watcher.specs.push(current);
watcher.start()
}
}
pub struct Watcher {
sender: WatchSender,
stream: WatchStream,
}
impl Watcher {
pub fn into_parts(self) -> (WatchSender, WatchStream) {
(self.sender, self.stream)
}
pub fn add(&self, watch: Watch) -> WatchId {
self.sender.add(watch)
}
pub fn cancel(&self, watch_id: WatchId) {
self.sender.cancel(watch_id);
}
pub fn request_progress(&self) {
self.sender.request_progress();
}
}
impl Deref for Watcher {
type Target = WatchStream;
fn deref(&self) -> &Self::Target {
&self.stream
}
}
impl DerefMut for Watcher {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.stream
}
}
impl Stream for Watcher {
type Item = Result<WatchEvent, WatchError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Pin::new(&mut self.stream).poll_next(cx)
}
}
#[cfg(feature = "nightly-async-iterator")]
impl std::async_iter::AsyncIterator for Watcher {
type Item = Result<WatchEvent, WatchError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
Stream::poll_next(Pin::new(&mut self.stream), cx)
}
}
pub struct WatchSender {
requests: Weak<std::sync::Mutex<Requests>>,
next_id: AtomicI64,
}
impl WatchSender {
fn send(&self, request: etcdserverpb::WatchRequest) {
if let Some(requests) = self.requests.upgrade() {
requests.lock().unwrap().send(request);
}
}
pub fn add(&self, watch: Watch) -> WatchId {
let id = self.next_id.fetch_add(1, Ordering::Relaxed);
let mut request = watch.current;
request.watch_id = id;
self.send(etcdserverpb::WatchRequest {
request_union: Some(PbRequestUnion::CreateRequest(request)),
});
WatchId::new(id).expect("watch ID counter overflowed to 0")
}
pub fn cancel(&self, watch_id: WatchId) {
self.send(cancel_request(watch_id.get()));
}
pub fn request_progress(&self) {
self.send(etcdserverpb::WatchRequest {
request_union: Some(PbRequestUnion::ProgressRequest(etcdserverpb::WatchProgressRequest {})),
});
}
}
fn cancel_request(watch_id: i64) -> etcdserverpb::WatchRequest {
etcdserverpb::WatchRequest {
request_union: Some(PbRequestUnion::CancelRequest(etcdserverpb::WatchCancelRequest {
watch_id,
})),
}
}
pub struct WatchStream {
inner: Box<dyn Stream<Item = Result<WatchEvent, WatchError>> + Send>,
}
impl WatchStream {
fn poll_next_impl(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<Option<WatchEvent>, WatchError>> {
let inner = unsafe { self.map_unchecked_mut(|s| s.inner.as_mut()) };
inner.poll_next(cx).map(|item| match item {
None => Ok(None),
Some(Ok(event)) => Ok(Some(event)),
Some(Err(err)) => Err(err),
})
}
}
impl Stream for WatchStream {
type Item = Result<WatchEvent, WatchError>;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
self.poll_next_impl(cx).map(Result::transpose)
}
}
#[cfg(feature = "nightly-async-iterator")]
impl std::async_iter::AsyncIterator for WatchStream {
type Item = Result<WatchEvent, WatchError>;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
self.poll_next_impl(cx).map(Result::transpose)
}
}
struct Requests {
attempt: Option<tokio::sync::mpsc::UnboundedSender<etcdserverpb::WatchRequest>>,
replay: Option<Vec<etcdserverpb::WatchRequest>>,
}
impl Requests {
fn send(&mut self, request: etcdserverpb::WatchRequest) {
if let Some(replay) = &mut self.replay {
replay.push(request.clone());
}
if let Some(attempt) = &self.attempt {
let _ = attempt.send(request);
}
}
fn new_attempt(&mut self) -> tokio::sync::mpsc::UnboundedReceiver<etcdserverpb::WatchRequest> {
let (attempt, receiver) = tokio::sync::mpsc::unbounded_channel();
for request in self.replay.iter().flatten() {
let _ = attempt.send(request.clone());
}
self.attempt = Some(attempt);
receiver
}
}
struct ReceiverStream {
inner: tokio::sync::mpsc::UnboundedReceiver<etcdserverpb::WatchRequest>,
unanswered_creates: Arc<std::sync::Mutex<VecDeque<i64>>>,
}
impl Stream for ReceiverStream {
type Item = etcdserverpb::WatchRequest;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let polled = self.inner.poll_recv(cx);
if let Poll::Ready(Some(request)) = &polled
&& let Some(PbRequestUnion::CreateRequest(create)) = &request.request_union
{
self.unanswered_creates.lock().unwrap().push_back(create.watch_id);
}
polled
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum WatchErrorKind {
Compacted,
Canceled,
InvalidResponse,
Unknown,
}
pub struct WatchError(Box<WatchErrorRepr>);
struct WatchErrorRepr {
kind: WatchErrorKind,
watch_id: Option<WatchId>,
compact_revision: Option<i64>,
message: Cow<'static, str>,
status: Option<tonic::Status>,
backtrace: Backtrace,
}
impl WatchError {
pub fn kind(&self) -> WatchErrorKind {
self.0.kind
}
pub fn watch_id(&self) -> Option<WatchId> {
self.0.watch_id
}
pub fn compact_revision(&self) -> Option<i64> {
self.0.compact_revision
}
pub fn cancel_reason(&self) -> Option<&str> {
if self.0.kind == WatchErrorKind::Canceled {
Some(&self.0.message)
} else {
None
}
}
pub fn grpc_status(&self) -> Option<&tonic::Status> {
self.0.status.as_ref()
}
pub fn take_grpc_status(self) -> Option<tonic::Status> {
self.0.status
}
pub fn backtrace(&self) -> &Backtrace {
&self.0.backtrace
}
pub(crate) fn from_status(status: tonic::Status) -> Self {
Self(Box::new(WatchErrorRepr {
kind: WatchErrorKind::Unknown,
watch_id: None,
compact_revision: None,
message: Cow::Borrowed(""),
status: Some(status),
backtrace: Backtrace::capture(),
}))
}
fn compacted(watch_id: i64, compact_revision: i64) -> Self {
Self(Box::new(WatchErrorRepr {
kind: WatchErrorKind::Compacted,
watch_id: WatchId::new(watch_id),
compact_revision: Some(compact_revision),
message: Cow::Owned(format!("watch {watch_id} compacted at revision {compact_revision}")),
status: None,
backtrace: Backtrace::capture(),
}))
}
fn canceled(watch_id: i64, reason: String) -> Self {
Self(Box::new(WatchErrorRepr {
kind: WatchErrorKind::Canceled,
watch_id: WatchId::new(watch_id),
compact_revision: None,
message: if reason.is_empty() {
Cow::Borrowed("canceled")
} else {
Cow::Owned(reason)
},
status: None,
backtrace: Backtrace::capture(),
}))
}
fn invalid_response(message: &'static str) -> Self {
Self(Box::new(WatchErrorRepr {
kind: WatchErrorKind::InvalidResponse,
watch_id: None,
compact_revision: None,
message: Cow::Borrowed(message),
status: None,
backtrace: Backtrace::capture(),
}))
}
}
impl WatchError {
fn display_message(&self) -> &str {
if !self.0.message.is_empty() {
&self.0.message
} else if let Some(status) = &self.0.status {
status.message()
} else {
""
}
}
}
impl fmt::Debug for WatchError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("WatchError")
.field("kind", &self.0.kind)
.field("message", &self.display_message())
.field("watch_id", &self.0.watch_id)
.finish()
}
}
impl fmt::Display for WatchError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}: {}", self.0.kind, self.display_message())
}
}
impl std::error::Error for WatchError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
self.0.status.as_ref().map(|s| s as _)
}
}
impl crate::error::OperationError for WatchError {
fn grpc_status(&self) -> Option<&tonic::Status> {
self.0.status.as_ref()
}
fn backtrace(&self) -> &Backtrace {
&self.0.backtrace
}
}
fn watch_metadata_from_pb(kv: &mvccpb::KeyValue) -> Metadata {
let create_revision = Revision::new(kv.create_revision)
.unwrap_or_else(|| Revision::new(kv.mod_revision).expect("mod_revision should be non-zero"));
Metadata {
create_revision,
modified_revision: Revision::new(kv.mod_revision).expect("mod_revision should be non-zero"),
version: Version::new(kv.version as u64),
lease: LeaseId::new(kv.lease),
}
}
fn watch_record_from_pb(kv: mvccpb::KeyValue) -> Record {
let metadata = watch_metadata_from_pb(&kv);
Record::new(kv.key, kv.value, metadata)
}
fn convert_response(resp: etcdserverpb::WatchResponse) -> Vec<Result<WatchEvent, WatchError>> {
if resp.canceled {
let err = if resp.compact_revision != 0 {
WatchError::compacted(resp.watch_id, resp.compact_revision)
} else {
WatchError::canceled(resp.watch_id, resp.cancel_reason)
};
return vec![Err(err)];
}
let header = resp.header.map(ResponseHeader::from_pb);
if resp.events.is_empty() {
if let Some(header) = header {
return vec![Ok(WatchEvent::Progress {
revision: header.revision(),
header,
watch_id: WatchId::new(resp.watch_id),
})];
}
return vec![];
}
let header = header.expect("WatchResponse with events should have a valid header");
let watch_id = WatchId::new(resp.watch_id).expect("server returned watch_id 0");
resp.events
.into_iter()
.map(|event| {
let kv = event
.kv
.ok_or_else(|| WatchError::invalid_response("watch event missing kv field"))?;
let prev_record = event.prev_kv.map(record_from_pb);
if event.r#type == PbEventType::Delete as i32 {
let metadata = watch_metadata_from_pb(&kv);
Ok(WatchEvent::Delete {
header,
watch_id,
key: KeyWithMetadata::new(kv.key, metadata),
prev_record,
})
} else {
let created = kv.create_revision == kv.mod_revision;
let record = watch_record_from_pb(kv);
Ok(WatchEvent::Put {
header,
watch_id,
record,
prev_record,
created,
})
}
})
.collect()
}
#[cfg(test)]
mod test {
use std::time::Duration;
use futures::{FutureExt as _, StreamExt as _};
use super::*;
use crate::pb::etcdserverpb::watch_server::{Watch as WatchService, WatchServer};
struct Scripted {
responses: std::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<etcdserverpb::WatchResponse>>>,
requests: tokio::sync::mpsc::UnboundedSender<etcdserverpb::WatchRequest>,
}
#[tonic::async_trait]
impl WatchService for Scripted {
async fn watch(
self: Arc<Self>,
request: tonic::Request<tonic::Streaming<etcdserverpb::WatchRequest>>,
) -> Result<tonic::Response<tonic::codegen::BoxStream<etcdserverpb::WatchResponse>>, tonic::Status> {
let mut responses = self.responses.lock().unwrap().take().expect("one stream");
let mut incoming = request.into_inner();
let requests = self.requests.clone();
tokio::spawn(async move {
while let Ok(Some(request)) = incoming.message().await {
let _ = requests.send(request);
}
});
Ok(tonic::Response::new(Box::pin(futures::stream::poll_fn(move |cx| {
responses.poll_recv(cx).map(|response| response.map(Ok))
}))))
}
}
async fn scripted_watcher() -> (
Watcher,
tokio::sync::mpsc::UnboundedSender<etcdserverpb::WatchResponse>,
tokio::sync::mpsc::UnboundedReceiver<etcdserverpb::WatchRequest>,
) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let address = listener.local_addr().unwrap();
let (responses, receiver) = tokio::sync::mpsc::unbounded_channel();
let (sender, requests) = tokio::sync::mpsc::unbounded_channel();
tokio::spawn(tonic::transport::Server::builder().serve_with_incoming(
WatchServer::new(Scripted {
responses: std::sync::Mutex::new(Some(receiver)),
requests: sender,
}),
tonic::transport::server::TcpIncoming::from(listener),
));
let client = Client::new(&format!("http://{address}")).unwrap();
(client.watch().prefix("k/").start(), responses, requests)
}
fn header(revision: i64) -> etcdserverpb::ResponseHeader {
etcdserverpb::ResponseHeader {
cluster_id: 1,
member_id: 1,
revision,
raft_term: 1,
}
}
fn created() -> etcdserverpb::WatchResponse {
etcdserverpb::WatchResponse {
header: Some(header(1)),
watch_id: 1,
created: true,
..Default::default()
}
}
fn progress(revision: i64) -> etcdserverpb::WatchResponse {
etcdserverpb::WatchResponse {
header: Some(header(revision)),
watch_id: -1,
..Default::default()
}
}
fn puts(keys: &[&str], fragment: bool) -> etcdserverpb::WatchResponse {
etcdserverpb::WatchResponse {
header: Some(header(2)),
watch_id: 1,
fragment,
events: keys
.iter()
.map(|key| mvccpb::Event {
r#type: PbEventType::Put as i32,
kv: Some(mvccpb::KeyValue {
key: Bytes::copy_from_slice(key.as_bytes()),
create_revision: 2,
mod_revision: 2,
version: 1,
..Default::default()
}),
prev_kv: None,
})
.collect(),
..Default::default()
}
}
fn put_record(item: Option<Result<WatchEvent, WatchError>>) -> Record {
match item {
Some(Ok(WatchEvent::Put { record, .. })) => record,
other => panic!("expected a put, got {other:?}"),
}
}
fn put_key(item: Option<Result<WatchEvent, WatchError>>) -> String {
String::from_utf8(put_record(item).key().to_vec()).unwrap()
}
#[tokio::test]
async fn fragmented_response_is_yielded_once_whole() {
let (mut watcher, responses, _) = scripted_watcher().await;
responses.send(puts(&["k/0"], false)).unwrap();
assert_eq!(put_key(watcher.next().await), "k/0");
responses.send(puts(&["k/1", "k/2"], true)).unwrap();
assert!(
tokio::time::timeout(Duration::from_millis(200), watcher.next())
.await
.is_err()
);
responses.send(puts(&["k/3"], false)).unwrap();
let mut keys = vec![put_key(watcher.next().await)];
while let Some(item) = watcher.next().now_or_never() {
keys.push(put_key(item));
}
assert_eq!(keys, ["k/1", "k/2", "k/3"]);
}
#[tokio::test]
async fn stream_ending_between_fragments_yields_none_of_them() {
let (mut watcher, responses, _) = scripted_watcher().await;
responses.send(puts(&["k/0"], false)).unwrap();
assert_eq!(put_key(watcher.next().await), "k/0");
responses.send(puts(&["k/1", "k/2"], true)).unwrap();
drop(responses);
assert!(watcher.next().await.is_none());
}
#[tokio::test]
async fn interrupted_fragments_are_an_invalid_response() {
let (mut watcher, responses, _) = scripted_watcher().await;
responses.send(puts(&["k/1"], true)).unwrap();
responses
.send(etcdserverpb::WatchResponse {
watch_id: 2,
..puts(&["k/2"], false)
})
.unwrap();
let error = watcher.next().await.unwrap().unwrap_err();
assert_eq!(error.kind(), WatchErrorKind::InvalidResponse);
assert_eq!(put_key(watcher.next().await), "k/2");
}
#[tokio::test]
async fn stream_wide_progress_before_a_created_reply_is_dropped() {
let (mut watcher, responses, mut requests) = scripted_watcher().await;
tokio::select! {
item = watcher.next() => panic!("expected nothing, got {item:?}"),
request = requests.recv() => assert!(
matches!(request.unwrap().request_union, Some(PbRequestUnion::CreateRequest(_)))
),
}
responses.send(progress(2)).unwrap();
responses.send(created()).unwrap();
responses.send(puts(&["k/0"], false)).unwrap();
responses.send(progress(3)).unwrap();
assert_eq!(put_key(watcher.next().await), "k/0");
let item = watcher.next().await;
assert!(
matches!(&item, Some(Ok(WatchEvent::Progress { revision, .. })) if revision.get() == 3),
"expected progress at 3, got {item:?}"
);
}
#[tokio::test]
async fn response_over_4_mib_is_yielded() {
let (mut watcher, responses, _) = scripted_watcher().await;
let keys = (0..50).map(|i| format!("k/{i:02}")).collect::<Vec<_>>();
let mut response = puts(&keys.iter().map(String::as_str).collect::<Vec<_>>(), false);
for (i, event) in response.events.iter_mut().enumerate() {
event.kv.as_mut().unwrap().value = Bytes::from(vec![i as u8; 100 * 1024]);
}
responses.send(response).unwrap();
for (i, key) in keys.iter().enumerate() {
let record = put_record(watcher.next().await);
assert_eq!(record.key(), key.as_bytes());
assert_eq!(record.value().len(), 100 * 1024);
assert!(record.value().iter().all(|&byte| byte == i as u8), "{key}");
}
}
}