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.microsoft.windowsazure.mobileservices.zumoe2etestapp.framework.LogServiceFilter.java

@Override
public ListenableFuture<ServiceFilterResponse> handleRequest(ServiceFilterRequest request,
        NextServiceFilterCallback nextServiceFilterCallback) {

    final SettableFuture<ServiceFilterResponse> resultFuture = SettableFuture.create();

    String content = request.getContent();
    if (content == null)
        content = "NULL";

    String url = request.getUrl();
    if (url == null)
        url = "";

    Log.d("REQUEST URL", url);
    Log.d("REQUEST CONTENT", content);

    ListenableFuture<ServiceFilterResponse> nextServiceFilterCallbackFuture = nextServiceFilterCallback
            .onNext(request);// ww w.ja v  a2 s.c o m

    Futures.addCallback(nextServiceFilterCallbackFuture, new FutureCallback<ServiceFilterResponse>() {

        @Override
        public void onFailure(Throwable exception) {
            resultFuture.setException(exception);

        }

        @Override
        public void onSuccess(ServiceFilterResponse response) {
            if (response != null) {
                String content = response.getContent();
                if (content != null) {
                    Log.d("RESPONSE CONTENT", content);
                }
            }

            resultFuture.set(response);
        }
    });

    return resultFuture;
}

---

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

@Override
public Future<RpcResult<Void>> buyCar(BuyCarInput input) {
    log.info("Routed RPC buyCar : generating notification for buying car [{}]", input);
    SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
    CarBoughtBuilder carBoughtBuilder = new CarBoughtBuilder();
    carBoughtBuilder.setCarId(input.getCarId());
    carBoughtBuilder.setPersonId(input.getPersonId());
    notificationProvider.publish(carBoughtBuilder.build());
    futureResult.set(RpcResultBuilder.<Void>success().build());
    return futureResult;
}

---

From source file:com.microsoft.office365.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  .j a v a  2 s  .  c  o  m
        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);
                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;
}

---

From source file:com.facebook.presto.util.MoreFutures.java

public static <T> ListenableFuture<T> addTimeout(final ListenableFuture<T> future,
        final Callable<T> timeoutTask, Duration timeout, ScheduledExecutorService executorService) {
    // if the future is already complete, just return it
    if (future.isDone()) {
        return future;
    }//from   w ww .  j  av  a2 s.c  o  m

    // wrap the future, so we can set the result directly
    final SettableFuture<T> settableFuture = SettableFuture.create();

    // schedule a task to complete the future when the time expires
    final ScheduledFuture<?> timeoutTaskFuture = executorService.schedule(
            new TimeoutFutureTask<>(settableFuture, timeoutTask, future), timeout.toMillis(),
            TimeUnit.MILLISECONDS);

    // add a listener to the core future, which simply updates the settable future
    Futures.addCallback(future, new FutureCallback<T>() {
        @Override
        public void onSuccess(@Nullable T result) {
            settableFuture.set(result);
            timeoutTaskFuture.cancel(true);
        }

        @Override
        public void onFailure(Throwable t) {
            settableFuture.setException(t);
            timeoutTaskFuture.cancel(true);
        }
    }, executorService);

    return settableFuture;
}

---

From source file:com.microsoft.alm.plugin.authentication.AuthHelper.java

/**
 * This method wraps the normal Async call to authenticate and waits on the result.
 *///from w  w w.  j a v a 2 s  .com
public static AuthenticationInfo getAuthenticationInfoSynchronously(final AuthenticationProvider provider,
        final String gitRemoteUrl) {
    final SettableFuture<AuthenticationInfo> future = SettableFuture.create();

    provider.authenticateAsync(gitRemoteUrl, new AuthenticationListener() {
        @Override
        public void authenticating() {
            // do nothing
        }

        @Override
        public void authenticated(final AuthenticationInfo authenticationInfo, final Throwable throwable) {
            if (throwable != null) {
                future.setException(throwable);
            } else {
                future.set(authenticationInfo);
            }
        }
    });

    // Wait for the authentication info object to be ready
    // Don't wait any longer than 15 minutes for the user to authenticate
    Throwable t = null;
    try {
        return future.get(15, TimeUnit.MINUTES);
    } catch (InterruptedException ie) {
        t = ie;
    } catch (ExecutionException ee) {
        t = ee;
    } catch (TimeoutException te) {
        t = te;
    } finally {
        if (t != null) {
            logger.error("getAuthenticationInfoSynchronously: failed to get authentication info from user");
            logger.warn("getAuthenticationInfoSynchronously", t);
        }
    }
    return null;
}

