Example usage for com.google.common.util.concurrent SettableFuture setException

List of usage examples for com.google.common.util.concurrent SettableFuture setException

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.util.concurrent.*
  5. SettableFuture
  6. setException

Introduction

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

Prototype

@Override
    public boolean setException(Throwable throwable)

Source Link

Usage

From source file:co.cask.cdap.common.zookeeper.ZKExtOperations.java

/**
 * Performs the create part as described in
 * {@link #updateOrCreate(ZKClient, String, Function, Codec, List)}. If the creation failed with
 * {@link KeeperException.NodeExistsException}, the
 * {@link #getAndSet(ZKClient, String, AsyncFunction, Codec, SettableFuture, List)} will be called.
 *///w  ww.  ja  v a2 s.  c  o m
private static <V> void createOrGetAndSet(final ZKClient zkClient, final String path,
        final AsyncFunction<V, V> modifier, final Codec<V> codec, final SettableFuture<V> resultFuture,
        final List<ACL> createAcl) {
    try {
        Futures.addCallback(modifier.apply(null), new FutureCallback<V>() {
            @Override
            public void onSuccess(final V content) {
                if (content == null) {
                    resultFuture.set(null);
                    return;
                }

                try {
                    byte[] data = codec.encode(content);

                    OperationFuture<String> future;
                    if (createAcl == null) {
                        future = zkClient.create(path, data, CreateMode.PERSISTENT);
                    } else {
                        future = zkClient.create(path, data, CreateMode.PERSISTENT, createAcl);
                    }

                    Futures.addCallback(future, new FutureCallback<String>() {
                        @Override
                        public void onSuccess(String result) {
                            resultFuture.set(content);
                        }

                        @Override
                        public void onFailure(Throwable t) {
                            if (t instanceof KeeperException.NodeExistsException) {
                                // If failed to create due to node exists, try to do getAndSet.
                                getAndSet(zkClient, path, modifier, codec, resultFuture, createAcl);
                            } else {
                                resultFuture.setException(t);
                            }
                        }
                    }, Threads.SAME_THREAD_EXECUTOR);
                } catch (Throwable t) {
                    resultFuture.setException(t);
                }

            }

            @Override
            public void onFailure(Throwable t) {
                resultFuture.setException(t);
            }
        }, Threads.SAME_THREAD_EXECUTOR);
    } catch (Throwable e) {
        resultFuture.setException(e);
    }
}

From source file:com.facebook.buck.distributed.ServerContentsProvider.java

/** Blocking call */
private int processFileBuffer(boolean onlyIfBufferIsFull) {
    Set<String> hashCodes;
    SettableFuture<Map<String, byte[]>> resultFuture;

    synchronized (multiFetchLock) {
        if (onlyIfBufferIsFull && hashCodesToFetch.size() < multiFetchBufferMaxSize) {
            return 0;
        }// w w w. j ava  2 s .  c  om

        if (hashCodesToFetch.isEmpty()) {
            return 0;
        }

        hashCodes = hashCodesToFetch;
        hashCodesToFetch = new HashSet<>();
        resultFuture = multiFetchFuture;
        multiFetchFuture = SettableFuture.create();
    }

    try {
        LOG.info("Fetching [%d] source files from the CAS (%s).", hashCodes.size(),
                onlyIfBufferIsFull ? "buffer was full" : "scheduled");
        resultFuture.set(service.multiFetchSourceFiles(hashCodes));
    } catch (IOException e) {
        LOG.error(e);
        resultFuture.setException(e);
        return 0;
    }

    return hashCodes.size();
}

From source file:com.microsoft.intellij.helpers.IDEHelperImpl.java

