Java Examples for com.amazonaws.handlers.AsyncHandler

/**
     * asynchronously enqueues a message to SQS.
     *
     * @return a Future object that will be notified when the operation is completed; never null
     */
public Future<SendMessageResult> sendMessage(SendMessageRequest request, AsyncHandler<SendMessageRequest, SendMessageResult> handler) {
    QueueBufferCallback<SendMessageRequest, SendMessageResult> callback = null;
    if (handler != null) {
        callback = new QueueBufferCallback<SendMessageRequest, SendMessageResult>(handler, request);
    }
    QueueBufferFuture<SendMessageRequest, SendMessageResult> future = sendBuffer.sendMessage(request, callback);
    future.setBuffer(this);
    return future;
}

public void store(TaskStatistics ts) {
    try {
        String json = objectMapper.writeValueAsString(ts);
        SendMessageRequest req = new SendMessageRequest();
        req.setMessageBody(json);
        req.setQueueUrl(queueUrl);
        sqs.sendMessageAsync(req, new AsyncHandler<SendMessageRequest, SendMessageResult>() {

            @Override
            public void onError(Exception e) {
                LOG.error("Error saving stats to SQS", e);
            }

            @Override
            public void onSuccess(SendMessageRequest request, SendMessageResult sendMessageResult) {
            /* do nothing */
            }
        });
    } catch (Exception e) {
        LOG.error("Error saving stats to SQS", e);
    }
}

@Override
public void run() {
    try {
        ReceiveMessageRequest request = new ReceiveMessageRequest();
        request.withAttributeNames("SenderId");
        request.setQueueUrl(queueUrl);
        client.receiveMessageAsync(request, new AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult>() {

            @Override
            public void onError(Exception e) {
                logger.severe(e.getMessage());
            }

            @Override
            public void onSuccess(ReceiveMessageRequest receiveMessageRequest, ReceiveMessageResult receiveMessageResult) {
                if (receiveMessageResult.getMessages().size() > 0) {
                    for (Message message : receiveMessageResult.getMessages()) {
                        Event event = SQSUtils.convertMessageToEvent(config.getBaseDir(), message);
                        // Receive the message and delete it
                        receive(event);
                        deleteMessage(message.getReceiptHandle());
                    }
                }
            }
        });
    } catch (Exception e) {
        logger.severe("Lost connection while receiving message " + e.getMessage());
    }
}

protected void sendBatch(Map<String, Collection<MetricDatum>> datums) {
    for (final Map.Entry<String, Collection<MetricDatum>> e : datums.entrySet()) {
        for (final List<MetricDatum> batch : Lists.partition(Lists.newLinkedList(e.getValue()), BATCH_SIZE)) {
            cloudWatch.putMetricDataAsync(new PutMetricDataRequest().withNamespace(e.getKey()).withMetricData(batch), new AsyncHandler<PutMetricDataRequest, Void>() {

                @Override
                public void onError(Exception exception) {
                    LOG.error("PutMetricData failed", exception);
                    LOG.info("Requeueing metric data.");
                    queuedDatums.putAll(e.getKey(), batch);
                }

                @Override
                public void onSuccess(PutMetricDataRequest request, Void result) {
                    LOG.info("Successfully put " + request.getMetricData().size() + " datums for namespace " + request.getNamespace());
                    LOG.debug("Request", request);
                }
            });
        }
    }
}