---

From source file:com.microsoft.services.odata.ODataMediaEntityFetcher.java

public ListenableFuture<byte[]> getContent() {

    final SettableFuture<byte[]> result = SettableFuture.create();

    Request request = getResolver().createRequest();
    request.setVerb(HttpVerb.GET);/*from   w  w w  . j  a  v a 2s  .  c  o  m*/
    ODataURL url = request.getUrl();
    url.appendPathComponent("$value");

    ListenableFuture<ODataResponse> future = oDataExecute(request);

    Futures.addCallback(future, new FutureCallback<ODataResponse>() {
        @Override
        public void onSuccess(ODataResponse response) {
            result.set(response.getPayload());
        }

        @Override
        public void onFailure(Throwable t) {
            result.setException(t);
        }
    });
    return result;
}

---

From source file:com.microsoft.directoryservices.odata.ApplicationOperations.java

/**
* restore listenable future./*from w  w  w .j a va2 s  . c om*/
* @param identifierUris the identifierUris 
* @return the listenable future
*/
public ListenableFuture<Application> restore(java.util.List<String> identifierUris) {

    final SettableFuture<Application> result = SettableFuture.create();
    java.util.Map<String, Object> map = new java.util.HashMap<String, Object>();
    map.put("identifierUris", identifierUris);

    Request request = getResolver().createRequest();
    request.setVerb(HttpVerb.POST);
    request.setContent(serializeToJsonByteArray(map, getResolver()));
    String parameters = getFunctionParameters(map);
    request.getUrl().appendPathComponent("restore(" + parameters + ")");
    ListenableFuture<ODataResponse> future = oDataExecute(request);
    return transformToEntityListenableFuture(transformToStringListenableFuture(future), Application.class,
            getResolver());

}

---

From source file:io.v.v23.syncbase.Batch.java

@CheckReturnValue
private static ListenableFuture<Boolean> tryBatch(final VContext ctx, final Database db,
        final BatchOptions opts, final BatchOperation op) {
    final SettableFuture<Boolean> ret = SettableFuture.create();
    Futures.addCallback(db.beginBatch(ctx, opts), new FutureCallback<BatchDatabase>() {
        @Override//  w ww.  ja  v  a  2s .c  o  m
        public void onFailure(Throwable t) {
            ret.setException(t);
        }

        @Override
        public void onSuccess(final BatchDatabase batch) {
            Futures.addCallback(op.run(batch), new FutureCallback<Void>() {
                @Override
                public void onFailure(final Throwable t) {
                    Futures.addCallback(batch.abort(ctx), new FutureCallback<Void>() {
                        @Override
                        public void onSuccess(Void result) {
                            ret.setException(t);
                        }

                        @Override
                        public void onFailure(Throwable newT) {
                            ret.setException(t);
                        }
                    });
                }

                @Override
                public void onSuccess(Void result) {
                    Futures.addCallback(opts.getReadOnly() ? batch.abort(ctx) : batch.commit(ctx),
                            new FutureCallback<Void>() {
                                @Override
                                public void onSuccess(Void result) {
                                    ret.set(true); // success
                                }

                                @Override
                                public void onFailure(Throwable t) {
                                    if (t instanceof ConcurrentBatchException) {
                                        // retry
                                        ret.set(false);
                                    } else {
                                        ret.setException(t);
                                    }
                                }
                            });
                }
            });
        }
    });
    return ret;
}

---

From source file:com.microsoft.services.odata.BaseODataContainer.java

