How to use

fromListenableFuture

method

in

org.apache.bookkeeper.common.util.ListenableFutures

/**
 * Convert a {@link ListenableFuture} to a {@link CompletableFuture}.
 *
 * @param listenableFuture listenable future to convert.
 * @return the completable future.
 */
public static <T> CompletableFuture<T> fromListenableFuture(ListenableFuture<T> listenableFuture) {
  return fromListenableFuture(listenableFuture, Function.identity());
}

/**
 * Run the action with retries.
 *
 * @param action action to run
 * @return the result of the action
 */
public <T> CompletableFuture<T> executeListenable(Supplier<ListenableFuture<T>> action) {
  return Retries.run(
    backoffPolicy.toBackoffs(),
    retryPredicate,
    () -> fromListenableFuture(action.get()),
    scheduler
  );
}

@Override
public CompletableFuture<List<OneStorageContainerEndpointResponse>>
locateStorageContainers(List<Revisioned<Long>> storageContainerIds) {
  GetStorageContainerEndpointRequest request = createGetStorageContainerEndpointRequest(storageContainerIds);
  return Retries.run(
    getDefaultBackoffs(),
    LOCATE_STORAGE_CONTAINERS_RETRY_PREDICATE,
    () -> fromListenableFuture(
      locationService.getStorageContainerEndpoint(request),
      GetStorageContainerEndpointsFunction),
    scheduler,
    request);
}

@Override
public CompletableFuture<Boolean> deleteNamespace(String namespace) {
  return retryUtils.execute(() ->
    fromListenableFuture(rootRangeService.deleteNamespace(createDeleteNamespaceRequest(namespace)))
  ).thenCompose(resp -> {
    if (StatusCode.SUCCESS == resp.getCode()) {
      return FutureUtils.value(true);
    } else {
      return FutureUtils.exception(createRootRangeException(namespace, resp.getCode()));
    }
  });
}

@Override
public CompletableFuture<Boolean> deleteStream(String namespace, String streamName) {
  return retryUtils.execute(() ->
    fromListenableFuture(rootRangeService.deleteStream(
      createDeleteStreamRequest(namespace, streamName)))
  ).thenCompose(resp -> {
    if (StatusCode.SUCCESS == resp.getCode()) {
      return FutureUtils.value(true);
    } else {
      return FutureUtils.exception(createRootRangeException(namespace, resp.getCode()));
    }
  });
}

@Override
public CompletableFuture<NamespaceProperties> getNamespace(String namespace) {
  return retryUtils.execute(() ->
    fromListenableFuture(rootRangeService.getNamespace(createGetNamespaceRequest(namespace)))
  ).thenCompose(resp -> {
    if (StatusCode.SUCCESS == resp.getCode()) {
      return FutureUtils.value(resp.getNsProps());
    } else {
      return FutureUtils.exception(createRootRangeException(namespace, resp.getCode()));
    }
  });
}

@Override
public CompletableFuture<NamespaceProperties> createNamespace(String namespace, NamespaceConfiguration conf) {
  return retryUtils.execute(() ->
    fromListenableFuture(rootRangeService.createNamespace(createCreateNamespaceRequest(namespace, conf)))
  ).thenCompose(resp -> {
    if (StatusCode.SUCCESS == resp.getCode()) {
      return FutureUtils.value(resp.getNsProps());
    } else {
      return FutureUtils.exception(createRootRangeException(namespace, resp.getCode()));
    }
  });
}

@Override
public CompletableFuture<StreamProperties> getStream(String namespace, String streamName) {
  return retryUtils.execute(() ->
    fromListenableFuture(rootRangeService.getStream(
      createGetStreamRequest(namespace, streamName)))
  ).thenCompose(resp -> {
    if (StatusCode.SUCCESS == resp.getCode()) {
      return FutureUtils.value(resp.getStreamProps());
    } else {
      return FutureUtils.exception(createRootRangeException(namespace, resp.getCode()));
    }
  });
}

@Override
public CompletableFuture<StreamProperties> createStream(String namespace,
                            String streamName,
                            StreamConfiguration streamConfiguration) {
  return retryUtils.execute(() ->
    fromListenableFuture(rootRangeService.createStream(
      createCreateStreamRequest(namespace, streamName, streamConfiguration)))
  ).thenCompose(resp -> {
    if (StatusCode.SUCCESS == resp.getCode()) {
      return FutureUtils.value(resp.getStreamProps());
    } else {
      return FutureUtils.exception(createRootRangeException(namespace, resp.getCode()));
    }
  });
}

private void openTableImpl(String namespaceName,
              String streamName,
              CompletableFuture<PTable<ByteBuf, ByteBuf>> future) {
  CompletableFuture<StreamProperties> getStreamFuture = retryUtils.execute(() ->
    fromListenableFuture(rootRangeService.getStream(
      createGetStreamRequest(namespaceName, streamName)))
  ).thenCompose(resp -> {
    if (StatusCode.SUCCESS == resp.getCode()) {
      StreamProperties streamProps = resp.getStreamProps();
      log.info("Retrieved table properties for table {}/{} : {}",
        namespaceName, streamName, streamProps);
      if (StorageType.TABLE != streamProps.getStreamConf().getStorageType()) {
        return FutureUtils.exception(new ApiException(
          "Can't open a non-table storage entity : " + streamProps.getStreamConf().getStorageType()));
      } else {
        return FutureUtils.value(streamProps);
      }
    } else {
      return FutureUtils.exception(createRootRangeException(namespaceName, resp.getCode()));
    }
  });
  FutureUtils.proxyTo(
    getStreamFuture.thenApply(streamProps ->
      new PByteBufSimpleTableImpl(streamProps, managedChannel, CallOptions.DEFAULT, retryUtils)),
    future);
}