index int64 0 0 | repo_id stringlengths 26 205 | file_path stringlengths 51 246 | content stringlengths 8 433k | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model/ScanMetaData.java | package com.amazonaws.gurureviewercli.model;
import java.nio.file.Path;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* Data class to store information about a started CodeGuru Review.
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ScanMetaData {
private String associationArn;
private String codeReviewArn;
private String region;
private Path repositoryRoot;
private List<Path> sourceDirectories;
private String bucketName;
private String sourceKey;
private String buildKey;
}
| 1,600 |
0 | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model/configfile/ExcludeRecommendation.java | package com.amazonaws.gurureviewercli.model.configfile;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* Model class to exclude a detector in a given file.
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ExcludeRecommendation {
private String detectorId;
private List<String> locations;
}
| 1,601 |
0 | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model/configfile/CustomConfiguration.java | package com.amazonaws.gurureviewercli.model.configfile;
import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j2;
import com.amazonaws.gurureviewercli.util.Log;
/**
* Guru Configuration file. Customers can leave such a file in their repository to customize the behavior of
* CodeGuru. E.g., to suppress recommendations in parts of the repository.
*/
@Log4j2
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CustomConfiguration {
private static final ObjectMapper YAML_MAPPER =
YAMLMapper.builder()
.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true)
.build();
public static CustomConfiguration load(final Path file) throws IOException {
try {
return YAML_MAPPER.readValue(file.toFile(), CustomConfiguration.class);
} catch (JsonParseException | JsonMappingException e) {
Log.error("Failed to parse " + file);
Log.error(e);
}
return null;
}
private static final String VERSION = "1.0";
@Builder.Default
private String version = VERSION;
@Builder.Default
private List<String> excludeFiles = new ArrayList<>();
private String excludeBelowSeverity;
@Builder.Default
private List<String> excludeTags = new ArrayList<>();
@Builder.Default
private List<String> excludeById = new ArrayList<>();
@Builder.Default
private List<ExcludeRecommendation> excludeRecommendations = new ArrayList<>();
}
| 1,602 |
0 | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model/bitbucket/CodeInsightsReportData.java | package com.amazonaws.gurureviewercli.model.bitbucket;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j2;
/**
* Bitbucket CodeInsight report data.
* See https://developer.atlassian.com/cloud/bitbucket/rest/api-group-reports/#api-group-reports
*/
@Log4j2
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CodeInsightsReportData {
private String title;
private String type;
private Object value;
}
| 1,603 |
0 | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model/bitbucket/CodeInsightsReport.java | package com.amazonaws.gurureviewercli.model.bitbucket;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j2;
/**
* Bitbucket CodeInsight report format.
* See https://developer.atlassian.com/cloud/bitbucket/rest/api-group-reports/#api-group-reports
* Example:
* {
* "title": "Amazon CodeGuru Reviewer Scan Report",
* "details": "Some more text.",
* "report_type": "SECURITY",
* "reporter": "Amazon CodeGuru Reviewer",
* "link": "http://www.CodeGuruReviewer.com/reports/001",
* "result": "FAILED",
* "data": [
* {
* "title": "Duration (seconds)",
* "type": "DURATION",
* "value": 14
* },
* {
* "title": "Safe to merge?",
* "type": "BOOLEAN",
* "value": false
* }
* ]
* }
*/
@Log4j2
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CodeInsightsReport {
private String title;
private String details;
private String result;
private String link;
private List<CodeInsightsReportData> data;
@JsonProperty("reporter")
private String reporter;
@JsonProperty("report_type")
private final String reportType = "SECURITY";
}
| 1,604 |
0 | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model | Create_ds/aws-codeguru-cli/src/main/java/com/amazonaws/gurureviewercli/model/bitbucket/CodeInsightsAnnotation.java | package com.amazonaws.gurureviewercli.model.bitbucket;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.log4j.Log4j2;
/**
* Bitbucket CodeInsight annotation.
* See https://developer.atlassian.com/cloud/bitbucket/rest/api-group-reports/#api-group-reports
*
* Example
* {
* "external_id": "CodeGuruReviewer-02-annotation002",
* "title": "Bug report",
* "annotation_type": "BUG",
* "summary": "This line might introduce a bug.",
* "severity": "MEDIUM",
* "path": "my-service/src/main/java/com/myCompany/mysystem/logic/Helper.java",
* "line": 13
* }
*/
@Log4j2
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CodeInsightsAnnotation {
private String title;
@JsonProperty("external_id")
private String externalId;
@JsonProperty("annotation_type")
private String annotationType;
private String path;
private long line;
private String summary;
private String severity;
private String details;
private String link;
}
| 1,605 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/HandlerParamsTest.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import com.amazonaws.services.lambda.runtime.tests.annotations.*;
import org.junit.jupiter.params.ParameterizedTest;
import static org.assertj.core.api.Assertions.assertThat;
public class HandlerParamsTest {
@ParameterizedTest
@HandlerParams(
event = @Event(value = "apigw/events/apigw_event.json", type = APIGatewayProxyRequestEvent.class),
response = @Response(value = "apigw/responses/apigw_response.json", type = APIGatewayProxyResponseEvent.class))
public void testSimpleEventResponse(APIGatewayProxyRequestEvent event, APIGatewayProxyResponseEvent response) {
assertThat(event).isNotNull();
assertThat(event.getBody()).contains("Lambda rocks");
assertThat(event.getHeaders()).hasSize(18);
assertThat(event.getHttpMethod()).isEqualTo("POST");
assertThat(response).isNotNull();
assertThat(response.getStatusCode()).isEqualTo(200);
assertThat(response.getBody()).contains("Lambda rocks");
}
@ParameterizedTest
@HandlerParams(
events = @Events(folder = "apigw/events/", type = APIGatewayProxyRequestEvent.class),
responses = @Responses(folder = "apigw/responses/", type = APIGatewayProxyResponseEvent.class))
public void testMultipleEventsResponsesinFolder(APIGatewayProxyRequestEvent event, APIGatewayProxyResponseEvent response) {
assertThat(event).isNotNull();
assertThat(event.getHeaders()).hasSize(18);
assertThat(event.getHttpMethod()).isEqualTo("POST");
assertThat(response).isNotNull();
assertThat(response.getStatusCode()).isEqualTo(200);
assertThat(response.getBody()).isEqualTo(event.getBody());
}
@ParameterizedTest
@HandlerParams(
events = @Events(
events = {
@Event("apigw/events/apigw_event.json"),
@Event("apigw/events/apigw_event_nobody.json"),
},
type = APIGatewayProxyRequestEvent.class
),
responses = @Responses(
responses = {
@Response("apigw/responses/apigw_response.json"),
@Response("apigw/responses/apigw_response2.json")
},
type = APIGatewayProxyResponseEvent.class
)
)
public void testMultipleEventsResponses(APIGatewayProxyRequestEvent event, APIGatewayProxyResponseEvent response) {
assertThat(event).isNotNull();
assertThat(event.getHeaders()).hasSize(18);
assertThat(event.getHttpMethod()).isEqualTo("POST");
assertThat(response).isNotNull();
assertThat(response.getStatusCode()).isEqualTo(200);
assertThat(response.getBody()).isEqualTo(event.getBody());
}
}
| 1,606 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/EventsTest.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.amazonaws.services.lambda.runtime.tests.annotations.Event;
import com.amazonaws.services.lambda.runtime.tests.annotations.Events;
import org.junit.jupiter.params.ParameterizedTest;
import static org.assertj.core.api.Assertions.assertThat;
public class EventsTest {
@ParameterizedTest
@Events(
events = {
@Event("sqs/sqs_event_nobody.json"),
@Event("sqs/sqs_event_product.json"),
},
type = SQSEvent.class
)
public void testInjectEvents(SQSEvent event) {
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
}
@ParameterizedTest
@Events(
events = {
@Event(value = "sqs/sqs_event_nobody.json", type = SQSEvent.class),
@Event(value = "sqs/sqs_event_product.json", type = SQSEvent.class),
}
)
public void testInjectEvents2(SQSEvent event) {
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
}
@ParameterizedTest
@Events(folder = "sqs", type = SQSEvent.class)
public void testInjectEventsFromFolder(SQSEvent event) {
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
}
}
| 1,607 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/EventTest.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.amazonaws.services.lambda.runtime.tests.annotations.Event;
import org.junit.jupiter.params.ParameterizedTest;
import static org.assertj.core.api.Assertions.assertThat;
public class EventTest {
@ParameterizedTest
@Event(value = "sqs/sqs_event_nobody.json", type = SQSEvent.class)
public void testInjectEvent(SQSEvent event) {
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
}
}
| 1,608 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/test/java/com/amazonaws/services/lambda/runtime/tests/EventLoaderTest.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue;
import com.amazonaws.services.lambda.runtime.events.models.dynamodb.Record;
import com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord;
import org.joda.time.DateTime;
import org.junit.jupiter.api.Test;
import java.time.Instant;
import java.util.Date;
import java.util.List;
import java.util.Map;
import static java.time.Instant.ofEpochSecond;
import static org.assertj.core.api.Assertions.*;
import static org.assertj.core.api.Assertions.from;
import com.amazonaws.services.lambda.runtime.events.*;
public class EventLoaderTest {
@Test
public void testLoadApiGatewayRestEvent() {
APIGatewayProxyRequestEvent event = EventLoader.loadApiGatewayRestEvent("apigw_rest_event.json");
assertThat(event).isNotNull();
assertThat(event.getBody()).isEqualTo("Hello from Lambda!");
assertThat(event.getHeaders()).hasSize(2);
}
@Test
public void testLoadApiGatewayHttpEvent() {
APIGatewayV2HTTPEvent event = EventLoader.loadApiGatewayHttpEvent("apigw_http_event.json");
assertThat(event).isNotNull();
assertThat(event.getBody()).isEqualTo("Hello from Lambda!!");
}
@Test
public void testLoadAPIGatewayCustomAuthorizerEvent() {
APIGatewayCustomAuthorizerEvent event = EventLoader.loadAPIGatewayCustomAuthorizerEvent("apigw_auth.json");
assertThat(event).isNotNull();
assertThat(event.getRequestContext().getHttpMethod()).isEqualTo("GET");
assertThat(event.getHeaders()).hasSize(8);
}
@Test
public void testLoadAPIGatewayV2CustomAuthorizerEvent() {
APIGatewayV2CustomAuthorizerEvent event = EventLoader.loadAPIGatewayV2CustomAuthorizerEvent("apigw_auth_v2.json");
assertThat(event).isNotNull();
assertThat(event.getRequestContext().getHttp().getMethod()).isEqualTo("POST");
assertThat(event.getRequestContext().getTimeEpoch()).isEqualTo(Instant.ofEpochMilli(1583348638390L));
}
@Test
public void testLoadApplicationLoadBalancerRequestEvent() {
ApplicationLoadBalancerRequestEvent event = EventLoader.loadApplicationLoadBalancerRequestEvent("elb_event.json");
assertThat(event).isNotNull();
assertThat(event.getBody()).isEqualTo("Hello from ELB");
}
@Test
public void testLoadConfigEvent() {
ConfigEvent event = EventLoader.loadConfigEvent("config_event.json");
assertThat(event).isNotNull();
assertThat(event.getConfigRuleArn()).isEqualTo("arn:aws:config:eu-central-1:123456789012:config-rule/config-rule-0123456");
assertThat(event.getConfigRuleName()).isEqualTo("change-triggered-config-rule");
}
@Test
public void testLoadKafkaEvent() {
KafkaEvent event = EventLoader.loadKafkaEvent("kafka_event.json");
assertThat(event).isNotNull();
assertThat(event.getEventSourceArn()).isEqualTo("arn:aws:kafka:us-east-1:123456789012:cluster/vpc-3432434/4834-3547-3455-9872-7929");
assertThat(event.getBootstrapServers()).isEqualTo("b-2.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092,b-1.demo-cluster-1.a1bcde.c1.kafka.us-east-1.amazonaws.com:9092");
KafkaEvent.KafkaEventRecord record = event.getRecords().get("mytopic-01").get(0);
assertThat(record.getValue()).decodedAsBase64().asString().isEqualTo("Hello from Kafka !!");
String headerValue = new String(record.getHeaders().get(0).get("headerKey"));
assertThat(headerValue).isEqualTo("headerValue");
}
@Test
public void testLoadLambdaDestinationEvent() {
LambdaDestinationEvent event = EventLoader.loadLambdaDestinationEvent("lambda_destination_event.json");
assertThat(event).isNotNull();
assertThat(event.getTimestamp()).isEqualTo(DateTime.parse("2019-11-24T21:52:47.333Z"));
assertThat(event.getRequestContext().getFunctionArn()).isEqualTo("arn:aws:lambda:sa-east-1:123456678912:function:event-destinations:$LATEST");
assertThat(event.getRequestPayload().get("Success")).isEqualTo(false);
}
@Test
public void testLoadLexEvent() {
LexEvent event = EventLoader.loadLexEvent("lex_event.json");
assertThat(event).isNotNull();
assertThat(event.getInvocationSource()).isEqualTo("DialogCodeHook");
assertThat(event.getSessionAttributes()).hasSize(1);
assertThat(event.getCurrentIntent().getName()).isEqualTo("BookHotel");
assertThat(event.getCurrentIntent().getSlots()).hasSize(4);
assertThat(event.getBot().getName()).isEqualTo("BookTrip");
}
@Test
public void testLoadKinesisFirehoseEvent() {
KinesisFirehoseEvent event = EventLoader.loadKinesisFirehoseEvent("firehose_event.json");
assertThat(event).isNotNull();
assertThat(event.getDeliveryStreamArn()).isEqualTo("arn:aws:kinesis:EXAMPLE");
assertThat(event.getRecords()).hasSize(1);
assertThat(event.getRecords().get(0).getData().array()).asString().isEqualTo("Hello, this is a test 123.");
}
@Test
public void testLoadS3Event() {
S3Event event = EventLoader.loadS3Event("s3_event.json");
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
}
@Test
public void testLoadSQSEvent() {
SQSEvent event = EventLoader.loadSQSEvent("sqs/sqs_event_nobody.json");
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
assertThat(event.getRecords().get(0).getEventSourceArn()).isEqualTo("arn:aws:sqs:eu-central-1:123456789012:TestLambda");
}
@Test
public void testLoadSNSEvent() {
SNSEvent event = EventLoader.loadSNSEvent("sns_event.json");
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
SNSEvent.SNSRecord record = event.getRecords().get(0);
assertThat(record.getEventSource()).isEqualTo("aws:sns");
assertThat(record.getEventVersion()).isEqualTo("1.0");
assertThat(record.getEventSubscriptionArn()).isEqualTo("arn:aws:sns:eu-central-1:123456789012:TopicSendToMe:e3ddc7d5-2f86-40b8-a13d-3362f94fd8dd");
SNSEvent.SNS sns = record.getSNS();
assertThat(sns)
.returns("Test sns message", from(SNSEvent.SNS::getSubject))
.returns("{\n \"id\": 42,\n \"name\": \"Bob\"\n}", from(SNSEvent.SNS::getMessage))
.returns("arn:aws:sns:eu-central-1:123456789012:TopicSendToMe", from(SNSEvent.SNS::getTopicArn))
.returns("dc918f50-80c6-56a2-ba33-d8a9bbf013ab", from(SNSEvent.SNS::getMessageId))
.returns(DateTime.parse("2020-10-08T16:06:14.656Z"), from(SNSEvent.SNS::getTimestamp))
.returns("https://sns.eu-central-1.amazonaws.com/?Action=Unsubscribe", SNSEvent.SNS::getUnsubscribeUrl);
assertThat(sns.getMessageAttributes()).containsKey("name");
assertThat(sns.getMessageAttributes().get("name").getValue()).isEqualTo("Bob");
assertThat(sns.getMessageAttributes().get("name").getType()).isEqualTo("String");
}
@Test
public void testLoadDynamoEvent() {
DynamodbEvent event = EventLoader.loadDynamoDbEvent("dynamo_event.json");
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(3);
DynamodbEvent.DynamodbStreamRecord record = event.getRecords().get(0);
assertThat(record)
.returns("arn:aws:dynamodb:eu-central-1:123456789012:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899", from(DynamodbEvent.DynamodbStreamRecord::getEventSourceARN))
.returns("INSERT", from(Record::getEventName));
StreamRecord streamRecord = record.getDynamodb();
assertThat(streamRecord)
.returns("4421584500000000017450439091", StreamRecord::getSequenceNumber)
.returns(26L, StreamRecord::getSizeBytes)
.returns("NEW_AND_OLD_IMAGES", StreamRecord::getStreamViewType)
.returns(Date.from(ofEpochSecond(1428537600)), StreamRecord::getApproximateCreationDateTime);
assertThat(streamRecord.getKeys()).contains(entry("Id", new AttributeValue().withN("101")));
assertThat(streamRecord.getNewImage()).containsAnyOf(
entry("Message", new AttributeValue("New item!")),
entry("Id", new AttributeValue().withN("101"))
);
}
@Test
public void testLoadKinesisEvent() {
KinesisEvent event = EventLoader.loadKinesisEvent("kinesis_event.json");
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
KinesisEvent.Record record = event.getRecords().get(0).getKinesis();
assertThat(record.getEncryptionType()).isEqualTo("NONE");
assertThat(record.getApproximateArrivalTimestamp()).isEqualTo(Date.from(ofEpochSecond(1428537600)));
assertThat(new String(record.getData().array())).isEqualTo("Hello, this is a test 123.");
}
@Test
public void testLoadActiveMQEvent() {
ActiveMQEvent event = EventLoader.loadActiveMQEvent("mq_event.json");
assertThat(event).isNotNull();
assertThat(event.getMessages()).hasSize(2);
assertThat(event.getMessages().get(0).getMessageID()).isEqualTo("ID:b-9bcfa592-423a-4942-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1");
assertThat(event.getMessages().get(1).getMessageID()).isEqualTo("ID:b-8bcfa572-428a-4642-879d-eb284b418fc8-1.mq.us-west-2.amazonaws.com-37557-1234520418293-4:1:1:1:1");
}
@Test
public void testLoadActiveMQEventWithProperties() {
ActiveMQEvent event = EventLoader.loadActiveMQEvent("mq_event.json");
assertThat(event).isNotNull();
assertThat(event.getMessages()).hasSize(2);
assertThat(event.getMessages().get(0).getProperties().get("testKey")).isEqualTo("testValue");
assertThat(event.getMessages().get(1).getProperties().get("testKey")).isEqualTo("testValue");
}
@Test
public void testLoadCodeCommitEvent() {
CodeCommitEvent event = EventLoader.loadCodeCommitEvent("codecommit_event.json");
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
CodeCommitEvent.Record record = event.getRecords().get(0);
assertThat(record.getEventSourceArn()).isEqualTo("arn:aws:codecommit:eu-central-1:123456789012:my-repo");
assertThat(record.getUserIdentityArn()).isEqualTo("arn:aws:iam::123456789012:root");
assertThat(record.getEventTime()).isEqualTo(DateTime.parse("2016-01-01T23:59:59.000+0000"));
assertThat(record.getCodeCommit().getReferences()).hasSize(1);
CodeCommitEvent.Reference reference = record.getCodeCommit().getReferences().get(0);
assertThat(reference.getCommit()).isEqualTo("5c4ef1049f1d27deadbeeff313e0730018be182b");
assertThat(reference.getRef()).isEqualTo("refs/heads/master");
}
@Test
public void testLoadCloudWatchLogsEvent() {
CloudWatchLogsEvent cloudWatchLogsEvent = EventLoader.loadCloudWatchLogsEvent("cloudwatchlogs_event.json");
assertThat(cloudWatchLogsEvent).isNotNull();
assertThat(cloudWatchLogsEvent.getAwsLogs().getData()).isEqualTo("H4sIAAAAAAAAAHWPwQqCQBCGX0Xm7EFtK+smZBEUgXoLCdMhFtKV3akI8d0bLYmibvPPN3wz00CJxmQnTO41whwWQRIctmEcB6sQbFC3CjW3XW8kxpOpP+OC22d1Wml1qZkQGtoMsScxaczKN3plG8zlaHIta5KqWsozoTYw3/djzwhpLwivWFGHGpAFe7DL68JlBUk+l7KSN7tCOEJ4M3/qOI49vMHj+zCKdlFqLaU2ZHV2a4Ct/an0/ivdX8oYc1UVX860fQDQiMdxRQEAAA==");
}
@Test
public void testLoadCloudFrontEvent() {
CloudFrontEvent event = EventLoader.loadCloudFrontEvent("cloudfront_event.json");
assertThat(event).isNotNull();
assertThat(event.getRecords()).hasSize(1);
assertThat(event.getRecords().get(0).getCf().getConfig().getDistributionId()).isEqualTo("EXAMPLE");
}
@Test
public void testLoadScheduledEvent() {
ScheduledEvent event = EventLoader.loadScheduledEvent("cloudwatch_event.json");
assertThat(event).isNotNull();
assertThat(event.getDetailType()).isEqualTo("Scheduled Event");
assertThat(event.getTime()).isEqualTo(DateTime.parse("2020-09-30T15:58:34Z"));
}
@Test
public void testLoadConnectEvent() {
ConnectEvent event = EventLoader.loadConnectEvent("connect_event.json");
assertThat(event).isNotNull();
ConnectEvent.ContactData contactData = event.getDetails().getContactData();
assertThat(contactData)
.returns("VOICE", from(ConnectEvent.ContactData::getChannel))
.returns("5ca32fbd-8f92-46af-92a5-6b0f970f0efe", from(ConnectEvent.ContactData::getContactId))
.returns("6ca32fbd-8f92-46af-92a5-6b0f970f0efe", from(ConnectEvent.ContactData::getInitialContactId))
.returns("API", from(ConnectEvent.ContactData::getInitiationMethod))
.returns("arn:aws:connect:eu-central-1:123456789012:instance/9308c2a1-9bc6-4cea-8290-6c0b4a6d38fa", from(ConnectEvent.ContactData::getInstanceArn))
.returns("4ca32fbd-8f92-46af-92a5-6b0f970f0efe", from(ConnectEvent.ContactData::getPreviousContactId));
assertThat(contactData.getCustomerEndpoint())
.returns("+11234567890",from(ConnectEvent.CustomerEndpoint::getAddress))
.returns("TELEPHONE_NUMBER",from(ConnectEvent.CustomerEndpoint::getType));
assertThat(contactData.getSystemEndpoint())
.returns("+21234567890",from(ConnectEvent.SystemEndpoint::getAddress))
.returns("TELEPHONE_NUMBER",from(ConnectEvent.SystemEndpoint::getType));
}
@Test
public void testLoadCloudFormationCustomResourceEvent() {
CloudFormationCustomResourceEvent event = EventLoader.loadCloudFormationCustomResourceEvent("cloudformation_event.json");
assertThat(event).isNotNull();
assertThat(event)
.returns("Update", from(CloudFormationCustomResourceEvent::getRequestType))
.returns("http://pre-signed-S3-url-for-response", from(CloudFormationCustomResourceEvent::getResponseUrl))
.returns("arn:aws:cloudformation:eu-central-1:123456789012:stack/MyStack/guid", from(CloudFormationCustomResourceEvent::getStackId))
.returns("unique id for this create request", from(CloudFormationCustomResourceEvent::getRequestId))
.returns("Custom::TestResource", from(CloudFormationCustomResourceEvent::getResourceType))
.returns("MyTestResource", from(CloudFormationCustomResourceEvent::getLogicalResourceId))
.returns("MyTestResourceId", from(CloudFormationCustomResourceEvent::getPhysicalResourceId))
.returns("abcd", from(CloudFormationCustomResourceEvent::getServiceToken));
Map<String, Object> resourceProperties = event.getResourceProperties();
assertThat(resourceProperties).hasSize(2);
assertThat(resourceProperties.get("StackName")).isEqualTo("MyStack");
assertThat(resourceProperties.get("List")).isInstanceOf(List.class);
assertThat(resourceProperties.get("List")).asList().hasSize(3);
Map<String, Object> oldResourceProperties = event.getOldResourceProperties();
assertThat(oldResourceProperties).hasSize(2);
assertThat(oldResourceProperties.get("StackName")).isEqualTo("MyStack");
assertThat(oldResourceProperties.get("List")).isInstanceOf(List.class);
assertThat(oldResourceProperties.get("List")).asList().hasSize(1);
}
@Test
public void testLoadSecretsManagerRotationEvent() {
SecretsManagerRotationEvent event = EventLoader.loadSecretsManagerRotationEvent("secrets_rotation_event.json");
assertThat(event).isNotNull();
assertThat(event)
.returns("123e4567-e89b-12d3-a456-426614174000", from(SecretsManagerRotationEvent::getClientRequestToken))
.returns("arn:aws:secretsmanager:eu-central-1:123456789012:secret:/powertools/secretparam-xBPaJ5", from(SecretsManagerRotationEvent::getSecretId))
.returns("CreateSecret", from(SecretsManagerRotationEvent::getStep));
}
@Test
public void testLoadRabbitMQEvent() {
RabbitMQEvent event = EventLoader.loadRabbitMQEvent("rabbitmq_event.json");
assertThat(event).isNotNull();
assertThat(event)
.returns("aws:rmq", from(RabbitMQEvent::getEventSource))
.returns("arn:aws:mq:us-west-2:112556298976:broker:test:b-9bcfa592-423a-4942-879d-eb284b418fc8", from(RabbitMQEvent::getEventSourceArn));
Map<String, List<RabbitMQEvent.RabbitMessage>> messagesByQueue = event.getRmqMessagesByQueue();
assertThat(messagesByQueue).isNotEmpty();
List<RabbitMQEvent.RabbitMessage> messages = messagesByQueue.get("test::/");
assertThat(messages).hasSize(1);
RabbitMQEvent.RabbitMessage firstMessage = messages.get(0);
assertThat(firstMessage)
.returns(false, RabbitMQEvent.RabbitMessage::getRedelivered)
.returns("eyJ0aW1lb3V0IjowLCJkYXRhIjoiQ1pybWYwR3c4T3Y0YnFMUXhENEUifQ==", RabbitMQEvent.RabbitMessage::getData);
RabbitMQEvent.BasicProperties basicProperties = firstMessage.getBasicProperties();
assertThat(basicProperties)
.returns("text/plain", from(RabbitMQEvent.BasicProperties::getContentType))
.returns(1, from(RabbitMQEvent.BasicProperties::getDeliveryMode))
.returns(34, from(RabbitMQEvent.BasicProperties::getPriority))
.returns(60000, from(RabbitMQEvent.BasicProperties::getExpiration))
.returns("AIDACKCEVSQ6C2EXAMPLE", from(RabbitMQEvent.BasicProperties::getUserId))
.returns(80, from(RabbitMQEvent.BasicProperties::getBodySize))
.returns("Jan 1, 1970, 12:33:41 AM", from(RabbitMQEvent.BasicProperties::getTimestamp));
Map<String, Object> headers = basicProperties.getHeaders();
assertThat(headers).hasSize(3);
Map<String, List<Integer>> header1 = (Map<String, List<Integer>>) headers.get("header1");
assertThat(header1.get("bytes")).contains(118, 97, 108, 117, 101, 49);
assertThat((Integer) headers.get("numberInHeader")).isEqualTo(10);
}
}
| 1,609 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventArgumentsProvider.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.tests.annotations.Event;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.support.AnnotationConsumer;
import java.util.stream.Stream;
/**
* Used to process @{@link Event} com.amazonaws.services.lambda.runtime.tests.annotations
*/
public class EventArgumentsProvider implements ArgumentsProvider, AnnotationConsumer<Event> {
private Event event;
@Override
public Stream<? extends Arguments> provideArguments(ExtensionContext extensionContext) {
Object o = EventLoader.loadEvent(event.value(), event.type());
return Stream.of(Arguments.of(o));
}
@Override
public void accept(Event event) {
this.event = event;
}
}
| 1,610 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventLoader.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer;
import com.amazonaws.services.lambda.runtime.serialization.events.LambdaEventSerializers;
import java.io.*;
import com.amazonaws.services.lambda.runtime.events.*;
/**
* Load events from json files and serialize them in Events
*/
public class EventLoader {
public static ActiveMQEvent loadActiveMQEvent(String filename) {
return loadEvent(filename, ActiveMQEvent.class);
}
public static APIGatewayV2HTTPEvent loadApiGatewayHttpEvent(String filename) {
return loadEvent(filename, APIGatewayV2HTTPEvent.class);
}
public static APIGatewayProxyRequestEvent loadApiGatewayRestEvent(String filename) {
return loadEvent(filename, APIGatewayProxyRequestEvent.class);
}
public static APIGatewayCustomAuthorizerEvent loadAPIGatewayCustomAuthorizerEvent(String filename) {
return loadEvent(filename, APIGatewayCustomAuthorizerEvent.class);
}
public static APIGatewayV2CustomAuthorizerEvent loadAPIGatewayV2CustomAuthorizerEvent(String filename) {
return loadEvent(filename, APIGatewayV2CustomAuthorizerEvent.class);
}
public static ApplicationLoadBalancerRequestEvent loadApplicationLoadBalancerRequestEvent(String filename) {
return loadEvent(filename, ApplicationLoadBalancerRequestEvent.class);
}
public static CloudFormationCustomResourceEvent loadCloudFormationCustomResourceEvent(String filename) {
return loadEvent(filename, CloudFormationCustomResourceEvent.class);
}
public static CloudFrontEvent loadCloudFrontEvent(String filename) {
return loadEvent(filename, CloudFrontEvent.class);
}
public static CloudWatchLogsEvent loadCloudWatchLogsEvent(String filename) {
return loadEvent(filename, CloudWatchLogsEvent.class);
}
public static CodeCommitEvent loadCodeCommitEvent(String filename) {
return loadEvent(filename, CodeCommitEvent.class);
}
public static ConfigEvent loadConfigEvent(String filename) {
return loadEvent(filename, ConfigEvent.class);
}
public static ConnectEvent loadConnectEvent(String filename) {
return loadEvent(filename, ConnectEvent.class);
}
public static DynamodbEvent loadDynamoDbEvent(String filename) {
return loadEvent(filename, DynamodbEvent.class);
}
public static KafkaEvent loadKafkaEvent(String filename) {
return loadEvent(filename, KafkaEvent.class);
}
public static KinesisEvent loadKinesisEvent(String filename) {
return loadEvent(filename, KinesisEvent.class);
}
public static KinesisFirehoseEvent loadKinesisFirehoseEvent(String filename) {
return loadEvent(filename, KinesisFirehoseEvent.class);
}
public static LambdaDestinationEvent loadLambdaDestinationEvent(String filename) {
return loadEvent(filename, LambdaDestinationEvent.class);
}
public static LexEvent loadLexEvent(String filename) {
return loadEvent(filename, LexEvent.class);
}
public static S3Event loadS3Event(String filename) {
return loadEvent(filename, S3Event.class);
}
public static SecretsManagerRotationEvent loadSecretsManagerRotationEvent(String filename) {
return loadEvent(filename, SecretsManagerRotationEvent.class);
}
public static ScheduledEvent loadScheduledEvent(String filename) {
return loadEvent(filename, ScheduledEvent.class);
}
public static SNSEvent loadSNSEvent(String filename) {
return loadEvent(filename, SNSEvent.class);
}
public static SQSEvent loadSQSEvent(String filename) {
return loadEvent(filename, SQSEvent.class);
}
public static RabbitMQEvent loadRabbitMQEvent(String filename) {
return loadEvent(filename, RabbitMQEvent.class);
}
public static <T> T loadEvent(String filename, Class<T> targetClass) {
if (!filename.endsWith("json")) {
throw new IllegalArgumentException("File " + filename + " must have json extension");
}
PojoSerializer<T> serializer = LambdaEventSerializers.serializerFor(targetClass, ClassLoader.getSystemClassLoader());
InputStream stream = serializer.getClass().getResourceAsStream(filename);
if (stream == null) {
stream = serializer.getClass().getClassLoader().getResourceAsStream(filename);
}
if (stream == null) {
try {
stream = new FileInputStream(new File(filename));
} catch (FileNotFoundException e) {
throw new EventLoadingException("Cannot load " + filename, e);
}
}
try {
return serializer.fromJson(stream);
} finally {
try {
stream.close();
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
}
| 1,611 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/HandlerParamsArgumentsProvider.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.tests.annotations.*;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.support.AnnotationConsumer;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* Used to process @{@link HandlerParams} com.amazonaws.services.lambda.runtime.tests.annotations
*/
public class HandlerParamsArgumentsProvider implements ArgumentsProvider, AnnotationConsumer<HandlerParams> {
private Event event;
private Response response;
private Events events;
private Responses responses;
@Override
public void accept(HandlerParams handlerParams) {
this.event = handlerParams.event();
this.response = handlerParams.response();
this.events = handlerParams.events();
this.responses = handlerParams.responses();
}
@Override
public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
if ((!event.value().isEmpty() && response.value().isEmpty()) ||
(event.value().isEmpty() && !response.value().isEmpty())) {
throw new IllegalStateException("You must use either Event & Response (singular) or Events & Responses (plural) annotations together, you cannot mix them");
}
if (((ArrayUtils.isEmpty(events.events()) && StringUtils.isEmpty(events.folder()))
&& (StringUtils.isNotEmpty(responses.folder()) || ArrayUtils.isNotEmpty(responses.responses())))
||
((ArrayUtils.isEmpty(responses.responses()) && StringUtils.isEmpty(responses.folder()))
&& (StringUtils.isNotEmpty(events.folder()) || ArrayUtils.isNotEmpty(events.events())))) {
throw new IllegalStateException("You must use either Event & Response (singular) or Events & Responses (plural) annotations together, you cannot mix them");
}
// deal with one element
if (!event.value().isEmpty() && !response.value().isEmpty()) {
return Stream.of(
Arguments.of(
EventLoader.loadEvent(event.value(), event.type()),
EventLoader.loadEvent(response.value(), response.type())
)
);
}
// deal with many elements
List<Object> eventList = getEvents();
List<Object> responseList = getResponses();
if (eventList == null || eventList.size() == 0 || responseList == null || responseList.size() == 0 || eventList.size() != responseList.size()) {
throw new IllegalStateException("At least one event and one response should be provided, and you should have the exact same number of events and responses.");
}
Stream.Builder<Arguments> streamBuilder = Stream.builder();
for (int i = 0; i < eventList.size(); i++) {
streamBuilder.add(Arguments.of(eventList.get(i), responseList.get(i)));
}
return streamBuilder.build();
}
private List<Object> getResponses() throws IOException, URISyntaxException {
List<Object> responseList;
if (ArrayUtils.isNotEmpty(responses.responses())) {
responseList = Arrays.stream(responses.responses()).map(
response -> {
Class<?> clazz = response.type() == Void.class ? responses.type() : response.type();
return EventLoader.loadEvent(response.value(), clazz);
}
).collect(Collectors.toList());
} else {
Stream<Path> files = listFiles(responses.folder());
responseList = files
.filter(Files::isRegularFile)
.map(path -> EventLoader.loadEvent(path.toString(), responses.type()))
.collect(Collectors.toList());
}
return responseList;
}
private List<Object> getEvents() throws IOException, URISyntaxException {
List<Object> eventList;
if (ArrayUtils.isNotEmpty(events.events())) {
eventList = Arrays.stream(events.events()).map(
event -> {
Class<?> clazz = event.type() == Void.class ? events.type() : event.type();
return EventLoader.loadEvent(event.value(), clazz);
}
).collect(Collectors.toList());
} else {
Stream<Path> files = listFiles(events.folder());
eventList = files
.filter(Files::isRegularFile)
.map(path -> EventLoader.loadEvent(path.toString(), events.type()))
.collect(Collectors.toList());
}
return eventList;
}
private Stream<Path> listFiles(String folder) throws IOException, URISyntaxException {
URL folderUrl = getClass().getResource(folder);
if (folderUrl == null) {
folderUrl = getClass().getClassLoader().getResource(folder);
}
if (folderUrl == null) {
throw new IllegalArgumentException("Path " + folder + " cannot be found");
}
return Files.list(Paths.get(folderUrl.toURI())).sorted();
}
}
| 1,612 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventLoadingException.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
public class EventLoadingException extends RuntimeException {
private static final long serialVersionUID = 5766526909472206270L;
public EventLoadingException() {
}
public EventLoadingException(String message) {
super(message);
}
public EventLoadingException(String message, Throwable cause) {
super(message, cause);
}
}
| 1,613 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/EventsArgumentsProvider.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests;
import com.amazonaws.services.lambda.runtime.tests.annotations.Events;
import org.apache.commons.lang3.ArrayUtils;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.support.AnnotationConsumer;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.stream.Stream;
/**
* Used to process @{@link Events} com.amazonaws.services.lambda.runtime.tests.annotations
*/
public class EventsArgumentsProvider implements ArgumentsProvider, AnnotationConsumer<Events> {
private Events events;
@Override
public void accept(Events events) {
this.events = events;
}
@Override
public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
if (ArrayUtils.isNotEmpty(events.events())) {
return Arrays.stream(events.events())
.map(event -> {
Class<?> clazz = event.type() == Void.class ? events.type() : event.type();
return Arguments.of(EventLoader.loadEvent(event.value(), clazz));
});
} else {
URL folderUrl = getClass().getResource(events.folder());
if (folderUrl == null) {
folderUrl = getClass().getClassLoader().getResource(events.folder());
}
if (folderUrl == null) {
throw new IllegalArgumentException("Path " + events.folder() + " cannot be found");
}
Stream<Path> files = Files.list(Paths.get(folderUrl.toURI())).sorted();
return files
.filter(Files::isRegularFile)
.map(path -> Arguments.of(EventLoader.loadEvent(path.toString(), events.type())));
}
}
}
| 1,614 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/annotations/Response.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests.annotations;
import java.lang.annotation.*;
/**
* This annotation must be used in conjunction with {@link HandlerParams}.
*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Response {
/**
* Path and file name of the json response
* @return the file name (including the path)
*/
String value();
/**
* Type of the response
* @return the type of the response
*/
Class<?> type() default Void.class;
}
| 1,615 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/annotations/HandlerParams.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests.annotations;
import com.amazonaws.services.lambda.runtime.tests.HandlerParamsArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;
import java.lang.annotation.*;
/**
* This annotation must be used in conjunction with {@link org.junit.jupiter.params.ParameterizedTest}.<br/>
* It enables to inject Events and Responses into the current test.<br/>
* Either use the {@link #event()} and {@link #response()} for a single event/response
* or {@link #events()} and {@link #responses()} for multiple ones.<br/>
*
* Example:<br/>
* <pre>
* @ParameterizedTest
* @HandlerParams(
* event = @Event(value = "apigw/events/apigw_event.json", type = APIGatewayProxyRequestEvent.class),
* response = @Response(value = "apigw/responses/apigw_response.json", type = APIGatewayProxyResponseEvent.class))
* public void testSingleEventResponse(APIGatewayProxyRequestEvent event, APIGatewayProxyResponseEvent response) {
* }
*
* @ParameterizedTest
* @HandlerParams(
* events = @Events(folder = "apigw/events/", type = APIGatewayProxyRequestEvent.class),
* responses = @Responses(folder = "apigw/responses/", type = APIGatewayProxyResponseEvent.class))
* public void testMultipleEventsResponsesInFolder(APIGatewayProxyRequestEvent event, APIGatewayProxyResponseEvent response) {
* }
*
* @ParameterizedTest
* @HandlerParams(
* events = @Events(
* events = {
* @Event("apigw/events/apigw_event.json"),
* @Event("apigw/events/apigw_event2.json"),
* },
* type = APIGatewayProxyRequestEvent.class
* ),
* responses = @Responses(
* responses = {
* @Response("apigw/responses/apigw_response.json"),
* @Response("apigw/responses/apigw_response2.json")
* },
* type = APIGatewayProxyResponseEvent.class
* )
* )
* public void testMultipleEventsResponses(APIGatewayProxyRequestEvent event, APIGatewayProxyResponseEvent response) {
* }
* </pre>
*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@ArgumentsSource(HandlerParamsArgumentsProvider.class)
public @interface HandlerParams {
Event event() default @Event("");
Response response() default @Response("");
Events events() default @Events;
Responses responses() default @Responses;
}
| 1,616 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/annotations/Responses.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests.annotations;
import java.lang.annotation.*;
/**
* This annotation must be used in conjunction with {@link HandlerParams}.
*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Responses {
/**
* Folder where to find json files containing responses
* @return the folder name
*/
String folder() default "";
/**
* Type of the responses
* @return the type of the responses
*/
Class<?> type() default Void.class;
/**
* Mutually exclusive with folder
* @return the array of responses
*/
Response[] responses() default {};
}
| 1,617 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/annotations/Event.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests.annotations;
import com.amazonaws.services.lambda.runtime.tests.EventArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;
import java.lang.annotation.*;
/**
* This annotation must be used in conjunction with {@link org.junit.jupiter.params.ParameterizedTest}.<br/>
* It enables to inject an event (loaded from a json file) of the desired type into the current test.<br/>
* Example:<br/>
* <pre>
* @ParameterizedTest
* @Event(value = "sqs_event.json", type = SQSEvent.class)
* public void testInjectEvent(SQSEvent event) {
* assertThat(event).isNotNull();
* assertThat(event.getRecords()).hasSize(1);
* }
* </pre>
*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@ArgumentsSource(EventArgumentsProvider.class)
public @interface Event {
/**
* Path and file name of the json event
* @return the file name (including the path)
*/
String value();
/**
* Type of the event (for example, one of the <a href="https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events">aws-lambda-java-events</a>), or your own type
* @return the type of the event
*/
Class<?> type() default Void.class;
}
| 1,618 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests | Create_ds/aws-lambda-java-libs/aws-lambda-java-tests/src/main/java/com/amazonaws/services/lambda/runtime/tests/annotations/Events.java | /* Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.tests.annotations;
import com.amazonaws.services.lambda.runtime.tests.EventsArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;
import java.lang.annotation.*;
/**
* This annotation must be used in conjunction with {@link org.junit.jupiter.params.ParameterizedTest}.<br/>
* It enables to inject multiple events (loaded from json files) of the desired type into the current test.<br/>
* <p>
* Several notations are possible according to what you want to do:
* <ul>
* <li>
* Using the <code>folder</code> parameter is the more straightforward, and it will use all files in the folder<br/>
* <pre>
* @ParameterizedTest
* @Events(folder = "sqs", type = SQSEvent.class)
* public void testInjectEventsFromFolder(SQSEvent event) {
* assertThat(event).isNotNull();
* assertThat(event.getRecords()).hasSize(1);
* }
* </pre>
* </li>
* <li>
* Or you can list all the {@link Event}s<br/>
* <pre>
* @ParameterizedTest
* @Events(
* events = {
* @Event("sqs/sqs_event.json"),
* @Event("sqs/sqs_event2.json"),
* },
* type = SQSEvent.class
* )
* public void testInjectEvents(SQSEvent event) {
* assertThat(event).isNotNull();
* assertThat(event.getRecords()).hasSize(1);
* }
*
* @ParameterizedTest
* @Events(
* events = {
* @Event(value = "sqs/sqs_event.json", type = SQSEvent.class),
* @Event(value = "sqs/sqs_event2.json", type = SQSEvent.class),
* }
* )
* public void testInjectEvents2(SQSEvent event) {
* assertThat(event).isNotNull();
* assertThat(event.getRecords()).hasSize(1);
* }
* </pre>
* </li>
* </ul>
* </p>
*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@ArgumentsSource(EventsArgumentsProvider.class)
public @interface Events {
/**
* Folder where to find json files containing events
* @return the folder name
*/
String folder() default "";
/**
* Type of the events (for example, one of the <a href="https://github.com/aws/aws-lambda-java-libs/tree/master/aws-lambda-java-events">aws-lambda-java-events</a>), or your own type
* @return the type of the events
*/
Class<?> type() default Void.class;
/**
* Mutually exclusive with folder
* @return the array of events
*/
Event[] events() default {};
}
| 1,619 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-log4j2/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-log4j2/src/main/java/com/amazonaws/services/lambda/runtime/log4j2/LambdaAppender.java | package com.amazonaws.services.lambda.runtime.log4j2;
import com.amazonaws.services.lambda.runtime.LambdaRuntime;
import com.amazonaws.services.lambda.runtime.LambdaRuntimeInternal;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.appender.AbstractAppender;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory;
import org.apache.logging.log4j.core.config.plugins.PluginElement;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
/**
* Class to append log4j2 logs from AWS Lambda function to CloudWatch
* Created by adsuresh on 6/9/17.
*/
@Plugin(name = LambdaAppender.PLUGIN_NAME, category = LambdaAppender.PLUGIN_CATEGORY,
elementType = LambdaAppender.PLUGIN_TYPE, printObject = true)
public class LambdaAppender extends AbstractAppender {
static {
LambdaRuntimeInternal.setUseLog4jAppender(true);
}
public static final String PLUGIN_NAME = "Lambda";
public static final String PLUGIN_CATEGORY = "Core";
public static final String PLUGIN_TYPE = "appender";
private LambdaLogger logger = LambdaRuntime.getLogger();
private static LogFormat logFormat = LogFormat.TEXT;
private static final Map<Level, LogLevel> logLevelMapper = new HashMap<Level, LogLevel>() {{
put(Level.TRACE, LogLevel.TRACE);
put(Level.DEBUG, LogLevel.DEBUG);
put(Level.INFO, LogLevel.INFO);
put(Level.WARN, LogLevel.WARN);
put(Level.ERROR, LogLevel.ERROR);
put(Level.FATAL, LogLevel.FATAL);
}};
/**
* Builder class that follows log4j2 plugin convention
* @param <B> Generic Builder class
*/
public static class Builder<B extends Builder<B>> extends AbstractAppender.Builder<B>
implements org.apache.logging.log4j.core.util.Builder<LambdaAppender> {
@PluginAttribute(value = "format", defaultString = "TEXT")
LogFormat logFormat;
@PluginElement("LambdaTextFormat")
private LambdaTextFormat lambdaTextFormat;
@PluginElement("LambdaJsonFormat")
private LambdaJsonFormat lambdaJsonFormat;
/**
* creates a new LambdaAppender
* @return a new LambdaAppender
*/
public LambdaAppender build() {
Layout<?> layout;
if (logFormat == LogFormat.TEXT) {
layout = lambdaTextFormat != null ? lambdaTextFormat.getLayout() : super.getOrCreateLayout();
} else {
layout = lambdaJsonFormat != null ? lambdaJsonFormat.getLayout() : super.getOrCreateLayout();
}
return new LambdaAppender(super.getName(), super.getFilter(), layout, super.isIgnoreExceptions());
}
}
/**
* Method used by log4j2 to access this appender
* @param <B> Generic Builder class
* @return LambdaAppender Builder
*/
@PluginBuilderFactory
public static <B extends Builder<B>> B newBuilder() {
return new Builder<B>().asBuilder();
}
/**
* Constructor method following AbstractAppender convention
* @param name name of appender
* @param filter filter specified in xml
* @param layout layout specified in xml
* @param ignoreExceptions whether to show exceptions or not specified in xml
*/
private LambdaAppender(String name, Filter filter, Layout<? extends Serializable> layout, boolean ignoreExceptions) {
super(name, filter, layout, ignoreExceptions);
}
/**
* Converts log4j Level into Lambda LogLevel
* @param level the log4j log level
* @return Lambda log leve
*/
private LogLevel toLambdaLogLevel(Level level) {
return logLevelMapper.getOrDefault(level, LogLevel.UNDEFINED);
}
/**
* Append log event to System.out
* @param event log4j event
*/
public void append(LogEvent event) {
logger.log(getLayout().toByteArray(event), toLambdaLogLevel(event.getLevel()));
}
}
| 1,620 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-log4j2/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-log4j2/src/main/java/com/amazonaws/services/lambda/runtime/log4j2/LambdaJsonFormat.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.log4j2;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginElement;
import org.apache.logging.log4j.core.config.plugins.PluginFactory;
import java.io.Serializable;
@Plugin(name = "LambdaJsonFormat", category = "core", printObject = true)
public class LambdaJsonFormat {
private Layout layout;
@PluginFactory
public static LambdaJsonFormat createNode(@PluginElement("Layout") Layout<? extends Serializable> layout) {
return new LambdaJsonFormat(layout);
}
private LambdaJsonFormat(Layout layout) {
this.layout = layout;
}
public Layout getLayout() {
return layout;
}
}
| 1,621 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-log4j2/src/main/java/com/amazonaws/services/lambda/runtime | Create_ds/aws-lambda-java-libs/aws-lambda-java-log4j2/src/main/java/com/amazonaws/services/lambda/runtime/log4j2/LambdaTextFormat.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.log4j2;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginElement;
import org.apache.logging.log4j.core.config.plugins.PluginFactory;
import java.io.Serializable;
@Plugin(name = "LambdaTextFormat", category = "core", printObject = true)
public class LambdaTextFormat {
private Layout layout;
@PluginFactory
public static LambdaTextFormat createNode(@PluginElement("Layout") Layout<? extends Serializable> layout) {
return new LambdaTextFormat(layout);
}
private LambdaTextFormat(Layout layout) {
this.layout = layout;
}
public Layout getLayout() {
return layout;
}
}
| 1,622 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/test/integration/test-handler/src/main/java | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/test/integration/test-handler/src/main/java/helloworld/App.java | package helloworld;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import java.util.Map;
/**
* Handler for requests to Lambda function.
*/
public class App implements RequestHandler<Map<String,String>, String>{
@Override
public String handleRequest(Map<String,String> event, Context context)
{
String response = new String("success");
return response;
}
}
| 1,623 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/test/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/test/lambda/handlers/RequestStreamHandlerImpl.java | package test.lambda.handlers;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestStreamHandler;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
@SuppressWarnings("unused")
public class RequestStreamHandlerImpl implements RequestStreamHandler {
@Override
public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException {
output.write("\"success\"".getBytes());
}
}
| 1,624 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/test/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/test/lambda/handlers/POJOHanlderImpl.java | package test.lambda.handlers;
import com.amazonaws.services.lambda.runtime.Context;
@SuppressWarnings("unused")
public class POJOHanlderImpl {
@SuppressWarnings("unused")
public String noParamsHandler() {
return "success";
}
@SuppressWarnings("unused")
public String oneParamHandler_event(String event) {
return "success";
}
@SuppressWarnings("unused")
public String oneParamHandler_context(Context context) {
return "success";
}
@SuppressWarnings("unused")
public String twoParamsHandler(String event, Context context) {
return "success";
}
}
| 1,625 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/test/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/test/lambda/handlers/RequestHandlerImpl.java | package test.lambda.handlers;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class RequestHandlerImpl implements RequestHandler<String, String> {
@Override
public String handleRequest(String event, Context context) {
return "success";
}
}
| 1,626 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/testpkg/StackTraceHelper.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package testpkg;
import com.amazonaws.services.lambda.crac.CheckpointException;
/**
* A helper class for throwing exception which is not in the com.amazonaws.services.lambda.runtime.api.client package
* to avoid the stack traces from being filtered out.
*
*/
public class StackTraceHelper {
/**
* Throws a RuntimeException directly with msg as the message.
*/
public static void throwRuntimeException(String msg){
throw new RuntimeException(msg);
}
/**
* Calls another method which throws a RuntimeException with msg as the message.
*/
public static void callThenThrowRuntimeException(String msg){
throwRuntimeException(msg);
}
public static void throwCheckpointExceptionWithTwoSuppressedExceptions(String msg1, String msg2) throws CheckpointException {
CheckpointException e1 = new CheckpointException();
e1.addSuppressed(new RuntimeException(msg1));
e1.addSuppressed(new RuntimeException(msg2));
throw e1;
}
}
| 1,627 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/crac/ContextImplTest.java | /*
* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
package com.amazonaws.services.lambda.crac;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import org.mockito.InOrder;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.doThrow;
public class ContextImplTest {
private Resource throwsWithSuppressedException, noop, noop2, throwsException, throwCustomException;
@BeforeEach
public void setup() throws Exception {
throwsWithSuppressedException = Mockito.mock(Resource.class);
CheckpointException checkpointException = new CheckpointException();
checkpointException.addSuppressed(new NumberFormatException());
RestoreException restoreException = new RestoreException();
restoreException.addSuppressed(new NumberFormatException());
doThrow(checkpointException).when(throwsWithSuppressedException).beforeCheckpoint(ArgumentMatchers.any());
doThrow(restoreException).when(throwsWithSuppressedException).afterRestore(ArgumentMatchers.any());
noop = Mockito.mock(Resource.class);
Mockito.doNothing().when(noop).beforeCheckpoint(ArgumentMatchers.any());
Mockito.doNothing().when(noop).afterRestore(ArgumentMatchers.any());
noop2 = Mockito.mock(Resource.class);
Mockito.doNothing().when(noop2).beforeCheckpoint(ArgumentMatchers.any());
Mockito.doNothing().when(noop2).afterRestore(ArgumentMatchers.any());
throwsException = Mockito.mock(Resource.class);
doThrow(CheckpointException.class).when(throwsException).beforeCheckpoint(ArgumentMatchers.any());
doThrow(RestoreException.class).when(throwsException).afterRestore(ArgumentMatchers.any());
throwCustomException = Mockito.mock(Resource.class);
doThrow(IndexOutOfBoundsException.class).when(throwCustomException).beforeCheckpoint(ArgumentMatchers.any());
doThrow(UnsupportedOperationException.class).when(throwCustomException).afterRestore(ArgumentMatchers.any());
Core.resetGlobalContext();
}
static class StatefulResource implements Resource {
int state = 0;
@Override
public void afterRestore(Context<? extends Resource> context) {
state += 1;
}
@Override
public void beforeCheckpoint(Context<? extends Resource> context) {
state += 2;
}
int getValue() {
return state;
}
}
static int GLOBAL_STATE;
static class ChangeGlobalStateResource implements Resource {
ChangeGlobalStateResource() {
GLOBAL_STATE = 0;
}
@Override
public void afterRestore(Context<? extends Resource> context) {
GLOBAL_STATE += 1;
}
@Override
public void beforeCheckpoint(Context<? extends Resource> context) {
GLOBAL_STATE += 2;
}
}
/**
* Happy path test with real / not mocked resource
*/
@Test
public void verifyHooksWereExecuted() throws CheckpointException, RestoreException {
StatefulResource resource = new StatefulResource();
Core.getGlobalContext().register(resource);
Core.getGlobalContext().beforeCheckpoint(null);
Core.getGlobalContext().afterRestore(null);
assertEquals(3, resource.getValue());
}
/**
* This test is to validate GC intervention
*/
@Test
public void verifyHooksWereExecutedWithGC() throws CheckpointException, RestoreException {
StatefulResource resource = new StatefulResource();
Core.getGlobalContext().register(resource);
gcAndSleep();
Core.getGlobalContext().beforeCheckpoint(null);
Core.getGlobalContext().afterRestore(null);
assertEquals(3, resource.getValue());
}
@Test
public void verifyHooksAreNotExecutedForGarbageCollectedResources() throws CheckpointException, RestoreException {
Core.getGlobalContext().register(new ChangeGlobalStateResource());
gcAndSleep();
Core.getGlobalContext().beforeCheckpoint(null);
Core.getGlobalContext().afterRestore(null);
assertEquals(0, GLOBAL_STATE);
}
private static void gcAndSleep() {
for (int i = 0; i < 10; i++) {
System.gc();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println("thread was interrupted");
throw new RuntimeException(e);
}
}
@Test
public void Should_NotifyResourcesInReverseOrderOfRegistration_When_CheckpointNotification() throws Exception {
// Given
InOrder checkpointNotificationOrder = Mockito.inOrder(noop, noop2);
Core.getGlobalContext().register(noop);
Core.getGlobalContext().register(noop2);
// When
Core.getGlobalContext().beforeCheckpoint(null);
// Then
checkpointNotificationOrder.verify(noop2).beforeCheckpoint(ArgumentMatchers.any());
checkpointNotificationOrder.verify(noop).beforeCheckpoint(ArgumentMatchers.any());
}
@Test
public void Should_NotifyResourcesInOrderOfRegistration_When_RestoreNotification() throws Exception {
// Given
InOrder restoreNotificationOrder = Mockito.inOrder(noop, noop2);
Core.getGlobalContext().register(noop);
Core.getGlobalContext().register(noop2);
// When
Core.getGlobalContext().afterRestore(null);
// Then
restoreNotificationOrder.verify(noop).afterRestore(ArgumentMatchers.any());
restoreNotificationOrder.verify(noop2).afterRestore(ArgumentMatchers.any());
}
@Test
public void Should_ResourcesAreAlwaysNotified_When_AnyNotificationThrowsException() throws Exception {
// Given
Core.getGlobalContext().register(throwsWithSuppressedException);
Core.getGlobalContext().register(noop);
Core.getGlobalContext().register(noop2);
Core.getGlobalContext().register(throwsException);
Core.getGlobalContext().register(throwCustomException);
// When
try {
Core.getGlobalContext().beforeCheckpoint(null);
} catch (Exception ignored) {
}
try {
Core.getGlobalContext().afterRestore(null);
} catch (Exception ignored) {
}
// Then
Mockito.verify(throwsWithSuppressedException, Mockito.times(1)).beforeCheckpoint(ArgumentMatchers.any());
Mockito.verify(noop, Mockito.times(1)).beforeCheckpoint(ArgumentMatchers.any());
Mockito.verify(noop2, Mockito.times(1)).beforeCheckpoint(ArgumentMatchers.any());
Mockito.verify(throwsException, Mockito.times(1)).beforeCheckpoint(ArgumentMatchers.any());
Mockito.verify(throwCustomException, Mockito.times(1)).beforeCheckpoint(ArgumentMatchers.any());
Mockito.verify(throwsWithSuppressedException, Mockito.times(1)).afterRestore(ArgumentMatchers.any());
Mockito.verify(noop, Mockito.times(1)).afterRestore(ArgumentMatchers.any());
Mockito.verify(noop2, Mockito.times(1)).afterRestore(ArgumentMatchers.any());
Mockito.verify(throwsException, Mockito.times(1)).afterRestore(ArgumentMatchers.any());
Mockito.verify(throwCustomException, Mockito.times(1)).afterRestore(ArgumentMatchers.any());
}
@Test
public void Should_CatchAndSuppressAnyExceptionsAsCheckpointException_When_CheckpointNotification() {
// Given
Core.getGlobalContext().register(throwsWithSuppressedException);
Core.getGlobalContext().register(throwCustomException);
// When
try {
Core.getGlobalContext().beforeCheckpoint(null);
} catch (CheckpointException e1) {
// Then
assertEquals(2, e1.getSuppressed().length);
} catch (Throwable e2) {
fail("All exceptions thrown during checkpoint notification should be reported as CheckpointException");
}
}
@Test
public void Should_CatchAndSuppressAnyExceptionsAsRestoreException_When_RestoreNotification() {
// Given
Core.getGlobalContext().register(throwsWithSuppressedException);
Core.getGlobalContext().register(throwCustomException);
// When
try {
Core.getGlobalContext().afterRestore(null);
} catch (RestoreException e1) {
// Then
assertEquals(2, e1.getSuppressed().length);
} catch (Exception e2) {
fail("All exceptions thrown during restore notification should be reported as RestoreException");
}
}
@Test
public void Should_SuppressOriginalCheckpointExceptionUnderAnotherCheckpointException_When_ResourceIsAContext() throws Exception {
// Given
Context<Resource> c0 = Mockito.mock(Context.class);
doThrow(CheckpointException.class).when(c0).beforeCheckpoint(ArgumentMatchers.any());
Core.getGlobalContext().register(c0);
// When
try {
Core.getGlobalContext().beforeCheckpoint(null);
} catch (CheckpointException e1) {
// Then
assertEquals(1, e1.getSuppressed().length);
assertTrue(e1.getSuppressed()[0] instanceof CheckpointException,
"When the Resource is a Context and it throws CheckpointException it should be suppressed under another CheckpointException");
} catch (Exception e2) {
fail("All exceptions thrown during checkpoint notification should be reported as CheckpointException");
}
}
@Test
public void Should_SuppressOriginalRestoreExceptionUnderAnotherRestoreException_When_ResourceIsAContext() throws Exception {
// Given
Context<Resource> c0 = Mockito.mock(Context.class);
doThrow(RestoreException.class).when(c0).afterRestore(ArgumentMatchers.any());
Core.getGlobalContext().register(c0);
// When
try {
Core.getGlobalContext().afterRestore(null);
} catch (RestoreException e1) {
// Then
assertEquals(1, e1.getSuppressed().length);
assertTrue(e1.getSuppressed()[0] instanceof RestoreException,
"When the Resource is a Context and it throws RestoreException it should be suppressed under another RestoreException");
} catch (Exception e2) {
fail("All exceptions thrown during restore notification should be reported as RestoreException");
}
}
@Test
public void Should_NotifyOnlyOnce_When_ResourceRegistersMultipleTimes() throws Exception {
// Given
Core.getGlobalContext().register(noop);
Core.getGlobalContext().register(noop);
// When
Core.getGlobalContext().beforeCheckpoint(null);
Core.getGlobalContext().afterRestore(null);
// Then
Mockito.verify(noop, Mockito.times(1)).beforeCheckpoint(ArgumentMatchers.any());
Mockito.verify(noop, Mockito.times(1)).afterRestore(ArgumentMatchers.any());
}
}
| 1,628 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/XRayErrorCauseTest.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static testpkg.StackTraceHelper.callThenThrowRuntimeException;
public class XRayErrorCauseTest {
private static final String TEST_WORKING_DIR = "/tmp";
private static final String ORIGINAL_WORKING_DIR = System.getProperty("user.dir");
@BeforeEach
public void before() {
System.setProperty("user.dir", TEST_WORKING_DIR);
}
@AfterEach
public void after() {
System.setProperty("user.dir", ORIGINAL_WORKING_DIR);
}
@Test
public void xrayErrorCauseTest() {
try {
callThenThrowRuntimeException("woops");
} catch (Throwable t) {
UserFault.filterStackTrace(t);
assertXrayErrorCause(t);
}
}
@Test
public void xrayErrorCauseTestNoFileName() {
try {
callThenThrowRuntimeException("woops");
} catch (Throwable t) {
UserFault.filterStackTrace(t);
clearStackTraceElementsFilename(t);
assertXrayErrorCause(t);
}
}
private void assertXrayErrorCause(Throwable t) {
XRayErrorCause xRayErrorCause = new XRayErrorCause(t);
assertEquals(TEST_WORKING_DIR, xRayErrorCause.getWorking_directory());
assertEquals(1, xRayErrorCause.getPaths().size());
assertTrue(xRayErrorCause.getPaths().contains("StackTraceHelper.java"));
assertEquals(1, xRayErrorCause.getExceptions().size());
XRayErrorCause.XRayException xRayException = xRayErrorCause.getExceptions().iterator().next();
assertEquals("woops", xRayException.getMessage());
assertEquals("java.lang.RuntimeException", xRayException.getType());
assertEquals("throwRuntimeException", xRayException.getStack().get(0).getLabel());
assertEquals("StackTraceHelper.java", xRayException.getStack().get(0).getPath());
assertTrue(xRayException.getStack().get(0).getLine() > 0);
assertEquals("callThenThrowRuntimeException", xRayException.getStack().get(1).getLabel());
assertEquals("StackTraceHelper.java", xRayException.getStack().get(1).getPath());
assertTrue(xRayException.getStack().get(0).getLine() > 0);
}
private void clearStackTraceElementsFilename(Throwable t) {
StackTraceElement[] stackTrace = t.getStackTrace();
StackTraceElement[] updatedStackTrace = new StackTraceElement[stackTrace.length];
for(int i = 0; i < updatedStackTrace.length; i++) {
StackTraceElement curr = stackTrace[i];
updatedStackTrace[i] = new StackTraceElement(curr.getClassName(), curr.getMethodName(), null, curr.getLineNumber());
}
t.setStackTrace(updatedStackTrace);
}
}
| 1,629 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/UserFaultTest.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
import static testpkg.StackTraceHelper.callThenThrowRuntimeException;
import static testpkg.StackTraceHelper.throwCheckpointExceptionWithTwoSuppressedExceptions;
import static testpkg.StackTraceHelper.throwRuntimeException;
public class UserFaultTest {
@Test
public void testReportableErrorNoTraces() {
UserFault userFault = UserFault.makeUserFault(new RuntimeException("woops"));
String actual = userFault.reportableError();
String expected = "woops: java.lang.RuntimeException\n" +
"java.lang.RuntimeException: woops\n\n";
assertEquals(expected, actual);
}
@Test
public void testReportableErrorSingleTrace() {
try {
throwRuntimeException("woops");
} catch (RuntimeException e) {
UserFault userFault = UserFault.makeUserFault(e);
String actual = userFault.reportableError();
String expected = "woops: java.lang.RuntimeException\n" +
"java.lang.RuntimeException: woops\n" +
"\tat testpkg.StackTraceHelper.throwRuntimeException\\(StackTraceHelper.java:\\d+\\)\n\n";
assertTrue(actual.matches(expected), String.format("'%s' did not match '%s'", actual, expected));
return;
}
fail("Exception should have been thrown and caught");
}
@Test
public void testReportableErrorMultipleTraces() {
try {
callThenThrowRuntimeException("woops");
} catch (RuntimeException e) {
UserFault userFault = UserFault.makeUserFault(e);
String actual = userFault.reportableError();
String expected = "woops: java.lang.RuntimeException\n" +
"java.lang.RuntimeException: woops\n" +
"\tat testpkg.StackTraceHelper.throwRuntimeException\\(StackTraceHelper.java:\\d+\\)\n" +
"\tat testpkg.StackTraceHelper.callThenThrowRuntimeException\\(StackTraceHelper.java:\\d+\\)\n\n";
assertTrue(actual.matches(expected), String.format("'%s' did not match '%s'", actual, expected));
return;
}
fail("Exception should have been thrown and caught");
}
@Test
public void testReportableErrorOnlyMessage() {
String msg = "No public method named handleRequest with appropriate method signature found on class example.Function";
UserFault userFault = UserFault.makeUserFault(msg);
String expected = msg + '\n';
String actual = userFault.reportableError();
assertEquals(expected, actual);
}
@Test
public void testSuppressedExceptionsAreIncluded() {
try{
throwCheckpointExceptionWithTwoSuppressedExceptions("error 1", "error 2");
} catch(Exception e1) {
UserFault userFault = UserFault.makeUserFault(e1);
String reportableUserFault = userFault.reportableError();
assertTrue(reportableUserFault.contains("com.amazonaws.services.lambda.crac.CheckpointException"), "CheckpointException missing in reported UserFault");
assertTrue(reportableUserFault.contains("Suppressed: java.lang.RuntimeException: error 1"), "Suppressed error 1 missing in reported UserFault");
assertTrue(reportableUserFault.contains("Suppressed: java.lang.RuntimeException: error 2"), "Suppressed error 2 missing in reported UserFault");
}
}
}
| 1,630 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/CustomerClassLoaderTest.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.DisabledOnOs;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import static org.junit.jupiter.api.condition.OS.MAC;
public class CustomerClassLoaderTest {
final static String[] EXAMPLE_FUNCTION = new String[]{
"var/runtime/lib/LambdaJavaRTEntry-1.0.jar",
"user/path/Hello.class",
"user/path/example/Hello.class",
"user/path/hidden.jar",
"user/path/lib/b.jar",
"user/path/lib/z.jar",
"user/path/lib/A.jar",
"user/path/lib/4.jar",
"user/path/lib/λ.jar",
"user/path/lib/a.jar",
"user/path/lib/hidden/c.jar"
};
final static String[] EXAMPLE_FUNCTION_AND_LAYERS = new String[]{
"var/runtime/lib/LambdaJavaRTEntry-1.0.jar",
"user/path/Hello.class",
"user/path/example/Hello.class",
"user/path/hidden.jar",
"user/path/lib/a.jar",
"user/path/lib/b.jar",
"user/path/lib/hidden/c.jar",
"opt/hidden.jar",
"opt/java/hidden.jar",
"opt/java/lib/b.jar",
"opt/java/lib/c.jar",
"opt/java/lib/a-2.0.jar",
"opt/java/lib/a-1.0.jar",
"opt/java/lib/a-1.12.jar",
"opt/java/lib/a-1.21.jar",
"user/path/lib/hidden/d.jar"
};
/**
* Generate a fake file-system with the provided list of paths
*/
private Path fakeFileSystem(String[] paths) throws IOException {
Path dir = Files.createTempDirectory("rtentry");
for (String path : paths) {
Path stub = dir.resolve(path);
Files.createDirectories(stub.getParent());
Files.write(stub, "fake-data".getBytes());
}
return dir;
}
/**
* Strip the base URL from list
*/
private List<String> strip(String base, URL[] urls) {
return Arrays.stream(urls)
.map(URL::toExternalForm)
.filter(s -> s.startsWith(base))
.map(s -> s.substring(base.length()))
.collect(Collectors.toList());
}
@Test
@DisabledOnOs(MAC) // test fails on systems with case-insensitive volumes
public void customerClassLoaderFunction() throws IOException {
try {
Path rootDir = fakeFileSystem(EXAMPLE_FUNCTION);
URLClassLoader customerClassLoader = new CustomerClassLoader(
rootDir.resolve("user/path").toString(),
rootDir.resolve("opt/java").toString(),
ClassLoader.getSystemClassLoader());
List<String> res = strip("file:" + rootDir.toString(), customerClassLoader.getURLs());
Assertions.assertEquals(Arrays.asList(
"/user/path/",
"/user/path/lib/4.jar",
"/user/path/lib/A.jar",
"/user/path/lib/a.jar",
"/user/path/lib/b.jar",
"/user/path/lib/z.jar",
"/user/path/lib/λ.jar"),
res);
} catch(Throwable t) {
// this system property is the name of the charset used when encoding/decoding file paths
// exception is expected if it is not set to a UTF variant or not set at all
String systemEncoding = System.getProperty("sun.jnu.encoding");
if (systemEncoding != null && !systemEncoding.toLowerCase().contains("utf")){
Assertions.assertTrue(t.getMessage().contains("Malformed input or input contains unmappable characters"));
}
else {
throw t;
}
}
}
@Test
@DisabledOnOs(MAC) // test fails on systems with case-insensitive volumes
public void customerClassLoaderLayer() throws IOException {
Path rootDir = fakeFileSystem(EXAMPLE_FUNCTION_AND_LAYERS);
URLClassLoader customerClassLoader = new CustomerClassLoader(
rootDir.resolve("user/path").toString(),
rootDir.resolve("opt/java").toString(),
ClassLoader.getSystemClassLoader());
List<String> res = strip("file:" + rootDir.toString(), customerClassLoader.getURLs());
// Layer order is fixed (unicode value)
Assertions.assertEquals(Arrays.asList(
"/user/path/",
"/user/path/lib/a.jar",
"/user/path/lib/b.jar",
"/opt/java/lib/a-1.0.jar",
"/opt/java/lib/a-1.12.jar",
"/opt/java/lib/a-1.21.jar",
"/opt/java/lib/a-2.0.jar",
"/opt/java/lib/b.jar",
"/opt/java/lib/c.jar"
), res);
}
}
| 1,631 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/FailureTest.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import org.junit.jupiter.api.Test;
import java.io.IOError;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class FailureTest {
static class MySecretException extends ClassNotFoundException {}
@Test
public void doesNotReportCustomException() {
Throwable throwable = new MySecretException();
assertEquals(ClassNotFoundException.class, Failure.getReportableExceptionClass(throwable));
MySecretException mySecretException = new MySecretException();
assertEquals(ClassNotFoundException.class, Failure.getReportableExceptionClass(mySecretException));
}
@Test
public void correctlyReportsExceptionsWeTrack() {
Throwable ioError = new IOError(new Throwable());
assertEquals(IOError.class, Failure.getReportableExceptionClass(ioError));
Throwable error = new Error(new Throwable());
assertEquals(Error.class, Failure.getReportableExceptionClass(error));
ClassNotFoundException classNotFoundException = new ClassNotFoundException();
assertEquals(ClassNotFoundException.class, Failure.getReportableExceptionClass(classNotFoundException));
VirtualMachineError virtualMachineError = new OutOfMemoryError();
assertEquals(VirtualMachineError.class, Failure.getReportableExceptionClass(virtualMachineError));
Throwable linkageError = new LinkageError();
assertEquals(LinkageError.class, Failure.getReportableExceptionClass(linkageError));
Throwable exceptionInInitializerError = new ExceptionInInitializerError();
assertEquals(ExceptionInInitializerError.class, Failure.getReportableExceptionClass(exceptionInInitializerError));
Throwable noClassDefFoundError = new NoClassDefFoundError();
assertEquals(NoClassDefFoundError.class, Failure.getReportableExceptionClass(noClassDefFoundError));
Throwable invalidHandlerException = new HandlerInfo.InvalidHandlerException();
assertEquals(HandlerInfo.InvalidHandlerException.class, Failure.getReportableExceptionClass(invalidHandlerException));
Throwable throwable = new Throwable();
assertEquals(Throwable.class, Failure.getReportableExceptionClass(throwable));
}
@Test
public void verifyCorrectClassName() {
Throwable ioError = new IOError(new Throwable());
assertEquals("java.io.IOError", Failure.getReportableExceptionClassName(ioError));
Throwable error = new Error(new Throwable());
assertEquals("java.lang.Error", Failure.getReportableExceptionClassName(error));
ClassNotFoundException classNotFoundException = new ClassNotFoundException();
assertEquals("java.lang.ClassNotFoundException", Failure.getReportableExceptionClassName(classNotFoundException));
}
}
| 1,632 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoaderTest.java | package com.amazonaws.services.lambda.runtime.api.client;
import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.InvocationRequest;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import static org.junit.jupiter.api.Assertions.assertEquals;
class EventHandlerLoaderTest {
@Test
void RequestHandlerTest() throws Exception {
String handler = "test.lambda.handlers.RequestHandlerImpl";
LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandler(handler);
assertSuccessfulInvocation(lambdaRequestHandler);
}
@Test
void RequestStreamHandlerTest() throws Exception {
String handler = "test.lambda.handlers.RequestStreamHandlerImpl";
LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandler(handler);
assertSuccessfulInvocation(lambdaRequestHandler);
}
@Test
void PojoHandlerTest_noParams() throws Exception {
String handler = "test.lambda.handlers.POJOHanlderImpl::noParamsHandler";
LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandler(handler);
assertSuccessfulInvocation(lambdaRequestHandler);
}
@Test
void PojoHandlerTest_oneParamEvent() throws Exception {
String handler = "test.lambda.handlers.POJOHanlderImpl::oneParamHandler_event";
LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandler(handler);
assertSuccessfulInvocation(lambdaRequestHandler);
}
@Test
void PojoHandlerTest_oneParamContext() throws Exception {
String handler = "test.lambda.handlers.POJOHanlderImpl::oneParamHandler_context";
LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandler(handler);
assertSuccessfulInvocation(lambdaRequestHandler);
}
@Test
void PojoHandlerTest_twoParams() throws Exception {
String handler = "test.lambda.handlers.POJOHanlderImpl::twoParamsHandler";
LambdaRequestHandler lambdaRequestHandler = getLambdaRequestHandler(handler);
assertSuccessfulInvocation(lambdaRequestHandler);
}
private LambdaRequestHandler getLambdaRequestHandler(String handler) throws ClassNotFoundException {
ClassLoader cl = this.getClass().getClassLoader();
HandlerInfo handlerInfo = HandlerInfo.fromString(handler, cl);
return EventHandlerLoader.loadEventHandler(handlerInfo);
}
private static void assertSuccessfulInvocation(LambdaRequestHandler lambdaRequestHandler) throws Exception {
InvocationRequest invocationRequest = getTestInvocationRequest();
ByteArrayOutputStream resultBytes = lambdaRequestHandler.call(invocationRequest);
String result = resultBytes.toString();
assertEquals("\"success\"", result);
}
private static InvocationRequest getTestInvocationRequest() {
InvocationRequest invocationRequest = new InvocationRequest();
invocationRequest.setContent("\"Hello\"".getBytes());
invocationRequest.setId("id");
invocationRequest.setXrayTraceId("traceId");
return invocationRequest;
}
} | 1,633 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/api/LambdaContextTest.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.api;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class LambdaContextTest {
private static final String REQUEST_ID = "request-id";
private static final String LOG_GROUP_NAME = "log-group-name";
private static final String LOG_STREAM_NAME = "log-stream-name";
private static final String FUNCTION_NAME = "function-name";
private static final LambdaCognitoIdentity IDENTITY = new LambdaCognitoIdentity("identity-id", "pool-id");
private static final String FUNCTION_VERSION = "function-version";
private static final String INVOKED_FUNCTION_ARN = "invoked-function-arn";
private static final LambdaClientContext CLIENT_CONTEXT = new LambdaClientContext();
public static final int MEMORY_LIMIT = 128;
@Test
public void getRemainingTimeInMillis() {
long now = System.currentTimeMillis();
LambdaContext ctx = createContextWithDeadline(now + 1000);
int actual = ctx.getRemainingTimeInMillis();
assertTrue(actual > 0);
assertTrue(actual <= 1000);
}
@Test
public void getRemainingTimeInMillis_Sleep() throws InterruptedException {
long now = System.currentTimeMillis();
LambdaContext ctx = createContextWithDeadline(now + 1000);
int before = ctx.getRemainingTimeInMillis();
Thread.sleep(100);
int after = ctx.getRemainingTimeInMillis();
assertTrue((before - after) >= 100);
}
@Test
public void getRemainingTimeInMillis_Deadline() throws InterruptedException {
long now = System.currentTimeMillis();
LambdaContext ctx = createContextWithDeadline(now + 100);
Thread.sleep(110);
assertEquals(0, ctx.getRemainingTimeInMillis());
}
private LambdaContext createContextWithDeadline(long deadlineTimeInMs) {
return new LambdaContext(MEMORY_LIMIT, deadlineTimeInMs, REQUEST_ID, LOG_GROUP_NAME, LOG_STREAM_NAME,
FUNCTION_NAME, IDENTITY, FUNCTION_VERSION, INVOKED_FUNCTION_ARN, CLIENT_CONTEXT);
}
}
| 1,634 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/TextLogFormatterTest.java | package com.amazonaws.services.lambda.runtime.api.client.logging;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
class TextLogFormatterTest {
@Test
void testFormattingStringWithLogLevel() {
assertFormatsString("test log", LogLevel.WARN, "[WARN] test log");
}
@Test
void testFormattingStringWithoutLogLevel() {
assertFormatsString("test log", LogLevel.UNDEFINED, "test log");
}
void assertFormatsString(String input, LogLevel logLevel, String expected) {
LogFormatter logFormatter = new TextLogFormatter();
String output = logFormatter.format(input, logLevel);
assertEquals(expected, output);
}
} | 1,635 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/FrameTypeTest.java | package com.amazonaws.services.lambda.runtime.api.client.logging;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
public class FrameTypeTest {
@Test
public void logFrames() {
assertHexEquals(
0xa55a0003,
FrameType.getValue(LogLevel.UNDEFINED, LogFormat.TEXT)
);
assertHexEquals(
0xa55a001b,
FrameType.getValue(LogLevel.FATAL, LogFormat.TEXT)
);
}
/**
* Helper function to make it easier to debug failing test.
*
* @param expected Expected value as int
* @param actual Actual value as int
*/
private void assertHexEquals(int expected, int actual) {
assertEquals(
Integer.toHexString(expected),
Integer.toHexString(actual)
);
}
}
| 1,636 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/FramedTelemetryLogSinkTest.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ReadableByteChannel;
import java.nio.file.Path;
import java.time.Instant;
import java.util.Arrays;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
public class FramedTelemetryLogSinkTest {
private static final int DEFAULT_BUFFER_SIZE = 256;
private static final byte ZERO_BYTE = (byte) 0;
private long timestamp() {
Instant instant = Instant.now();
return instant.getEpochSecond() * 1_000_000 + instant.getNano() / 1000;
}
@TempDir
public Path tmpFolder;
@Test
public void logSingleFrame() throws IOException {
byte[] message = "{\"message\": \"hello world\nsomething on a new line!\"}".getBytes();
LogLevel logLevel = LogLevel.ERROR;
LogFormat logFormat = LogFormat.JSON;
File tmpFile = tmpFolder.resolve("pipe").toFile();
FileOutputStream fos = new FileOutputStream(tmpFile);
FileDescriptor fd = fos.getFD();
long before = timestamp();
try (FramedTelemetryLogSink logSink = new FramedTelemetryLogSink(fd)) {
logSink.log(logLevel, logFormat, message);
}
long after = timestamp();
ByteBuffer buf = ByteBuffer.allocate(DEFAULT_BUFFER_SIZE);
ReadableByteChannel readChannel = new FileInputStream(tmpFile).getChannel();
readChannel.read(buf);
// reset the position to the start
buf.position(0);
// first 4 bytes indicate the type
int type = buf.getInt();
assertEquals(FrameType.getValue(logLevel, logFormat), type);
// next 4 bytes indicate the length of the message
int len = buf.getInt();
assertEquals(message.length, len);
// next 8 bytes should indicate the timestamp
long timestamp = buf.getLong();
assertTrue(before <= timestamp);
assertTrue(timestamp <= after);
// use `len` to allocate a byte array to read the logged message into
byte[] actual = new byte[len];
buf.get(actual);
assertArrayEquals(message, actual);
// rest of buffer should be empty
while (buf.hasRemaining())
assertEquals(ZERO_BYTE, buf.get());
}
@Test
public void logMultipleFrames() throws IOException {
byte[] firstMessage = "hello world\nsomething on a new line!".getBytes();
byte[] secondMessage = "hello again\nhere's another message\n".getBytes();
LogLevel logLevel = LogLevel.ERROR;
LogFormat logFormat = LogFormat.TEXT;
File tmpFile = tmpFolder.resolve("pipe").toFile();
FileOutputStream fos = new FileOutputStream(tmpFile);
FileDescriptor fd = fos.getFD();
long before = timestamp();
try (FramedTelemetryLogSink logSink = new FramedTelemetryLogSink(fd)) {
logSink.log(logLevel, logFormat, firstMessage);
logSink.log(logLevel, logFormat, secondMessage);
}
long after = timestamp();
ByteBuffer buf = ByteBuffer.allocate(DEFAULT_BUFFER_SIZE);
ReadableByteChannel readChannel = new FileInputStream(tmpFile).getChannel();
readChannel.read(buf);
// reset the position to the start
buf.position(0);
for (byte[] message : Arrays.asList(firstMessage, secondMessage)) {
// first 4 bytes indicate the type
int type = buf.getInt();
assertEquals(FrameType.getValue(logLevel, logFormat), type);
// next 4 bytes indicate the length of the message
int len = buf.getInt();
assertEquals(message.length, len);
// next 8 bytes should indicate the timestamp
long timestamp = buf.getLong();
assertTrue(before <= timestamp);
assertTrue(timestamp <= after);
// use `len` to allocate a byte array to read the logged message into
byte[] actual = new byte[len];
buf.get(actual);
assertArrayEquals(message, actual);
}
// rest of buffer should be empty
while (buf.hasRemaining())
assertEquals(ZERO_BYTE, buf.get());
}
/**
* The implementation of FramedTelemetryLogSink was based on java.nio.channels.WritableByteChannel which would
* throw ClosedByInterruptException if Thread.currentThread.interrupt() was called. The implementation was changed
* and this test ensures that logging works even if the current thread was interrupted.
* <p>
* https://t.corp.amazon.com/0304370986/
*/
@Test
public void interruptedThread() throws IOException {
try {
byte[] message = "hello world\nsomething on a new line!\n".getBytes();
File tmpFile = tmpFolder.resolve("pipe").toFile();
FileOutputStream fos = new FileOutputStream(tmpFile);
FileDescriptor fd = fos.getFD();
try (FramedTelemetryLogSink logSink = new FramedTelemetryLogSink(fd)) {
Thread.currentThread().interrupt();
logSink.log(LogLevel.ERROR, LogFormat.TEXT, message);
}
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
FileInputStream logInputStream = new FileInputStream(tmpFile);
int readBytes = logInputStream.read(buffer);
int headerSizeBytes = 16; // message type (4 bytes) + len (4 bytes) + timestamp (8 bytes)
int expectedBytes = headerSizeBytes + message.length;
assertEquals(expectedBytes, readBytes);
for (int i = 0; i < message.length; i++) {
assertEquals(message[i], buffer[i + headerSizeBytes]);
}
} finally {
// clear interrupted status of the current thread
assertTrue(Thread.interrupted());
}
}
}
| 1,637 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/JsonLogFormatterTest.java | package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer;
import com.amazonaws.services.lambda.runtime.serialization.factories.GsonFactory;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
public class JsonLogFormatterTest {
@Test
void testFormattingWithoutLambdaContext() {
assertFormatsString("test log", LogLevel.WARN, null);
}
@Test
void testFormattingWithLambdaContext() {
LambdaContext context = new LambdaContext(
0,
0,
"request-id",
null,
null,
"function-name",
null,
null,
"function-arn",
null
);
assertFormatsString("test log", LogLevel.WARN, context);
}
void assertFormatsString(String message, LogLevel logLevel, LambdaContext context) {
JsonLogFormatter logFormatter = new JsonLogFormatter();
if (context != null) {
logFormatter.setLambdaContext(context);
}
String output = logFormatter.format(message, logLevel);
PojoSerializer<StructuredLogMessage> serializer = GsonFactory.getInstance().getSerializer(StructuredLogMessage.class);
assert_expected_log_message(serializer.fromJson(output), message, logLevel, context);
}
void assert_expected_log_message(StructuredLogMessage result, String message, LogLevel logLevel, LambdaContext context) {
assertEquals(message, result.message);
assertEquals(logLevel, result.level);
assertNotNull(result.timestamp);
if (context != null) {
assertEquals(context.getAwsRequestId(), result.AWSRequestId);
}
}
}
| 1,638 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/StdOutLogSinkTest.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
public class StdOutLogSinkTest {
private final PrintStream originalOutPrintStream = System.out;
private final ByteArrayOutputStream bos = new ByteArrayOutputStream();
private final PrintStream capturedOutPrintStream = new PrintStream(bos);
@BeforeEach
public void setup() {
bos.reset();
}
@Test
public void testSingleLog() {
System.setOut(capturedOutPrintStream);
try {
try (StdOutLogSink logSink = new StdOutLogSink()) {
logSink.log("hello\nworld".getBytes());
}
} finally {
System.setOut(originalOutPrintStream);
}
assertEquals("hello\nworld", bos.toString());
}
@Test
public void testSingleLogWithLogLevel() {
System.setOut(capturedOutPrintStream);
try {
try (StdOutLogSink logSink = new StdOutLogSink()) {
logSink.log(LogLevel.ERROR, LogFormat.TEXT, "hello\nworld".getBytes());
}
} finally {
System.setOut(originalOutPrintStream);
}
assertEquals("hello\nworld", bos.toString());
}
@Test
public void testContextLoggerWithStdoutLogSink_logBytes() {
System.setOut(capturedOutPrintStream);
try {
try (StdOutLogSink logSink = new StdOutLogSink()) {
logSink.log("hello\nworld".getBytes());
logSink.log("hello again".getBytes());
}
} finally {
System.setOut(originalOutPrintStream);
}
assertEquals("hello\nworldhello again", bos.toString());
}
}
| 1,639 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/test/java/com/amazonaws/services/lambda/runtime/api/client/logging/AbstractLambdaLoggerTest.java | package com.amazonaws.services.lambda.runtime.api.client.logging;
import static org.junit.jupiter.api.Assertions.assertEquals;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
import org.junit.jupiter.api.Test;
import java.util.LinkedList;
import java.util.List;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
public class AbstractLambdaLoggerTest {
class TestSink implements LogSink {
private List<byte[]> messages = new LinkedList<>();
public TestSink() {
}
@Override
public void log(byte[] message) {
messages.add(message);
}
@Override
public void log(LogLevel logLevel, LogFormat logFormat, byte[] message) {
messages.add(message);
}
@Override
public void close() {
}
List<byte[]> getMessages() {
return messages;
}
}
private void logMessages(LambdaLogger logger) {
logger.log("trace", LogLevel.TRACE);
logger.log("debug", LogLevel.DEBUG);
logger.log("info", LogLevel.INFO);
logger.log("warn", LogLevel.WARN);
logger.log("error", LogLevel.ERROR);
logger.log("fatal", LogLevel.FATAL);
}
@Test
public void testLoggingNullValuesWithoutLogLevelInText() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.INFO, LogFormat.TEXT);
String isNullString = null;
byte[] isNullBytes = null;
logger.log(isNullString);
logger.log(isNullBytes);
assertEquals("null", new String(sink.getMessages().get(0)));
assertEquals("null", new String(sink.getMessages().get(1)));
}
@Test
public void testLoggingNullValuesWithoutLogLevelInJSON() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.INFO, LogFormat.JSON);
String isNullString = null;
byte[] isNullBytes = null;
logger.log(isNullString);
logger.log(isNullBytes);
assertEquals(2, sink.getMessages().size());
}
@Test
public void testLoggingNullValuesWithLogLevelInText() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.INFO, LogFormat.TEXT);
String isNullString = null;
byte[] isNullBytes = null;
logger.log(isNullString, LogLevel.ERROR);
logger.log(isNullBytes, LogLevel.ERROR);
assertEquals("[ERROR] null", new String(sink.getMessages().get(0)));
assertEquals("null", new String(sink.getMessages().get(1)));
}
@Test
public void testLoggingNullValuesWithLogLevelInJSON() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.INFO, LogFormat.JSON);
String isNullString = null;
byte[] isNullBytes = null;
logger.log(isNullString, LogLevel.ERROR);
logger.log(isNullBytes, LogLevel.ERROR);
assertEquals(2, sink.getMessages().size());
}
@Test
public void testWithoutFiltering() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.UNDEFINED, LogFormat.TEXT);
logMessages(logger);
assertEquals(6, sink.getMessages().size());
}
@Test
public void testWithFiltering() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.WARN, LogFormat.TEXT);
logMessages(logger);
assertEquals(3, sink.getMessages().size());
}
@Test
public void testUndefinedLogLevelWithFiltering() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.WARN, LogFormat.TEXT);
logger.log("undefined");
assertEquals(1, sink.getMessages().size());
}
@Test
public void testFormattingLogMessages() {
TestSink sink = new TestSink();
LambdaLogger logger = new LambdaContextLogger(sink, LogLevel.INFO, LogFormat.TEXT);
logger.log("test message", LogLevel.INFO);
assertEquals(1, sink.getMessages().size());
assertEquals("[INFO] test message", new String(sink.getMessages().get(0)));
}
}
| 1,640 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/crac/ContextImpl.java | /*
* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
package com.amazonaws.services.lambda.crac;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.stream.Collectors;
/**
* Spec reference: https://crac.github.io/openjdk-builds/javadoc/api/java.base/jdk/crac/package-summary.html
*/
public class ContextImpl extends Context<Resource> {
private volatile long order = -1L;
private final WeakHashMap<Resource, Long> checkpointQueue = new WeakHashMap<>();
@Override
public synchronized void beforeCheckpoint(Context<? extends Resource> context) throws CheckpointException {
List<Throwable> exceptionsThrown = new ArrayList<>();
for (Resource resource : getCheckpointQueueReverseOrderOfRegistration()) {
try {
resource.beforeCheckpoint(this);
} catch (CheckpointException e) {
Collections.addAll(exceptionsThrown, e.getSuppressed());
} catch (Exception e) {
exceptionsThrown.add(e);
}
}
if (!exceptionsThrown.isEmpty()) {
CheckpointException checkpointException = new CheckpointException();
for (Throwable t : exceptionsThrown) {
checkpointException.addSuppressed(t);
}
throw checkpointException;
}
}
@Override
public synchronized void afterRestore(Context<? extends Resource> context) throws RestoreException {
List<Throwable> exceptionsThrown = new ArrayList<>();
for (Resource resource : getCheckpointQueueForwardOrderOfRegistration()) {
try {
resource.afterRestore(this);
} catch (RestoreException e) {
Collections.addAll(exceptionsThrown, e.getSuppressed());
} catch (Exception e) {
exceptionsThrown.add(e);
}
}
if (!exceptionsThrown.isEmpty()) {
RestoreException restoreException = new RestoreException();
for (Throwable t : exceptionsThrown) {
restoreException.addSuppressed(t);
}
throw restoreException;
}
}
@Override
public synchronized void register(Resource resource) {
checkpointQueue.put(resource, ++order);
}
private List<Resource> getCheckpointQueueReverseOrderOfRegistration() {
return checkpointQueue.entrySet()
.stream()
.sorted((r1, r2) -> (int) (r2.getValue() - r1.getValue()))
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}
private List<Resource> getCheckpointQueueForwardOrderOfRegistration() {
return checkpointQueue.entrySet()
.stream()
.sorted((r1, r2) -> (int) (r1.getValue() - r2.getValue()))
.map(Map.Entry::getKey)
.collect(Collectors.toList());
}
}
| 1,641 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/crac/CheckpointException.java | /*
* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
package com.amazonaws.services.lambda.crac;
public class CheckpointException extends Exception {
private static final long serialVersionUID = -4956873658083157585L;
public CheckpointException() {
super();
}
}
| 1,642 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/crac/Context.java | /*
* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
package com.amazonaws.services.lambda.crac;
public abstract class Context<R extends Resource> implements Resource {
protected Context() {
}
@Override
public abstract void beforeCheckpoint(Context<? extends Resource> context)
throws CheckpointException;
@Override
public abstract void afterRestore(Context<? extends Resource> context)
throws RestoreException;
public abstract void register(R resource);
}
| 1,643 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/crac/Resource.java | /*
* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
package com.amazonaws.services.lambda.crac;
public interface Resource {
void afterRestore(Context<? extends Resource> context) throws Exception;
void beforeCheckpoint(Context<? extends Resource> context) throws Exception;
}
| 1,644 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/crac/Core.java | /*
* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
package com.amazonaws.services.lambda.crac;
/**
* Provides the global context for registering resources.
*/
public final class Core {
private Core() {
}
private static Context<Resource> globalContext = new ContextImpl();
public static Context<Resource> getGlobalContext() {
return globalContext;
}
public static void checkpointRestore() {
throw new UnsupportedOperationException();
}
static void resetGlobalContext() {
globalContext = new ContextImpl();
}
}
| 1,645 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/crac/RestoreException.java | /*
* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
package com.amazonaws.services.lambda.crac;
public class RestoreException extends Exception {
private static final long serialVersionUID = -823900409868237860L;
public RestoreException() {
super();
}
}
| 1,646 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/Failure.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import java.io.IOError;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class Failure {
private static final Class[] reportableExceptionsArray = {
Error.class,
ClassNotFoundException.class,
IOError.class,
Throwable.class,
VirtualMachineError.class,
LinkageError.class,
ExceptionInInitializerError.class,
NoClassDefFoundError.class,
HandlerInfo.InvalidHandlerException.class
};
private static final List<Class> sortedExceptions = Collections.unmodifiableList(
Arrays.stream(reportableExceptionsArray).sorted(new ClassHierarchyComparator()).collect(Collectors.toList()));
private final String errorMessage;
private final String errorType;
private final String[] stackTrace;
private final Failure cause;
public Failure(Throwable t) {
this.errorMessage = t.getLocalizedMessage() == null ? t.getClass().getName() : t.getLocalizedMessage();
this.errorType = t.getClass().getName();
StackTraceElement[] trace = t.getStackTrace();
this.stackTrace = new String[trace.length];
for (int i = 0; i < trace.length; i++) {
this.stackTrace[i] = trace[i].toString();
}
Throwable cause = t.getCause();
this.cause = (cause == null) ? null : new Failure(cause);
}
public Failure(UserFault userFault) {
this.errorMessage = userFault.msg;
this.errorType = userFault.exception;
// Not setting stacktrace for compatibility with legacy/native runtime
this.stackTrace = null;
this.cause = null;
}
public static Class getReportableExceptionClass(Throwable customerException) {
return sortedExceptions
.stream()
.filter(e -> e.isAssignableFrom(customerException.getClass()))
.findFirst()
.orElse(Throwable.class);
}
public static String getReportableExceptionClassName(Throwable f) {
return getReportableExceptionClass(f).getName();
}
public static boolean isInvokeFailureFatal(Throwable t) {
return t instanceof VirtualMachineError || t instanceof IOError;
}
private static class ClassHierarchyComparator implements Comparator<Class> {
@Override
public int compare(Class o1, Class o2) {
if (o1.isAssignableFrom(o2)) {
return 1;
} else {
return -1;
}
}
}
public String getErrorType() {
return errorType;
}
public String getErrorMessage() {
return errorMessage;
}
}
| 1,647 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/ReservedRuntimeEnvironmentVariables.java | /*
* Copyright 2017-2020 original authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.amazonaws.services.lambda.runtime.api.client;
/**
* Lambda runtimes set several environment variables during initialization.
* Most of the environment variables provide information about the function or runtime.
* The keys for these environment variables are reserved and cannot be set in your function configuration.
*
* @see <a href="https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime">Using AWS Lambda Environment Variables</a>
* <p>
* NOTICE: This class is forked from io.micronaut.function.aws.runtime.ReservedRuntimeEnvironments found at https://github.com/micronaut-projects/micronaut-aws
*/
public interface ReservedRuntimeEnvironmentVariables {
/**
* The handler location configured on the function.
*/
String HANDLER = "_HANDLER";
/**
* The AWS Region where the Lambda function is executed.
*/
String AWS_REGION = "AWS_REGION";
/**
* The runtime identifier, prefixed by AWS_Lambda_—for example, AWS_Lambda_java8.
*/
String AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV";
/**
* The name of the function.
*/
String AWS_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
/**
* The amount of memory available to the function in MB.
*/
String AWS_LAMBDA_FUNCTION_MEMORY_SIZE = "AWS_LAMBDA_FUNCTION_MEMORY_SIZE";
/**
* The version of the function being executed.
*/
String AWS_LAMBDA_FUNCTION_VERSION = "AWS_LAMBDA_FUNCTION_VERSION";
/**
* The name of the Amazon CloudWatch Logs group for the function.
*/
String AWS_LAMBDA_LOG_GROUP_NAME = "AWS_LAMBDA_LOG_GROUP_NAME";
/**
* The name of the Amazon CloudWatch stream for the function.
*/
String AWS_LAMBDA_LOG_STREAM_NAME = "AWS_LAMBDA_LOG_STREAM_NAME";
/**
* The logging level set for the function.
*/
String AWS_LAMBDA_LOG_LEVEL = "AWS_LAMBDA_LOG_LEVEL";
/**
* The logging format set for the function.
*/
String AWS_LAMBDA_LOG_FORMAT = "AWS_LAMBDA_LOG_FORMAT";
/**
* Access key id obtained from the function's execution role.
*/
String AWS_ACCESS_KEY_ID = "AWS_ACCESS_KEY_ID";
/**
* secret access key obtained from the function's execution role.
*/
String AWS_SECRET_ACCESS_KEY = "AWS_SECRET_ACCESS_KEY";
/**
* The access keys obtained from the function's execution role.
*/
String AWS_SESSION_TOKEN = "AWS_SESSION_TOKEN";
/**
* (Custom runtime) The host and port of the runtime API.
*/
String AWS_LAMBDA_RUNTIME_API = "AWS_LAMBDA_RUNTIME_API";
/**
* Initialization type
*/
String AWS_LAMBDA_INITIALIZATION_TYPE = "AWS_LAMBDA_INITIALIZATION_TYPE";
/**
* The path to your Lambda function code.
*/
String LAMBDA_TASK_ROOT = "LAMBDA_TASK_ROOT";
/**
* The path to runtime libraries.
*/
String LAMBDA_RUNTIME_DIR = "LAMBDA_RUNTIME_DIR";
/**
* The environment's time zone (UTC). The execution environment uses NTP to synchronize the system clock.
*/
String TZ = "TZ";
}
| 1,648 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/AWSLambda.java | //
// AWSLambda.java
//
// Copyright (c) 2013 Amazon. All rights reserved.
//
package com.amazonaws.services.lambda.runtime.api.client;
import com.amazonaws.services.lambda.crac.Core;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.api.client.LambdaRequestHandler.UserFaultHandler;
import com.amazonaws.services.lambda.runtime.api.client.logging.FramedTelemetryLogSink;
import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
import com.amazonaws.services.lambda.runtime.api.client.logging.LogSink;
import com.amazonaws.services.lambda.runtime.api.client.logging.StdOutLogSink;
import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.InvocationRequest;
import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.LambdaRuntimeClient;
import com.amazonaws.services.lambda.runtime.api.client.util.LambdaOutputStream;
import com.amazonaws.services.lambda.runtime.api.client.util.UnsafeUtil;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer;
import com.amazonaws.services.lambda.runtime.serialization.factories.GsonFactory;
import com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory;
import com.amazonaws.services.lambda.runtime.serialization.util.ReflectUtil;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.reflect.Constructor;
import java.net.URLClassLoader;
import java.security.Security;
import java.util.Properties;
/**
* The entrypoint of this class is {@link AWSLambda#startRuntime}. It performs two main tasks:
*
* <p>
* 1. loads the user's handler.
* <br/>
* 2. enters the Lambda runtime loop which handles function invocations as defined in the Lambda Custom Runtime API.
*
* <p>
* Once initialized, {@link AWSLambda#startRuntime} will halt only if an irrecoverable error occurs.
*/
public class AWSLambda {
private static final String TRUST_STORE_PROPERTY = "javax.net.ssl.trustStore";
private static final String JAVA_SECURITY_PROPERTIES = "java.security.properties";
private static final String NETWORKADDRESS_CACHE_NEGATIVE_TTL_ENV_VAR = "AWS_LAMBDA_JAVA_NETWORKADDRESS_CACHE_NEGATIVE_TTL";
private static final String NETWORKADDRESS_CACHE_NEGATIVE_TTL_PROPERTY = "networkaddress.cache.negative.ttl";
private static final String DEFAULT_NEGATIVE_CACHE_TTL = "1";
// System property for Lambda tracing, see aws-xray-sdk-java/LambdaSegmentContext
// https://github.com/aws/aws-xray-sdk-java/blob/2f467e50db61abb2ed2bd630efc21bddeabd64d9/aws-xray-recorder-sdk-core/src/main/java/com/amazonaws/xray/contexts/LambdaSegmentContext.java#L39-L40
private static final String LAMBDA_TRACE_HEADER_PROP = "com.amazonaws.xray.traceHeader";
private static final String INIT_TYPE_SNAP_START = "snap-start";
private static final String AWS_LAMBDA_INITIALIZATION_TYPE = System.getenv(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_INITIALIZATION_TYPE);
static {
// Override the disabledAlgorithms setting to match configuration for openjdk8-u181.
// This is to keep DES ciphers around while we deploying security updates.
Security.setProperty(
"jdk.tls.disabledAlgorithms",
"SSLv3, RC4, MD5withRSA, DH keySize < 1024, EC keySize < 224, DES40_CBC, RC4_40, 3DES_EDE_CBC"
);
// Override the location of the trusted certificate authorities to be provided by the system.
// The ca-certificates package provides /etc/pki/java/cacerts which becomes the symlink destination
// of $java_home/lib/security/cacerts when java is installed in the chroot. Given that java is provided
// in /var/lang as opposed to installed in the chroot, this brings it closer.
if (System.getProperty(TRUST_STORE_PROPERTY) == null) {
final File systemCacerts = new File("/etc/pki/java/cacerts");
if (systemCacerts.exists() && systemCacerts.isFile()) {
System.setProperty(TRUST_STORE_PROPERTY, systemCacerts.getPath());
}
}
if (isNegativeCacheOverridable()) {
String ttlFromEnv = System.getenv(NETWORKADDRESS_CACHE_NEGATIVE_TTL_ENV_VAR);
String negativeCacheTtl = ttlFromEnv == null ? DEFAULT_NEGATIVE_CACHE_TTL : ttlFromEnv;
Security.setProperty(NETWORKADDRESS_CACHE_NEGATIVE_TTL_PROPERTY, negativeCacheTtl);
}
}
private static boolean isNegativeCacheOverridable() {
String securityPropertiesPath = System.getProperty(JAVA_SECURITY_PROPERTIES);
if (securityPropertiesPath == null) {
return true;
}
try (FileInputStream inputStream = new FileInputStream(securityPropertiesPath)) {
Properties secProps = new Properties();
secProps.load(inputStream);
return !secProps.containsKey(NETWORKADDRESS_CACHE_NEGATIVE_TTL_PROPERTY);
} catch (IOException e) {
return true;
}
}
private static LambdaRequestHandler findRequestHandler(final String handlerString, ClassLoader customerClassLoader) {
final HandlerInfo handlerInfo;
try {
handlerInfo = HandlerInfo.fromString(handlerString, customerClassLoader);
} catch (HandlerInfo.InvalidHandlerException e) {
UserFault userFault = UserFault.makeUserFault("Invalid handler: `" + handlerString + "'");
return new UserFaultHandler(userFault);
} catch (ClassNotFoundException e) {
return LambdaRequestHandler.classNotFound(e, HandlerInfo.className(handlerString));
} catch (NoClassDefFoundError e) {
return LambdaRequestHandler.initErrorHandler(e, HandlerInfo.className(handlerString));
} catch (Throwable t) {
throw UserFault.makeInitErrorUserFault(t, HandlerInfo.className(handlerString));
}
final LambdaRequestHandler requestHandler = EventHandlerLoader.loadEventHandler(handlerInfo);
// if loading the handler failed and the failure is fatal (for e.g. the constructor threw an exception)
// we want to report this as an init error rather than deferring to the first invoke.
if (requestHandler instanceof UserFaultHandler) {
UserFault userFault = ((UserFaultHandler) requestHandler).fault;
if (userFault.fatal) {
throw userFault;
}
}
return requestHandler;
}
public static void setupRuntimeLogger(LambdaLogger lambdaLogger)
throws ClassNotFoundException {
ReflectUtil.setStaticField(
Class.forName("com.amazonaws.services.lambda.runtime.LambdaRuntime"),
"logger",
true,
lambdaLogger
);
}
public static String getEnvOrExit(String envVariableName) {
String value = System.getenv(envVariableName);
if (value == null) {
System.err.println("Could not get environment variable " + envVariableName);
System.exit(-1);
}
return value;
}
protected static URLClassLoader customerClassLoader;
/**
* convert an integer into a FileDescriptor object using reflection to access private members.
*/
private static FileDescriptor intToFd(int fd) throws RuntimeException {
try {
Class<FileDescriptor> clazz = FileDescriptor.class;
Constructor<FileDescriptor> c = clazz.getDeclaredConstructor(Integer.TYPE);
c.setAccessible(true);
return c.newInstance(fd);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static LogSink createLogSink() {
final String fdStr = System.getenv("_LAMBDA_TELEMETRY_LOG_FD");
if (fdStr == null) {
return new StdOutLogSink();
}
try {
int fdInt = Integer.parseInt(fdStr);
FileDescriptor fd = intToFd(fdInt);
return new FramedTelemetryLogSink(fd);
} catch (Exception e) {
return new StdOutLogSink();
}
}
public static void main(String[] args) {
startRuntime(args[0]);
}
private static void startRuntime(String handler) {
try (LogSink logSink = createLogSink()) {
LambdaLogger logger = new LambdaContextLogger(
logSink,
LogLevel.fromString(LambdaEnvironment.LAMBDA_LOG_LEVEL),
LogFormat.fromString(LambdaEnvironment.LAMBDA_LOG_FORMAT)
);
startRuntime(handler, logger);
} catch (Throwable t) {
throw new Error(t);
}
}
private static void startRuntime(String handler, LambdaLogger lambdaLogger) throws Throwable {
UnsafeUtil.disableIllegalAccessWarning();
System.setOut(new PrintStream(new LambdaOutputStream(System.out), false, "UTF-8"));
System.setErr(new PrintStream(new LambdaOutputStream(System.err), false, "UTF-8"));
setupRuntimeLogger(lambdaLogger);
String runtimeApi = getEnvOrExit(ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_RUNTIME_API);
LambdaRuntimeClient runtimeClient = new LambdaRuntimeClient(runtimeApi);
String taskRoot = System.getProperty("user.dir");
String libRoot = "/opt/java";
// Make system classloader the customer classloader's parent to ensure any aws-lambda-java-core classes
// are loaded from the system classloader.
customerClassLoader = new CustomerClassLoader(taskRoot, libRoot, ClassLoader.getSystemClassLoader());
Thread.currentThread().setContextClassLoader(customerClassLoader);
// Load the user's handler
LambdaRequestHandler requestHandler;
try {
requestHandler = findRequestHandler(handler, customerClassLoader);
} catch (UserFault userFault) {
lambdaLogger.log(userFault.reportableError());
reportInitError(new Failure(userFault), runtimeClient);
System.exit(1);
return;
}
if (INIT_TYPE_SNAP_START.equals(AWS_LAMBDA_INITIALIZATION_TYPE)) {
onInitComplete(runtimeClient, lambdaLogger);
}
boolean shouldExit = false;
while (!shouldExit) {
UserFault userFault = null;
InvocationRequest request = runtimeClient.waitForNextInvocation();
if (request.getXrayTraceId() != null) {
System.setProperty(LAMBDA_TRACE_HEADER_PROP, request.getXrayTraceId());
} else {
System.clearProperty(LAMBDA_TRACE_HEADER_PROP);
}
ByteArrayOutputStream payload;
try {
payload = requestHandler.call(request);
runtimeClient.postInvocationResponse(request.getId(), payload.toByteArray());
boolean ignored = Thread.interrupted(); // clear interrupted flag in case if it was set by user's code
} catch (UserFault f) {
userFault = f;
UserFault.filterStackTrace(f);
payload = new ByteArrayOutputStream(1024);
Failure failure = new Failure(f);
GsonFactory.getInstance().getSerializer(Failure.class).toJson(failure, payload);
shouldExit = f.fatal;
runtimeClient.postInvocationError(request.getId(), payload.toByteArray(), failure.getErrorType());
} catch (Throwable t) {
UserFault.filterStackTrace(t);
userFault = UserFault.makeUserFault(t);
payload = new ByteArrayOutputStream(1024);
Failure failure = new Failure(t);
GsonFactory.getInstance().getSerializer(Failure.class).toJson(failure, payload);
// These two categories of errors are considered fatal.
shouldExit = Failure.isInvokeFailureFatal(t);
runtimeClient.postInvocationError(request.getId(), payload.toByteArray(), failure.getErrorType(),
serializeAsXRayJson(t));
} finally {
if (userFault != null) {
lambdaLogger.log(userFault.reportableError());
}
}
}
}
static void onInitComplete(final LambdaRuntimeClient runtimeClient, final LambdaLogger lambdaLogger) throws IOException {
try {
Core.getGlobalContext().beforeCheckpoint(null);
// Blocking call to RAPID /restore/next API, will return after taking snapshot.
// This will also be the 'entrypoint' when resuming from snapshots.
runtimeClient.getRestoreNext();
} catch (Exception e1) {
logExceptionCloudWatch(lambdaLogger, e1);
reportInitError(new Failure(e1), runtimeClient);
System.exit(64);
}
try {
Core.getGlobalContext().afterRestore(null);
} catch (Exception restoreExc) {
logExceptionCloudWatch(lambdaLogger, restoreExc);
Failure errorPayload = new Failure(restoreExc);
reportRestoreError(errorPayload, runtimeClient);
System.exit(64);
}
}
private static void logExceptionCloudWatch(LambdaLogger lambdaLogger, Exception exc) {
UserFault.filterStackTrace(exc);
UserFault userFault = UserFault.makeUserFault(exc, true);
lambdaLogger.log(userFault.reportableError());
}
static void reportInitError(final Failure failure,
final LambdaRuntimeClient runtimeClient) throws IOException {
ByteArrayOutputStream payload = new ByteArrayOutputStream(1024);
JacksonFactory.getInstance().getSerializer(Failure.class).toJson(failure, payload);
runtimeClient.postInitError(payload.toByteArray(), failure.getErrorType());
}
static int reportRestoreError(final Failure failure,
final LambdaRuntimeClient runtimeClient) throws IOException {
ByteArrayOutputStream payload = new ByteArrayOutputStream(1024);
JacksonFactory.getInstance().getSerializer(Failure.class).toJson(failure, payload);
return runtimeClient.postRestoreError(payload.toByteArray(), failure.getErrorType());
}
private static PojoSerializer<XRayErrorCause> xRayErrorCauseSerializer;
/**
* @param throwable throwable to convert
* @return json as string expected by XRay's web console. On conversion failure, returns null.
*/
private static String serializeAsXRayJson(Throwable throwable) {
try {
final OutputStream outputStream = new ByteArrayOutputStream();
final XRayErrorCause cause = new XRayErrorCause(throwable);
if (xRayErrorCauseSerializer == null) {
xRayErrorCauseSerializer = JacksonFactory.getInstance().getSerializer(XRayErrorCause.class);
}
xRayErrorCauseSerializer.toJson(cause, outputStream);
return outputStream.toString();
} catch (Exception e) {
return null;
}
}
}
| 1,649 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/UserFault.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import java.io.PrintWriter;
import java.io.StringWriter;
public final class UserFault extends RuntimeException {
private static final long serialVersionUID = -479308856905162038L;
public final String msg;
public final String exception;
public final String trace;
public final Boolean fatal;
private static final String packagePrefix = AWSLambda.class.getPackage().getName();
public UserFault(String msg, String exception, String trace) {
this.msg = msg;
this.exception = exception;
this.trace = trace;
this.fatal = false;
}
public UserFault(String msg, String exception, String trace, Boolean fatal) {
this.msg = msg;
this.exception = exception;
this.trace = trace;
this.fatal = fatal;
}
/**
* Convenience function to report a fault given an exception. The constructed fault is marked non-fatal.
* No more user code should run after a fault.
*/
public static UserFault makeUserFault(Throwable t) {
return makeUserFault(t, false);
}
public static UserFault makeUserFault(Throwable t, boolean fatal) {
final String msg = t.getLocalizedMessage() == null ? t.getClass().getName() : t.getLocalizedMessage();
return new UserFault(msg, t.getClass().getName(), trace(t), fatal);
}
/**
* Convenience function to report a fault given a message.
* No more user code should run after a fault.
*/
public static UserFault makeUserFault(String msg) {
return new UserFault(msg, null, null);
}
/**
* Convert a throwable's stack trace to a String
*/
public static String trace(Throwable t) {
filterStackTrace(t);
StringWriter sw = new StringWriter();
t.printStackTrace(new PrintWriter(sw));
return sw.toString();
}
/**
* remove our runtime code from the stack trace recursively. Returns
* the same object for convenience.
*/
public static <T extends Throwable> T filterStackTrace(T t) {
StackTraceElement[] trace = t.getStackTrace();
for (int i = 0; i < trace.length; i++) {
if (trace[i].getClassName().startsWith(packagePrefix)) {
StackTraceElement[] newTrace = new StackTraceElement[i];
System.arraycopy(trace, 0, newTrace, 0, i);
t.setStackTrace(newTrace);
break;
}
}
Throwable cause = t.getCause();
if (cause != null) {
filterStackTrace(cause);
}
Throwable[] suppressedExceptions = t.getSuppressed();
for (Throwable suppressed : suppressedExceptions) {
filterStackTrace(suppressed);
}
return t;
}
static UserFault makeInitErrorUserFault(Throwable e, String className) {
return new UserFault(
"Error loading class " + className + (e.getMessage() == null ? "" : ": " + e.getMessage()),
e.getClass().getName(),
trace(e),
true
);
}
static UserFault makeClassNotFoundUserFault(Throwable e, String className) {
return new UserFault(
"Class not found: " + className,
e.getClass().getName(),
trace(e),
false
);
}
public String reportableError() {
if (this.exception != null || this.trace != null) {
return String.format("%s: %s\n%s\n",
this.msg,
this.exception == null ? "" : this.exception,
this.trace == null ? "" : this.trace);
}
return String.format("%s\n", this.msg);
}
}
| 1,650 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/LambdaRequestHandler.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.InvocationRequest;
import java.io.ByteArrayOutputStream;
public interface LambdaRequestHandler {
ByteArrayOutputStream call(InvocationRequest request) throws Error, Exception;
class UserFaultHandler implements LambdaRequestHandler {
public final UserFault fault;
public UserFaultHandler(UserFault fault) {
this.fault = fault;
}
public ByteArrayOutputStream call(InvocationRequest request) {
throw fault;
}
}
static LambdaRequestHandler initErrorHandler(final Throwable e, String className) {
return new UserFaultHandler(UserFault.makeInitErrorUserFault(e, className));
}
static LambdaRequestHandler classNotFound(final Throwable e, String className) {
return new UserFaultHandler(UserFault.makeClassNotFoundUserFault(e, className));
}
}
| 1,651 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/HandlerInfo.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
public final class HandlerInfo {
public static class InvalidHandlerException extends RuntimeException {
public static final long serialVersionUID = -1;
}
public final Class<?> clazz;
public final String methodName;
public HandlerInfo(Class<?> clazz, String methodName) {
this.clazz = clazz;
this.methodName = methodName;
}
public static HandlerInfo fromString(String handler, ClassLoader cl) throws ClassNotFoundException, NoClassDefFoundError, InvalidHandlerException {
final int colonLoc = handler.lastIndexOf("::");
final String className;
final String methodName;
if (colonLoc < 0) {
className = handler;
methodName = null;
} else {
className = handler.substring(0, colonLoc);
methodName = handler.substring(colonLoc + 2);
}
if (className.isEmpty() || (methodName != null && methodName.isEmpty())) {
throw new InvalidHandlerException();
}
return new HandlerInfo(Class.forName(className, true, cl), methodName);
}
public static String className(String handler) {
final int colonLoc = handler.lastIndexOf("::");
return (colonLoc < 0) ? handler : handler.substring(0, colonLoc);
}
}
| 1,652 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/XRayErrorCause.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
/**
* helper class for serializing an exception in the format expected by XRay's web console.
*/
public class XRayErrorCause {
private final String working_directory;
private final Collection<XRayException> exceptions;
private final Collection<String> paths;
public XRayErrorCause(Throwable throwable) {
working_directory = System.getProperty("user.dir");
exceptions = Collections.singletonList(new XRayException(throwable));
paths = Collections.unmodifiableCollection(
Arrays.stream(throwable.getStackTrace())
.map(XRayErrorCause::determineFileName)
.collect(Collectors.toSet()));
}
public String getWorking_directory() {
return working_directory;
}
public Collection<XRayException> getExceptions() {
return exceptions;
}
public Collection<String> getPaths() {
return paths;
}
/**
* This method provides compatibility between Java 8 and Java 11 in determining the fileName of the class in the
* StackTraceElement.
*
* If the fileName property of the StackTraceElement is null (as it can be for native methods in Java 11), it
* constructs it using the className by stripping out the package and appending ".java".
*/
private static String determineFileName(StackTraceElement e) {
String fileName = null;
if(e.getFileName() != null) {
fileName = e.getFileName();
}
if(fileName == null) {
String className = e.getClassName();
fileName = className == null ? null : className.substring(className.lastIndexOf('.') + 1) + ".java";
}
return fileName;
}
public static class XRayException {
private final String message;
private final String type;
private final List<StackElement> stack;
public XRayException(Throwable throwable) {
this.message = throwable.getMessage();
this.type = throwable.getClass().getName();
this.stack = Arrays.stream(throwable.getStackTrace()).map(this::toStackElement).collect(Collectors.toList());
}
private StackElement toStackElement(StackTraceElement e) {
return new StackElement(
e.getMethodName(),
determineFileName(e),
e.getLineNumber());
}
public String getMessage() {
return message;
}
public String getType() {
return type;
}
public List<StackElement> getStack() {
return stack;
}
public static class StackElement {
private final String label;
private final String path;
private final int line;
private StackElement(String label, String path, int line) {
this.label = label;
this.path = path;
this.line = line;
}
public String getLabel() {
return label;
}
public String getPath() {
return path;
}
public int getLine() {
return line;
}
}
}
}
| 1,653 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/TooManyServiceProvidersFoundException.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
public class TooManyServiceProvidersFoundException extends RuntimeException {
public TooManyServiceProvidersFoundException() {
}
public TooManyServiceProvidersFoundException(String errorMessage) {
super(errorMessage);
}
public TooManyServiceProvidersFoundException(Throwable cause) {
super(cause);
}
public TooManyServiceProvidersFoundException(String message, Throwable cause) {
super(message, cause);
}
} | 1,654 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/CustomerClassLoader.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
class CustomerClassLoader extends URLClassLoader {
/**
* This Comparator is used to ensure that jars added to this classloader are added in a deterministic order which
* does not depend on the underlying filesystem.
*/
private final static Comparator<String> LEXICAL_SORT_ORDER = Comparator.comparing(String::toString);
private final static FilenameFilter JAR_FILE_NAME_FILTER = new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
int offset = name.length() - 4;
if (offset <= 0) { /* must be at least A.jar */
return false;
} else {
return name.startsWith(".jar", offset);
}
}
};
CustomerClassLoader(String taskRoot, String optRoot, ClassLoader parent) throws IOException {
super(getUrls(taskRoot, optRoot), parent);
}
private static URL[] getUrls(String taskRoot, String optRoot) throws MalformedURLException {
File taskDir = new File(taskRoot + "/");
List<URL> res = new ArrayList<>();
res.add(newURL(taskDir, ""));
appendJars(new File(taskRoot + "/lib"), res);
appendJars(new File(optRoot + "/lib"), res);
return res.toArray(new URL[res.size()]);
}
private static void appendJars(File dir, List<URL> result) throws MalformedURLException {
if (!dir.isDirectory()) {
return;
}
String[] names = dir.list(CustomerClassLoader.JAR_FILE_NAME_FILTER);
if (names == null) {
return;
}
Arrays.sort(names, CustomerClassLoader.LEXICAL_SORT_ORDER);
for (String path : names) {
result.add(newURL(dir, path));
}
}
private static URL newURL(File parent, String path) throws MalformedURLException {
return new URL("file", null, -1, parent.getPath() + "/" + path);
}
}
| 1,655 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/ClasspathLoader.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
/**
* This class loads all of the classes that are in jars on the classpath.
* <p>
* It is used to generate a class list and Application CDS archive that includes all the possible classes that could be
* loaded by the runtime. This simplifies the process of generating the Application CDS archive.
*/
public class ClasspathLoader {
private static final Set<String> BLOCKLIST = new HashSet<>();
private static final ClassLoader SYSTEM_CLASS_LOADER = ClassLoader.getSystemClassLoader();
private static final int CLASS_SUFFIX_LEN = ".class".length();
static {
// Ignore module info class for serialization lib
BLOCKLIST.add("META-INF.versions.9.module-info");
}
private static String pathToClassName(final String path) {
return path.substring(0, path.length() - CLASS_SUFFIX_LEN).replaceAll("/|\\\\", "\\.");
}
private static void loadClass(String name) {
try {
Class.forName(name, true, SYSTEM_CLASS_LOADER);
} catch (ClassNotFoundException e) {
System.err.println("[WARN] Failed to load " + name + ": " + e.getMessage());
}
}
private static void loadClassesInJar(File file) throws IOException {
JarFile jar = new JarFile(file);
Enumeration<JarEntry> en = jar.entries();
while (en.hasMoreElements()) {
JarEntry entry = en.nextElement();
if (!entry.getName().endsWith(".class")) {
continue;
}
String name = pathToClassName(entry.getName());
if (BLOCKLIST.contains(name)) {
continue;
}
loadClass(name);
}
}
private static void loadClassesInClasspathEntry(String entry) throws IOException {
File file = new File(entry);
if (!file.exists()) {
throw new FileNotFoundException("Classpath entry does not exist: " + file.getPath());
}
if (file.isDirectory() || !file.getPath().endsWith(".jar")) {
System.err.println("[WARN] Only jar classpath entries are supported. Skipping " + file.getPath());
return;
}
loadClassesInJar(file);
}
private static void loadAllClasses() throws IOException {
final String classPath = System.getProperty("java.class.path");
if (classPath == null) {
return;
}
for (String classPathEntry : classPath.split(File.pathSeparator)) {
loadClassesInClasspathEntry(classPathEntry);
}
}
public static void main(String[] args) throws IOException {
loadAllClasses();
}
}
| 1,656 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/LambdaEnvironment.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import com.amazonaws.services.lambda.runtime.api.client.util.EnvReader;
import static com.amazonaws.services.lambda.runtime.api.client.ReservedRuntimeEnvironmentVariables.*;
import static java.lang.Integer.parseInt;
public class LambdaEnvironment {
public static final EnvReader ENV_READER = new EnvReader();
public static final int MEMORY_LIMIT = parseInt(ENV_READER.getEnvOrDefault(AWS_LAMBDA_FUNCTION_MEMORY_SIZE, "128"));
public static final String LOG_GROUP_NAME = ENV_READER.getEnv(AWS_LAMBDA_LOG_GROUP_NAME);
public static final String LOG_STREAM_NAME = ENV_READER.getEnv(AWS_LAMBDA_LOG_STREAM_NAME);
public static final String LAMBDA_LOG_LEVEL = ENV_READER.getEnvOrDefault(AWS_LAMBDA_LOG_LEVEL, "UNDEFINED");
public static final String LAMBDA_LOG_FORMAT = ENV_READER.getEnvOrDefault(AWS_LAMBDA_LOG_FORMAT, "TEXT");
public static final String FUNCTION_NAME = ENV_READER.getEnv(AWS_LAMBDA_FUNCTION_NAME);
public static final String FUNCTION_VERSION = ENV_READER.getEnv(AWS_LAMBDA_FUNCTION_VERSION);
}
| 1,657 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/PojoSerializerLoader.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer;
import com.amazonaws.services.lambda.runtime.CustomPojoSerializer;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Type;
import java.util.Iterator;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
public class PojoSerializerLoader {
// The serializer obtained from the provider will always be the same so we can cache it as a filed.
private static CustomPojoSerializer customPojoSerializer;
// If Input and Output type are different, the runtime will try to search for a serializer twice due to
// the getSerializerCached method. Save the initialization state in order to search for the provider only once.
private static boolean initialized = false;
private static CustomPojoSerializer loadSerializer()
throws ServiceConfigurationError, TooManyServiceProvidersFoundException {
if (customPojoSerializer != null) {
return customPojoSerializer;
}
ServiceLoader<CustomPojoSerializer> loader = ServiceLoader.load(CustomPojoSerializer.class, AWSLambda.customerClassLoader);
Iterator<CustomPojoSerializer> serializers = loader.iterator();
if (!serializers.hasNext()) {
initialized = true;
return null;
}
customPojoSerializer = serializers.next();
if (serializers.hasNext()) {
throw new TooManyServiceProvidersFoundException(
"Too many serializers provided inside the META-INF/services folder, only one is allowed"
);
}
initialized = true;
return customPojoSerializer;
}
public static PojoSerializer<Object> getCustomerSerializer(Type type) {
if (!initialized) {
customPojoSerializer = loadSerializer();
}
if (customPojoSerializer == null) {
return null;
}
return new PojoSerializer<Object>() {
@Override
public Object fromJson(InputStream input) {
return customPojoSerializer.fromJson(input, type);
}
@Override
public Object fromJson(String input) {
return customPojoSerializer.fromJson(input, type);
}
@Override
public void toJson(Object value, OutputStream output) {
customPojoSerializer.toJson(value, output, type);
}
};
}
}
| 1,658 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/EventHandlerLoader.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client;
import com.amazonaws.services.lambda.runtime.ClientContext;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.LambdaRuntimeInternal;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.RequestStreamHandler;
import com.amazonaws.services.lambda.runtime.api.client.LambdaRequestHandler.UserFaultHandler;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaClientContext;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaCognitoIdentity;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
import com.amazonaws.services.lambda.runtime.api.client.logging.LambdaContextLogger;
import com.amazonaws.services.lambda.runtime.api.client.runtimeapi.InvocationRequest;
import com.amazonaws.services.lambda.runtime.api.client.util.UnsafeUtil;
import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer;
import com.amazonaws.services.lambda.runtime.serialization.events.LambdaEventSerializers;
import com.amazonaws.services.lambda.runtime.serialization.factories.GsonFactory;
import com.amazonaws.services.lambda.runtime.serialization.factories.JacksonFactory;
import com.amazonaws.services.lambda.runtime.serialization.util.Functions;
import com.amazonaws.services.lambda.runtime.serialization.util.ReflectUtil;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Arrays;
import java.util.Comparator;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import static com.amazonaws.services.lambda.runtime.api.client.UserFault.*;
public final class EventHandlerLoader {
private static final byte[] _JsonNull = new byte[]{'n', 'u', 'l', 'l'};
private enum Platform {
ANDROID,
IOS,
UNKNOWN
}
private static final EnumMap<Platform, Map<Type, PojoSerializer<Object>>> typeCache = new EnumMap<>(Platform.class);
private EventHandlerLoader() {
}
/**
* returns the appropriate serializer for the class based on platform and whether the class is a supported event
*
* @param platform enum platform
* @param type Type of object used
* @return PojoSerializer
* @see Platform for which platforms are used
* @see LambdaEventSerializers for how mixins and modules are added to the serializer
*/
@SuppressWarnings({"unchecked", "rawtypes"})
private static PojoSerializer<Object> getSerializer(Platform platform, Type type) {
PojoSerializer<Object> customSerializer = PojoSerializerLoader.getCustomerSerializer(type);
if (customSerializer != null) {
return customSerializer;
}
// if serializing a Class that is a Lambda supported event, use Jackson with customizations
if (type instanceof Class) {
Class<Object> clazz = ((Class) type);
if (LambdaEventSerializers.isLambdaSupportedEvent(clazz.getName())) {
return LambdaEventSerializers.serializerFor(clazz, AWSLambda.customerClassLoader);
}
}
// else platform dependent (Android uses GSON but all other platforms use Jackson)
if (Objects.requireNonNull(platform) == Platform.ANDROID) {
return GsonFactory.getInstance().getSerializer(type);
}
return JacksonFactory.getInstance().getSerializer(type);
}
private static PojoSerializer<Object> getSerializerCached(Platform platform, Type type) {
Map<Type, PojoSerializer<Object>> cache = typeCache.get(platform);
if (cache == null) {
cache = new HashMap<>();
typeCache.put(platform, cache);
}
PojoSerializer<Object> serializer = cache.get(type);
if (serializer == null) {
serializer = getSerializer(platform, type);
cache.put(type, serializer);
}
return serializer;
}
private static volatile PojoSerializer<LambdaClientContext> contextSerializer;
private static volatile PojoSerializer<LambdaCognitoIdentity> cognitoSerializer;
private static PojoSerializer<LambdaClientContext> getContextSerializer() {
if (contextSerializer == null) {
contextSerializer = GsonFactory.getInstance().getSerializer(LambdaClientContext.class);
}
return contextSerializer;
}
private static PojoSerializer<LambdaCognitoIdentity> getCognitoSerializer() {
if (cognitoSerializer == null) {
cognitoSerializer = GsonFactory.getInstance().getSerializer(LambdaCognitoIdentity.class);
}
return cognitoSerializer;
}
private static Platform getPlatform(Context context) {
ClientContext cc = context.getClientContext();
if (cc == null) {
return Platform.UNKNOWN;
}
Map<String, String> env = cc.getEnvironment();
if (env == null) {
return Platform.UNKNOWN;
}
String platform = env.get("platform");
if (platform == null) {
return Platform.UNKNOWN;
}
if ("Android".equalsIgnoreCase(platform)) {
return Platform.ANDROID;
} else if ("iPhoneOS".equalsIgnoreCase(platform)) {
return Platform.IOS;
} else {
return Platform.UNKNOWN;
}
}
private static boolean isVoid(Type type) {
return Void.TYPE.equals(type) || (type instanceof Class) && Void.class.isAssignableFrom((Class<?>) type);
}
/**
* Wraps a RequestHandler as a lower level stream handler using supplied types.
* Optional types mean that the input and/or output should be ignored respectiveley
*/
@SuppressWarnings("rawtypes")
private static final class PojoHandlerAsStreamHandler implements RequestStreamHandler {
public RequestHandler innerHandler;
public final Optional<Type> inputType;
public final Optional<Type> outputType;
public PojoHandlerAsStreamHandler(
RequestHandler innerHandler,
Optional<Type> inputType,
Optional<Type> outputType
) {
this.innerHandler = innerHandler;
this.inputType = inputType;
this.outputType = outputType;
if (inputType.isPresent()) {
getSerializerCached(Platform.UNKNOWN, inputType.get());
}
if (outputType.isPresent()) {
getSerializerCached(Platform.UNKNOWN, outputType.get());
}
}
@SuppressWarnings("unchecked")
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context)
throws IOException {
final Object input;
final Platform platform = getPlatform(context);
try {
if (inputType.isPresent()) {
input = getSerializerCached(platform, inputType.get()).fromJson(inputStream);
} else {
input = null;
}
} catch (Throwable t) {
throw new RuntimeException("An error occurred during JSON parsing", filterStackTrace(t));
}
final Object output;
try {
output = innerHandler.handleRequest(input, context);
} catch (Throwable t) {
throw UnsafeUtil.throwException(filterStackTrace(t));
}
try {
if (outputType.isPresent()) {
PojoSerializer<Object> serializer = getSerializerCached(platform, outputType.get());
serializer.toJson(output, outputStream);
} else {
outputStream.write(_JsonNull);
}
} catch (Throwable t) {
throw new RuntimeException("An error occurred during JSON serialization of response", t);
}
}
}
/**
* Wraps a java.lang.reflect.Method as a POJO RequestHandler
*/
private static final class PojoMethodRequestHandler implements RequestHandler<Object, Object> {
public final Method m;
public final Type pType;
public final Object instance;
public final boolean needsContext;
public final int argSize;
public PojoMethodRequestHandler(Method m, Type pType, Type rType, Object instance, boolean needsContext) {
this.m = m;
this.pType = pType;
this.instance = instance;
this.needsContext = needsContext;
this.argSize = (needsContext ? 1 : 0) + (pType != null ? 1 : 0);
}
public static PojoMethodRequestHandler fromMethod(
Class<?> clazz,
Method m,
Type pType,
Type rType,
boolean needsContext
) throws Exception {
final Object instance;
if (Modifier.isStatic(m.getModifiers())) {
instance = null;
} else {
instance = newInstance(getConstructor(clazz));
}
return new PojoMethodRequestHandler(m, pType, rType, instance, needsContext);
}
public static LambdaRequestHandler makeRequestHandler(
Class<?> clazz,
Method m,
Type pType,
Type rType,
boolean needsContext
) {
try {
return wrapPojoHandler(fromMethod(clazz, m, pType, rType, needsContext), pType, rType);
} catch (UserFault f) {
return new UserFaultHandler(f);
} catch (Throwable t) {
return new UserFaultHandler(makeUserFault(t));
}
}
@Override
public Object handleRequest(Object input, Context context) {
final Object[] args = new Object[argSize];
int idx = 0;
if (pType != null) {
args[idx++] = input;
}
if (this.needsContext) {
args[idx++] = context;
}
try {
return m.invoke(this.instance, args);
} catch (InvocationTargetException e) {
if (e.getCause() != null) {
throw UnsafeUtil.throwException(filterStackTrace(e.getCause()));
} else {
throw UnsafeUtil.throwException(filterStackTrace(e));
}
} catch (Throwable t) {
throw UnsafeUtil.throwException(filterStackTrace(t));
}
}
}
/**
* Wraps a java.lang.reflect.Method object as a RequestStreamHandler
*/
private static final class StreamMethodRequestHandler implements RequestStreamHandler {
public final Method m;
public final Object instance;
public final boolean needsInput;
public final boolean needsOutput;
public final boolean needsContext;
public final int argSize;
public StreamMethodRequestHandler(
Method m,
Object instance,
boolean needsInput,
boolean needsOutput,
boolean needsContext
) {
this.m = m;
this.instance = instance;
this.needsInput = needsInput;
this.needsOutput = needsOutput;
this.needsContext = needsContext;
this.argSize = (needsInput ? 1 : 0) + (needsOutput ? 1 : 0) + (needsContext ? 1 : 0);
}
public static StreamMethodRequestHandler fromMethod(
Class<?> clazz,
Method m,
boolean needsInput,
boolean needsOutput,
boolean needsContext
) throws Exception {
if (!isVoid(m.getReturnType())) {
System.err.println("Will ignore return type " + m.getReturnType() + " on byte stream handler");
}
final Object instance = Modifier.isStatic(m.getModifiers())
? null
: newInstance(getConstructor(clazz));
return new StreamMethodRequestHandler(m, instance, needsInput, needsOutput, needsContext);
}
public static LambdaRequestHandler makeRequestHandler(
Class<?> clazz,
Method m,
boolean needsInput,
boolean needsOutput,
boolean needsContext
) {
try {
return wrapRequestStreamHandler(fromMethod(clazz, m, needsInput, needsOutput, needsContext));
} catch (UserFault f) {
return new UserFaultHandler(f);
} catch (Throwable t) {
return new UserFaultHandler(makeUserFault(t));
}
}
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context context)
throws IOException {
final Object[] args = new Object[argSize];
int idx = 0;
if (needsInput) {
args[idx++] = inputStream;
} else {
inputStream.close();
}
if (needsOutput) {
args[idx++] = outputStream;
}
if (needsContext) {
args[idx++] = context;
}
try {
m.invoke(this.instance, args);
if (!needsOutput) {
outputStream.write(_JsonNull);
}
} catch (InvocationTargetException e) {
if (e.getCause() != null) {
throw UnsafeUtil.throwException(filterStackTrace(e.getCause()));
} else {
throw UnsafeUtil.throwException(filterStackTrace(e));
}
} catch (Throwable t) {
throw UnsafeUtil.throwException(filterStackTrace(t));
}
}
}
private static <T> Constructor<T> getConstructor(Class<T> clazz) throws Exception {
final Constructor<T> constructor;
try {
constructor = clazz.getConstructor();
} catch (NoSuchMethodException e) {
if (clazz.getEnclosingClass() != null && !Modifier.isStatic(clazz.getModifiers())) {
throw new Exception("Class "
+ clazz.getName()
+ " cannot be instantiated because it is a non-static inner class");
} else {
throw new Exception("Class " + clazz.getName() + " has no public zero-argument constructor", e);
}
}
return constructor;
}
private static <T> T newInstance(Constructor<? extends T> constructor) {
try {
return constructor.newInstance();
} catch (UserFault e) {
throw e;
} catch (InvocationTargetException e) {
throw makeUserFault(e.getCause() == null ? e : e.getCause(), true);
} catch (InstantiationException e) {
throw UnsafeUtil.throwException(e.getCause() == null ? e : e.getCause());
} catch (IllegalAccessException e) {
throw UnsafeUtil.throwException(e);
}
}
private static final class ClassContext {
public final Class<?> clazz;
public final Type[] actualTypeArguments;
@SuppressWarnings({"rawtypes"})
private TypeVariable[] typeParameters;
public ClassContext(Class<?> clazz, Type[] actualTypeArguments) {
this.clazz = clazz;
this.actualTypeArguments = actualTypeArguments;
}
@SuppressWarnings({"rawtypes"})
public ClassContext(Class<?> clazz, ClassContext curContext) {
this.typeParameters = clazz.getTypeParameters();
if (typeParameters.length == 0 || curContext.actualTypeArguments == null) {
this.clazz = clazz;
this.actualTypeArguments = null;
} else {
Type[] types = new Type[typeParameters.length];
for (int i = 0; i < types.length; i++) {
types[i] = curContext.resolveTypeVariable(typeParameters[i]);
}
this.clazz = clazz;
this.actualTypeArguments = types;
}
}
@SuppressWarnings({"rawtypes"})
public ClassContext(ParameterizedType type, ClassContext curContext) {
Type[] types = type.getActualTypeArguments();
for (int i = 0; i < types.length; i++) {
Type t = types[i];
if (t instanceof TypeVariable) {
types[i] = curContext.resolveTypeVariable((TypeVariable) t);
}
}
Type t = type.getRawType();
if (t instanceof Class) {
this.clazz = (Class) t;
} else if (t instanceof TypeVariable) {
this.clazz = (Class) ((TypeVariable) t).getGenericDeclaration();
} else {
throw new RuntimeException("Type " + t + " is of unexpected type " + t.getClass());
}
this.actualTypeArguments = types;
}
@SuppressWarnings({"rawtypes"})
public Type resolveTypeVariable(TypeVariable t) {
TypeVariable[] variables = getTypeParameters();
for (int i = 0; i < variables.length; i++) {
if (t.getName().equals(variables[i].getName())) {
return actualTypeArguments == null ? variables[i] : actualTypeArguments[i];
}
}
return t;
}
@SuppressWarnings({"rawtypes"})
private TypeVariable[] getTypeParameters() {
if (typeParameters == null) {
typeParameters = clazz.getTypeParameters();
}
return typeParameters;
}
}
/**
* perform a breadth-first search for the first parameterized type for iface
*
* @return null of no type found. Otherwise the type found.
*/
private static Type[] findInterfaceParameters(Class<?> clazz, Class<?> iface) {
LinkedList<ClassContext> clazzes = new LinkedList<>();
clazzes.addFirst(new ClassContext(clazz, (Type[]) null));
while (!clazzes.isEmpty()) {
final ClassContext curContext = clazzes.removeLast();
Type[] interfaces = curContext.clazz.getGenericInterfaces();
for (Type type : interfaces) {
if (type instanceof ParameterizedType) {
ParameterizedType candidate = (ParameterizedType) type;
Type rawType = candidate.getRawType();
if (!(rawType instanceof Class)) {
//should be impossible
System.err.println("raw type is not a class: " + rawType);
continue;
}
Class<?> rawClass = (Class<?>) rawType;
if (iface.isAssignableFrom(rawClass)) {
return new ClassContext(candidate, curContext).actualTypeArguments;
} else {
clazzes.addFirst(new ClassContext(candidate, curContext));
}
} else if (type instanceof Class) {
clazzes.addFirst(new ClassContext((Class<?>) type, curContext));
} else {
//should never happen?
System.err.println("Unexpected type class " + type.getClass().getName());
}
}
final Type superClass = curContext.clazz.getGenericSuperclass();
if (superClass instanceof ParameterizedType) {
clazzes.addFirst(new ClassContext((ParameterizedType) superClass, curContext));
} else if (superClass != null) {
clazzes.addFirst(new ClassContext((Class<?>) superClass, curContext));
}
}
return null;
}
@SuppressWarnings({"rawtypes"})
private static LambdaRequestHandler wrapRequestHandlerClass(final Class<? extends RequestHandler> clazz) {
Type[] ptypes = findInterfaceParameters(clazz, RequestHandler.class);
if (ptypes == null) {
return new UserFaultHandler(makeUserFault("Class "
+ clazz.getName()
+ " does not implement RequestHandler with concrete type parameters"));
}
if (ptypes.length != 2) {
return new UserFaultHandler(makeUserFault(
"Invalid class signature for RequestHandler. Expected two generic types, got " + ptypes.length));
}
for (Type t : ptypes) {
if (t instanceof TypeVariable) {
Type[] bounds = ((TypeVariable) t).getBounds();
boolean foundBound = false;
if (bounds != null) {
for (Type bound : bounds) {
if (!Object.class.equals(bound)) {
foundBound = true;
break;
}
}
}
if (!foundBound) {
return new UserFaultHandler(makeUserFault("Class " + clazz.getName()
+ " does not implement RequestHandler with concrete type parameters: parameter "
+ t + " has no upper bound."));
}
}
}
final Type pType = ptypes[0];
final Type rType = ptypes[1];
final Constructor<? extends RequestHandler> constructor;
try {
constructor = getConstructor(clazz);
return wrapPojoHandler(newInstance(constructor), pType, rType);
} catch (UserFault f) {
return new UserFaultHandler(f);
} catch (Throwable e) {
return new UserFaultHandler(makeUserFault(e));
}
}
private static LambdaRequestHandler wrapRequestStreamHandlerClass(final Class<? extends RequestStreamHandler> clazz) {
final Constructor<? extends RequestStreamHandler> constructor;
try {
constructor = getConstructor(clazz);
return wrapRequestStreamHandler(newInstance(constructor));
} catch (UserFault f) {
return new UserFaultHandler(f);
} catch (Throwable e) {
return new UserFaultHandler(makeUserFault(e));
}
}
private static LambdaRequestHandler loadStreamingRequestHandler(Class<?> clazz) {
if (RequestStreamHandler.class.isAssignableFrom(clazz)) {
return wrapRequestStreamHandlerClass(clazz.asSubclass(RequestStreamHandler.class));
} else if (RequestHandler.class.isAssignableFrom(clazz)) {
return wrapRequestHandlerClass(clazz.asSubclass(RequestHandler.class));
} else {
return new UserFaultHandler(makeUserFault("Class does not implement an appropriate handler interface: "
+ clazz.getName()));
}
}
public static LambdaRequestHandler loadEventHandler(HandlerInfo handlerInfo) {
if (handlerInfo.methodName == null) {
return loadStreamingRequestHandler(handlerInfo.clazz);
} else {
return loadEventPojoHandler(handlerInfo);
}
}
private static Optional<LambdaRequestHandler> getOneLengthHandler(
Class<?> clazz,
Method m,
Type pType,
Type rType
) {
if (InputStream.class.equals(pType)) {
return Optional.of(StreamMethodRequestHandler.makeRequestHandler(clazz, m, true, false, false));
} else if (OutputStream.class.equals(pType)) {
return Optional.of(StreamMethodRequestHandler.makeRequestHandler(clazz, m, false, true, false));
} else if (isContext(pType)) {
return Optional.of(PojoMethodRequestHandler.makeRequestHandler(clazz, m, null, rType, true));
} else {
return Optional.of(PojoMethodRequestHandler.makeRequestHandler(clazz, m, pType, rType, false));
}
}
private static Optional<LambdaRequestHandler> getTwoLengthHandler(
Class<?> clazz,
Method m,
Type pType1,
Type pType2,
Type rType
) {
if (OutputStream.class.equals(pType1)) {
if (isContext(pType2)) {
return Optional.of(StreamMethodRequestHandler.makeRequestHandler(clazz, m, false, true, true));
} else {
System.err.println(
"Ignoring two-argument overload because first argument type is OutputStream and second argument type is not Context");
return Optional.empty();
}
} else if (isContext(pType1)) {
System.err.println("Ignoring two-argument overload because first argument type is Context");
return Optional.empty();
} else if (InputStream.class.equals(pType1)) {
if (OutputStream.class.equals(pType2)) {
return Optional.of(StreamMethodRequestHandler.makeRequestHandler(clazz, m, true, true, false));
} else if (isContext(pType2)) {
return Optional.of(StreamMethodRequestHandler.makeRequestHandler(clazz, m, true, false, true));
} else {
System.err.println("Ignoring two-argument overload because second parameter type, "
+ ReflectUtil.getRawClass(pType2).getName()
+ ", is not OutputStream.");
return Optional.empty();
}
} else if (isContext(pType2)) {
return Optional.of(PojoMethodRequestHandler.makeRequestHandler(clazz, m, pType1, rType, true));
} else {
System.err.println("Ignoring two-argument overload because second parameter type is not Context");
return Optional.empty();
}
}
private static Optional<LambdaRequestHandler> getThreeLengthHandler(
Class<?> clazz,
Method m,
Type pType1,
Type pType2,
Type pType3,
Type rType
) {
if (InputStream.class.equals(pType1) && OutputStream.class.equals(pType2) && isContext(pType3)) {
return Optional.of(StreamMethodRequestHandler.makeRequestHandler(clazz, m, true, true, true));
} else {
System.err.println(
"Ignoring three-argument overload because argument signature is not (InputStream, OutputStream, Context");
return Optional.empty();
}
}
private static Optional<LambdaRequestHandler> getHandlerFromOverload(Class<?> clazz, Method m) {
final Type rType = m.getGenericReturnType();
final Type[] pTypes = m.getGenericParameterTypes();
if (pTypes.length == 0) {
return Optional.of(PojoMethodRequestHandler.makeRequestHandler(clazz, m, null, rType, false));
} else if (pTypes.length == 1) {
return getOneLengthHandler(clazz, m, pTypes[0], rType);
} else if (pTypes.length == 2) {
return getTwoLengthHandler(clazz, m, pTypes[0], pTypes[1], rType);
} else if (pTypes.length == 3) {
return getThreeLengthHandler(clazz, m, pTypes[0], pTypes[1], pTypes[2], rType);
} else {
System.err.println("Ignoring an overload of method "
+ m.getName()
+ " because it has too many parameters: Expected at most 3, got "
+ pTypes.length);
return Optional.empty();
}
}
private static boolean isContext(Type t) {
return Context.class.equals(t);
}
/**
* Returns true if the last type in params is a lambda context object interface (Context).
*/
private static boolean lastParameterIsContext(Class<?>[] params) {
return params.length != 0 && isContext(params[params.length - 1]);
}
/**
* Implement a comparator for Methods. We sort overloaded handler methods using this comparator, and then pick the
* lowest sorted method.
*/
private static final Comparator<Method> methodPriority = new Comparator<Method>() {
public int compare(Method lhs, Method rhs) {
//1. Non bridge methods are preferred over bridge methods.
if (!lhs.isBridge() && rhs.isBridge()) {
return -1;
} else if (!rhs.isBridge() && lhs.isBridge()) {
return 1;
}
//2. We prefer longer signatures to shorter signatures. Except we count a method whose last argument is
//Context as having 1 more argument than it really does. This is a stupid thing to do, but we
//need to keep it for back compat reasons.
Class<?>[] lParams = lhs.getParameterTypes();
Class<?>[] rParams = rhs.getParameterTypes();
int lParamCompareLength = lParams.length;
int rParamCompareLength = rParams.length;
if (lastParameterIsContext(lParams)) {
++lParamCompareLength;
}
if (lastParameterIsContext(rParams)) {
++rParamCompareLength;
}
return -Integer.compare(lParamCompareLength, rParamCompareLength);
}
};
private static LambdaRequestHandler loadEventPojoHandler(HandlerInfo handlerInfo) {
Method[] methods;
try {
methods = handlerInfo.clazz.getMethods();
} catch (NoClassDefFoundError e) {
return new LambdaRequestHandler.UserFaultHandler(new UserFault(
"Error loading method " + handlerInfo.methodName + " on class " + handlerInfo.clazz.getName(),
e.getClass().getName(),
trace(e)
));
}
if (methods.length == 0) {
final String msg = "Class "
+ handlerInfo.getClass().getName()
+ " has no public method named "
+ handlerInfo.methodName;
return new UserFaultHandler(makeUserFault(msg));
}
/*
* We support the following signatures
* Anything (InputStream, OutputStream, Context)
* Anything (InputStream, OutputStream)
* Anything (OutputStream, Context)
* Anything (InputStream, Context)
* Anything (InputStream)
* Anything (OutputStream)
* Anything (Context)
* Anything (AlmostAnything, Context)
* Anything (AlmostAnything)
* Anything ()
*
* where AlmostAnything is any type except InputStream, OutputStream, Context
* Anything represents any type (primitive, void, or Object)
*
* prefer methods with longer signatures, add extra weight to those ending with a Context object
*
*/
int slide = 0;
for (int i = 0; i < methods.length; i++) {
Method m = methods[i];
methods[i - slide] = m;
if (!m.getName().equals(handlerInfo.methodName)) {
slide++;
continue;
}
}
final int end = methods.length - slide;
Arrays.sort(methods, 0, end, methodPriority);
for (int i = 0; i < end; i++) {
Method m = methods[i];
Optional<LambdaRequestHandler> result = getHandlerFromOverload(handlerInfo.clazz, m);
if (result.isPresent()) {
return result.get();
} else {
continue;
}
}
return new UserFaultHandler(makeUserFault("No public method named "
+ handlerInfo.methodName
+ " with appropriate method signature found on class "
+ handlerInfo.clazz.getName()));
}
@SuppressWarnings({"rawtypes"})
private static LambdaRequestHandler wrapPojoHandler(RequestHandler instance, Type pType, Type rType) {
return wrapRequestStreamHandler(new PojoHandlerAsStreamHandler(instance, Optional.ofNullable(pType),
isVoid(rType) ? Optional.<Type>empty() : Optional.of(rType)
));
}
private static LambdaRequestHandler wrapRequestStreamHandler(final RequestStreamHandler handler) {
return new LambdaRequestHandler() {
private final ByteArrayOutputStream output = new ByteArrayOutputStream(1024);
private Functions.V2<String, String> log4jContextPutMethod = null;
private void safeAddRequestIdToLog4j(String log4jContextClassName,
InvocationRequest request, Class contextMapValueClass) {
try {
Class<?> log4jContextClass = ReflectUtil.loadClass(AWSLambda.customerClassLoader, log4jContextClassName);
log4jContextPutMethod = ReflectUtil.loadStaticV2(log4jContextClass, "put", false, String.class, contextMapValueClass);
log4jContextPutMethod.call("AWSRequestId", request.getId());
} catch (Exception e) {
}
}
/**
* Passes the LambdaContext to the logger so that the JSON formatter can include the requestId.
*
* We do casting here because both the LambdaRuntime and the LambdaLogger is in the core package,
* and the setLambdaContext(context) is a method we don't want to publish for customers. That method is
* only implemented on the internal LambdaContextLogger, so we check and cast to be able to call it.
* @param context the LambdaContext
*/
private void safeAddContextToLambdaLogger(LambdaContext context) {
LambdaLogger logger = com.amazonaws.services.lambda.runtime.LambdaRuntime.getLogger();
if (logger instanceof LambdaContextLogger) {
LambdaContextLogger contextLogger = (LambdaContextLogger) logger;
contextLogger.setLambdaContext(context);
}
}
public ByteArrayOutputStream call(InvocationRequest request) throws Error, Exception {
output.reset();
LambdaCognitoIdentity cognitoIdentity = null;
if (request.getCognitoIdentity() != null && !request.getCognitoIdentity().isEmpty()) {
cognitoIdentity = getCognitoSerializer().fromJson(request.getCognitoIdentity());
}
LambdaClientContext clientContext = null;
if (request.getClientContext() != null && !request.getClientContext().isEmpty()) {
//Use GSON here because it handles immutable types without requiring annotations
clientContext = getContextSerializer().fromJson(request.getClientContext());
}
LambdaContext context = new LambdaContext(
LambdaEnvironment.MEMORY_LIMIT,
request.getDeadlineTimeInMs(),
request.getId(),
LambdaEnvironment.LOG_GROUP_NAME,
LambdaEnvironment.LOG_STREAM_NAME,
LambdaEnvironment.FUNCTION_NAME,
cognitoIdentity,
LambdaEnvironment.FUNCTION_VERSION,
request.getInvokedFunctionArn(),
clientContext
);
safeAddContextToLambdaLogger(context);
if (LambdaRuntimeInternal.getUseLog4jAppender()) {
safeAddRequestIdToLog4j("org.apache.log4j.MDC", request, Object.class);
safeAddRequestIdToLog4j("org.apache.logging.log4j.ThreadContext", request, String.class);
// if put method not assigned in either call to safeAddRequestIdtoLog4j then log4jContextPutMethod = null
if (log4jContextPutMethod == null) {
System.err.println("Customer using log4j appender but unable to load either " +
"org.apache.log4j.MDC or org.apache.logging.log4j.ThreadContext. " +
"Customer cannot see RequestId in log4j log lines.");
}
}
handler.handleRequest(request.getContentAsStream(), output, context);
return output;
}
};
}
}
| 1,659 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/util/UnsafeUtil.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.util;
import sun.misc.Unsafe;
import java.lang.reflect.Field;
/**
* Utilities for easy access to sun.misc.Unsafe
*/
public final class UnsafeUtil {
public static final Unsafe TheUnsafe;
static {
try {
final Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
TheUnsafe = (Unsafe) theUnsafe.get(null);
} catch (Exception e) {
throw new Error("failed to load Unsafe", e);
}
}
private UnsafeUtil() {
}
public static void disableIllegalAccessWarning() {
try {
Class illegalAccessLoggerClass = Class.forName("jdk.internal.module.IllegalAccessLogger");
Field loggerField = illegalAccessLoggerClass.getDeclaredField("logger");
TheUnsafe.putObjectVolatile(illegalAccessLoggerClass, TheUnsafe.staticFieldOffset(loggerField), null);
} catch (Throwable t) { /* ignore */ }
}
public static RuntimeException throwException(Throwable t) {
TheUnsafe.throwException(t);
throw new Error("should never get here");
}
}
| 1,660 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/util/EnvReader.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.util;
import java.util.Map;
public class EnvReader {
public Map<String, String> getEnv() {
return System.getenv();
}
public String getEnv(String envVariableName) {
return System.getenv(envVariableName);
}
public String getEnvOrDefault(String envVariableName, String defaultVal) {
String val = getEnv(envVariableName);
return val == null ? defaultVal : val;
}
}
| 1,661 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/util/LambdaOutputStream.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.util;
import java.io.OutputStream;
import java.io.IOException;
public class LambdaOutputStream extends OutputStream {
private final OutputStream inner;
public LambdaOutputStream(OutputStream inner) {
this.inner = inner;
}
@Override
public void write(int b) throws IOException {
write(new byte[]{(byte) b});
}
@Override
public void write(byte[] bytes) throws IOException {
write(bytes, 0, bytes.length);
}
@Override
public void write(byte[] bytes, int offset, int length) throws IOException {
inner.write(bytes, offset, length);
}
}
| 1,662 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeClient.java | package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import static java.net.HttpURLConnection.HTTP_ACCEPTED;
import static java.net.HttpURLConnection.HTTP_OK;
import static java.nio.charset.StandardCharsets.UTF_8;
/**
* LambdaRuntimeClient is a client of the AWS Lambda Runtime HTTP API for custom runtimes.
* <p>
* API definition can be found at https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html
* <p>
* Copyright (c) 2019 Amazon. All rights reserved.
*/
public class LambdaRuntimeClient {
private final String hostname;
private final int port;
private final String invocationEndpoint;
private static final String DEFAULT_CONTENT_TYPE = "application/json";
private static final String XRAY_ERROR_CAUSE_HEADER = "Lambda-Runtime-Function-XRay-Error-Cause";
private static final String ERROR_TYPE_HEADER = "Lambda-Runtime-Function-Error-Type";
private static final int XRAY_ERROR_CAUSE_MAX_HEADER_SIZE = 1024 * 1024; // 1MiB
public LambdaRuntimeClient(String hostnamePort) {
Objects.requireNonNull(hostnamePort, "hostnamePort cannot be null");
String[] parts = hostnamePort.split(":");
this.hostname = parts[0];
this.port = Integer.parseInt(parts[1]);
this.invocationEndpoint = invocationEndpoint();
NativeClient.init();
}
public InvocationRequest waitForNextInvocation() {
return NativeClient.next();
}
public void postInvocationResponse(String requestId, byte[] response) {
NativeClient.postInvocationResponse(requestId.getBytes(UTF_8), response);
}
public void postInvocationError(String requestId, byte[] errorResponse, String errorType) throws IOException {
postInvocationError(requestId, errorResponse, errorType, null);
}
public void postInvocationError(String requestId, byte[] errorResponse, String errorType, String errorCause)
throws IOException {
String endpoint = invocationErrorEndpoint(requestId);
post(endpoint, errorResponse, errorType, errorCause);
}
public void getRestoreNext() throws IOException {
doGet(restoreNextEndpoint(), HTTP_OK);
}
public int postRestoreError(byte[] errorResponse, String errorType) throws IOException {
String endpoint = restoreErrorEndpoint();
return postError(endpoint, errorResponse, errorType, null);
}
public void postInitError(byte[] errorResponse, String errorType) throws IOException {
String endpoint = initErrorEndpoint();
post(endpoint, errorResponse, errorType, null);
}
private void post(String endpoint, byte[] errorResponse, String errorType, String errorCause) throws IOException {
URL url = createUrl(endpoint);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Type", DEFAULT_CONTENT_TYPE);
if (errorType != null && !errorType.isEmpty()) {
conn.setRequestProperty(ERROR_TYPE_HEADER, errorType);
}
if (errorCause != null && errorCause.getBytes().length < XRAY_ERROR_CAUSE_MAX_HEADER_SIZE) {
conn.setRequestProperty(XRAY_ERROR_CAUSE_HEADER, errorCause);
}
conn.setFixedLengthStreamingMode(errorResponse.length);
conn.setDoOutput(true);
try (OutputStream outputStream = conn.getOutputStream()) {
outputStream.write(errorResponse);
}
int responseCode = conn.getResponseCode();
if (responseCode != HTTP_ACCEPTED) {
throw new LambdaRuntimeClientException(endpoint, responseCode);
}
// don't need to read the response, close stream to ensure connection re-use
closeQuietly(conn.getInputStream());
}
private String invocationEndpoint() {
return getBaseUrl() + "/2018-06-01/runtime/invocation/";
}
private String invocationErrorEndpoint(String requestId) {
return invocationEndpoint + requestId + "/error";
}
private String initErrorEndpoint() {
return getBaseUrl() + "/2018-06-01/runtime/init/error";
}
private String restoreErrorEndpoint() {
return getBaseUrl() + "/2018-06-01/runtime/restore/error";
}
private String restoreNextEndpoint() {
return getBaseUrl() + "/2018-06-01/runtime/restore/next";
}
private String getBaseUrl() {
return "http://" + hostname + ":" + port;
}
private int postError(String endpoint,
byte[] errorResponse,
String errorType,
String errorCause) throws IOException {
Map<String, String> headers = new HashMap<>();
if (errorType != null && !errorType.isEmpty()) {
headers.put(ERROR_TYPE_HEADER, errorType);
}
if (errorCause != null && errorCause.getBytes().length < XRAY_ERROR_CAUSE_MAX_HEADER_SIZE) {
headers.put(XRAY_ERROR_CAUSE_HEADER, errorCause);
}
return doPost(endpoint, DEFAULT_CONTENT_TYPE, headers, errorResponse);
}
private int doPost(String endpoint,
String contentType,
Map<String, String> headers,
byte[] payload) throws IOException {
URL url = createUrl(endpoint);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("Content-Type", contentType);
for (Map.Entry<String, String> header : headers.entrySet()) {
conn.setRequestProperty(header.getKey(), header.getValue());
}
conn.setFixedLengthStreamingMode(payload.length);
conn.setDoOutput(true);
try (OutputStream outputStream = conn.getOutputStream()) {
outputStream.write(payload);
}
// get response code before closing the stream
int responseCode = conn.getResponseCode();
// don't need to read the response, close stream to ensure connection re-use
closeInputStreamQuietly(conn);
return responseCode;
}
private void doGet(String endpoint, int expectedHttpResponseCode) throws IOException {
URL url = createUrl(endpoint);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
int responseCode = conn.getResponseCode();
if (responseCode != expectedHttpResponseCode) {
throw new LambdaRuntimeClientException(endpoint, responseCode);
}
closeInputStreamQuietly(conn);
}
private URL createUrl(String endpoint) {
try {
return new URL(endpoint);
} catch (MalformedURLException e) {
throw new RuntimeException(e);
}
}
private void closeQuietly(InputStream inputStream) {
if (inputStream == null) return;
try {
inputStream.close();
} catch (IOException e) {
}
}
private void closeInputStreamQuietly(HttpURLConnection conn) {
InputStream inputStream;
try {
inputStream = conn.getInputStream();
} catch (IOException e) {
return;
}
if (inputStream == null) {
return;
}
try {
inputStream.close();
} catch (IOException e) {
// ignore
}
}
}
| 1,663 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/LambdaRuntimeClientException.java | package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
/**
* Copyright (c) 2019 Amazon. All rights reserved.
*/
public class LambdaRuntimeClientException extends RuntimeException {
public LambdaRuntimeClientException(String message, int responseCode) {
super(message + "Response code: '" + responseCode + "'.");
}
}
| 1,664 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/NativeClient.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.List;
/**
* This module defines the native Runtime Interface Client which is responsible for all HTTP
* interactions with the Runtime API.
*/
class NativeClient {
private static final String NATIVE_LIB_PATH = "/tmp/.libaws-lambda-jni.so";
public static final String NATIVE_CLIENT_JNI_PROPERTY = "com.amazonaws.services.lambda.runtime.api.client.runtimeapi.NativeClient.JNI";
static void init() {
loadJNILib();
initUserAgent();
}
private static void loadJNILib() {
String jniLib = System.getProperty(NATIVE_CLIENT_JNI_PROPERTY);
if (jniLib != null) {
System.load(jniLib);
} else {
String[] libsToTry = new String[]{
"libaws-lambda-jni.linux-x86_64.so",
"libaws-lambda-jni.linux-aarch_64.so",
"libaws-lambda-jni.linux_musl-x86_64.so",
"libaws-lambda-jni.linux_musl-aarch_64.so"
};
unpackAndLoadNativeLibrary(libsToTry);
}
}
/**
* Unpacks JNI library from the JAR to a temporary location and tries to load it using System.load()
* Implementation based on AWS CRT
* (ref. <a href="https://github.com/awslabs/aws-crt-java/blob/0e9c3db8b07258b57c2503cfc47c787ccef10670/src/main/java/software/amazon/awssdk/crt/CRT.java#L106-L134">...</a>)
*
* @param libsToTry - array of native libraries to try
*/
static void unpackAndLoadNativeLibrary(String[] libsToTry) {
List<String> errorMessages = new ArrayList<>();
for (String libToTry : libsToTry) {
try (InputStream inputStream = NativeClient.class.getResourceAsStream(
Paths.get("/jni", libToTry).toString())) {
if (inputStream == null) {
throw new FileNotFoundException("Specified file not in the JAR: " + libToTry);
}
Files.copy(inputStream, Paths.get(NATIVE_LIB_PATH), StandardCopyOption.REPLACE_EXISTING);
System.load(NATIVE_LIB_PATH);
return;
} catch (UnsatisfiedLinkError | Exception e) {
errorMessages.add(e.getMessage());
}
}
for (int i = 0; i < libsToTry.length; ++i) {
System.err.println("Failed to load the native runtime interface client library " + libsToTry[i] +
". Exception: " + errorMessages.get(i));
}
System.exit(-1);
}
private static void initUserAgent() {
String userAgent = String.format(
"aws-lambda-java/%s-%s",
System.getProperty("java.vendor.version"),
NativeClient.class.getPackage().getImplementationVersion());
initializeClient(userAgent.getBytes());
}
static native void initializeClient(byte[] userAgent);
static native InvocationRequest next();
static native void postInvocationResponse(byte[] requestId, byte[] response);
}
| 1,665 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/UnknownPlatformException.java | package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
/**
* Copyright (c) 2022 Amazon. All rights reserved.
*/
public class UnknownPlatformException extends RuntimeException {
public UnknownPlatformException(String message) {
super(message);
}
}
| 1,666 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/runtimeapi/InvocationRequest.java | package com.amazonaws.services.lambda.runtime.api.client.runtimeapi;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
/**
* An invocation request represents the response of the runtime API's next invocation API.
* <p>
* Copyright (c) 2019 Amazon. All rights reserved.
*/
public class InvocationRequest {
/**
* The Lambda request ID associated with the request.
*/
private String id;
/**
* The X-Ray tracing ID.
*/
private String xrayTraceId;
/**
* The ARN of the Lambda function being invoked.
*/
private String invokedFunctionArn;
/**
* Function execution deadline counted in milliseconds since the Unix epoch.
*/
private long deadlineTimeInMs;
/**
* The client context header. This field is populated when the function is invoked from a mobile client.
*/
private String clientContext;
/**
* The Cognito Identity context for the invocation. This field is populated when the function is invoked with AWS
* credentials obtained from Cognito Identity.
*/
private String cognitoIdentity;
private byte[] content;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getXrayTraceId() {
return xrayTraceId;
}
public void setXrayTraceId(String xrayTraceId) {
this.xrayTraceId = xrayTraceId;
}
public String getInvokedFunctionArn() {
return invokedFunctionArn;
}
public void setInvokedFunctionArn(String invokedFunctionArn) {
this.invokedFunctionArn = invokedFunctionArn;
}
public long getDeadlineTimeInMs() {
return deadlineTimeInMs;
}
public void setDeadlineTimeInMs(long deadlineTimeInMs) {
this.deadlineTimeInMs = deadlineTimeInMs;
}
public String getClientContext() {
return clientContext;
}
public void setClientContext(String clientContext) {
this.clientContext = clientContext;
}
public String getCognitoIdentity() {
return cognitoIdentity;
}
public void setCognitoIdentity(String cognitoIdentity) {
this.cognitoIdentity = cognitoIdentity;
}
public InputStream getContentAsStream() {
return new ByteArrayInputStream(content);
}
public void setContent(byte[] content) {
this.content = content;
}
}
| 1,667 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/api/LambdaClientContext.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.api;
import com.amazonaws.services.lambda.runtime.Client;
import com.amazonaws.services.lambda.runtime.ClientContext;
import java.util.Map;
public class LambdaClientContext implements ClientContext {
private LambdaClientContextClient client;
private Map<String, String> custom;
private Map<String, String> env;
public Client getClient() {
return client;
}
public Map<String, String> getCustom() {
return custom;
}
public Map<String, String> getEnvironment() {
return env;
}
}
| 1,668 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/api/LambdaCognitoIdentity.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.api;
import com.amazonaws.services.lambda.runtime.CognitoIdentity;
public class LambdaCognitoIdentity implements CognitoIdentity {
private final String cognitoIdentityId;
private final String cognitoIdentityPoolId;
public LambdaCognitoIdentity(String identityid, String poolid) {
this.cognitoIdentityId = identityid;
this.cognitoIdentityPoolId = poolid;
}
public String getIdentityId() {
return this.cognitoIdentityId;
}
public String getIdentityPoolId() {
return this.cognitoIdentityPoolId;
}
}
| 1,669 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/api/LambdaContext.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.api;
import com.amazonaws.services.lambda.runtime.ClientContext;
import com.amazonaws.services.lambda.runtime.CognitoIdentity;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
public class LambdaContext implements Context {
private int memoryLimit;
private final String awsRequestId;
private final String logGroupName;
private final String logStreamName;
private final String functionName;
private final String functionVersion;
private final String invokedFunctionArn;
private final long deadlineTimeInMs;
private final CognitoIdentity cognitoIdentity;
private final ClientContext clientContext;
private final LambdaLogger logger;
public LambdaContext(
int memoryLimit,
long deadlineTimeInMs,
String requestId,
String logGroupName,
String logStreamName,
String functionName,
CognitoIdentity identity,
String functionVersion,
String invokedFunctionArn,
ClientContext clientContext
) {
this.memoryLimit = memoryLimit;
this.deadlineTimeInMs = deadlineTimeInMs;
this.awsRequestId = requestId;
this.logGroupName = logGroupName;
this.logStreamName = logStreamName;
this.functionName = functionName;
this.cognitoIdentity = identity;
this.clientContext = clientContext;
this.functionVersion = functionVersion;
this.invokedFunctionArn = invokedFunctionArn;
this.logger = com.amazonaws.services.lambda.runtime.LambdaRuntime.getLogger();
}
public int getMemoryLimitInMB() {
return memoryLimit;
}
public String getAwsRequestId() {
return awsRequestId;
}
public String getLogGroupName() {
return logGroupName;
}
public String getLogStreamName() {
return logStreamName;
}
public String getFunctionName() {
return functionName;
}
public String getFunctionVersion() {
return functionVersion;
}
public String getInvokedFunctionArn() {
return invokedFunctionArn;
}
public CognitoIdentity getIdentity() {
return cognitoIdentity;
}
public ClientContext getClientContext() {
return clientContext;
}
public int getRemainingTimeInMillis() {
long now = System.currentTimeMillis();
int delta = (int) (this.deadlineTimeInMs - now);
return delta > 0 ? delta : 0;
}
public LambdaLogger getLogger() {
return logger;
}
}
| 1,670 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/api/LambdaClientContextClient.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.api;
import com.amazonaws.services.lambda.runtime.Client;
public class LambdaClientContextClient implements Client {
private String installation_id;
private String app_title;
private String app_version_name;
private String app_version_code;
private String app_package_name;
public String getInstallationId() {
return installation_id;
}
public String getAppTitle() {
return app_title;
}
public String getAppVersionName() {
return app_version_name;
}
public String getAppVersionCode() {
return app_version_code;
}
public String getAppPackageName() {
return app_package_name;
}
}
| 1,671 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/FrameType.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
/**
* The first 4 bytes of the framing protocol is the Frame Type, that's made of a magic number (3 bytes) and 1 byte of flags.
* +-----------------------+
* | Frame Type - 4 bytes |
* +-----------------------+
* | a5 5a 00 | flgs |
* + - - - - - + - - - - - +
* \ bit |
* | view|
* +---------+ +
* | |
* v byte 3 v F - free
* +-+-+-+-+-+-+-+-+ J - { JsonLog = 0, PlainTextLog = 1 }
* |F|F|F|L|l|l|T|J| T - { NoTimeStamp = 0, TimeStampPresent = 1 }
* +-+-+-+-+-+-+-+-+ Lll -> Log Level in 3-bit binary (L-> most significant bit)
*/
public class FrameType {
private static final int LOG_MAGIC = 0xa55a0000;
private static final int OFFSET_LOG_FORMAT = 0;
private static final int OFFSET_TIMESTAMP_PRESENT = 1;
private static final int OFFSET_LOG_LEVEL = 2;
private final int val;
public static int getValue(LogLevel logLevel, LogFormat logFormat) {
return LOG_MAGIC |
(logLevel.ordinal() << OFFSET_LOG_LEVEL) |
(1 << OFFSET_TIMESTAMP_PRESENT) |
(logFormat.ordinal() << OFFSET_LOG_FORMAT);
}
FrameType(int val) {
this.val = val;
}
public int getValue() {
return this.val;
}
}
| 1,672 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/LambdaContextLogger.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import static java.nio.charset.StandardCharsets.UTF_8;
public class LambdaContextLogger extends AbstractLambdaLogger {
// If a null string is passed in, replace it with "null",
// replicating the behavior of System.out.println(null);
private static final byte[] NULL_BYTES_VALUE = "null".getBytes(UTF_8);
private final transient LogSink sink;
public LambdaContextLogger(LogSink sink, LogLevel logLevel, LogFormat logFormat) {
super(logLevel, logFormat);
this.sink = sink;
}
@Override
protected void logMessage(byte[] message, LogLevel logLevel) {
if (message == null) {
message = NULL_BYTES_VALUE;
}
sink.log(logLevel, this.logFormat, message);
}
}
| 1,673 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/StructuredLogMessage.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
class StructuredLogMessage {
public String timestamp;
public String message;
public LogLevel level;
public String AWSRequestId;
}
| 1,674 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/AbstractLambdaLogger.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import static java.nio.charset.StandardCharsets.UTF_8;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
/**
* Provides default implementation of the convenience logger functions.
* When extending AbstractLambdaLogger, only one function has to be overridden:
* void logMessage(byte[] message, LogLevel logLevel);
*/
public abstract class AbstractLambdaLogger implements LambdaLogger {
private final LogFiltering logFiltering;
private final LogFormatter logFormatter;
protected final LogFormat logFormat;
public AbstractLambdaLogger(LogLevel logLevel, LogFormat logFormat) {
this.logFiltering = new LogFiltering(logLevel);
this.logFormat = logFormat;
if (logFormat == LogFormat.JSON) {
logFormatter = new JsonLogFormatter();
} else {
logFormatter = new TextLogFormatter();
}
}
protected abstract void logMessage(byte[] message, LogLevel logLevel);
protected void logMessage(String message, LogLevel logLevel) {
byte[] messageBytes = message == null ? null : message.getBytes(UTF_8);
logMessage(messageBytes, logLevel);
}
@Override
public void log(String message, LogLevel logLevel) {
if (logFiltering.isEnabled(logLevel)) {
this.logMessage(logFormatter.format(message, logLevel), logLevel);
}
}
@Override
public void log(byte[] message, LogLevel logLevel) {
if (logFiltering.isEnabled(logLevel)) {
// there is no formatting for byte[] messages
this.logMessage(message, logLevel);
}
}
@Override
public void log(String message) {
this.log(message, LogLevel.UNDEFINED);
}
@Override
public void log(byte[] message) {
this.log(message, LogLevel.UNDEFINED);
}
public void setLambdaContext(LambdaContext lambdaContext) {
this.logFormatter.setLambdaContext(lambdaContext);
}
}
| 1,675 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/StdOutLogSink.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import java.io.IOException;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
public class StdOutLogSink implements LogSink {
@Override
public void log(byte[] message) {
log(LogLevel.UNDEFINED, LogFormat.TEXT, message);
}
public void log(LogLevel logLevel, LogFormat logFormat, byte[] message) {
try {
System.out.write(message);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void close() {
}
}
| 1,676 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/LogFiltering.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
public class LogFiltering {
private final LogLevel minimumLogLevel;
public LogFiltering(LogLevel minimumLogLevel) {
this.minimumLogLevel = minimumLogLevel;
}
boolean isEnabled(LogLevel logLevel) {
return (logLevel == LogLevel.UNDEFINED || logLevel.ordinal() >= minimumLogLevel.ordinal());
}
}
| 1,677 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/LogFormatter.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
public interface LogFormatter {
String format(String message, LogLevel logLevel);
default void setLambdaContext(LambdaContext context) {
};
}
| 1,678 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/FramedTelemetryLogSink.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.time.Instant;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
/**
* FramedTelemetryLogSink implements the logging contract between runtimes and the platform. It implements a simple
* framing protocol so message boundaries can be determined. Each frame can be visualized as follows:
*
* <pre>
* {@code
* +----------------------+------------------------+---------------------+-----------------------+
* | Frame Type - 4 bytes | Length (len) - 4 bytes | Timestamp - 8 bytes | Message - 'len' bytes |
* +----------------------+------------------------+---------------------+-----------------------+
* }
* </pre>
* <p>
* The first 4 bytes indicate the type of the frame - log frames have a type defined as the hex value 0xa55a0001. The
* second 4 bytes should indicate the message's length. The next 8 bytes contain UNIX timestamp of the message in
* microsecond accuracy. The next 'len' bytes contain the message. The byte order is big-endian.
*/
public class FramedTelemetryLogSink implements LogSink {
private static final int HEADER_LENGTH = 16;
private final FileOutputStream logOutputStream;
private final ByteBuffer headerBuf;
public FramedTelemetryLogSink(FileDescriptor fd) throws IOException {
this.logOutputStream = new FileOutputStream(fd);
this.headerBuf = ByteBuffer.allocate(HEADER_LENGTH).order(ByteOrder.BIG_ENDIAN);
}
@Override
public synchronized void log(LogLevel logLevel, LogFormat logFormat, byte[] message) {
try {
writeFrame(logLevel, logFormat, message);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void log(byte[] message) {
log(LogLevel.UNDEFINED, LogFormat.TEXT, message);
}
private void writeFrame(LogLevel logLevel, LogFormat logFormat, byte[] message) throws IOException {
updateHeader(logLevel, logFormat, message.length);
this.logOutputStream.write(this.headerBuf.array());
this.logOutputStream.write(message);
}
private long timestamp() {
Instant instant = Instant.now();
return instant.getEpochSecond() * 1_000_000 + instant.getNano() / 1000; // microsecond precision
}
/**
* Updates the header ByteBuffer with the provided length. The header comprises the frame type and message length.
*/
private void updateHeader(LogLevel logLevel, LogFormat logFormat, int length) {
this.headerBuf.clear();
this.headerBuf.putInt(FrameType.getValue(logLevel, logFormat));
this.headerBuf.putInt(length);
this.headerBuf.putLong(timestamp());
this.headerBuf.flip();
}
@Override
public void close() throws IOException {
this.logOutputStream.close();
}
}
| 1,679 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/LogSink.java | /* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import java.io.Closeable;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.logging.LogFormat;
public interface LogSink extends Closeable {
void log(byte[] message);
void log(LogLevel logLevel, LogFormat logFormat, byte[] message);
}
| 1,680 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/JsonLogFormatter.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import com.amazonaws.services.lambda.runtime.serialization.PojoSerializer;
import com.amazonaws.services.lambda.runtime.serialization.factories.GsonFactory;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
public class JsonLogFormatter implements LogFormatter {
private final PojoSerializer<StructuredLogMessage> serializer = GsonFactory.getInstance().getSerializer(StructuredLogMessage.class);
private LambdaContext lambdaContext;
private static final DateTimeFormatter dateFormatter =
DateTimeFormatter
.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
.withZone(ZoneId.of("UTC"));
@Override
public String format(String message, LogLevel logLevel) {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
StructuredLogMessage msg = createLogMessage(message, logLevel);
serializer.toJson(msg, stream);
stream.write('\n');
return new String(stream.toByteArray(), StandardCharsets.UTF_8);
}
private StructuredLogMessage createLogMessage(String message, LogLevel logLevel) {
StructuredLogMessage msg = new StructuredLogMessage();
msg.timestamp = dateFormatter.format(LocalDateTime.now());
msg.message = message;
msg.level = logLevel;
if (lambdaContext != null) {
msg.AWSRequestId = lambdaContext.getAwsRequestId();
}
return msg;
}
/**
* Function to set the context for every invocation.
* This way the logger will be able to attach additional information to the log packet.
*/
@Override
public void setLambdaContext(LambdaContext context) {
this.lambdaContext = context;
}
}
| 1,681 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client | Create_ds/aws-lambda-java-libs/aws-lambda-java-runtime-interface-client/src/main/java/com/amazonaws/services/lambda/runtime/api/client/logging/TextLogFormatter.java | /* Copyright 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved. */
package com.amazonaws.services.lambda.runtime.api.client.logging;
import com.amazonaws.services.lambda.runtime.api.client.api.LambdaContext;
import com.amazonaws.services.lambda.runtime.logging.LogLevel;
import java.util.HashMap;
public class TextLogFormatter implements LogFormatter {
private static final HashMap<LogLevel, String> logLevelMapper = new HashMap<LogLevel, String>() {{
for (LogLevel logLevel: LogLevel.values()) {
put(logLevel, "[" + logLevel.toString() + "] ");
}
}};
@Override
public String format(String message, LogLevel logLevel) {
if (logLevel == LogLevel.UNDEFINED) {
return message;
}
return new StringBuilder()
.append(logLevelMapper.get(logLevel))
.append(message)
.toString();
}
}
| 1,682 |
0 | Create_ds/aws-lambda-java-libs/samples/kinesis-firehose-event-handler/src/test/java | Create_ds/aws-lambda-java-libs/samples/kinesis-firehose-event-handler/src/test/java/example/KinesisFirehoseEventHandlerTest.java | package example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.events.KinesisAnalyticsInputPreprocessingResponse;
import com.amazonaws.services.lambda.runtime.events.KinesisFirehoseEvent;
import com.amazonaws.services.lambda.runtime.tests.annotations.Event;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.params.ParameterizedTest;
import static java.nio.charset.StandardCharsets.UTF_8;
public class KinesisFirehoseEventHandlerTest {
private Context context; // intentionally null as it's not used in the test
@ParameterizedTest
@Event(value = "event.json", type = KinesisFirehoseEvent.class)
public void testEventHandler(KinesisFirehoseEvent event) {
KinesisFirehoseEventHandler kinesisFirehoseEventHandler = new KinesisFirehoseEventHandler();
KinesisAnalyticsInputPreprocessingResponse response = kinesisFirehoseEventHandler.handleRequest(event, context);
String expectedString = "\n!dlroW olleH";
KinesisAnalyticsInputPreprocessingResponse.Record firstRecord = response.getRecords().get(0);
Assertions.assertEquals(expectedString, UTF_8.decode(firstRecord.getData()).toString());
Assertions.assertEquals(KinesisAnalyticsInputPreprocessingResponse.Result.Ok, firstRecord.getResult());
}
} | 1,683 |
0 | Create_ds/aws-lambda-java-libs/samples/kinesis-firehose-event-handler/src/main/java | Create_ds/aws-lambda-java-libs/samples/kinesis-firehose-event-handler/src/main/java/example/KinesisFirehoseEventHandler.java | package example;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.KinesisAnalyticsInputPreprocessingResponse;
import com.amazonaws.services.lambda.runtime.events.KinesisFirehoseEvent;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import static com.amazonaws.services.lambda.runtime.events.KinesisAnalyticsInputPreprocessingResponse.Result.Ok;
import static java.nio.charset.StandardCharsets.UTF_8;
/**
* A sample KinesisFirehoseEvent handler
*
* For more information see the developer guide - https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html
*/
public class KinesisFirehoseEventHandler implements RequestHandler<KinesisFirehoseEvent, KinesisAnalyticsInputPreprocessingResponse> {
@Override
public KinesisAnalyticsInputPreprocessingResponse handleRequest(KinesisFirehoseEvent kinesisFirehoseEvent, Context context) {
List<KinesisAnalyticsInputPreprocessingResponse.Record> records = new ArrayList<>();
for (KinesisFirehoseEvent.Record record : kinesisFirehoseEvent.getRecords()) {
String recordData = new String(record.getData().array());
// Your business logic
String reversedString = new StringBuilder(recordData).reverse().toString();
records.add(new KinesisAnalyticsInputPreprocessingResponse.Record(record.getRecordId(), Ok, ByteBuffer.wrap(reversedString.getBytes(UTF_8))));
}
return new KinesisAnalyticsInputPreprocessingResponse(records);
}
}
| 1,684 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/DynamodbEventTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1;
import com.amazonaws.services.dynamodbv2.model.Record;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbRecordTransformerTest.record_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbRecordTransformerTest.record_v1;
public class DynamodbEventTransformerTest {
private final DynamodbEvent dynamodbEvent;
{
record_event.setEventSourceARN("arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899");
dynamodbEvent = new DynamodbEvent();
dynamodbEvent.setRecords(Collections.singletonList(record_event));
}
private final List<Record> expectedRecordsV2 = Collections.singletonList(record_v1);
@Test
public void testDynamodbEventToRecordsV2() {
List<Record> convertedRecords = DynamodbEventTransformer.toRecordsV1(dynamodbEvent);
Assertions.assertEquals(expectedRecordsV2, convertedRecords);
}
@Test
public void testDynamodbEventToRecordsV2_FiltersNullRecords() {
DynamodbEvent event = dynamodbEvent.clone();
event.setRecords(Arrays.asList(record_event, null));
Assertions.assertEquals(2, event.getRecords().size());
List<Record> convertedRecords = DynamodbEventTransformer.toRecordsV1(event);
Assertions.assertEquals(expectedRecordsV2, convertedRecords);
Assertions.assertEquals(1, convertedRecords.size());
}
} | 1,685 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbAttributeValueTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
class DynamodbAttributeValueTransformerTest {
private static final String valueN = "101";
private static final List<String> valueNS = Arrays.asList("1", "2", "3");
private static final String valueS = "SVal";
private static final List<String> valueSS = Arrays.asList("first", "second", "third");
private static final ByteBuffer valueB = ByteBuffer.wrap("BVal".getBytes());
private static final List<ByteBuffer> valueBS = Arrays.asList(
ByteBuffer.wrap("first".getBytes()),
ByteBuffer.wrap("second".getBytes()),
ByteBuffer.wrap("third".getBytes()));
private static final boolean valueBOOL = true;
private static final boolean valueNUL = true;
private static final String keyM1 = "NestedMapKey1";
private static final String keyM2 = "NestedMapKey2";
//region AttributeValue_event
public static final AttributeValue attributeValueN_event = new AttributeValue().withN(valueN);
public static final AttributeValue attributeValueNS_event = new AttributeValue().withNS(valueNS);
public static final AttributeValue attributeValueS_event = new AttributeValue().withS(valueS);
public static final AttributeValue attributeValueSS_event = new AttributeValue().withSS(valueSS);
public static final AttributeValue attributeValueB_event = new AttributeValue().withB(valueB);
public static final AttributeValue attributeValueBS_event = new AttributeValue().withBS(valueBS);
public static final AttributeValue attributeValueBOOL_event = new AttributeValue().withBOOL(valueBOOL);
public static final AttributeValue attributeValueNUL_event = new AttributeValue().withNULL(valueNUL);
public static final AttributeValue attributeValueM_event = new AttributeValue().withM(new HashMap<String, AttributeValue>() {{
put(keyM1, attributeValueN_event);
put(keyM2, attributeValueS_event);
}});
public static final AttributeValue attributeValueL_event = new AttributeValue().withL(Arrays.asList(
attributeValueN_event,
attributeValueNS_event,
attributeValueS_event,
attributeValueSS_event,
attributeValueB_event,
attributeValueBS_event,
attributeValueBOOL_event,
attributeValueNUL_event,
attributeValueM_event,
new AttributeValue().withL(Arrays.asList(
attributeValueN_event,
attributeValueNS_event,
attributeValueS_event,
attributeValueSS_event,
attributeValueB_event,
attributeValueBS_event,
attributeValueBOOL_event,
attributeValueNUL_event,
attributeValueM_event
))
));
//endregion
//region AttributeValue_v1
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueN_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withN(valueN);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueNS_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withNS(valueNS);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueS_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withS(valueS);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueSS_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withSS(valueSS);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueB_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withB(valueB);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueBS_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withBS(valueBS);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueBOOL_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withBOOL(valueBOOL);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueNUL_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withNULL(valueNUL);
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueM_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withM(new HashMap<String, com.amazonaws.services.dynamodbv2.model.AttributeValue>() {{
put(keyM1, attributeValueN_v1);
put(keyM2, attributeValueS_v1);
}});
public static final com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValueL_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withL(Arrays.asList(
attributeValueN_v1,
attributeValueNS_v1,
attributeValueS_v1,
attributeValueSS_v1,
attributeValueB_v1,
attributeValueBS_v1,
attributeValueBOOL_v1,
attributeValueNUL_v1,
attributeValueM_v1,
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withL(Arrays.asList(
attributeValueN_v1,
attributeValueNS_v1,
attributeValueS_v1,
attributeValueSS_v1,
attributeValueB_v1,
attributeValueBS_v1,
attributeValueBOOL_v1,
attributeValueNUL_v1,
attributeValueM_v1
))
));
//endregion
@Test
public void testToAttributeValueV1_N() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueN =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueN_event);
Assertions.assertEquals(attributeValueN_v1, convertedAttributeValueN);
}
@Test
public void testToAttributeValueV1_NS() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueNS =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueNS_event);
Assertions.assertEquals(attributeValueNS_v1, convertedAttributeValueNS);
}
@Test
public void testToAttributeValueV1_S() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueS =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueS_event);
Assertions.assertEquals(attributeValueS_v1, convertedAttributeValueS);
}
@Test
public void testToAttributeValueV1_SS() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueSS =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueSS_event);
Assertions.assertEquals(attributeValueSS_v1, convertedAttributeValueSS);
}
@Test
public void testToAttributeValueV1_B() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueB =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueB_event);
Assertions.assertEquals(attributeValueB_v1, convertedAttributeValueB);
}
@Test
public void testToAttributeValueV1_BS() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueBS =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueBS_event);
Assertions.assertEquals(attributeValueBS_v1, convertedAttributeValueBS);
}
@Test
public void testToAttributeValueV1_BOOL() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueBOOL =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueBOOL_event);
Assertions.assertEquals(attributeValueBOOL_v1, convertedAttributeValueBOOL);
}
@Test
public void testToAttributeValueV1_NUL() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueNUL =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueNUL_event);
Assertions.assertEquals(attributeValueNUL_v1, convertedAttributeValueNUL);
}
@Test
public void testToAttributeValueV1_M() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueM =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueM_event);
Assertions.assertEquals(attributeValueM_v1, convertedAttributeValueM);
}
@Test
public void testToAttributeValueV1_L() {
com.amazonaws.services.dynamodbv2.model.AttributeValue convertedAttributeValueL =
DynamodbAttributeValueTransformer.toAttributeValueV1(attributeValueL_event);
Assertions.assertEquals(attributeValueL_v1, convertedAttributeValueL);
Assertions.assertEquals("ArrayList", convertedAttributeValueL.getL().getClass().getSimpleName(), "List is mutable");
}
@Test
public void testToAttributeValueV1_IllegalArgumentWhenNull() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue())
);
}
@Test
public void testToAttributeValueV1_IllegalArgumentWhenNull_N() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withN(null))
);
}
@Test
public void testToAttributeValueV1_IllegalArgumentWhenNull_S() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withS(null))
);
}
@Test
public void testToAttributeValueV1_IllegalArgumentWhenNull_B() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withB(null))
);
}
@Test
public void testToAttributeValueV1_IllegalArgumentWhenNull_BOOL() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withBOOL(null))
);
}
@Test
public void testToAttributeValueV1_IllegalArgumentWhenNull_NUL() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withNULL(null))
);
}
@Test
public void testToAttributeValueV1_IllegalArgumentWhenNull_M() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withM(null))
);
}
@Test
public void testToAttributeValueV1_DoesNotThrowWhenEmpty_NS() {
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withNS())
);
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withNS(Collections.emptyList()))
);
}
@Test
public void testToAttributeValueV1_DoesNotThrowWhenEmpty_SS() {
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withSS())
);
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withSS(Collections.emptyList()))
);
}
@Test
public void testToAttributeValueV1_DoesNotThrowWhenEmpty_BS() {
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withBS())
);
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withBS(Collections.emptyList()))
);
}
@Test
public void testToAttributeValueV1_DoesNotThrowWhenEmpty_L() {
Assertions.assertDoesNotThrow(() -> {
com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValue = DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withL());
Assertions.assertEquals("ArrayList", attributeValue.getL().getClass().getSimpleName(), "List is mutable");
});
Assertions.assertDoesNotThrow(() -> {
com.amazonaws.services.dynamodbv2.model.AttributeValue attributeValue = DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withL(Collections.emptyList()));
Assertions.assertEquals("ArrayList", attributeValue.getL().getClass().getSimpleName(), "List is mutable");
});
}
@Test
public void testToAttributeValueV1_EmptyV1ObjectWhenEmpty_NS() {
com.amazonaws.services.dynamodbv2.model.AttributeValue expectedAttributeValue_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue();
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withNS()));
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withNS(Collections.emptyList())));
}
@Test
public void testToAttributeValueV1_EmptyV1ObjectWhenEmpty_SS() {
com.amazonaws.services.dynamodbv2.model.AttributeValue expectedAttributeValue_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue();
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withSS()));
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withSS(Collections.emptyList())));
}
@Test
public void testToAttributeValueV1_EmptyV1ObjectWhenEmpty_BS() {
com.amazonaws.services.dynamodbv2.model.AttributeValue expectedAttributeValue_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue();
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withBS()));
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withBS(Collections.emptyList())));
}
@Test
public void testToAttributeValueV1_EmptyV1ObjectWhenEmpty_L() {
com.amazonaws.services.dynamodbv2.model.AttributeValue expectedAttributeValue_v1 =
new com.amazonaws.services.dynamodbv2.model.AttributeValue().withL(Collections.emptyList());
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withL()));
Assertions.assertEquals(expectedAttributeValue_v1,
DynamodbAttributeValueTransformer.toAttributeValueV1(new AttributeValue().withL(Collections.emptyList())));
}
} | 1,686 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbRecordTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.dynamodbv2.model.OperationType;
import com.amazonaws.services.dynamodbv2.model.Record;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import com.amazonaws.services.lambda.runtime.events.transformers.v1.DynamodbEventTransformer;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbIdentityTransformerTest.identity_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbIdentityTransformerTest.identity_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbStreamRecordTransformerTest.streamRecord_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbStreamRecordTransformerTest.streamRecord_v1;
public class DynamodbRecordTransformerTest {
private static final String eventId = "2";
private static final String eventName = OperationType.MODIFY.toString();
private static final String eventVersion = "1.0";
private static final String eventSource = "aws:dynamodb";
private static final String awsRegion = "us-west-2";
//region Record_event
public static final DynamodbEvent.DynamodbStreamRecord record_event = (DynamodbEvent.DynamodbStreamRecord)
new DynamodbEvent.DynamodbStreamRecord()
.withEventID(eventId)
.withEventName(eventName)
.withEventVersion(eventVersion)
.withEventSource(eventSource)
.withAwsRegion(awsRegion)
.withDynamodb(streamRecord_event)
.withUserIdentity(identity_event);
//endregion
//region Record_v1
public static final Record record_v1 =
new Record()
.withEventID(eventId)
.withEventName(eventName)
.withEventVersion(eventVersion)
.withEventSource(eventSource)
.withAwsRegion(awsRegion)
.withDynamodb(streamRecord_v1)
.withUserIdentity(identity_v1);
//endregion
@Test
public void testToRecordV1() {
Record convertedRecord = DynamodbRecordTransformer.toRecordV1(record_event);
Assertions.assertEquals(record_v1, convertedRecord);
}
@Test
public void testToRecordV1WhenUserIdentityIsNull() {
DynamodbEvent.DynamodbStreamRecord record = record_event.clone();
record.setUserIdentity(null);
Assertions.assertDoesNotThrow(() -> {
com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbRecordTransformer.toRecordV1(record);
});
}
} | 1,687 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbIdentityTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.dynamodbv2.model.Identity;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
class DynamodbIdentityTransformerTest {
private static final String principalId = "1234567890";
private static final String identityType = "type";
//region Identity_event
public static final com.amazonaws.services.lambda.runtime.events.models.dynamodb.Identity identity_event = new com.amazonaws.services.lambda.runtime.events.models.dynamodb.Identity()
.withPrincipalId(principalId)
.withType(identityType);
//endregion
//region Identity_v1
public static final Identity identity_v1 = new Identity()
.withPrincipalId(principalId)
.withType(identityType);
//endregion
@Test
public void testToIdentityV1() {
Identity convertedIdentity = DynamodbIdentityTransformer.toIdentityV1(identity_event);
Assertions.assertEquals(identity_v1, convertedIdentity);
}
} | 1,688 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbStreamRecordTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.dynamodbv2.model.StreamRecord;
import com.amazonaws.services.dynamodbv2.model.StreamViewType;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.Date;
import java.util.HashMap;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBOOL_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBOOL_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBS_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueB_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueB_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueL_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueL_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueM_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueM_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNS_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNUL_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNUL_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueN_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueN_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueSS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueSS_v1;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueS_v1;
class DynamodbStreamRecordTransformerTest {
private static final String keyNK = "Id";
private static final String keyNSK = "KeyNS";
private static final String keySK = "SKey";
private static final String keySSK = "KeySS";
private static final String keyBK = "BKey";
private static final String keyBSK = "KeyBS";
private static final String keyBOOLK = "IsBool";
private static final String keyNULK = "nil";
private static final String keyMK = "MapKey";
private static final String keyLK = "LongNum";
private static final String oldImageSK = "Message";
private static final String newImageSK = "Message";
private static final String streamViewType = StreamViewType.NEW_AND_OLD_IMAGES.toString();
private static final String sequenceNumber = "222";
private static final Long sizeBytes = 59L;
private static final Date approximateCreationDateTime = new Date();
//region StreamRecord_event
public static final com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord streamRecord_event = new com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord()
.withKeys(new HashMap<String, com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue>() {
{
put(keyNK, attributeValueN_event);
put(keyNSK, attributeValueNS_event);
put(keySK, attributeValueS_event);
put(keySSK, attributeValueSS_event);
put(keyBK, attributeValueB_event);
put(keyBSK, attributeValueBS_event);
put(keyBOOLK, attributeValueBOOL_event);
put(keyNULK, attributeValueNUL_event);
put(keyMK, attributeValueM_event);
put(keyLK, attributeValueL_event);
}
})
.withOldImage(new HashMap<String, com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue>() {
{
put(oldImageSK, attributeValueS_event);
put(keyNK, attributeValueN_event);
}
})
.withNewImage(new HashMap<String, com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue>() {
{
put(newImageSK, attributeValueS_event);
put(keyNK, attributeValueN_event);
}
})
.withStreamViewType(com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamViewType.fromValue(streamViewType))
.withSequenceNumber(sequenceNumber)
.withSizeBytes(sizeBytes)
.withApproximateCreationDateTime(approximateCreationDateTime);
//endregion
//region StreamRecord_v1
public static final StreamRecord streamRecord_v1 = new StreamRecord()
.withApproximateCreationDateTime(approximateCreationDateTime)
.withKeys(new HashMap<String, com.amazonaws.services.dynamodbv2.model.AttributeValue>() {
{
put(keyNK, attributeValueN_v1);
put(keyNSK, attributeValueNS_v1);
put(keySK, attributeValueS_v1);
put(keySSK, attributeValueSS_v1);
put(keyBK, attributeValueB_v1);
put(keyBSK, attributeValueBS_v1);
put(keyBOOLK, attributeValueBOOL_v1);
put(keyNULK, attributeValueNUL_v1);
put(keyMK, attributeValueM_v1);
put(keyLK, attributeValueL_v1);
}
})
.withOldImage(new HashMap<String, com.amazonaws.services.dynamodbv2.model.AttributeValue>() {
{
put(oldImageSK, attributeValueS_v1);
put(keyNK, attributeValueN_v1);
}
})
.withNewImage(new HashMap<String, com.amazonaws.services.dynamodbv2.model.AttributeValue>() {
{
put(newImageSK, attributeValueS_v1);
put(keyNK, attributeValueN_v1);
}
})
.withSequenceNumber(sequenceNumber)
.withSizeBytes(sizeBytes)
.withStreamViewType(streamViewType);
//endregion
@Test
public void testToStreamRecordV1() {
StreamRecord convertedStreamRecord = DynamodbStreamRecordTransformer.toStreamRecordV1(streamRecord_event);
Assertions.assertEquals(streamRecord_v1, convertedStreamRecord);
}
@Test
public void testToStreamRecordV1WhenOldImageIsNull() {
com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord streamRecord = streamRecord_event.clone();
streamRecord.setOldImage(null);
Assertions.assertDoesNotThrow(() -> {
com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbStreamRecordTransformer.toStreamRecordV1(streamRecord);
});
}
@Test
public void testToStreamRecordV1WhenNewImageIsNull() {
com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord streamRecord = streamRecord_event.clone();
streamRecord.setNewImage(null);
Assertions.assertDoesNotThrow(() -> {
com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbStreamRecordTransformer.toStreamRecordV1(streamRecord);
});
}
} | 1,689 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2/DynamodbEventTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v2;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import software.amazon.awssdk.services.dynamodb.model.Record;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbRecordTransformerTest.record_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbRecordTransformerTest.record_v2;
public class DynamodbEventTransformerTest {
private final DynamodbEvent dynamodbEvent;
{
record_event.setEventSourceARN("arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899");
dynamodbEvent = new DynamodbEvent();
dynamodbEvent.setRecords(Collections.singletonList(record_event));
}
private final List<Record> expectedRecordsV2 = Collections.singletonList(record_v2);
@Test
public void testDynamodbEventToRecordsV2() {
List<Record> convertedRecords = DynamodbEventTransformer.toRecordsV2(dynamodbEvent);
Assertions.assertEquals(expectedRecordsV2, convertedRecords);
}
@Test
public void testDynamodbEventToRecordsV2_FiltersNullRecords() {
DynamodbEvent event = dynamodbEvent.clone();
event.setRecords(Arrays.asList(record_event, null));
Assertions.assertEquals(2, event.getRecords().size());
List<Record> convertedRecords = DynamodbEventTransformer.toRecordsV2(event);
Assertions.assertEquals(expectedRecordsV2, convertedRecords);
Assertions.assertEquals(1, convertedRecords.size());
}
} | 1,690 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2/dynamodb/DynamodbAttributeValueTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb;
import com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.utils.ImmutableMap;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
class DynamodbAttributeValueTransformerTest {
private static final String valueN = "101";
private static final List<String> valueNS = Arrays.asList("1", "2", "3");
private static final String valueS = "SVal";
private static final List<String> valueSS = Arrays.asList("first", "second", "third");
private static final ByteBuffer valueB = ByteBuffer.wrap("BVal".getBytes());
private static final List<ByteBuffer> valueBS = Arrays.asList(
ByteBuffer.wrap("first".getBytes()),
ByteBuffer.wrap("second".getBytes()),
ByteBuffer.wrap("third".getBytes()));
private static final boolean valueBOOL = true;
private static final boolean valueNUL = true;
private static final String keyM1 = "NestedMapKey1";
private static final String keyM2 = "NestedMapKey2";
//region AttributeValue_event
public static final AttributeValue attributeValueN_event = new AttributeValue().withN(valueN);
public static final AttributeValue attributeValueNS_event = new AttributeValue().withNS(valueNS);
public static final AttributeValue attributeValueS_event = new AttributeValue().withS(valueS);
public static final AttributeValue attributeValueSS_event = new AttributeValue().withSS(valueSS);
public static final AttributeValue attributeValueB_event = new AttributeValue().withB(valueB);
public static final AttributeValue attributeValueBS_event = new AttributeValue().withBS(valueBS);
public static final AttributeValue attributeValueBOOL_event = new AttributeValue().withBOOL(valueBOOL);
public static final AttributeValue attributeValueNUL_event = new AttributeValue().withNULL(valueNUL);
public static final AttributeValue attributeValueM_event = new AttributeValue().withM(ImmutableMap.of(
keyM1, attributeValueN_event,
keyM2, attributeValueS_event
));
public static final AttributeValue attributeValueL_event = new AttributeValue().withL(Arrays.asList(
attributeValueN_event,
attributeValueNS_event,
attributeValueS_event,
attributeValueSS_event,
attributeValueB_event,
attributeValueBS_event,
attributeValueBOOL_event,
attributeValueNUL_event,
attributeValueM_event,
new AttributeValue().withL(Arrays.asList(
attributeValueN_event,
attributeValueNS_event,
attributeValueS_event,
attributeValueSS_event,
attributeValueB_event,
attributeValueBS_event,
attributeValueBOOL_event,
attributeValueNUL_event,
attributeValueM_event
))
));
//endregion
//region AttributeValue_v2
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueN_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().n(valueN).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueNS_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().ns(valueNS).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueS_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().s(valueS).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueSS_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().ss(valueSS).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueB_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().b(SdkBytes.fromByteBuffer(valueB)).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueBS_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().bs(valueBS.stream()
.map(SdkBytes::fromByteBuffer)
.collect(Collectors.toList())).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueBOOL_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().bool(valueBOOL).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueNUL_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().nul(valueNUL).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueM_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().m(ImmutableMap.of(
keyM1, attributeValueN_v2,
keyM2, attributeValueS_v2
)).build();
public static final software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValueL_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().l(Arrays.asList(
attributeValueN_v2,
attributeValueNS_v2,
attributeValueS_v2,
attributeValueSS_v2,
attributeValueB_v2,
attributeValueBS_v2,
attributeValueBOOL_v2,
attributeValueNUL_v2,
attributeValueM_v2,
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().l(Arrays.asList(
attributeValueN_v2,
attributeValueNS_v2,
attributeValueS_v2,
attributeValueSS_v2,
attributeValueB_v2,
attributeValueBS_v2,
attributeValueBOOL_v2,
attributeValueNUL_v2,
attributeValueM_v2
)).build()
)).build();
//endregion
@Test
public void testToAttributeValueV2_N() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueN =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueN_event);
Assertions.assertEquals(attributeValueN_v2, convertedAttributeValueN);
}
@Test
public void testToAttributeValueV2_NS() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueNS =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueNS_event);
Assertions.assertEquals(attributeValueNS_v2, convertedAttributeValueNS);
}
@Test
public void testToAttributeValueV2_S() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueS =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueS_event);
Assertions.assertEquals(attributeValueS_v2, convertedAttributeValueS);
}
@Test
public void testToAttributeValueV2_SS() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueSS =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueSS_event);
Assertions.assertEquals(attributeValueSS_v2, convertedAttributeValueSS);
}
@Test
public void testToAttributeValueV2_B() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueB =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueB_event);
Assertions.assertEquals(attributeValueB_v2, convertedAttributeValueB);
}
@Test
public void testToAttributeValueV2_BS() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueBS =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueBS_event);
Assertions.assertEquals(attributeValueBS_v2, convertedAttributeValueBS);
}
@Test
public void testToAttributeValueV2_BOOL() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueBOOL =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueBOOL_event);
Assertions.assertEquals(attributeValueBOOL_v2, convertedAttributeValueBOOL);
}
@Test
public void testToAttributeValueV2_NUL() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueNUL =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueNUL_event);
Assertions.assertEquals(attributeValueNUL_v2, convertedAttributeValueNUL);
}
@Test
public void testToAttributeValueV2_M() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueM =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueM_event);
Assertions.assertEquals(attributeValueM_v2, convertedAttributeValueM);
}
@Test
public void testToAttributeValueV2_L() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue convertedAttributeValueL =
DynamodbAttributeValueTransformer.toAttributeValueV2(attributeValueL_event);
Assertions.assertEquals(attributeValueL_v2, convertedAttributeValueL);
Assertions.assertEquals("UnmodifiableRandomAccessList", convertedAttributeValueL.l().getClass().getSimpleName(), "List is immutable");
}
@Test
public void testToAttributeValueV2_IllegalArgumentWhenNull() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue())
);
}
@Test
public void testToAttributeValueV2_IllegalArgumentWhenNull_N() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withN(null))
);
}
@Test
public void testToAttributeValueV2_IllegalArgumentWhenNull_S() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withS(null))
);
}
@Test
public void testToAttributeValueV2_IllegalArgumentWhenNull_B() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withB(null))
);
}
@Test
public void testToAttributeValueV2_IllegalArgumentWhenNull_BOOL() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withBOOL(null))
);
}
@Test
public void testToAttributeValueV2_IllegalArgumentWhenNull_NUL() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withNULL(null))
);
}
@Test
public void testToAttributeValueV2_IllegalArgumentWhenNull_M() {
Assertions.assertThrows(IllegalArgumentException.class, () ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withM(null))
);
}
@Test
public void testToAttributeValueV2_DoesNotThrowWhenEmpty_NS() {
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withNS())
);
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withNS(Collections.emptyList()))
);
}
@Test
public void testToAttributeValueV2_DoesNotThrowWhenEmpty_SS() {
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withSS())
);
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withSS(Collections.emptyList()))
);
}
@Test
public void testToAttributeValueV2_DoesNotThrowWhenEmpty_BS() {
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withBS())
);
Assertions.assertDoesNotThrow(() ->
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withBS(Collections.emptyList()))
);
}
@Test
public void testToAttributeValueV2_DoesNotThrowWhenEmpty_L() {
Assertions.assertDoesNotThrow(() -> {
software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValue = DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withL());
Assertions.assertEquals("UnmodifiableRandomAccessList", attributeValue.l().getClass().getSimpleName(), "List is immutable");
});
Assertions.assertDoesNotThrow(() -> {
software.amazon.awssdk.services.dynamodb.model.AttributeValue attributeValue = DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withL(Collections.emptyList()));
Assertions.assertEquals("UnmodifiableRandomAccessList", attributeValue.l().getClass().getSimpleName(), "List is immutable");
});
}
@Test
public void testToAttributeValueV2_EmptyV2ObjectWhenEmpty_NS() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue expectedAttributeValue_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().build();
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withNS()));
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withNS(Collections.emptyList())));
}
@Test
public void testToAttributeValueV2_EmptyV2ObjectWhenEmpty_SS() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue expectedAttributeValue_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().build();
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withSS()));
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withSS(Collections.emptyList())));
}
@Test
public void testToAttributeValueV2_EmptyV2ObjectWhenEmpty_BS() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue expectedAttributeValue_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().build();
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withBS()));
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withBS(Collections.emptyList())));
}
@Test
public void testToAttributeValueV2_EmptyV2ObjectWhenEmpty_L() {
software.amazon.awssdk.services.dynamodb.model.AttributeValue expectedAttributeValue_v2 =
software.amazon.awssdk.services.dynamodb.model.AttributeValue.builder().l(Collections.emptyList()).build();
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withL()));
Assertions.assertEquals(expectedAttributeValue_v2,
DynamodbAttributeValueTransformer.toAttributeValueV2(new AttributeValue().withL(Collections.emptyList())));
}
} | 1,691 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2/dynamodb/DynamodbRecordTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import software.amazon.awssdk.services.dynamodb.model.OperationType;
import software.amazon.awssdk.services.dynamodb.model.Record;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbIdentityTransformerTest.identity_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbIdentityTransformerTest.identity_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbStreamRecordTransformerTest.streamRecord_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbStreamRecordTransformerTest.streamRecord_v2;
public class DynamodbRecordTransformerTest {
private static final String eventId = "2";
private static final String eventName = OperationType.MODIFY.toString();
private static final String eventVersion = "1.0";
private static final String eventSource = "aws:dynamodb";
private static final String awsRegion = "us-west-2";
//region Record_event
public static final DynamodbEvent.DynamodbStreamRecord record_event = (DynamodbEvent.DynamodbStreamRecord)
new DynamodbEvent.DynamodbStreamRecord()
.withEventID(eventId)
.withEventName(eventName)
.withEventVersion(eventVersion)
.withEventSource(eventSource)
.withAwsRegion(awsRegion)
.withDynamodb(streamRecord_event)
.withUserIdentity(identity_event);
//endregion
//region Record_v2
public static final Record record_v2 =
Record.builder()
.eventID(eventId)
.eventName(eventName)
.eventVersion(eventVersion)
.eventSource(eventSource)
.awsRegion(awsRegion)
.dynamodb(streamRecord_v2)
.userIdentity(identity_v2)
.build();
//endregion
@Test
public void testToRecordV2() {
Record convertedRecord = DynamodbRecordTransformer.toRecordV2(record_event);
Assertions.assertEquals(record_v2, convertedRecord);
}
@Test
public void testToRecordV2WhenUserIdentityIsNull() {
DynamodbEvent.DynamodbStreamRecord record = record_event.clone();
record.setUserIdentity(null);
Assertions.assertDoesNotThrow(() -> {
DynamodbRecordTransformer.toRecordV2(record);
});
}
} | 1,692 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2/dynamodb/DynamodbIdentityTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import software.amazon.awssdk.services.dynamodb.model.Identity;
class DynamodbIdentityTransformerTest {
private static final String principalId = "1234567890";
private static final String identityType = "type";
//region Identity_event
public static final com.amazonaws.services.lambda.runtime.events.models.dynamodb.Identity identity_event =
new com.amazonaws.services.lambda.runtime.events.models.dynamodb.Identity()
.withPrincipalId(principalId)
.withType(identityType);
//endregion
//region Identity_v2
public static final Identity identity_v2 = Identity.builder()
.principalId(principalId)
.type(identityType)
.build();
//endregion
@Test
public void testToIdentityV2() {
Identity convertedIdentity = DynamodbIdentityTransformer.toIdentityV2(identity_event);
Assertions.assertEquals(identity_v2, convertedIdentity);
}
} | 1,693 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/test/java/com/amazonaws/services/lambda/runtime/events/transformers/v2/dynamodb/DynamodbStreamRecordTransformerTest.java | package com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb;
import com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue;
import com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamViewType;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import software.amazon.awssdk.services.dynamodb.model.StreamRecord;
import software.amazon.awssdk.utils.ImmutableMap;
import java.util.Date;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBOOL_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBOOL_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueBS_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueB_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueB_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueL_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueL_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueM_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueM_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNS_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNUL_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueNUL_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueN_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueN_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueSS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueSS_v2;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueS_event;
import static com.amazonaws.services.lambda.runtime.events.transformers.v2.dynamodb.DynamodbAttributeValueTransformerTest.attributeValueS_v2;
class DynamodbStreamRecordTransformerTest {
private static final String keyNK = "Id";
private static final String keyNSK = "KeyNS";
private static final String keySK = "SKey";
private static final String keySSK = "KeySS";
private static final String keyBK = "BKey";
private static final String keyBSK = "KeyBS";
private static final String keyBOOLK = "IsBool";
private static final String keyNULK = "nil";
private static final String keyMK = "MapKey";
private static final String keyLK = "LongNum";
private static final String oldImageSK = "Message";
private static final String newImageSK = "Message";
private static final String streamViewType = StreamViewType.NEW_AND_OLD_IMAGES.toString();
private static final String sequenceNumber = "222";
private static final Long sizeBytes = 59L;
private static final Date approximateCreationDateTime = new Date();
//region StreamRecord_event
public static final com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord streamRecord_event =
new com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord()
.withKeys(ImmutableMap.<String, AttributeValue>builder()
.put(keyNK, attributeValueN_event)
.put(keyNSK, attributeValueNS_event)
.put(keySK, attributeValueS_event)
.put(keySSK, attributeValueSS_event)
.put(keyBK, attributeValueB_event)
.put(keyBSK, attributeValueBS_event)
.put(keyBOOLK, attributeValueBOOL_event)
.put(keyNULK, attributeValueNUL_event)
.put(keyMK, attributeValueM_event)
.put(keyLK, attributeValueL_event)
.build()
)
.withOldImage(ImmutableMap.of(
oldImageSK, attributeValueS_event,
keyNK, attributeValueN_event
))
.withNewImage(ImmutableMap.of(
newImageSK, attributeValueS_event,
keyNK, attributeValueN_event
))
.withStreamViewType(StreamViewType.fromValue(streamViewType))
.withSequenceNumber(sequenceNumber)
.withSizeBytes(sizeBytes)
.withApproximateCreationDateTime(approximateCreationDateTime);
//endregion
//region StreamRecord_v2
public static final StreamRecord streamRecord_v2 = StreamRecord.builder()
.approximateCreationDateTime(approximateCreationDateTime.toInstant())
.keys(ImmutableMap.<String, software.amazon.awssdk.services.dynamodb.model.AttributeValue>builder()
.put(keyNK, attributeValueN_v2)
.put(keyNSK, attributeValueNS_v2)
.put(keySK, attributeValueS_v2)
.put(keySSK, attributeValueSS_v2)
.put(keyBK, attributeValueB_v2)
.put(keyBSK, attributeValueBS_v2)
.put(keyBOOLK, attributeValueBOOL_v2)
.put(keyNULK, attributeValueNUL_v2)
.put(keyMK, attributeValueM_v2)
.put(keyLK, attributeValueL_v2)
.build()
)
.oldImage(ImmutableMap.of(
oldImageSK, attributeValueS_v2,
keyNK, attributeValueN_v2
))
.newImage(ImmutableMap.of(
newImageSK, attributeValueS_v2,
keyNK, attributeValueN_v2
))
.sequenceNumber(sequenceNumber)
.sizeBytes(sizeBytes)
.streamViewType(streamViewType)
.build();
//endregion
@Test
public void testToStreamRecordV2() {
StreamRecord convertedStreamRecord = DynamodbStreamRecordTransformer.toStreamRecordV2(streamRecord_event);
Assertions.assertEquals(streamRecord_v2, convertedStreamRecord);
}
@Test
public void testToStreamRecordV2WhenOldImageIsNull() {
com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord streamRecord = streamRecord_event.clone();
streamRecord.setOldImage(null);
Assertions.assertDoesNotThrow(() -> {
DynamodbStreamRecordTransformer.toStreamRecordV2(streamRecord);
});
}
@Test
public void testToStreamRecordV2WhenNewImageIsNull() {
com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord streamRecord = streamRecord_event.clone();
streamRecord.setNewImage(null);
Assertions.assertDoesNotThrow(() -> {
DynamodbStreamRecordTransformer.toStreamRecordV2(streamRecord);
});
}
} | 1,694 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/DynamodbEventTransformer.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1;
import com.amazonaws.services.dynamodbv2.model.Record;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb.DynamodbRecordTransformer;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
public class DynamodbEventTransformer {
public static List<Record> toRecordsV1(final DynamodbEvent dynamodbEvent) {
return dynamodbEvent
.getRecords()
.stream()
.filter(record -> !Objects.isNull(record))
.map(DynamodbRecordTransformer::toRecordV1)
.collect(Collectors.toList());
}
}
| 1,695 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbIdentityTransformer.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.dynamodbv2.model.Identity;
public class DynamodbIdentityTransformer {
public static Identity toIdentityV1(final com.amazonaws.services.lambda.runtime.events.models.dynamodb.Identity identity) {
return new Identity()
.withPrincipalId(identity.getPrincipalId())
.withType(identity.getType());
}
}
| 1,696 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbAttributeValueTransformer.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
public class DynamodbAttributeValueTransformer {
public static AttributeValue toAttributeValueV1(final com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue value) {
if (Objects.nonNull(value.getS())) {
return new AttributeValue()
.withS(value.getS());
} else if (Objects.nonNull(value.getSS())) {
return new AttributeValue()
.withSS(value.getSS().isEmpty() ? null : value.getSS());
} else if (Objects.nonNull(value.getN())) {
return new AttributeValue()
.withN(value.getN());
} else if (Objects.nonNull(value.getNS())) {
return new AttributeValue()
.withNS(value.getNS().isEmpty() ? null : value.getNS());
} else if (Objects.nonNull(value.getB())) {
return new AttributeValue()
.withB(value.getB());
} else if (Objects.nonNull(value.getBS())) {
return new AttributeValue()
.withBS(value.getBS().isEmpty() ? null : value.getBS());
} else if (Objects.nonNull(value.getBOOL())) {
return new AttributeValue()
.withBOOL(value.getBOOL());
} else if (Objects.nonNull(value.getL())) {
return new AttributeValue()
.withL(value.getL().isEmpty()
? Collections.emptyList()
: value.getL().stream()
.map(DynamodbAttributeValueTransformer::toAttributeValueV1)
.collect(Collectors.toList()));
} else if (Objects.nonNull(value.getM())) {
return new AttributeValue()
.withM(toAttributeValueMapV1(value.getM()));
} else if (Objects.nonNull(value.getNULL())) {
return new AttributeValue()
.withNULL(value.getNULL());
} else {
throw new IllegalArgumentException(
String.format("Unsupported attributeValue type: %s", value));
}
}
public static Map<String, AttributeValue> toAttributeValueMapV1(
final Map<String, com.amazonaws.services.lambda.runtime.events.models.dynamodb.AttributeValue> attributeValueMap
) {
return attributeValueMap
.entrySet()
.stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
entry -> toAttributeValueV1(entry.getValue())
));
}
}
| 1,697 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbRecordTransformer.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.dynamodbv2.model.Record;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
public class DynamodbRecordTransformer {
public static Record toRecordV1(final DynamodbEvent.DynamodbStreamRecord record) {
return new Record()
.withAwsRegion(record.getAwsRegion())
.withDynamodb(
DynamodbStreamRecordTransformer.toStreamRecordV1(record.getDynamodb())
)
.withEventID(record.getEventID())
.withEventName(record.getEventName())
.withEventSource(record.getEventSource())
.withEventVersion(record.getEventVersion())
.withUserIdentity(
record.getUserIdentity() != null
? DynamodbIdentityTransformer.toIdentityV1(record.getUserIdentity())
: null
);
}
}
| 1,698 |
0 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1 | Create_ds/aws-lambda-java-libs/aws-lambda-java-events-sdk-transformer/src/main/java/com/amazonaws/services/lambda/runtime/events/transformers/v1/dynamodb/DynamodbStreamRecordTransformer.java | package com.amazonaws.services.lambda.runtime.events.transformers.v1.dynamodb;
import com.amazonaws.services.dynamodbv2.model.StreamRecord;
public class DynamodbStreamRecordTransformer {
public static StreamRecord toStreamRecordV1(final com.amazonaws.services.lambda.runtime.events.models.dynamodb.StreamRecord streamRecord) {
return new StreamRecord()
.withApproximateCreationDateTime(
streamRecord.getApproximateCreationDateTime()
)
.withKeys(
DynamodbAttributeValueTransformer.toAttributeValueMapV1(streamRecord.getKeys())
)
.withNewImage(
streamRecord.getNewImage() != null
? DynamodbAttributeValueTransformer.toAttributeValueMapV1(streamRecord.getNewImage())
: null
)
.withOldImage(
streamRecord.getOldImage() != null
? DynamodbAttributeValueTransformer.toAttributeValueMapV1(streamRecord.getOldImage())
: null
)
.withSequenceNumber(streamRecord.getSequenceNumber())
.withSizeBytes(streamRecord.getSizeBytes())
.withStreamViewType(streamRecord.getStreamViewType());
}
}
| 1,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.