flow

Flow vs Stream

https://wikidiff.com/flow/stream

As nouns the difference between flow and stream

is that flow is the movement of a fluid while stream is a small river; a large creek; a body of moving water confined by banks.

As verbs the difference between flow and stream

is that flow is to move as a fluid from one position to another while stream is to flow in a continuous or steady manner, like a liquid.

Data flow

https://www.computerhope.com/jargon/d/data-flow-diagram.htm

Data flow diagram

Updated: 04/26/2017 by Computer Hope

A data flow diagram (or DFD) is a graphical representation of the flow of data through an information system. It shows how information is input to and output from the system, the sources and destinations of that information, and where that information is stored.

Information not shown in a DFD includes how long processes take, and whether those processes operate in series or parallel. Such information is often shown in a flowchart instead.

Process Flow

https://www.differencebetween.com/difference-between-flowchart-and-vs-data-flow-diagram-dfd/

The terms flowchart and data flow diagram (DFD) are related to software engineering describing the path of process or data step by step. Although flow chart is used in almost all the fields of education and engineering data flow diagram is mainly used is the software industry. Both the diagrams are made to make the process simple to understand. A flow chart provides the steps needed to reach the desired results and a data flow diagram describes the source from which data is coming, the change that occurs in the system and the source at which it ends. Both these diagrams provide a very easy way to understand the way a process is taking place or data is being processed from the beginning till the end.

Flowchart

A flowchart is made to break down a process into simple steps by writing down the steps in boxes that are connected with arrows. A flow chart starts from the first step and ends at the last step with all the actions to be performed in middle. Flow chart also trouble shoots the problems by providing solution if an error occurs during any step. The biggest advantage of a flow chart is that it gives an overall view of the process at a single glance, to understand it better. There are different types of flowcharts like

• System flow chart

• Data flow chart

• Document flow chart

• Program flow chart

Data Flow Diagram

A data flow diagram is a representation of data flow through a system during which it is processed as well. The flow of data from an external source or internal source to its destination is shown by a diagram. Where the data will end up after being processed is also shown in a data flow diagram. The processes through which data will go through are shown in these diagrams. These processes can be a sequence or act simultaneously while data is going through the system.

Flowchart vs Data Flow Diagram (DFD)

• The main difference between flow chart and data flow diagram is that flow chart presents steps to complete a process where as data flow diagram presents the flow of data.

• Flow chart does not have any input from or output to external source whereas data flow diagram describes the path of data from external source to internal store or vice versa.

• The timing and sequence of the process is aptly shown by a flow chart where as the processing of data is taking place in a particular order or several processes are taking simultaneously is not described by a data flow diagram.

• Data flow diagrams define the functionality of a system where as flow diagram shows how to make a system function.

• Flow charts are used in designing a process but data flow diagram are used to describe the path of data that will complete that process.

work flow

https://www.process.st/what-is-a-workflow/

If you look at the Wikipedia definition of a workflow, you’re probably going to get confused as I did:

“A workflow consists of an orchestrated and repeatable pattern of business activity enabled by the systematic organization of resources into processes that transform materials, provide services, or process information It can be depicted as a sequence of operations, declared as work of a person or group, an organization of staff, or one or more simple or complex mechanisms.”

Let’s put this simply…

Workflows are the way people get work done, and can be illustrated as series of steps that need to be completed sequentially in a diagram or checklist.

例如报道工作流

https://www.dmcinfo.com/latest-thinking/blog/id/8569/onboarding-employees-using-sharepoint-workflow

ticket状态工作流

https://confluence.atlassian.com/adminjiraserver072/working-with-workflows-828787890.html

流控制实现

workflow-es

https://github.com/danielgerlag/workflow-es/blob/master/samples/node.js/javascript/01-hello-world.js

const workflow_es = require("workflow-es");
const workflow_mongo = require("workflow-es-mongodb");

