International Women's Day

Think equal, build smart, innovate for change

Read: Women who Flogo
Flogo Illustration for International Women's Day

Project Flogo is an Open Source ecosystem for event-driven apps

Paste in terminal window and run:
License Type: Beta | License Term: 90 days
I have read and accepted the End User License Agreement

Go to Source

Project Flogo is an ultra-light, Go-based open source ecosystem for building event-driven apps. Event-driven, you say? Yup, the notion of triggers and actions are leveraged to process incoming events. An action, a common interface, exposes key capabilities such as application integration, stream processing, etc.


Project Flogo Ecosystem

All capabilities within the Flogo Ecosystem have a few things in common, they all process events (in a manner suitable for the specific purpose) and they all implement the action interface exposed by Flogo Core.

Some of the key highlights include:

The concept is simple, an event is just that, an event, how it’s processed is what differs. Flogo Core eases the burden by enabling a common set of functionality, such as:

While also exposing a common set of contributions via activities and triggers. For example, all available triggers can be leveraged to dispatch events to any action implementation, that is, flows for application integration, streams for stream processing, rules for contextual rule processing, etc.

Flogo Core

Flogo Core is an event-driven app framework used to develop apps for the cloud & IoT edge. It can also be thought of as a lightweight app kernel used by open source & commercial solutions.

Flogo Core provides the following key benefits:

Flogo Core Contribution Model

Flogo Core exposes three principal contribution interfaces that enable developers to build common capabilities and functionality. These contribution interfaces include:

Repos

Project Flogo consists of the following sub-projects available as separate repos:

Flogo Flows

Flogo Flows provides application integration capabilities and includes the following key highlights.

Getting Started

We've made getting started with Flogo Flows as easy as possible. The current set of tooling is designed for:

Zero-code Developers

If your background is in or you prefer to develop your apps using zero-coding environments, then read on, because we’ve got something special for you.

Flows Web UI is available via Docker Hub or Flogo.io. The Docker image contains the Flows Web UI along with all required components to begin developing, testing and building deployable artifacts right from your web browser.

To report any issues with the Issue tracker on this project.

Flogo Streams

Edge devices have the potential for producing millions or even billions of events at rapid intervals, often times the events on their own are meaningless, hence the need to provide basic streaming operations against the slew of events.

A native streaming action as part of the Project Flogo Ecosystem accomplishes the following primary objectives:

Some of the key highlights include:

Getting Started

We’ve made building powerful streaming pipelines as easy as possible. Develop your pipelines using:

See the sample below of an aggregation pipeline (for brevity, the triggers and metadata of the resource has been omitted). Also don’t forget to check out the examples in the project-flogo/stream repo.

  "stages": [
    {
      "ref": "github.com/TIBCOSoftware/flogo-contrib/activity/aggregate",
      "settings": {
        "function": "sum",
        "windowType": "timeTumbling",
        "windowSize": "5000"
      },
      "input": {
        "value": "=$.input"
      }
    },
    {
      "ref": "github.com/TIBCOSoftware/flogo-contrib/activity/log",
      "input": {
        "message": "=$.result"
      }
    }
  ]

Flogo Rules

Processing Events in real-time to determine next best action is an important function of Event driven applications. With the vast amount of events that are generated from different sources, making sense of the information in a given context can be immensely valuable.

Flogo Rules simplifies the complexity involved with real-time contextual decisions.

Flogo Rules supports

The CLI

The CLI is used to build all applications that leverage the JSON-based DSL. If you’re using the Go API to build your apps, feel free to just go build your stuff without the flogo CLI.

Getting started with the CLI couldn't be any easier (refer to Flogo CLI repo for detail instructions and dependencies):

