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

Introduction

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

Prototype

public void setMessageAttributeNames(java.util.Collection<String> messageAttributeNames) 

Source Link

Document

The name of the message attribute, where N is the index.

Usage

From source file:com.streamsets.pipeline.stage.origin.sqs.SqsConsumerWorkerCallable.java

License:Apache License

@Override
public Exception call() throws Exception {
    Exception terminatingException = null;
    final AmazonSQSAsync asyncConsumer = sqsAsync;

    final ArrayBlockingQueue<String> urlQueue = new ArrayBlockingQueue(queueUrlToNamePrefix.size(), false,
            queueUrlToNamePrefix.keySet());

    while (!context.isStopped() && terminatingException == null) {
        String nextQueueUrl = null;
        try {/* w  w  w. j  av a  2 s  . c  om*/
            nextQueueUrl = urlQueue.take();
            final ReceiveMessageRequest receiveRequest = new ReceiveMessageRequest()
                    .withMaxNumberOfMessages(numMessagesPerRequest).withQueueUrl(nextQueueUrl);
            if (pollWaitTimeSeconds > 0) {
                receiveRequest.setWaitTimeSeconds(pollWaitTimeSeconds);
            }
            if (messageAttributeNames.size() > 0) {
                receiveRequest.setMessageAttributeNames(messageAttributeNames);
            }
            Future<ReceiveMessageResult> resultFuture = asyncConsumer.receiveMessageAsync(receiveRequest);

            ReceiveMessageResult result = resultFuture.get();
            for (Message message : result.getMessages()) {
                final String recordId = getRecordId(message, nextQueueUrl);
                DataParser parser = null;
                try {
                    parser = context.getService(DataFormatParserService.class).getParser(recordId,
                            message.getBody());
                    Record record = null;
                    do {
                        try {
                            record = parser.parse();
                        } catch (RecoverableDataParserException e) {
                            // log the error and keep trying to parse this message
                            LOG.error(Errors.SQS_04.getMessage(), e.getMessage(), e);
                            terminatingException = new StageException(Errors.SQS_04, e.getMessage(), e);
                        } catch (DataParserException e) {
                            // log the error and stop trying to parse this message
                            LOG.error(Errors.SQS_07.getMessage(), e.getMessage(), e);
                            errorRecordHandler.onError(Errors.SQS_07, e.getMessage(), e);
                            break;
                        }
                    } while (record == null);

                    setSqsAttributesOnRecord(message, record, nextQueueUrl,
                            queueUrlToNamePrefix.get(nextQueueUrl));

                    startBatchIfNeeded();
                    batchContext.getBatchMaker().addRecord(record);
                    commitQueueUrlsToMessages.put(nextQueueUrl, message);

                    if (++batchRecordCount > maxBatchSize) {
                        cycleBatch();
                    }
                } catch (DataParserException e) {
                    LOG.error(Errors.SQS_05.getMessage(), e.getMessage(), e);
                    terminatingException = new StageException(Errors.SQS_05, e.getMessage(), e);
                    break;
                } finally {
                    if (parser != null) {
                        parser.close();
                    }
                }
            }

            boolean batchMaxTimeElapsed = Clock.systemUTC().millis() > lastBatchStartTimestamp
                    + maxBatchWaitTimeMs;
            if (batchMaxTimeElapsed) {
                cycleBatch();
            }
        } catch (InterruptedException e) {
            LOG.error("InterruptedException trying to get SQS messages: {}", e.getMessage(), e);
            Thread.currentThread().interrupt();
            break;
        } finally {
            if (nextQueueUrl != null) {
                urlQueue.put(nextQueueUrl);
            }
        }
    }
    flushBatch();
    Optional.ofNullable(asyncConsumer).ifPresent(AmazonSQSAsync::shutdown);
    return terminatingException;
}

---

From source file:org.apache.nifi.processors.aws.sqs.GetSQS.java

