/**
* connect ZK, register Watch/unhandle Watch
*
* @return
*/
public CuratorFramework mkClient(
Map conf, List<String> servers, Object port, String root, final WatcherCallBack watcher) {
CuratorFramework fk = Utils.newCurator(conf, servers, port, root);
fk.getCuratorListenable()
.addListener(
new CuratorListener() {
@Override
public void eventReceived(CuratorFramework _fk, CuratorEvent e) throws Exception {
if (e.getType().equals(CuratorEventType.WATCHED)) {
WatchedEvent event = e.getWatchedEvent();
watcher.execute(event.getState(), event.getType(), event.getPath());
}
}
});
fk.getUnhandledErrorListenable()
.addListener(
new UnhandledErrorListener() {
@Override
public void unhandledError(String msg, Throwable error) {
String errmsg = "Unrecoverable Zookeeper error, halting process: " + msg;
LOG.error(errmsg, error);
JStormUtils.halt_process(1, "Unrecoverable Zookeeper error");
}
});
fk.start();
return fk;
}
public static void main(String[] args) throws Exception {
CuratorFramework client = null;
DistributedDelayQueue<String> queue = null;
try {
client = CuratorClientFactory.newClient();
client
.getCuratorListenable()
.addListener(
new CuratorListener() {
@Override
public void eventReceived(CuratorFramework client, CuratorEvent event)
throws Exception {
System.out.println("CuratorEvent: " + event.getType().name());
}
});
client.start();
QueueConsumer<String> consumer = createQueueConsumer();
QueueBuilder<String> builder =
QueueBuilder.builder(client, consumer, createQueueSerializer(), PATH);
queue = builder.buildDelayQueue();
queue.start();
for (int i = 0; i < 10; i++) {
queue.put("test-" + i, System.currentTimeMillis() + 10000);
}
System.out.println(getCurrentTimeStr() + ": 所有的数据已经生产完毕");
Thread.sleep(20000);
} finally {
CloseableUtils.closeQuietly(client);
CloseableUtils.closeQuietly(queue);
}
}
public static void main(String[] args) throws Exception {
TestingServer server = new TestingServer();
CuratorFramework client = null;
DistributedQueue<String> queue = null;
try {
client =
CuratorFrameworkFactory.newClient(
server.getConnectString(), new ExponentialBackoffRetry(1000, 3));
client
.getCuratorListenable()
.addListener(
new CuratorListener() {
@Override
public void eventReceived(CuratorFramework client, CuratorEvent event)
throws Exception {
System.out.println("CuratorEvent: " + event.getType().name());
}
});
client.start();
AkinDistributedBlockingQueue<String> consumerQueue =
new AkinDistributedBlockingQueue<String>(
null,
new ConnectionStateListener() {
@Override
public void stateChanged(CuratorFramework client, ConnectionState newState) {}
});
QueueBuilder<String> builder =
QueueBuilder.builder(client, consumerQueue, createQueueSerializer(), PATH);
queue = builder.buildQueue();
consumerQueue.setDistributedQueue(queue);
queue.start();
for (int i = 0; i < 10; i++) {
queue.put(" test-" + i);
Thread.sleep((long) (3 * Math.random()));
}
Thread.sleep(20000);
for (Object object : consumerQueue) {
System.out.println(consumerQueue.poll());
}
} catch (Exception ex) {
} finally {
CloseableUtils.closeQuietly(queue);
CloseableUtils.closeQuietly(client);
CloseableUtils.closeQuietly(server);
}
}
public static void setDataAsync(CuratorFramework client, String path, byte[] payload)
throws Exception {
CuratorListener listener =
new CuratorListener() {
@Override
public void eventReceived(CuratorFramework client, CuratorEvent event) throws Exception {
// examine event for details
}
};
client.getCuratorListenable().addListener(listener);
client.setData().inBackground().forPath(path, payload);
}
/**
* Test start kaa node server application.
*
* @throws Exception the exception
*/
@Test
public void testStartKaaNodeServerApplication() throws Exception {
TestingCluster zkCluster = null;
TTransport transport = null;
Thread kaaNodeServerLauncherThread = null;
KaaNodeThriftService.Client client = null;
CuratorFramework zkClient = null;
CountDownLatch latch = new CountDownLatch(1);
boolean kaaNodeStarted = false;
TestKaaNodeLauncher launcher = new TestKaaNodeLauncher();
try {
zkCluster = new TestingCluster(new InstanceSpec(null, 2185, -1, -1, true, -1, -1, -1));
zkCluster.start();
zkClient =
CuratorFrameworkFactory.newClient(zkCluster.getConnectString(), new RetryOneTime(100));
zkClient.start();
kaaNodeServerLauncherThread = new Thread(launcher);
kaaNodeServerLauncherThread.start();
OperationsNodeStartupListener operationsNodeStartupListener =
new OperationsNodeStartupListener();
zkClient.getCuratorListenable().addListener(operationsNodeStartupListener);
zkClient.getChildren().inBackground(latch).forPath(OPERATIONS_SERVER_NODE_PATH);
// Wait for operations service to start
kaaNodeStarted = latch.await(KAA_NODE_START_TIMEOUT_SEC, TimeUnit.SECONDS);
zkClient.getCuratorListenable().removeListener(operationsNodeStartupListener);
transport = new TSocket(HOST, PORT);
TProtocol protocol = new TBinaryProtocol(transport);
TMultiplexedProtocol mp =
new TMultiplexedProtocol(protocol, KaaThriftService.KAA_NODE_SERVICE.getServiceName());
client = new KaaNodeThriftService.Client(mp);
transport.open();
client.shutdown();
} finally {
boolean shutdownFailed = false;
Closeables.close(zkClient, true);
if (transport != null && transport.isOpen()) {
Closeables.close(transport, true);
}
if (kaaNodeServerLauncherThread != null) {
kaaNodeServerLauncherThread.join(30000);
shutdownFailed = kaaNodeServerLauncherThread.isAlive();
}
Closeables.close(zkCluster, true);
if (launcher != null) {
ConfigurableApplicationContext appContext = launcher.getApplicationContext();
if (appContext.isActive()) {
Closeables.close(appContext, true);
}
}
if (!kaaNodeStarted) {
throw new TimeoutException(
"Timeout ("
+ KAA_NODE_START_TIMEOUT_SEC
+ " sec) occured while waiting kaa node server to start!");
} else if (shutdownFailed) {
throw new TimeoutException(
"Timeout ("
+ KAA_NODE_STOP_TIMEOUT_SEC
+ " sec) occured while waiting kaa node server shutdown thread!");
}
}
}