go get -u github.com/TIBCOSoftware/flogo-cli/...
Flogo CLI animation
  • flogo the core CLI for creating and building your applications
  • flogogen a scaffolding tool to begin building your Flogo contributions (activities, triggers & actions)
  • If you're interested in building your own contribution(s), refer to the Flogo Documentation or join us on the project-flogo/Lobby Gitter Channel.

    Golang API

    Are you the kind of person who would rather code, but would love to leverage the capabilities of the Flogo Ecosystem? Makes total sense, we just to code also! We’ve exposed a number of Go APIs for leveraging the various action types, activities and triggers. Getting started is pretty easy, just follow the steps below.

    go get -u github.com/TIBCOSoftware/flogo-lib/...
    go get -u github.com/TIBCOSoftware/flogo-contrib/...
    package main
    
    import (
    	"context"
    
    	"github.com/TIBCOSoftware/flogo-contrib/trigger/rest"
    	"github.com/TIBCOSoftware/flogo-lib/core/data"
    	"github.com/TIBCOSoftware/flogo-lib/engine"
    	"github.com/TIBCOSoftware/flogo-lib/flogo"
    	"github.com/TIBCOSoftware/flogo-lib/logger"
    )
    
    //go:generate go run $GOPATH/src/github.com/TIBCOSoftware/flogo-lib/flogo/gen/gen.go $GOPATH
    
    func main() {
    
    	// Create our Flogo app
    	app := flogo.NewApp()
    
    	// Setup our event trigger (HTTP REST in this case).
    
    	// Listen on port 9999
    	trg := app.NewTrigger(&rest.RestTrigger{}, map[string]interface{}{"port": 9999})
    
    	// Create a Function Handler for verb: GET and URI path: /blah
    	trg.NewFuncHandler(map[string]interface{}{"method": "GET", "path": "/blah"}, HandleHttpEvent)
    
    	// Create the Flogo engine
    	e, err := flogo.NewEngine(app)
    
    	if err != nil {
    		logger.Error(err)
    		return
    	}
    
    	// Start your engine!
    	engine.RunEngine(e)
    }
    
    // HandleHttpEvent handles events being dispatched by the function handler. 
    // All GET requests to http://localhost:9999/blah events will handled by this function
    func HandleHttpEvent(ctx context.Context, inputs map[string]*data.Attribute) (map[string]*data.Attribute, error) {
    
    	logger.Infof("#v", inputs)
    
    	return nil, nil
    }
    go generate
    go build

    For additional examples, including how to leverage a flow that has already been built by the Web UI, refer to the wiki.

    When to use Flogo

    You’ll look to leverage Flogo if you’re a dev & sick of building all the messy stuff that comes along with coding production apps. Such as connectivity to event-driven messaging platforms, datastores, SaaS apps, etc & want to deploy to a wide range of targets, such as

    The broader Flogo ecosystem exposes an opinionated perspective on building event-driven apps. If you’re looking to process events in any of the following ways, then read on because the Project Flogo Ecosystem is for you!

    In short...

    Flogo is... Flogo is not...
    an ecosystem of opinionated, event-driven capabilities a front-end web app or analytics framework
    a Go lib to increase dev productivity an IoT platform

    Contributing

    Want to contribute to Project Flogo? We've made it easy, all you need to do is fork the repository you intend to contribute to, make your changes and create a Pull Request! Once the pull request has been created, you'll be prompted to sign the CLA (Contributor License Agreement) online.

    Not sure where to start? No problem, here are a few suggestions:

    If you have any questions, feel free to post an issue and tag it as a question, email flogo-oss@tibco.com or chat with the team and community:

    For additional details, refer to the Contribution Guidelines.

    License

    The top level flogo repo, consisting of flow samples & documentation, is licensed licensed under a BSD-style license. Refer to LICENSE for license text.

    Flogo source code in flogo-cli, flogo-lib, flogo-contrib, flogo-services, project-flogo/stream & project-flogo/rules are all licensed under a BSD-style license, refer to LICENSE

    Usage Guidelines

    We’re excited that you’re using Project Flogo to power your project(s). Please adhere to the usage guidelines when referencing the use of Project Flogo within your project(s) and don't forget to let others know you're using Project Flogo by proudly displaying one of the following badges or the Flynn logo, found in the branding folder of this project.

    Get Started with Flogo

    Flogo is yours to build upon and contribute to. See what can you do with Flogo.

    Paste in terminal window and run:
    License Type: Beta | License Term: 90 days
    I have read and accepted the End User License Agreement

    Go to Source