private void tryDelete(AdminClient adminClient, String topic) throws Exception { try { adminClient.deleteTopics(Collections.singleton(topic)).all().get(DELETE_TIMEOUT_SECONDS, TimeUnit.SECONDS); } catch (TimeoutException e) { LOG.info("Did not receive delete topic response within %d seconds. Checking if it succeeded", DELETE_TIMEOUT_SECONDS); if (adminClient.listTopics().names().get(DELETE_TIMEOUT_SECONDS, TimeUnit.SECONDS).contains(topic)) { throw new Exception("Topic still exists after timeout"); } } }
runnable.call(call, now); return new DeleteTopicsResult(new HashMap<>(topicFutures));
@Test public void testInvalidTopicNames() throws Exception { try (AdminClientUnitTestEnv env = mockClientEnv()) { env.kafkaClient().setNodeApiVersions(NodeApiVersions.create()); List<String> sillyTopicNames = asList("", null); Map<String, KafkaFuture<Void>> deleteFutures = env.adminClient().deleteTopics(sillyTopicNames).values(); for (String sillyTopicName : sillyTopicNames) { TestUtils.assertFutureError(deleteFutures.get(sillyTopicName), InvalidTopicException.class); } assertEquals(0, env.kafkaClient().inFlightRequestCount()); Map<String, KafkaFuture<TopicDescription>> describeFutures = env.adminClient().describeTopics(sillyTopicNames).values(); for (String sillyTopicName : sillyTopicNames) { TestUtils.assertFutureError(describeFutures.get(sillyTopicName), InvalidTopicException.class); } assertEquals(0, env.kafkaClient().inFlightRequestCount()); List<NewTopic> newTopics = new ArrayList<>(); for (String sillyTopicName : sillyTopicNames) { newTopics.add(new NewTopic(sillyTopicName, 1, (short) 1)); } Map<String, KafkaFuture<Void>> createFutures = env.adminClient().createTopics(newTopics).values(); for (String sillyTopicName : sillyTopicNames) { TestUtils.assertFutureError(createFutures .get(sillyTopicName), InvalidTopicException.class); } assertEquals(0, env.kafkaClient().inFlightRequestCount()); } }
public void deleteTopic(String name) { if (topics().contains(name)) { log.warn("Deleting topic. name: {}", name); DeleteTopicsResult result = adminClient.deleteTopics(singleton(name)); try { result.all().get(); log.warn("Deleted topic. name: {}, result: {}", name, result); deletedTopics.inc(result.values().size()); } catch (InterruptedException | ExecutionException e) { log.error("Exception occured during topic deletion. name: {}", name, e); } } }
public void doDelete(final List<String> topicsToDelete, final AdminClient adminClient) { boolean hasDeleteErrors = false; final DeleteTopicsResult deleteTopicsResult = adminClient.deleteTopics(topicsToDelete); final Map<String, KafkaFuture<Void>> results = deleteTopicsResult.values(); for (final Map.Entry<String, KafkaFuture<Void>> entry : results.entrySet()) { try { entry.getValue().get(30, TimeUnit.SECONDS); } catch (Exception e) { System.err.println("ERROR: deleting topic " + entry.getKey()); e.printStackTrace(System.err); hasDeleteErrors = true; } } if (hasDeleteErrors) { throw new RuntimeException("Encountered an error deleting one or more topics"); } }
public void doDelete(final List<String> topicsToDelete, final AdminClient adminClient) { boolean hasDeleteErrors = false; final DeleteTopicsResult deleteTopicsResult = adminClient.deleteTopics(topicsToDelete); final Map<String, KafkaFuture<Void>> results = deleteTopicsResult.values(); for (final Map.Entry<String, KafkaFuture<Void>> entry : results.entrySet()) { try { entry.getValue().get(30, TimeUnit.SECONDS); } catch (Exception e) { System.err.println("ERROR: deleting topic " + entry.getKey()); e.printStackTrace(System.err); hasDeleteErrors = true; } } if (hasDeleteErrors) { throw new RuntimeException("Encountered an error deleting one or more topics"); } }
@Test public void testDeleteTopics() throws Exception { try (AdminClientUnitTestEnv env = mockClientEnv()) { env.kafkaClient().setNodeApiVersions(NodeApiVersions.create()); env.kafkaClient().prepareResponse(body -> body instanceof DeleteTopicsRequest, new DeleteTopicsResponse(Collections.singletonMap("myTopic", Errors.NONE))); KafkaFuture<Void> future = env.adminClient().deleteTopics(Collections.singletonList("myTopic"), new DeleteTopicsOptions()).all(); future.get(); env.kafkaClient().prepareResponse(body -> body instanceof DeleteTopicsRequest, new DeleteTopicsResponse(Collections.singletonMap("myTopic", Errors.TOPIC_DELETION_DISABLED))); future = env.adminClient().deleteTopics(Collections.singletonList("myTopic"), new DeleteTopicsOptions()).all(); TestUtils.assertFutureError(future, TopicDeletionDisabledException.class); env.kafkaClient().prepareResponse(body -> body instanceof DeleteTopicsRequest, new DeleteTopicsResponse(Collections.singletonMap("myTopic", Errors.UNKNOWN_TOPIC_OR_PARTITION))); future = env.adminClient().deleteTopics(Collections.singletonList("myTopic"), new DeleteTopicsOptions()).all(); TestUtils.assertFutureError(future, UnknownTopicOrPartitionException.class); } }
@Override public DeleteTopicsResult deleteTopics(Collection<String> topicsToDelete, DeleteTopicsOptions options) { Map<String, KafkaFuture<Void>> deleteTopicsResult = new HashMap<>(); if (timeoutNextRequests > 0) { for (final String topicName : topicsToDelete) { KafkaFutureImpl<Void> future = new KafkaFutureImpl<>(); future.completeExceptionally(new TimeoutException()); deleteTopicsResult.put(topicName, future); } --timeoutNextRequests; return new DeleteTopicsResult(deleteTopicsResult); } for (final String topicName : topicsToDelete) { KafkaFutureImpl<Void> future = new KafkaFutureImpl<>(); if (allTopics.remove(topicName) == null) { future.completeExceptionally(new UnknownTopicOrPartitionException(String.format("Topic %s does not exist.", topicName))); } else { future.complete(null); } deleteTopicsResult.put(topicName, future); } return new DeleteTopicsResult(deleteTopicsResult); }
public void doDelete(final List<String> topicsToDelete, final AdminClient adminClient) { boolean hasDeleteErrors = false; final DeleteTopicsResult deleteTopicsResult = adminClient.deleteTopics(topicsToDelete); final Map<String, KafkaFuture<Void>> results = deleteTopicsResult.values(); for (final Map.Entry<String, KafkaFuture<Void>> entry : results.entrySet()) { try { entry.getValue().get(30, TimeUnit.SECONDS); } catch (Exception e) { System.err.println("ERROR: deleting topic " + entry.getKey()); e.printStackTrace(System.err); hasDeleteErrors = true; } } if (hasDeleteErrors) { throw new RuntimeException("Encountered an error deleting one or more topics"); } }
@Override public boolean clearStream(StreamSpec streamSpec) { LOG.info("Creating Kafka topic: {} on system: {}", streamSpec.getPhysicalName(), streamSpec.getSystemName()); String topicName = streamSpec.getPhysicalName(); try { DeleteTopicsResult deleteTopicsResult = adminClient.deleteTopics(ImmutableSet.of(topicName)); deleteTopicsResult.all().get(KAFKA_ADMIN_OPS_TIMEOUT_MS, TimeUnit.MILLISECONDS); } catch (Exception e) { LOG.error("Failed to delete topic {} with exception {}.", topicName, e); return false; } return true; }
public void doDelete(final List<String> topicsToDelete, final AdminClient adminClient) { boolean hasDeleteErrors = false; final DeleteTopicsResult deleteTopicsResult = adminClient.deleteTopics(topicsToDelete); final Map<String, KafkaFuture<Void>> results = deleteTopicsResult.values(); for (final Map.Entry<String, KafkaFuture<Void>> entry : results.entrySet()) { try { entry.getValue().get(30, TimeUnit.SECONDS); } catch (Exception e) { System.err.println("ERROR: deleting topic " + entry.getKey()); e.printStackTrace(System.err); hasDeleteErrors = true; } } if (hasDeleteErrors) { throw new RuntimeException("Encountered an error deleting one or more topics"); } }
/** * Delete a topic via the Kafka AdminClient API, calling the given handler * (in a different thread) with the result. */ @Override public void deleteTopic(TopicName topicName, Handler<AsyncResult<Void>> handler) { LOGGER.debug("Deleting topic {}", topicName); KafkaFuture<Void> future = adminClient.deleteTopics( Collections.singleton(topicName.toString())).values().get(topicName.toString()); queueWork(new UniWork<>("deleteTopic", future, handler)); }