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

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

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

Introduction

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

Prototype

@CheckReturnValue
public static <V> ListenableFuture<V> immediateFailedFuture(Throwable throwable)

Source Link

Document

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

Usage

From source file:com.spotify.futures.FuturesExtra.java

/**
 * Returns a new {@link ListenableFuture} with the result of the first of futures that
 * successfully completes. If all ListenableFutures in futures fails the returned feature
 * fails as well with the Exception of the last failed future. If futures is an empty
 * list the returned future fails immediately with {@link java.util.NoSuchElementException}
 *
 * @param futures a {@link List} of futures
 * @return a new future with the result of the first completing future.
 * @throws NullPointerException if the {@param futures} is null
 *//*from w w w.java2s  .c o  m*/
public static <T> ListenableFuture<T> select(final List<? extends ListenableFuture<T>> futures) {
    Preconditions.checkNotNull(futures);
    if (futures.isEmpty()) {
        return Futures.immediateFailedFuture(new NoSuchElementException("List is empty"));
    }
    final int count = futures.size();
    final AtomicInteger failures = new AtomicInteger();

    final SettableFuture<T> promise = SettableFuture.create();
    final FutureCallback<T> cb = new FutureCallback<T>() {
        @Override
        public void onSuccess(final T result) {
            promise.set(result);
        }

        @Override
        public void onFailure(Throwable t) {
            if (failures.incrementAndGet() == count) {
                promise.setException(t);
            }
        }
    };

    for (final ListenableFuture<T> future : futures) {
        Futures.addCallback(future, cb);
    }
    return promise;
}

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

@Override
public ListenableFuture<MultipleGetOut> multipleGet(VContext context, ServerCall call) {
    if (lastAddedFortune == null) {
        return Futures.immediateFailedFuture(new NoFortunesException(context));
    }//  w w w .  j a v a  2s. co  m
    MultipleGetOut ret = new MultipleGetOut();
    ret.fortune = lastAddedFortune;
    ret.another = lastAddedFortune;
    return Futures.immediateFuture(ret);
}

From source file:org.apache.jackrabbit.oak.plugins.document.BatchCommit.java

Future<NodeDocument> execute(int idx) {
    if (idx == 0) {
        NodeDocument before = null;/*from   w w  w .  ja  v  a  2 s . c om*/
        try {
            UpdateOp combined = UpdateOp.combine(id, ops);
            LOG.debug("Batch committing {} updates", ops.size());
            before = queue.getStore().findAndUpdate(NODES, combined);
        } catch (Throwable t) {
            LOG.warn("BatchCommit failed, will retry individually. " + t.getMessage());
        } finally {
            queue.finished(this);
        }
        try {
            if (before == null) {
                // batch commit unsuccessful, execute individually
                executeIndividually();
            } else {
                populateResults(before);
            }
        } finally {
            finished.countDown();
        }
    } else {
        try {
            finished.await();
        } catch (InterruptedException e) {
            String msg = "Interrupted while waiting for batch commit to finish";
            return Futures.immediateFailedFuture(new DocumentStoreException(msg));
        }
    }
    return results.get(idx);
}

From source file:org.opendaylight.netvirt.openstack.netvirt.providers.openflow13.services.arp.ArpSender.java

/**
 * Sends ARP Request as packet-out from the given port (node connector).
 *
 * @param senderAddress the addresses used in sender part of ARP packet
 * @param tpa the target protocol address, in this case IPv4 address for which MAC should be
 *        discovered//from   w  w w .j  av a2 s  .  c  om
 * @param arpRequestDestMacAddress the destination MAC address to be used in the ARP packet or null if not known.
 * @param egressNc the path to node connector from where the ARP packet will be sent  @return future result about success of * packet-out
 * @return future result about success of packet-out
 */
