Example usage for com.google.common.util.concurrent Futures immediateFailedCheckedFuture

List of usage examples for com.google.common.util.concurrent Futures immediateFailedCheckedFuture

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. Futures
  6. immediateFailedCheckedFuture

Introduction

In this page you can find the example usage for com.google.common.util.concurrent Futures immediateFailedCheckedFuture.

Prototype

@GwtIncompatible("TODO")
@CheckReturnValue
public static <V, X extends Exception> CheckedFuture<V, X> immediateFailedCheckedFuture(X exception)

Source Link

Document

Returns a CheckedFuture which has an exception set immediately upon construction.

Usage

From source file:com.ibm.stocator.fs.cos.SemaphoredDelegatingExecutor.java

@Override
public <T> ListenableFuture<T> submit(Runnable task, T result) {
    try {//from ww w.j  av  a  2  s  .c om
        queueingPermits.acquire();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return Futures.immediateFailedCheckedFuture(e);
    }
    return super.submit(new RunnableWithPermitRelease(task), result);
}

From source file:org.opendaylight.aaa.authz.srv.AuthzDataReadWriteTransaction.java

@Override
public CheckedFuture<Boolean, ReadFailedException> exists(LogicalDatastoreType logicalDatastoreType,
        YangInstanceIdentifier yangInstanceIdentifier) {

    if (AuthzServiceImpl.isAuthorized(logicalDatastoreType, yangInstanceIdentifier, ActionType.Exists)) {
        return domDataReadWriteTransaction.exists(logicalDatastoreType, yangInstanceIdentifier);
    }//w  ww . j a v  a2  s.  co m
    ReadFailedException e = new ReadFailedException("Authorization Failed");
    return Futures.immediateFailedCheckedFuture(e);
}

From source file:org.opendaylight.centinel.impl.ConfigurationServiceImpl.java

@Override
public Future<RpcResult<SetCentinelConfigurationsOutput>> setCentinelConfigurations(
        SetCentinelConfigurationsInput input) {
    final SettableFuture<RpcResult<SetCentinelConfigurationsOutput>> futureResult = SettableFuture.create();

    final ReadWriteTransaction tx = dataProvider.newReadWriteTransaction();

    if (input.getGraylogIp().isEmpty() || input.getGraylogIp().trim().isEmpty()
            || input.getGraylogIp() == null) {
        LOG.debug("IP cannot be null");
        return Futures.immediateFailedCheckedFuture(
                new TransactionCommitFailedException("invalid-input", RpcResultBuilder
                        .newError(ErrorType.APPLICATION, "invalid-input", "Graylog IP cannot be null")));
    }//from   ww  w.  jav a 2s  .c o m
    graylogIp = input.getGraylogIp();
    flumeIp = input.getFlumeIp();
    drillIp = input.getDrillIp();
    graylogPort = input.getGraylogPort();
    flumePort = input.getFlumePort();
    drillPort = input.getDrillPort();
    syslogPort = input.getSyslogPort();
    secureSyslog = input.isSecureSysLog();

    final SetCentinelConfigurationsOutputBuilder centinelConfigurationsOutputBuilder = new SetCentinelConfigurationsOutputBuilder();

    centinelConfigurationsOutputBuilder.setGraylogIp(graylogIp);
    centinelConfigurationsOutputBuilder.setDrillIp(drillIp);
    centinelConfigurationsOutputBuilder.setFlumeIp(flumeIp);
    centinelConfigurationsOutputBuilder.setGraylogPort(graylogPort);
    centinelConfigurationsOutputBuilder.setFlumePort(flumePort);
    centinelConfigurationsOutputBuilder.setDrillPort(drillPort);
    centinelConfigurationsOutputBuilder.setSyslogPort(syslogPort);
    centinelConfigurationsOutputBuilder.setSecureSysLog(secureSyslog);
    try {
        tx.merge(LogicalDatastoreType.OPERATIONAL, configurationRecordId,
                new ConfigurationRecordBuilder().setGraylogIp(graylogIp).setDrillIp(drillIp).setFlumeIp(flumeIp)
                        .setFlumePort(flumePort).setDrillPort(drillPort).setGraylogPort(graylogPort)
                        .setSyslogPort(syslogPort).setSecureSysLog(secureSyslog).build(),
                true);
        tx.submit();

        notificationProvider.publish(new ConfigurationChangedBuilder().setGraylogIp(graylogIp)
                .setDrillIp(drillIp).setFlumeIp(flumeIp).setGraylogPort(graylogPort).setFlumePort(flumePort)
                .setDrillPort(drillPort).setSyslogPort(syslogPort).setSecureSysLog(secureSyslog).build());
        LOG.info("notification published");
        futureResult.set(RpcResultBuilder
                .<SetCentinelConfigurationsOutput>success(centinelConfigurationsOutputBuilder.build()).build());
    } catch (Exception e) {
        LOG.info("Failed to commit ConfigurationRecord in operational", e);

        futureResult.set(RpcResultBuilder.<SetCentinelConfigurationsOutput>failed()
                .withRpcErrors(((TransactionCommitFailedException) e).getErrorList()).build());
    }

    return futureResult;
}

