Example usage for org.springframework.util.concurrent ListenableFutureCallback ListenableFutureCallback

List of usage examples for org.springframework.util.concurrent ListenableFutureCallback ListenableFutureCallback

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.util.concurrent.*
  5. ListenableFutureCallback
  6. ListenableFutureCallback

Introduction

In this page you can find the example usage for org.springframework.util.concurrent ListenableFutureCallback ListenableFutureCallback.

Prototype

ListenableFutureCallback

Source Link

Usage

From source file:at.ac.tuwien.infosys.DeviceManager.java

/**
 * Invoked by the ArtifactBuilder to notify the Manager that a new device
 * update is available.//from  w w w.  j ava 2s  . c o  m
 * 
 * @param deviceId
 * @param imageId
 * @param attachment
 * @return
 */
// TODO get rid of deviceId since Image contains id or set of ids already!
@RequestMapping(value = "/update", method = RequestMethod.POST)
public ResponseEntity<String> update(@RequestBody Image image) {

    logger.info("Received request to update device(s): " + image.getDeviceIds() + " with image: " + image);

    deviceStore.addUpdate(image);

    //      if (force){
    //invoke API manager
    for (String deviceId : image.getDeviceIds()) {
        ListenableFuture<ResponseEntity<String>> result = asyncRestTemplate
                .getForEntity("http://localhost:8080/APIManager/invokeAgent/" + deviceId, String.class);

        result.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
            @Override
            public void onSuccess(ResponseEntity<String> result) {
                //                  LOGGER.info("Received result from node: "
                //                        + result.getBody());
                //                  // Add to a queue
                //                  endTS = System.currentTimeMillis();
                //                  LOGGER.info("Invocation time was: " + startTime + ","
                //                        + endTS);
            }

            @Override
            public void onFailure(Throwable t) {
                //                  LOGGER.info("Error contacting device: "
                //                        + t.getMessage());
            }
        });

    }

    //      }
    return new ResponseEntity<String>("Successfully stored image!", HttpStatus.OK);
}

From source file:io.getlime.push.service.PushMessageSenderService.java

private void sendMessageToAndroid(final FcmClient fcmClient, final PushMessageBody pushMessageBody,
        final PushMessageAttributes attributes, final String pushToken, final PushSendingCallback callback)
        throws PushServerException {

    FcmSendRequest request = new FcmSendRequest();
    request.setTo(pushToken);/*w w  w .  j  av  a2  s. c om*/
    request.setData(pushMessageBody.getExtras());
    request.setCollapseKey(pushMessageBody.getCollapseKey());
    if (attributes == null || !attributes.getSilent()) { // if there are no attributes, assume the message is not silent
        FcmNotification notification = new FcmNotification();
        notification.setTitle(pushMessageBody.getTitle());
        notification.setBody(pushMessageBody.getBody());
        notification.setIcon(pushMessageBody.getIcon());
        notification.setSound(pushMessageBody.getSound());
        notification.setTag(pushMessageBody.getCategory());
        request.setNotification(notification);
    }
    final ListenableFuture<ResponseEntity<FcmSendResponse>> future = fcmClient.exchange(request);

    future.addCallback(new ListenableFutureCallback<ResponseEntity<FcmSendResponse>>() {

        @Override
        public void onFailure(Throwable throwable) {
            Logger.getLogger(PushMessageSenderService.class.getName()).log(Level.SEVERE,
                    "Notification rejected by the FCM gateway: " + throwable.getLocalizedMessage());
            callback.didFinishSendingMessage(PushSendingCallback.Result.FAILED, null);
        }

        @Override
        public void onSuccess(ResponseEntity<FcmSendResponse> response) {
            for (FcmResult fcmResult : response.getBody().getFcmResults()) {
                if (fcmResult.getMessageId() != null) {
                    // no issues, straight sending
                    if (fcmResult.getRegistrationId() == null) {
                        Logger.getLogger(PushMessageSenderService.class.getName()).log(Level.INFO,
                                "Notification sent");
                        callback.didFinishSendingMessage(PushSendingCallback.Result.OK, null);
                    } else {
                        // no issues, straight sending + update token (pass it via context)
                        Logger.getLogger(PushMessageSenderService.class.getName()).log(Level.INFO,
                                "Notification sent and token has been updated");
                        Map<String, Object> contextData = new HashMap<>();
                        contextData.put(FcmResult.KEY_UPDATE_TOKEN, fcmResult.getRegistrationId());
                        callback.didFinishSendingMessage(PushSendingCallback.Result.OK, contextData);
                    }
                } else {
                    if (fcmResult.getFcmError() != null) {
                        switch (fcmResult.getFcmError().toLowerCase()) { // make sure to account for case issues
                        // token doesn't exist, remove device registration
                        case "notregistered":
                            Logger.getLogger(PushMessageSenderService.class.getName()).log(Level.SEVERE,
                                    "Notification rejected by the FCM gateway, invalid token, will be deleted: ");
                            callback.didFinishSendingMessage(PushSendingCallback.Result.FAILED_DELETE, null);
                            break;
                        // retry to send later
                        case "unavailable":
                            Logger.getLogger(PushMessageSenderService.class.getName()).log(Level.SEVERE,
                                    "Notification rejected by the FCM gateway, will retry to send: ");
                            callback.didFinishSendingMessage(PushSendingCallback.Result.PENDING, null);
                            break;
                        // non-recoverable error, remove device registration
                        default:
                            Logger.getLogger(PushMessageSenderService.class.getName()).log(Level.SEVERE,
                                    "Notification rejected by the FCM gateway, non-recoverable error, will be deleted: ");
                            callback.didFinishSendingMessage(PushSendingCallback.Result.FAILED_DELETE, null);
                            break;
                        }
                    }
                }
            }
        }
    });
}