@Test
public void testGetProfileChecks() throws Exception {
    // Capture the parameters when invoking the method describeTrustedAdvisorChecksAsync (first callback)
    doAnswer( invocation -> {
        DescribeTrustedAdvisorChecksRequest request = invocation.getArgument(0);
        AsyncHandler<DescribeTrustedAdvisorChecksRequest, DescribeTrustedAdvisorChecksResult> handler = invocation.getArgument(1);
        DescribeTrustedAdvisorChecksResult result = createChecks();
        handler.onSuccess(request, result);
        Assert.assertThat(request.getLanguage(), is(Locale.ENGLISH.getLanguage()));
        return CompletableFuture.completedFuture(result);
    }).when(mockClient).describeTrustedAdvisorChecksAsync(any(DescribeTrustedAdvisorChecksRequest.class), any());
    // Capture the parameters when invoking the method describeTrustedAdvisorCheckResultAsync (second callback)
    DescribeTrustedAdvisorCheckResultResult describeTrustedAdvisorCheckResultResult = createChecksResult();
    doAnswer( invocation -> {
        DescribeTrustedAdvisorCheckResultRequest request = invocation.getArgument(0);
        AsyncHandler<DescribeTrustedAdvisorCheckResultRequest, DescribeTrustedAdvisorCheckResultResult> handler = invocation.getArgument(1);
        handler.onSuccess(request, describeTrustedAdvisorCheckResultResult);
        Assert.assertThat(request.getLanguage(), is(Locale.ENGLISH.getLanguage()));
        return CompletableFuture.completedFuture(describeTrustedAdvisorCheckResultResult);
    }).when(mockClient).describeTrustedAdvisorCheckResultAsync(any(DescribeTrustedAdvisorCheckResultRequest.class), any());
    // Calls the method
    TrustedAdvisorClient trustedClient = TrustedAdvisorClient.withClient(mockClient);
    CompletableFuture<ProfileChecks> future = (CompletableFuture<ProfileChecks>) trustedClient.getProfileChecks();
    Assert.assertThat(trustedClient.isAutoshutdown(), is(false));
    // Waits until the future is complete
    Awaitility.await().until(future::isDone);
    Assert.assertThat(future.get().getErrors().isEmpty(), is(false));
    Assert.assertThat(future.get().getErrors().size(), is(2));
    Assert.assertThat(future.get().getErrors().get(0), is("Name 1"));
    Assert.assertThat(future.get().getExceptions().isEmpty(), is(true));
    Assert.assertThat(future.get().getWarnings().isEmpty(), is(false));
    Assert.assertThat(future.get().getWarnings().size(), is(2));
    Assert.assertThat(future.get().getWarnings().get(1), is("Name 4"));
    verify(mockClient).describeTrustedAdvisorChecksAsync(any(DescribeTrustedAdvisorChecksRequest.class), any());
    verify(mockClient, times(4)).describeTrustedAdvisorCheckResultAsync(any(DescribeTrustedAdvisorCheckResultRequest.class), any());
    verify(mockClient, never()).shutdown();
}

private void sendToCloudWatch(Collection<MetricDatum> metricData) {
    PutMetricDataRequest putMetricDataRequest = new PutMetricDataRequest().withNamespace(BufferingCloudWatchMetricSender.this.namespace).withMetricData(metricData);
    BufferingCloudWatchMetricSender.this.amazonCloudWatchAsync.putMetricDataAsync(putMetricDataRequest, new AsyncHandler<PutMetricDataRequest, PutMetricDataResult>() {

        @Override
        public void onError(Exception exception) {
            LOGGER.error("Error sending metric data.", exception);
        }

        @Override
        public void onSuccess(PutMetricDataRequest request, PutMetricDataResult result) {
            LOGGER.debug("Published metric with namespace:{}", request.getNamespace());
        }
    });
}

/**
     * Only one thread can call this method at a time
     */
private void dispatchAllEventsAsync() {
    final List<Event> eventsBatch = this.eventQueue.pollAllQueuedEvents();
    mobileAnalytics.putEventsAsync(new PutEventsRequest().withClientContext(clientContextString).withEvents(eventsBatch), new AsyncHandler<PutEventsRequest, PutEventsResult>() {

        public void onSuccess(PutEventsRequest arg0, PutEventsResult arg1) {
            markRequestDone();
        }

        public void onError(Exception arg0) {
            restoreEventsQueue(eventsBatch);
            markRequestDone();
        }

        private void restoreEventsQueue(List<Event> failedBatch) {
            MobileAnalyticsBatchClientImpl.this.eventQueue.addToHead(failedBatch);
        }

        private void markRequestDone() {
            MobileAnalyticsBatchClientImpl.this.isSendingPutEventsRequest.set(false);
        }
    });
}

