Example usage for com.amazonaws.services.sqs.model ReceiveMessageRequest ReceiveMessageRequest

List of usage examples for com.amazonaws.services.sqs.model ReceiveMessageRequest ReceiveMessageRequest

Introduction

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

Prototype

public ReceiveMessageRequest() 

Source Link

Document

Default constructor for ReceiveMessageRequest object.

Usage

From source file:aws.example.sqs.LongPolling.java

License:Open Source License

public static void main(String[] args) {
    final String USAGE = "To run this example, supply the name of a queue to create and\n"
            + "queue url of an existing queue.\n\n"
            + "Ex: LongPolling <unique-queue-name> <existing-queue-url>\n";

    if (args.length != 2) {
        System.out.println(USAGE);
        System.exit(1);//w w w . ja  v  a  2s .  c o m
    }

    String queue_name = args[0];
    String queue_url = args[1];

    final AmazonSQS sqs = AmazonSQSClientBuilder.defaultClient();

    // Enable long polling when creating a queue
    CreateQueueRequest create_request = new CreateQueueRequest().withQueueName(queue_name)
            .addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");

    try {
        sqs.createQueue(create_request);
    } catch (AmazonSQSException e) {
        if (!e.getErrorCode().equals("QueueAlreadyExists")) {
            throw e;
        }
    }

    // Enable long polling on an existing queue
    SetQueueAttributesRequest set_attrs_request = new SetQueueAttributesRequest().withQueueUrl(queue_url)
            .addAttributesEntry("ReceiveMessageWaitTimeSeconds", "20");
    sqs.setQueueAttributes(set_attrs_request);

    // Enable long polling on a message receipt
    ReceiveMessageRequest receive_request = new ReceiveMessageRequest().withQueueUrl(queue_url)
            .withWaitTimeSeconds(20);
    sqs.receiveMessage(receive_request);
}

From source file:awslabs.lab31.SolutionCode.java

License:Open Source License

@Override
public List<Message> readMessages(AmazonSQSClient sqsClient, String queueUrl) {
    ReceiveMessageResult receiveMessageResult;

    // TODO: Construct a ReceiveMessageRequest object using the queue URL provided. Set the maximum number of
    // messages to 10.
    ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest().withMaxNumberOfMessages(10)
            .withQueueUrl(queueUrl);//from  ww w .  j  a v a  2s .c om

    // TODO: Submit the request using the receiveMessage method of the sqsClient object. Store the result in the
    // receiveMessageResult object (already defined).
    receiveMessageResult = sqsClient.receiveMessage(receiveMessageRequest);

    return receiveMessageResult.getMessages();
}

From source file:cloudworker.RemoteWorker.java

License:Apache License

public static void main(String[] args) throws Exception {
    //Command interpreter
    CommandLineInterface cmd = new CommandLineInterface(args);
    final int poolSize = Integer.parseInt(cmd.getOptionValue("s"));
    long idle_time = Long.parseLong(cmd.getOptionValue("i")); //idle time = 60 sec

    init();/* w ww .  j  av  a  2  s.  c  o m*/
    System.out.println("Initialized one remote worker.\n");

    //Create thread pool
    ExecutorService threadPool = Executors.newFixedThreadPool(poolSize);
    BlockingExecutor blockingPool = new BlockingExecutor(threadPool, poolSize);

    //Get queue url
    GetQueueUrlResult urlResult = sqs.getQueueUrl("JobQueue");
    String jobQueueUrl = urlResult.getQueueUrl();

    // Receive messages
    //System.out.println("Receiving messages from JobQueue.\n");

    //...Check idle state
    boolean terminate = false;
    boolean startClock = true;
    long start_time = 0, end_time;

    JSONParser parser = new JSONParser();
    Runtime runtime = Runtime.getRuntime();
    String task_id = null;
    boolean runAnimoto = false;

    while (!terminate || idle_time == 0) {
        while (getQueueSize(sqs, jobQueueUrl) > 0) {

            //Batch retrieving messages
            ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest().withQueueUrl(jobQueueUrl)
                    .withMaxNumberOfMessages(10);

            List<Message> messages = sqs.receiveMessage(receiveMessageRequest).getMessages();

            for (Message message : messages) {
                //System.out.println("  Message");
                //                  System.out.println("    MessageId:     " + message.getMessageId());
                //                  System.out.println("    ReceiptHandle: " + message.getReceiptHandle());
                //                  System.out.println("    MD5OfBody:     " + message.getMD5OfBody());
                //System.out.println("    Body:          " + message.getBody());

                //Get task
                String messageBody = message.getBody();
                JSONObject json = (JSONObject) parser.parse(messageBody);

                task_id = json.get("task_id").toString();
                String task = json.get("task").toString();

                try {
                    //Check duplicate task
                    dynamoDB.addTask(task_id, task);

                    //Execute task, will be blocked if no more thread is currently available 
                    blockingPool.submitTask(new Animoto(task_id, task, sqs));

                    // Delete the message
                    String messageRecieptHandle = message.getReceiptHandle();
                    sqs.deleteMessage(new DeleteMessageRequest(jobQueueUrl, messageRecieptHandle));
                } catch (ConditionalCheckFailedException ccf) {
                    //DO something...
                }

            }

            startClock = true;

        }

        //Start clock to measure idle time
        if (startClock) {
            startClock = false;
            start_time = System.currentTimeMillis();
        } else {
            end_time = System.currentTimeMillis();
            long elapsed_time = (end_time - start_time) / 1000;
            if (elapsed_time > idle_time) {
                terminate = true;
            }
        }
    }

    //System.out.println();

    threadPool.shutdown();
    // Wait until all threads are finished
    while (!threadPool.isTerminated()) {

    }

    //Terminate running instance
    cleanUpInstance();

}

