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

Introduction

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

Prototype

public static <V> SettableFuture<V> create()

Source Link

Document

Creates a new SettableFuture that can be completed or cancelled by a later method call.

Usage

From source file:com.google.cloud.pubsub.StreamingSubscriberConnection.java

@Override
void initialize() {
    final SettableFuture<Void> errorFuture = SettableFuture.create();
    final ClientResponseObserver<StreamingPullRequest, StreamingPullResponse> responseObserver = new ClientResponseObserver<StreamingPullRequest, StreamingPullResponse>() {
        @Override//  www .  j av  a  2  s  .c  o m
        public void beforeStart(ClientCallStreamObserver<StreamingPullRequest> requestObserver) {
            StreamingSubscriberConnection.this.requestObserver = requestObserver;
            requestObserver.disableAutoInboundFlowControl();
        }

        @Override
        public void onNext(StreamingPullResponse response) {
            processReceivedMessages(response.getReceivedMessagesList());
            // Only if not shutdown we will request one more batch of messages to be delivered.
            if (isAlive()) {
                requestObserver.request(1);
            }
        }

        @Override
        public void onError(Throwable t) {
            logger.debug("Terminated streaming with exception", t);
            errorFuture.setException(t);
        }

        @Override
        public void onCompleted() {
            logger.debug("Streaming pull terminated successfully!");
            errorFuture.set(null);
        }
    };
    final ClientCallStreamObserver<StreamingPullRequest> requestObserver = (ClientCallStreamObserver<StreamingPullRequest>) (ClientCalls
            .asyncBidiStreamingCall(
                    channel.newCall(SubscriberGrpc.METHOD_STREAMING_PULL,
                            CallOptions.DEFAULT.withCallCredentials(MoreCallCredentials.from(credentials))),
                    responseObserver));
    logger.debug("Initializing stream to subscription {} with deadline {}", subscription,
            getMessageDeadlineSeconds());
    requestObserver.onNext(StreamingPullRequest.newBuilder().setSubscription(subscription)
            .setStreamAckDeadlineSeconds(getMessageDeadlineSeconds()).build());
    requestObserver.request(1);

    Futures.addCallback(errorFuture, new FutureCallback<Void>() {
        @Override
        public void onSuccess(@Nullable Void result) {
            channelReconnectBackoff = INITIAL_CHANNEL_RECONNECT_BACKOFF;
            // The stream was closed. And any case we want to reopen it to continue receiving
            // messages.
            initialize();
        }

        @Override
        public void onFailure(Throwable t) {
            Status errorStatus = Status.fromThrowable(t);
            if (isRetryable(errorStatus) && isAlive()) {
                long backoffMillis = channelReconnectBackoff.getMillis();
                channelReconnectBackoff = channelReconnectBackoff.plus(backoffMillis);
                executor.schedule(new Runnable() {
                    @Override
                    public void run() {
                        initialize();
                    }
                }, backoffMillis, TimeUnit.MILLISECONDS);
            } else {
                if (isAlive()) {
                    notifyFailed(t);
                }
            }
        }
    }, executor);
}

From source file:org.opendaylight.netconf.topology.impl.OnlySuccessStateAggregator.java

@Override
public ListenableFuture<Void> combineDeleteAttempts(List<ListenableFuture<Void>> stateFutures) {
    final SettableFuture<Void> future = SettableFuture.create();
    final ListenableFuture<List<Void>> allAsList = Futures.allAsList(stateFutures);
    Futures.addCallback(allAsList, new FutureCallback<List<Void>>() {
        @Override//from   ww  w .  j a  v  a 2  s.com
        public void onSuccess(List<Void> result) {
            future.set(null);
        }

        @Override
        public void onFailure(Throwable t) {
            LOG.error("One of the combined delete attempts failed {}", t);
            future.setException(t);
        }
    });
    return future;
}

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

public DropTableTask(DropTablePlan plan, TransportDeleteIndexTemplateAction deleteTemplateAction,
        TransportDeleteIndexAction deleteIndexAction) {
    super(plan.jobId());
    this.ifExists = plan.ifExists();
    this.tableInfo = plan.tableInfo();
    this.deleteTemplateAction = deleteTemplateAction;
    this.deleteIndexAction = deleteIndexAction;
    this.result = SettableFuture.create();
}

From source file:zipkin.storage.cassandra.DeduplicatingExecutor.java

/**
 * @param session which conditionally executes bound statements
 * @param ttl how long the results of statements are remembered, in milliseconds.
 *//*from   w w w  .  ja  va 2 s  .  co  m*/