From source file:org.opendaylight.toaster.impl.ToasterServiceImpl.java

@Override
public Future<RpcResult<java.lang.Void>> cancelToast() {
    LOG.info("cancelToast");
    final InstanceIdentifier<Toaster> TOASTER_IID = InstanceIdentifier.builder(Toaster.class).build();
    final ReadWriteTransaction tx = broker.newReadWriteTransaction();
    ListenableFuture<Optional<Toaster>> readFuture = tx.read(LogicalDatastoreType.OPERATIONAL, TOASTER_IID);

    //Optional<Toaster>ListenableFuture??VoidListenableFuture
    final ListenableFuture<Void> commitFuture = Futures.transform(readFuture,
            new AsyncFunction<Optional<Toaster>, Void>() {

                @Override//from  www  . j a va 2s.  c  o m
                public ListenableFuture<Void> apply(final Optional<Toaster> toasterData) throws Exception {
                    //?toastertasterStatus
                    ToasterStatus toasterStatus = ToasterStatus.Down;
                    if (toasterData.isPresent()) {
                        toasterStatus = toasterData.get().getToasterStatus();
                    }

                    //???Up
                    if (toasterStatus == ToasterStatus.Down) {
                        //Down?
                        LOG.info("the toaster is not running!");
                        return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException("",
                                RpcResultBuilder.newWarning(ErrorType.APPLICATION, "not-in-use",
                                        "Toaster is not running", null, null, null)));
                    } else {
                        //up??down?
                        tx.put(LogicalDatastoreType.OPERATIONAL, TOASTER_IID,
                                new ToasterBuilder().setToasterStatus(ToasterStatus.Down).build());
                        return tx.submit();
                    }
                }
            });

    //callback
    Futures.addCallback(commitFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(final Void result) {
            // data store?makeToast
            LOG.info("******Task was canceled.******");
        }

        @Override
        public void onFailure(final Throwable ex) {
            LOG.debug("Failed to commit Toaster status", ex);
        }
    });
    return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
}

From source file:org.opendaylight.distributed.tx.impl.CachingReadWriteTx.java

