Merge pull request #283 from awslabs/core

Preparing for 1.4 release

Author: sapessi

aws-serverless-java-container-core/pom.xml

@@ -16,7 +16,6 @@
     </parent>
 
     <properties>
-        <jackson.version>2.9.9</jackson.version>
         <jaxrs.version>2.1</jaxrs.version>
         <servlet.version>3.1.0</servlet.version>
     </properties>
@@ -55,6 +54,12 @@
             <groupId>com.fasterxml.jackson.module</groupId>
             <artifactId>jackson-module-afterburner</artifactId>
             <version>${jackson.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.fasterxml.jackson.core</groupId>
+                    <artifactId>jackson-databind</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
 
 
@@ -86,6 +91,12 @@
             <version>4.4.10</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-web</artifactId>
+            <version>5.1.5.RELEASE</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -97,6 +108,9 @@
                 <configuration>
                     <destFile>${basedir}/target/coverage-reports/jacoco-unit.exec</destFile>
                     <dataFile>${basedir}/target/coverage-reports/jacoco-unit.exec</dataFile>
+                    <excludes>
+                        <exclude>com/amazonaws/serverless/proxy/internal/testutils/**</exclude>
+                    </excludes>
                 </configuration>
                 <executions>
                     <execution>
@@ -183,6 +197,7 @@
                         <suppressionFile>${project.basedir}/../owasp-suppression.xml</suppressionFile>
                     </suppressionFiles>
                     <failBuildOnCVSS>7</failBuildOnCVSS>
+                    <failOnError>false</failOnError>
                 </configuration>
                 <executions>
                     <execution>

aws-serverless-java-container-core/src/main/java/com/amazonaws/serverless/proxy/AsyncInitializationWrapper.java

@@ -0,0 +1,103 @@
+package com.amazonaws.serverless.proxy;
+
+import com.amazonaws.serverless.exceptions.ContainerInitializationException;
+import com.amazonaws.serverless.proxy.internal.LambdaContainerHandler;
+import com.amazonaws.services.lambda.runtime.Context;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Instant;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * An async implementation of the <code>InitializationWrapper</code> interface. This initializer calls the
+ * {@link LambdaContainerHandler#initialize()} in a separate thread. Then uses a latch to wait for the maximum Lambda
+ * initialization time of 10 seconds, if the <code>initialize</code> method takes longer than 10 seconds to return, the
+ * {@link #start(LambdaContainerHandler)} returns control to the caller and lets the initialization thread continue in
+ * the background. The {@link LambdaContainerHandler#proxy(Object, Context)} automatically waits for the latch of the
+ * initializer to be released.
+ *
+ * The constructor of this class expects an epoch long. This is meant to be as close as possible to the time the Lambda
+ * function actually started. In most cases, the first action in the constructor of the handler class should be to populate
+ * this long value ({@code Instant.now().toEpochMs();}). This class uses the value to estimate how much of the init 10
+ * seconds has already been used up.
+ */
+public class AsyncInitializationWrapper extends InitializationWrapper {
+    private static final int INIT_GRACE_TIME_MS = 250;
+    private static final int LAMBDA_MAX_INIT_TIME_MS = 10_000;
+
+    private CountDownLatch initializationLatch;
+    private long actualStartTime;
+    private Logger log = LoggerFactory.getLogger(AsyncInitializationWrapper.class);
+
+    /**
+     * Creates a new instance of the async initializer.
+     * @param startTime The epoch ms start time of the Lambda function, this should be measured as close as possible to
+     *                  the initialization of the function.
+     */
+    public AsyncInitializationWrapper(long startTime) {
+        actualStartTime = startTime;
+    }
+
+    @Override
+    public void start(LambdaContainerHandler handler) throws ContainerInitializationException {
+        initializationLatch = new CountDownLatch(1);
+        AsyncInitializer initializer = new AsyncInitializer(initializationLatch, handler);
+        Thread initThread = new Thread(initializer);
+        initThread.start();
+        try {
+            long curTime = Instant.now().toEpochMilli();
+            // account for the time it took to call the various constructors with the actual start time + a grace of 500ms
+            long awaitTime = LAMBDA_MAX_INIT_TIME_MS - (curTime - actualStartTime) - INIT_GRACE_TIME_MS;
+            log.info("Async initialization will wait for " + awaitTime + "ms");
+            if (!initializationLatch.await(awaitTime, TimeUnit.MILLISECONDS)) {
+                log.info("Initialization took longer than " + LAMBDA_MAX_INIT_TIME_MS + ", setting new CountDownLatch and " +
+                        "continuing in event handler");
+                initializationLatch = new CountDownLatch(1);
+                initializer.replaceLatch(initializationLatch);
+            }
+        } catch (InterruptedException e) {
+            // at the moment we assume that this happened because of a timeout since the init thread calls System.exit
+            // when an exception is thrown.
+            throw new ContainerInitializationException("Container initialization interrupted", e);
+        }
+    }
+
+    @Override
+    public CountDownLatch getInitializationLatch() {
+        return initializationLatch;
+    }
+
+    private static class AsyncInitializer implements Runnable {
+        private LambdaContainerHandler handler;
+        private CountDownLatch initLatch;
+        private Logger log = LoggerFactory.getLogger(AsyncInitializationWrapper.class);
+
+        AsyncInitializer(CountDownLatch latch, LambdaContainerHandler h) {
+            initLatch = latch;
+            handler = h;
+        }
+
+        synchronized void replaceLatch(CountDownLatch newLatch) {
+            initLatch = newLatch;
+        }
+
+        @Override
+        @SuppressFBWarnings("DM_EXIT")
+        public void run() {
+            log.info("Starting async initializer");
+            try {
+                handler.initialize();
+            } catch (ContainerInitializationException e) {
+                log.error("Failed to initialize container handler", e);
+                // we cannot return the exception so we crash the whole kaboodle here
+                System.exit(1);
+            }
+            synchronized(this) {
+                initLatch.countDown();
+            }
+        }
+    }
+}

aws-serverless-java-container-core/src/main/java/com/amazonaws/serverless/proxy/AwsProxyExceptionHandler.java

@@ -22,6 +22,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.ws.rs.InternalServerErrorException;
 import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MediaType;
 
@@ -31,7 +32,8 @@
 /**
  * Default implementation of the <code>ExceptionHandler</code> object that returns AwsProxyResponse objects.
  *
- * Returns application/json messages with a status code of 500 when the RequestReader failed to read the incoming event.
+ * Returns application/json messages with a status code of 500 when the RequestReader failed to read the incoming event
+ *  or if InternalServerErrorException is thrown.
  * For all other exceptions returns a 502. Responses are populated with a JSON object containing a message property.
  *
  * @see ExceptionHandler
@@ -76,7 +78,7 @@ public AwsProxyResponse handle(Throwable ex) {
         // adding a print stack trace in case we have no appender or we are running inside SAM local, where need the
         // output to go to the stderr.
         ex.printStackTrace();
-        if (ex instanceof InvalidRequestEventException) {
+        if (ex instanceof InvalidRequestEventException || ex instanceof InternalServerErrorException) {
             return new AwsProxyResponse(500, headers, getErrorJson(INTERNAL_SERVER_ERROR));
         } else {
             return new AwsProxyResponse(502, headers, getErrorJson(GATEWAY_TIMEOUT_ERROR));

aws-serverless-java-container-core/src/main/java/com/amazonaws/serverless/proxy/InitializationWrapper.java

@@ -0,0 +1,34 @@
+package com.amazonaws.serverless.proxy;
+
+import com.amazonaws.serverless.exceptions.ContainerInitializationException;
+import com.amazonaws.serverless.proxy.internal.LambdaContainerHandler;
+
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * This class is in charge of initializing a {@link LambdaContainerHandler}.
+ * In most cases, this means calling the {@link LambdaContainerHandler#initialize()} method. Some implementations may
+ * require additional initialization steps, in this case implementations should provide their own
+ * <code>InitializationWrapper</code>. This library includes an async implementation of this class
+ * {@link AsyncInitializationWrapper} for frameworks that are likely to take longer than 10 seconds to start.
+ */
+public class InitializationWrapper {
+    /**
+     * This is the main entry point. Container handler builder and the static <code>getAwsProxyHandler()</code> methods
+     * of the various implementations will call this to initialize the underlying framework
+     * @param handler The container handler to be initializer
+     * @throws ContainerInitializationException If anything goes wrong during container initialization.
+     */
+    public void start(LambdaContainerHandler handler) throws ContainerInitializationException {
+        handler.initialize();
+    }
+
+    /**
+     * Asynchronous implementations of the framework should return a latch that the container handler can use to decide
+     * whether it can start handling events. Synchronous implementations of this interface should return <code>null</code>.
+     * @return An initialized latch if the underlying container is starting in a separate thread, null otherwise.
+     */
+    public CountDownLatch getInitializationLatch() {
+        return null;
+    }
+}

aws-serverless-java-container-core/src/main/java/com/amazonaws/serverless/proxy/internal/LambdaContainerHandler.java

@@ -14,13 +14,9 @@
 
 
 import com.amazonaws.serverless.exceptions.ContainerInitializationException;
-import com.amazonaws.serverless.proxy.LogFormatter;
+import com.amazonaws.serverless.proxy.*;
 import com.amazonaws.serverless.proxy.internal.servlet.ApacheCombinedServletLogFormatter;
 import com.amazonaws.serverless.proxy.model.ContainerConfig;
-import com.amazonaws.serverless.proxy.ExceptionHandler;
-import com.amazonaws.serverless.proxy.RequestReader;
-import com.amazonaws.serverless.proxy.ResponseWriter;
-import com.amazonaws.serverless.proxy.SecurityContextWriter;
 import com.amazonaws.services.lambda.runtime.Context;
 
 import com.fasterxml.jackson.core.JsonParseException;
@@ -38,6 +34,7 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
 
 /**
@@ -67,6 +64,7 @@ public abstract class LambdaContainerHandler<RequestType, ResponseType, Containe
     private ExceptionHandler<ResponseType> exceptionHandler;
     private Class<RequestType> requestTypeClass;
     private Class<ResponseType> responseTypeClass;
+    private InitializationWrapper initializationWrapper;
 
     protected Context lambdaContext;
     private LogFormatter<ContainerRequestType, ContainerResponseType> logFormatter;
@@ -97,16 +95,28 @@ protected LambdaContainerHandler(Class<RequestType> requestClass,
                                      RequestReader<RequestType, ContainerRequestType> requestReader,
                                      ResponseWriter<ContainerResponseType, ResponseType> responseWriter,
                                      SecurityContextWriter<RequestType> securityContextWriter,
-                                     ExceptionHandler<ResponseType> exceptionHandler) {
+                                     ExceptionHandler<ResponseType> exceptionHandler,
+                                     InitializationWrapper init) {
         log.info("Starting Lambda Container Handler");
         requestTypeClass = requestClass;
         responseTypeClass = responseClass;
         this.requestReader = requestReader;
         this.responseWriter = responseWriter;
         this.securityContextWriter = securityContextWriter;
         this.exceptionHandler = exceptionHandler;
+        initializationWrapper = init;
         objectReader = getObjectMapper().readerFor(requestTypeClass);
         objectWriter = getObjectMapper().writerFor(responseTypeClass);
+
+    }
+
+    protected LambdaContainerHandler(Class<RequestType> requestClass,
+                                     Class<ResponseType> responseClass,
+                                     RequestReader<RequestType, ContainerRequestType> requestReader,
+                                     ResponseWriter<ContainerResponseType, ResponseType> responseWriter,
+                                     SecurityContextWriter<RequestType> securityContextWriter,
+                                     ExceptionHandler<ResponseType> exceptionHandler) {
+        this(requestClass, responseClass, requestReader, responseWriter, securityContextWriter, exceptionHandler, new InitializationWrapper());
     }
 
 
@@ -131,6 +141,23 @@ public static ObjectMapper getObjectMapper() {
         return objectMapper;
     }
 
+    /**
+     * Returns the initialization wrapper this container handler will monitor to handle events
+     * @return The initialization wrapper that was passed to the constructor and this instance will use to decide
+     *         whether it can start handling events.
+     */
+    public InitializationWrapper getInitializationWrapper() {
+        return initializationWrapper;
+    }
+
+    /**
+     * Sets a new initialization wrapper.
+     * @param wrapper The wrapper this instance will use to decide whether it can start handling events.
+     */
+    public void setInitializationWrapper(InitializationWrapper wrapper) {
+        initializationWrapper = wrapper;
+    }
+
     /**
      * Configures the library to strip a base path from incoming requests before passing them on to the wrapped
      * framework. This was added in response to issue #34 (https://github.com/awslabs/aws-serverless-java-container/issues/34).
@@ -168,12 +195,19 @@ public void setLogFormatter(LogFormatter<ContainerRequestType, ContainerResponse
      */
     public ResponseType proxy(RequestType request, Context context) {
         lambdaContext = context;
+        CountDownLatch latch = new CountDownLatch(1);
         try {
             SecurityContext securityContext = securityContextWriter.writeSecurityContext(request, context);
-            CountDownLatch latch = new CountDownLatch(1);
             ContainerRequestType containerRequest = requestReader.readRequest(request, securityContext, context, config);
             ContainerResponseType containerResponse = getContainerResponse(containerRequest, latch);
 
+            if (initializationWrapper != null && initializationWrapper.getInitializationLatch() != null) {
+                // we let the potential InterruptedException bubble up
+                if (!initializationWrapper.getInitializationLatch().await(config.getInitializationTimeout(), TimeUnit.MILLISECONDS)) {
+                    throw new ContainerInitializationException("Could not initialize framework within the " + config.getInitializationTimeout() + "ms timeout", null);
+                }
+            }
+
             handleRequest(containerRequest, containerResponse, context);
 
             latch.await();
@@ -185,6 +219,9 @@ public ResponseType proxy(RequestType request, Context context) {
             return responseWriter.writeResponse(containerResponse, context);
         } catch (Exception e) {
             log.error("Error while handling request", e);
+            // release all waiting threads. This is safe here because if the count was already 0
+            // the latch will do nothing
+            latch.countDown();
 
             return exceptionHandler.handle(e);
         }