License:Apache License

@Override
public void onTrigger(final ProcessContext context, final ProcessSession session) {
    final String queueUrl = context.getProperty(DYNAMIC_QUEUE_URL).evaluateAttributeExpressions().getValue();

    final AmazonSQSClient client = getClient();

    final ReceiveMessageRequest request = new ReceiveMessageRequest();
    request.setAttributeNames(Collections.singleton("All"));
    request.setMessageAttributeNames(Collections.singleton("All"));
    request.setMaxNumberOfMessages(context.getProperty(BATCH_SIZE).asInteger());
    request.setVisibilityTimeout(//from w w  w  .  j ava  2  s . co  m
            context.getProperty(VISIBILITY_TIMEOUT).asTimePeriod(TimeUnit.SECONDS).intValue());
    request.setQueueUrl(queueUrl);
    request.setWaitTimeSeconds(
            context.getProperty(RECEIVE_MSG_WAIT_TIME).asTimePeriod(TimeUnit.SECONDS).intValue());

    final Charset charset = Charset.forName(context.getProperty(CHARSET).getValue());

    final ReceiveMessageResult result;
    try {
        result = client.receiveMessage(request);
    } catch (final Exception e) {
        getLogger().error("Failed to receive messages from Amazon SQS due to {}", new Object[] { e });
        context.yield();
        return;
    }

    final List<Message> messages = result.getMessages();
    if (messages.isEmpty()) {
        context.yield();
        return;
    }

    final boolean autoDelete = context.getProperty(AUTO_DELETE).asBoolean();

    for (final Message message : messages) {
        FlowFile flowFile = session.create();

        final Map<String, String> attributes = new HashMap<>();
        for (final Map.Entry<String, String> entry : message.getAttributes().entrySet()) {
            attributes.put("sqs." + entry.getKey(), entry.getValue());
        }

        for (final Map.Entry<String, MessageAttributeValue> entry : message.getMessageAttributes().entrySet()) {
            attributes.put("sqs." + entry.getKey(), entry.getValue().getStringValue());
        }

        attributes.put("hash.value", message.getMD5OfBody());
        attributes.put("hash.algorithm", "md5");
        attributes.put("sqs.message.id", message.getMessageId());
        attributes.put("sqs.receipt.handle", message.getReceiptHandle());

        flowFile = session.putAllAttributes(flowFile, attributes);
        flowFile = session.write(flowFile, new OutputStreamCallback() {
            @Override
            public void process(final OutputStream out) throws IOException {
                out.write(message.getBody().getBytes(charset));
            }
        });

        session.transfer(flowFile, REL_SUCCESS);
        session.getProvenanceReporter().receive(flowFile, queueUrl);

        getLogger().info("Successfully received {} from Amazon SQS", new Object[] { flowFile });
    }

    if (autoDelete) {
        // If we want to auto-delete messages, we must fist commit the session to ensure that the data
        // is persisted in NiFi's repositories.
        session.commit();

        final DeleteMessageBatchRequest deleteRequest = new DeleteMessageBatchRequest();
        deleteRequest.setQueueUrl(queueUrl);
        final List<DeleteMessageBatchRequestEntry> deleteRequestEntries = new ArrayList<>();
        for (final Message message : messages) {
            final DeleteMessageBatchRequestEntry entry = new DeleteMessageBatchRequestEntry();
            entry.setId(message.getMessageId());
            entry.setReceiptHandle(message.getReceiptHandle());
            deleteRequestEntries.add(entry);
        }

        deleteRequest.setEntries(deleteRequestEntries);

        try {
            client.deleteMessageBatch(deleteRequest);
        } catch (final Exception e) {
            getLogger().error(
                    "Received {} messages from Amazon SQS but failed to delete the messages; these messages"
                            + " may be duplicated. Reason for deletion failure: {}",
                    new Object[] { messages.size(), e });
        }
    }

}

---