Example usage for org.apache.zookeeper KeeperException code

List of usage examples for org.apache.zookeeper KeeperException code

  1. HOME
  2. Java
  3. org.apache.zookeeper
  4. org.apache.zookeeper.*
  5. KeeperException
  6. code

Introduction

In this page you can find the example usage for org.apache.zookeeper KeeperException code.

Prototype

Code code

To view the source code for org.apache.zookeeper KeeperException code.

Click Source Link

Usage

From source file:org.apache.distributedlog.impl.acl.ZKAccessControl.java

License:Apache License

public static CompletableFuture<ZKAccessControl> read(final ZooKeeperClient zkc, final String zkPath,
        Watcher watcher) {//from w w w . j a va2  s  .co  m
    final CompletableFuture<ZKAccessControl> promise = new CompletableFuture<ZKAccessControl>();

    try {
        zkc.get().getData(zkPath, watcher, new AsyncCallback.DataCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
                if (KeeperException.Code.OK.intValue() == rc) {
                    try {
                        AccessControlEntry ace = deserialize(zkPath, data);
                        promise.complete(new ZKAccessControl(ace, zkPath, stat.getVersion()));
                    } catch (IOException ioe) {
                        promise.completeExceptionally(ioe);
                    }
                } else {
                    promise.completeExceptionally(KeeperException.create(KeeperException.Code.get(rc)));
                }
            }
        }, null);
    } catch (ZooKeeperClient.ZooKeeperConnectionException e) {
        promise.completeExceptionally(e);
    } catch (InterruptedException e) {
        promise.completeExceptionally(e);
    }
    return promise;
}

From source file:org.apache.distributedlog.impl.acl.ZKAccessControl.java

License:Apache License

public static CompletableFuture<Void> delete(final ZooKeeperClient zkc, final String zkPath) {
    final CompletableFuture<Void> promise = new CompletableFuture<Void>();

    try {//from  ww w. ja  v a  2  s  .co m
        zkc.get().delete(zkPath, -1, new AsyncCallback.VoidCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx) {
                if (KeeperException.Code.OK.intValue() == rc || KeeperException.Code.NONODE.intValue() == rc) {
                    promise.complete(null);
                } else {
                    promise.completeExceptionally(KeeperException.create(KeeperException.Code.get(rc)));
                }
            }
        }, null);
    } catch (ZooKeeperClient.ZooKeeperConnectionException e) {
        promise.completeExceptionally(e);
    } catch (InterruptedException e) {
        promise.completeExceptionally(e);
    }
    return promise;
}

From source file:org.apache.distributedlog.impl.acl.ZKAccessControlManager.java

License:Apache License

private void fetchAccessControlEntries(final CompletableFuture<Void> promise) {
    try {//from  w ww. java  2s .  c  o m
        zkc.get().getChildren(zkRootPath, this, new AsyncCallback.Children2Callback() {
            @Override
            public void processResult(int rc, String path, Object ctx, List<String> children, Stat stat) {
                if (KeeperException.Code.OK.intValue() != rc) {
                    promise.completeExceptionally(KeeperException.create(KeeperException.Code.get(rc)));
                    return;
                }
                Set<String> streamsReceived = new HashSet<String>();
                streamsReceived.addAll(children);
                Set<String> streamsCached = streamEntries.keySet();
                Set<String> streamsRemoved = Sets.difference(streamsCached, streamsReceived).immutableCopy();
                for (String s : streamsRemoved) {
                    ZKAccessControl accessControl = streamEntries.remove(s);
                    if (null != accessControl) {
                        logger.info("Removed Access Control Entry for stream {} : {}", s,
                                accessControl.getAccessControlEntry());
                    }
                }
                if (streamsReceived.isEmpty()) {
                    promise.complete(null);
                    return;
                }
                final AtomicInteger numPendings = new AtomicInteger(streamsReceived.size());
                final AtomicInteger numFailures = new AtomicInteger(0);
                for (String s : streamsReceived) {
                    final String streamName = s;
                    ZKAccessControl.read(zkc, zkRootPath + "/" + streamName, null)
                            .whenComplete(new FutureEventListener<ZKAccessControl>() {

                                @Override
                                public void onSuccess(ZKAccessControl accessControl) {
                                    streamEntries.put(streamName, accessControl);
                                    logger.info("Added overrided access control for stream {} : {}", streamName,
                                            accessControl.getAccessControlEntry());
                                    complete();
                                }

                                @Override
                                public void onFailure(Throwable cause) {
                                    if (cause instanceof KeeperException.NoNodeException) {
                                        streamEntries.remove(streamName);
                                    } else if (cause instanceof ZKAccessControl.CorruptedAccessControlException) {
                                        logger.warn(
                                                "Access control is corrupted for stream {} @ {},skipped it ...",
                                                new Object[] { streamName, zkRootPath, cause });
                                        streamEntries.remove(streamName);
                                    } else {
                                        if (1 == numFailures.incrementAndGet()) {
                                            promise.completeExceptionally(cause);
                                        }
                                    }
                                    complete();
                                }

                                private void complete() {
                                    if (0 == numPendings.decrementAndGet() && numFailures.get() == 0) {
                                        promise.complete(null);
                                    }
                                }
                            });
                }
            }
        }, null);
    } catch (ZooKeeperClient.ZooKeeperConnectionException e) {
        promise.completeExceptionally(e);
    } catch (InterruptedException e) {
        promise.completeExceptionally(e);
    }
}

