Flow

The Flowlang crate - https://crates.io/crates/flowlang

This repo is published on crates.io and provides a unified Functional Programming API across functions written in Rust, Java, JavaScript, Python and Flow.

The Flow Language

The Flow language is a 3D visual dataflow language, which is based loosely on the Prograph programming language (https://en.wikipedia.org/wiki/Prograph). Flow allows you to construct a diagram of how data flows through your application, and then execute it. The official IDE for the Flow language is Newbound (https://github.com/mraiser/newbound).

Introductory Video:

https://youtu.be/5vZKR4FGJyU

Installation

This repo can be used as a binary or a library. I assume if you are using this to develop something and want to publish something for release, you already know how to convert the below instructions from "debug" to "release". To compile and use as a binary (on Linux):

git clone https://github.com/mraiser/flow.git flow
cd flow
cargo build
mypath=$(pwd)
cd /usr/bin
sudo ln -s $mypath/target/debug/flow flow
sudo ln -s $mypath/target/debug/flowb flowb
cd -

To use as a Rust library, add the following to your Cargo.toml file:

[dependencies]
flowlang = "0.1.15"
# NOTE: Change version to latest version: https://crates.io/crates/flowlang

Executing Flow Code

This repo includes a "data" folder which contains the "testflow" library. You can add your own libraries to the "data" folder, and they will become executable as well. Libraries are created using the Newbound Metabot (https://github.com/mraiser/newbound).

From the command line:

Execute the following from the directory that contains the "data" directory containing your Flow code.

flow testflow testflow test_add <<< "{\"a\": 300,\"b\":120}"

From Rust code:

DataStore::init("data");
Generated::init(); // Load any flow commands written in rust
env::set_var("RUST_BACKTRACE", "1");
{
    let args = DataObject::from_json(serde_json::from_str(r#"
    {
      "a": 299,
      "b": 121
    }
    "#).unwrap());
    let cmd = Command::lookup("testflow", "testflow", "test_add");
    let res = cmd.execute(args).unwrap();
    println!("Hello, my dudes! {}", res.to_json());
}
DataStore::gc();

From a web browser:

# Start the HTTP service from the directory where you installed Flow
flow flowlang http listen <<< "{\"socket_address\": \"127.0.0.1:7878\", \"library\":\"flowlang\", \"control\":\"http\", \"command\":\"parse_request\"}"

Test your HTTP service in a web browser:

http://127.0.0.1:7878/testflow/testflow/test_add?a=42&b=378

Support for commands in multiple languages

Flow commands can be written in Java, Python, Rust, Javascript, or Flow. All languages maintain state between calls. When developing Flow code using Newbound, the IDE automatically builds, compiles, and runs any files needed. Newbound has its own instructions for enabling support for multiple languages (https://github.com/mraiser/newbound). The following only applies to running Flow code outside of the Newbound IDE.

Enabling JavaScript commands:

Since JavaScript support is a feature that is disabled by default, you will have to compile flow with the --features=javascript_runtime flag.

cargo run --features javascript_runtime --bin flow testflow testflow test_javascript <<< "{\"a\":\"world\"}"

Enabling Python commands:

Since Python support is a feature that is disabled by default, you will have to compile flow with the --features=python_runtime flag. You must install Python3 in the local environment first. In order to run Libraries that contain commands written in Python, you will need to generate the Python files.

# To rebuild all rust and python commands, use: flowb all
cargo run --bin flowb testflow testflow test_python
cargo run --features python_runtime --bin flow testflow testflow test_python <<< "{\"a\":\"world\"}"

Enabling Rust commands:

In order to run Libraries that contain commands written in Rust, you will need to generate the Rust files.

# To rebuild all rust and python commands, use: flowb all
cargo run --bin flowb testflow testflow test_rust
cargo run --bin flow testflow testflow test_rust <<< "{\"a\":\"world\"}"

Enabling Java commands

In order to run Libraries that contain commands written in Java, you will need to add data/botmanager, runtime/botmanager, runtime/peerbot, src/Startup.java, src/com, and src/org from Newbound (https://github.com/mraiser/newbound) to your Flow project. Since Java support is a feature that is disabled by default, you will have to compile flow with the --features=java_runtime flag. You will also need to make sure the JDK's libjvm library is in your LD_LIBRARY_PATH.

mkdir bin
mkdir runtime
git clone https://github.com/mraiser/newbound.git newbound
cp -R newbound/data/botmanager data/botmanager
cp -R newbound/runtime/botmanager runtime/botmanager
cp -R newbound/runtime/peerbot runtime/peerbot
cp newbound/src/Startup.java src/Startup.java
cp -R newbound/src/com src/com
cp -R newbound/src/org src/org
cd src
javac -d ../bin Startup.java
cd ../
# Make sure LD_LIBRARY_PATH contains path to libjvm.so 
# Something along the lines of:
export LD_LIBRARY_PATH=/usr/lib/jvm/java-11-openjdk-amd64/lib/server/
# Example from testflow library:
cargo run --bin flow --features=java_runtime testflow testflow test_java <<< "{\"a\":\"world\"}"

Background:

Flow was originally written in Java as part of Newbound, an integrated development environment for peer-to-peer HTML5 web apps. Newbound supports Java, JavaScript, Python, Rust, and Flow for server-side commands, and Javascript and Flow on the front-end. This repository contains a port of the Flow language interpreter from Newbound's Java implementation (https://github.com/mraiser/newbound/blob/master/runtime/botmanager/src/com/newbound/code/Code.java). Newbound also uses this crate to compile and execute Rust code.