DeduplicatingExecutor(Session session, long ttl) {
    this.session = session;
    this.cache = CacheBuilder.newBuilder().expireAfterWrite(ttl, TimeUnit.MILLISECONDS).ticker(new Ticker() {
        @Override
        public long read() {
            return nanoTime();
        }
    })
            // TODO: maximum size or weight
            .build(new CacheLoader<BoundStatementKey, ListenableFuture<Void>>() {
                @Override
                public ListenableFuture<Void> load(final BoundStatementKey key) {
                    ListenableFuture<?> cassandraFuture = executeAsync(key.statement);

                    // Drop the cassandra future so that we don't hold references to cassandra state for
                    // long periods of time.
                    final SettableFuture<Void> disconnectedFuture = SettableFuture.create();
                    Futures.addCallback(cassandraFuture, new FutureCallback<Object>() {

                        @Override
                        public void onSuccess(Object result) {
                            disconnectedFuture.set(null);
                        }

                        @Override
                        public void onFailure(Throwable t) {
                            cache.invalidate(key);
                            disconnectedFuture.setException(t);
                        }
                    });
                    return disconnectedFuture;
                }
            });
}

From source file:edu.umich.si.inteco.minuku.dao.NoteDataRecordDAO.java

@Override
public Future<List<NoteDataRecord>> getAll() throws DAOException {
    final SettableFuture<List<NoteDataRecord>> settableFuture = SettableFuture.create();
    Firebase noteListRef = new Firebase(Constants.getInstance().getFirebaseUrlForNotes()).child(myUserEmail)
            .child(new SimpleDateFormat("MMddyyyy").format(new Date()).toString());

    noteListRef.addValueEventListener(new ValueEventListener() {
        @Override/*from   w w  w.  j a va2  s  .  c  o  m*/
        public void onDataChange(DataSnapshot dataSnapshot) {
            Map<String, NoteDataRecord> noteListMap = (HashMap<String, NoteDataRecord>) dataSnapshot.getValue();
            List<NoteDataRecord> values = (List) noteListMap.values();
            settableFuture.set(values);
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {
            settableFuture.set(null);
        }
    });
    return settableFuture;
}

From source file:org.opendaylight.controller.clustering.it.provider.impl.IdIntsListener.java

public Future<Void> tryFinishProcessing() {
    executorService = Executors.newSingleThreadScheduledExecutor();
    final SettableFuture<Void> settableFuture = SettableFuture.create();

    scheduledFuture = executorService.scheduleAtFixedRate(new CheckFinishedTask(settableFuture), 0, 1,
            TimeUnit.SECONDS);// www. ja v  a  2  s . c o  m
    return settableFuture;
}

From source file:com.twitter.heron.statemgr.NullStateManager.java

@Override
public ListenableFuture<TopologyMaster.TMasterLocation> getTMasterLocation(WatchCallback watcher,
        String topologyName) {
    return SettableFuture.create();
}

From source file:com.microsoft.tooling.msservices.serviceexplorer.RefreshableNode.java

public ListenableFuture<List<Node>> load() {
    final RefreshableNode node = this;
    final SettableFuture<List<Node>> future = SettableFuture.create();

    DefaultLoader.getIdeHelper().runInBackground(getProject(), "Loading " + getName() + "...", false, true,
            null, new Runnable() {
                @Override/*from   w  w w.  j  a v  a 2 s.  co  m*/
                public void run() {
                    final String nodeName = node.getName();
                    node.setName(nodeName + " (Refreshing...)");

                    Futures.addCallback(future, new FutureCallback<List<Node>>() {
                        @Override
                        public void onSuccess(List<Node> nodes) {
                            updateName(null);
                        }

                        @Override
                        public void onFailure(Throwable throwable) {
                            updateName(throwable);
                        }

                        private void updateName(final Throwable throwable) {
                            DefaultLoader.getIdeHelper().invokeLater(new Runnable() {
                                @Override
                                public void run() {
                                    node.setName(nodeName);

                                    if (throwable != null) {
                                        DefaultLoader.getUIHelper().showException(
                                                "An error occurred while attempting " + "to load "
                                                        + node.getName() + ".",
                                                throwable, "MS Services - Error Loading " + node.getName(),
                                                false, true);
                                    }
                                }
                            });
                        }
                    });

                    node.refreshItems(future);
                }
            });

    return future;
}

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//www  .jav  a 2s .  c om
        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:edu.umich.si.inteco.minuku.dao.MoodDataRecordDAO.java

@Override
public Future<List<MoodDataRecord>> getAll() throws DAOException {
    final SettableFuture<List<MoodDataRecord>> settableFuture = SettableFuture.create();
    Firebase moodListRef = new Firebase(Constants.getInstance().getFirebaseUrlForMoods()).child(myUserEmail)
            .child(new SimpleDateFormat("MMddyyyy").format(new Date()).toString());
    Log.d(TAG, "Attempting to get information from " + moodListRef);

    moodListRef.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override//from  w w  w  . ja  v a  2s .c o m
        public void onDataChange(DataSnapshot dataSnapshot) {
            List<MoodDataRecord> values = new ArrayList<>();
            for (DataSnapshot moodEntry : dataSnapshot.getChildren()) {
                values.add(moodEntry.getValue(MoodDataRecord.class));
            }
            settableFuture.set(values);
            Log.d(TAG, "Getall: Successfully retrieved information from DB to DAO.");
        }

        @Override
        public void onCancelled(FirebaseError firebaseError) {
            settableFuture.set(null);
        }
    });
    return settableFuture;
}