class HelloWorld extends workflow_es.StepBody {
    run(context) {
        console.log("Hello World");
        return workflow_es.ExecutionResult.next();
    }
}
class GoodbyeWorld extends workflow_es.StepBody {
    run(context) {
        console.log("Goodbye World");
        return workflow_es.ExecutionResult.next();
    }
}
class HelloWorld_Workflow {
    constructor() {
        this.id = "hello-world";
        this.version = 1;
    }
    build(builder) {
        builder
            .startWith(HelloWorld)
            .then(GoodbyeWorld);
    }
}

async function main() {
    var config = workflow_es.configureWorkflow();
    //config.useLogger(new workflow_es.ConsoleLogger());
    //let mongoPersistence = new workflow_mongo.MongoDBPersistence("mongodb://127.0.0.1:27017/workflow-node");
    //await mongoPersistence.connect;
    //config.usePersistence(mongoPersistence);
    var host = config.getHost();

    host.registerWorkflow(HelloWorld_Workflow);
    await host.start();
    let id = await host.startWorkflow("hello-world", 1);
    console.log("Started workflow: " + id);
}

main();

上面是先后顺序控制：

下面是并行控制：

const workflow_es = require("workflow-es");
const workflow_mongo = require("workflow-es-mongodb");

class SayHello extends workflow_es.StepBody {
    run(context) {
        console.log("Hello");
        return workflow_es.ExecutionResult.next();
    }
}

class PrintMessage extends workflow_es.StepBody {
    run(context) {
        console.log(this.message);
        return workflow_es.ExecutionResult.next();
    }
}

class DoSomething extends workflow_es.StepBody {
    run(context) {
        console.log("Doing something...");
        return workflow_es.ExecutionResult.next();
    }
}

class SayGoodbye extends workflow_es.StepBody {
    run(context) {
        console.log("Bye");
        return workflow_es.ExecutionResult.next();
    }
}

class Parallel_Workflow {
    constructor() {
        this.id = "parallel-sample";
        this.version = 1;
    }
    build(builder) {
        builder
        .startWith(SayHello)
        .parallel()
            .do(branch1 => branch1
                .startWith(PrintMessage)
                    .input((step, data) => step.message = "Running in branch 1")
                .delay(data => 5000)
                .then(DoSomething)
            )
            .do(branch2 => branch2
                .startWith(PrintMessage)
                    .input((step, data) => step.message = "Running in branch 2")
            )
            .do(branch3 => branch3
                .startWith(PrintMessage)
                    .input((step, data) => step.message = "Running in branch 3")
            )
        .join()
        .then(SayGoodbye);
    }
}

async function main() {
    var config = workflow_es.configureWorkflow();
    var host = config.getHost();

    host.registerWorkflow(Parallel_Workflow);
    await host.start();
    let id = await host.startWorkflow("parallel-sample", 1);
    console.log("Started workflow: " + id);
}

main();

Python taskflow

https://github.com/openstack/taskflow/blob/master/taskflow/examples/hello_world.py

# -*- coding: utf-8 -*-

#    Copyright (C) 2014 Yahoo! Inc. All Rights Reserved.
#
#    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.

import logging
import os
import sys

logging.basicConfig(level=logging.ERROR)

top_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
                                       os.pardir,
                                       os.pardir))
sys.path.insert(0, top_dir)

from taskflow import engines
from taskflow.patterns import linear_flow as lf
from taskflow.patterns import unordered_flow as uf
from taskflow import task

# INTRO: This is the defacto hello world equivalent for taskflow; it shows how
# an overly simplistic workflow can be created that runs using different
# engines using different styles of execution (all can be used to run in
# parallel if a workflow is provided that is parallelizable).

class PrinterTask(task.Task):
    def __init__(self, name, show_name=True, inject=None):
        super(PrinterTask, self).__init__(name, inject=inject)
        self._show_name = show_name

    def execute(self, output):
        if self._show_name:
            print("%s: %s" % (self.name, output))
        else:
            print(output)

