AbstractReader (Debezium Connector for MySQL 0.8.0.Final API)

java.lang.Object
- io.debezium.connector.mysql.AbstractReader

All Implemented Interfaces:

Reader

Direct Known Subclasses:

BinlogReader, SnapshotReader
```
public abstract class AbstractReader
extends Object
implements Reader
```
A component that performs a snapshot of a MySQL server, and records the schema changes in MySqlSchema.

Author:

Randall Hauch

Nested Class Summary
- Nested classes/interfaces inherited from interface io.debezium.connector.mysql.Reader
  Reader.State

Field Summary

Fields
Modifier and Type	Field and Description
`protected MySqlJdbcContext`	`connectionContext`
`protected MySqlTaskContext`	`context`
`private AtomicReference<org.apache.kafka.connect.errors.ConnectException>`	`failure`
`private org.apache.kafka.connect.errors.ConnectException`	`failureException`
`protected org.slf4j.Logger`	`logger`
`private int`	`maxBatchSize`
`private Metronome`	`metronome`
`private String`	`name`
`private Duration`	`pollInterval`
`private BlockingQueue<org.apache.kafka.connect.source.SourceRecord>`	`records`
`private AtomicBoolean`	`running`
`private AtomicBoolean`	`success`
`private AtomicReference<Runnable>`	`uponCompletion`

Constructor Summary

Constructors
Constructor and Description

AbstractReader(String name, MySqlTaskContext context)
Create a snapshot reader.

Constructors
Constructor and Description
`AbstractReader(String name, MySqlTaskContext context)` Create a snapshot reader.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`cleanupResources()` This method is normally called by `poll()` when there this reader finishes normally and all generated records are consumed prior to being `stopped`.
`protected void`	`completeSuccessfully()` Call this method only when the reader has successfully completed all of its work, signaling that subsequent calls to `poll()` should forever return `null` and that this reader should transition from `Reader.State.STOPPING` to `Reader.State.STOPPED`.
`void`	`destroy()` After the reader has stopped, there may still be some resources we want left available until the connector task is destroyed.
`protected abstract void`	`doCleanup()` The reader has completed all processing and all `enqueued records` have been `consumed`, so this reader should clean up any resources that might remain.
`protected void`	`doDestroy()` The reader has been requested to de-initialize resources after stopping.
`protected void`	`doInitialize()` The reader has been requested to initialize resources prior to starting.
`protected abstract void`	`doStart()` The reader has been requested to start, so initialize any un-initialized resources required by the reader.
`protected abstract void`	`doStop()` The reader has been requested to stop, so perform any work required to stop the reader's resources that were previously `started`.
`protected void`	`enqueueRecord(org.apache.kafka.connect.source.SourceRecord record)` Enqueue a record so that it can be obtained when this reader is `polled`.
`protected void`	`failed(Throwable error)` Call this method only when the reader has failed, that a subsequent call to `poll()` should throw this error, and that `doCleanup()` can be called at any time.
`protected void`	`failed(Throwable error, String msg)` Call this method only when the reader has failed, that a subsequent call to `poll()` should throw this error, and that `doCleanup()` can be called at any time.
`void`	`initialize()` Perform any initialization of the reader before being started.
`protected boolean`	`isRunning()`
`String`	`name()` Get the name of this reader.
`List<org.apache.kafka.connect.source.SourceRecord>`	`poll()` Poll for the next batch of source records.
`protected void`	`pollComplete(List<org.apache.kafka.connect.source.SourceRecord> batch)` Method called when `poll()` completes sending a non-zero-sized batch of records.
`void`	`start()` Start the reader and return immediately.
`Reader.State`	`state()` Get the current state of this reader.
`void`	`stop()` Stop the reader from running and transition to the `Reader.State.STOPPING` state until all remaining records are `consumed`, at which point its state transitions to `Reader.State.STOPPED`.
`void`	`uponCompletion(Runnable handler)` Set the function that should be called when this reader transitions from the `Reader.State.STOPPING` to `Reader.State.STOPPED` state, which is after all generated records have been consumed via the `poll` method.
`protected org.apache.kafka.connect.errors.ConnectException`	`wrap(Throwable error)` Wraps the specified exception in a `ConnectException`, ensuring that all useful state is captured inside the new exception's message.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - logger
```
protected final org.slf4j.Logger logger
```
  - name