From source file:org.apache.distributedlog.impl.acl.ZKAccessControlManager.java

License:Apache License

private void createDefaultAccessControlEntryIfNeeded(final CompletableFuture<ZKAccessControl> promise) {
    ZooKeeper zk;/*from ww w .  ja  va  2  s  .  co m*/
    try {
        zk = zkc.get();
    } catch (ZooKeeperClient.ZooKeeperConnectionException e) {
        promise.completeExceptionally(e);
        return;
    } catch (InterruptedException e) {
        promise.completeExceptionally(e);
        return;
    }
    ZkUtils.asyncCreateFullPathOptimistic(zk, zkRootPath, new byte[0], zkc.getDefaultACL(),
            CreateMode.PERSISTENT, new AsyncCallback.StringCallback() {
                @Override
                public void processResult(int rc, String path, Object ctx, String name) {
                    if (KeeperException.Code.OK.intValue() == rc) {
                        logger.info("Created zk path {} for default ACL.", zkRootPath);
                        fetchDefaultAccessControlEntry(promise);
                    } else {
                        promise.completeExceptionally(KeeperException.create(KeeperException.Code.get(rc)));
                    }
                }
            }, null);
}

From source file:org.apache.distributedlog.impl.metadata.ZKLogStreamMetadataStore.java

License:Apache License

@Override
public CompletableFuture<Void> logExists(URI uri, final String logName) {
    final String logSegmentsPath = LogMetadata.getLogSegmentsPath(uri, logName,
            conf.getUnpartitionedStreamName());
    final CompletableFuture<Void> promise = new CompletableFuture<Void>();
    try {//www  .  j a v a 2 s  .c om
        final ZooKeeper zk = zooKeeperClient.get();
        zk.sync(logSegmentsPath, new AsyncCallback.VoidCallback() {
            @Override
            public void processResult(int syncRc, String path, Object syncCtx) {
                if (KeeperException.Code.NONODE.intValue() == syncRc) {
                    promise.completeExceptionally(new LogNotFoundException(
                            String.format("Log %s does not exist or has been deleted", logName)));
                    return;
                } else if (KeeperException.Code.OK.intValue() != syncRc) {
                    promise.completeExceptionally(
                            new ZKException("Error on checking log existence for " + logName,
                                    KeeperException.create(KeeperException.Code.get(syncRc))));
                    return;
                }
                zk.exists(logSegmentsPath, false, new AsyncCallback.StatCallback() {
                    @Override
                    public void processResult(int rc, String path, Object ctx, Stat stat) {
                        if (KeeperException.Code.OK.intValue() == rc) {
                            promise.complete(null);
                        } else if (KeeperException.Code.NONODE.intValue() == rc) {
                            promise.completeExceptionally(new LogNotFoundException(
                                    String.format("Log %s does not exist or has been deleted", logName)));
                        } else {
                            promise.completeExceptionally(
                                    new ZKException("Error on checking log existence for " + logName,
                                            KeeperException.create(KeeperException.Code.get(rc))));
                        }
                    }
                }, null);
            }
        }, null);

    } catch (InterruptedException ie) {
        LOG.error("Interrupted while reading {}", logSegmentsPath, ie);
        promise.completeExceptionally(
                new DLInterruptedException("Interrupted while checking " + logSegmentsPath, ie));
    } catch (ZooKeeperClient.ZooKeeperConnectionException e) {
        promise.completeExceptionally(e);
    }
    return promise;
}

From source file:org.apache.distributedlog.impl.metadata.ZKLogStreamMetadataStore.java