@Test
@SuppressWarnings("unchecked")
public void testKinesisMessageHandler() {
    Message<?> message = MessageBuilder.withPayload("message").build();
    try {
        this.kinesisSendChannel.send(message);
    } catch (Exception e) {
        assertThat(e).isInstanceOf(MessageHandlingException.class);
        assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
        assertThat(e.getMessage()).contains("'stream' must not be null for sending a Kinesis record");
    }
    this.kinesisMessageHandler.setStream("foo");
    try {
        this.kinesisSendChannel.send(message);
    } catch (Exception e) {
        assertThat(e).isInstanceOf(MessageHandlingException.class);
        assertThat(e.getCause()).isInstanceOf(IllegalStateException.class);
        assertThat(e.getMessage()).contains("'partitionKey' must not be null for sending a Kinesis record");
    }
    message = MessageBuilder.fromMessage(message).setHeader(AwsHeaders.PARTITION_KEY, "fooKey").setHeader(AwsHeaders.SEQUENCE_NUMBER, "10").build();
    this.kinesisSendChannel.send(message);
    ArgumentCaptor<PutRecordRequest> putRecordRequestArgumentCaptor = ArgumentCaptor.forClass(PutRecordRequest.class);
    verify(this.amazonKinesis).putRecordAsync(putRecordRequestArgumentCaptor.capture(), eq((AsyncHandler<PutRecordRequest, PutRecordResult>) this.asyncHandler));
    PutRecordRequest putRecordRequest = putRecordRequestArgumentCaptor.getValue();
    assertThat(putRecordRequest.getStreamName()).isEqualTo("foo");
    assertThat(putRecordRequest.getPartitionKey()).isEqualTo("fooKey");
    assertThat(putRecordRequest.getSequenceNumberForOrdering()).isEqualTo("10");
    assertThat(putRecordRequest.getExplicitHashKey()).isNull();
    assertThat(putRecordRequest.getData()).isEqualTo(ByteBuffer.wrap("message".getBytes()));
    message = new GenericMessage<>(new PutRecordsRequest().withStreamName("myStream").withRecords(new PutRecordsRequestEntry().withData(ByteBuffer.wrap("test".getBytes())).withPartitionKey("testKey")));
    this.kinesisSendChannel.send(message);
    ArgumentCaptor<PutRecordsRequest> putRecordsRequestArgumentCaptor = ArgumentCaptor.forClass(PutRecordsRequest.class);
    verify(this.amazonKinesis).putRecordsAsync(putRecordsRequestArgumentCaptor.capture(), eq((AsyncHandler<PutRecordsRequest, PutRecordsResult>) this.asyncHandler));
    PutRecordsRequest putRecordsRequest = putRecordsRequestArgumentCaptor.getValue();
    assertThat(putRecordsRequest.getStreamName()).isEqualTo("myStream");
    assertThat(putRecordsRequest.getRecords()).containsExactlyInAnyOrder(new PutRecordsRequestEntry().withData(ByteBuffer.wrap("test".getBytes())).withPartitionKey("testKey"));
}

private void sendUsingAsyncClient(final PutRecordRequest putRecordRequest, Message<JsonObject> event) {
    if (retryCounter == 3) {
        sendError(event, "Failed sending message to Kinesis");
    }
    final Context ctx = vertx.currentContext();
    kinesisAsyncClient.putRecordAsync(putRecordRequest, new AsyncHandler<PutRecordRequest, PutRecordResult>() {

        public void onSuccess(PutRecordRequest request, final PutRecordResult recordResult) {
            ctx.runOnContext( v -> {
                logger.debug("Sent message to Kinesis: " + recordResult.toString());
                sendOK(event);
            });
        }

        public void onError(final java.lang.Exception iexc) {
            ctx.runOnContext( v -> {
                retryCounter++;
                kinesisAsyncClient = createClient();
                logger.info("Failed sending message to Kinesis, retry: " + retryCounter + " ... ", iexc);
                vertx.setTimer(500,  timerID -> sendUsingAsyncClient(putRecordRequest, event));
            });
        }
    });
}

public void store(Event event, CompletableFuture<Void> future, int tryCount) {
    ByteBuf buffer = getBuffer(event);
    kinesis.putRecordAsync(config.getEventStoreStreamName(), buffer.nioBuffer(), getPartitionKey(event), new AsyncHandler<PutRecordRequest, PutRecordResult>() {

        @Override
        public void onError(Exception e) {
            if (e instanceof ResourceNotFoundException) {
                try {
                    KinesisUtils.createAndWaitForStreamToBecomeAvailable(kinesis, config.getEventStoreStreamName(), 1);
                } catch (Exception e1) {
                    throw new RuntimeException("Couldn't send event to Amazon Kinesis", e);
                }
            }
            LOGGER.error(e);
            if (tryCount > 0) {
                store(event, future, tryCount - 1);
            } else {
                buffer.release();
                future.completeExceptionally(new RakamException(INTERNAL_SERVER_ERROR));
            }
        }

        @Override
        public void onSuccess(PutRecordRequest request, PutRecordResult putRecordResult) {
            buffer.release();
            future.complete(null);
        }
    });
}

@Override
public <T extends Serializable> void sendMessageToAllRegions(final T body) throws IOException {
    if (snsAsync == null) {
        logger.error("SNS client is null, perhaps it failed to initialize successfully");
        return;
    }
    final String stringBody = toString(body);
    String topicArn = getWriteTopicArn();
    if (logger.isTraceEnabled()) {
        logger.trace("Publishing Message...{} to arn: {}", stringBody, topicArn);
    }
    PublishRequest publishRequest = new PublishRequest(topicArn, stringBody);
    snsAsync.publishAsync(publishRequest, new AsyncHandler<PublishRequest, PublishResult>() {

        @Override
        public void onError(Exception e) {
            logger.error("Error publishing message... {}", e);
        }

        @Override
        public void onSuccess(PublishRequest request, PublishResult result) {
            if (logger.isTraceEnabled()) {
                logger.trace("Successfully published... messageID=[{}],  arn=[{}]", result.getMessageId(), request.getTopicArn());
            }
        }
    });
}