Java CompletableFuture.completeExceptionally方法代码示例

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Override
public CompletionStage<ClusterConnectionReport> closeConnectionAsync(
    SocketAddress connection, CloseType type) {

  for (BoundNode node : this.getNodes()) {
    // identify the node that has the connection and close it with that node.
    for (SocketAddress address : node.getConnections().getConnections()) {
      if (connection.equals(address)) {
        return node.closeConnectionAsync(address, type)
            .thenApply(NodeConnectionReport::getRootReport);
      }
    }
  }

  CompletableFuture<ClusterConnectionReport> failedFuture = new CompletableFuture<>();
  failedFuture.completeExceptionally(new IllegalArgumentException("Not found"));
  return failedFuture;
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
private static <T> CompletableFuture<T> run(ThriftCall<T> call) {
    ThriftCompletableFuture<T> future = new ThriftCompletableFuture<>();
    try {
        call.apply(future);
    } catch (Exception e) {
        final Throwable cause;
        if (e instanceof InvocationTargetException) {
            cause = MoreObjects.firstNonNull(e.getCause(), e);
        } else {
            cause = e;
        }
        CompletableFuture<T> failedFuture = new CompletableFuture<>();
        failedFuture.completeExceptionally(cause);
        return failedFuture;
    }
    return future;
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
private void onConnectResponse(final String shardName, final long cookie,
        final CompletableFuture<ShardBackendInfo> future, final Object response, final Throwable failure) {
    if (failure != null) {
        LOG.debug("Connect attempt to {} failed, will retry", shardName, failure);
        future.completeExceptionally(wrap("Connection attempt failed", failure));
        return;
    }
    if (response instanceof RequestFailure) {
        final Throwable cause = ((RequestFailure<?, ?>) response).getCause().unwrap();
        LOG.debug("Connect attempt to {} failed to process", shardName, cause);
        final Throwable result = cause instanceof NotLeaderException
                ? wrap("Leader moved during establishment", cause) : cause;
        future.completeExceptionally(result);
        return;
    }

    LOG.debug("Resolved backend information to {}", response);
    Preconditions.checkArgument(response instanceof ConnectClientSuccess, "Unhandled response %s",
        response);
    final ConnectClientSuccess success = (ConnectClientSuccess) response;
    future.complete(new ShardBackendInfo(success.getBackend(), nextSessionId.getAndIncrement(),
        success.getVersion(), shardName, UnsignedLong.fromLongBits(cookie), success.getDataTree(),
        success.getMaxMessages()));
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Override
public CompletableFuture<MeterStoreResult> storeMeter(Meter meter) {
    CompletableFuture<MeterStoreResult> future = new CompletableFuture<>();
    MeterKey key = MeterKey.key(meter.deviceId(), meter.id());
    futures.put(key, future);
    MeterData data = new MeterData(meter, null, local);

    try {
        meters.put(key, data);
    } catch (StorageException e) {
        future.completeExceptionally(e);
    }

    return future;

}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * thenCompose result completes exceptionally after exceptional
 * completion of source
 */
public void testThenCompose_exceptionalCompletion() {
    for (ExecutionMode m : ExecutionMode.values())
    for (boolean createIncomplete : new boolean[] { true, false })
{
    final CFException ex = new CFException();
    final CompletableFutureInc r = new CompletableFutureInc(m);
    final CompletableFuture<Integer> f = new CompletableFuture<>();
    if (!createIncomplete) f.completeExceptionally(ex);
    final CompletableFuture<Integer> g = m.thenCompose(f, r);
    if (createIncomplete) f.completeExceptionally(ex);

    checkCompletedWithWrappedException(g, ex);
    checkCompletedExceptionally(f, ex);
    r.assertNotInvoked();
}}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * minimalStage.toCompletableFuture() returns a CompletableFuture that
 * is completed exceptionally when source is.
 */
public void testMinimalCompletionStage_toCompletableFuture_exceptionalCompletion() {
    for (boolean createIncomplete : new boolean[] { true, false })
{
    CFException ex = new CFException();
    CompletableFuture<Integer> f = new CompletableFuture<>();
    CompletionStage<Integer> minimal = f.minimalCompletionStage();
    if (!createIncomplete) f.completeExceptionally(ex);
    CompletableFuture<Integer> g = minimal.toCompletableFuture();
    if (createIncomplete) {
        checkIncomplete(f);
        checkIncomplete(g);
        f.completeExceptionally(ex);
    }
    checkCompletedExceptionally(f, ex);
    checkCompletedWithWrappedException(g, ex);
}}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * completeExceptionally completes exceptionally, as indicated by
 * methods isDone, isCancelled, join, get, and getNow
 */
public void testCompleteExceptionally() {
    CompletableFuture<Integer> f = new CompletableFuture<>();
    CFException ex = new CFException();
    checkIncomplete(f);
    f.completeExceptionally(ex);
    checkCompletedExceptionally(f, ex);
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Override
public CompletableFuture<com.fnproject.fn.api.flow.HttpResponse> invokeFunction(String fnId, HttpMethod method, Headers headers, byte[] data) {
    FnFunctionStub stub = functionStubs
       .computeIfAbsent(fnId, (k) -> {
           throw new IllegalStateException("Function was invoked that had no definition: " + k);
       });

    try {
        return CompletableFuture.completedFuture(stub.stubFunction(method, headers, data));
    } catch (Exception e) {
        CompletableFuture<com.fnproject.fn.api.flow.HttpResponse> respFuture = new CompletableFuture<>();
        respFuture.completeExceptionally(e);
        return respFuture;
    }
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Override
CompletableFuture<Void> whenReceivingResponse() {
    CompletableFuture<Void> cf = new MinimalFuture<>();
    try {
        ReceiveResponseEvent evt = new ReceiveResponseEvent(cf);
        client.registerEvent(evt);
    } catch (IOException e) {
        cf.completeExceptionally(e);
    }
    return cf;
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void resolveProductTypeReference_WithExceptionOnProductTypeFetch_ShouldNotResolveReference() {
    final ProductDraftBuilder productBuilder = getBuilderWithProductTypeRefId(PRODUCT_TYPE_ID)
        .key("dummyKey");

    final CompletableFuture<Optional<String>> futureThrowingSphereException = new CompletableFuture<>();
    futureThrowingSphereException.completeExceptionally(new SphereException("CTP error on fetch"));
    when(productTypeService.fetchCachedProductTypeId(anyString())).thenReturn(futureThrowingSphereException);

    assertThat(referenceResolver.resolveProductTypeReference(productBuilder).toCompletableFuture())
        .hasFailed()
        .hasFailedWithThrowableThat()
        .isExactlyInstanceOf(SphereException.class)
        .hasMessageContaining("CTP error on fetch");
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Override
public CompletableFuture<U> create(final C credentials, final AsyncWebContext context) {
    try {
        final CompletableFuture<T> tokenFuture = new CompletableFuture<>();
        try {
            tokenFuture.complete(getAccessToken(credentials));
        } catch (HttpAction action) {
            tokenFuture.completeExceptionally(action);
        }
        return tokenFuture.thenCompose(this::retrieveUserProfileFromToken);
    } catch (final OAuthException e) {
        throw new TechnicalException(e);
    }
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * Tests the accounting of pending writes.
 */
@Test
public void testNonTransactionalWriterProcessElementAccounting() throws Exception {
    try (NonTransactionalWriterTestContext context = new NonTransactionalWriterTestContext(PravegaWriterMode.ATLEAST_ONCE)) {
        try (StreamSinkOperatorTestHarness<Integer> testHarness = createTestHarness(context.sinkFunction)) {
            testHarness.open();
            FlinkPravegaWriter.NonTransactionalWriter internalWriter = (FlinkPravegaWriter.NonTransactionalWriter) context.sinkFunction.writer;

            CompletableFuture<Void> e1Future = context.prepareWrite();
            StreamRecord<Integer> e1 = new StreamRecord<>(1, 1L);
            testHarness.processElement(e1);
            Assert.assertEquals(1, internalWriter.pendingWritesCount.get());

            CompletableFuture<Void> e2Future = context.prepareWrite();
            StreamRecord<Integer> e2 = new StreamRecord<>(2, 2L);
            testHarness.processElement(e2);
            Assert.assertEquals(2, internalWriter.pendingWritesCount.get());

            CompletableFuture<Void> e3Future = context.prepareWrite();
            StreamRecord<Integer> e3 = new StreamRecord<>(3, 3L);
            testHarness.processElement(e3);
            Assert.assertEquals(3, internalWriter.pendingWritesCount.get());

            e1Future.complete(null);
            e2Future.completeExceptionally(new IntentionalRuntimeException());
            e3Future.complete(null);
            Assert.assertEquals(0, internalWriter.pendingWritesCount.get());

            // clear the error for test simplicity
            internalWriter.writeError.set(null);
        }
    }
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * runAfterBoth result completes exceptionally after exceptional
 * completion of either source
 */
public void testRunAfterBoth_exceptionalCompletion() throws Throwable {
    for (ExecutionMode m : ExecutionMode.values())
    for (boolean fFirst : new boolean[] { true, false })
    for (boolean failFirst : new boolean[] { true, false })
    for (Integer v1 : new Integer[] { 1, null })
{
    final CompletableFuture<Integer> f = new CompletableFuture<>();
    final CompletableFuture<Integer> g = new CompletableFuture<>();
    final CFException ex = new CFException();
    final Noop r1 = new Noop(m);
    final Noop r2 = new Noop(m);
    final Noop r3 = new Noop(m);

    final CompletableFuture<Integer> fst =  fFirst ? f : g;
    final CompletableFuture<Integer> snd = !fFirst ? f : g;
    final Callable<Boolean> complete1 = failFirst ?
        () -> fst.completeExceptionally(ex) :
        () -> fst.complete(v1);
    final Callable<Boolean> complete2 = failFirst ?
        () -> snd.complete(v1) :
        () -> snd.completeExceptionally(ex);

    final CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
    assertTrue(complete1.call());
    final CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
    checkIncomplete(h1);
    checkIncomplete(h2);
    assertTrue(complete2.call());
    final CompletableFuture<Void> h3 = m.runAfterBoth(f, g, r3);

    checkCompletedWithWrappedException(h1, ex);
    checkCompletedWithWrappedException(h2, ex);
    checkCompletedWithWrappedException(h3, ex);
    r1.assertNotInvoked();
    r2.assertNotInvoked();
    r3.assertNotInvoked();
    checkCompletedNormally(failFirst ? snd : fst, v1);
    checkCompletedExceptionally(failFirst ? fst : snd, ex);
}}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test public void wrapFuture_futureBecomesExpectedFailure() throws Exception {
  CompletableFuture<String> future = new CompletableFuture<>();
  CompletionStage<Maybe<String, MyException>> stage =
      Maybe.catchException(MyException.class, future);
  assertPending(stage);
  MyException exception = new MyException("test");
  future.completeExceptionally(exception);
  assertCompleted(stage).isEqualTo(Maybe.except(exception));
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Override
public CompletableFuture<Void> connectAsync() {
    CompletableFuture<Void> plainFuture = new MinimalFuture<>();
    try {
        chan.configureBlocking(false);
        chan.connect(address);
        client.registerEvent(new ConnectEvent(plainFuture));
    } catch (IOException e) {
        plainFuture.completeExceptionally(e);
    }
    return plainFuture;
}