Movatterモバイル変換


[0]ホーム

URL:


Skip to content

Navigation Menu

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

Sign up

Flow-based and dataflow programming library for Go (golang)

License

NotificationsYou must be signed in to change notification settings

trustmaster/goflow

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Build Statuscodecov

Status of this branch (WIP)

Warning: you are currently on v1 branch of GoFlow. v1 is a revisit and refactoring of the original GoFlow code which remained almost unchanged for 7 years. This branch is deepin progress, no stability guaranteed. API also may change.

If your code depends on the old implementation, you can build it usingrelease 0.1.

--

GoFlow is a lean and opinionated implementation ofFlow-based programming in Go that aims at designing applications as graphs of components which react to data that flows through the graph.

The main properties of the proposed model are:

  • Concurrent - graph nodes run in parallel.
  • Structural - applications are described as components, their ports and connections between them.
  • Reactive/active - system's behavior is how components react to events or how they handle their lifecycle.
  • Asynchronous/synchronous - there is no determined order in which events happen, unless you demand for such order.
  • Isolated - sharing is done by communication, state is not shared.

Getting started

If you don't have the Go compiler installed, read the officialGo install guide.

Use go tool to install the package in your packages tree:

go get github.com/trustmaster/goflow

Then you can use it in import section of your Go programs:

import"github.com/trustmaster/goflow"

Basic Example

Below there is a listing of a simple program running a network of two processes.

Greeter example diagram

This first one generates greetings for given names, the second one prints them on screen. It demonstrates how components and graphs are defined and how they are embedded into the main program.

package mainimport ("fmt""github.com/trustmaster/goflow")// Greeter sends greetingstypeGreeterstruct {Name<-chanstring// input portReschan<-string// output port}// Process incoming datafunc (c*Greeter)Process() {// Keep reading incoming packetsforname:=rangec.Name {greeting:=fmt.Sprintf("Hello, %s!",name)// Send the greeting to the output portc.Res<-greeting}}// Printer prints its input on screentypePrinterstruct {Line<-chanstring// inport}// Process prints a line when it gets itfunc (c*Printer)Process() {forline:=rangec.Line {fmt.Println(line)}}// NewGreetingApp defines the app graphfuncNewGreetingApp()*goflow.Graph {n:=goflow.NewGraph()// Add processes to the networkn.Add("greeter",new(Greeter))n.Add("printer",new(Printer))// Connect them with a channeln.Connect("greeter","Res","printer","Line")// Our net has 1 inport mapped to greeter.Namen.MapInPort("In","greeter","Name")returnn}funcmain() {// Create the networknet:=NewGreetingApp()// We need a channel to talk to itin:=make(chanstring)net.SetInPort("In",in)// Run the netwait:=goflow.Run(net)// Now we can send some names and see what happensin<-"John"in<-"Boris"in<-"Hanna"// Send end of inputclose(in)// Wait until the net has completed its job<-wait}

Looks a bit heavy for such a simple task but FBP is aimed at a bit more complex things than just printing on screen. So in more complex an realistic examples the infractructure pays the price.

You probably have one question left even after reading the comments in code: why do we need to wait for the finish signal? This is because flow-based world is asynchronous and while you expect things to happen in the same sequence as they are in main(), during runtime they don't necessarily follow the same order and the application might terminate before the network has done its job. To avoid this confusion we listen for a signal on network'swait channel which is sent when the network finishes its job.

Terminology

Here are some Flow-based programming terms used in GoFlow:

  • Component - the basic element that processes data. Its structure consists of input and output ports and state fields. Its behavior is the set of event handlers. In OOP terms Component is a Class.
  • Connection - a link between 2 ports in the graph. In Go it is a channel of specific type.
  • Graph - components and connections between them, forming a higher level entity. Graphs may represent composite components or entire applications. In OOP terms Graph is a Class.
  • Network - is a Graph instance running in memory. In OOP terms a Network is an object of Graph class.
  • Port - is a property of a Component or Graph through which it communicates with the outer world. There are input ports (Inports) and output ports (Outports). For GoFlow components it is a channel field.
  • Process - is a Component instance running in memory. In OOP terms a Process is an object of Component class.

More terms can be found inFlow-based Wiki Terms andFBP wiki.

Documentation

Contents

  1. Components
    1. Ports and Events
    2. Process
    3. State
  2. Graphs
    1. Structure definition
    2. Behavior

Package docs

Documentation for the flow package can be accessed using standard godoc tool, e.g.

godoc github.com/trustmaster/goflow

Links

Here are related projects and resources:

TODO

  • Integration with NoFlo-UI/Flowhub (in progress)
  • Distributed networks via TCP/IP and UDP
  • Reflection and monitoring of networks

About

Flow-based and dataflow programming library for Go (golang)

Topics

Resources

License

Stars

Watchers

Forks


[8]ページ先頭

©2009-2025 Movatter.jp