Struct rdkafka::producer::future_producer::FutureProducer
[−]
[src]
#[must_use = "Producer polling thread will stop immediately if unused"]pub struct FutureProducer<C: ClientContext + 'static = DefaultClientContext> { /* fields omitted */ }
A producer that returns a Future
for every message being produced.
Since message production in rdkafka is asynchronous, the called cannot immediately know if the
delivery of the message was successful or not. The FutureProducer
provides this information in
a Future
, that will be completed once the information becomes available. This producer has an
internal polling thread and as such it doesn't need to be polled. It can be cheaply cloned to
get a reference to the same underlying producer. The internal will be terminated once the
the FutureProducer
goes out of scope.
Methods
impl<C: ClientContext + 'static> FutureProducer<C>
[src]
pub fn send_copy<P: ?Sized, K: ?Sized>(
&self,
topic: &str,
partition: Option<i32>,
payload: Option<&P>,
key: Option<&K>,
timestamp: Option<i64>,
block_ms: i64
) -> DeliveryFuture where
K: ToBytes,
P: ToBytes,
[src]
&self,
topic: &str,
partition: Option<i32>,
payload: Option<&P>,
key: Option<&K>,
timestamp: Option<i64>,
block_ms: i64
) -> DeliveryFuture where
K: ToBytes,
P: ToBytes,
Sends a copy of the payload and key provided to the specified topic. When no partition is
specified the underlying Kafka library picks a partition based on the key, or a random one
if the key is not specified. Returns a DeliveryFuture
that will eventually contain the
result of the send. The block_ms
parameter will control for how long the producer
is allowed to block if the queue is full. Set it to -1 to block forever, or 0 to never block.
If block_ms
is reached and the queue is still full, a RDKafkaError::QueueFull
will be
reported in the DeliveryFuture
.
pub fn send_copy_result<P: ?Sized, K: ?Sized>(
&self,
topic: &str,
partition: Option<i32>,
payload: Option<&P>,
key: Option<&K>,
timestamp: Option<i64>
) -> KafkaResult<DeliveryFuture> where
K: ToBytes,
P: ToBytes,
[src]
&self,
topic: &str,
partition: Option<i32>,
payload: Option<&P>,
key: Option<&K>,
timestamp: Option<i64>
) -> KafkaResult<DeliveryFuture> where
K: ToBytes,
P: ToBytes,
Sends a copy of the payload and key provided to the specified topic. This works the same
way as send_copy
, the only difference is that it returns an error if enqueuing fails.
pub fn poll<T: Into<Option<Duration>>>(&self, timeout: T)
[src]
Polls the internal producer. This is not normally required since the ThreadedProducer
had
a thread dedicated to calling poll
regularly.
pub fn flush<T: Into<Option<Duration>>>(&self, timeout: T)
[src]
Flushes the producer. Should be called before termination.
pub fn in_flight_count(&self) -> i32
[src]
Returns the number of messages waiting to be sent, or send but not acknowledged yet.
Trait Implementations
impl<C: ClientContext + 'static> Clone for FutureProducer<C>
[src]
fn clone(&self) -> FutureProducer<C>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl FromClientConfig for FutureProducer
[src]
fn from_config(config: &ClientConfig) -> KafkaResult<FutureProducer>
[src]
Create a client from client configuration. The default client context will be used.
impl<C: ClientContext + 'static> FromClientConfigAndContext<C> for FutureProducer<C>
[src]
fn from_config_and_context(
config: &ClientConfig,
context: C
) -> KafkaResult<FutureProducer<C>>
[src]
config: &ClientConfig,
context: C
) -> KafkaResult<FutureProducer<C>>
Create a client from client configuration and a client context.