1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
use std::fmt::Debug;
use std::marker::PhantomData;
use fluvio_protocol::api::Request;
use fluvio_protocol::{Decoder, Encoder};
use fluvio_protocol::derive::FluvioDefault;
use fluvio_protocol::record::RecordSet;
use fluvio_types::PartitionId;
use crate::COMMON_VERSION;
use crate::isolation::Isolation;
use super::FetchResponse;
pub type DefaultFetchRequest = FetchRequest<RecordSet>;
#[derive(Encoder, Decoder, FluvioDefault, Debug)]
pub struct FetchRequest<R> {
/// The maximum time in milliseconds to wait for the response.
pub max_wait: i32,
/// The minimum bytes to accumulate in the response.
pub min_bytes: i32,
/// The maximum bytes to fetch. See KIP-74 for cases where this limit may not be honored.
#[fluvio(min_version = 3, ignorable)]
pub max_bytes: i32,
/// This setting controls the visibility of transactional records. Using READ_UNCOMMITTED
/// (isolation_level = 0) makes all records visible. With READ_COMMITTED (isolation_level = 1),
/// non-transactional and COMMITTED transactional records are visible. To be more concrete,
/// READ_COMMITTED returns all data from offsets smaller than the current LSO (last stable
/// offset), and enables the inclusion of the list of aborted transactions in the result, which
/// allows consumers to discard ABORTED transactional records
#[fluvio(min_version = 4)]
pub isolation_level: Isolation,
/// The topics to fetch.
pub topics: Vec<FetchableTopic>,
/// In an incremental fetch request, the partitions to remove.
#[fluvio(min_version = 7)]
pub forgotten: Vec<ForgottenTopic>,
pub data: PhantomData<R>,
}
impl<R> Request for FetchRequest<R>
where
R: Debug + Decoder + Encoder,
{
const API_KEY: u16 = 1;
const MIN_API_VERSION: i16 = 0;
const DEFAULT_API_VERSION: i16 = COMMON_VERSION;
type Response = FetchResponse<R>;
}
#[derive(Encoder, Decoder, FluvioDefault, Debug)]
pub struct FetchableTopic {
/// The name of the topic to fetch.
pub name: String,
/// The partitions to fetch.
pub fetch_partitions: Vec<FetchPartition>,
}
#[derive(Encoder, Decoder, FluvioDefault, Debug)]
pub struct ForgottenTopic {
/// The partition name.
#[fluvio(min_version = 7)]
pub name: String,
/// The partitions indexes to forget.
#[fluvio(min_version = 7)]
pub forgotten_partition_indexes: Vec<i32>,
}
#[derive(Encoder, Decoder, FluvioDefault, Debug)]
pub struct FetchPartition {
/// The partition index.
pub partition_index: PartitionId,
/// The current leader epoch of the partition.
#[fluvio(min_version = 9, ignorable)]
pub current_leader_epoch: i32,
/// The message offset.
pub fetch_offset: i64,
/// The earliest available offset of the follower replica. The field is only used when the
/// request is sent by the follower.
#[fluvio(min_version = 5)]
pub log_start_offset: i64,
/// The maximum bytes to fetch from this partition. See KIP-74 for cases where this limit may
/// not be honored.
pub max_bytes: i32,
}
#[cfg(feature = "file")]
pub use file::*;
#[cfg(feature = "file")]
mod file {
use super::*;
use crate::file::FileRecordSet;
pub type FileFetchRequest = FetchRequest<FileRecordSet>;
}