@NotNull
@Override/*from w w w  .  j a  va 2 s. c  om*/
public ListenableFuture<String> buildArtifact(@NotNull ProjectDescriptor projectDescriptor,
        @NotNull ArtifactDescriptor artifactDescriptor) {
    try {
        Project project = findOpenProject(projectDescriptor);

        final Artifact artifact = findProjectArtifact(project, artifactDescriptor);

        final SettableFuture<String> future = SettableFuture.create();

        Futures.addCallback(buildArtifact(project, artifact, false), new FutureCallback<Boolean>() {
            @Override
            public void onSuccess(@Nullable Boolean succeded) {
                if (succeded != null && succeded) {
                    future.set(artifact.getOutputFilePath());
                } else {
                    future.setException(new AzureCmdException("An error occurred while building the artifact"));
                }
            }

            @Override
            public void onFailure(Throwable throwable) {
                if (throwable instanceof ExecutionException) {
                    future.setException(new AzureCmdException("An error occurred while building the artifact",
                            throwable.getCause()));
                } else {
                    future.setException(
                            new AzureCmdException("An error occurred while building the artifact", throwable));
                }
            }
        });

        return future;
    } catch (AzureCmdException e) {
        return Futures.immediateFailedFuture(e);
    }
}

From source file:c5db.control.SimpleControlClient.java

public ListenableFuture<CommandReply> sendRequest(CommandRpcRequest<?> request,
        InetSocketAddress remoteAddress) {
    SettableFuture<CommandReply> replyMessageFuture = SettableFuture.create();
    ChannelFuture connectFuture = client.connect(remoteAddress);
    connectFuture.addListener(new ChannelFutureListener() {
        @Override//from   w  ww  .j  a  v a 2 s . c o  m
        public void operationComplete(ChannelFuture future) throws Exception {
            if (future.isSuccess()) {
                future.channel().pipeline().addLast(new SimpleChannelInboundHandler<CommandReply>() {
                    @Override
                    protected void channelRead0(ChannelHandlerContext ctx, CommandReply msg) throws Exception {
                        replyMessageFuture.set(msg);
                        ctx.channel().close();
                    }
                });

                // connected is fine, flush message:
                future.channel().writeAndFlush(request);
            } else {
                replyMessageFuture.setException(future.cause());
                future.channel().close();
            }
        }
    });

    return replyMessageFuture;
}

From source file:org.apache.bookkeeper.bookie.LedgerDescriptorImpl.java

/**
 * Log the fence ledger entry in Journal so that we can rebuild the state.
 * @param journal log the fence entry in the Journal
 * @return A future which will be satisfied when add entry to journal complete
 *//* www  .  j  a v a2 s . c  o m*/
private SettableFuture<Boolean> logFenceEntryInJournal(Journal journal) {
    SettableFuture<Boolean> result;
    synchronized (this) {
        result = logFenceResult = SettableFuture.create();
    }
    ByteBuf entry = createLedgerFenceEntry(ledgerId);
    try {
        journal.logAddEntry(entry, false /* ackBeforeSync */, (rc, ledgerId, entryId, addr, ctx) -> {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Record fenced state for ledger {} in journal with rc {}", ledgerId,
                        BKException.codeLogger(rc));
            }
            if (rc == 0) {
                fenceEntryPersisted.compareAndSet(false, true);
                result.set(true);
            } else {
                result.set(false);
            }
        }, null);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        result.setException(e);
    }
    return result;
}

From source file:org.apache.storm.cassandra.executor.AsyncExecutor.java

/**
 * Asynchronously executes the specified batch statement. Inputs will be passed to
 * the {@link #handler} once query succeed or failed.
 *///from w w  w.ja  v  a 2s  .  c om
public SettableFuture<T> execAsync(final Statement statement, final T inputs,
        final AsyncResultHandler<T> handler) {
    final SettableFuture<T> settableFuture = SettableFuture.create();
    pending.incrementAndGet();
    ResultSetFuture future = session.executeAsync(statement);
    Futures.addCallback(future, new FutureCallback<ResultSet>() {
        public void release() {
            pending.decrementAndGet();
        }

        @Override
        public void onSuccess(ResultSet result) {
            release();
            settableFuture.set(inputs);
            handler.success(inputs);
        }

        @Override
        public void onFailure(Throwable t) {
            LOG.error(String.format("Failed to execute statement '%s' ", statement), t);
            release();
            settableFuture.setException(t);
            handler.failure(t, inputs);
        }
    }, executorService);
    return settableFuture;
}