public CheckedFuture<Void, DTxException> asyncDelete(final LogicalDatastoreType logicalDatastoreType,
        final InstanceIdentifier<?> instanceIdentifier) {
    increaseOperation();//from w  w w.  j a  v  a 2 s  .c  o m
    CheckedFuture<Optional<DataObject>, ReadFailedException> readFuture = null;
    try {
        readFuture = delegate.read(logicalDatastoreType, (InstanceIdentifier<DataObject>) instanceIdentifier);
    } catch (Exception e) {
        readFuture = Futures
                .immediateFailedCheckedFuture(new ReadFailedException("Read exception in delete action"));
    }

    final SettableFuture<Void> retFuture = SettableFuture.create();

    Futures.addCallback(readFuture, new FutureCallback<Optional<DataObject>>() {
        @Override
        public void onSuccess(final Optional<DataObject> result) {
            synchronized (this) {
                cache.add(new CachedData(logicalDatastoreType, instanceIdentifier, result.orNull(),
                        ModifyAction.DELETE));
            }

            final ListeningExecutorService executorService = MoreExecutors
                    .listeningDecorator(executorPoolPerCache);
            final ListenableFuture asyncDeleteFuture = executorService.submit(new Callable() {
                @Override
                public Object call() throws Exception {
                    delegate.delete(logicalDatastoreType, instanceIdentifier);
                    return null;
                }
            });

            Futures.addCallback(asyncDeleteFuture, new FutureCallback() {
                @Override
                public void onSuccess(@Nullable Object result) {
                    decreaseOperation();
                    retFuture.set(null);
                }

                @Override
                public void onFailure(Throwable t) {
                    decreaseOperation();
                    LOG.trace("async delete failure");
                    retFuture.setException(new DTxException.EditFailedException("async delete failure", t));
                }
            });
        }

        @Override
        public void onFailure(final Throwable t) {
            decreaseOperation();
            retFuture.setException(
                    new DTxException.ReadFailedException("failed to read from node in delete action", t));
        }
    });

    return Futures.makeChecked(retFuture, new Function<Exception, DTxException>() {
        @Nullable
        @Override
        public DTxException apply(@Nullable Exception e) {
            e = (Exception) e.getCause();
            return e instanceof DTxException ? (DTxException) e
                    : new DTxException("delete operation failed ", e);
        }
    });
}

From source file:com.ibm.stocator.fs.cos.SemaphoredDelegatingExecutor.java

@Override
public ListenableFuture<?> submit(Runnable task) {
    try {/*from  ww  w  . j  av  a2s  . c o m*/
        queueingPermits.acquire();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return Futures.immediateFailedCheckedFuture(e);
    }
    return super.submit(new RunnableWithPermitRelease(task));
}

From source file:org.opendaylight.mdsal.dom.broker.ShardedDOMDataWriteTransaction.java

@Override
public synchronized CheckedFuture<Void, TransactionCommitFailedException> submit() {
    Preconditions.checkState(!closed, "Transaction %s is already closed", identifier);

    final Set<DOMStoreWriteTransaction> txns = ImmutableSet.copyOf(idToTransaction.values());
    final List<DOMStoreThreePhaseCommitCohort> cohorts = new ArrayList<>(txns.size());
    for (final DOMStoreWriteTransaction tx : txns) {
        cohorts.add(tx.ready());// w  w w . j a  v  a2s.  c o  m
    }
    producer.transactionSubmitted(this);
    try {
        return Futures.immediateCheckedFuture(new CommitCoordinationTask(this, cohorts, null).call());
    } catch (final TransactionCommitFailedException e) {
        return Futures.immediateFailedCheckedFuture(e);
    }
}

From source file:org.opendaylight.controller.md.sal.dom.broker.impl.DOMDataCommitCoordinatorImpl.java

