1 package de.juplo.kafka;
3 import lombok.RequiredArgsConstructor;
4 import lombok.extern.slf4j.Slf4j;
5 import org.apache.kafka.clients.consumer.Consumer;
6 import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
7 import org.apache.kafka.clients.consumer.ConsumerRecord;
8 import org.apache.kafka.clients.consumer.ConsumerRecords;
9 import org.apache.kafka.common.TopicPartition;
10 import org.apache.kafka.common.errors.RecordDeserializationException;
11 import org.apache.kafka.common.errors.WakeupException;
13 import javax.annotation.PreDestroy;
14 import java.time.Duration;
16 import java.util.concurrent.ExecutionException;
17 import java.util.concurrent.ExecutorService;
18 import java.util.concurrent.locks.Condition;
19 import java.util.concurrent.locks.Lock;
20 import java.util.concurrent.locks.ReentrantLock;
24 @RequiredArgsConstructor
25 public class EndlessConsumer<K, V> implements ConsumerRebalanceListener, Runnable
27 private final ExecutorService executor;
28 private final String id;
29 private final String topic;
30 private final Consumer<K, V> consumer;
31 private final RecordHandler handler;
33 private final Lock lock = new ReentrantLock();
34 private final Condition condition = lock.newCondition();
35 private boolean running = false;
36 private Exception exception;
37 private long consumed = 0;
39 private final Map<Integer, Map<String, Long>> seen = new HashMap<>();
40 private final Map<Integer, Long> offsets = new HashMap<>();
44 public void onPartitionsRevoked(Collection<TopicPartition> partitions)
46 partitions.forEach(tp ->
48 Integer partition = tp.partition();
49 Long newOffset = consumer.position(tp);
50 Long oldOffset = offsets.remove(partition);
52 "{} - removing partition: {}, consumed {} records (offset {} -> {})",
55 newOffset - oldOffset,
58 Map<String, Long> removed = seen.remove(partition);
59 for (String key : removed.keySet())
62 "{} - Seen {} messages for partition={}|key={}",
72 public void onPartitionsAssigned(Collection<TopicPartition> partitions)
74 partitions.forEach(tp ->
76 Integer partition = tp.partition();
77 Long offset = consumer.position(tp);
78 log.info("{} - adding partition: {}, offset={}", id, partition, offset);
79 offsets.put(partition, offset);
80 seen.put(partition, new HashMap<>());
90 log.info("{} - Subscribing to topic {}", id, topic);
91 consumer.subscribe(Arrays.asList(topic), this);
95 ConsumerRecords<K, V> records =
96 consumer.poll(Duration.ofSeconds(1));
98 // Do something with the data...
99 log.info("{} - Received {} messages", id, records.count());
100 for (ConsumerRecord<K, V> record : records)
103 "{} - {}: {}/{} - {}={}",
112 handler.accept(record);
116 Integer partition = record.partition();
117 String key = record.key() == null ? "NULL" : record.key().toString();
118 Map<String, Long> byKey = seen.get(partition);
120 if (!byKey.containsKey(key))
123 long seenByKey = byKey.get(key);
125 byKey.put(key, seenByKey);
129 catch(WakeupException e)
131 log.info("{} - RIIING! Request to stop consumption - commiting current offsets!", id);
132 consumer.commitSync();
135 catch(RecordDeserializationException e)
137 TopicPartition tp = e.topicPartition();
138 long offset = e.offset();
140 "{} - Could not deserialize message on topic {} with offset={}: {}",
144 e.getCause().toString());
146 consumer.commitSync();
151 log.error("{} - Unexpected error: {}", id, e.toString(), e);
156 log.info("{} - Consumer-Thread exiting", id);
160 private void shutdown()
165 private void shutdown(Exception e)
172 log.info("{} - Unsubscribing from topic {}", id, topic);
173 consumer.unsubscribe();
178 "{} - Error while unsubscribing from topic {}: {}",
196 public Map<Integer, Map<String, Long>> getSeen()
207 throw new IllegalStateException("Consumer instance " + id + " is already running!");
209 log.info("{} - Starting - consumed {} messages before", id, consumed);
212 executor.submit(this);
220 public synchronized void stop() throws ExecutionException, InterruptedException
226 throw new IllegalStateException("Consumer instance " + id + " is not running!");
228 log.info("{} - Stopping", id);
231 log.info("{} - Stopped - consumed {} messages so far", id, consumed);
240 public void destroy() throws ExecutionException, InterruptedException
242 log.info("{} - Destroy!", id);
247 catch (IllegalStateException e)
249 log.info("{} - Was already stopped", id);
253 log.error("{} - Unexpected exception while trying to stop the consumer", id, e);
257 log.info("{}: Consumed {} messages in total, exiting!", id, consumed);
261 public boolean running()
274 public Optional<Exception> exitStatus()
280 throw new IllegalStateException("No exit-status available: Consumer instance " + id + " is running!");
282 return Optional.ofNullable(exception);