From source file:io.crate.executor.transport.task.SymbolBasedUpsertByIdTask.java

private List<ListenableFuture<TaskResult>> initializeBulkShardProcessor(Settings settings) {
    bulkShardProcessor = new SymbolBasedBulkShardProcessor(clusterService, settings,
            transportShardUpsertActionDelegate, transportCreateIndexAction, node.isPartitionedTable(), false, // overwrite Duplicates
            node.items().size(), node.isBulkRequest() || node.updateColumns() != null, // continue on error on bulk and/or update
            node.updateColumns(), node.insertColumns());

    if (!node.isBulkRequest()) {
        final SettableFuture<TaskResult> futureResult = SettableFuture.create();
        List<ListenableFuture<TaskResult>> resultList = new ArrayList<>(1);
        resultList.add(futureResult);/*from www. j a v  a 2 s. c om*/
        Futures.addCallback(bulkShardProcessor.result(), new FutureCallback<BitSet>() {
            @Override
            public void onSuccess(@Nullable BitSet result) {
                if (result == null) {
                    futureResult.set(TaskResult.ROW_COUNT_UNKNOWN);
                } else {
                    futureResult.set(new RowCountResult(result.cardinality()));
                }
            }

            @Override
            public void onFailure(@Nonnull Throwable t) {
                futureResult.setException(t);
            }
        });
        return resultList;
    } else {
        final int numResults = node.items().size();
        final List<ListenableFuture<TaskResult>> resultList = new ArrayList<>(numResults);
        for (int i = 0; i < numResults; i++) {
            resultList.add(SettableFuture.<TaskResult>create());
        }

        Futures.addCallback(bulkShardProcessor.result(), new FutureCallback<BitSet>() {
            @Override
            public void onSuccess(@Nullable BitSet result) {
                if (result == null) {
                    setAllToFailed(null);
                    return;
                }

                for (int i = 0; i < numResults; i++) {
                    SettableFuture<TaskResult> future = (SettableFuture<TaskResult>) resultList.get(i);
                    future.set(result.get(i) ? TaskResult.ONE_ROW : TaskResult.FAILURE);
                }
            }

            private void setAllToFailed(@Nullable Throwable throwable) {
                if (throwable == null) {
                    for (ListenableFuture<TaskResult> future : resultList) {
                        ((SettableFuture<TaskResult>) future).set(TaskResult.FAILURE);
                    }
                } else {
                    for (ListenableFuture<TaskResult> future : resultList) {
                        ((SettableFuture<TaskResult>) future).set(RowCountResult.error(throwable));
                    }
                }
            }

            @Override
            public void onFailure(@Nonnull Throwable t) {
                setAllToFailed(t);
            }
        });
        return resultList;
    }
}

From source file:io.joynr.messaging.http.operation.LongPollingMessageReceiver.java

@Override
public synchronized Future<Void> start(MessageArrivedListener messageListener,
        ReceiverStatusListener... receiverStatusListeners) {
    synchronized (shutdownSynchronizer) {
        if (shutdown) {
            throw new JoynrShutdownException("Cannot register Message Listener: " + messageListener
                    + ": LongPollingMessageReceiver is already shutting down");
        }//from ww  w  .  j av a2s .c  o  m
    }

    if (isStarted()) {
        return Futures.immediateFailedFuture(new IllegalStateException("receiver is already started"));
    }

    final SettableFuture<Void> channelCreatedFuture = SettableFuture.create();
    ReceiverStatusListener[] statusListeners = ObjectArrays.concat(new ReceiverStatusListener() {

        @Override
        // Register the ChannelUrl once the receiver is started
        public void receiverStarted() {
            if (channelMonitor.isChannelCreated()) {
                for (ChannelCreatedListener listener : channelCreatedListeners) {
                    listener.channelCreated(channelMonitor.getChannelUrl());
                }
                // Signal that the channel is now created for anyone blocking on the future
                channelCreatedFuture.set(null);
            }
        }

        @Override
        // Shutdown the receiver if an exception is thrown
        public void receiverException(Throwable e) {
            channelCreatedFuture.setException(e);
            channelMonitor.shutdown();
        }
    }, receiverStatusListeners);

    channelMonitor.startLongPolling(messageListener, statusListeners);
    return channelCreatedFuture;
}