public ListenableFuture<RpcResult<Void>> sendArp(ArpMessageAddress senderAddress, Ipv4Address tpa,
        MacAddress arpRequestDestMacAddress, InstanceIdentifier<NodeConnector> egressNc) {
    checkNotNull(senderAddress);
    checkNotNull(tpa);
    checkNotNull(egressNc);
    final Ethernet arpFrame = createArpFrame(senderAddress, tpa, arpRequestDestMacAddress);
    byte[] arpFrameAsBytes;
    try {
        arpFrameAsBytes = arpFrame.serialize();
    } catch (PacketException e) {
        LOG.warn("Serializition of ARP packet is not successful.", e);
        if (LOG.isDebugEnabled()) {
            LOG.debug("ARP packet: {}", ArpUtils.getArpFrameToStringFormat(arpFrame));
        }
        return Futures.immediateFailedFuture(e);
    }
    // Generate packet with destination switch and port
    TransmitPacketInput packet = new TransmitPacketInputBuilder().setEgress(new NodeConnectorRef(egressNc))
            .setNode(new NodeRef(egressNc.firstIdentifierOf(Node.class))).setPayload(arpFrameAsBytes).build();
    if (LOG.isTraceEnabled()) {
        LOG.trace("Sending ARP REQUEST \n{}", ArpUtils.getArpFrameToStringFormat(arpFrame));
    }
    Future<RpcResult<Void>> futureTransmitPacketResult = packetProcessingService.transmitPacket(packet);
    return JdkFutureAdapters.listenInPoolThread(futureTransmitPacketResult);
}

From source file:io.druid.java.util.http.client.NettyHttpClient.java