From source file:org.apache.servicecomb.demo.springmvc.tests.SpringMvcIntegrationTestBase.java

@Test
public void ableToSetCustomHeader() {
    HttpHeaders headers = new HttpHeaders();
    headers.set("name", "world");

    HttpEntity<?> requestEntity = new HttpEntity<>(headers);
    ResponseEntity<String> result = restTemplate.exchange(controllerUrl + "sayhei", GET, requestEntity,
            String.class);

    assertThat(jsonOf(result.getBody(), String.class), is("hei world"));

    ListenableFuture<ResponseEntity<String>> listenableFuture = asyncRestTemplate
            .exchange(controllerUrl + "sayhei", GET, requestEntity, String.class);
    //    ResponseEntity<String> responseEntity = listenableFuture.get();
    listenableFuture.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
        @Override//  w  w w  . jav  a2  s . c o m
        public void onFailure(Throwable ex) {
        }

        @Override
        public void onSuccess(ResponseEntity<String> result) {
            assertThat(jsonOf(result.getBody(), String.class), is("hei world"));
        }
    });
}

From source file:org.springframework.cloud.deployer.spi.yarn.YarnAppDeployer.java

@Override
public String deploy(AppDeploymentRequest request) {
    logger.info("Deploy request for {}", request);
    final AppDefinition definition = request.getDefinition();
    Map<String, String> definitionParameters = definition.getProperties();
    Map<String, String> deploymentProperties = request.getDeploymentProperties();
    logger.info("Deploying request for definition {}", definition);
    logger.info("Parameters for definition {}", definitionParameters);
    logger.info("Deployment properties for request {}", deploymentProperties);

    int count = 1;
    String countString = request.getDeploymentProperties().get(AppDeployer.COUNT_PROPERTY_KEY);
    if (StringUtils.hasText(countString)) {
        count = Integer.parseInt(countString);
    }/*from   ww  w .  ja v  a 2  s .  co  m*/
    final String group = request.getDeploymentProperties().get(AppDeployer.GROUP_PROPERTY_KEY);
    Resource resource = request.getResource();
    final String clusterId = group + ":" + definition.getName();

    // contextRunArgs are passed to boot app ran to control yarn apps
    ArrayList<String> contextRunArgs = new ArrayList<String>();
    contextRunArgs.add("--spring.yarn.appName=scdstream:app:" + group);

    // deployment properties override servers.yml which overrides application.yml
    for (Entry<String, String> entry : deploymentProperties.entrySet()) {
        if (entry.getKey().startsWith("spring.cloud.deployer.yarn.app.streamappmaster")) {
            contextRunArgs.add("--" + entry.getKey() + "=" + entry.getValue());
        } else if (entry.getKey().startsWith("spring.cloud.deployer.yarn.app.streamcontainer")) {
            // weird format with '--' is just straight pass to appmaster
            contextRunArgs.add("--spring.yarn.client.launchcontext.arguments.--" + entry.getKey() + "='"
                    + entry.getValue() + "'");
        }
    }

    String baseDir = yarnDeployerProperties.getBaseDir();
    if (!baseDir.endsWith("/")) {
        baseDir = baseDir + "/";
    }

    String artifactPath = isHdfsResource(resource) ? getHdfsArtifactPath(resource)
            : baseDir + "/artifacts/cache/";
    contextRunArgs
            .add("--spring.yarn.client.launchcontext.arguments.--spring.cloud.deployer.yarn.appmaster.artifact="
                    + artifactPath);

    // TODO: using default app name "app" until we start to customise
    //       via deploymentProperties
    final Message<String> message = MessageBuilder.withPayload(AppDeployerStateMachine.EVENT_DEPLOY)
            .setHeader(AppDeployerStateMachine.HEADER_APP_VERSION, "app")
            .setHeader(AppDeployerStateMachine.HEADER_CLUSTER_ID, clusterId)
            .setHeader(AppDeployerStateMachine.HEADER_GROUP_ID, group)
            .setHeader(AppDeployerStateMachine.HEADER_COUNT, count)
            .setHeader(AppDeployerStateMachine.HEADER_ARTIFACT, resource)
            .setHeader(AppDeployerStateMachine.HEADER_ARTIFACT_DIR, artifactPath)
            .setHeader(AppDeployerStateMachine.HEADER_DEFINITION_PARAMETERS, definitionParameters)
            .setHeader(AppDeployerStateMachine.HEADER_CONTEXT_RUN_ARGS, contextRunArgs).build();

    // Use of future here is to set id when it becomes available from machine
    final SettableListenableFuture<String> id = new SettableListenableFuture<>();
    final StateMachineListener<String, String> listener = new StateMachineListenerAdapter<String, String>() {

        @Override
        public void stateContext(StateContext<String, String> stateContext) {
            if (stateContext.getStage() == Stage.STATE_ENTRY
                    && stateContext.getTarget().getId().equals(AppDeployerStateMachine.STATE_READY)) {
                if (ObjectUtils.nullSafeEquals(message.getHeaders().getId().toString(), stateContext
                        .getExtendedState().get(AppDeployerStateMachine.VAR_MESSAGE_ID, String.class))) {
                    Exception exception = stateContext.getExtendedState().get(AppDeployerStateMachine.VAR_ERROR,
                            Exception.class);
                    if (exception != null) {
                        id.setException(exception);
                    } else {
                        String applicationId = stateContext.getStateMachine().getExtendedState()
                                .get(AppDeployerStateMachine.VAR_APPLICATION_ID, String.class);
                        DeploymentKey key = new DeploymentKey(group, definition.getName(), applicationId);
                        id.set(key.toString());
                    }
                }
            }
        }
    };
    stateMachine.addStateListener(listener);
    id.addCallback(new ListenableFutureCallback<String>() {

        @Override
        public void onSuccess(String result) {
            stateMachine.removeStateListener(listener);
        }

        @Override
        public void onFailure(Throwable ex) {
            stateMachine.removeStateListener(listener);
        }
    });

    stateMachine.sendEvent(message);
    // we need to block here until SPI supports
    // returning id asynchronously
    try {
        return id.get(2, TimeUnit.MINUTES);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.springframework.cloud.deployer.spi.yarn.YarnTaskLauncher.java

@Override
public String launch(AppDeploymentRequest request) {
    logger.info("Deploy request for {}", request);
    logger.info("Deploy request deployment properties {}", request.getDeploymentProperties());
    logger.info("Deploy definition {}", request.getDefinition());
    Resource resource = request.getResource();
    AppDefinition definition = request.getDefinition();

    String artifact = resource.getFilename();

    final String name = definition.getName();
    Map<String, String> definitionParameters = definition.getProperties();
    Map<String, String> deploymentProperties = request.getDeploymentProperties();
    List<String> commandlineArguments = request.getCommandlineArguments();
    String appName = "scdtask:" + name;

    // contextRunArgs are passed to boot app ran to control yarn apps
    // we pass needed args to control module coordinates and params,
    // weird format with '--' is just straight pass to container
    ArrayList<String> contextRunArgs = new ArrayList<String>();

    contextRunArgs.add("--spring.yarn.appName=" + appName);
    for (Entry<String, String> entry : definitionParameters.entrySet()) {
        if (StringUtils.hasText(entry.getValue())) {
            contextRunArgs.add(/*w  ww  .  j av  a 2  s .com*/
                    "--spring.yarn.client.launchcontext.arguments.--spring.cloud.deployer.yarn.appmaster.parameters."
                            + entry.getKey() + ".='" + entry.getValue() + "'");
        }
    }

    int index = 0;
    for (String commandlineArgument : commandlineArguments) {
        contextRunArgs.add("--spring.yarn.client.launchcontext.argumentsList[" + index
                + "]='--spring.cloud.deployer.yarn.appmaster.commandlineArguments[" + index + "]="
                + commandlineArgument + "'");
        index++;
    }

    String baseDir = yarnDeployerProperties.getBaseDir();
    if (!baseDir.endsWith("/")) {
        baseDir = baseDir + "/";
    }
    String artifactPath = isHdfsResource(resource) ? getHdfsArtifactPath(resource)
            : baseDir + "/artifacts/cache/";

    contextRunArgs.add(
            "--spring.yarn.client.launchcontext.arguments.--spring.yarn.appmaster.launchcontext.archiveFile="
                    + artifact);
    contextRunArgs
            .add("--spring.yarn.client.launchcontext.arguments.--spring.cloud.deployer.yarn.appmaster.artifact="
                    + artifactPath + artifact);

    // deployment properties override servers.yml which overrides application.yml
    for (Entry<String, String> entry : deploymentProperties.entrySet()) {
        if (StringUtils.hasText(entry.getValue())) {
            if (entry.getKey().startsWith("spring.cloud.deployer.yarn.app.taskcontainer")) {
                contextRunArgs.add("--spring.yarn.client.launchcontext.arguments.--" + entry.getKey() + "='"
                        + entry.getValue() + "'");
            } else if (entry.getKey().startsWith("spring.cloud.deployer.yarn.app.taskappmaster")) {
                contextRunArgs.add("--" + entry.getKey() + "=" + entry.getValue());
            }
        }
    }

    final Message<String> message = MessageBuilder.withPayload(TaskLauncherStateMachine.EVENT_LAUNCH)
            .setHeader(TaskLauncherStateMachine.HEADER_APP_VERSION, "app")
            .setHeader(TaskLauncherStateMachine.HEADER_ARTIFACT, resource)
            .setHeader(TaskLauncherStateMachine.HEADER_ARTIFACT_DIR, artifactPath)
            .setHeader(TaskLauncherStateMachine.HEADER_DEFINITION_PARAMETERS, definitionParameters)
            .setHeader(TaskLauncherStateMachine.HEADER_CONTEXT_RUN_ARGS, contextRunArgs).build();

    // setup future, listen event from machine and finally unregister listener,
    // and set future value
    final SettableListenableFuture<String> id = new SettableListenableFuture<>();
    final StateMachineListener<String, String> listener = new StateMachineListenerAdapter<String, String>() {

        @Override
        public void stateContext(StateContext<String, String> stateContext) {
            if (stateContext.getStage() == Stage.STATE_ENTRY
                    && stateContext.getTarget().getId().equals(TaskLauncherStateMachine.STATE_READY)) {
                if (ObjectUtils.nullSafeEquals(message.getHeaders().getId().toString(), stateContext
                        .getExtendedState().get(TaskLauncherStateMachine.VAR_MESSAGE_ID, String.class))) {
                    Exception exception = stateContext.getExtendedState()
                            .get(TaskLauncherStateMachine.VAR_ERROR, Exception.class);
                    if (exception != null) {
                        id.setException(exception);
                    } else {
                        String applicationId = stateContext.getStateMachine().getExtendedState()
                                .get(TaskLauncherStateMachine.VAR_APPLICATION_ID, String.class);
                        DeploymentKey key = new DeploymentKey(name, applicationId);
                        id.set(key.toString());
                    }
                }
            }
        }
    };

    stateMachine.addStateListener(listener);
    id.addCallback(new ListenableFutureCallback<String>() {

        @Override
        public void onSuccess(String result) {
            stateMachine.removeStateListener(listener);
        }

        @Override
        public void onFailure(Throwable ex) {
            stateMachine.removeStateListener(listener);
        }
    });

    stateMachine.sendEvent(message);
    // we need to block here until SPI supports
    // returning id asynchronously
    try {
        return id.get(2, TimeUnit.MINUTES);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.springframework.cloud.gcp.autoconfigure.pubsub.it.PubSubChannelAdaptersIntegrationTests.java

@Test
public void sendAndReceiveMessagePublishCallback() {
    this.contextRunner.run((context) -> {
        try {/*from  ww w  .  j a va2  s  .  co  m*/
            ListenableFutureCallback<String> callbackSpy = Mockito.spy(new ListenableFutureCallback<String>() {
                @Override
                public void onFailure(Throwable ex) {

                }

                @Override
                public void onSuccess(String result) {

                }
            });
            context.getBean(PubSubMessageHandler.class).setPublishCallback(callbackSpy);
            context.getBean("inputChannel", MessageChannel.class)
                    .send(MessageBuilder.withPayload("I am a message.".getBytes()).build());

            Message<?> message = context.getBean("outputChannel", PollableChannel.class).receive(5000);
            assertThat(message).isNotNull();
            verify(callbackSpy, times(1)).onSuccess(any());
        } finally {
            PubSubAdmin pubSubAdmin = context.getBean(PubSubAdmin.class);
            pubSubAdmin.deleteSubscription((String) context.getBean("subscriptionName"));
            pubSubAdmin.deleteTopic((String) context.getBean("topicName"));
        }
    });
}

From source file:org.springframework.cloud.stream.binder.kafka.streams.KafkaStreamsDlqDispatch.java

@SuppressWarnings("unchecked")
public void sendToDlq(byte[] key, byte[] value, int partittion) {
    ProducerRecord<byte[], byte[]> producerRecord = new ProducerRecord<>(this.dlqName, partittion, key, value,
            null);//w  w w  .  ja v a 2s .c o m

    StringBuilder sb = new StringBuilder().append(" a message with key='")
            .append(toDisplayString(ObjectUtils.nullSafeToString(key))).append("'").append(" and payload='")
            .append(toDisplayString(ObjectUtils.nullSafeToString(value))).append("'").append(" received from ")
            .append(partittion);
    ListenableFuture<SendResult<byte[], byte[]>> sentDlq = null;
    try {
        sentDlq = this.kafkaTemplate.send(producerRecord);
        sentDlq.addCallback(new ListenableFutureCallback<SendResult<byte[], byte[]>>() {

            @Override
            public void onFailure(Throwable ex) {
                KafkaStreamsDlqDispatch.this.logger.error("Error sending to DLQ " + sb.toString(), ex);
            }

            @Override
            public void onSuccess(SendResult<byte[], byte[]> result) {
                if (KafkaStreamsDlqDispatch.this.logger.isDebugEnabled()) {
                    KafkaStreamsDlqDispatch.this.logger.debug("Sent to DLQ " + sb.toString());
                }
            }
        });
    } catch (Exception ex) {
        if (sentDlq == null) {
            KafkaStreamsDlqDispatch.this.logger.error("Error sending to DLQ " + sb.toString(), ex);
        }
    }
}

From source file:org.springframework.integration.samples.async.gateway.ListenableFutureTest.java

@Test
public void testAsyncGateway() throws Exception {
    Random random = new Random();
    int[] numbers = new int[100];
    int expectedResults = 0;
    for (int i = 0; i < 100; i++) {
        numbers[i] = random.nextInt(200);
        if (numbers[i] > 100) {
            expectedResults++;// w w  w  .  j  a  v  a 2s . co m
        }
    }
    final CountDownLatch latch = new CountDownLatch(expectedResults);
    final AtomicInteger failures = new AtomicInteger();
    for (int i = 0; i < 100; i++) {
        final int number = numbers[i];
        ListenableFuture<Integer> result = gateway.multiplyByTwo(number);
        ListenableFutureCallback<Integer> callback = new ListenableFutureCallback<Integer>() {

            @Override
            public void onSuccess(Integer result) {
                logger.info("Result of multiplication of " + number + " by 2 is " + result);
                latch.countDown();
            }

            @Override
            public void onFailure(Throwable t) {
                failures.incrementAndGet();
                logger.error("Unexpected exception for " + number, t);
                latch.countDown();
            }
        };
        result.addCallback(callback);
    }
    assertTrue(latch.await(60, TimeUnit.SECONDS));
    assertEquals(0, failures.get());
    logger.info("Finished");
}

From source file:org.springframework.integration.stomp.AbstractStompSessionManager.java

private synchronized void connect() {
    if (this.connecting || this.connected) {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Aborting connect; another thread is connecting.");
        }//from   www  . j  a va  2s  . c  o  m
        return;
    }
    final int epoch = this.epoch.get();
    this.connecting = true;
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Connecting " + this);
    }
    try {
        this.stompSessionListenableFuture = doConnect(this.compositeStompSessionHandler);
    } catch (Exception e) {
        if (epoch == this.epoch.get()) {
            scheduleReconnect(e);
        } else {
            this.logger.error("STOMP doConnect() error for " + this, e);
        }
        return;
    }
    final CountDownLatch latch = new CountDownLatch(1);
    this.stompSessionListenableFuture.addCallback(new ListenableFutureCallback<StompSession>() {

        @Override
        public void onFailure(Throwable e) {
            if (AbstractStompSessionManager.this.logger.isDebugEnabled()) {
                AbstractStompSessionManager.this.logger.debug("onFailure", e);
            }
            latch.countDown();
            if (epoch == AbstractStompSessionManager.this.epoch.get()) {
                scheduleReconnect(e);
            }
        }

        @Override
        public void onSuccess(StompSession stompSession) {
            if (AbstractStompSessionManager.this.logger.isDebugEnabled()) {
                AbstractStompSessionManager.this.logger.debug("onSuccess");
            }
            AbstractStompSessionManager.this.connected = true;
            AbstractStompSessionManager.this.connecting = false;
            stompSession.setAutoReceipt(isAutoReceiptEnabled());
            if (AbstractStompSessionManager.this.applicationEventPublisher != null) {
                AbstractStompSessionManager.this.applicationEventPublisher
                        .publishEvent(new StompSessionConnectedEvent(this));
            }
            AbstractStompSessionManager.this.reconnectFuture = null;
            latch.countDown();
        }

    });
    try {
        if (!latch.await(10, TimeUnit.SECONDS)) {
            this.logger.error("No response to connection attempt");
            if (epoch == this.epoch.get()) {
                scheduleReconnect(null);
            }
        }
    } catch (InterruptedException e1) {
        this.logger.error("Interrupted while waiting for connection attempt");
        Thread.currentThread().interrupt();
    }
}