com.ververica.cdc.debezium.internal

Class Handover

java.lang.Object

com.ververica.cdc.debezium.internal.Handover

All Implemented Interfaces:

Closeable, AutoCloseable

@ThreadSafe
 @Internal
public class Handover
extends Object
implements Closeable

The Handover is a utility to hand over data (a buffer of records) and exception from a producer thread to a consumer thread. It effectively behaves like a "size one blocking queue", with some extras around exception reporting, closing, and waking up thread without interrupting threads.

This class is used in the Flink Debezium Engine Consumer to hand over data and exceptions between the thread that runs the DebeziumEngine class and the main thread.

The Handover can also be "closed", signalling from one thread to the other that it the thread has terminated.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Handover.ClosedException An exception thrown by the Handover in the pollNext() or produce(List) method, after the Handover was closed via close().

Constructor Summary

Constructors

Constructor and Description
Handover()

Method Summary

Modifier and Type	Method and Description
void	close() Closes the handover.
boolean	hasError() Return whether there is an error.
List<io.debezium.engine.ChangeEvent<org.apache.kafka.connect.source.SourceRecord,org.apache.kafka.connect.source.SourceRecord>>	pollNext() Polls the next element from the Handover, possibly blocking until the next element is available.
void	produce(List<io.debezium.engine.ChangeEvent<org.apache.kafka.connect.source.SourceRecord,org.apache.kafka.connect.source.SourceRecord>> element) Hands over an element from the producer.
void	reportError(Throwable t) Reports an exception.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Handover

public Handover()

Method Detail

pollNext

public List<io.debezium.engine.ChangeEvent<org.apache.kafka.connect.source.SourceRecord,org.apache.kafka.connect.source.SourceRecord>> pollNext()
                                                                                                                                         throws Exception

Polls the next element from the Handover, possibly blocking until the next element is available. This method behaves similar to polling from a blocking queue.

If an exception was handed in by the producer (reportError(Throwable)), then that exception is thrown rather than an element being returned.

Returns:

The next element (buffer of records, never null).

Throws:

Handover.ClosedException - Thrown if the Handover was closed.

Exception - Rethrows exceptions from the reportError(Throwable) method.

produce

public void produce(List<io.debezium.engine.ChangeEvent<org.apache.kafka.connect.source.SourceRecord,org.apache.kafka.connect.source.SourceRecord>> element)
             throws InterruptedException

Hands over an element from the producer. If the Handover already has an element that was not yet picked up by the consumer thread, this call blocks until the consumer picks up that previous element.

This behavior is similar to a "size one" blocking queue.

Parameters:

element - The next element to hand over.

Throws:

InterruptedException - Thrown, if the thread is interrupted while blocking for the Handover to be empty.

reportError

public void reportError(Throwable t)

Reports an exception. The consumer will throw the given exception immediately, if it is currently blocked in the pollNext() method, or the next time it calls that method.

After this method has been called, no call to either produce( List) or pollNext() will ever return regularly any more, but will always return exceptionally.

If another exception was already reported, this method does nothing.

For the producer, the Handover will appear as if it was closed.

Parameters:

t - The exception to report.

hasError

public boolean hasError()

Return whether there is an error.

Returns:

whether there is an error

close

public void close()

Closes the handover. Both the produce(List) method and the pollNext() will throw a Handover.ClosedException on any currently blocking and future invocations.

If an exception was previously reported via the reportError(Throwable) method, that exception will not be overridden. The consumer thread will throw that exception upon calling pollNext(), rather than the ClosedException.

Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable