Alternate entry point without Lambda (#308)

* Introduce another entrypoint for plugin without lambda dependency

* Refactor lambda wrapper and executable wrapper into different classes

* Fix spacing and naming

* Add more tests and change the way the wrapper outputs info

* Change Wrapper.java class, move image config to java plugin

* Don't create ExecutableHandlerWrapper when plugin version is not bumped and move start/end response to handlerwrapper.java class instead

* Fix merging with master

* Add missing constructors

* Change ExecutableHandlerWrapper.java to HandlerWrapperExecutable.java for backwards compatible unit tests excludes

* Change root logging level to Debug

Author: nina-ctrlv

.pre-commit-config.yaml

@@ -58,7 +58,7 @@ repos:
   - id: pytest-local
     name: pytest-local
     description: Run pytest in the local virtualenv
-    entry: pytest --cov=rpdk.java --doctest-modules tests/
+    entry: pytest --cov-report term-missing --cov=rpdk.java --doctest-modules tests/
     language: system
     # ignore all files, run on hard-coded modules instead
     pass_filenames: false

python/rpdk/java/codegen.py

@@ -1,6 +1,7 @@
 # pylint: disable=useless-super-delegation,too-many-locals
 # pylint doesn't recognize abstract methods
 import logging
+import os
 import shutil
 import xml.etree.ElementTree as ET  # nosec
 from collections import namedtuple
@@ -44,6 +45,7 @@ def wrapper(*args, **kwargs):
 DEFAULT_SETTINGS = {PROTOCOL_VERSION_SETTING: DEFAULT_PROTOCOL_VERSION}
 
 MINIMUM_JAVA_DEPENDENCY_VERSION = "2.0.0"
+MINIMUM_JAVA_DEPENDENCY_VERSION_EXECUTABLE_HANDLER_WRAPPER = "2.0.3"
 
 
 class JavaArchiveNotFoundError(SysExitRecommendedError):
@@ -67,6 +69,7 @@ class JavaLanguagePlugin(LanguagePlugin):
     RUNTIME = "java8"
     ENTRY_POINT = "{}.HandlerWrapper::handleRequest"
     TEST_ENTRY_POINT = "{}.HandlerWrapper::testEntrypoint"
+    EXECUTABLE_ENTRY_POINT = "{}.HandlerWrapperExecutable"
     CODE_URI = "./target/{}-1.0-SNAPSHOT.jar"
 
     def __init__(self):
@@ -166,19 +169,22 @@ def init(self, project):
         src = (project.root / "src" / "main" / "java").joinpath(*self.namespace)
         LOG.debug("Making source folder structure: %s", src)
         src.mkdir(parents=True, exist_ok=True)
+        resources = project.root / "src" / "resources"
+        LOG.debug("Making resources folder structure: %s", resources)
+        resources.mkdir(parents=True, exist_ok=True)
         tst = (project.root / "src" / "test" / "java").joinpath(*self.namespace)
         LOG.debug("Making test folder structure: %s", tst)
         tst.mkdir(parents=True, exist_ok=True)
 
         # initialize shared files
-        self.init_shared(project, src, tst)
+        self.init_shared(project, src, tst, resources)
 
         # write specialized generated files
         if self._is_aws_guided(project):
             self.init_guided_aws(project, src, tst)
 
     @logdebug
-    def init_shared(self, project, src, tst):
+    def init_shared(self, project, src, tst, resources):
         """Writing project configuration"""
         # .gitignore
         path = project.root / ".gitignore"
@@ -257,6 +263,12 @@ def init_shared(self, project, src, tst):
         )
         project.safewrite(path, contents)
 
+        # log4j2
+        path = resources / "log4j2.xml"
+        LOG.debug("Writing log4j2: %s", path)
+        contents = resource_stream(__name__, "data/log4j2.xml").read()
+        project.safewrite(path, contents)
+
         self.init_handlers(project, src, tst)
 
     @logdebug
@@ -304,6 +316,9 @@ def _init_settings(self, project):
         project.runtime = self.RUNTIME
         project.entrypoint = self.ENTRY_POINT.format(self.package_name)
         project.test_entrypoint = self.TEST_ENTRY_POINT.format(self.package_name)
+        project.executable_entrypoint = self.EXECUTABLE_ENTRY_POINT.format(
+            self.package_name
+        )
         project.settings.update(DEFAULT_SETTINGS)
 
     @staticmethod
@@ -345,9 +360,13 @@ def generate(self, project):
             package_name=self.package_name,
             operations=project.schema.get("handlers", {}).keys(),
             pojo_name="ResourceModel",
