Example usage for com.amazonaws.services.sqs.model ReceiveMessageResult getMessages

List of usage examples for com.amazonaws.services.sqs.model ReceiveMessageResult getMessages

Introduction

In this page you can find the example usage for com.amazonaws.services.sqs.model ReceiveMessageResult getMessages.

Prototype


public java.util.List<Message> getMessages() 

Source Link

Document

A list of messages.

Usage

From source file:com.easarrive.image.thumbor.executer.impl.RequestSQSCallable.java

License:Open Source License

@Override
public Boolean call() throws Exception {
    try {/*w  w w . j  a  v a  2s .  c o  m*/
        AmazonSQS client = sqsService.getAmazonSQSClient(region);
        ReceiveMessageResult result = sqsService.receiveMessage(client, queueUrl, maxNumberOfMessages,
                visibilityTimeout);
        if (logger.isDebugEnabled()) {
            logger.debug("The messages to receive result is {}", result);
        }
        if (result == null) {
            throw new ThumborException("The messages to receive result is null");
        }
        List<Message> messageList = result.getMessages();
        if (messageList == null) {
            throw new ThumborException("The message list is null");
        }
        if (messageList.isEmpty()) {
            if (logger.isInfoEnabled()) {
                logger.info("The message list is empty", result);
            }
            return true;
        }

        ExecutorService executorService = Executors.newCachedThreadPool();
        List<Future<Map<String, Object>>> resultList = new ArrayList<Future<Map<String, Object>>>();
        for (Message message : messageList) {
            Future<Map<String, Object>> future = executorService
                    .submit(new MessageCallable(notificationService, message));
            resultList.add(future);
        }

        //??
        for (Future<Map<String, Object>> fs : resultList) {
            try {
                Map<String, Object> resultMap = fs.get();
                if (logger.isDebugEnabled()) {
                    logger.debug("The SQS message result to handle is {}", resultMap);
                }
                Message message = (Message) resultMap.get(MessageCallable.KEY_MESSAGE);
                List<NotificationHandleResult<Message, Boolean>> resultList1 = (List<NotificationHandleResult<Message, Boolean>>) resultMap
                        .get(MessageCallable.KEY_RESULT);
                logger.info("The SQS message result list is {}", resultList1);
                boolean success = false;
                for (NotificationHandleResult<Message, Boolean> resultA : resultList1) {
                    success = resultA.getData();
                    if (!resultA.getData()) {
                        break;
                    }
                }
                if (logger.isInfoEnabled()) {
                    logger.info("\n\t\t|=======- The SQS message (ID : {})  result to handle is {}",
                            message.getMessageId(), success);
                }
                if (success) {
                    DeleteMessageResult deleteMessageResult = sqsService.deleteMessage(client, queueUrl,
                            message);
                    if (logger.isInfoEnabled()) {
                        logger.info(
                                "\n\t\t\t\t\t\t<<======| [Delete SQS Message] The message (ID : {}) to delete result is {}\n",
                                message.getMessageId(), deleteMessageResult);
                    }
                }
                return true;
            } catch (Exception e) {
                if (logger.isErrorEnabled()) {
                    logger.error(e.getMessage(), e);
                }
            } finally {
                //????????
                executorService.shutdown();
            }
        }
    } catch (Exception e) {
        if (logger.isErrorEnabled()) {
            logger.error(e.getMessage(), e);
        }
    }
    return false;
}

From source file:com.eucalyptus.portal.SimpleQueueClientManager.java

License:Open Source License