@Override
public <Intermediate, Final> ListenableFuture<Final> go(final Request request,
        final HttpResponseHandler<Intermediate, Final> handler, final Duration requestReadTimeout) {
    final HttpMethod method = request.getMethod();
    final URL url = request.getUrl();
    final Multimap<String, String> headers = request.getHeaders();

    final String requestDesc = StringUtils.format("%s %s", method, url);
    if (log.isDebugEnabled()) {
        log.debug("[%s] starting", requestDesc);
    }/*  w  w w .  j  a v a 2 s .c om*/

    // Block while acquiring a channel from the pool, then complete the request asynchronously.
    final Channel channel;
    final String hostKey = getPoolKey(url);
    final ResourceContainer<ChannelFuture> channelResourceContainer = pool.take(hostKey);
    final ChannelFuture channelFuture = channelResourceContainer.get().awaitUninterruptibly();
    if (!channelFuture.isSuccess()) {
        channelResourceContainer.returnResource(); // Some other poor sap will have to deal with it...
        return Futures.immediateFailedFuture(
                new ChannelException("Faulty channel in resource pool", channelFuture.getCause()));
    } else {
        channel = channelFuture.getChannel();
    }

    final String urlFile = Strings.nullToEmpty(url.getFile());
    final HttpRequest httpRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_1, method,
            urlFile.isEmpty() ? "/" : urlFile);

    if (!headers.containsKey(HttpHeaders.Names.HOST)) {
        httpRequest.headers().add(HttpHeaders.Names.HOST, getHost(url));
    }

    // If Accept-Encoding is set in the Request, use that. Otherwise use the default from "compressionCodec".
    if (!headers.containsKey(HttpHeaders.Names.ACCEPT_ENCODING)) {
        httpRequest.headers().set(HttpHeaders.Names.ACCEPT_ENCODING, compressionCodec.getEncodingString());
    }

    for (Map.Entry<String, Collection<String>> entry : headers.asMap().entrySet()) {
        String key = entry.getKey();

        for (String obj : entry.getValue()) {
            httpRequest.headers().add(key, obj);
        }
    }

    if (request.hasContent()) {
        httpRequest.setContent(request.getContent());
    }

    final long readTimeout = getReadTimeout(requestReadTimeout);
    final SettableFuture<Final> retVal = SettableFuture.create();

    if (readTimeout > 0) {
        channel.getPipeline().addLast(READ_TIMEOUT_HANDLER_NAME,
                new ReadTimeoutHandler(timer, readTimeout, TimeUnit.MILLISECONDS));
    }

    channel.getPipeline().addLast(LAST_HANDLER_NAME, new SimpleChannelUpstreamHandler() {
        private volatile ClientResponse<Intermediate> response = null;

        @Override
        public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
            if (log.isDebugEnabled()) {
                log.debug("[%s] messageReceived: %s", requestDesc, e.getMessage());
            }
            try {
                Object msg = e.getMessage();

                if (msg instanceof HttpResponse) {
                    HttpResponse httpResponse = (HttpResponse) msg;
                    if (log.isDebugEnabled()) {
                        log.debug("[%s] Got response: %s", requestDesc, httpResponse.getStatus());
                    }

                    response = handler.handleResponse(httpResponse);
                    if (response.isFinished()) {
                        retVal.set((Final) response.getObj());
                    }

                    if (!httpResponse.isChunked()) {
                        finishRequest();
                    }
                } else if (msg instanceof HttpChunk) {
                    HttpChunk httpChunk = (HttpChunk) msg;
                    if (log.isDebugEnabled()) {
                        log.debug("[%s] Got chunk: %sB, last=%s", requestDesc,
                                httpChunk.getContent().readableBytes(), httpChunk.isLast());
                    }

                    if (httpChunk.isLast()) {
                        finishRequest();
                    } else {
                        response = handler.handleChunk(response, httpChunk);
                        if (response.isFinished() && !retVal.isDone()) {
                            retVal.set((Final) response.getObj());
                        }
                    }
                } else {
                    throw new IllegalStateException(
                            StringUtils.format("Unknown message type[%s]", msg.getClass()));
                }
            } catch (Exception ex) {
                log.warn(ex, "[%s] Exception thrown while processing message, closing channel.", requestDesc);

                if (!retVal.isDone()) {
                    retVal.set(null);
                }
                channel.close();
                channelResourceContainer.returnResource();

                throw ex;
            }
        }

        private void finishRequest() {
            ClientResponse<Final> finalResponse = handler.done(response);
            if (!finalResponse.isFinished()) {
                throw new IllegalStateException(
                        StringUtils.format("[%s] Didn't get a completed ClientResponse Object from [%s]",
                                requestDesc, handler.getClass()));
            }
            if (!retVal.isDone()) {
                retVal.set(finalResponse.getObj());
            }
            removeHandlers();
            channelResourceContainer.returnResource();
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext context, ExceptionEvent event) {
            if (log.isDebugEnabled()) {
                final Throwable cause = event.getCause();
                if (cause == null) {
                    log.debug("[%s] Caught exception", requestDesc);
                } else {
                    log.debug(cause, "[%s] Caught exception", requestDesc);
                }
            }

            retVal.setException(event.getCause());
            // response is non-null if we received initial chunk and then exception occurs
            if (response != null) {
                handler.exceptionCaught(response, event.getCause());
            }
            removeHandlers();
            try {
                channel.close();
            } catch (Exception e) {
                // ignore
            } finally {
                channelResourceContainer.returnResource();
            }

            context.sendUpstream(event);
        }

        @Override
        public void channelDisconnected(ChannelHandlerContext context, ChannelStateEvent event) {
            if (log.isDebugEnabled()) {
                log.debug("[%s] Channel disconnected", requestDesc);
            }
            // response is non-null if we received initial chunk and then exception occurs
            if (response != null) {
                handler.exceptionCaught(response, new ChannelException("Channel disconnected"));
            }
            channel.close();
            channelResourceContainer.returnResource();
            if (!retVal.isDone()) {
                log.warn("[%s] Channel disconnected before response complete", requestDesc);
                retVal.setException(new ChannelException("Channel disconnected"));
            }
            context.sendUpstream(event);
        }

        private void removeHandlers() {
            if (readTimeout > 0) {
                channel.getPipeline().remove(READ_TIMEOUT_HANDLER_NAME);
            }
            channel.getPipeline().remove(LAST_HANDLER_NAME);
        }
    });

    channel.write(httpRequest).addListener(new ChannelFutureListener() {
        @Override
        public void operationComplete(ChannelFuture future) {
            if (!future.isSuccess()) {
                channel.close();
                channelResourceContainer.returnResource();
                if (!retVal.isDone()) {
                    retVal.setException(new ChannelException(
                            StringUtils.format("[%s] Failed to write request to channel", requestDesc),
                            future.getCause()));
                }
            }
        }
    });

    return retVal;
}

From source file:com.microsoft.azure.keyvault.cryptography.RsaKey.java