@Override
protected ListenableFuture<ODataResponse> oDataExecute(Request request) {
    final SettableFuture<ODataResponse> result = SettableFuture.create();
    final Logger logger = resolver.getLogger();

    try {//from w w w . j a va2  s. c om
        request.getUrl().setBaseUrl(this.url);
        String fullUrl = request.getUrl().toString();

        String executionInfo = String.format("URL: %s - HTTP VERB: %s", fullUrl, request.getVerb());
        logger.log("Start preparing OData execution for " + executionInfo, LogLevel.INFO);

        if (request.getContent() != null) {
            logger.log("With " + request.getContent().length + " bytes of payload", LogLevel.INFO);
        }

        HttpTransport httpTransport = resolver.getHttpTransport();

        String userAgent = resolver.getPlatformUserAgent(this.getClass().getCanonicalName());
        request.addHeader(Constants.USER_AGENT_HEADER, userAgent);
        request.addHeader(Constants.TELEMETRY_HEADER, userAgent);
        request.addHeader(Constants.CONTENT_TYPE_HEADER, Constants.JSON_CONTENT_TYPE);
        request.addHeader(Constants.ACCEPT_HEADER, Constants.JSON_CONTENT_TYPE);
        request.addHeader(Constants.ODATA_VERSION_HEADER, Constants.ODATA_VERSION);
        request.addHeader(Constants.ODATA_MAXVERSION_HEADER, Constants.ODATA_MAXVERSION);

        if (request.getHeaders() != null) {
            for (String key : request.getHeaders().keySet()) {
                request.addHeader(key, request.getHeaders().get(key));
            }
        }

        boolean credentialsSet = false;

        Credentials cred = resolver.getCredentials();
        if (cred != null) {
            cred.prepareRequest(request);
            credentialsSet = true;
        }

        if (!credentialsSet) {
            logger.log("Executing request without setting credentials", LogLevel.WARNING);
        }

        logger.log("Request Headers: ", LogLevel.VERBOSE);
        for (String key : request.getHeaders().keySet()) {
            logger.log(key + " : " + request.getHeaders().get(key), LogLevel.VERBOSE);
        }

        final ListenableFuture<Response> future = httpTransport.execute(request);
        logger.log("OData request executed", LogLevel.INFO);

        Futures.addCallback(future, new FutureCallback<Response>() {

            @Override
            public void onSuccess(Response response) {
                try {
                    logger.log("OData response received", LogLevel.INFO);

                    logger.log("Reading response data...", LogLevel.VERBOSE);
                    byte[] data = readAllBytes(response.getStream());
                    logger.log(data.length + " bytes read from response", LogLevel.VERBOSE);

                    int status = response.getStatus();
                    logger.log("Response Status Code: " + status, LogLevel.INFO);

                    try {
                        logger.log("Closing response", LogLevel.VERBOSE);
                        response.close();
                    } catch (Throwable t) {
                        logger.log("Error closing response: " + t.toString(), LogLevel.ERROR);
                        result.setException(t);
                        return;
                    }

                    ODataResponse odataResponse = new ODataResponseImpl(data, response);
                    if (status < 200 || status > 299) {
                        logger.log("Invalid status code. Processing response content as String",
                                LogLevel.VERBOSE);
                        String responseData = new String(data, Constants.UTF8_NAME);
                        String message = "Response status: " + response.getStatus() + "\n"
                                + "Response content: " + responseData;
                        logger.log(message, LogLevel.ERROR);
                        result.setException(new ODataException(odataResponse, message));
                        return;
                    }
                    result.set(odataResponse);
                } catch (Throwable t) {
                    logger.log("Unexpected error: " + t.toString(), LogLevel.ERROR);
                    ODataResponse odataResponse = new ODataResponseImpl(null, response);
                    result.setException(new ODataException(odataResponse, t));
                }
            }

            @Override
            public void onFailure(Throwable throwable) {
                result.setException(throwable);
            }
        });
    } catch (Throwable t) {
        result.setException(t);
    }
    return result;

}

---

From source file:com.google.devtools.kythe.platform.shared.RemoteFileData.java

@Override
public Future<byte[]> startLookup(String path, String digest) {
    SettableFuture<byte[]> future = SettableFuture.create();
    stub.get(new SingletonLookup(future))
            .onValue(FileInfo.newBuilder().setPath(path).setDigest(digest).build());
    return future;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »