@Test
public void testNamespace() throws Exception {
Timing timing = new Timing();
ChildReaper reaper = null;
CuratorFramework client =
CuratorFrameworkFactory.builder()
.connectString(server.getConnectString())
.sessionTimeoutMs(timing.session())
.connectionTimeoutMs(timing.connection())
.retryPolicy(new RetryOneTime(1))
.namespace("foo")
.build();
try {
client.start();
for (int i = 0; i < 10; ++i) {
client.create().creatingParentsIfNeeded().forPath("/test/" + Integer.toString(i));
}
reaper = new ChildReaper(client, "/test", Reaper.Mode.REAP_UNTIL_DELETE, 1);
reaper.start();
timing.forWaiting().sleepABit();
Stat stat = client.checkExists().forPath("/test");
Assert.assertEquals(stat.getNumChildren(), 0);
stat = client.usingNamespace(null).checkExists().forPath("/foo/test");
Assert.assertNotNull(stat);
Assert.assertEquals(stat.getNumChildren(), 0);
} finally {
Closeables.closeQuietly(reaper);
Closeables.closeQuietly(client);
}
}
@Test
public void testCheckVersion() throws Exception {
CuratorFramework client =
CuratorFrameworkFactory.newClient(server.getConnectString(), new RetryOneTime(1));
client.start();
try {
client.create().forPath("/foo");
Stat stat = client.setData().forPath("/foo", "new".getBytes()); // up the version
try {
client
.inTransaction()
.check()
.withVersion(stat.getVersion() + 1)
.forPath("/foo") // force a bad version
.and()
.create()
.forPath("/bar")
.and()
.commit();
Assert.fail();
} catch (KeeperException.BadVersionException correct) {
// correct
}
Assert.assertNull(client.checkExists().forPath("/bar"));
} finally {
client.close();
}
}
@Test
public void testSomeNodes() throws Exception {
Timing timing = new Timing();
ChildReaper reaper = null;
CuratorFramework client =
CuratorFrameworkFactory.newClient(
server.getConnectString(), timing.session(), timing.connection(), new RetryOneTime(1));
try {
client.start();
Random r = new Random();
int nonEmptyNodes = 0;
for (int i = 0; i < 10; ++i) {
client.create().creatingParentsIfNeeded().forPath("/test/" + Integer.toString(i));
if (r.nextBoolean()) {
client.create().forPath("/test/" + Integer.toString(i) + "/foo");
++nonEmptyNodes;
}
}
reaper = new ChildReaper(client, "/test", Reaper.Mode.REAP_UNTIL_DELETE, 1);
reaper.start();
timing.forWaiting().sleepABit();
Stat stat = client.checkExists().forPath("/test");
Assert.assertEquals(stat.getNumChildren(), nonEmptyNodes);
} finally {
Closeables.closeQuietly(reaper);
Closeables.closeQuietly(client);
}
}
@Test
public void testBasic() throws Exception {
CuratorFramework client =
CuratorFrameworkFactory.newClient(server.getConnectString(), new RetryOneTime(1));
client.start();
try {
Collection<CuratorTransactionResult> results =
client
.inTransaction()
.create()
.forPath("/foo")
.and()
.create()
.forPath("/foo/bar", "snafu".getBytes())
.and()
.commit();
Assert.assertTrue(client.checkExists().forPath("/foo/bar") != null);
Assert.assertEquals(client.getData().forPath("/foo/bar"), "snafu".getBytes());
CuratorTransactionResult fooResult =
Iterables.find(
results, CuratorTransactionResult.ofTypeAndPath(OperationType.CREATE, "/foo"));
CuratorTransactionResult fooBarResult =
Iterables.find(
results, CuratorTransactionResult.ofTypeAndPath(OperationType.CREATE, "/foo/bar"));
Assert.assertNotNull(fooResult);
Assert.assertNotNull(fooBarResult);
Assert.assertNotSame(fooResult, fooBarResult);
Assert.assertEquals(fooResult.getResultPath(), "/foo");
Assert.assertEquals(fooBarResult.getResultPath(), "/foo/bar");
} finally {
client.close();
}
}
@Before
public void setup() throws Exception {
zkServer = new TestingServer(2222);
zkClient =
CuratorFrameworkFactory.newClient(
zkServer.getConnectString(), new ExponentialBackoffRetry(300, 5));
dragonZK = new DragonZooKeeper(zkClient, "/dragon");
}
public static IZkConnection createZkConnection(String connectString) {
Timing timing = new Timing();
CuratorFramework client =
CuratorFrameworkFactory.newClient(
connectString, timing.session(), timing.connection(), new RetryOneTime(1));
client.start();
try {
return new CuratorZKClientBridge(client);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Before
public void setUp() throws Exception {
server = new TestingServer();
String connectionString = server.getConnectString();
Map conf = new HashMap();
conf.put(Config.STORM_ZOOKEEPER_SESSION_TIMEOUT, 1000);
conf.put(Config.STORM_ZOOKEEPER_RETRY_TIMES, 4);
conf.put(Config.STORM_ZOOKEEPER_RETRY_INTERVAL, 5);
ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(1000, 3);
zookeeper = CuratorFrameworkFactory.newClient(connectionString, retryPolicy);
dynamicBrokersReader = new DynamicBrokersReader(conf, connectionString, masterPath, topic);
zookeeper.start();
}
@Test
public void testOverSubscribed() throws Exception {
final Timing timing = new Timing();
final CuratorFramework client =
CuratorFrameworkFactory.newClient(
server.getConnectString(), timing.session(), timing.connection(), new RetryOneTime(1));
ExecutorService service = Executors.newCachedThreadPool();
ExecutorCompletionService<Void> completionService =
new ExecutorCompletionService<Void>(service);
try {
client.start();
final Semaphore semaphore = new Semaphore(0);
final CountDownLatch latch = new CountDownLatch(1);
for (int i = 0; i < (QTY + 1); ++i) {
completionService.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
DistributedDoubleBarrier barrier =
new DistributedDoubleBarrier(client, "/barrier", QTY) {
@Override
protected List<String> getChildrenForEntering() throws Exception {
semaphore.release();
Assert.assertTrue(timing.awaitLatch(latch));
return super.getChildrenForEntering();
}
};
Assert.assertTrue(barrier.enter(timing.seconds(), TimeUnit.SECONDS));
Assert.assertTrue(barrier.leave(timing.seconds(), TimeUnit.SECONDS));
return null;
}
});
}
Assert.assertTrue(
semaphore.tryAcquire(
QTY + 1,
timing.seconds(),
TimeUnit.SECONDS)); // wait until all QTY+1 barriers are trying to enter
latch.countDown();
for (int i = 0; i < (QTY + 1); ++i) {
completionService.take().get(); // to check for assertions
}
} finally {
service.shutdown();
Closeables.close(client, true);
}
}
public KafkaTestBroker() {
try {
server = new TestingServer();
String zookeeperConnectionString = server.getConnectString();
ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(1000, 3);
zookeeper = CuratorFrameworkFactory.newClient(zookeeperConnectionString, retryPolicy);
zookeeper.start();
port = InstanceSpec.getRandomPort();
kafka.server.KafkaConfig config = buildKafkaConfig(zookeeperConnectionString);
kafka = new KafkaServerStartable(config);
kafka.startup();
} catch (Exception ex) {
throw new RuntimeException("Could not start test broker", ex);
}
}
/**
* Create and configure the ZK sync object with the KinesisSpoutConfig.
*
* @param config the configuration for the spout.
*/
ZookeeperShardState(final KinesisSpoutConfig config) {
this.config = config;
this.rand = new Random();
try {
zk =
CuratorFrameworkFactory.newClient(
config.getZookeeperConnectionString(),
new ExponentialBackoffRetry(BASE_SLEEP_TIME_MS, MAX_NUM_RETRIES));
} catch (IOException e) {
LOG.error("Could not connect to ZooKeeper", e);
throw new KinesisSpoutException(e);
}
zk.start();
}
@Test
public void testWithNamespace() throws Exception {
CuratorFramework client =
CuratorFrameworkFactory.builder()
.connectString(server.getConnectString())
.retryPolicy(new RetryOneTime(1))
.namespace("galt")
.build();
client.start();
try {
Collection<CuratorTransactionResult> results =
client
.inTransaction()
.create()
.forPath("/foo", "one".getBytes())
.and()
.create()
.withMode(CreateMode.PERSISTENT_SEQUENTIAL)
.forPath("/test-", "one".getBytes())
.and()
.setData()
.forPath("/foo", "two".getBytes())
.and()
.create()
.forPath("/foo/bar")
.and()
.delete()
.forPath("/foo/bar")
.and()
.commit();
Assert.assertTrue(client.checkExists().forPath("/foo") != null);
Assert.assertTrue(client.nonNamespaceView().checkExists().forPath("/galt/foo") != null);
Assert.assertEquals(client.getData().forPath("/foo"), "two".getBytes());
Assert.assertTrue(client.checkExists().forPath("/foo/bar") == null);
CuratorTransactionResult ephemeralResult =
Iterables.find(
results, CuratorTransactionResult.ofTypeAndPath(OperationType.CREATE, "/test-"));
Assert.assertNotNull(ephemeralResult);
Assert.assertNotEquals(ephemeralResult.getResultPath(), "/test-");
Assert.assertTrue(ephemeralResult.getResultPath().startsWith("/test-"));
} finally {
client.close();
}
}
private void initZooKeeper() {
getLogger().info("Init ZooKeeper");
this.zooKeeperClient =
CuratorFrameworkFactory.builder()
.connectString("elab.kr:2181")
.retryPolicy(new ExponentialBackoffRetry(1000, 3))
.aclProvider(new ServiceACLProvider())
.sessionTimeoutMs(10 * 1000)
.build();
this.zooKeeperClient.start();
try {
this.zooKeeperClient.getZookeeperClient().blockUntilConnectedOrTimedOut();
} catch (InterruptedException e) {
getLogger().fatal("Not Connected ZooKeeper", e);
}
this.registerService();
}
@Test
public void testInCluster() throws Exception {
final int PARTICIPANT_QTY = 3;
List<ClientAndLatch> clients = Lists.newArrayList();
Timing timing = new Timing();
TestingCluster cluster = new TestingCluster(PARTICIPANT_QTY);
try {
cluster.start();
List<InstanceSpec> instances = Lists.newArrayList(cluster.getInstances());
for (int i = 0; i < PARTICIPANT_QTY; ++i) {
CuratorFramework client =
CuratorFrameworkFactory.newClient(
instances.get(i).getConnectString(),
timing.session(),
timing.connection(),
new RetryOneTime(1));
LeaderLatch latch = new LeaderLatch(client, "/latch");
clients.add(new ClientAndLatch(client, latch, i));
client.start();
latch.start();
}
ClientAndLatch leader = waitForALeader(clients, timing);
Assert.assertNotNull(leader);
cluster.killServer(instances.get(leader.index));
Thread.sleep(timing.multiple(2).session());
leader = waitForALeader(clients, timing);
Assert.assertNotNull(leader);
Assert.assertEquals(getLeaders(clients).size(), 1);
} finally {
for (ClientAndLatch client : clients) {
Closeables.close(client.latch, true);
Closeables.close(client.client, true);
}
Closeables.close(cluster, true);
}
}
/** Amoeba启动的时候，初始化zookeeper客户端，另外，给zookeeper预热 */
public void init() throws Exception {
Properties props = Utils.readGlobalSeqConfigProps();
String zkHosts = props.getProperty("zkHosts", "127.0.0.1:2181");
Integer connTimeOut = Integer.valueOf(props.getProperty("zkConnTimeOut", "60"));
log.info(String.format("zookeeper config: connect string= %s", zkHosts));
log.info(String.format("zookeeper config: connect timeout= %d seconds", connTimeOut));
client =
CuratorFrameworkFactory.builder()
.connectString(zkHosts)
.retryPolicy(new ExponentialBackoffRetry(BASE_SLEEP_TIME, RETRY_TIMES))
.connectionTimeoutMs(connTimeOut * 1000)
.build(); // 时间要由秒转成毫秒
client.start();
// 只是为client热身而调用
client.checkExists().forPath(ROOT_PATH);
}
public static CuratorFramework newCurator(
Map conf, List<String> servers, Object port, String root) {
List<String> serverPorts = new ArrayList<String>();
for (String zkServer : (List<String>) servers) {
serverPorts.add(zkServer + ":" + Utils.getInt(port));
}
String zkStr = StringUtils.join(serverPorts, ",") + root;
try {
CuratorFramework ret =
CuratorFrameworkFactory.newClient(
zkStr,
Utils.getInt(conf.get(Config.STORM_ZOOKEEPER_SESSION_TIMEOUT)),
15000,
new RetryNTimes(
Utils.getInt(conf.get(Config.STORM_ZOOKEEPER_RETRY_TIMES)),
Utils.getInt(conf.get(Config.STORM_ZOOKEEPER_RETRY_INTERVAL))));
return ret;
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@SuppressWarnings("unchecked")
private CuratorFramework newCurator(Map stateConf) {
Integer port = (Integer) stateConf.get(Config.TRANSACTIONAL_ZOOKEEPER_PORT);
String zkServerPorts = "";
for (String server : (List<String>) stateConf.get(Config.TRANSACTIONAL_ZOOKEEPER_SERVERS)) {
zkServerPorts += server + ":" + port + ",";
}
// LOG.info("@@@@@@@@@@@@@@@" + zkServerPorts);
try {
return CuratorFrameworkFactory.newClient(
zkServerPorts,
Utils.getInt(stateConf.get(Config.STORM_ZOOKEEPER_SESSION_TIMEOUT)),
20000,
new RetryNTimes(
Utils.getInt(stateConf.get(Config.STORM_ZOOKEEPER_RETRY_TIMES)),
Utils.getInt(stateConf.get(Config.STORM_ZOOKEEPER_RETRY_INTERVAL))));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Test
public void testBasic() throws Exception {
final Timing timing = new Timing();
final List<Closeable> closeables = Lists.newArrayList();
final CuratorFramework client =
CuratorFrameworkFactory.newClient(
server.getConnectString(), timing.session(), timing.connection(), new RetryOneTime(1));
try {
closeables.add(client);
client.start();
final CountDownLatch postEnterLatch = new CountDownLatch(QTY);
final CountDownLatch postLeaveLatch = new CountDownLatch(QTY);
final AtomicInteger count = new AtomicInteger(0);
final AtomicInteger max = new AtomicInteger(0);
List<Future<Void>> futures = Lists.newArrayList();
ExecutorService service = Executors.newCachedThreadPool();
for (int i = 0; i < QTY; ++i) {
Future<Void> future =
service.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
DistributedDoubleBarrier barrier =
new DistributedDoubleBarrier(client, "/barrier", QTY);
Assert.assertTrue(barrier.enter(timing.seconds(), TimeUnit.SECONDS));
synchronized (TestDistributedDoubleBarrier.this) {
int thisCount = count.incrementAndGet();
if (thisCount > max.get()) {
max.set(thisCount);
}
}
postEnterLatch.countDown();
Assert.assertTrue(timing.awaitLatch(postEnterLatch));
Assert.assertEquals(count.get(), QTY);
Assert.assertTrue(barrier.leave(10, TimeUnit.SECONDS));
count.decrementAndGet();
postLeaveLatch.countDown();
Assert.assertTrue(timing.awaitLatch(postLeaveLatch));
return null;
}
});
futures.add(future);
}
for (Future<Void> f : futures) {
f.get();
}
Assert.assertEquals(count.get(), 0);
Assert.assertEquals(max.get(), QTY);
} finally {
for (Closeable c : closeables) {
Closeables.close(c, true);
}
}
}
private void buildZKClient(final String zkFullPath) {
final String[] zkFullPathItems = zkFullPath.split(ZK_FULL_PATH_DELIMITER);
zkHost_ = zkFullPathItems[1];
zkNamespace_ =
zkFullPathItems[2].substring(
0, zkFullPathItems[2].lastIndexOf(ZK_FULL_PATH_NAMESPACE_SEPERATOR));
zkNodePath_ =
zkFullPathItems[2].substring(
zkFullPathItems[2].lastIndexOf(ZK_FULL_PATH_NAMESPACE_SEPERATOR));
if (zkClient_ == null) {
try {
zkClient_ =
CuratorFrameworkFactory.builder()
.connectString(zkHost_)
.namespace(zkNamespace_)
.retryPolicy(new ExponentialBackoffRetry(1000, 60))
.connectionTimeoutMs(2 * 3600 * 1000)
.build();
zkClient_
.getConnectionStateListenable()
.addListener(
new ConnectionStateListener() {
@Override
public void stateChanged(CuratorFramework client, ConnectionState newState) {
// TODO Auto-generated method stub
if (newState == ConnectionState.LOST) {
try {
synchronized (this) {
while (!client.getZookeeperClient().blockUntilConnectedOrTimedOut()) {
if (logger_ != null) {
if (logger_.isInfoEnabled()) logger_.info("waitting reconnected...");
}
wait(1000);
}
}
if (logger_ != null) {
if (logger_.isInfoEnabled()) logger_.info("to zookeeper reconnected.");
}
doNodesDiscovery();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
if (logger_ != null) {
if (logger_.isInfoEnabled())
logger_.info(
String.format(
"To re connect to zookeeper to generate an error, cause:%s",
e));
}
}
}
}
});
zkClient_.start();
} catch (Throwable t) {
zkClient_.close();
throw new IllegalStateException("building zookeeper client failed.");
}
}
}
