Java Code Examples for org.apache.zookeeper.AsyncCallback#VoidCallback

@Override
public final void deleteOnlyCurrent(final String key, final AsyncCallback.VoidCallback callback, final Object ctx) throws KeeperException, InterruptedException {
    getProvider().executeContention(new LeaderElection() {
        
        @Override
        public void action() throws KeeperException, InterruptedException {
            getProvider().delete(getProvider().getRealPath(key), callback, ctx);
        }
    });
}
 

@Override
public void deleteOnlyCurrent(final String key, final AsyncCallback.VoidCallback callback, final Object ctx) throws KeeperException, InterruptedException {
    if (getRootNode().equals(key)) {
        deleteNamespace();
        return;
    }
    execStrategy.deleteOnlyCurrent(key, callback, ctx);
}
 

@Override
public void performBackgroundOperation(final OperationAndData<String> operationAndData)
        throws Exception
{
    try
    {
        final TimeTrace   trace = client.getZookeeperClient().startTracer("RemoteWatches-Background");

        AsyncCallback.VoidCallback callback = new AsyncCallback.VoidCallback()
        {
            @Override
            public void processResult(int rc, String path, Object ctx)
            {
                trace.commit();
                CuratorEvent event = new CuratorEventImpl(client, CuratorEventType.REMOVE_WATCHES, rc, path, null, ctx, null, null, null, null, null, null);
                client.processBackgroundOperation(operationAndData, event);
            }
        };

        ZooKeeper zkClient = client.getZooKeeper();
        NamespaceWatcher namespaceWatcher = makeNamespaceWatcher(operationAndData.getData());
        if(namespaceWatcher == null)
        {
            zkClient.removeAllWatches(operationAndData.getData(), watcherType, local, callback, operationAndData.getContext());
        }
        else
        {
            zkClient.removeWatches(operationAndData.getData(), namespaceWatcher, watcherType, local, callback, operationAndData.getContext());
        }
    }
    catch ( Throwable e )
    {
        backgrounding.checkError(e, null);
    }
}
 

public static void collectLedgers(BookKeeper bk, long ledgerId, AsyncCallback.VoidCallback cb, Map<Long, LedgerMetadata> ledgers) {
    try {
        bk.getLedgerManager()
          .readLedgerMetadata(ledgerId)
          .thenAccept((v) -> {
              LOG.debug("Got ledger metadata");
              ledgers.put(ledgerId, v.getValue());
          })
          .thenAccept((v) -> {
              cb.processResult(BKException.Code.OK, null, null);
          });
    } catch (Exception ex) {
        throw new RuntimeException(ex);
    }
}
 

@Override
public void deleteOnlyCurrent(final String key, final AsyncCallback.VoidCallback callback, final Object ctx) throws KeeperException, InterruptedException {
    super.deleteOnlyCurrent(key, callback, ctx);
    pathTree.delete(PathUtil.getRealPath(getRootNode(), key));
}
 

@Override
public final void delete(final String key, final AsyncCallback.VoidCallback callback, final Object ctx) {
    holder.getZooKeeper().delete(key, ZookeeperConstants.VERSION, callback, ctx);
}
 

@Override
public void deleteOnlyCurrent(final String key, final AsyncCallback.VoidCallback callback, final Object ctx) throws KeeperException, InterruptedException {
    getProvider().delete(getProvider().getRealPath(key), callback, ctx);
}
 

public void sync(String path, AsyncCallback.VoidCallback cb, Object ctx) throws KeeperException {
  checkZk().sync(path, cb, ctx);
}
 

public void delete(final String path, final int version, final AsyncCallback.VoidCallback cb, final Object ctx) {
    zooKeeper.delete(path, version, cb, ctx);
}
 

public void sync(final String path, final AsyncCallback.VoidCallback cb, final Object ctx) {
    zooKeeper.sync(path, cb, ctx);
}
 

@Override
public void delete(String path, int version, AsyncCallback.VoidCallback cb, Object ctx) {
    delegate.delete(path, version, cb, ctx);
}
 

@Override
public void sync(String path, AsyncCallback.VoidCallback cb, Object ctx) {
    delegate.sync(path, cb, ctx);
}
 

/**
 * Only delete target node..
 *
 * @param key key
 * @param callback callback
 * @param ctx context
 * @throws KeeperException zookeeper exception
 * @throws InterruptedException interrupted exception
 */
void deleteOnlyCurrent(String key, AsyncCallback.VoidCallback callback, Object ctx) throws KeeperException, InterruptedException;
 

/**
 * Only delete target node.
 *
 * @param key key
 * @param callback callback
 * @param ctx ctx
 * @throws KeeperException zookeeper exception
 * @throws InterruptedException interrupted exception
 */
void delete(String key, AsyncCallback.VoidCallback callback, Object ctx) throws KeeperException, InterruptedException;
 

void delete(String path, int version, AsyncCallback.VoidCallback cb, Object ctx); 

void sync(String path, AsyncCallback.VoidCallback cb, Object ctx);