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

Introduction

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

Prototype

@CheckReturnValue
public static <V> ListenableFuture<V> immediateFuture(@Nullable V value)

Source Link

Document

Creates a ListenableFuture which has its value set immediately upon construction.

Usage

From source file:io.v.x.jni.test.fortune.FortuneServerImpl.java

@Override
public ListenableFuture<String> get(final VContext context, ServerCall call) {
    if (serverLatch != null) {
        serverLatch.countDown();//from  w w  w  . ja  va 2  s .c  o  m
    }
    if (clientLatch != null) {
        try {
            // Caution: this is not idiomatic for server methods: they must be non-blocking.
            // However, it helps us with LameDuck tests.
            clientLatch.await();
        } catch (InterruptedException e) {
            return Futures.immediateFailedFuture(new VException(e.getMessage()));
        }
    }
    if (lastAddedFortune == null) {
        return Futures.immediateFailedFuture(new NoFortunesException(context));
    }
    return Futures.immediateFuture(lastAddedFortune);
}

From source file:org.glowroot.central.util.MoreFutures.java

public static ListenableFuture<?> rollupAsync(ListenableFuture<ResultSet> input, Executor asyncExecutor,
        DoRollup function) {//from  ww w. j  ava 2 s.  c om
    return transformAsync(input, asyncExecutor, new AsyncFunction<ResultSet, /*@Nullable*/ Object>() {
        @Override
        @SuppressWarnings("unchecked")
        public ListenableFuture</*@Nullable*/ Object> apply(ResultSet results) throws Exception {
            if (results.isExhausted()) {
                return Futures.immediateFuture(null);
            }
            return (ListenableFuture</*@Nullable*/ Object>) function.execute(results);
        }
    });
}

From source file:org.opendaylight.lispflowmapping.southbound.LispSouthboundRPC.java

@Override
public Future<RpcResult<Void>> sendMapNotify(SendMapNotifyInput mapNotifyInput) {
    LOG.trace("sendMapNotify called!!");
    if (mapNotifyInput != null) {
        ByteBuffer outBuffer = MapNotifySerializer.getInstance().serialize(mapNotifyInput.getMapNotify());
        lispSbPlugin.handleSerializedLispBuffer(mapNotifyInput.getTransportAddress(), outBuffer,
                MessageType.MapNotify);/*w  w  w.jav  a 2  s .c o m*/
    } else {
        LOG.warn("MapNotify was null");
        return Futures.immediateFuture(RpcResultBuilder.<Void>failed().build());
    }
    return Futures.immediateFuture(RpcResultBuilder.<Void>success().build());
}

From source file:org.opendaylight.openflowplugin.applications.frsync.impl.SyncReactorFutureWithCompressionDecorator.java

protected ListenableFuture<Boolean> doSyncupInFuture(
        final InstanceIdentifier<FlowCapableNode> flowcapableNodePath, final FlowCapableNode configTree,
        final FlowCapableNode operationalTree) throws InterruptedException {
    final NodeId nodeId = PathUtil.digNodeId(flowcapableNodePath);
    LOG.trace("doSyncupInFuture {}", nodeId.getValue());

    final Pair<FlowCapableNode, FlowCapableNode> lastCompressionState = removeLastCompressionState(
            flowcapableNodePath);/*from   w w w  . j  a  va2  s .  co  m*/
    if (lastCompressionState == null) {
        return Futures.immediateFuture(true);
    } else {
        return super.doSyncupInFuture(flowcapableNodePath, lastCompressionState.getLeft(),
                lastCompressionState.getRight());
    }
}

From source file:org.esbtools.eventhandler.lightblue.testing.MultiStringDocumentEvent.java

@Override
public Future<?> lookupDocument() {
    return Futures.immediateFuture(values);
}

From source file:org.hawkular.rx.cassandra.driver.MockResultSet.java

@Override
public ListenableFuture<ResultSet> fetchMoreResults() {
    if (fetched < count) {
        fetched += Math.min(pageSize, count - fetched);
    }/* ww w.ja  v  a  2 s.  c  o m*/
    return Futures.immediateFuture(this);
}

From source file:com.google.api.server.spi.config.datastore.testing.FakeAsyncMemcacheService.java

@Override
public Future<Object> get(Object key) {
    return Futures.immediateFuture(memcacheService.get(key));
}

From source file:org.apache.qpid.server.logging.logback.AbstractNameAndLevelLogInclusionRule.java