public List<Message> receiveAllMessages(final String queueName, final boolean shouldDelete) throws Exception {
    try {// w w w .  j a  v a  2  s.com
        final int visibilityTimeout = 600;
        final int visibilityBuffer = 300;
        final long startTime = System.currentTimeMillis();
        final List<Message> messages = Lists.newArrayList();
        while ((System.currentTimeMillis() - startTime) < ((visibilityTimeout - visibilityBuffer) * 1000L)) {
            final ReceiveMessageRequest req = new ReceiveMessageRequest();
            req.setQueueUrl(getQueueUrl(queueName));
            req.setMaxNumberOfMessages(10);
            req.setWaitTimeSeconds(0);
            req.setVisibilityTimeout(visibilityTimeout);

            final ReceiveMessageResult result = getSimpleQueueClient().receiveMessage(req);
            final List<Message> received = result.getMessages();
            if (received == null || received.size() <= 0)
                break;
            messages.addAll(received);
        }

        // TODO: Use PurgeQueue
        if (shouldDelete) {
            for (final List<Message> partition : Iterables.partition(messages, 10)) {
                final DeleteMessageBatchRequest delReq = new DeleteMessageBatchRequest();
                delReq.setQueueUrl(getQueueUrl(queueName));
                delReq.setEntries(partition.stream().map(m -> new DeleteMessageBatchRequestEntry()
                        .withId(m.getMessageId()).withReceiptHandle(m.getReceiptHandle()))
                        .collect(Collectors.toList()));
                getSimpleQueueClient().deleteMessageBatch(delReq);
            }
        }
        return messages;
    } catch (final AmazonServiceException ex) {
        throw new Exception("Failed to receive messages due to service error", ex);
    } catch (final AmazonClientException ex) {
        throw new Exception("Failed to receive messages due to client error", ex);
    }
}

From source file:com.github.gregwhitaker.sns.Consumer.java

License:Apache License

