improve error handling for non-conformant compositions, e.g. no FSM annotation

Fixes #925

Author: starpit

app/content/css/ui.css

@@ -952,6 +952,11 @@ sidecar.no-limits-data .activation-estimated-cost-container {
 }
 
 /* generic */
+.normal-text {
+    font-weight: 400;
+    opacity: 1;
+    font-size: 1em;
+}
 .deemphasize {
     font-weight: 300;
     font-size: 0.75em;

app/content/js/ui.js

@@ -707,6 +707,7 @@ const ui = (function() {
         container.innerText = beautify(raw, { wrap_line_length: 80 })
         setTimeout(() => hljs.highlightBlock(container), 0)
     }
+    ui.prettyJSON = prettyJSON
 
     /**
      * Beautify any kinds we know how to

app/content/js/usage-error.js

@@ -344,7 +344,7 @@ const format = (message, options={}) => {
                         alias, numeric, aliases=[alias], hidden=false, advanced=false,
                         available,
                         example=numeric&&'N', dir:isDir=available||false,
-                        title, header, docs=title||header, partial=false, allowed, defaultValue } = rowData
+                        title, header, docs=header||title, partial=false, allowed, defaultValue } = rowData
 
                 // row is either hidden or only shown for advanced users
                 if (hidden) return

app/plugins/modules/composer/lib/composer.js

@@ -343,11 +343,10 @@ exports.isValidFSM = maybe => {
  *
  */
 exports.getFSM = entity => {
-    const fsmPair = entity.parameters && entity.parameters.find( ({key}) => key === '$invoke')  // parameter binding?
-          || entity.annotations && entity.annotations.find( ({key}) => key === 'fsm')        // or annotation?
+    const fsmAnnotation = exports.fsmAnnotation(entity)
 
-    if (fsmPair) {
-        return openwhiskComposer.deserialize(fsmPair.value)
+    if (fsmAnnotation) {
+        return openwhiskComposer.deserialize(fsmAnnotation.value)
     }
 }
 
@@ -398,29 +397,44 @@ exports.moveAside = (wsk, name) => repl.qexec(`mv "${name}" "${name}-orig"`)
     }).then(() => ({ ok: name }))*/
 
 /**
- * Merge previous and current and internal annotations
+ * Merge previous and current and internal annotations. Take all of
+ * the new (A2) annotations and add in any old (A1) annotations that
+ * are not replaced by new ones.
  *
  */
 const mergeAnnotations = (A1=[], A2=[], type, fsm) => {
-    const annotations = A1.concat(A2),
-          fsmAnnotation = annotations.find(({key}) => key === 'fsm'),
-          badgesAnnotation = annotations.find(({key}) => key === 'wskng.combinators'),
-          badge = {"type":"composition","role":"replacement","badge":type}
+    // map from annotation key to "is new"
+    const inA2 = A2.reduce((M, {key}) => {
+        M[key] = true
+        return M
+    }, {})
 
-    if (!fsmAnnotation) {
-        annotations.push({ key: 'fsm', value: fsm })
-    } else {
-        fsmAnnotation.value = fsm
-    }
+    // any old annotations are are not replaced by new ones
+    const filteredA1 = A1.filter(({key}) => !inA2[key])
 
-    if (!badgesAnnotation) {
-        annotations.push({ key: 'wskng.combinators', value: [badge] })
-    } else {
-        const existing = badgesAnnotation.value.find(({type}) => type === 'composition')
-        if (existing) {
-            existing.badge = type
+    // the union of old and new
+    const annotations = A2.concat(filteredA1)
+
+    if (type && fsm) {
+        const fsmAnnotation = annotations.find(({key}) => key === 'fsm') || annotations.find(({key}) => key === 'conductor'),
+              badgesAnnotation = annotations.find(({key}) => key === 'wskng.combinators'),
+              badge = {"type":"composition","role":"replacement","badge":type}
+
+        if (!fsmAnnotation) {
+            annotations.push({ key: 'fsm', value: fsm })
         } else {
-            badgesAnnotation.push(badge)
+            fsmAnnotation.value = fsm
+        }
+
+        if (!badgesAnnotation) {
+            annotations.push({ key: 'wskng.combinators', value: [badge] })
+        } else {
+            const existing = badgesAnnotation.value.find(({type}) => type === 'composition')
+            if (existing) {
+                existing.badge = type
+            } else {
+                badgesAnnotation.push(badge)
+            }
         }
     }
 
@@ -452,7 +466,9 @@ exports.create = ({name, fsm, type, annotations=[], parameters=[], wsk, commandT
             // now we merge together the parameters and annotations
             const fsmAction = fsm.encode(fqnAppName).actions[0].action
             fsmAction.parameters = currentAction.parameters.concat(parameters).concat(fsmAction.parameters || []),
-            fsmAction.annotations = mergeAnnotations(currentAction.annotations, annotations.concat(fsmAction.annotations||[]), type, fsm)
+            fsmAction.annotations = mergeAnnotations(currentAction.annotations,
+                                                     mergeAnnotations(annotations||[], fsmAction.annotations||[]),
+                                                     type, fsm)
             return fsmAction
         })
         .then(fsmAction => wsk.owOpts({ // add common flags to the requewst
@@ -482,12 +498,28 @@ exports.update = ({name, entity, fsm, type, wsk, commandTree, execOptions}) => {
  *
  */
 exports.isAnApp = action => {
-    const allManagement = action.annotations && action.annotations.find(({key}) => key === 'wskng.combinators'),
-          anyAppManagement = allManagement && util.isArray(allManagement.value) && allManagement.value.find(({type}) => type === 'composition')
+    const anno = action && action.annotations && action.annotations.find(({key}) => key === 'conductor')
+    return anno && anno.value
+}
+
+/**
+ * Return the annotation that stores the IR/fsm
+ *
+ */
+exports.fsmAnnotation = action => {
+    const anno = action.annotations.find(({key}) => key === 'fsm')
+          || action.annotations.find(({key}) => key === 'conductor')
 
-    return anyAppManagement
+    // avoid conductor:true as indicating the presence of an FSM
+    return anno && anno.value !== true ? anno : undefined
 }
 
+/**
+ * Does the given action have an IR/fsm associated with it?
+ *
+ */
+exports.hasFSM = action => !!exports.fsmAnnotation(action)
+
 /**
  * Helper method for kill and purge operations, which share enough code...
  *
@@ -693,7 +725,7 @@ exports.hasUnknownOptions = (options, expected) => {
  */
 exports.decorateAsApp = ({action, viewName='app', commandPrefix='app get', doVisualize, options}) => {
     action.prettyType = appBadge
-    action.fsm = action.annotations.find(({key}) => key === 'fsm').value
+    action.fsm = exports.fsmAnnotation(action).value
 
     if (action.exec) {
         action.exec.prettyKind = 'app'
@@ -714,7 +746,7 @@ exports.decorateAsApp = ({action, viewName='app', commandPrefix='app get', doVis
             .concat(exports.vizAndfsmViewModes(visualize, commandPrefix, undefined, options))
             .concat(exports.zoomToFitButtons(controller))
 
-        return view
+        return view || action
 
     } else {
         return action

app/plugins/modules/composer/lib/get.js

@@ -18,7 +18,7 @@ const debug = require('debug')('app get')
 debug('loading')
 
 const { app_get:usage } = require('./usage'),
-      { isAnApp, decorateAsApp } = require('./composer')
+      { hasFSM, decorateAsApp } = require('./composer')
 
 const viewName = 'app'
 
@@ -61,7 +61,7 @@ module.exports = (commandTree, prequire) => {
                     const action = response.message || response,
                           execOptions = arguments[5]
 
-                    if (action && action.annotations && action.annotations.find(({key}) => key === 'fsm')) {
+                    if (hasFSM(action)) {
                         const doVisualize = execOptions.override || !execOptions.nested,
                               options = execOptions.originalOptions || {},
                               content = decorateAsApp({ action, doVisualize, options }),

app/plugins/modules/composer/lib/list.js

@@ -64,7 +64,7 @@ module.exports = (commandTree, prequire) => {
 
                 return rawListImpl.apply(undefined, arguments)
                     .then(response => response.map(action => {
-                        if (action && action.annotations && action.annotations.find(({key}) => key === 'fsm')) {
+                        if (isAnApp(action)) {
                             decorateAsApp({action})
                             action.prettyKind = 'composition'
                         }

app/plugins/modules/wskflow/lib/flowCommand.js

@@ -21,7 +21,7 @@ const PromisePool = require('es6-promise-pool'),
       usage = require('../usage'),
       path = require('path'),
       visualize = require('./visualize'),
-      { zoomToFitButtons } = require(path.join(__dirname, '../../composer/lib/composer'))
+      { zoomToFitButtons, fsmAnnotation } = require(path.join(__dirname, '../../composer/lib/composer'))
 
 const viewName = 'session flow'
 
@@ -94,13 +94,19 @@ module.exports = (commandTree, prequire) => {
                 let fsm;
                 if (action.wskflowErr) {
                     // 1) if an app was deleted, the last promise item returns an error
-                    const error = new Error(`${viewName} unavailable, as the composition was deleted`);
+                    const error = new Error(`Sorry, this view is not available, as the composition was deleted`);
                     error.code = 404
                     throw error
 
                 } else {
                     // extract the FSM
-                    fsm = action.annotations.find(({key}) => key === 'fsm').value
+                    const fsmAnno = fsmAnnotation(action)
+                    if (!fsmAnno) {
+                        const error = new Error(`Sorry, this view is not available, as the composition was improperly created`);
+                        error.code = 404
+                        throw error
+                    }
+                    fsm = fsmAnno && fsmAnno.value
                 }
 
                 const {view, controller} = visualize(fsm, undefined, undefined, undefined, activations)