Java CheckedFuture.checkedGet方法代码示例

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
/**
 * Tests that the {@link CheckedFuture#checkedGet()} method throws the correct
 * type of cancellation exception when it is cancelled.
 */
public void testCheckedGetThrowsApplicationExceptionOnCancellation() {

  final CheckedFuture<Boolean, ?> future =
      createCheckedFuture(Boolean.TRUE, null, latch);

  assertFalse(future.isDone());
  assertFalse(future.isCancelled());

  new Thread(new Runnable() {
    @Override
    public void run() {
      future.cancel(true);
    }
  }).start();

  try {
    future.checkedGet();
    fail("RPC Should have been cancelled.");
  } catch (Exception e) {
    checkCancelledException(e);
  }

  assertTrue(future.isDone());
  assertTrue(future.isCancelled());
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
public void testCheckedGetThrowsApplicationExceptionOnError() {
  final CheckedFuture<Boolean, ?> future =
      createCheckedFuture(Boolean.TRUE, new Exception("Error"), latch);

  assertFalse(future.isDone());
  assertFalse(future.isCancelled());

  new Thread(new Runnable() {
    @Override
    public void run() {
      latch.countDown();
    }
  }).start();

  try {
    future.checkedGet();
    fail();
  } catch (Exception e) {
    checkExecutionException(e);
  }

  assertTrue(future.isDone());
  assertFalse(future.isCancelled());
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
private String readFromGreetingRegistry(HelloWorldInput input) {
    String result = "Hello " + input.getName();
    ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
    InstanceIdentifier<GreetingRegistryEntry> iid = toInstanceIdentifier(input);
    CheckedFuture<Optional<GreetingRegistryEntry>, ReadFailedException> future =
            transaction.read(LogicalDatastoreType.CONFIGURATION, iid);
    Optional<GreetingRegistryEntry> optional = Optional.absent();
    try {
        optional = future.checkedGet();
    } catch (ReadFailedException e) {
        LOG.warn("Reading greeting failed:",e);
    }
    if(optional.isPresent()) {
        result = optional.get().getGreeting();
    }
    return result;
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
/**
 * A simple unbound producer. It write some basic things into the data store based on the
 * test model.
 * @throws DOMDataTreeProducerException
 * @throws TransactionCommitFailedException
 */
@Test
public final void testBasicProducer() throws DOMDataTreeProducerException, TransactionCommitFailedException {
    // Create a producer. It is an AutoCloseable resource, hence the try-with pattern
    try (final DOMDataTreeProducer prod = service().createProducer(Collections.singleton(UNORDERED_CONTAINER_TREE))) {
        assertNotNull(prod);

        final DOMDataWriteTransaction tx = prod.createTransaction(true);
        assertNotNull(tx);

        tx.put(LogicalDatastoreType.OPERATIONAL, UNORDERED_CONTAINER_IID, ImmutableContainerNodeBuilder.create().build());

        final CheckedFuture<Void, TransactionCommitFailedException> f = tx.submit();
        assertNotNull(f);

        f.checkedGet();
    }
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
@Override
public String getModuleSource(final org.opendaylight.yangtools.yang.model.api.ModuleIdentifier moduleIdentifier) {
    final CheckedFuture<? extends YangTextSchemaSource, SchemaSourceException> source = this.sourceProvider
            .getSource(SourceIdentifier.create(moduleIdentifier.getName(),
                    Optional.fromNullable(QName.formattedRevision(moduleIdentifier.getRevision()))));

    try {
        final YangTextSchemaSource yangTextSchemaSource = source.checkedGet();
        try (InputStream inStream = yangTextSchemaSource.openStream()) {
            return new String(ByteStreams.toByteArray(inStream), StandardCharsets.UTF_8);
        }
    } catch (SchemaSourceException | IOException e) {
        LOG.warn("Unable to provide source for {}", moduleIdentifier, e);
        throw new IllegalArgumentException("Unable to provide source for " + moduleIdentifier, e);
    }
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
/**
 * This test method invokes and executes the remote rpc.
 */
@Test(expected = DOMRpcException.class)
public void testInvokeRpcWithRemoteFailedFuture() throws Exception {
    final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
    @SuppressWarnings({"unchecked", "rawtypes"})
    final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
            (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);

    when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
            Futures.<DOMRpcResult, DOMRpcException>immediateFailedCheckedFuture(new RemoteDOMRpcException(
                    "Test Exception", null)));

    final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
            remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
    assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
    frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
/**
 * This test method invokes and executes the remote rpc.
 */
@Test
public void testInvokeRpc() throws Exception {
    final ContainerNode rpcOutput = makeRPCOutput("bar");
    final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);

    final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
    @SuppressWarnings({"unchecked", "rawtypes"})
    final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
            (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);

    when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
            Futures.<DOMRpcResult, DOMRpcException>immediateCheckedFuture(rpcResult));

    final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
            remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
    assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);

    final DOMRpcResult result = frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
    assertEquals(rpcOutput, result.getResult());
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
public void testCheckedGetThrowsApplicationExceptionOnInterruption()
    throws InterruptedException {

  final CheckedFuture<Boolean, ?> future =
      createCheckedFuture(Boolean.TRUE, null, latch);

  final CountDownLatch startingGate = new CountDownLatch(1);
  final CountDownLatch successLatch = new CountDownLatch(1);

  assertFalse(future.isDone());
  assertFalse(future.isCancelled());

  Thread getThread = new Thread(new Runnable() {
    @Override
    public void run() {
      startingGate.countDown();

      try {
        future.checkedGet();
      } catch (Exception e) {
        checkInterruptedException(e);

        // This only gets hit if the original call throws an exception and
        // the check call above passes.
        successLatch.countDown();
      }
    }
  });
  getThread.start();

  assertTrue(startingGate.await(500, TimeUnit.MILLISECONDS));
  getThread.interrupt();

  assertTrue(successLatch.await(500, TimeUnit.MILLISECONDS));

  assertFalse(future.isDone());
  assertFalse(future.isCancelled());
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
private void validateGreetingRegistry(String name) {
    InstanceIdentifier<GreetingRegistryEntry> iid = InstanceIdentifier.create(GreetingRegistry.class)
            .child(GreetingRegistryEntry.class, new GreetingRegistryEntryKey(name));
    DataBroker db = getSession().getSALService(DataBroker.class);
    ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
    CheckedFuture<Optional<GreetingRegistryEntry>, ReadFailedException> future =
            transaction.read(LogicalDatastoreType.OPERATIONAL, iid);
    Optional<GreetingRegistryEntry> optional = Optional.absent();
    try {
        optional = future.checkedGet();
    } catch (ReadFailedException e) {
        LOG.warn("Reading greeting failed:",e);
    }
    Assert.assertTrue(name + " not recorded in greeting registry",optional.isPresent());
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
/**
 * This test method invokes and tests exceptions when akka timeout occured
 * Currently ignored since this test with current config takes around 15 seconds to complete.
 */
@Ignore
@Test(expected = RemoteDOMRpcException.class)
public void testInvokeRpcWithAkkaTimeoutException() throws Exception {
    final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
    final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
            remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
    assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);

    frontEndFuture.checkedGet(20, TimeUnit.SECONDS);
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
@Test(expected = SchemaSourceException.class)
public void getNonExistingSchemaSource() throws Exception {
    Futures.failed(new Exception("halo"));

    Mockito.when(mockedRemoteSchemaRepository.getYangTextSchemaSource(ID)).thenReturn(
            Futures.failed(
                    new SchemaSourceException("Source not provided")));

    CheckedFuture<?, ?> sourceFuture = remoteSchemaProvider.getSource(ID);
    assertTrue(sourceFuture.isDone());
    sourceFuture.checkedGet();
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
/**
 * This test method invokes remote rpc and lookup failed
 * with runtime exception.
 */
@Test(expected = DOMRpcException.class)
public void testInvokeRpcWithLookupException() throws Exception {
    final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");

    doThrow(new RuntimeException("test")).when(domRpcService2).invokeRpc(any(SchemaPath.class),
        any(NormalizedNode.class));

    final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
            remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
    assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);

    frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
@Override
public void executeList() {
    final LogicalDatastoreType dsType = getDataStoreType();

    try (ReadOnlyTransaction tx = bindingDataBroker.newReadOnlyTransaction()) {
        for (long l = 0; l < outerListElem; l++) {

            InstanceIdentifier<OuterList> iid = InstanceIdentifier.create(TestExec.class)
                    .child(OuterList.class, new OuterListKey((int) l));
            CheckedFuture<Optional<OuterList>, ReadFailedException> submitFuture =
                    tx.read(dsType, iid);

            try {
                Optional<OuterList> optionalDataObject = submitFuture.checkedGet();
                if (optionalDataObject != null && optionalDataObject.isPresent()) {
                    OuterList outerList = optionalDataObject.get();

                    String[] objectsArray = new String[outerList.getInnerList().size()];
                    for (InnerList innerList : outerList.getInnerList()) {
                        if (objectsArray[innerList.getName()] != null) {
                            LOG.error("innerList: DUPLICATE name: {}, value: {}", innerList.getName(),
                                innerList.getValue());
                        }
                        objectsArray[innerList.getName()] = innerList.getValue();
                    }
                    for (int i = 0; i < outerList.getInnerList().size(); i++) {
                        String itemStr = objectsArray[i];
                        if (!itemStr.contentEquals("Item-" + String.valueOf(l) + "-" + String.valueOf(i))) {
                            LOG.error("innerList: name: {}, value: {}", i, itemStr);
                            break;
                        }
                    }
                    txOk++;
                } else {
                    txError++;
                }
            } catch (final ReadFailedException e) {
                LOG.warn("failed to ....", e);
                txError++;
            }
        }
    }
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
@Override
public void executeList() {
    final LogicalDatastoreType dsType = getDataStoreType();

    try (ReadOnlyTransaction tx = dataBroker.newReadOnlyTransaction()) {
        for (long l = 0; l < outerListElem; l++) {

            InstanceIdentifier<OuterList> iid = InstanceIdentifier.create(TestExec.class)
                    .child(OuterList.class, new OuterListKey((int)l));
            Optional<OuterList> optionalDataObject;
            CheckedFuture<Optional<OuterList>, ReadFailedException> submitFuture = tx.read(dsType, iid);
            try {
                optionalDataObject = submitFuture.checkedGet();
                if (optionalDataObject != null && optionalDataObject.isPresent()) {
                    OuterList outerList = optionalDataObject.get();

                    String[] objectsArray = new String[outerList.getInnerList().size()];

                    for (InnerList innerList : outerList.getInnerList()) {
                        if (objectsArray[innerList.getName()] != null) {
                            LOG.error("innerList: DUPLICATE name: {}, value: {}", innerList.getName(),
                                innerList.getValue());
                        }
                        objectsArray[innerList.getName()] = innerList.getValue();
                    }
                    for (int i = 0; i < outerList.getInnerList().size(); i++) {
                        String itemStr = objectsArray[i];
                        if (!itemStr.contentEquals("Item-" + String.valueOf(l) + "-" + String.valueOf(i))) {
                            LOG.error("innerList: name: {}, value: {}", i, itemStr);
                            break;
                        }
                    }
                    txOk++;
                } else {
                    txError++;
                }
            } catch (final ReadFailedException e) {
                LOG.warn("failed to ....", e);
                txError++;
            }
        }
    }
}
 

import com.google.common.util.concurrent.CheckedFuture; //导入方法依赖的package包/类
@Test
public void testCreateChainedTransactionsInQuickSuccession() throws Exception {
    new IntegrationTestKit(getSystem(), datastoreContextBuilder) {
        {
            try (AbstractDataStore dataStore = setupAbstractDataStore(
                    testParameter, "testCreateChainedTransactionsInQuickSuccession", "cars-1")) {

                final ConcurrentDOMDataBroker broker = new ConcurrentDOMDataBroker(
                        ImmutableMap.<LogicalDatastoreType, DOMStore>builder()
                                .put(LogicalDatastoreType.CONFIGURATION, dataStore).build(),
                        MoreExecutors.directExecutor());

                final TransactionChainListener listener = Mockito.mock(TransactionChainListener.class);
                DOMTransactionChain txChain = broker.createTransactionChain(listener);

                final List<CheckedFuture<Void, TransactionCommitFailedException>> futures = new ArrayList<>();

                final DOMDataWriteTransaction writeTx = txChain.newWriteOnlyTransaction();
                writeTx.put(LogicalDatastoreType.CONFIGURATION, CarsModel.BASE_PATH, CarsModel.emptyContainer());
                writeTx.put(LogicalDatastoreType.CONFIGURATION, CarsModel.CAR_LIST_PATH, CarsModel.newCarMapNode());
                futures.add(writeTx.submit());

                int numCars = 100;
                for (int i = 0; i < numCars; i++) {
                    final DOMDataReadWriteTransaction rwTx = txChain.newReadWriteTransaction();

                    rwTx.merge(LogicalDatastoreType.CONFIGURATION, CarsModel.newCarPath("car" + i),
                            CarsModel.newCarEntry("car" + i, BigInteger.valueOf(20000)));

                    futures.add(rwTx.submit());
                }

                for (final CheckedFuture<Void, TransactionCommitFailedException> f : futures) {
                    f.checkedGet();
                }

                final Optional<NormalizedNode<?, ?>> optional = txChain.newReadOnlyTransaction()
                        .read(LogicalDatastoreType.CONFIGURATION, CarsModel.CAR_LIST_PATH).get(5, TimeUnit.SECONDS);
                assertEquals("isPresent", true, optional.isPresent());
                assertEquals("# cars", numCars, ((Collection<?>) optional.get().getValue()).size());

                txChain.close();

                broker.close();
            }
        }
    };
}