+            wrapper_parent="LambdaWrapper",
         )
         project.overwrite(path, contents)
 
+        # write generated handler integration with ExecutableWrapper
+        self._write_executable_wrapper_class(src, project)
+
         path = src / "BaseConfiguration.java"
         LOG.debug("Writing base configuration: %s", path)
         template = self.env.get_template("generate/BaseConfiguration.java")
@@ -403,6 +422,39 @@ def generate(self, project):
 
         LOG.debug("Generate complete")
 
+    def _write_executable_wrapper_class(self, src, project):
+        try:
+            java_plugin_dependency_version = self._get_java_plugin_dependency_version(
+                project
+            )
+            if (
+                java_plugin_dependency_version
+                >= MINIMUM_JAVA_DEPENDENCY_VERSION_EXECUTABLE_HANDLER_WRAPPER
+            ):
+                path = src / "HandlerWrapperExecutable.java"
+                LOG.debug("Writing handler wrapper: %s", path)
+                template = self.env.get_template("generate/HandlerWrapper.java")
+                contents = template.render(
+                    package_name=self.package_name,
+                    operations=project.schema.get("handlers", {}).keys(),
+                    pojo_name="ResourceModel",
+                    wrapper_parent="ExecutableWrapper",
+                )
+                project.overwrite(path, contents)
+            else:
+                LOG.info(
+                    "Please update your java plugin dependency to version "
+                    "%s or above in order to use "
+                    "the Executable Handler Wrapper feature.",
+                    MINIMUM_JAVA_DEPENDENCY_VERSION_EXECUTABLE_HANDLER_WRAPPER,
+                )
+        except JavaPluginNotFoundError:
+            LOG.info(
+                "Please make sure to have 'aws-cloudformation-rpdk-java-plugin' "
+                "to version %s or above.",
+                MINIMUM_JAVA_DEPENDENCY_VERSION,
+            )
+
     def _update_settings(self, project):
         try:
             java_plugin_dependency_version = self._get_java_plugin_dependency_version(
@@ -427,6 +479,15 @@ def _update_settings(self, project):
             project.settings[PROTOCOL_VERSION_SETTING] = DEFAULT_PROTOCOL_VERSION
             project.write_settings()
 
+        if (
+            hasattr(project, "executable_entrypoint")
+            and not project.executable_entrypoint
+        ):
+            project.executable_entrypoint = self.EXECUTABLE_ENTRY_POINT.format(
+                self.package_name
+            )
+            project.write_settings()
+
     @staticmethod
     def _find_jar(project):
         jar_glob = list(
@@ -490,3 +551,23 @@ def write_with_relative_path(path):
         for path in (project.root / "target" / "generated-sources").rglob("*"):
             if path.is_file():
                 write_with_relative_path(path)
+
+    @logdebug
+    def generate_image_build_config(self, project):
+        """Generating image build config"""
+
+        jar_path = self._find_jar(project)
+
+        dockerfile_path = (
+            os.path.dirname(os.path.realpath(__file__))
+            + "/data/build-image-src/Dockerfile-"
+            + project.runtime
+        )
+
+        project_path = project.root
+
+        return {
+            "executable_name": str(jar_path.relative_to(project.root)),
+            "dockerfile_path": dockerfile_path,
+            "project_path": str(project_path),
+        }

python/rpdk/java/data/build-image-src/Dockerfile-java11

@@ -0,0 +1,4 @@
+FROM openjdk:11-alpine
+ARG executable_name
+ADD ${executable_name} handler.jar
+ENTRYPOINT ["java", "-Xmx512M", "-cp", "handler.jar"]

python/rpdk/java/data/build-image-src/Dockerfile-java8

@@ -0,0 +1,4 @@
+FROM openjdk:8-alpine
+ARG executable_name
+ADD ${executable_name} handler.jar
+ENTRYPOINT ["java", "-Xmx512M", "-cp", "handler.jar"]

python/rpdk/java/data/log4j2.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+    <Appenders>
+        <Console name="Console" target="SYSTEM_OUT">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </Console>
+        <File name="APPLICATION" fileName="log/application.log">
+            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+        </File>
+    </Appenders>
+    <Loggers>
+        <Root level="DEBUG">
+            <AppenderRef ref="Console"/>
+            <AppenderRef ref="APPLICATION"/>
+        </Root>
+    </Loggers>
+</Configuration>

python/rpdk/java/templates/generate/HandlerWrapper.java

@@ -7,7 +7,7 @@
 import software.amazon.awssdk.regions.Region;
 import software.amazon.cloudformation.Action;
 import software.amazon.cloudformation.exceptions.BaseHandlerException;
-import software.amazon.cloudformation.LambdaWrapper;
+import software.amazon.cloudformation.{{ wrapper_parent }};
 import software.amazon.cloudformation.loggers.LambdaLogPublisher;
 import software.amazon.cloudformation.metrics.MetricsPublisher;
 import software.amazon.cloudformation.proxy.AmazonWebServicesClientProxy;
@@ -26,18 +26,23 @@
 import com.amazonaws.services.lambda.runtime.Context;
 import com.fasterxml.jackson.core.type.TypeReference;
 
+import java.io.BufferedReader;
 import java.io.IOException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.io.PrintStream;
 import java.nio.charset.Charset;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.UUID;
 
 import org.apache.commons.io.IOUtils;
 import org.json.JSONObject;
 
 
-public final class HandlerWrapper extends LambdaWrapper<{{ pojo_name }}, CallbackContext> {
+public class {{ "HandlerWrapper" if wrapper_parent == "LambdaWrapper" else "HandlerWrapperExecutable" }} extends {{ wrapper_parent }}<{{ pojo_name }}, CallbackContext> {
 
     private final Configuration configuration = new Configuration();
     private JSONObject resourceSchema;
@@ -50,7 +55,7 @@ public final class HandlerWrapper extends LambdaWrapper<{{ pojo_name }}, Callbac
         new TypeReference<ResourceHandlerTestPayload<{{ pojo_name }}, CallbackContext>>() {};
 
 
-    public HandlerWrapper() {
+    public {{ "HandlerWrapper" if wrapper_parent == "LambdaWrapper" else "HandlerWrapperExecutable" }}() {
         initialiseHandlers();
     }
 
@@ -62,11 +67,10 @@ private void initialiseHandlers() {
 
     @Override
     public ProgressEvent<{{ pojo_name }}, CallbackContext> invokeHandler(
-                final AmazonWebServicesClientProxy proxy,
-                final ResourceHandlerRequest<{{ pojo_name }}> request,
-                final Action action,
-                final CallbackContext callbackContext) {
-
+            final AmazonWebServicesClientProxy proxy,
+            final ResourceHandlerRequest<{{ pojo_name }}> request,
+            final Action action,
+            final CallbackContext callbackContext) {
         final String actionName = (action == null) ? "<null>" : action.toString(); // paranoia
         if (!handlers.containsKey(action))
             throw new RuntimeException("Unknown action " + actionName);
@@ -79,6 +83,9 @@ private void initialiseHandlers() {
         return result;
     }
 
+    {% if wrapper_parent == "LambdaWrapper" -%}
+
+
     public void testEntrypoint(
             final InputStream inputStream,
             final OutputStream outputStream,
@@ -108,8 +115,37 @@ public void testEntrypoint(
             response = ProgressEvent.defaultFailureHandler(e, HandlerErrorCode.InternalFailure);
         } finally {
             writeResponse(outputStream, response);
+            outputStream.close();
+        }
+    }
+    {% else %}
+    public static void main(String[] args) throws IOException {
+        if (args.length != 1){
+            System.exit(1);
+        }
+        final String outputFile = (UUID.randomUUID().toString() + ".txt");
+        try(FileOutputStream output = new FileOutputStream(outputFile)){
+            try(InputStream input=IOUtils.toInputStream(args[0],"UTF-8")){
+                new HandlerWrapperExecutable().handleRequest(input, output);
+                output.flush();
+            }
+        }
+        System.out.println("__CFN_RESOURCE_START_RESPONSE__");
+        readFileToSystemOut(outputFile);
+        System.out.println("__CFN_RESOURCE_END_RESPONSE__");
+    }
+
+private static void readFileToSystemOut(final String fileName) throws IOException {
+        //Create object of FileReader
+        final FileReader inputFile = new FileReader(fileName);
+        try(BufferedReader bufferReader = new BufferedReader(inputFile)) {
+            String line;
+            while ((line = bufferReader.readLine()) != null)   {
+                System.out.println(line);
+            }
         }
     }
+    {%- endif %}
 
     @Override
     public JSONObject provideResourceSchemaJSONObject() {

python/rpdk/java/templates/init/shared/pom.xml

@@ -32,6 +32,24 @@
             <version>1.18.4</version>
             <scope>provided</scope>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <version>2.13.3</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.13.3</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-slf4j-impl -->
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-slf4j-impl</artifactId>
+            <version>2.13.3</version>
+        </dependency>
 
         <!-- https://mvnrepository.com/artifact/org.assertj/assertj-core -->
         <dependency>