Merge pull request #139 from networknt/issue138

fixes #138 refactor the executor for sync call handlers

Author: stevehu

src/main/java/com/networknt/aws/lambda/LightLambdaExchange.java

@@ -5,7 +5,7 @@
 import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
 import com.networknt.aws.lambda.exception.LambdaExchangeStateException;
 import com.networknt.aws.lambda.handler.MiddlewareHandler;
-import com.networknt.aws.lambda.handler.chain.PooledChainLinkExecutor;
+import com.networknt.aws.lambda.handler.chain.ChainExecutor;
 import com.networknt.aws.lambda.handler.chain.Chain;
 import com.networknt.aws.lambda.handler.middleware.ExceptionUtil;
 import com.networknt.aws.lambda.listener.LambdaExchangeFailureListener;
@@ -15,8 +15,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.InputStream;
-import java.io.OutputStream;
 import java.util.*;
 
 
@@ -29,7 +27,7 @@ public final class LightLambdaExchange {
     private APIGatewayProxyResponseEvent response;
     private final Context context;
     private final Map<Attachable<?>, Object> attachments = Collections.synchronizedMap(new HashMap<>());
-    private final PooledChainLinkExecutor executor;
+    private final ChainExecutor executor;
     private final List<LambdaResponseCompleteListener> responseCompleteListeners = Collections.synchronizedList(new ArrayList<>());
     private final List<LambdaRequestCompleteListener> requestCompleteListeners = Collections.synchronizedList(new ArrayList<>());
     private final List<LambdaExchangeFailureListener> exchangeFailedListeners = Collections.synchronizedList(new ArrayList<>());
@@ -67,7 +65,7 @@ public final class LightLambdaExchange {
     public LightLambdaExchange(Context context, Chain chain) {
         this.context = context;
         this.chain = chain;
-        this.executor = new PooledChainLinkExecutor();
+        this.executor = new ChainExecutor();
     }
 
     public void executeChain() {

src/main/java/com/networknt/aws/lambda/handler/Handler.java

@@ -61,14 +61,15 @@ static void initChains() {
             // add the chains to the handler list by id list.
             for (var chainName : config.getChains().keySet()) {
                 var chain = config.getChains().get(chainName);
-                Chain handlerChain = new Chain(false);
+                Chain handlerChain = new Chain();
                 for (var chainItemName : chain) {
                     var chainItem = handlers.get(chainItemName);
                     if (chainItem == null) {
                         throw new RuntimeException("Unknown handler in chain: " + chainItemName);
                     }
                     handlerChain.addChainable(chainItem);
                 }
+                handlerChain.setFinalized(true);
                 handlerListById.put(chainName, handlerChain);
             }
         }
@@ -162,7 +163,7 @@ private static void addPathChain(PathChain pathChain) {
      * @return A list containing references to the instantiated handlers
      */
     private static Chain getHandlersFromExecList(List<String> execs) {
-        var handlersFromExecList = new Chain(false);
+        var handlersFromExecList = new Chain();
 
         if (execs != null) {
 
@@ -185,7 +186,7 @@ private static Chain getHandlersFromExecList(List<String> execs) {
                 }
             }
         }
-        handlersFromExecList.setupGroupedChain();
+        handlersFromExecList.setFinalized(true);
         return handlersFromExecList;
     }
 

src/main/java/com/networknt/aws/lambda/handler/chain/Chain.java

@@ -12,18 +12,14 @@
 public class Chain {
     private static final Logger LOG = LoggerFactory.getLogger(Chain.class);
     private final LinkedList<LambdaHandler> chain = new LinkedList<>();
-    private final LinkedList<ArrayList<LambdaHandler>> groupedChain = new LinkedList<>();
-
-    private final boolean forceSynchronousExecution;
 
     private static final String CONFIG_NAME = "pooled-chain-executor";
     private static final PooledChainConfig CONFIG = (PooledChainConfig) Config.getInstance().getJsonObjectConfig(CONFIG_NAME, PooledChainConfig.class);
 
     private boolean isFinalized;
 
-    public Chain(boolean forceSynchronousExecution) {
+    public Chain() {
         this.isFinalized = false;
-        this.forceSynchronousExecution = forceSynchronousExecution;
     }
 
     public void addChainable(LambdaHandler chainable) {
@@ -38,43 +34,14 @@ public boolean isFinalized() {
         return isFinalized;
     }
 
-    public LinkedList<ArrayList<LambdaHandler>> getGroupedChain() {
-        return groupedChain;
+    public void setFinalized(boolean finalized) {
+        this.isFinalized = finalized;
     }
 
     public int getChainSize() {
         return this.chain.size();
     }
 
-    public void setupGroupedChain() {
-
-        if (this.isFinalized)
-            return;
-
-        var group = new ArrayList<LambdaHandler>();
-        for (var chainable : this.chain) {
-
-            if (this.forceSynchronousExecution || (!chainable.isAsynchronous() && group.isEmpty())) {
-                this.cutGroup(group, chainable);
-                group = new ArrayList<>();
-
-            } else if (chainable.isAsynchronous()) {
-                group.add(chainable);
-
-            } else if (!chainable.isAsynchronous() && !group.isEmpty()) {
-                this.groupedChain.add(group);
-                group = new ArrayList<>();
-                this.cutGroup(group, chainable);
-                group = new ArrayList<>();
-            }
-        }
-
-        if (!group.isEmpty()) {
-            this.groupedChain.add(group);
-        }
-
-        this.isFinalized = true;
-    }
 
     /**
      * Add to chain from string parameter
@@ -135,11 +102,6 @@ public Chain add(Class<? extends LambdaHandler> middleware) {
         return this;
     }
 
-    private void cutGroup(ArrayList<LambdaHandler> group, LambdaHandler chainable) {
-        group.add(chainable);
-        this.groupedChain.add(group);
-    }
-
     public LinkedList<LambdaHandler> getChain() {
         return chain;
     }

src/main/java/com/networknt/aws/lambda/handler/chain/ChainExecutor.java

@@ -0,0 +1,51 @@
+package com.networknt.aws.lambda.handler.chain;
+
+import com.networknt.aws.lambda.LightLambdaExchange;
+import com.networknt.status.Status;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class ChainExecutor {
+    private static final Logger LOG = LoggerFactory.getLogger(ChainExecutor.class);
+    private final LinkedList<Status> chainResults = new LinkedList<>();
+    private static final String MIDDLEWARE_UNHANDLED_EXCEPTION = "ERR14004";
+
+    public void executeChain(final LightLambdaExchange exchange, final Chain chain) {
+
+        if (!chain.isFinalized()) {
+            LOG.error("Execution attempt on a chain that is not finalized! Call 'finalizeChain' before 'executeChain'");
+            return;
+        }
+
+        for(var handler : chain.getChain()) {
+            if (!handler.isEnabled()) {
+                LOG.debug("Skipping disabled handler: {}", handler.getClass().getName());
+                continue;
+            }
+            Status status = null;
+            try {
+                status = handler.execute(exchange);
+                exchange.updateExchangeStatus(status);
+                addChainableResult(status);
+            } catch (Exception e) {
+                LOG.error("Exception in handler: {}", handler.getClass().getName(), e);
+                addChainableResult(new Status(MIDDLEWARE_UNHANDLED_EXCEPTION));
+            }
+            if (exchange.hasFailedState()) {
+                break;
+            }
+        }
+    }
+
+    protected void addChainableResult(Status result) {
+        this.chainResults.add(result);
+    }
+
+    public List<Status> getChainResults() {
+        return chainResults;
+    }
+
+}