@Override
public ListenableFuture<Triple<byte[], byte[], String>> encryptAsync(final byte[] plaintext, final byte[] iv,
        final byte[] authenticationData, final String algorithm) throws NoSuchAlgorithmException {

    if (plaintext == null) {
        throw new IllegalArgumentException("plaintext");
    }/*from   w w w .  ja  v  a  2 s .  c  om*/

    // Interpret the requested algorithm
    String algorithmName = (Strings.isNullOrWhiteSpace(algorithm) ? getDefaultEncryptionAlgorithm()
            : algorithm);
    Algorithm baseAlgorithm = AlgorithmResolver.Default.get(algorithmName);

    if (baseAlgorithm == null || !(baseAlgorithm instanceof AsymmetricEncryptionAlgorithm)) {
        throw new NoSuchAlgorithmException(algorithmName);
    }

    AsymmetricEncryptionAlgorithm algo = (AsymmetricEncryptionAlgorithm) baseAlgorithm;

    ICryptoTransform transform;
    ListenableFuture<Triple<byte[], byte[], String>> result;

    try {
        transform = algo.CreateEncryptor(_keyPair, _provider);
        result = Futures.immediateFuture(Triple.of(transform.doFinal(plaintext), (byte[]) null, algorithmName));
    } catch (Exception e) {
        result = Futures.immediateFailedFuture(e);
    }

    return result;
}

From source file:com.orangerhymelabs.helenus.cassandra.AbstractCassandraRepository.java

public ListenableFuture<T> read(Identifier id) {
    ListenableFuture<ResultSet> rs = submitRead(id);
    return Futures.transformAsync(rs, new AsyncFunction<ResultSet, T>() {
        @Override/*www.j a  va 2  s  . c  om*/
        public ListenableFuture<T> apply(ResultSet result) {
            if (result.isExhausted()) {
                return Futures.immediateFailedFuture(new ItemNotFoundException(id.toString()));
            }

            return Futures.immediateFuture(marshalRow(result.one()));
        }
    }, MoreExecutors.directExecutor());
}

From source file:org.apache.druid.java.util.http.client.NettyHttpClient.java