License:Apache License

private CompletableFuture<Void> ensureReadLockPathExist(final LogMetadata logMetadata,
        final String readLockPath) {
    final CompletableFuture<Void> promise = new CompletableFuture<Void>();
    promise.whenComplete((value, cause) -> {
        if (cause instanceof CancellationException) {
            FutureUtils.completeExceptionally(promise,
                    new LockCancelledException(readLockPath, "Could not ensure read lock path", cause));
        }/*from w  w  w  . j a  va  2  s .c  o m*/
    });
    Optional<String> parentPathShouldNotCreate = Optional.of(logMetadata.getLogRootPath());
    Utils.zkAsyncCreateFullPathOptimisticRecursive(zooKeeperClient, readLockPath, parentPathShouldNotCreate,
            new byte[0], zooKeeperClient.getDefaultACL(), CreateMode.PERSISTENT,
            new org.apache.zookeeper.AsyncCallback.StringCallback() {
                @Override
                public void processResult(final int rc, final String path, Object ctx, String name) {
                    if (KeeperException.Code.NONODE.intValue() == rc) {
                        FutureUtils.completeExceptionally(promise,
                                new LogNotFoundException(
                                        String.format("Log %s does not exist or has been deleted",
                                                logMetadata.getFullyQualifiedName())));
                    } else if (KeeperException.Code.OK.intValue() == rc) {
                        FutureUtils.complete(promise, null);
                        LOG.trace("Created path {}.", path);
                    } else if (KeeperException.Code.NODEEXISTS.intValue() == rc) {
                        FutureUtils.complete(promise, null);
                        LOG.trace("Path {} is already existed.", path);
                    } else if (DistributedLogConstants.ZK_CONNECTION_EXCEPTION_RESULT_CODE == rc) {
                        FutureUtils.completeExceptionally(promise,
                                new ZooKeeperClient.ZooKeeperConnectionException(path));
                    } else if (DistributedLogConstants.DL_INTERRUPTED_EXCEPTION_RESULT_CODE == rc) {
                        FutureUtils.completeExceptionally(promise, new DLInterruptedException(path));
                    } else {
                        FutureUtils.completeExceptionally(promise,
                                KeeperException.create(KeeperException.Code.get(rc)));
                    }
                }
            }, null);
    return promise;
}

From source file:org.apache.distributedlog.impl.metadata.ZKLogStreamMetadataStore.java

License:Apache License