@Override
public CheckedFuture<Void, TransactionCommitFailedException> submit(final DOMDataWriteTransaction transaction,
        final Iterable<DOMStoreThreePhaseCommitCohort> cohorts,
        final Optional<DOMDataCommitErrorListener> listener) {
    Preconditions.checkArgument(transaction != null, "Transaction must not be null.");
    Preconditions.checkArgument(cohorts != null, "Cohorts must not be null.");
    Preconditions.checkArgument(listener != null, "Listener must not be null");
    LOG.debug("Tx: {} is submitted for execution.", transaction.getIdentifier());

    ListenableFuture<Void> commitFuture = null;
    try {//  w  w w. jav  a  2  s. c om
        commitFuture = executor.submit(new CommitCoordinationTask(transaction, cohorts, listener));
    } catch (RejectedExecutionException e) {
        LOG.error("The commit executor's queue is full - submit task was rejected. \n" + executor, e);
        return Futures.immediateFailedCheckedFuture(new TransactionCommitFailedException(
                "Could not submit the commit task - the commit queue capacity has been exceeded.", e));
    }

    if (listener.isPresent()) {
        Futures.addCallback(commitFuture, new DOMDataCommitErrorInvoker(transaction, listener.get()));
    }

    return MappingCheckedFuture.create(commitFuture,
            TransactionCommitFailedExceptionMapper.COMMIT_ERROR_MAPPER);
}

From source file:io.airlift.discovery.client.HttpDiscoveryLookupClient.java

private ListenableFuture<ServiceDescriptors> lookup(final String type, final String pool,
        final ServiceDescriptors serviceDescriptors) {
    Preconditions.checkNotNull(type, "type is null");

    URI uri = discoveryServiceURI.get();
    if (uri == null) {
        return Futures
                .immediateFailedCheckedFuture(new DiscoveryException("No discovery servers are available"));
    }/*w  w  w .  j ava 2  s  .co  m*/

    uri = URI.create(uri + "/v1/service/" + type + "/");
    if (pool != null) {
        uri = uri.resolve(pool);
    }

    Builder requestBuilder = prepareGet().setUri(uri).setHeader("User-Agent", nodeInfo.getNodeId());
    if (serviceDescriptors != null && serviceDescriptors.getETag() != null) {
        requestBuilder.setHeader(HttpHeaders.ETAG, serviceDescriptors.getETag());
    }
    return httpClient.executeAsync(requestBuilder.build(),
            new DiscoveryResponseHandler<ServiceDescriptors>(format("Lookup of %s", type), uri) {
                @Override
                public ServiceDescriptors handle(Request request, Response response) {
                    Duration maxAge = extractMaxAge(response);
                    String eTag = response.getHeader(HttpHeaders.ETAG);

                    if (NOT_MODIFIED.code() == response.getStatusCode() && serviceDescriptors != null) {
                        return new ServiceDescriptors(serviceDescriptors, maxAge, eTag);
                    }

                    if (OK.code() != response.getStatusCode()) {
                        throw new DiscoveryException(format("Lookup of %s failed with status code %s", type,
                                response.getStatusCode()));
                    }

                    byte[] json;
                    try {
                        json = ByteStreams.toByteArray(response.getInputStream());
                    } catch (IOException e) {
                        throw new DiscoveryException(format("Lookup of %s failed", type), e);
                    }

                    ServiceDescriptorsRepresentation serviceDescriptorsRepresentation = serviceDescriptorsCodec
                            .fromJson(json);
                    if (!environment.equals(serviceDescriptorsRepresentation.getEnvironment())) {
                        throw new DiscoveryException(format("Expected environment to be %s, but was %s",
                                environment, serviceDescriptorsRepresentation.getEnvironment()));
                    }

                    return new ServiceDescriptors(type, pool,
                            serviceDescriptorsRepresentation.getServiceDescriptors(), maxAge, eTag);
                }
            });
}

From source file:org.opendaylight.netconf.sal.connect.netconf.sal.tx.ReadOnlyTx.java

@Override
public CheckedFuture<Boolean, ReadFailedException> exists(final LogicalDatastoreType store,
        final YangInstanceIdentifier path) {
    final CheckedFuture<Optional<NormalizedNode<?, ?>>, ReadFailedException> data = read(store, path);

    try {// w  w  w.  java 2  s.  co  m
        return Futures.immediateCheckedFuture(data.get().isPresent());
    } catch (InterruptedException | ExecutionException e) {
        return Futures.immediateFailedCheckedFuture(new ReadFailedException("Exists failed", e));
    }
}