@Override
public void run() {
    String queueName = queueArn.substring(queueArn.lastIndexOf(":") + 1);
    String queueUrl = sqsClient.getQueueUrl(queueName).getQueueUrl();

    while (true) {
        ReceiveMessageResult result = sqsClient.receiveMessage(queueUrl);

        List<Message> messages = result.getMessages();

        if (messages != null && !messages.isEmpty()) {
            for (Message message : messages) {
                try {
                    SnsMessage parsedMessage = mapper.readerFor(SnsMessage.class).readValue(message.getBody());
                    System.out.println(name + ": " + parsedMessage.getMessage());
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    // Acknowledge the message so that it will not be redelivered
                    sqsClient.deleteMessage(queueUrl, message.getReceiptHandle());
                }//from   ww w.j a v a 2 s.  c  o m
            }
        } else {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

From source file:com.netflix.bdp.s3mper.alert.impl.AlertJanitor.java

License:Apache License

private List<Message> pull(String queue, int max) {
    ReceiveMessageResult result = sqs
            .receiveMessage(new ReceiveMessageRequest(queue).withMaxNumberOfMessages(max));

    return result.getMessages();
}

From source file:com.netflix.conductor.contribs.queue.sqs.SQSObservableQueue.java

License:Apache License

@VisibleForTesting
List<Message> receiveMessages() {
    ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest().withQueueUrl(queueURL)
            .withVisibilityTimeout(visibilityTimeout).withMaxNumberOfMessages(batchSize);
    ReceiveMessageResult result = client.receiveMessage(receiveMessageRequest);
    return result.getMessages().stream()
            .map(msg -> new Message(msg.getMessageId(), msg.getBody(), msg.getReceiptHandle()))
            .collect(Collectors.toList());
}

From source file:com.netflix.spinnaker.clouddriver.aws.lifecycle.InstanceTerminationLifecycleAgent.java

License:Apache License

@Override
public void run() {
    AmazonSQS amazonSQS = amazonClientProvider.getAmazonSQS(queueARN.account, queueARN.region);
    AmazonSNS amazonSNS = amazonClientProvider.getAmazonSNS(topicARN.account, topicARN.region);

    List<String> allAccountIds = accountCredentialsProvider.getAll().stream()
            .map(AccountCredentials::getAccountId).filter(a -> a != null).collect(Collectors.toList());

    this.queueId = ensureQueueExists(amazonSQS, queueARN, topicARN);
    ensureTopicExists(amazonSNS, topicARN, allAccountIds, queueARN);

    AtomicInteger messagesProcessed = new AtomicInteger(0);
    while (messagesProcessed.get() < properties.getMaxMessagesPerCycle()) {
        ReceiveMessageResult receiveMessageResult = amazonSQS.receiveMessage(
                new ReceiveMessageRequest(queueId).withMaxNumberOfMessages(AWS_MAX_NUMBER_OF_MESSAGES)
                        .withVisibilityTimeout(properties.getVisibilityTimeout())
                        .withWaitTimeSeconds(properties.getWaitTimeSeconds()));

        if (receiveMessageResult.getMessages().isEmpty()) {
            // No messages
            break;
        }/*from w  w  w . j  a va 2  s. c o m*/

        receiveMessageResult.getMessages().forEach(message -> {
            try {
                LifecycleMessage lifecycleMessage = objectMapper.readValue(message.getBody(),
                        LifecycleMessage.class);

                if (SUPPORTED_LIFECYCLE_TRANSITION.equalsIgnoreCase(lifecycleMessage.lifecycleTransition)) {
                    Task originalTask = TaskRepository.threadLocalTask.get();
                    try {
                        TaskRepository.threadLocalTask.set(Optional.ofNullable(originalTask).orElse(
                                new DefaultTask(InstanceTerminationLifecycleAgent.class.getSimpleName())));
                        handleMessage(lifecycleMessage, TaskRepository.threadLocalTask.get());
                    } finally {
                        TaskRepository.threadLocalTask.set(originalTask);
                    }
                }
            } catch (IOException e) {
                log.error("Unable to convert NotificationMessage (body: {})", message.getBody(), e);
            }

            deleteMessage(amazonSQS, queueId, message);
            messagesProcessed.incrementAndGet();
        });
    }

    log.info("Processed {} messages (queueARN: {})", messagesProcessed.get(), queueARN.arn);
}

From source file:com.netflix.spinnaker.clouddriver.aws.lifecycle.InstanceTerminationLifecycleWorker.java

License:Apache License

private void listenForMessages() {
    AmazonSQS amazonSQS = amazonClientProvider.getAmazonSQS(queueARN.account, queueARN.region);
    AmazonSNS amazonSNS = amazonClientProvider.getAmazonSNS(topicARN.account, topicARN.region);

    Set<? extends AccountCredentials> accountCredentials = accountCredentialsProvider.getAll();
    List<String> allAccountIds = getAllAccountIds(accountCredentials);

    this.queueId = ensureQueueExists(amazonSQS, queueARN, topicARN, getSourceRoleArns(accountCredentials),
            properties.getSqsMessageRetentionPeriodSeconds());
    ensureTopicExists(amazonSNS, topicARN, allAccountIds, queueARN);

    while (true) {
        ReceiveMessageResult receiveMessageResult = amazonSQS.receiveMessage(
                new ReceiveMessageRequest(queueId).withMaxNumberOfMessages(AWS_MAX_NUMBER_OF_MESSAGES)
                        .withVisibilityTimeout(properties.getVisibilityTimeout())
                        .withWaitTimeSeconds(properties.getWaitTimeSeconds()));

        if (receiveMessageResult.getMessages().isEmpty()) {
            // No messages
            continue;
        }/*from   w  w  w  . ja  v a  2s.  c  om*/

        receiveMessageResult.getMessages().forEach(message -> {
            LifecycleMessage lifecycleMessage = unmarshalLifecycleMessage(message.getBody());

            if (lifecycleMessage != null) {
                if (!SUPPORTED_LIFECYCLE_TRANSITION.equalsIgnoreCase(lifecycleMessage.lifecycleTransition)) {
                    log.info("Ignoring unsupported lifecycle transition: "
                            + lifecycleMessage.lifecycleTransition);
                    deleteMessage(amazonSQS, queueId, message);
                    return;
                }
                handleMessage(lifecycleMessage);
            }

            deleteMessage(amazonSQS, queueId, message);
            registry.counter(getProcessedMetricId(queueARN.region)).increment();
        });
    }
}

From source file:com.netflix.spinnaker.clouddriver.aws.lifecycle.LaunchFailureNotificationAgent.java

License:Apache License

@Override
public void run() {
    List<String> allAccountIds = accountCredentialsProvider.getAll().stream()
            .filter(c -> c instanceof NetflixAmazonCredentials).map(AccountCredentials::getAccountId)
            .collect(Collectors.toList());

    AmazonSQS amazonSQS = amazonClientProvider.getAmazonSQS(queueARN.account, queueARN.region);
    this.queueId = ensureQueueExists(amazonSQS, queueARN, topicARN);

    AmazonSNS amazonSNS = amazonClientProvider.getAmazonSNS(topicARN.account, topicARN.region);
    this.topicId = ensureTopicExists(amazonSNS, topicARN, allAccountIds, queueARN);

    AtomicInteger messagesProcessed = new AtomicInteger(0);
    while (messagesProcessed.get() < properties.getMaxMessagesPerCycle()) {
        ReceiveMessageResult receiveMessageResult = amazonSQS.receiveMessage(
                new ReceiveMessageRequest(queueId).withMaxNumberOfMessages(AWS_MAX_NUMBER_OF_MESSAGES)
                        .withVisibilityTimeout(properties.getVisibilityTimeout())
                        .withWaitTimeSeconds(properties.getWaitTimeSeconds()));

        receiveMessageResult.getMessages().forEach(message -> {
            try {
                NotificationMessageWrapper notificationMessageWrapper = objectMapper
                        .readValue(message.getBody(), NotificationMessageWrapper.class);

                NotificationMessage notificationMessage = objectMapper
                        .readValue(notificationMessageWrapper.message, NotificationMessage.class);

                if (SUPPORTED_LIFECYCLE_TRANSITION.equalsIgnoreCase(notificationMessage.event)) {
                    handleMessage(serverGroupTagger, notificationMessage);
                }//from  w  ww. ja  v  a 2 s. co m
            } catch (IOException e) {
                log.error("Unable to convert NotificationMessage (body: {})", message.getBody(), e);
            }

            deleteMessage(amazonSQS, queueId, message);
            messagesProcessed.incrementAndGet();
        });

        if (receiveMessageResult.getMessages().isEmpty()) {
            // no messages received, stop polling.
            break;
        }
    }

    log.info("Processed {} messages (queueARN: {})", messagesProcessed.get(), queueARN.arn);
}

From source file:com.netflix.spinnaker.echo.pubsub.amazon.SQSSubscriber.java

License:Apache License

private void listenForMessages() {
    while (isEnabled.get()) {
        ReceiveMessageResult receiveMessageResult = amazonSQS.receiveMessage(
                new ReceiveMessageRequest(queueId).withMaxNumberOfMessages(AWS_MAX_NUMBER_OF_MESSAGES)
                        .withVisibilityTimeout(subscription.getVisibilityTimeout())
                        .withWaitTimeSeconds(subscription.getWaitTimeSeconds()));

        if (receiveMessageResult.getMessages().isEmpty()) {
            log.debug("Received no messages for queue: {}", queueARN);
            continue;
        }/*from  w w w .j  a va2s.  c o  m*/

        receiveMessageResult.getMessages().forEach(message -> {
            handleMessage(message);
        });
    }
}

From source file:com.netflix.spinnaker.echo.pubsub.aws.SQSSubscriber.java

License:Apache License

private void listenForMessages() {
    while (isEnabled.get()) {
        ReceiveMessageResult receiveMessageResult = amazonSQS.receiveMessage(new ReceiveMessageRequest(queueId)
                .withMaxNumberOfMessages(AWS_MAX_NUMBER_OF_MESSAGES)
                .withVisibilityTimeout(subscription.getVisibilityTimeout())
                .withWaitTimeSeconds(subscription.getWaitTimeSeconds()).withMessageAttributeNames("All"));

        if (receiveMessageResult.getMessages().isEmpty()) {
            log.debug("Received no messages for queue: {}", queueARN);
            continue;
        }/* www .j  av  a2s  .  c  o  m*/

        receiveMessageResult.getMessages().forEach(this::handleMessage);
    }
}