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.logicoin.core.MockTransactionBroadcaster.java

@Override
public SettableFuture<Transaction> broadcastTransaction(Transaction tx) {
    // Use a lock just to catch lock ordering inversions.
    lock.lock();//from   w w  w .j a  va 2  s. co  m
    try {
        SettableFuture<Transaction> result = SettableFuture.create();
        broadcasts.put(tx);
        return result;
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        lock.unlock();
    }
}

From source file:org.apache.omid.tso.client.MockTSOClient.java

@Override
public TSOFuture<Long> getNewStartTimestamp() {
    synchronized (conflictMap) {
        SettableFuture<Long> f = SettableFuture.create();
        f.set(timestampGenerator.incrementAndGet());
        return new ForwardingTSOFuture<>(f);
    }/*from w  ww  .  ja v  a2s  .c  om*/
}

From source file:com.griddynamics.jagger.coordinator.AbstractRemoteExecutor.java

@Override
public <C extends Command<R>, R extends Serializable> Future<R> run(C command,
        NodeCommandExecutionListener<C> listener) {
    final SettableFuture<R> future = SettableFuture.create();
    run(command, listener, FutureAsyncCallback.create(future));
    return future;
}

From source file:com.facebook.buck.rules.FakeBuildEngine.java

@Override
public ListenableFuture<BuildResult> build(BuildEngineBuildContext buildContext,
        ExecutionContext executionContext, BuildRule rule) {
    SettableFuture<BuildResult> future = SettableFuture.create();
    future.set(buildResults.get(rule.getBuildTarget()));
    return future;
}

From source file:com.yahoo.yqlplus.engine.internal.java.runtime.TimeoutHandler.java

public <T> ListenableFuture<T> withTimeoutAsync(final Callable<ListenableFuture<T>> callable,
        final Timeout tracker, ListeningExecutorService executor) {
    final SettableFuture<T> result = SettableFuture.create();
    final long remaining = tracker.remainingTicks();
    final TimeUnit units = tracker.getTickUnits();
    final ListenableFuture<ListenableFuture<T>> source = executor.submit(callable);
    final ScheduledFuture<?> scheduledFuture = timers.schedule(new IntermediateTask<>(result, remaining, units),
            remaining, units);//  w w w  .j av a 2 s . c om
    Futures.addCallback(source, scoper.continueScope(new FutureCallback<ListenableFuture<T>>() {
        @Override
        public void onSuccess(ListenableFuture<T> next) {
            scheduledFuture.cancel(false);
            try {
                long remaining = tracker.verify();
                final ScheduledFuture<?> remainingFuture = timers
                        .schedule(new TimeoutTask<>(next, result, remaining, units), remaining, units);
                Futures.addCallback(next, scoper.continueScope(new FutureCallback<T>() {
                    @Override
                    public void onSuccess(T out) {
                        remainingFuture.cancel(false);
                        result.set(out);
                    }

                    @Override
                    public void onFailure(Throwable t) {
                        remainingFuture.cancel(false);
                        result.setException(t);
                    }
                }));
            } catch (TimeoutException e) {
                next.cancel(true);
                result.setException(e);
            }
        }

        @Override
        public void onFailure(Throwable t) {
            scheduledFuture.cancel(false);
            result.setException(t);
        }
    }));
    return scoper.scopeCallbacks(result);
}

From source file:com.github.xose.persona.verifier.RemoteVerifier.java

@Override
public ListenableFuture<VerifyResult> verify(String assertion, String audience) {
    final SettableFuture<VerifyResult> future = SettableFuture.create();

    Request request = new RequestBuilder("POST").setUrl(verifyUrl).addParameter("assertion", assertion)
            .addParameter("audience", audience).build();

    try {//from w  w w . j  a v a 2  s.c o  m
        client.executeRequest(request, new AsyncCompletionHandler<Response>() {
            @Override
            public Response onCompleted(Response response) throws IOException {
                if (200 != response.getStatusCode()) {
                    future.setException(new Exception("HTTP Code " + response.getStatusCode()));
                    return response;
                }

                try {
                    future.set(VerifyResultParser.fromJSONString(response.getResponseBody()));
                } catch (Throwable e) {
                    future.setException(new Exception("JSON parsing error", e));
                }

                return response;
            }

            @Override
            public void onThrowable(Throwable t) {
                future.setException(t);
            }
        });
    } catch (IOException e) {
        future.setException(e);
    }

    return future;
}