```
private final String name
```
  - context
```
protected final MySqlTaskContext context
```
  - connectionContext
```
protected final MySqlJdbcContext connectionContext
```
  - records
```
private final BlockingQueue<org.apache.kafka.connect.source.SourceRecord> records
```
  - running
```
private final AtomicBoolean running
```
  - success
```
private final AtomicBoolean success
```
  - failure
```
private final AtomicReference<org.apache.kafka.connect.errors.ConnectException> failure
```
  - failureException
```
private org.apache.kafka.connect.errors.ConnectException failureException
```
  - maxBatchSize
```
private final int maxBatchSize
```
  - metronome
```
private final Metronome metronome
```
  - uponCompletion
```
private final AtomicReference<Runnable> uponCompletion
```
  - pollInterval
```
private final Duration pollInterval
```
- Constructor Detail
  - AbstractReader
```
public AbstractReader(String name,
                      MySqlTaskContext context)
```
    Create a snapshot reader.
    
    Parameters:
    
    name - the name of the reader
    
    context - the task context in which this reader is running; may not be null
- Method Detail
  - name
```
public String name()
```
    Description copied from interface: Reader
    
    Get the name of this reader.
    
    Specified by:
    
    name in interface Reader
    
    Returns:
    
    the reader's name; never null
  - uponCompletion
```
public void uponCompletion(Runnable handler)
```
    Description copied from interface: Reader
    
    Set the function that should be called when this reader transitions from the Reader.State.STOPPING to Reader.State.STOPPED state, which is after all generated records have been consumed via the poll method.
    This method should only be called while the reader is in the Reader.State.STOPPED state.
    
    Specified by:
    
    uponCompletion in interface Reader
    
    Parameters:
    
    handler - the function; may not be null
  - initialize
```
public final void initialize()
```
    Description copied from interface: Reader
    
    Perform any initialization of the reader before being started. This method should be called exactly once before Reader.start() is called, and it should block until all initialization is completed.
    
    Specified by:
    
    initialize in interface Reader
  - destroy
```
public final void destroy()
```
    Description copied from interface: Reader
    
    After the reader has stopped, there may still be some resources we want left available until the connector task is destroyed. This method is used to clean up those remaining resources upon shutdown. This method is effectively the opposite of Reader.initialize(), performing any de-initialization of the reader entity before shutdown. This method should be called exactly once after Reader.stop() is called, and it should block until all de-initialization is completed.
    
    Specified by:
    
    destroy in interface Reader
  - start
```
public void start()
```
    Description copied from interface: Reader
    
    Start the reader and return immediately. Once started, the SourceRecords generated by the reader can be obtained by periodically calling Reader.poll() until that method returns null.
    This method does nothing if it is already running.
    
    Specified by:
    
    start in interface Reader
  - stop
```
public void stop()
```
    Description copied from interface: Reader
    
    Stop the reader from running and transition to the Reader.State.STOPPING state until all remaining records are consumed, at which point its state transitions to Reader.State.STOPPED.
    
    Specified by:
    
    stop in interface Reader
  - doInitialize
```
protected void doInitialize()
```
    The reader has been requested to initialize resources prior to starting. This should only be called once before doStart().
  - doDestroy
```
protected void doDestroy()
```
    The reader has been requested to de-initialize resources after stopping. This should only be called once after doStop().
  - doStart
```
protected abstract void doStart()
```
    The reader has been requested to start, so initialize any un-initialized resources required by the reader.
  - doStop
