Use conductor actions to implement compositions (#37)

Composer now generates conductor actions to implement compositions. This resolves double billing and restores substitution. Compositions support blocking invocations and may be designated as web actions. Redis is no longer required to run compositions.


The JSON serialization format has evolved to retain the original code structure (sequences, conditionals...). The compilation to finite state machines now happens when the action container is initialized.


The scheduling code is now stitched to the composition JSON to produce a self-contained action that implements the composition, resolving possible versioning or dangling reference issues.

New constructs have been added including finally and dowhile.

A composition may now include the definition of component actions and compositions.


A compose shell script is provided to serialize compositions to the JSON format and deploy them. An extension of the Javascript client for OpenWhisk can do the same. Deployment takes care of nested actions and compositions.

The composer module now regroups the client-side and server-side code in one file.

Author: tardieu

README.md

@@ -5,25 +5,26 @@
 Composer is a new programming model from [IBM
 Research](https://ibm.biz/serverless-research) for composing [IBM
 Cloud Functions](https://ibm.biz/openwhisk), built on [Apache
-OpenWhisk](https://github.com/apache/incubator-openwhisk).  Composer
-extends Functions and sequences with more powerful control flow and
-automatic state management. With it, developers can build even more
+OpenWhisk](https://github.com/apache/incubator-openwhisk).
+With composer, developers can build even more
 serverless applications including using it for IoT, with workflow
 orchestration, conversation services, and devops automation, to name a
 few examples.
 
-Composer helps you express cloud-native apps that are serverless by
-construction: scale automatically, and pay as you go and not for idle
-time. Programming compositions for IBM Cloud Functions is done via the
-[functions shell](https://github.com/ibm-functions/shell), which
+Composer extends Functions and sequences with more powerful control
+flow and automatic state management.
+Composer helps express cloud-native apps that are serverless by
+construction: scale automatically, pay as you go and not for idle time.
+
+The [IBM Cloud functions shell](https://github.com/ibm-functions/shell)
 offers a CLI and graphical interface for fast, incremental, iterative,
 and local development of serverless apps. Some additional highlights
 of the shell include:
 
-* Edit your code and program using your favorite text editor, rather than using a drag-n-drop UI
-* Validate your compositions with readily accessible visualizations, without switching tools or using a browser
-* Deploy and invoke compositions using familiar CLI commands
-* Debug your invocations with either familiar CLI commands or readily accessible visualizations
+* Edit your code and program using your favorite text editor, rather than using a drag-n-drop UI.
+* Validate compositions with readily accessible visualizations, without switching tools or using a browser.
+* Deploy and invoke compositions using familiar CLI commands.
+* Debug invocations with either familiar CLI commands or readily accessible visualizations.
 
 Composer and shell are currently available as IBM Research
 previews. We are excited about both and are looking forward to what
@@ -39,11 +40,9 @@ you to [join us on slack](http://ibm.biz/composer-users).
 
 This repository includes:
 
- * [tutorial](docs) for getting started with Composer in the [docs](docs) folder,
- * [composer](composer.js) node.js module to author compositions using JavaScript,
- * [conductor](conductor.js) action code to orchestrate the execution of compositions,
- * [manager](manager.js) node.js module to query the state of compositions,
- * [test-harness](test-harness.js) helper module for testing composer,
- * [redis-promise](redis-promise.js) helper module that implements a promisified redis client for node.js,
+ * a [composer](composer.js) node.js module to author compositions using JavaScript,
+ * a [compose](bin/compose) shell script for deploying compositions,
+ * a [tutorial](docs/README.md),
+ * a [reference manual](docs/COMPOSER.md),
  * example compositions in the [samples](samples) folder,
- * unit tests in the [test](test) folder.
+ * tests in the [test](test) folder.

bin/compose

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const fs = require('fs')
+const vm = require('vm')
+const minimist = require('minimist')
+const composer = require('../composer')
+
+const argv = minimist(process.argv.slice(2), { string: ['apihost', 'auth', 'deploy'], boolean: 'insecure', alias: { auth: 'u', insecure: 'i' } })
+
+if (argv._.length !== 1) {
+    console.error('Usage: compose <composition.js[on]> [--deploy <name>] [--apihost <host>] [--auth <key>] [--insecure]')
+    return
+}
+
+const filename = argv._[0]
+const source = fs.readFileSync(filename, { encoding: 'utf8' })
+const composition = filename.slice(filename.lastIndexOf('.')) === '.js' ? vm.runInNewContext(source, { composer, require, console, process }) : composer.deserialize(JSON.parse(source))
+if (argv.deploy) {
+    const options = { ignore_certs: argv.insecure }
+    if (argv.apihost) options.apihost = argv.apihost
+    if (argv.auth) options.api_key = argv.auth
+    composer.openwhisk(options).compositions.deploy(composition,argv.deploy).catch(console.error)
+} else {
+    console.log(JSON.stringify(composition, null, 4))
+}