From source file:com.navercorp.nbasearc.gcp.SingleThreadEventLoop.java

ListenableFuture<?> close() {
    final SettableFuture<?> sf = SettableFuture.create();

    eventLoop.execute(new Runnable() {
        @Override/*from  w w  w .  j  av a 2  s  .co m*/
        public void run() {
            eventLoop.shutdownGracefully();
            sf.set(null);
        }
    });

    return sf;
}

From source file:com.facebook.buck.core.build.engine.impl.FakeBuildEngine.java

@Override
public BuildEngineResult build(BuildEngineBuildContext buildContext, ExecutionContext executionContext,
        BuildRule rule) {/* w ww. j a  v  a  2  s  .c om*/
    SettableFuture<BuildResult> future = SettableFuture.create();
    future.set(buildResults.get(rule.getBuildTarget()));
    return BuildEngineResult.builder().setResult(future).build();
}

From source file:co.cask.cdap.common.discovery.AbstractEndpointStrategy.java

@Override
public Discoverable pick(long timeout, TimeUnit timeoutUnit) {
    Discoverable discoverable = pick();/*from  w  w  w .  ja  v  a 2 s .co  m*/
    if (discoverable != null) {
        return discoverable;
    }
    final SettableFuture<Discoverable> future = SettableFuture.create();
    Cancellable cancellable = serviceDiscovered.watchChanges(new ServiceDiscovered.ChangeListener() {
        @Override
        public void onChange(ServiceDiscovered serviceDiscovered) {
            // The serviceDiscovered provided is the same as the one in the field, hence ok to just call pick().
            Discoverable discoverable = pick();
            if (discoverable != null) {
                future.set(discoverable);
            }
        }
    }, Threads.SAME_THREAD_EXECUTOR);
    try {
        return future.get(timeout, timeoutUnit);
    } catch (Exception e) {
        return null;
    } finally {
        cancellable.cancel();
    }
}

From source file:com.microsoft.services.sharepoint.http.FroyoHttpConnection.java

@Override
public ListenableFuture<Response> execute(final Request request) {

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

    final RequestTask requestTask = new RequestTask() {

        AndroidHttpClient mClient;//from w  w  w .  jav  a2 s. c  om
        InputStream mResponseStream;

        @Override
        protected Void doInBackground(Void... voids) {
            if (request == null) {
                future.setException(new IllegalArgumentException("request"));
            }

            mClient = AndroidHttpClient.newInstance(Platform.getUserAgent());
            mResponseStream = null;
            URI uri;

            try {
                HttpRequest realRequest = createRealRequest(request);
                assert request != null;
                uri = new URI(request.getUrl());

                HttpHost host = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());

                HttpResponse response;

                try {
                    response = mClient.execute(host, realRequest);
                } catch (SocketTimeoutException timeoutException) {
                    closeStreamAndClient();
                    future.setException(timeoutException);
                    return null;
                }

                mResponseStream = response.getEntity().getContent();
                Header[] headers = response.getAllHeaders();
                Map<String, List<String>> headersMap = new HashMap<String, List<String>>();
                for (Header header : headers) {
                    String headerName = header.getName();
                    if (headersMap.containsKey(headerName)) {
                        headersMap.get(headerName).add(header.getValue());
                    } else {
                        List<String> headerValues = new ArrayList<String>();
                        headerValues.add(header.getValue());
                        headersMap.put(headerName, headerValues);
                    }
                }

                future.set(new StreamResponse(mResponseStream, response.getStatusLine().getStatusCode(),
                        headersMap));
                closeStreamAndClient();
            } catch (Exception e) {
                closeStreamAndClient();

                future.setException(e);
            }

            return null;
        }

        protected void closeStreamAndClient() {
            if (mResponseStream != null) {
                try {
                    mResponseStream.close();
                } catch (IOException e) {
                }
            }

            if (mClient != null) {
                mClient.close();
            }
        }
    };

    Futures.addCallback(future, new FutureCallback<Response>() {
        @Override
        public void onFailure(Throwable arg0) {
            requestTask.closeStreamAndClient();

        }

        @Override
        public void onSuccess(Response response) {
        }
    });

    executeTask(requestTask);

    return future;
}