Merge pull request #21 from tsurdilo/errorhandlingupdate2

Error Handling updates

Author: Tihomir Surdilovic

api/src/main/java/io/serverlessworkflow/api/deserializers/RetriesDeserializer.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ * <p>
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.serverlessworkflow.api.deserializers;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
+import io.serverlessworkflow.api.interfaces.WorkflowPropertySource;
+import io.serverlessworkflow.api.retry.RetryDefinition;
+import io.serverlessworkflow.api.utils.Utils;
+import io.serverlessworkflow.api.workflow.Retries;
+import org.json.JSONObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class RetriesDeserializer extends StdDeserializer<Retries> {
+
+    private static final long serialVersionUID = 510l;
+    private static Logger logger = LoggerFactory.getLogger(RetriesDeserializer.class);
+
+    private WorkflowPropertySource context;
+
+    public RetriesDeserializer() {
+        this(Retries.class);
+    }
+
+    public RetriesDeserializer(Class<?> vc) {
+        super(vc);
+    }
+
+    public RetriesDeserializer(WorkflowPropertySource context) {
+        this(Retries.class);
+        this.context = context;
+    }
+
+    @Override
+    public Retries deserialize(JsonParser jp,
+                              DeserializationContext ctxt) throws IOException {
+
+        ObjectMapper mapper = (ObjectMapper) jp.getCodec();
+        JsonNode node = jp.getCodec().readTree(jp);
+
+        Retries retries = new Retries();
+        List<RetryDefinition> retryDefinitions = new ArrayList<>();
+
+        if (node.isArray()) {
+            for (final JsonNode nodeEle : node) {
+                retryDefinitions.add(mapper.treeToValue(nodeEle, RetryDefinition.class));
+            }
+        } else {
+            String retriesFileDef = node.asText();
+            String retriesFileSrc = Utils.getResourceFileAsString(retriesFileDef);
+            JsonNode retriesRefNode;
+            ObjectMapper jsonWriter = new ObjectMapper();
+            if (retriesFileSrc != null && retriesFileSrc.trim().length() > 0) {
+                // if its a yaml def convert to json first
+                if (!retriesFileSrc.trim().startsWith("{")) {
+                    // convert yaml to json to validate
+                    ObjectMapper yamlReader = new ObjectMapper(new YAMLFactory());
+                    Object obj = yamlReader.readValue(retriesFileSrc, Object.class);
+
+                    retriesRefNode = jsonWriter.readTree(new JSONObject(jsonWriter.writeValueAsString(obj)).toString());
+                } else {
+                    retriesRefNode = jsonWriter.readTree(new JSONObject(retriesFileSrc).toString());
+                }
+
+                JsonNode refRetries = retriesRefNode.get("retries");
+                if (refRetries != null) {
+                    for (final JsonNode nodeEle : refRetries) {
+                        retryDefinitions.add(mapper.treeToValue(nodeEle, RetryDefinition.class));
+                    }
+                } else {
+                    logger.error("Unable to find retries definitions in reference file: {}", retriesFileSrc);
+                }
+
+            } else {
+                logger.error("Unable to load retries defs reference file: {}", retriesFileSrc);
+            }
+
+        }
+        retries.setRetryDefs(retryDefinitions);
+        return retries;
+
+    }
+}

api/src/main/java/io/serverlessworkflow/api/interfaces/State.java

@@ -19,7 +19,6 @@
 import io.serverlessworkflow.api.end.End;
 import io.serverlessworkflow.api.error.Error;
 import io.serverlessworkflow.api.filters.StateDataFilter;
-import io.serverlessworkflow.api.retry.Retry;
 import io.serverlessworkflow.api.start.Start;
 import io.serverlessworkflow.api.states.DefaultState.Type;
 import io.serverlessworkflow.api.transitions.Transition;
@@ -47,9 +46,7 @@ public interface State {
 
     Transition getTransition();
 
-    List<Error> getOnError();
-
-    List<Retry> getRetry();
+    List<Error> getOnErrors();
 
     Map<String, String> getMetadata();
 }

api/src/main/java/io/serverlessworkflow/api/mapper/WorkflowModule.java

@@ -30,6 +30,7 @@
 import io.serverlessworkflow.api.states.ParallelState;
 import io.serverlessworkflow.api.workflow.Events;
 import io.serverlessworkflow.api.workflow.Functions;
