Add Support for AWS Lambda Function SDK V2

aws-sdk-v2/build.gradle.kts

@@ -24,6 +24,7 @@ dependencies {
     compileOnly(libs.awssdk.secretsmanager)
     compileOnly(libs.awssdk.servicediscovery)
     compileOnly(libs.awssdk.cloudwatchlogs)
+    compileOnly(libs.awssdk.lambda)
 
     // Tests
     testAnnotationProcessor(mn.micronaut.inject.java)
@@ -41,6 +42,7 @@ dependencies {
     testImplementation(libs.awssdk.sqs)
     testImplementation(libs.awssdk.ssm)
     testImplementation(libs.awssdk.rekognition)
+    testImplementation(libs.awssdk.lambda)
     testRuntimeOnly(libs.jcl.over.slf4j)
 
     testRuntimeOnly(mn.snakeyaml)

aws-sdk-v2/src/main/java/io/micronaut/aws/sdk/v2/service/lambda/LambdaClientFactory.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2017-2024 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 io.micronaut.aws.sdk.v2.service.lambda;
+
+import io.micronaut.aws.sdk.v2.service.AWSServiceConfiguration;
+import io.micronaut.aws.sdk.v2.service.AwsClientFactory;
+import io.micronaut.aws.ua.UserAgentProvider;
+import io.micronaut.context.annotation.Bean;
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.core.annotation.Internal;
+import io.micronaut.core.annotation.Nullable;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import software.amazon.awssdk.auth.credentials.AwsCredentialsProviderChain;
+import software.amazon.awssdk.http.SdkHttpClient;
+import software.amazon.awssdk.http.async.SdkAsyncHttpClient;
+import software.amazon.awssdk.regions.providers.AwsRegionProviderChain;
+import software.amazon.awssdk.services.lambda.LambdaAsyncClient;
+import software.amazon.awssdk.services.lambda.LambdaAsyncClientBuilder;
+import software.amazon.awssdk.services.lambda.LambdaClient;
+import software.amazon.awssdk.services.lambda.LambdaClientBuilder;
+
+/**
+ * Factory that creates {@link LambdaClient} and {@link LambdaAsyncClient}.
+ * @since 4.7.0
+ */
+@Factory
+@Internal
+class LambdaClientFactory extends AwsClientFactory<LambdaClientBuilder, LambdaAsyncClientBuilder, LambdaClient, LambdaAsyncClient> {
+    /**
+     * Constructor.
+     *
+     * @param credentialsProvider The credentials provider
+     * @param regionProvider      The region provider
+     * @param userAgentProvider User-Agent Provider
+     * @param awsServiceConfiguration  AWS Service Configuration
+     */
+    protected LambdaClientFactory(AwsCredentialsProviderChain credentialsProvider,
+                                  AwsRegionProviderChain regionProvider,
+                                  @Nullable UserAgentProvider userAgentProvider,
+                                  @Nullable @Named(LambdaClient.SERVICE_NAME) AWSServiceConfiguration awsServiceConfiguration) {
+        super(credentialsProvider, regionProvider, userAgentProvider, awsServiceConfiguration);
+    }
+
+    @Override
+    protected LambdaClientBuilder createSyncBuilder() {
+        return LambdaClient.builder();
+    }
+
+    @Override
+    protected LambdaAsyncClientBuilder createAsyncBuilder() {
+        return LambdaAsyncClient.builder();
+    }
+
+    @Override
+    @Singleton
+    public LambdaClientBuilder syncBuilder(SdkHttpClient httpClient) {
+        return super.syncBuilder(httpClient);
+    }
+
+    @Override
+    @Bean(preDestroy = "close")
+    @Singleton
+    public LambdaClient syncClient(LambdaClientBuilder builder) {
+        return super.syncClient(builder);
+    }
+
+    @Override
+    @Singleton
+    @Requires(beans = SdkAsyncHttpClient.class)
+    public LambdaAsyncClientBuilder asyncBuilder(SdkAsyncHttpClient httpClient) {
+        return super.asyncBuilder(httpClient);
+    }
+
+    @Override
+    @Bean(preDestroy = "close")
+    @Singleton
+    @Requires(beans = SdkAsyncHttpClient.class)
+    public LambdaAsyncClient asyncClient(LambdaAsyncClientBuilder builder) {
+        return super.asyncClient(builder);
+    }
+}

aws-sdk-v2/src/main/java/io/micronaut/aws/sdk/v2/service/lambda/package-info.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2017-2024 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.
+ */
+/**
+ * Lambda client factory.
+ * @author Luis Duarte
+ * @since 4.7.0
+ */
+@Requires(classes = {LambdaClient.class, LambdaAsyncClient.class})
+@Configuration
+package io.micronaut.aws.sdk.v2.service.lambda;
+
+import io.micronaut.context.annotation.Configuration;
+import io.micronaut.context.annotation.Requires;
+import software.amazon.awssdk.services.lambda.LambdaAsyncClient;
+import software.amazon.awssdk.services.lambda.LambdaClient;

aws-sdk-v2/src/test/groovy/io/micronaut/aws/sdk/v2/service/LambdaClientSpec.groovy

@@ -0,0 +1,20 @@
+package io.micronaut.aws.sdk.v2.service
+
+import software.amazon.awssdk.services.lambda.LambdaAsyncClient
+import software.amazon.awssdk.services.lambda.LambdaClient
+
+class LambdaClientSpec  extends ServiceClientSpec<LambdaClient, LambdaAsyncClient> {
+    @Override
+    protected String serviceName() {
+        return LambdaClient.SERVICE_NAME
+    }
+
+    @Override
+    protected LambdaClient getClient() {
+        applicationContext.getBean(LambdaClient)
+    }
+
+    protected LambdaAsyncClient getAsyncClient() {
+        applicationContext.getBean(LambdaAsyncClient)
+    }
+}

function-client-aws-v2/build.gradle.kts

@@ -0,0 +1,25 @@
+plugins {
+    id("io.micronaut.build.internal.aws-module")
+}
+
+dependencies {
+    api(projects.micronautAwsSdkV2)
+    implementation(libs.awssdk.lambda)
+    implementation(mn.reactor)
+    api(mn.micronaut.function.client)
+    implementation(mn.micronaut.jackson.databind)
+    testAnnotationProcessor(mn.micronaut.inject.java)
+    testImplementation(mn.micronaut.inject.java)
+    testImplementation(mnSerde.micronaut.serde.api)
+    testImplementation(mn.micronaut.http.server.netty)
+    testImplementation(mn.micronaut.function.web)
+    testImplementation(mnGroovy.micronaut.function.groovy)
+    testImplementation(mnGroovy.micronaut.runtime.groovy)
+    testImplementation(libs.commons.compress)
+    // TODO: Switch to Test Resources, once Lambda Client is also included in Service Override
+    implementation(platform(libs.boms.testcontainers))
+    implementation(libs.testcontainers)
+    implementation(libs.testcontainers.localstack)
+    implementation(libs.testcontainers.junit)
+    implementation(libs.testcontainers.spock)
+}

function-client-aws-v2/src/main/java/io/micronaut/function/client/aws/AwsInvokeRequestDefinition.java

@@ -0,0 +1,46 @@
+/*
+ * 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 io.micronaut.function.client.aws;
+
+import io.micronaut.context.annotation.EachProperty;
+import io.micronaut.context.annotation.Parameter;
+import io.micronaut.function.client.FunctionDefinition;
+
+/**
+ * Builds an {@link InvokeRequest} for each definition under {@code aws.lambda.functions}.
+ *
+ * @author graemerocher
+ * @since 1.0
+ */
+@EachProperty(AwsInvokeRequestDefinition.AWS_LAMBDA_FUNCTIONS)
+public class AwsInvokeRequestDefinition implements FunctionDefinition {
+    public static final String AWS_LAMBDA_FUNCTIONS = "aws.lambda.functions";
+
+    private final String name;
+
+    /**
+     * Constructor.
+     * @param name configured name from a property
+     */
+    public AwsInvokeRequestDefinition(@Parameter String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String getName() {
+        return this.name;
+    }
+}

function-client-aws-v2/src/main/java/io/micronaut/function/client/aws/AwsLambdaFunctionExecutor.java

@@ -0,0 +1,138 @@
+/*
+ * 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 io.micronaut.function.client.aws;
+
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.core.async.publisher.Publishers;
+import io.micronaut.core.convert.ConversionService;
+import io.micronaut.core.io.buffer.ByteBufferFactory;
+import io.micronaut.core.type.Argument;
+import io.micronaut.function.client.FunctionDefinition;
+import io.micronaut.function.client.FunctionInvoker;
+import io.micronaut.function.client.FunctionInvokerChooser;
+import io.micronaut.function.client.exceptions.FunctionExecutionException;
+import io.micronaut.jackson.codec.JsonMediaTypeCodec;
+import io.micronaut.scheduling.TaskExecutors;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+import software.amazon.awssdk.core.SdkBytes;
+import software.amazon.awssdk.services.lambda.LambdaAsyncClient;
+import software.amazon.awssdk.services.lambda.LambdaClient;
+import software.amazon.awssdk.services.lambda.model.InvokeRequest;
+import software.amazon.awssdk.services.lambda.model.InvokeResponse;
+
+import java.nio.ByteBuffer;
+import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+
+/**
+ * A {@link FunctionInvoker} for invoking functions on AWS.
+ *
+ * @param <I> input type
+ * @param <O> output type
+ * @author graemerocher
+ * @since 1.0
+ */
+@Requires(beans = LambdaAsyncClient.class)
+@Singleton
+public class AwsLambdaFunctionExecutor<I, O> implements FunctionInvoker<I, O>, FunctionInvokerChooser {
+
+    private static final int STATUS_CODE_ERROR = 300;
+    private final LambdaClient syncClient;
+    private final LambdaAsyncClient asyncClient;
+    private final ByteBufferFactory byteBufferFactory;
+    private final JsonMediaTypeCodec jsonMediaTypeCodec;
+    private final ExecutorService ioExecutor;
+
+    /**
+     * Constructor.
+     *
+     * @param asyncClient        asyncClient
+     * @param byteBufferFactory  byteBufferFactory
+     * @param jsonMediaTypeCodec jsonMediaTypeCodec
+     * @param ioExecutor         ioExecutor
+     */
+    protected AwsLambdaFunctionExecutor(
+        LambdaClient syncClient,
+        LambdaAsyncClient asyncClient,
+        ByteBufferFactory byteBufferFactory,
+        JsonMediaTypeCodec jsonMediaTypeCodec,
+        @Named(TaskExecutors.IO) ExecutorService ioExecutor) {
+        this.syncClient = syncClient;
+        this.asyncClient = asyncClient;
+        this.byteBufferFactory = byteBufferFactory;
+        this.jsonMediaTypeCodec = jsonMediaTypeCodec;
+        this.ioExecutor = ioExecutor;
+    }
+
+    @Override
+    public O invoke(FunctionDefinition definition, I input, Argument<O> outputType) {
+        if (!(definition instanceof AwsInvokeRequestDefinition)) {
+            throw new IllegalArgumentException("Function definition must be a AWSInvokeRequestDefinition");
+        }
+
+        boolean isReactiveType = Publishers.isConvertibleToPublisher(outputType.getType());
+        SdkBytes sdkBytes = encodeInput(input);
+        InvokeRequest invokeRequest = InvokeRequest.builder()
+            .functionName(definition.getName())
+            .payload(sdkBytes)
+            .build();
+        if (isReactiveType) {
+            Mono<Object> invokeFlowable = Mono.fromFuture(asyncClient.invoke(invokeRequest))
+                .map(invokeResult ->
+                    decodeResult(definition, (Argument<O>) outputType.getFirstTypeVariable().orElse(Argument.OBJECT_ARGUMENT), invokeResult))
+                .onErrorResume(throwable -> Mono.error(new FunctionExecutionException("Error executing AWS Lambda [" + definition.getName() + "]: " + throwable.getMessage(), throwable)))
+                .subscribeOn(Schedulers.fromExecutor(ioExecutor));
+            return ConversionService.SHARED.convert(invokeFlowable, outputType).orElseThrow(() -> new IllegalArgumentException("Unsupported Reactive type: " + outputType));
+        } else {
+            InvokeResponse invokeResult = syncClient.invoke(invokeRequest);
+            try {
+                return (O) decodeResult(definition, outputType, invokeResult);
+            } catch (Exception e) {
+                throw new FunctionExecutionException("Error executing AWS Lambda [" + definition.getName() + "]: " + e.getMessage(), e);
+            }
+        }
+    }
+
+    private Object decodeResult(FunctionDefinition definition, Argument<O> outputType, InvokeResponse invokeResult) {
+        Integer statusCode = invokeResult.statusCode();
+        if (statusCode >= STATUS_CODE_ERROR) {
+            throw new FunctionExecutionException("Error executing AWS Lambda [" + definition.getName() + "]: " + invokeResult.functionError());
+        }
+        io.micronaut.core.io.buffer.ByteBuffer byteBuffer = byteBufferFactory.copiedBuffer(invokeResult.payload().asByteArray());
+
+        return jsonMediaTypeCodec.decode(outputType, byteBuffer);
+    }
+
+    private SdkBytes encodeInput(I input) {
+        if (input != null) {
+            ByteBuffer nioBuffer = jsonMediaTypeCodec.encode(input, byteBufferFactory).asNioBuffer();
+            return SdkBytes.fromByteBuffer(nioBuffer);
+        }
+        return null;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <I1, O2> Optional<FunctionInvoker<I1, O2>> choose(FunctionDefinition definition) {
+        if (definition instanceof AwsInvokeRequestDefinition) {
+            return Optional.of((FunctionInvoker) this);
+        }
+        return Optional.empty();
+    }
+}

function-client-aws-v2/src/main/java/io/micronaut/function/client/aws/package-info.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2017-2024 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.
+ */
+/**
+ * Function AWS lamda configuration.
+ *
+ * @author graemerocher
+ * @since 1.0
+ */
+package io.micronaut.function.client.aws;
+