@Override
public <Intermediate, Final> ListenableFuture<Final> go(final Request request,
        final HttpResponseHandler<Intermediate, Final> handler, final Duration requestReadTimeout) {
    final HttpMethod method = request.getMethod();
    final URL url = request.getUrl();
    final Multimap<String, String> headers = request.getHeaders();

    final String requestDesc = StringUtils.format("%s %s", method, url);
    if (log.isDebugEnabled()) {
        log.debug("[%s] starting", requestDesc);
    }/*from ww w  .j a v a 2s.c o m*/

    // Block while acquiring a channel from the pool, then complete the request asynchronously.
    final Channel channel;
    final String hostKey = getPoolKey(url);
    final ResourceContainer<ChannelFuture> channelResourceContainer = pool.take(hostKey);
    final ChannelFuture channelFuture = channelResourceContainer.get().awaitUninterruptibly();
    if (!channelFuture.isSuccess()) {
        channelResourceContainer.returnResource(); // Some other poor sap will have to deal with it...
        return Futures.immediateFailedFuture(
                new ChannelException("Faulty channel in resource pool", channelFuture.getCause()));
    } else {
        channel = channelFuture.getChannel();

        // In case we get a channel that never had its readability turned back on.
        channel.setReadable(true);
    }
    final String urlFile = StringUtils.nullToEmptyNonDruidDataString(url.getFile());
    final HttpRequest httpRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_1, method,
            urlFile.isEmpty() ? "/" : urlFile);

    if (!headers.containsKey(HttpHeaders.Names.HOST)) {
        httpRequest.headers().add(HttpHeaders.Names.HOST, getHost(url));
    }

    // If Accept-Encoding is set in the Request, use that. Otherwise use the default from "compressionCodec".
    if (!headers.containsKey(HttpHeaders.Names.ACCEPT_ENCODING)) {
        httpRequest.headers().set(HttpHeaders.Names.ACCEPT_ENCODING, compressionCodec.getEncodingString());
    }

    for (Map.Entry<String, Collection<String>> entry : headers.asMap().entrySet()) {
        String key = entry.getKey();

        for (String obj : entry.getValue()) {
            httpRequest.headers().add(key, obj);
        }
    }

    if (request.hasContent()) {
        httpRequest.setContent(request.getContent());
    }

    final long readTimeout = getReadTimeout(requestReadTimeout);
    final SettableFuture<Final> retVal = SettableFuture.create();

    if (readTimeout > 0) {
        channel.getPipeline().addLast(READ_TIMEOUT_HANDLER_NAME,
                new ReadTimeoutHandler(timer, readTimeout, TimeUnit.MILLISECONDS));
    }

    channel.getPipeline().addLast(LAST_HANDLER_NAME, new SimpleChannelUpstreamHandler() {
        private volatile ClientResponse<Intermediate> response = null;

        // Chunk number most recently assigned.
        private long currentChunkNum = 0;

        // Suspend and resume watermarks (respectively: last chunk number that triggered a suspend, and that was
        // provided to the TrafficCop's resume method). Synchronized access since they are not always accessed
        // from an I/O thread. (TrafficCops can be called from any thread.)
        private final Object watermarkLock = new Object();
        private long suspendWatermark = -1;
        private long resumeWatermark = -1;

        @Override
        public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
            if (log.isDebugEnabled()) {
                log.debug("[%s] messageReceived: %s", requestDesc, e.getMessage());
            }
            try {
                Object msg = e.getMessage();

                if (msg instanceof HttpResponse) {
                    HttpResponse httpResponse = (HttpResponse) msg;
                    if (log.isDebugEnabled()) {
                        log.debug("[%s] Got response: %s", requestDesc, httpResponse.getStatus());
                    }

                    HttpResponseHandler.TrafficCop trafficCop = resumeChunkNum -> {
                        synchronized (watermarkLock) {
                            resumeWatermark = Math.max(resumeWatermark, resumeChunkNum);

                            if (suspendWatermark >= 0 && resumeWatermark >= suspendWatermark) {
                                suspendWatermark = -1;
                                channel.setReadable(true);
                                long backPressureDuration = System.nanoTime() - backPressureStartTimeNs;
                                log.debug("[%s] Resumed reads from channel (chunkNum = %,d).", requestDesc,
                                        resumeChunkNum);
                                return backPressureDuration;
                            }
                        }

                        return 0; //If we didn't resume, don't know if backpressure was happening
                    };
                    response = handler.handleResponse(httpResponse, trafficCop);
                    if (response.isFinished()) {
                        retVal.set((Final) response.getObj());
                    }

                    assert currentChunkNum == 0;
                    possiblySuspendReads(response);

                    if (!httpResponse.isChunked()) {
                        finishRequest();
                    }
                } else if (msg instanceof HttpChunk) {
                    HttpChunk httpChunk = (HttpChunk) msg;
                    if (log.isDebugEnabled()) {
                        log.debug("[%s] Got chunk: %sB, last=%s", requestDesc,
                                httpChunk.getContent().readableBytes(), httpChunk.isLast());
                    }

                    if (httpChunk.isLast()) {
                        finishRequest();
                    } else {
                        response = handler.handleChunk(response, httpChunk, ++currentChunkNum);
                        if (response.isFinished() && !retVal.isDone()) {
                            retVal.set((Final) response.getObj());
                        }
                        possiblySuspendReads(response);
                    }
                } else {
                    throw new IllegalStateException(
                            StringUtils.format("Unknown message type[%s]", msg.getClass()));
                }
            } catch (Exception ex) {
                log.warn(ex, "[%s] Exception thrown while processing message, closing channel.", requestDesc);

                if (!retVal.isDone()) {
                    retVal.set(null);
                }
                channel.close();
                channelResourceContainer.returnResource();

                throw ex;
            }
        }

        private void possiblySuspendReads(ClientResponse<?> response) {
            if (!response.isContinueReading()) {
                synchronized (watermarkLock) {
                    suspendWatermark = Math.max(suspendWatermark, currentChunkNum);
                    if (suspendWatermark > resumeWatermark) {
                        channel.setReadable(false);
                        backPressureStartTimeNs = System.nanoTime();
                        log.debug("[%s] Suspended reads from channel (chunkNum = %,d).", requestDesc,
                                currentChunkNum);
                    }
                }
            }
        }

        private void finishRequest() {
            ClientResponse<Final> finalResponse = handler.done(response);

            if (!finalResponse.isFinished() || !finalResponse.isContinueReading()) {
                throw new ISE(
                        "[%s] Didn't get a completed ClientResponse Object from [%s] (finished = %s, continueReading = %s)",
                        requestDesc, handler.getClass(), finalResponse.isFinished(),
                        finalResponse.isContinueReading());
            }
            if (!retVal.isDone()) {
                retVal.set(finalResponse.getObj());
            }
            removeHandlers();
            channel.setReadable(true);
            channelResourceContainer.returnResource();
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext context, ExceptionEvent event) {
            if (log.isDebugEnabled()) {
                final Throwable cause = event.getCause();
                if (cause == null) {
                    log.debug("[%s] Caught exception", requestDesc);
                } else {
                    log.debug(cause, "[%s] Caught exception", requestDesc);
                }
            }

            retVal.setException(event.getCause());
            // response is non-null if we received initial chunk and then exception occurs
            if (response != null) {
                handler.exceptionCaught(response, event.getCause());
            }
            try {
                if (channel.isOpen()) {
                    channel.close();
                }
            } catch (Exception e) {
                log.warn(e, "Error while closing channel");
            } finally {
                channelResourceContainer.returnResource();
            }
        }

        @Override
        public void channelDisconnected(ChannelHandlerContext context, ChannelStateEvent event) {
            if (log.isDebugEnabled()) {
                log.debug("[%s] Channel disconnected", requestDesc);
            }
            // response is non-null if we received initial chunk and then exception occurs
            if (response != null) {
                handler.exceptionCaught(response, new ChannelException("Channel disconnected"));
            }
            channel.close();
            channelResourceContainer.returnResource();
            if (!retVal.isDone()) {
                log.warn("[%s] Channel disconnected before response complete", requestDesc);
                retVal.setException(new ChannelException("Channel disconnected"));
            }
        }

        private void removeHandlers() {
            if (readTimeout > 0) {
                channel.getPipeline().remove(READ_TIMEOUT_HANDLER_NAME);
            }
            channel.getPipeline().remove(LAST_HANDLER_NAME);
        }
    });

    channel.write(httpRequest).addListener(new ChannelFutureListener() {
        @Override
        public void operationComplete(ChannelFuture future) {
            if (!future.isSuccess()) {
                channel.close();
                channelResourceContainer.returnResource();
                if (!retVal.isDone()) {
                    retVal.setException(new ChannelException(
                            StringUtils.format("[%s] Failed to write request to channel", requestDesc),
                            future.getCause()));
                }
            }
        }
    });

    return retVal;
}