```
protected abstract void doStop()
```
    The reader has been requested to stop, so perform any work required to stop the reader's resources that were previously started.
    This method is always called when stop() is called, and the first time isRunning() will return true the first time and false for any subsequent calls.
  - doCleanup
```
protected abstract void doCleanup()
```
    The reader has completed all processing and all enqueued records have been consumed, so this reader should clean up any resources that might remain.
  - completeSuccessfully
```
protected void completeSuccessfully()
```
    Call this method only when the reader has successfully completed all of its work, signaling that subsequent calls to poll() should forever return null and that this reader should transition from Reader.State.STOPPING to Reader.State.STOPPED.
  - failed
```
protected void failed(Throwable error)
```
    Call this method only when the reader has failed, that a subsequent call to poll() should throw this error, and that doCleanup() can be called at any time.
    
    Parameters:
    
    error - the error that resulted in the failure; should not be null
  - failed
```
protected void failed(Throwable error,
                      String msg)
```
    Call this method only when the reader has failed, that a subsequent call to poll() should throw this error, and that doCleanup() can be called at any time.
    
    Parameters:
    
    error - the error that resulted in the failure; should not be null
    
    msg - the error message; may not be null
  - wrap
```
protected org.apache.kafka.connect.errors.ConnectException wrap(Throwable error)
```
    Wraps the specified exception in a ConnectException, ensuring that all useful state is captured inside the new exception's message.
    
    Parameters:
    
    error - the exception; may not be null
    
    Returns:
    
    the wrapped Kafka Connect exception
  - state
```
public Reader.State state()
```
    Description copied from interface: Reader
    
    Get the current state of this reader.
    
    Specified by:
    
    state in interface Reader
    
    Returns:
    
    the state; never null
  - isRunning
```
protected boolean isRunning()
```
  - poll
```
public List<org.apache.kafka.connect.source.SourceRecord> poll()
                                                        throws InterruptedException
```
    Description copied from interface: Reader
    
    Poll for the next batch of source records. This method returns null only when all records generated by this reader have been processed, following the natural or explicit stopping of this reader. Note that this method may block if no additional records are available but the reader may produce more, thus callers should call this method continually until this method returns null.
    
    Specified by:
    
    poll in interface Reader
    
    Returns:
    
    the list of source records that may or may not be empty; or null when there will be no more records because the reader has completely Reader.State.STOPPED.
    
    Throws:
    
    InterruptedException - if this thread is interrupted while waiting for more records
  - cleanupResources
```
protected void cleanupResources()
```
    This method is normally called by poll() when there this reader finishes normally and all generated records are consumed prior to being stopped. However, if this reader is explicitly stopped while still working, then subclasses should call this method when they have completed all of their shutdown work.
  - pollComplete
```
protected void pollComplete(List<org.apache.kafka.connect.source.SourceRecord> batch)
```
    Method called when poll() completes sending a non-zero-sized batch of records.
    
    Parameters:
    
    batch - the batch of records being recorded
  - enqueueRecord
```
protected void enqueueRecord(org.apache.kafka.connect.source.SourceRecord record)
                      throws InterruptedException
```
    Enqueue a record so that it can be obtained when this reader is polled. This method will block if the queue is full.
    
    Parameters:
    
    record - the record to be enqueued
    
    Throws:
    
    InterruptedException - if interrupted while waiting for the queue to have room for this record

Class AbstractReader

Nested Class Summary

Nested classes/interfaces inherited from interface io.debezium.connector.mysql.Reader

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

logger

name

context

connectionContext

records

running

success

failure

failureException

maxBatchSize

metronome

uponCompletion

pollInterval

Constructor Detail

AbstractReader

Method Detail

name

uponCompletion

initialize

destroy

start

stop

doInitialize

doDestroy

doStart

doStop

doCleanup

completeSuccessfully

failed

failed

wrap

state

isRunning

poll

cleanupResources

pollComplete

enqueueRecord