/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.twitter.distributedlog.util;
import java.io.Closeable;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.Nullable;
import com.google.common.base.Objects;
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.io.Closeables;
import com.twitter.distributedlog.DistributedLogConstants;
import com.twitter.distributedlog.ZooKeeperClient;
import com.twitter.distributedlog.exceptions.DLInterruptedException;
import com.twitter.distributedlog.exceptions.ZKException;
import com.twitter.distributedlog.function.VoidFunctions;
import com.twitter.distributedlog.io.AsyncCloseable;
import com.twitter.util.Await;
import com.twitter.util.Future;
import com.twitter.util.Promise;
import com.twitter.util.Return;
import com.twitter.util.Throw;
import org.apache.bookkeeper.meta.ZkVersion;
import org.apache.bookkeeper.versioning.Versioned;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import scala.runtime.BoxedUnit;
/**
* Basic Utilities.
*/
public class Utils {
private static final Logger logger = LoggerFactory.getLogger(Utils.class);
/**
* Current time from some arbitrary time base in the past, counting in
* nanoseconds, and not affected by settimeofday or similar system clock
* changes. This is appropriate to use when computing how much longer to
* wait for an interval to expire.
*
* @return current time in nanoseconds.
*/
public static long nowInNanos() {
return System.nanoTime();
}
/**
* Current time from some fixed base time - so useful for cross machine
* comparison
*
* @return current time in milliseconds.
*/
public static long nowInMillis() {
return System.currentTimeMillis();
}
/**
* Milliseconds elapsed since the time specified, the input is nanoTime
* the only conversion happens when computing the elapsed time
*
* @param startMsecTime the start of the interval that we are measuring
* @return elapsed time in milliseconds.
*/
public static long elapsedMSec(long startMsecTime) {
return (System.currentTimeMillis() - startMsecTime);
}
public static boolean randomPercent(double percent) {
return (Math.random() * 100.0) <= percent;
}
/**
* Synchronously create zookeeper path recursively and optimistically.
*
* @see #zkAsyncCreateFullPathOptimistic(ZooKeeperClient, String, byte[], List, CreateMode)
* @param zkc Zookeeper client
* @param path Zookeeper full path
* @param data Zookeeper data
* @param acl Acl of the zk path
* @param createMode Create mode of zk path
* @throws ZooKeeperClient.ZooKeeperConnectionException
* @throws KeeperException
* @throws InterruptedException
*/
public static void zkCreateFullPathOptimistic(
ZooKeeperClient zkc,
String path,
byte[] data,
final List<ACL> acl,
final CreateMode createMode)
throws ZooKeeperClient.ZooKeeperConnectionException, KeeperException, InterruptedException {
try {
Await.result(zkAsyncCreateFullPathOptimistic(zkc, path, data, acl, createMode));
} catch (ZooKeeperClient.ZooKeeperConnectionException zkce) {
throw zkce;
} catch (KeeperException ke) {
throw ke;
} catch (InterruptedException ie) {
throw ie;
} catch (RuntimeException rte) {
throw rte;
} catch (Exception exc) {
throw new RuntimeException("Unexpected Exception", exc);
}
}
/**
* Asynchronously create zookeeper path recursively and optimistically.
*
* @param zkc Zookeeper client
* @param pathToCreate Zookeeper full path
* @param parentPathShouldNotCreate The recursive creation should stop if this path doesn't exist
* @param data Zookeeper data
* @param acl Acl of the zk path
* @param createMode Create mode of zk path
* @param callback Callback
* @param ctx Context object
*/
public static void zkAsyncCreateFullPathOptimisticRecursive(
final ZooKeeperClient zkc,
final String pathToCreate,
final Optional<String> parentPathShouldNotCreate,
final byte[] data,
final List<ACL> acl,
final CreateMode createMode,
final AsyncCallback.StringCallback callback,
final Object ctx) {
try {
zkc.get().create(pathToCreate, data, acl, createMode, new AsyncCallback.StringCallback() {
@Override
public void processResult(int rc, String path, Object ctx, String name) {
if (rc != KeeperException.Code.NONODE.intValue()) {
callback.processResult(rc, path, ctx, name);
return;
}
// Since we got a nonode, it means that my parents may not exist
// ephemeral nodes can't have children so Create mode is always
// persistent parents
int lastSlash = pathToCreate.lastIndexOf('/');
if (lastSlash <= 0) {
callback.processResult(rc, path, ctx, name);
return;
}
String parent = pathToCreate.substring(0, lastSlash);
if (parentPathShouldNotCreate.isPresent() && Objects.equal(parentPathShouldNotCreate.get(), parent)) {
// we should stop here
callback.processResult(rc, path, ctx, name);
return;
}
zkAsyncCreateFullPathOptimisticRecursive(zkc, parent, parentPathShouldNotCreate, new byte[0], acl,
CreateMode.PERSISTENT, new AsyncCallback.StringCallback() {
@Override
public void processResult(int rc, String path, Object ctx, String name) {
if (rc == KeeperException.Code.OK.intValue() || rc == KeeperException.Code.NODEEXISTS.intValue()) {
// succeeded in creating the parent, now create the original path
zkAsyncCreateFullPathOptimisticRecursive(zkc, pathToCreate, parentPathShouldNotCreate,
data, acl, createMode, callback, ctx);
} else {
callback.processResult(rc, path, ctx, name);
}
}
}, ctx);
}
}, ctx);
} catch (ZooKeeperClient.ZooKeeperConnectionException zkce) {
callback.processResult(DistributedLogConstants.ZK_CONNECTION_EXCEPTION_RESULT_CODE, zkce.getMessage(), ctx, pathToCreate);
} catch (InterruptedException ie) {
callback.processResult(DistributedLogConstants.DL_INTERRUPTED_EXCEPTION_RESULT_CODE, ie.getMessage(), ctx, pathToCreate);
}
}
/**
* Asynchronously create zookeeper path recursively and optimistically.
*
* @param zkc Zookeeper client
* @param pathToCreate Zookeeper full path
* @param data Zookeeper data
* @param acl Acl of the zk path
* @param createMode Create mode of zk path
*/
public static Future<BoxedUnit> zkAsyncCreateFullPathOptimistic(
final ZooKeeperClient zkc,
final String pathToCreate,
final byte[] data,
final List<ACL> acl,
final CreateMode createMode) {
Optional<String> parentPathShouldNotCreate = Optional.absent();
return zkAsyncCreateFullPathOptimistic(
zkc,
pathToCreate,
parentPathShouldNotCreate,
data,
acl,
createMode);
}
/**
* Asynchronously create zookeeper path recursively and optimistically
*
* @param zkc Zookeeper client
* @param pathToCreate Zookeeper full path
* @param parentPathShouldNotCreate zookeeper parent path should not be created
* @param data Zookeeper data
* @param acl Acl of the zk path
* @param createMode Create mode of zk path
*/
public static Future<BoxedUnit> zkAsyncCreateFullPathOptimistic(
final ZooKeeperClient zkc,
final String pathToCreate,
final Optional<String> parentPathShouldNotCreate,
final byte[] data,
final List<ACL> acl,
final CreateMode createMode) {
final Promise<BoxedUnit> result = new Promise<BoxedUnit>();
zkAsyncCreateFullPathOptimisticRecursive(zkc, pathToCreate, parentPathShouldNotCreate,
data, acl, createMode, new AsyncCallback.StringCallback() {
@Override
public void processResult(int rc, String path, Object ctx, String name) {
handleKeeperExceptionCode(rc, path, result);
}
}, result);
return result;
}
/**
* Asynchronously create zookeeper path recursively and optimistically.
*
* @param zkc Zookeeper client
* @param pathToCreate Zookeeper full path
* @param data Zookeeper data
* @param acl Acl of the zk path
* @param createMode Create mode of zk path
*/
public static Future<BoxedUnit> zkAsyncCreateFullPathOptimisticAndSetData(
final ZooKeeperClient zkc,
final String pathToCreate,
final byte[] data,
final List<ACL> acl,
final CreateMode createMode) {
final Promise<BoxedUnit> result = new Promise<BoxedUnit>();
try {
zkc.get().setData(pathToCreate, data, -1, new AsyncCallback.StatCallback() {
@Override
public void processResult(int rc, String path, Object ctx, Stat stat) {
if (rc != KeeperException.Code.NONODE.intValue()) {
handleKeeperExceptionCode(rc, path, result);
return;
}
Optional<String> parentPathShouldNotCreate = Optional.absent();
zkAsyncCreateFullPathOptimisticRecursive(zkc, pathToCreate, parentPathShouldNotCreate,
data, acl, createMode, new AsyncCallback.StringCallback() {
@Override
public void processResult(int rc, String path, Object ctx, String name) {
handleKeeperExceptionCode(rc, path, result);
}
}, result);
}
}, result);
} catch (Exception exc) {
result.setException(exc);
}
return result;
}
private static void handleKeeperExceptionCode(int rc, String pathOrMessage, Promise<BoxedUnit> result) {
if (KeeperException.Code.OK.intValue() == rc) {
result.setValue(BoxedUnit.UNIT);
} else if (DistributedLogConstants.ZK_CONNECTION_EXCEPTION_RESULT_CODE == rc) {
result.setException(new ZooKeeperClient.ZooKeeperConnectionException(pathOrMessage));
} else if (DistributedLogConstants.DL_INTERRUPTED_EXCEPTION_RESULT_CODE == rc) {
result.setException(new DLInterruptedException(pathOrMessage));
} else {
result.setException(KeeperException.create(KeeperException.Code.get(rc), pathOrMessage));
}
}
public static Future<Versioned<byte[]>> zkGetData(ZooKeeperClient zkc, String path, boolean watch) {
ZooKeeper zk;
try {
zk = zkc.get();
} catch (ZooKeeperClient.ZooKeeperConnectionException e) {
return Future.exception(FutureUtils.zkException(e, path));
} catch (InterruptedException e) {
return Future.exception(FutureUtils.zkException(e, path));
}
return zkGetData(zk, path, watch);
}
/**
* Retrieve data from zookeeper <code>path</code>.
*
* @param path
* zookeeper path to retrieve data
* @param watch
* whether to watch the path
* @return future representing the versioned value. null version or null value means path doesn't exist.
*/
public static Future<Versioned<byte[]>> zkGetData(ZooKeeper zk, String path, boolean watch) {
final Promise<Versioned<byte[]>> promise = new Promise<Versioned<byte[]>>();
zk.getData(path, watch, new AsyncCallback.DataCallback() {
@Override
public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
if (KeeperException.Code.OK.intValue() == rc) {
if (null == stat) {
promise.setValue(new Versioned<byte[]>(null, null));
} else {
promise.setValue(new Versioned<byte[]>(data, new ZkVersion(stat.getVersion())));
}
} else if (KeeperException.Code.NONODE.intValue() == rc) {
promise.setValue(new Versioned<byte[]>(null, null));
} else {
promise.setException(KeeperException.create(KeeperException.Code.get(rc)));
}
}
}, null);
return promise;
}
public static Future<ZkVersion> zkSetData(ZooKeeperClient zkc, String path, byte[] data, ZkVersion version) {
ZooKeeper zk;
try {
zk = zkc.get();
} catch (ZooKeeperClient.ZooKeeperConnectionException e) {
return Future.exception(FutureUtils.zkException(e, path));
} catch (InterruptedException e) {
return Future.exception(FutureUtils.zkException(e, path));
}
return zkSetData(zk, path, data, version);
}
/**
* Set <code>data</code> to zookeeper <code>path</code>.
*
* @param zk
* zookeeper client
* @param path
* path to set data
* @param data
* data to set
* @param version
* version used to set data
* @return future representing the version after this operation.
*/
public static Future<ZkVersion> zkSetData(ZooKeeper zk, String path, byte[] data, ZkVersion version) {
final Promise<ZkVersion> promise = new Promise<ZkVersion>();
zk.setData(path, data, version.getZnodeVersion(), new AsyncCallback.StatCallback() {
@Override
public void processResult(int rc, String path, Object ctx, Stat stat) {
if (KeeperException.Code.OK.intValue() == rc) {
promise.updateIfEmpty(new Return<ZkVersion>(new ZkVersion(stat.getVersion())));
return;
}
promise.updateIfEmpty(new Throw<ZkVersion>(
KeeperException.create(KeeperException.Code.get(rc))));
return;
}
}, null);
return promise;
}
public static Future<Void> zkDelete(ZooKeeperClient zkc, String path, ZkVersion version) {
ZooKeeper zk;
try {
zk = zkc.get();
} catch (ZooKeeperClient.ZooKeeperConnectionException e) {
return Future.exception(FutureUtils.zkException(e, path));
} catch (InterruptedException e) {
return Future.exception(FutureUtils.zkException(e, path));
}
return zkDelete(zk, path, version);
}
/**
* Delete the given <i>path</i> from zookeeper.
*
* @param zk
* zookeeper client
* @param path
* path to delete
* @param version
* version used to set data
* @return future representing the version after this operation.
*/
public static Future<Void> zkDelete(ZooKeeper zk, String path, ZkVersion version) {
final Promise<Void> promise = new Promise<Void>();
zk.delete(path, version.getZnodeVersion(), new AsyncCallback.VoidCallback() {
@Override
public void processResult(int rc, String path, Object ctx) {
if (KeeperException.Code.OK.intValue() == rc) {
promise.updateIfEmpty(new Return<Void>(null));
return;
}
promise.updateIfEmpty(new Throw<Void>(
KeeperException.create(KeeperException.Code.get(rc))));
return;
}
}, null);
return promise;
}
public static Future<Void> asyncClose(@Nullable AsyncCloseable closeable,
boolean swallowIOException) {
if (null == closeable) {
return Future.Void();
} else if (swallowIOException) {
return FutureUtils.ignore(closeable.asyncClose());
} else {
return closeable.asyncClose();
}
}
/**
* Sync zookeeper client on given <i>path</i>.
*
* @param zkc
* zookeeper client
* @param path
* path to sync
* @return zookeeper client after sync
* @throws IOException
*/
public static ZooKeeper sync(ZooKeeperClient zkc, String path) throws IOException {
ZooKeeper zk;
try {
zk = zkc.get();
} catch (InterruptedException e) {
throw new DLInterruptedException("Interrupted on checking if log " + path + " exists", e);
}
final CountDownLatch syncLatch = new CountDownLatch(1);
final AtomicInteger syncResult = new AtomicInteger(0);
zk.sync(path, new AsyncCallback.VoidCallback() {
@Override
public void processResult(int rc, String path, Object ctx) {
syncResult.set(rc);
syncLatch.countDown();
}
}, null);
try {
syncLatch.await();
} catch (InterruptedException e) {
throw new DLInterruptedException("Interrupted on syncing zookeeper connection", e);
}
if (KeeperException.Code.OK.intValue() != syncResult.get()) {
throw new ZKException("Error syncing zookeeper connection ",
KeeperException.Code.get(syncResult.get()));
}
return zk;
}
/**
* Close a closeable.
*
* @param closeable
* closeable to close
*/
public static void close(@Nullable Closeable closeable) {
if (null == closeable) {
return;
}
try {
Closeables.close(closeable, true);
} catch (IOException e) {
// no-op. the exception is swallowed.
}
}
/**
* Close an async closeable.
*
* @param closeable
* closeable to close
*/
public static void close(@Nullable AsyncCloseable closeable)
throws IOException {
if (null == closeable) {
return;
}
FutureUtils.result(closeable.asyncClose());
}
/**
* Close an async closeable.
*
* @param closeable
* closeable to close
*/
public static void closeQuietly(@Nullable AsyncCloseable closeable) {
if (null == closeable) {
return;
}
try {
FutureUtils.result(closeable.asyncClose());
} catch (IOException e) {
// no-op. the exception is swallowed.
}
}
/**
* Close the closeables in sequence.
*
* @param closeables
* closeables to close
* @return future represents the close future
*/
public static Future<Void> closeSequence(ExecutorService executorService,
AsyncCloseable... closeables) {
return closeSequence(executorService, false, closeables);
}
/**
* Close the closeables in sequence and ignore errors during closing.
*
* @param executorService executor to execute closeable
* @param ignoreCloseError whether to ignore errors during closing
* @param closeables list of closeables
* @return future represents the close future.
*/
public static Future<Void> closeSequence(ExecutorService executorService,
boolean ignoreCloseError,
AsyncCloseable... closeables) {
List<AsyncCloseable> closeableList = Lists.newArrayListWithExpectedSize(closeables.length);
for (AsyncCloseable closeable : closeables) {
if (null == closeable) {
closeableList.add(AsyncCloseable.NULL);
} else {
closeableList.add(closeable);
}
}
return FutureUtils.processList(
closeableList,
ignoreCloseError ? AsyncCloseable.CLOSE_FUNC_IGNORE_ERRORS : AsyncCloseable.CLOSE_FUNC,
executorService).map(VoidFunctions.LIST_TO_VOID_FUNC);
}
}