# This will be the work that we want done, which for this example is just to
# print 'hello world' (like a song) using different tasks and different
# execution models.
song = lf.Flow("beats")

# Unordered flows when ran can be ran in parallel; and a chorus is everyone
# singing at once of course!
hi_chorus = uf.Flow('hello')
world_chorus = uf.Flow('world')
for (name, hello, world) in [('bob', 'hello', 'world'),
                             ('joe', 'hellooo', 'worllllld'),
                             ('sue', "helloooooo!", 'wooorllld!')]:
    hi_chorus.add(PrinterTask("%s@hello" % name,
                              # This will show up to the execute() method of
                              # the task as the argument named 'output' (which
                              # will allow us to print the character we want).
                              inject={'output': hello}))
    world_chorus.add(PrinterTask("%s@world" % name,
                                 inject={'output': world}))

# The composition starts with the conductor and then runs in sequence with
# the chorus running in parallel, but no matter what the 'hello' chorus must
# always run before the 'world' chorus (otherwise the world will fall apart).
song.add(PrinterTask("conductor@begin",
                     show_name=False, inject={'output': "*ding*"}),
         hi_chorus,
         world_chorus,
         PrinterTask("conductor@end",
                     show_name=False, inject={'output': "*dong*"}))

# Run in parallel using eventlet green threads...
try:
    import eventlet as _eventlet  # noqa
except ImportError:
    # No eventlet currently active, skip running with it...
    pass
else:
    print("-- Running in parallel using eventlet --")
    e = engines.load(song, executor='greenthreaded', engine='parallel',
                     max_workers=1)
    e.run()

# Run in parallel using real threads...
print("-- Running in parallel using threads --")
e = engines.load(song, executor='threaded', engine='parallel',
                 max_workers=1)
e.run()

# Run in parallel using external processes...
print("-- Running in parallel using processes --")
e = engines.load(song, executor='processes', engine='parallel',
                 max_workers=1)
e.run()

# Run serially (aka, if the workflow could have been ran in parallel, it will
# not be when ran in this mode)...
print("-- Running serially --")
e = engines.load(song, engine='serial')
e.run()
print("-- Statistics gathered --")
print(e.statistics)

https://www.tuicool.com/articles/fAfqMf

from __future__ import print_function

import urllib2

import taskflow.engines
from taskflow.patterns import linear_flow as lf
from taskflow import task

def flow_watch(state, details):
    print('Flow State: {}'.format(state))
    print('Flow Details: {}'.format(details))

def task_watch(state, details):
    print('Task State: {}'.format(state))
    print('Task Details: {}'.format(details))

def fetch(url):
    request = urllib2.Request(url=url)
    response = urllib2.urlopen(request)
    return response.getcode()

class GoogleFetch(task.Task):
    def execute(self, google_url, *args, **kwargs):
        status_code = fetch(google_url)
        print('Google Response Code: {}'.format(status_code))

    def revert(self, google_url, *args, **kwargs):
        print('Magically Reverting the Google Call!')

class AmazonFetch(task.Task):
    def execute(self, amazon_url, *args, **kwargs):
        status_code = fetch(amazon_url)
        print('Amazon Response Code: {}'.format(status_code))

    def revert(self, amazon_url, *args, **kwargs):
        print('Magically Reverting the Amazon Call!')

if __name__ == "__main__":
    flow = lf.Flow('simple-linear-listen').add(
        GoogleFetch(),
        AmazonFetch()
    )

    engine = taskflow.engines.load(flow,
                                   store=dict(
                                       google_url='http://google.com',
                                       amazon_url='HELLO!http://amazon.com'))

    engine.notifier.register('*', flow_watch)
    engine.task_notifier.register('*', task_watch)

    try:
        engine.run()
    except urllib2.URLError:
        print("I think the URL is bad in one of the tasks...")
    except Exception as ex:
        print(ex.message)