From source file:com.allogy.amazonaws.elasticbeanstalk.worker.simulator.application.QueueManager.java

License:Apache License

public Stream<MessageWrapper> readQueue() {
    ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest().withQueueUrl(queueUrl)
            .withWaitTimeSeconds(waitTimeSeconds).withMaxNumberOfMessages(maxNumberOfMessages);

    logger.debug("Reading from queue. queueUrl={}", queueUrl);

    ReceiveMessageResult receiveMessageResult = amazonSQS.receiveMessage(receiveMessageRequest);

    List<Message> messages = receiveMessageResult.getMessages();
    int messageCount = messages.size();
    logger.debug("Received {} messages from queue. queueUrl={}", messageCount, queueUrl);

    return messages.stream().map(
            m -> new MessageWrapper().withQueueUrl(queueUrl).withMessage(m).withMessageCount(messageCount));
}

From source file:com.comcast.cmb.test.tools.CMBTutorial.java

License:Apache License

public static void main(String[] args) {

    try {//from w w w .  j ava  2 s  . c  o  m

        Util.initLog4jTest();

        //TODO: set user id and credentials for two distinct users

        // user "cqs_test_1"

        //BasicAWSCredentials user1Credentials = new BasicAWSCredentials("<access_key>", "<secret_key>");

        BasicAWSCredentials user1Credentials = new BasicAWSCredentials("Z2DVBFRNZ2C2SSXDWS5F",
                "bH2UQiJkpctBaE3eaDob19fj5J9Q1FVafrZantBp");

        // user "cqs_test_2"

        //String user2Id = "<user_id>";
        String user2Id = "389653920093";

        //BasicAWSCredentials user2Credentials = new BasicAWSCredentials("<access_key>", "<secret_key>");

        BasicAWSCredentials user2Credentials = new BasicAWSCredentials("QL8Q1VOBCSJC5FZ2DMIU",
                "n6a82gyJZ04Z+Xqp7OgfqPtbbKqVc3UbuOTNrF+7");

        // service urls

        //TODO: add service URLs

        //String cqsServerUrl = "http://<host>:<port>";
        //String cnsServerUrl = "http://<host>:<port>";

        String cqsServerUrl = "http://localhost:6059";
        String cnsServerUrl = "http://localhost:6061";

        // initialize service

        AmazonSQSClient sqs = new AmazonSQSClient(user1Credentials);
        sqs.setEndpoint(cqsServerUrl);

        AmazonSNSClient sns = new AmazonSNSClient(user2Credentials);
        sns.setEndpoint(cnsServerUrl);

        // create queue

        Random randomGenerator = new Random();

        String queueName = QUEUE_PREFIX + randomGenerator.nextLong();

        HashMap<String, String> attributeParams = new HashMap<String, String>();
        CreateQueueRequest createQueueRequest = new CreateQueueRequest(queueName);
        createQueueRequest.setAttributes(attributeParams);
        String queueUrl = sqs.createQueue(createQueueRequest).getQueueUrl();

        AddPermissionRequest addPermissionRequest = new AddPermissionRequest();
        addPermissionRequest.setQueueUrl(queueUrl);
        addPermissionRequest.setActions(Arrays.asList("SendMessage"));
        addPermissionRequest.setLabel(UUID.randomUUID().toString());
        addPermissionRequest.setAWSAccountIds(Arrays.asList(user2Id));
        sqs.addPermission(addPermissionRequest);

        // create topic

        String topicName = "TSTT" + randomGenerator.nextLong();

        CreateTopicRequest createTopicRequest = new CreateTopicRequest(topicName);
        CreateTopicResult createTopicResult = sns.createTopic(createTopicRequest);
        String topicArn = createTopicResult.getTopicArn();

        // subscribe and confirm cqs endpoint

        SubscribeRequest subscribeRequest = new SubscribeRequest();
        String queueArn = getArnForQueueUrl(queueUrl);
        subscribeRequest.setEndpoint(queueArn);
        subscribeRequest.setProtocol("cqs");
        subscribeRequest.setTopicArn(topicArn);
        SubscribeResult subscribeResult = sns.subscribe(subscribeRequest);
        String subscriptionArn = subscribeResult.getSubscriptionArn();

        if (subscriptionArn.equals("pending confirmation")) {

            Thread.sleep(500);

            ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
            receiveMessageRequest.setQueueUrl(queueUrl);
            receiveMessageRequest.setMaxNumberOfMessages(1);
            ReceiveMessageResult receiveMessageResult = sqs.receiveMessage(receiveMessageRequest);

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

            if (messages != null && messages.size() == 1) {

                JSONObject o = new JSONObject(messages.get(0).getBody());

                if (!o.has("SubscribeURL")) {
                    throw new Exception("message is not a confirmation messsage");
                }

                String subscriptionUrl = o.getString("SubscribeURL");
                httpGet(subscriptionUrl);

                DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest();
                deleteMessageRequest.setReceiptHandle(messages.get(0).getReceiptHandle());
                deleteMessageRequest.setQueueUrl(queueUrl);
                sqs.deleteMessage(deleteMessageRequest);

            } else {
                throw new Exception("no confirmation message found");
            }
        }

        // publish and receive message

        PublishRequest publishRequest = new PublishRequest();
        String messageText = "quamvis sint sub aqua, sub aqua maledicere temptant";
        publishRequest.setMessage(messageText);
        publishRequest.setSubject("unit test message");
        publishRequest.setTopicArn(topicArn);
        sns.publish(publishRequest);

        Thread.sleep(500);

        ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
        receiveMessageRequest.setQueueUrl(queueUrl);
        receiveMessageRequest.setMaxNumberOfMessages(1);
        ReceiveMessageResult receiveMessageResult = sqs.receiveMessage(receiveMessageRequest);

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

        if (messages != null && messages.size() == 1) {

            String messageBody = messages.get(0).getBody();

            if (!messageBody.contains(messageText)) {
                throw new Exception("message text not found");
            }

            DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest();
            deleteMessageRequest.setReceiptHandle(messages.get(0).getReceiptHandle());
            deleteMessageRequest.setQueueUrl(queueUrl);
            sqs.deleteMessage(deleteMessageRequest);

        } else {
            throw new Exception("no messages found");
        }

        // subscribe and confirm http endpoint

        String id = randomGenerator.nextLong() + "";
        String endPointUrl = CMBTestingConstants.HTTP_ENDPOINT_BASE_URL + "recv/" + id;
        String lastMessageUrl = CMBTestingConstants.HTTP_ENDPOINT_BASE_URL + "info/" + id + "?showLast=true";

        subscribeRequest = new SubscribeRequest();
        subscribeRequest.setEndpoint(endPointUrl);
        subscribeRequest.setProtocol("http");
        subscribeRequest.setTopicArn(topicArn);
        subscribeResult = sns.subscribe(subscribeRequest);
        subscriptionArn = subscribeResult.getSubscriptionArn();

        if (subscriptionArn.equals("pending confirmation")) {

            Thread.sleep(500);

            String response = httpGet(lastMessageUrl);

            JSONObject o = new JSONObject(response);

            if (!o.has("SubscribeURL")) {
                throw new Exception("message is not a confirmation messsage");
            }

            String subscriptionUrl = o.getString("SubscribeURL");

            response = httpGet(subscriptionUrl);
        }

        // publish and receive message

        publishRequest = new PublishRequest();
        publishRequest.setMessage(messageText);
        publishRequest.setSubject("unit test message");
        publishRequest.setTopicArn(topicArn);
        sns.publish(publishRequest);

        Thread.sleep(500);

        String response = httpGet(lastMessageUrl);

        if (response != null && response.length() > 0) {

            if (!response.contains(messageText)) {
                throw new Exception("message text not found");
            }

        } else {
            throw new Exception("no messages found");
        }

        // delete queue and topic

        DeleteTopicRequest deleteTopicRequest = new DeleteTopicRequest(topicArn);
        sns.deleteTopic(deleteTopicRequest);

        sqs.deleteQueue(new DeleteQueueRequest(queueUrl));

        System.out.println("OK");

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

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 {//ww  w  .jav  a 2 s  . c om
        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.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.suro.sink.notice.SQSNotice.java

License:Apache License

@Override
public String recv() {
    ReceiveMessageRequest request = new ReceiveMessageRequest().withQueueUrl(queueUrls.get(0))
            .withMaxNumberOfMessages(1);

    try {//from   ww w .j  a v  a  2  s.c  o m
        ReceiveMessageResult result = sqsClient.receiveMessage(request);
        if (!result.getMessages().isEmpty()) {
            Message msg = result.getMessages().get(0);

            recvMessageCount.incrementAndGet();

            DeleteMessageRequest deleteReq = new DeleteMessageRequest().withQueueUrl(queueUrls.get(0))
                    .withReceiptHandle(msg.getReceiptHandle());
            sqsClient.deleteMessage(deleteReq);

            if (enableBase64Encoding) {
                return new String(Base64.decodeBase64(msg.getBody().getBytes()), Charsets.UTF_8);
            } else {
                return msg.getBody();
            }
        } else {
            return "";
        }
    } catch (Exception e) {
        log.error("Exception while recving SQS notice: " + e.getMessage(), e);
        return "";
    }
}

From source file:com.netflix.suro.sink.notice.SQSNotice.java

License:Apache License

@Override
public Pair<String, String> peek() {
    ReceiveMessageRequest request = new ReceiveMessageRequest().withQueueUrl(queueUrls.get(0))
            .withMaxNumberOfMessages(1);

    try {//from   w  w w .  ja va2  s .c o  m
        ReceiveMessageResult result = sqsClient.receiveMessage(request);
        if (!result.getMessages().isEmpty()) {
            Message msg = result.getMessages().get(0);

            recvMessageCount.incrementAndGet();

            if (enableBase64Encoding) {
                return new Pair<String, String>(msg.getReceiptHandle(),
                        new String(Base64.decodeBase64(msg.getBody().getBytes()), Charsets.UTF_8));
            } else {
                return new Pair<String, String>(msg.getReceiptHandle(), msg.getBody());
            }
        } else {
            return null;
        }
    } catch (Exception e) {
        log.error("Exception while recving SQS notice: " + e.getMessage(), e);
        return null;
    }
}

From source file:com.pinterest.teletraan.worker.LaunchEventCollector.java

License:Apache License

public void collectEvents() throws Exception {
    while (true) {
        ReceiveMessageRequest request = new ReceiveMessageRequest();
        request.setMaxNumberOfMessages(10);
        ReceiveMessageResult result = sqsClient.receiveMessage(request);
        List<Message> messageList = result.getMessages();
        if (messageList.isEmpty()) {
            LOG.info("No more Launch activity available at the moment.");
            return;
        }/*from w w  w  .  j a  v a  2s.co m*/
        LOG.info(String.format("Collect %d events from AWS SQS.", messageList.size()));
        ArrayList<DeleteMessageBatchRequestEntry> entries = new ArrayList<>();
        for (Message message : messageList) {
            try {
                boolean hasProcessed = processMessage(message);
                if (hasProcessed) {
                    DeleteMessageBatchRequestEntry entry = new DeleteMessageBatchRequestEntry();
                    entry.setId(message.getMessageId());
                    entry.setReceiptHandle(message.getReceiptHandle());
                    entries.add(entry);
                }
            } catch (Exception ex) {
                LOG.error("Failed to process SQS message:", message, ex);
            }
        }

        if (!entries.isEmpty()) {
            DeleteMessageBatchRequest deleteMessageBatchRequest = new DeleteMessageBatchRequest();
            deleteMessageBatchRequest.setEntries(entries);
            LOG.debug(String.format("Successful process %d messages, deleting them from SQS.", entries.size()));
            sqsClient.deleteMessageBatch(deleteMessageBatchRequest);
        }
    }
}