static void createMissingMetadata(final ZooKeeper zk, final String logRootPath,
        final List<Versioned<byte[]>> metadatas, final List<ACL> acl, final boolean ownAllocator,
        final boolean createIfNotExists, final CompletableFuture<List<Versioned<byte[]>>> promise) {
    final List<byte[]> pathsToCreate = Lists.newArrayListWithExpectedSize(metadatas.size());
    final List<Op> zkOps = Lists.newArrayListWithExpectedSize(metadatas.size());
    CreateMode createMode = CreateMode.PERSISTENT;

    // log root parent path
    if (pathExists(metadatas.get(MetadataIndex.LOG_ROOT_PARENT))) {
        pathsToCreate.add(null);/*  ww  w. jav  a 2  s .  com*/
    } else {
        String logRootParentPath = Utils.getParent(logRootPath);
        pathsToCreate.add(DistributedLogConstants.EMPTY_BYTES);
        zkOps.add(Op.create(logRootParentPath, DistributedLogConstants.EMPTY_BYTES, acl, createMode));
    }

    // log root path
    if (pathExists(metadatas.get(MetadataIndex.LOG_ROOT))) {
        pathsToCreate.add(null);
    } else {
        pathsToCreate.add(DistributedLogConstants.EMPTY_BYTES);
        zkOps.add(Op.create(logRootPath, DistributedLogConstants.EMPTY_BYTES, acl, createMode));
    }

    // max id
    if (pathExists(metadatas.get(MetadataIndex.MAX_TXID))) {
        pathsToCreate.add(null);
    } else {
        byte[] zeroTxnIdData = DLUtils.serializeTransactionId(0L);
        pathsToCreate.add(zeroTxnIdData);
        zkOps.add(Op.create(logRootPath + MAX_TXID_PATH, zeroTxnIdData, acl, createMode));
    }
    // version
    if (pathExists(metadatas.get(MetadataIndex.VERSION))) {
        pathsToCreate.add(null);
    } else {
        byte[] versionData = intToBytes(LAYOUT_VERSION);
        pathsToCreate.add(versionData);
        zkOps.add(Op.create(logRootPath + VERSION_PATH, versionData, acl, createMode));
    }
    // lock path
    if (pathExists(metadatas.get(MetadataIndex.LOCK))) {
        pathsToCreate.add(null);
    } else {
        pathsToCreate.add(DistributedLogConstants.EMPTY_BYTES);
        zkOps.add(Op.create(logRootPath + LOCK_PATH, DistributedLogConstants.EMPTY_BYTES, acl, createMode));
    }
    // read lock path
    if (pathExists(metadatas.get(MetadataIndex.READ_LOCK))) {
        pathsToCreate.add(null);
    } else {
        pathsToCreate.add(DistributedLogConstants.EMPTY_BYTES);
        zkOps.add(
                Op.create(logRootPath + READ_LOCK_PATH, DistributedLogConstants.EMPTY_BYTES, acl, createMode));
    }
    // log segments path
    if (pathExists(metadatas.get(MetadataIndex.LOGSEGMENTS))) {
        pathsToCreate.add(null);
    } else {
        byte[] logSegmentsData = DLUtils
                .serializeLogSegmentSequenceNumber(DistributedLogConstants.UNASSIGNED_LOGSEGMENT_SEQNO);
        pathsToCreate.add(logSegmentsData);
        zkOps.add(Op.create(logRootPath + LOGSEGMENTS_PATH, logSegmentsData, acl, createMode));
    }
    // allocation path
    if (ownAllocator) {
        if (pathExists(metadatas.get(MetadataIndex.ALLOCATION))) {
            pathsToCreate.add(null);
        } else {
            pathsToCreate.add(DistributedLogConstants.EMPTY_BYTES);
            zkOps.add(Op.create(logRootPath + ALLOCATION_PATH, DistributedLogConstants.EMPTY_BYTES, acl,
                    createMode));
        }
    }
    if (zkOps.isEmpty()) {
        // nothing missed
        promise.complete(metadatas);
        return;
    }
    if (!createIfNotExists) {
        promise.completeExceptionally(new LogNotFoundException("Log " + logRootPath + " not found"));
        return;
    }

    zk.multi(zkOps, new AsyncCallback.MultiCallback() {
        @Override
        public void processResult(int rc, String path, Object ctx, List<OpResult> resultList) {
            if (KeeperException.Code.OK.intValue() == rc) {
                List<Versioned<byte[]>> finalMetadatas = Lists.newArrayListWithExpectedSize(metadatas.size());
                for (int i = 0; i < pathsToCreate.size(); i++) {
                    byte[] dataCreated = pathsToCreate.get(i);
                    if (null == dataCreated) {
                        finalMetadatas.add(metadatas.get(i));
                    } else {
                        finalMetadatas.add(new Versioned<byte[]>(dataCreated, new LongVersion(0)));
                    }
                }
                promise.complete(finalMetadatas);
            } else if (KeeperException.Code.NODEEXISTS.intValue() == rc) {
                promise.completeExceptionally(
                        new LogExistsException("Someone just created log " + logRootPath));
            } else {
                if (LOG.isDebugEnabled()) {
                    StringBuilder builder = new StringBuilder();
                    for (OpResult result : resultList) {
                        if (result instanceof OpResult.ErrorResult) {
                            OpResult.ErrorResult errorResult = (OpResult.ErrorResult) result;
                            builder.append(errorResult.getErr()).append(",");
                        } else {
                            builder.append(0).append(",");
                        }
                    }
                    String resultCodeList = builder.substring(0, builder.length() - 1);
                    LOG.debug("Failed to create log, full rc list = {}", resultCodeList);
                }

                promise.completeExceptionally(
                        new ZKException("Failed to create log " + logRootPath, KeeperException.Code.get(rc)));
            }
        }
    }, null);
}

From source file:org.apache.distributedlog.impl.metadata.ZKLogStreamMetadataStore.java

License:Apache License

