com.landoop.lenses.topology.client.kafka.metrics.CallbackConsumer Maven / Gradle / Ivy

Go to download
package com.landoop.lenses.topology.client.kafka.metrics;

import com.landoop.lenses.topology.client.Publisher;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.clients.consumer.OffsetAndTimestamp;
import org.apache.kafka.clients.consumer.OffsetCommitCallback;
import org.apache.kafka.common.Metric;
import org.apache.kafka.common.MetricName;
import org.apache.kafka.common.PartitionInfo;
import org.apache.kafka.common.TopicPartition;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;

/**
 * An implementation of {@link Publisher} which will invoke a supplied
 * callback when the underlying producer is closed.
 */
public class CallbackConsumer implements Consumer {

    private final Consumer consumer;
    private final Runnable callback;

    public CallbackConsumer(Consumer consumer, Runnable callback) {
        this.consumer = consumer;
        this.callback = callback;
    }

    @Override
    public Set assignment() {
        return consumer.assignment();
    }

    @Override
    public Set subscription() {
        return consumer.subscription();
    }

    @Override
    public void subscribe(Collection collection) {
        consumer.subscribe(collection);
    }

    @Override
    public void subscribe(Collection collection, ConsumerRebalanceListener consumerRebalanceListener) {
        consumer.subscribe(collection, consumerRebalanceListener);
    }

    @Override
    public void assign(Collection collection) {
        consumer.assign(collection);
    }

    @Override
    public void subscribe(Pattern pattern, ConsumerRebalanceListener consumerRebalanceListener) {
        consumer.subscribe(pattern, consumerRebalanceListener);
    }

    @Override
    public void subscribe(Pattern pattern) {
        consumer.subscribe(pattern);
    }

    @Override
    public void unsubscribe() {
        consumer.unsubscribe();
    }

    @Override
    public ConsumerRecords poll(long l) {
        return consumer.poll(l);
    }

    @Override
    public void commitSync() {
        consumer.commitSync();
    }

    @Override
    public void commitSync(Map map) {
        consumer.commitSync(map);
    }

    @Override
    public void commitAsync() {
        consumer.commitAsync();
    }

    @Override
    public void commitAsync(OffsetCommitCallback offsetCommitCallback) {
        consumer.commitAsync(offsetCommitCallback);
    }

    @Override
    public void commitAsync(Map map, OffsetCommitCallback offsetCommitCallback) {
        consumer.commitAsync(map, offsetCommitCallback);
    }

    @Override
    public void seek(TopicPartition topicPartition, long l) {
        consumer.seek(topicPartition, l);
    }

    @Override
    public void seekToBeginning(Collection collection) {
        consumer.seekToBeginning(collection);
    }

    @Override
    public void seekToEnd(Collection collection) {
        consumer.seekToEnd(collection);
    }

    @Override
    public long position(TopicPartition topicPartition) {
        return consumer.position(topicPartition);
    }

    @Override
    public OffsetAndMetadata committed(TopicPartition topicPartition) {
        return consumer.committed(topicPartition);
    }

    @Override
    public Map metrics() {
        return consumer.metrics();
    }

    @Override
    public List partitionsFor(String s) {
        return consumer.partitionsFor(s);
    }

    @Override
    public Map> listTopics() {
        return consumer.listTopics();
    }

    @Override
    public Set paused() {
        return consumer.paused();
    }

    @Override
    public void pause(Collection collection) {
        consumer.pause(collection);
    }

    @Override
    public void resume(Collection collection) {
        consumer.resume(collection);
    }

    @Override
    public Map offsetsForTimes(Map map) {
        return consumer.offsetsForTimes(map);
    }

    @Override
    public Map beginningOffsets(Collection collection) {
        return consumer.beginningOffsets(collection);
    }

    @Override
    public Map endOffsets(Collection collection) {
        return consumer.endOffsets(collection);
    }

    @Override
    public void close() {
        consumer.close();
        callback.run();
    }

    @Override
    public void close(long l, TimeUnit timeUnit) {
        consumer.close(l, timeUnit);
        callback.run();
    }

    @Override
    public void wakeup() {
        consumer.wakeup();
    }

}