Flow Overview

Components

There are multiple types of components. Drag, drop, configure, and connect components to visually orchestrate flows. Before using flows, understand the components described in Table 1.

Orchestration Rules

• A flow must be a directed acyclic graph (DAG). It has a start node followed only by one node (except the error handling and stop nodes) and ends after another node. You can end a flow in the following ways:
  1. Do not connect any conditional, parallel, or start node to the last node of the flow.
  2. Add a stop node as the last node of the flow.
• Component design rules

  Table 2 Trigger, function, and EG

  Type	Description	Mandatory
  Trigger	A flow can have a maximum of 10 triggers. Triggers must be included in the start node. Triggers cannot be connected to any other node.	No
  Function	A flow can have a maximum of 99 functions. A function connected to an error handling node can be connected to another node that is not start or error handling. A function that is not connected to an error handling node can be connected to only one non-start node.	No
  EG	A flow can have a maximum of 10 EG nodes. An EG node connected to an error handling node can only be connected to another node that is not start or error handling. An EG node that is not connected to an error handling node can be connected to only one non-start node.	No

  Table 3 Processors

  Type	Description	Mandatory
  Callback	For details about the constraints of callback nodes, see the function parameter in Table 2. Callback nodes cannot be subnodes of a service node.	No
  Subflow	A flow.	No
  Parallel branch	Indicates that the connected branches will be executed concurrently. A parallel branch connects 1 to 20 nodes that are not error handling, start, or stop.	No
  Start	Indicates the start of a flow. Each flow has only one start node. The start node must be followed by a node that is not stop or error handling.	Yes
  Error handling	Can be connected to a maximum of 10 nodes that are not start, stop, or error handling.	No
  Loop	Cyclically processes each element in an array. All subflows in a loop are executed each time. The subflows in a loop must satisfy the following rules: Start with a function or wait node. Only include function, wait, and error handling nodes.	No
  Wait	Can be connected to zero or one node that is not start or error handling.	No
  Service	Consists of multiple functions and can be connected to a stop node or an error handling node.	No
  Conditional branch	Connects 2 to 20 nodes that are not start, stop, or error handling.	No
  Stop	Not followed by any other node.	No

Expression Operators

The expression for an error handling or conditional branch node is in the format "[JsonPath] + [logical operator] + [value]". For example, $.age >= 20.

JsonPath Description

Examples

• Simple values: JSON data example

  {  
       "fruits": [ "apple", "orange", "pear" ],  
       "vegetables": [{      
       "veggieName": "potato",
       "veggieLike": true    
        },     
        {       
            "veggieName": "broccoli",      
            "veggieLike": false    
        }] 
  }

  The $.fruits expression obtains all values under fruits.

  The result of $.fruits is ["apple","orange","pear"].

• Simple filtering: JSON data example

  {   
         "fruits": [ "apple", "orange", "pear" ],
         "vegetables": [{ 
         "veggieName": "potato",
         "veggieLike": true
         },     
        { 
            "veggieName": "broccoli",
            "veggieLike": false     
        }] 
  }

  Expression: $.vegetables[?(@.veggieLike == true)].veggieName

  Meaning: Obtains all values of the key vegetables and outputs the value of veggieName whose veggieLike is True.

  Result: [potato]

Logical Operators

The following data is used as input parameters in the examples:

{
  "name" : "apple",
  "weight": 13.4,
  "type": [3,4,6,8],
  "obj": {
        "a" : 1
   }
}

These are the supported operators.

• A string constant must be enclosed with quotation marks (''). For example, 'apple'.
• JsonPath expressions cannot contain =, !=, <, >, |, or &.

Configuration Examples

Example 1: Parallel branch

1. Create three Python 3.9 functions with the following code:
   • Function 1: Returning the value of the event input

     import json
     def handler (event, context):
         input = event.get('input',0)
         return {
             "result": input
             }

   • Function 2: Returning the value of the event input plus 2

     import json
     def handler (event, context):
         input = event.get('input',0)
         return {
             "result": input+2
             }

   • Function 3: Returning the square value of the event input

     import json
     def handler (event, context):
         input = event.get('input',0)
         return {
             "result": input*input
             }

2. Add components to a flow by drag and drop and configure a parallel branch node according to the following figure.
   Figure 1 Configuring a parallel branch node
   
3. Configure three function nodes by referring to Table 2.
   Figure 2 Configuring a function node
   
4. Save the flow. Then start execution with the following input:

   {
     "input":3
   }

5. Click the flow to view the execution result.
   Figure 3 Execution result
   

Example 2: Service node in serial mode

1. Orchestrate components by drag and drop, and set the execution mode of the service node to Serial.
   Figure 4 Configuring a service node
   
2. Add function 2 and function 3 to the service node and configure them according to the following figures.
   Figure 5 Configuring function node 2
   
   Figure 6 Configuring function node 3
   
3. Save the flow. Then start execution with the following input:

   {
     "input":3
   }

4. Click the flow to view the execution result.
   Figure 7 Execution result
   

Example 4: Error handling

• Design a function flow. input < 2: Execute the subflows in serial mode to output the input value plus 2 and then squared; input = 2: Execute the default branch to output the input value; input > 2: Execute the subflows in parallel mode to output the input value, the input value plus 2, and the square of the input value.

• Input 3 to execute the subflows in parallel mode and output the following result.

• Input 1 to execute the subflows in serial mode and output the following result.

• Input 2 to execute the default branch and output the input value, that is, 2.

Example 8: Loop node

Use the loop node to cyclically process each element in an input array. All subflows in a loop are executed each time.

• Design a function flow with a loop node. The node cyclically adds 2 to each element in an integer array and then squares the sum. The flow is shown in the following figure.

  

• Set Array Path to $.inputs and Iteration Variable to $.item.

  

• Configure function math_2 to output a result that is the input value plus 2. Ensure that the parameter value in Function Parameters is the same as the iteration variable in the loop node.