static CompletableFuture<LogMetadataForWriter> getLog(final URI uri, final String logName,
        final String logIdentifier, final ZooKeeperClient zooKeeperClient, final boolean ownAllocator,
        final boolean createIfNotExists) {
    final String logRootPath = LogMetadata.getLogRootPath(uri, logName, logIdentifier);
    try {// w  w w  .jav  a2 s .  co  m
        PathUtils.validatePath(logRootPath);
    } catch (IllegalArgumentException e) {
        LOG.error("Illegal path value {} for stream {}", new Object[] { logRootPath, logName, e });
        return FutureUtils.exception(new InvalidStreamNameException(logName, "Log name is invalid"));
    }

    try {
        final ZooKeeper zk = zooKeeperClient.get();
        return checkLogMetadataPaths(zk, logRootPath, ownAllocator).thenCompose(
                new Function<List<Versioned<byte[]>>, CompletableFuture<List<Versioned<byte[]>>>>() {
                    @Override
                    public CompletableFuture<List<Versioned<byte[]>>> apply(List<Versioned<byte[]>> metadatas) {
                        CompletableFuture<List<Versioned<byte[]>>> promise = new CompletableFuture<List<Versioned<byte[]>>>();
                        createMissingMetadata(zk, logRootPath, metadatas, zooKeeperClient.getDefaultACL(),
                                ownAllocator, createIfNotExists, promise);
                        return promise;
                    }
                })
                .thenCompose(new Function<List<Versioned<byte[]>>, CompletableFuture<LogMetadataForWriter>>() {
                    @Override
                    public CompletableFuture<LogMetadataForWriter> apply(List<Versioned<byte[]>> metadatas) {
                        try {
                            return FutureUtils.value(
                                    processLogMetadatas(uri, logName, logIdentifier, metadatas, ownAllocator));
                        } catch (UnexpectedException e) {
                            return FutureUtils.exception(e);
                        }
                    }
                });
    } catch (ZooKeeperClient.ZooKeeperConnectionException e) {
        return FutureUtils
                .exception(new ZKException("Encountered zookeeper connection issue on creating log " + logName,
                        KeeperException.Code.CONNECTIONLOSS));
    } catch (InterruptedException e) {
        return FutureUtils.exception(new DLInterruptedException("Interrupted on creating log " + logName, e));
    }
}

From source file:org.apache.distributedlog.impl.metadata.ZKLogStreamMetadataStore.java

License:Apache License

@Override
public CompletableFuture<Void> deleteLog(URI uri, final String logName) {
    final CompletableFuture<Void> promise = new CompletableFuture<Void>();
    try {/*from w  w w.j  a  v  a2  s  .co m*/
        String streamPath = LogMetadata.getLogStreamPath(uri, logName);
        ZKUtil.deleteRecursive(zooKeeperClient.get(), streamPath, new AsyncCallback.VoidCallback() {
            @Override
            public void processResult(int rc, String path, Object ctx) {
                if (KeeperException.Code.OK.intValue() != rc) {
                    FutureUtils.completeExceptionally(promise,
                            new ZKException("Encountered zookeeper issue on deleting log stream " + logName,
                                    KeeperException.Code.get(rc)));
                    return;
                }
                FutureUtils.complete(promise, null);
            }
        }, null);
    } catch (ZooKeeperClient.ZooKeeperConnectionException e) {
        FutureUtils.completeExceptionally(promise,
                new ZKException("Encountered zookeeper issue on deleting log stream " + logName,
                        KeeperException.Code.CONNECTIONLOSS));
    } catch (InterruptedException e) {
        FutureUtils.completeExceptionally(promise,
                new DLInterruptedException("Interrupted while deleting log stream " + logName));
    } catch (KeeperException e) {
        FutureUtils.completeExceptionally(promise,
                new ZKException("Encountered zookeeper issue on deleting log stream " + logName, e));
    }
    return promise;
}

From source file:org.apache.distributedlog.impl.subscription.ZKSubscriptionsStore.java

License:Apache License

@Override
public CompletableFuture<Map<String, DLSN>> getLastCommitPositions() {
    final CompletableFuture<Map<String, DLSN>> result = new CompletableFuture<Map<String, DLSN>>();
    try {/*from w ww  .java2s.  c o  m*/
        this.zkc.get().getChildren(this.zkPath, false, new AsyncCallback.Children2Callback() {
            @Override
            public void processResult(int rc, String path, Object ctx, List<String> children, Stat stat) {
                if (KeeperException.Code.NONODE.intValue() == rc) {
                    result.complete(new HashMap<String, DLSN>());
                } else if (KeeperException.Code.OK.intValue() != rc) {
                    result.completeExceptionally(KeeperException.create(KeeperException.Code.get(rc), path));
                } else {
                    getLastCommitPositions(result, children);
                }
            }
        }, null);
    } catch (ZooKeeperClient.ZooKeeperConnectionException zkce) {
        result.completeExceptionally(zkce);
    } catch (InterruptedException ie) {
        result.completeExceptionally(new DLInterruptedException("getLastCommitPositions was interrupted", ie));
    }
    return result;
}