@StateTransition(currentState = { State.ERRORED, State.UNINITIALIZED }, desiredState = State.ACTIVE)
private ListenableFuture<Void> doActivate() {
    setState(State.ACTIVE);
    QpidLoggerTurboFilter.filterAddedToRootContext(_filter);
    return Futures.immediateFuture(null);
}

From source file:org.opendaylight.openflowplugin.impl.services.OfMessageProcessingServiceImpl.java

@Override
public Future<RpcResult<GetOfVersionOutput>> getOfVersion(GetOfVersionInput input) {
    RpcResultBuilder<GetOfVersionOutput> rpcResultBuilder = RpcResultBuilder.success();
    GetOfVersionOutputBuilder builder = new GetOfVersionOutputBuilder();
    builder.setNode(input.getNode());//from www.ja va 2  s. c  o m
    builder.setOfVersion(deviceContext.getDeviceInfo().getVersion());
    rpcResultBuilder.withResult(builder);
    return Futures.immediateFuture(rpcResultBuilder.build());
}

From source file:com.linkedin.pinot.server.request.ScheduledRequestHandler.java

@Override
public ListenableFuture<byte[]> processRequest(ChannelHandlerContext channelHandlerContext, ByteBuf request) {
    final long queryStartTime = System.nanoTime();
    serverMetrics.addMeteredGlobalValue(ServerMeter.QUERIES, 1);

    LOGGER.debug("Processing request : {}", request);

    byte[] byteArray = new byte[request.readableBytes()];
    request.readBytes(byteArray);//from   w ww  .  ja  v  a2  s.  co  m
    SerDe serDe = new SerDe(new TCompactProtocol.Factory());
    final InstanceRequest instanceRequest = new InstanceRequest();

    if (!serDe.deserialize(instanceRequest, byteArray)) {
        LOGGER.error("Failed to deserialize query request from broker ip: {}",
                ((InetSocketAddress) channelHandlerContext.channel().remoteAddress()).getAddress()
                        .getHostAddress());
        DataTable result = new DataTable();
        result.addException(QueryException.INTERNAL_ERROR);
        serverMetrics.addMeteredGlobalValue(ServerMeter.REQUEST_DESERIALIZATION_EXCEPTIONS, 1);
        return Futures.immediateFuture(serializeDataTable(null, serverMetrics, result, queryStartTime));
    }
    long deserializationEndTime = System.nanoTime();
    final BrokerRequest brokerRequest = instanceRequest.getQuery();
    serverMetrics.addPhaseTiming(brokerRequest, ServerQueryPhase.REQUEST_DESERIALIZATION,
            deserializationEndTime - queryStartTime);
    LOGGER.debug("Processing requestId:{},request={}", instanceRequest.getRequestId(), instanceRequest);
    final QueryRequest queryRequest = new QueryRequest(instanceRequest);
    String brokerId = instanceRequest.isSetBrokerId() ? instanceRequest.getBrokerId()
            : ((InetSocketAddress) channelHandlerContext.channel().remoteAddress()).getAddress()
                    .getHostAddress();
    // we will set the ip address as client id. This is good enough for start.
    // Ideally, broker should send it's identity as part of the request
    queryRequest.setClientId(brokerId);

    final long schedulerSubmitTime = System.nanoTime();
    ListenableFuture<DataTable> queryTask = queryScheduler.submit(queryRequest);

    // following future will provide default response in case of uncaught
    // exceptions from query processing
    ListenableFuture<DataTable> queryResponse = Futures.catching(queryTask, Throwable.class,
            new Function<Throwable, DataTable>() {
                @Nullable
                @Override
                public DataTable apply(@Nullable Throwable input) {
                    // this is called iff queryTask fails with unhandled exception
                    serverMetrics.addMeteredGlobalValue(ServerMeter.UNCAUGHT_EXCEPTIONS, 1);
                    DataTable result = new DataTable();
                    result.addException(QueryException.INTERNAL_ERROR);
                    return result;
                }
            });

    // transform the DataTable to serialized byte[] to send back to broker
    ListenableFuture<byte[]> serializedQueryResponse = Futures.transform(queryResponse,
            new Function<DataTable, byte[]>() {
                @Nullable
                @Override
                public byte[] apply(@Nullable DataTable instanceResponse) {
                    long totalNanos = System.nanoTime() - schedulerSubmitTime;
                    serverMetrics.addPhaseTiming(brokerRequest, ServerQueryPhase.QUERY_PROCESSING, totalNanos);
                    return serializeDataTable(instanceRequest, serverMetrics, instanceResponse, queryStartTime);
                }
            });

    return serializedQueryResponse;
}