Java AdminUtils.deleteTopic方法代码示例

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
/**
 * Deletes the named topics
 * @param topicNames The names of the topics to delete
 * @return A set of the names of the topics that were successfully deleted
 */
public String[] deleteTopics(final String...topicNames) {
	if(!connected.get()) throw new IllegalStateException("The KafkaTestServer is not running");
	if(topicNames==null || topicNames.length==0) return new String[0];
	final Set<String> deleted = new LinkedHashSet<String>();
	for(String topicName: topicNames) {
		if(topicName==null || topicName.trim().isEmpty()) {
			try {
				AdminUtils.deleteTopic(zkUtils, topicName.trim());
				deleted.add(topicName.trim());
			} catch (Exception ex) {
				log.warn("Failed to delete topic [" + topicName.trim() + "]", ex);
			}
		}
	}
	return deleted.toArray(new String[deleted.size()]);
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
/**
 * Deletes the named topics
 * @param topicNames The names of the topics to delete
 * @return A set of the names of the topics that were successfully deleted
 */
public String[] deleteTopics(final String...topicNames) {
	if(!running.get()) throw new IllegalStateException("The KafkaTestServer is not running");
	if(topicNames==null || topicNames.length==0) return new String[0];
	final Set<String> deleted = new LinkedHashSet<String>();
	final ZkUtils z = getZkUtils();
	for(String topicName: topicNames) {
		if(topicName==null || topicName.trim().isEmpty()) {
			try {
				AdminUtils.deleteTopic(z, topicName.trim());
				deleted.add(topicName.trim());
			} catch (Exception ex) {
				log.warn("Failed to delete topic [" + topicName.trim() + "]", ex);
			}
		}
	}
	return deleted.toArray(new String[deleted.size()]);
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
@Override
public void deleteTestTopic(String topic) {
	ZkUtils zkUtils = getZkUtils();
	try {
		LOG.info("Deleting topic {}", topic);

		ZkClient zk = new ZkClient(zookeeperConnectionString, Integer.valueOf(standardProps.getProperty("zookeeper.session.timeout.ms")),
			Integer.valueOf(standardProps.getProperty("zookeeper.connection.timeout.ms")), new ZooKeeperStringSerializer());

		AdminUtils.deleteTopic(zkUtils, topic);

		zk.close();
	} finally {
		zkUtils.close();
	}
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
public static void deleteTopics(final KafkaEmbedded kafkaEmbedded, final String... topics) {
    ZkUtils zkUtils = new ZkUtils(kafkaEmbedded.getZkClient(), null, false);
    for (String topic : topics) {

        if (AdminUtils.topicExists(zkUtils, topic)) {
            LOGGER.info("Deleting topic {}", topic);
            kafkaEmbedded.waitUntilSynced(topic, 0);
            AdminUtils.deleteTopic(zkUtils, topic);
            while (AdminUtils.topicExists(zkUtils, topic)) {
                //wait for topic to die
            }
            kafkaEmbedded.waitUntilSynced(topic, 0);
        }
    }
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
public static void deleteTopic(String topicName) {
  int sessionTimeoutMs = 10000;
  int connectionTimeoutMs = 10000;
  ZkUtils zkUtils =
      ZkUtils.apply(testUtil.getZkUrl(), sessionTimeoutMs, connectionTimeoutMs, false);
  AdminUtils.deleteTopic(zkUtils, topicName);
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
public void deleteTopic(final String topic) {
    log.debug("Deleting topic { name: {} }", topic);

    final ZkClient zkClient = new ZkClient(
        zookeeperConnect(),
        DEFAULT_ZK_SESSION_TIMEOUT_MS,
        DEFAULT_ZK_CONNECTION_TIMEOUT_MS,
        ZKStringSerializer$.MODULE$);
    final boolean isSecure = false;
    final ZkUtils zkUtils = new ZkUtils(zkClient, new ZkConnection(zookeeperConnect()), isSecure);
    AdminUtils.deleteTopic(zkUtils, topic);
    zkClient.close();
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
/**
 * @param zkServers Zookeeper server string: host1:port1[,host2:port2,...]
 * @param topic topic to delete, if it exists
 */
public static void deleteTopic(String zkServers, String topic) {
  ZkUtils zkUtils = ZkUtils.apply(zkServers, ZK_TIMEOUT_MSEC, ZK_TIMEOUT_MSEC, false);
  try {
    if (AdminUtils.topicExists(zkUtils, topic)) {
      log.info("Deleting topic {}", topic);
      AdminUtils.deleteTopic(zkUtils, topic);
      log.info("Deleted Zookeeper topic {}", topic);
    } else {
      log.info("No need to delete topic {} as it does not exist", topic);
    }
  } finally {
    zkUtils.close();
  }
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
public void deleteTopic(final String topic) {
  log.debug("Deleting topic { name: {} }", topic);

  final ZkClient zkClient = new ZkClient(
      zookeeperConnect(),
      DEFAULT_ZK_SESSION_TIMEOUT_MS,
      DEFAULT_ZK_CONNECTION_TIMEOUT_MS,
      ZKStringSerializer$.MODULE$);
  final boolean isSecure = false;
  final ZkUtils zkUtils = new ZkUtils(zkClient, new ZkConnection(zookeeperConnect()), isSecure);
  AdminUtils.deleteTopic(zkUtils, topic);
  zkClient.close();
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
@Override
public void deleteTopic(final String topicName) {
    if (AdminUtils.topicExists(zkUtils, topicName)) {
        AdminUtils.deleteTopic(zkUtils, topicName);
    }
    throw new UnknownTopicException(topicName);
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
@Override
public void deleteTestTopic(String topic) {
	LOG.info("Deleting topic {}", topic);

	ZkClient zk = createZkClient();
	AdminUtils.deleteTopic(zk, topic);
	zk.close();
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
/**
 * Delete topic
 *
 * @return if the topic was deleted or not
 */
public synchronized boolean deleteTopic(String topic) {
  boolean deleted = true;
  try {
    AdminUtils.deleteTopic(getZooKeeperUtils(), topic);
  } catch (TopicAlreadyMarkedForDeletionException topicAlreadyMarkedForDeletionException) {
    deleted = false;
  }
  return deleted && AdminUtils.topicExists(getZooKeeperUtils(), topic);
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
@AfterClass
public static void tearDownClass() {
  for (int i = 0; i < topics.length; i++) {
    AdminUtils.deleteTopic(zkUtils, topics[i]);
  }
  kafkaServer.shutdown();
  zookeeper.shutdown();
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
/**
 * Delete may not work
 *
 * @param topic
 */
public void deleteTopic(String topic) {
    ZkClient zkClient = new ZkClient(zkConnection);
    ZkUtils zkUtils = new ZkUtils(zkClient, zkConnection, false);
    zkClient.setZkSerializer(new ZKStringSerializer());
    AdminUtils.deleteTopic(zkUtils, topic);
    zkClient.close();
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
public static void deleteKafkaTopic(String zkConnString, String topicName) {
    final int sessionTimeoutMillis = 10000;
    final int connTimeOutMillis = 10000;
    ZkClient zkClient = new ZkClient(zkConnString, sessionTimeoutMillis, connTimeOutMillis, ZKStringSerializer$.MODULE$);

    try {
        AdminUtils.deleteTopic(zkClient, topicName);
    } catch (Exception e) {
        LOG.warn("could not delete topic " + topicName + " assuming that it does not exist and moving on.", e);
    }
}
 

import kafka.admin.AdminUtils; //导入方法依赖的package包/类
public void stopClients() throws IOException {
  for (Map.Entry<String, KafkaConsumerSuite> consumerSuiteEntry: _topicConsumerMap.entrySet())
  {
    consumerSuiteEntry.getValue().shutdown();
    AdminUtils.deleteTopic(_kafkaServerSuite.getZkClient(), consumerSuiteEntry.getKey());
  }
}