From source file:com.vmware.photon.controller.common.thrift.ClientPoolImpl.java

@Override
public synchronized ListenableFuture<C> acquire() {
    if (promises.size() < options.getMaxWaiters()) {
        SettableFuture<C> future = SettableFuture.create();
        Promise<C> promise = new Promise<>(future);
        promises.add(promise);/*from  w  ww.j  a va 2 s  . c  o m*/
        processPromises();
        logger.info("options.getTimeoutMs() is {}", options.getTimeoutMs());
        if (options.getTimeoutMs() > 0 && !future.isDone()) {
            setTimeout(promise);
        }
        logger.info("{} Promise processed {}", options.getServiceName(), promise);
        return future;
    }

    return Futures.immediateFailedFuture(new ClientPoolException("Too many waiters"));
}

From source file:io.crate.operation.collect.HandlerSideDataCollectOperation.java

private ListenableFuture<Object[][]> handleCluster(CollectNode collectNode,
        RamAccountingContext ramAccountingContext) {
    collectNode = collectNode.normalize(clusterNormalizer);
    if (collectNode.whereClause().noMatch()) {
        return Futures.immediateFuture(TaskResult.EMPTY_RESULT.rows());
    }/*from  w w  w . j  a  va 2s  .co m*/
    assert collectNode.toCollect().size() > 0;

    // resolve Implementations
    ImplementationSymbolVisitor.Context ctx = implementationVisitor.process(collectNode);
    List<Input<?>> inputs = ctx.topLevelInputs();
    Set<CollectExpression<?>> collectExpressions = ctx.collectExpressions();

    FlatProjectorChain projectorChain = new FlatProjectorChain(collectNode.projections(), projectorVisitor,
            ramAccountingContext);
    SimpleOneRowCollector collector = new SimpleOneRowCollector(inputs, collectExpressions,
            projectorChain.firstProjector());

    projectorChain.startProjections();
    try {
        collector.doCollect(ramAccountingContext);
    } catch (CollectionAbortedException e) {
        // ignore
    } catch (Exception e) {
        return Futures.immediateFailedFuture(e);
    }
    return projectorChain.result();
}