Merge pull request #113 from tsurdilo/stateexectimeoutup

Updating state exec timeout

Author: tsurdilo

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification 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
+ *
+ * http://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.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.deser.std.StdDeserializer;
+import io.serverlessworkflow.api.interfaces.WorkflowPropertySource;
+import io.serverlessworkflow.api.timeouts.StateExecTimeout;
+
+import java.io.IOException;
+
+public class StateExecTimeoutDeserializer extends StdDeserializer<StateExecTimeout> {
+
+    private static final long serialVersionUID = 510l;
+
+    @SuppressWarnings("unused")
+    private WorkflowPropertySource context;
+
+    public StateExecTimeoutDeserializer() {
+        this(StateExecTimeout.class);
+    }
+
+    public StateExecTimeoutDeserializer(Class<?> vc) {
+        super(vc);
+    }
+
+    public StateExecTimeoutDeserializer(WorkflowPropertySource context) {
+        this(StateExecTimeout.class);
+        this.context = context;
+    }
+
+    @Override
+    public StateExecTimeout deserialize(JsonParser jp,
+                                        DeserializationContext ctxt) throws IOException {
+
+        JsonNode node = jp.getCodec().readTree(jp);
+
+        StateExecTimeout stateExecTimeout = new StateExecTimeout();
+
+        if (!node.isObject()) {
+            stateExecTimeout.setTotal(node.asText());
+            stateExecTimeout.setSingle(null);
+            return stateExecTimeout;
+        } else {
+            if (node.get("single") != null) {
+                stateExecTimeout.setSingle(node.get("single").asText());
+            }
+
+            if (node.get("total") != null) {
+                stateExecTimeout.setTotal(node.get("total").asText());
+            }
+
+            return stateExecTimeout;
+        }
+    }
+}

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

@@ -35,6 +35,7 @@
 import io.serverlessworkflow.api.states.DefaultState;
 import io.serverlessworkflow.api.states.OperationState;
 import io.serverlessworkflow.api.states.ParallelState;
+import io.serverlessworkflow.api.timeouts.StateExecTimeout;
 import io.serverlessworkflow.api.transitions.Transition;
 import io.serverlessworkflow.api.workflow.*;
 
@@ -77,6 +78,7 @@ private void addDefaultSerializers() {
         addSerializer(new ScheduleSerializer());
         addSerializer(new SubFlowRefSerializer());
         addSerializer(new AuthDefinitionSerializer());
+        addSerializer(new StateExecTimeoutSerializer());
         addSerializer(extensionSerializer);
     }
 
@@ -109,6 +111,7 @@ private void addDefaultDeserializers() {
         addDeserializer(Schedule.class, new ScheduleDeserializer(workflowPropertySource));
         addDeserializer(DataInputSchema.class, new DataInputSchemaDeserializer(workflowPropertySource));
         addDeserializer(AuthDefinition.class, new AuthDefinitionDeserializer(workflowPropertySource));
+        addDeserializer(StateExecTimeout.class, new StateExecTimeoutDeserializer(workflowPropertySource));
     }
 
     public ExtensionSerializer getExtensionSerializer() {

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification 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
+ *
+ * http://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.serverlessworkflow.api.serializers;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+import io.serverlessworkflow.api.timeouts.StateExecTimeout;
+
+import java.io.IOException;
+
+public class StateExecTimeoutSerializer extends StdSerializer<StateExecTimeout> {
+
+    public StateExecTimeoutSerializer() {
+        this(StateExecTimeout.class);
+    }
+
+    protected StateExecTimeoutSerializer(Class<StateExecTimeout> t) {
+        super(t);
+    }
+
+    @Override
+    public void serialize(StateExecTimeout stateExecTimeout,
+                          JsonGenerator gen,
+                          SerializerProvider provider) throws IOException {
+
+        if (stateExecTimeout != null) {
+            if ((stateExecTimeout.getTotal() != null && stateExecTimeout.getTotal().isEmpty())
+                    && (stateExecTimeout.getSingle() == null || stateExecTimeout.getSingle().isEmpty())) {
+                gen.writeString(stateExecTimeout.getTotal());
+            } else {
+                gen.writeStartObject();
+
+                if (stateExecTimeout.getTotal() != null && stateExecTimeout.getTotal().length() > 0) {
+                    gen.writeStringField("total", stateExecTimeout.getTotal());
+                }
+
+                if (stateExecTimeout.getSingle() != null && stateExecTimeout.getSingle().length() > 0) {
+                    gen.writeStringField("single", stateExecTimeout.getSingle());
+                }
+
+                gen.writeEndObject();
+            }
+        }
+    }
+}
+

api/src/main/resources/schema/timeouts/stateexectimeout.json

@@ -0,0 +1,19 @@
+{
+  "type": "object",
+  "javaType": "io.serverlessworkflow.api.timeouts.StateExecTimeout",
+  "properties": {
+    "single": {
+      "type": "string",
+      "description": "Single state execution timeout, not including retries (ISO 8601 duration format)",
+      "minLength": 1
+    },
+    "total": {
+      "type": "string",
+      "description": "Total state execution timeout, including retries (ISO 8601 duration format)",
+      "minLength": 1
+    }
+  },
+  "required": [
+    "total"
+  ]
+}

api/src/main/resources/schema/timeouts/timeoutsdef.json

@@ -7,9 +7,7 @@
       "$ref": "workflowexectimeout.json"
     },
     "stateExecTimeout": {
-      "type": "string",
-      "description": "State execution timeout duration (ISO 8601 duration format)",
-      "minLength": 1
+      "$ref": "stateexectimeout.json"
     },
     "actionExecTimeout": {
       "type": "string",

api/src/test/java/io/serverlessworkflow/api/test/MarkupToWorkflowTest.java

@@ -575,15 +575,15 @@ public void testTimeouts(String workflowLocation) {
         assertNotNull(firstState.getTimeouts());
         assertNotNull(firstState.getTimeouts().getStateExecTimeout());
         assertNotNull(firstState.getTimeouts().getEventTimeout());
-        assertEquals("PT5M", firstState.getTimeouts().getStateExecTimeout());
+        assertEquals("PT5M", firstState.getTimeouts().getStateExecTimeout().getTotal());
         assertEquals("PT2M", firstState.getTimeouts().getEventTimeout());
 
 
         assertTrue(workflow.getStates().get(1) instanceof ParallelState);
         ParallelState secondState = (ParallelState) workflow.getStates().get(1);
         assertNotNull(secondState.getTimeouts());
         assertNotNull(secondState.getTimeouts().getStateExecTimeout());
-        assertEquals("PT5M", secondState.getTimeouts().getStateExecTimeout());
+        assertEquals("PT5M", secondState.getTimeouts().getStateExecTimeout().getTotal());
 
         assertNotNull(secondState.getBranches());
         assertEquals(2, secondState.getBranches().size());
@@ -658,7 +658,5 @@ public void testAuthOAuth(String workflowLocation) {
         assertEquals("clientCredentials", auth.getOauth().getGrantType().value());
         assertEquals("${ $SECRETS.clientid }", auth.getOauth().getClientId());
         assertEquals("${ $SECRETS.clientsecret }", auth.getOauth().getClientSecret());
-
-        System.out.println("****************\n\n " + Workflow.toJson(workflow));
     }
 }