private synchronized CacheEntry<ConnectorStatus> getOrAdd(String connector) { CacheEntry<ConnectorStatus> entry = connectors.get(connector); if (entry == null) { entry = new CacheEntry<>(); connectors.put(connector, entry); } return entry; }
private synchronized void remove(String connector) { CacheEntry<ConnectorStatus> removed = connectors.remove(connector); if (removed != null) removed.delete(); Map<Integer, CacheEntry<TaskStatus>> tasks = this.tasks.remove(connector); if (tasks != null) { for (CacheEntry<TaskStatus> taskEntry : tasks.values()) taskEntry.delete(); } }
@Override public synchronized Collection<TaskStatus> getAll(String connector) { List<TaskStatus> res = new ArrayList<>(); for (CacheEntry<TaskStatus> statusEntry : tasks.row(connector).values()) { TaskStatus status = statusEntry.get(); if (status != null) res.add(status); } return res; }
private <V extends AbstractStatus> void send(final String key, final V status, final CacheEntry<V> entry, final boolean safeWrite) { final int sequence; synchronized (this) { this.generation = status.generation(); if (safeWrite && !entry.canWriteSafely(status)) return; sequence = entry.increment(); } final byte[] value = status.state() == ConnectorStatus.State.DESTROYED ? null : serialize(status); kafkaLog.send(key, value, new org.apache.kafka.clients.producer.Callback() { @Override public void onCompletion(RecordMetadata metadata, Exception exception) { if (exception == null) return; if (exception instanceof RetriableException) { synchronized (KafkaStatusBackingStore.this) { if (entry.isDeleted() || status.generation() != generation || (safeWrite && !entry.canWriteSafely(status, sequence))) return; } kafkaLog.send(key, value, this); } else { log.error("Failed to write status update", exception); } } }); }
private void readTaskStatus(String key, byte[] value) { ConnectorTaskId id = parseConnectorTaskId(key); if (id == null) { log.warn("Discarding record with invalid task status key {}", key); return; } if (value == null) { log.trace("Removing task status for {}", id); remove(id); return; } TaskStatus status = parseTaskStatus(id, value); if (status == null) { log.warn("Failed to parse task status with key {}", key); return; } synchronized (this) { log.trace("Received task {} status update {}", id, status); CacheEntry<TaskStatus> entry = getOrAdd(id); entry.put(status); } }
private void readConnectorStatus(String key, byte[] value) { String connector = parseConnectorStatusKey(key); if (connector == null || connector.isEmpty()) { log.warn("Discarding record with invalid connector status key {}", key); return; } if (value == null) { log.trace("Removing status for connector {}", connector); remove(connector); return; } ConnectorStatus status = parseConnectorStatus(connector, value); if (status == null) return; synchronized (this) { log.trace("Received connector {} status update {}", connector, status); CacheEntry<ConnectorStatus> entry = getOrAdd(connector); entry.put(status); } }
@Override public void onCompletion(RecordMetadata metadata, Exception exception) { if (exception == null) return; if (exception instanceof RetriableException) { synchronized (KafkaStatusBackingStore.this) { if (entry.isDeleted() || status.generation() != generation || (safeWrite && !entry.canWriteSafely(status, sequence))) return; } kafkaLog.send(key, value, this); } else { log.error("Failed to write status update", exception); } } });
public boolean canWriteSafely(T status, int sequence) { return canWriteSafely(status) && this.sequence == sequence; }
@Override public synchronized TaskStatus get(ConnectorTaskId id) { CacheEntry<TaskStatus> entry = tasks.get(id.connector(), id.task()); return entry == null ? null : entry.get(); }
private synchronized void remove(ConnectorTaskId id) { CacheEntry<TaskStatus> removed = tasks.remove(id.connector(), id.task()); if (removed != null) removed.delete(); }
private synchronized CacheEntry<TaskStatus> getOrAdd(ConnectorTaskId task) { CacheEntry<TaskStatus> entry = tasks.get(task.connector(), task.task()); if (entry == null) { entry = new CacheEntry<>(); tasks.put(task.connector(), task.task(), entry); } return entry; }
@Override public synchronized ConnectorStatus get(String connector) { CacheEntry<ConnectorStatus> entry = connectors.get(connector); return entry == null ? null : entry.get(); }