From source file:ohmdb.flease.FleaseLease.java

private void readInternal(final SettableFuture<LeaseValue> future, final BallotNumber k) {
    try {//ww  w . j  a  va2 s  .  c om
        // outgoing message:
        FleaseRequestMessage outMsg = FleaseRequestMessage.newBuilder()
                .setMessageType(FleaseRequestMessage.MessageType.READ).setLeaseId(leaseId).setK(k.getMessage())
                .build();

        final List<IncomingRpcReply> replies = new ArrayList<>(peers.size());

        final Disposable timeout = fiber.schedule(new Runnable() {
            @Override
            public void run() {
                future.setException(new FleaseReadTimeoutException(replies, majority));
            }
        }, 20, TimeUnit.SECONDS);

        // Send to all processes:
        for (long peer : peers) {
            OutgoingRpcRequest rpcRequest = new OutgoingRpcRequest(myId, outMsg, peer);

            AsyncRequest.withOneReply(fiber, sendRpcChannel, rpcRequest, new Callback<IncomingRpcReply>() {
                @Override
                public void onMessage(IncomingRpcReply message) {
                    if (message.isNackRead()) {
                        // even a single is a failure.
                        if (!future.setException(new NackReadException(message))) {
                            LOG.warn("{} read reply processing, got NackREAD but unable to set failure {}",
                                    getId(), message);
                        }
                        timeout.dispose(); // ditch the timeout.
                        return;
                    }

                    replies.add(message);

                    if (replies.size() >= majority) {
                        timeout.dispose(); // cancel the timeout.
                        checkReadReplies(replies, future);

                        // TODO Set a timeout to actually do the work so we have a chance for more messages.
                        //                            fiber.schedule(new Runnable() {
                        //                                @Override
                        //                                public void run() {
                        //                                    checkReadReplies(replies, future);
                        //                                }
                        //                            }, 20, TimeUnit.MILLISECONDS);
                    }
                }
            });
        }

    } catch (Throwable t) {
        future.setException(t);
    }
}

From source file:org.apache.qpid.server.model.AbstractSystemConfig.java

protected ListenableFuture<Void> makeActive() {

    final EventLogger eventLogger = _eventLogger;
    final EventLogger startupLogger = initiateStartupLogging();

    try {/*from   w  w w  .  j a  v  a2 s  .  c om*/
        final Container<?> container = initiateStoreAndRecovery();

        container.setEventLogger(startupLogger);
        final SettableFuture<Void> returnVal = SettableFuture.create();
        addFutureCallback(container.openAsync(), new FutureCallback() {
            @Override
            public void onSuccess(final Object result) {
                State state = container.getState();
                if (state == State.ACTIVE) {
                    startupLogger.message(BrokerMessages.READY());
                    container.setEventLogger(eventLogger);
                    returnVal.set(null);
                } else {
                    returnVal.setException(new ServerScopedRuntimeException(
                            "Broker failed reach ACTIVE state (state is " + state + ")"));
                }
            }

            @Override
            public void onFailure(final Throwable t) {
                returnVal.setException(t);
            }
        }, getTaskExecutor());

        return returnVal;
    } catch (IOException e) {
        throw new IllegalArgumentException(e);
    }

}