+import io.serverlessworkflow.api.workflow.Retries;
 
 public class WorkflowModule extends SimpleModule {
 
@@ -80,6 +81,7 @@ private void addDefaultDeserializers() {
         addDeserializer(EventDefinition.Kind.class, new EventDefinitionKindDeserializer(workflowPropertySource));
         addDeserializer(ParallelState.CompletionType.class, new ParallelStateCompletionTypeDeserializer(workflowPropertySource));
         addDeserializer(Schedule.DirectInvoke.class, new ScheduleDirectInvokeDeserializer(workflowPropertySource));
+        addDeserializer(Retries.class, new RetriesDeserializer(workflowPropertySource));
         addDeserializer(Functions.class, new FunctionsDeserializer(workflowPropertySource));
         addDeserializer(Events.class, new EventsDeserializer(workflowPropertySource));
         addDeserializer(Extension.class, extensionDeserializer);

api/src/main/java/io/serverlessworkflow/api/serializers/WorkflowSerializer.java

@@ -24,6 +24,7 @@
 import io.serverlessworkflow.api.functions.FunctionDefinition;
 import io.serverlessworkflow.api.interfaces.Extension;
 import io.serverlessworkflow.api.interfaces.State;
+import io.serverlessworkflow.api.retry.RetryDefinition;
 
 import java.io.IOException;
 import java.security.MessageDigest;
@@ -111,6 +112,17 @@ public void serialize(Workflow workflow,
             gen.writeEndArray();
         }
 
+        if (workflow.getRetries() != null && !workflow.getRetries().getRetryDefs().isEmpty()) {
+            gen.writeArrayFieldStart("retries");
+            for (RetryDefinition retry : workflow.getRetries().getRetryDefs()) {
+                gen.writeObject(retry);
+            }
+            gen.writeEndArray();
+        } else {
+            gen.writeArrayFieldStart("retries");
+            gen.writeEndArray();
+        }
+
         if (workflow.getStates() != null && !workflow.getStates().isEmpty()) {
             gen.writeArrayFieldStart("states");
             for (State state : workflow.getStates()) {

api/src/main/java/io/serverlessworkflow/api/workflow/BaseWorkflow.java

@@ -43,6 +43,7 @@ public static Workflow fromSource(String source) {
             return jsonObjectMapper.readValue(source,
                     Workflow.class);
         } catch (Exception e) {
+            logger.info("Unable to convert as json markup, trying as yaml");
             try {
                 return yamlObjectMapper.readValue(source,
                         Workflow.class);

api/src/main/java/io/serverlessworkflow/api/workflow/Retries.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ * <p>
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.serverlessworkflow.api.workflow;
+
+import io.serverlessworkflow.api.retry.RetryDefinition;
+
+import java.util.List;
+
+public class Retries {
+    private String refValue;
+    private List<RetryDefinition> retryDefs;
+
+    public Retries() {}
+
+    public Retries(List<RetryDefinition> retryDefs) {
+        this.retryDefs = retryDefs;
+    }
+
+    public Retries(String refValue) {
+        this.refValue = refValue;
+    }
+
+    public String getRefValue() {
+        return refValue;
+    }
+
+    public void setRefValue(String refValue) {
+        this.refValue = refValue;
+    }
+
+    public List<RetryDefinition> getRetryDefs() {
+        return retryDefs;
+    }
+
+    public void setRetryDefs(List<RetryDefinition> retryDefs) {
+        this.retryDefs = retryDefs;
+    }
+}

api/src/main/resources/schema/error/error.json

@@ -2,21 +2,32 @@
   "type": "object",
   "javaType": "io.serverlessworkflow.api.error.Error",
   "properties": {
-    "expression": {
+    "error": {
       "type": "string",
-      "description": "Common Expression Language (CEL) expression. Should be evaluated against error data. Must evaluate to true."
+      "description": "Domain-specific error name, or '*' to indicate all possible errors",
+      "minLength": 1
     },
-    "errorDataFilter": {
-      "$ref": "../filters/errordatafilter.json",
-      "description": "Error data filter definition "
+    "code": {
+      "type": "string",
+      "description": "Error code. Can be used in addition to the name to help runtimes resolve to technical errors/exceptions. Should not be defined if error is set to '*'",
+      "minLength": 1
+    },
+    "retryRef": {
+      "type": "string",
+      "description": "References a unique name of a retry definition.",
+      "minLength": 1
     },
     "transition": {
       "$ref": "../transitions/transition.json",
-      "description": "Next transition of the workflow when 'expression' is true"
+      "description": "Transition to next state to handle the error. If retryRef is defined, this transition is taken only if retries were unsuccessful."
+    },
+    "end": {
+      "description": "End workflow execution in case of this error. If retryRef is defined, this ends workflow only if retries were unsuccessful.",
+      "$ref": "../end/end.json"
     }
   },
   "required": [
-    "expression",
+    "error",
     "transition"
   ]
 }

api/src/main/resources/schema/filters/errordatafilter.json

@@ -1,15 +1,16 @@
 {
   "type": "object",
-  "javaType": "io.serverlessworkflow.api.retry.Retry",
+  "javaType": "io.serverlessworkflow.api.retry.RetryDefinition",
   "description": "Retry Definition",
   "properties": {
-    "expression": {
+    "name": {
       "type": "string",
-      "description": "Common Expression Language (CEL) expression. Should be evaluated against state data. Must evaluate to true for retry to execute"
+      "description": "Unique retry strategy name",
+      "minLength": 1
     },
-    "interval": {
+    "delay": {
       "type": "string",
-      "description": "Specifies the amount of time between retries (ISO 8601 format)"
+      "description": "Time delay between retry attempts (ISO 8601 duration format)"
     },
     "multiplier": {
       "type": "string",
@@ -28,6 +29,7 @@
     }
   },
   "required": [
-    "expression"
+    "name",
+    "maxAttempts"
   ]
 }

api/src/main/resources/schema/retry/retry.json renamed to api/src/main/resources/schema/retry/retrydef.json

@@ -57,21 +57,13 @@
       "type": "string",
       "description": "URI to JSON Schema that state data output adheres to"
     },
-    "onError": {
+    "onErrors": {
       "type": "array",
-      "description": "State onError definition",
+      "description": "State error handling definitions",
       "items": {
         "type": "object",
         "$ref": "../error/error.json"
       }
-    },
-    "retry": {
-      "type": "array",
-      "description": "State retry definition",
-      "items": {
-        "type": "object",
-        "$ref": "../retry/retry.json"
-      }
     }
   },
   "required": [