Awesome

Turtle

Apache 2.0 licensed.

Turtle is a toolkit for building and orchestrating event-driven and serverless applications. These apps may run anywhere, either locally or, via execution drivers, in the cloud. It's turtles all the way down.

Execution drivers exist for:

AWS Lambda

Drivers are planned (or in development) for:

Google Cloud Functions
Azure Functions
Docker (Engine & Swarm)

Turtle can:

Chain AWS Lambda Functions and local functions.
Convert NodeJS functions into serverless functions.
Compose applications with HTTP APIs.
Parallelize data into serverless workers (scatter & gather).

CLI

Use the Turtle CLI to create and export npm modules, share code, & provide runtime of magnetic functions. The CLI is still in early development, with our NodeJS SDK being more mature.

Find, download, and/or contribute to this tool in the CLI repo.

SDK

NodeJS SDK:

The NodeJS SDK provides a generic callback chaining mechanism which allows mixing HTTP(S) requests/POSTs, and function calls. Callbacks receive the return of the previous function call or HTTP body.

The callback variable received by a function is also an AWS Lambda-compatible "context" object. Because of this, you can chain standard callback-based NodeJS functions, and functions written for AWS Lambda.

Installation

Installation of the NodeJS module is easy via npm:

$ npm install @iopipe/turtle

Our CLI is still in early development and may be found on the releases page, with further instructions in the CLI repo.

Basic usage:

/* Create a Lambda function which returns event.key + 1. */
var turtle = require("@iopipe/turtle")()

exports.handle = turtle.define(
  (event, context) => {
    context.succeed(event.key + 1)
  }
)

Context argument

The context argument operates as both a callback and an object with several methods, similar to the same argument passed to AWS Lambda functions.

Developers may call context() directly, with its argument passed as the event to the next function, or may call its methods.

Context Methods:

context.done(err, data)
context.succeed(data)
context.fail(err)

Example of using context.fail to pass errors:

var turtle = require("@iopipe/turtle")()

exports.handle = turtle.define(
  (event, context) => {
    try {
      throw "Ford, you're turning into a penguin. Stop it!"
    }
    catch (err) {
      context.fail(err)
    }
  }
)

Function Composition

Turtle supports the composition of functions, HTTP endpoints, and modules, taken from functional-programming and flow-based programming models. This simplifies code-reuse and works as glue between algorithms.

There is (some) compatibility with Rambda for function composition & developing functional applications.

By using function composition, you will gain additional insights and increased granularity when utilizing (upcoming) telementry features.

Example:

/* Return event.int + 1, square the result,
   print, then return the result. */
exports.handle = turtle.define(
  (event, context) => {
    context(event.int + 1)
	},
  (event, context) => {
    context(Math.pow(event, 2))
	},
  (event, context) => {
    console.log(event)
    context(event)
	}
)

HTTP endpoints as "functions"

The first argument to define, if a URL, is fetched via an HTTP get request. Any URL string specified elsewhere in the argument list to define is sent a POST rqeuest.

This first example fetches data from a URL, then performs a POST request to another.

exports.handle = turtle.define("http://localhost/get-data",
                               "http://localhost/post-data")

It's possible to use Turtle to fetch from a URL and perform data transformations via composition as follows:

exports.handle = turtle.define(
  "http://localhost/get-data",
  (data, callback) => {
    console.log("Fetched data: " + data)
  }
)

Often, users will need to use Turtle to fetch a URL somewhere in the middle of a composition and will need to use functional tools such as turtle.fetch. The following example also uses turtle.property, which extracts a key from an ECMAscript Object:

exports.handle = turtle.define(
  turtle.property("url"),
  turtle.fetch,
  (data, callback) => {
    console.log("Fetched data: " + data)
  }
)

Scatter & Gather

Turtle also acts as a client to serverless infrastructure allowing the use of scatter & gather patterns such as map-reduce.

Below we initialize an AWS Lambda Client where a Lambda function may be specified by its Amazon URN and included in the execution chain:

var turtle = require("@iopipe/turtle")()
var turtle_aws = require("@iopipe/turtle")(
  exec_driver: 'aws'
  exec_driver_opts: {
    region: 'us-west-1',
    access_key: 'itsasecrettoeverybody',
    secret_key: 'itsasecrettoeverybody'
  }
)
var crypto = require("crypto")

export.handler = turtle_aws.define("urn:someLambdaFunction",
                                   "urn:anotherLambdaFunction",
                                   turtle.property("property-of-result"),
                                   turtle.fetch, // fetch that as a URL
                                   (event, callback) => {
                                      callback(JSON.parse(event))
                                   },
                                   turtle.map(
                                     iopipe_aws.define(
                                       "urn:spawn_this_on_aws_for_each_value_in_parallel"
                                     )
                                   ))

For more information on using the NodeJS SDK, please refer to its documentation: https://github.com/iopipe/iopipe/blob/master/docs/nodejs.md

Go SDK:

Bundled with the Turtle CLI is a Go SDK, still in early development.

Security

Applications are executed in individual virtual machines whenever allowed by the executing environment. The definition of a virtual machine here is lax, such that it may describe a Javascript VM, a Linux container, or a hardware-assisted x86 virtual machine. Users should exercise caution when running community contributed code.

It is a project priority to make fetching, publishing, and execution of functions secure for a production-ready 1.0.0 release.

Modules are fetched and stored using sha256 hashes, providing an advantage over module-hosting mechanisms which are based simply on a name and version. Future versions of Turtle will likely implement TUF for state-of-the-art software assurance.

Contact security@iopipe.com for questions.