@scion-scxml/express-middleware 1.0.0 → 2.0.0

package/CHANGES

@@ -0,0 +1,12 @@
+== 2.0.0 ==
+
+Modify API handleScxmlEvent to accept kwArgs. Allow handleScxmlEvent to accept an optional executionContext param
+
+== 1.0.3 ==
+
+Fix issue in scion express middleware: on initializing the new session, it was not waiting for the asynchronous database write to finish before calling the callback, so a subsequent event could be processed before the the serialized session was finished writing to the database
+
+
+== 1.0.2 ==
+
+Added support for automatic serialization to secondary storage (mongodb) of multi-level state machine on processing event and creation of new state machine instance. 

package/lib/index.js

@@ -1,6 +1,11 @@
 const path = require('path');
 const express = require('express')
 const monitorMiddlewareClient = require('@scion-scxml/monitor-middleware/client')
+const {
+  initializeRootSessionToSerializeAutomaticallyOnBigStepEndAndInvokedSessionInitialized,
+  handleInterpreterBigStepEnd
+} = require('./multilevel-state-machine-ser-des')
+const uuid = require('uuid')
 
 /*
  * options: 
@@ -8,7 +13,8 @@ const monitorMiddlewareClient = require('@scion-scxml/monitor-middleware/client'
 module.exports = function ({
   app,
   scxml,
-  pathToScxmlSrcDir
+  pathToScxmlSrcDir,
+  db
 }){
 
   //set the mime type
@@ -16,10 +22,8 @@ module.exports = function ({
 
   //serve static files
   const scxmlSrcDirExpressMountPath = '/scion/static/src'
-  app.use(scxmlSrcDirExpressMountPath, express.static(pathToScxmlSrcDir))
 
   const pathToDashboard = path.dirname(path.dirname(path.dirname(require.resolve('@scion-scxml/dashboard'))));
-  app.use('/scion/static/dashboard', express.static(pathToDashboard))
 
   //init sse
   monitorMiddlewareClient.init(scxml, {broadcast})
@@ -27,20 +31,6 @@ module.exports = function ({
   let sseResponses = new Set();
   let messageCount = 0;
 
-  //TODO: prefix this with "scion"
-  app.get('/api/update-stream', function(req, res){
-     res.writeHead(200, {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive'
-    });
-    res.write('\n');
-    sseResponses.add(res);
-    req.on("close", function() {
-      sseResponses.delete(res);
-    });
-  });
-
   function broadcast(messageName, messageData){
     //rewrite the docUrl
     messageData.meta.docUrl = path.join(scxmlSrcDirExpressMountPath, path.basename(messageData.meta.docUrl))
@@ -50,5 +40,209 @@ module.exports = function ({
       res.write("data: " + JSON.stringify(messageData) + '\n\n'); // Note the extra newline
     }
   }
+
+  const modelCache = {}
+  const fnModelCache = {}
+
+  function initModel({scxmlName, executionContext}, cb){
+    scxml.pathToModel(`${pathToScxmlSrcDir}/${scxmlName}.scxml`, function(err, model){
+      if(err){ 
+        return cb(err);
+      }
+      modelCache[scxmlName] = model
+      model.prepare(function(err, fnModel) {
+        if(err){ 
+          return cb(err);
+        }
+        fnModelCache[scxmlName] = fnModel
+        return cb(null, fnModel)
+      }, executionContext)
+    })
+  }
+
+  function initModelOrFetchFromCache({scxmlName, executionContext}, cb){
+    if(!fnModelCache[scxmlName]){
+      initModel({scxmlName, executionContext}, (err, fnModel) => {
+        if(err) {
+          return cb(err)
+        }
+        cb(null, fnModel)
+      })
+    } else {
+      cb(null, fnModelCache[scxmlName])
+    }
+  }
+
+  scxml.core.BaseInterpreter.generateSessionid = uuid.v4
+  scxml.core.BaseInterpreter.doSend = doSend
+
+  // TODO write a custom invoker based on invokeNewSession
+  //core.InterpreterScriptingContext.invokers = customInvokeTypes;    //TODO: set up default invokers
+
+  function invokeNewSession({scxmlName, sessionid, executionContext }, cb){
+    initModelOrFetchFromCache({ scxmlName, executionContext },  (err, fnModel) => {
+
+      if(err) return cb(err);
+
+      //instantiate the interpreter
+      const sc1 = new scxml.core.Statechart(fnModel, {doSend, sessionid});
+      initializeRootSessionToSerializeAutomaticallyOnBigStepEndAndInvokedSessionInitialized(null, sc1, db)
+      handleInterpreterBigStepEnd(null, sc1, db, 'once', (err) => {
+        if(err) return cb(err)
+      
+        //save the snapshot to the database
+        const snapshot = sc1.getSnapshot()
+        const sessionId = sc1.opts.sessionid
+
+        cb(null, {sessionId, snapshot})
+      })
+
+      sc1.start();
+    })
+  }
+
+
+
+  function doSend(session, event){
+    //console.log('session', session)
+    const scxmlName = path.basename(session._model.docUrl, '.scxml')
+    handleScxmlEvent({scxmlName, sessionId: session.opts.sessionid, event, cb: (err, newSnapshot) => {
+      if(err) throw err
+      console.log('new snapshot for event', JSON.stringify(event,4,4), newSnapshot)
+    }})
+  }
+
+  //TODO: use the database as an event queue to support multi-tenancy (horizontal scaling)
+  function handleScxmlEvent({scxmlName, sessionId, executionContext, event, cb}){
+    //console.log('handleScxmlEvent, scxmlName, sessionId, event', scxmlName, sessionId, event)
+    initModelOrFetchFromCache({scxmlName, executionContext}, (err, fnModel) => {
+      
+      if(err) return cb(err)
+
+      db.findOne({sessionid: sessionId}, (err, dbResult) => {
+
+        if(!dbResult){
+          console.error("Session not found", scxmlName, sessionId)
+          return cb(null, null)
+        }
+        
+        const {
+          sessionid, 
+          docUrl, 
+          invokeid, 
+          parentSession : parentSessionStub,
+          snapshot,
+          invokeMap : serializedInvokeMap,
+        } = dbResult
+
+        // complete the stub session
+        if(parentSessionStub){
+          parentSessionStub.cancel = cancelSession
+        }
+
+        if(err) return cb(err)
+          
+        // populate the invoke map with stub sessions
+        const invokeMap = {}
+        if(serializedInvokeMap){
+          Object.entries(serializedInvokeMap).map( ([key, value]) => {
+            invokeMap[key] = new Promise((resolve, reject) => {
+              value.cancel = cancelSession
+              resolve(value);
+            });
+          })
+        }
+
+        //instantiate the interpreter
+        const sc1 = new scxml.core.Statechart(fnModel, {
+          snapshot, 
+          sessionid: sessionId, 
+          doSend,
+          parentSession: parentSessionStub,
+          _invokeMap : invokeMap,
+          invokeid
+        });
+        initializeRootSessionToSerializeAutomaticallyOnBigStepEndAndInvokedSessionInitialized(parentSessionStub, sc1, db)
+        handleInterpreterBigStepEnd(parentSessionStub, sc1, db, 'once', (err) => {
+
+          if(err) return cb(err)
+
+          //save the snapshot to the database
+          const newSnapshot = sc1.getSnapshot()
+
+          if(cb) cb(null, newSnapshot)
+        })
+
+        sc1.gen(event)
+      })
+    })
+  }
+
+  function cancelSession(){
+    // TODO: we would need to clear any timeout events. This means clearing any events with timeouts that are still on the queue originating from this session. Will add this when we have chosen an asynchronous queue. 
+    // for now, we just delete him in the database
+    db.deleteOne({sessionid: this.opts.sessionid}, (err) => {
+      if(err) throw err;
+    }) 
+  }
+
+	if(app){
+		app.use(scxmlSrcDirExpressMountPath, express.static(pathToScxmlSrcDir))
+		app.use('/scion/static/dashboard', express.static(pathToDashboard))
+		//TODO: prefix this with "scion"
+		app.get('/api/update-stream', function(req, res){
+			 res.writeHead(200, {
+				'Content-Type': 'text/event-stream',
+				'Cache-Control': 'no-cache',
+				'Connection': 'keep-alive',
+				'X-Accel-Buffering': 'no'
+			});
+			res.write('\n');
+			sseResponses.add(res);
+			req.on("close", function() {
+				sseResponses.delete(res);
+			});
+		});
+
+		// API to init new session
+		app.post('/scion/:scxmlName', (req, res, next) => {
+			const scxmlName = req.params.scxmlName
+			invokeNewSession({scxmlName}, (err, {sessionId, snapshot}) => {
+				res.json({
+					sessionId,
+					snapshot 
+				})
+			})
+		});
+
+		// API to send event to session
+		app.post('/scion/:scxmlName/:sessionId', (req, res) => {
+
+			const scxmlName = req.params.scxmlName,
+				sessionId = req.params.sessionId;
+
+			const evt = req.body
+
+			//read the sessionId
+			// TODO: handle error where sessionId does not exist
+			handleScxmlEvent({scxmlName, sessionId, event, cb: (err, newSnapshot) => {
+
+				if(err) throw err;
+
+				res.json({
+					sessionId,
+					snapshot : newSnapshot
+				})
+			}})
+
+			//rehydrate the session
+		})
+	}
+
+	return {
+		invokeNewSession,
+		sendEvent: handleScxmlEvent,
+	}
+	
 }
 

package/lib/multilevel-state-machine-ser-des.js

@@ -0,0 +1,109 @@
+const fs = require('fs')
+const core = require('@scion-scxml/core')
+const util = require('util')
+
+function serializeInvokeMap(invokeMap){
+  const invokeIds = Object.keys(invokeMap)
+  return Promise.all(
+    invokeIds.map( invokeId => 
+      invokeMap[invokeId]
+    )
+  ).then(invokedSessions => {
+    const o = {}
+    invokedSessions.forEach( (session, index) => o[invokeIds[index]] = { 
+      opts : {
+        sessionid : session.opts.sessionid,
+      },
+      _model : { 
+        docUrl : session._model.docUrl
+      }
+    })
+    return o
+  })
+}
+
+function handleInterpreterBigStepEnd(parentSession, interpreter, dbAdapter, method, cb){
+  interpreter[method || 'on']('onBigStepEnd',(e) => {
+    if((e && e.name === "done.state.$generated-scxml-0") || interpreter.isFinal()) return;
+    // persist the state machine state
+    const sessionid = interpreter.opts.sessionid,
+      invokeid = interpreter.opts.invokeid,
+      snapshot = interpreter.getSnapshot(),
+      docUrl = interpreter._model.docUrl;
+
+    //console.log(sessionid, invokeid, interpreter.opts._invokeMap)
+    //console.log('persist state machine snapshot', snapshot)
+
+    //upsert
+    const query = { sessionid };
+    const update = { $set: {
+      parentSession: parentSession && {
+        opts : {
+          sessionid : parentSession.opts.sessionid,
+        },
+        _model : { 
+          docUrl : parentSession._model.docUrl
+        }
+      },
+      sessionid,
+      invokeid,
+      snapshot,
+      docUrl,
+    }};
+    const options = { upsert: true };
+    console.log('upsert onBigStepEnd', query, JSON.stringify(update, 4, 4))
+    dbAdapter.updateOne(query, JSON.parse(JSON.stringify(update)), options, cb || ((err, result) => {if(err) throw err;}));
+  })
+}
+
+function handleInvokedSessionInitialized(rootSession, dbAdapter, invokedInterpreter){
+
+  //clear the serialized session on exit
+  invokedInterpreter.on('onExitInterpreter', () => {
+    const sessionid = invokedInterpreter.opts.sessionid;
+
+    dbAdapter.deleteOne({sessionid}, (err, result) => {if(err) throw err;});
+  });
+
+  process.nextTick(() => {
+    serializeInvokeMap(rootSession._scriptingContext._invokeMap).then(serializedInvokeMap => {
+
+      const sessionid = rootSession.opts.sessionid,
+        invokeid = rootSession.opts.invokeid,
+        snapshot = rootSession.getSnapshot(),
+        docUrl = rootSession._model.docUrl;
+
+      //update invokeMap on the root session
+      const query1 = { sessionid: rootSession.opts.sessionid };
+      const update1 = { $set: { invokeMap : serializedInvokeMap }};
+      dbAdapter.updateOne(query1, JSON.parse(JSON.stringify(update1)), {}, (err, result) => {if(err) throw err;});
+      //console.log('upsert 1 onInvokedSessionInitialized', query1, util.inspect(update1, {depth: null}))
+
+      //upsert a session
+      const query2 = { sessionid };
+      const update2 = { $set: {
+        sessionid,
+        invokeid,
+        snapshot,
+        docUrl,
+        invokeMap : serializedInvokeMap
+      }};
+      const options = { upsert: true };
+      //console.log('upsert 2 onInvokedSessionInitialized', query2, util.inspect(update2, {depth: null}))
+      dbAdapter.updateOne(query2, JSON.parse(JSON.stringify(update2)), options, (err, result) => {if(err) throw err;});
+    })
+  })
+
+  handleInterpreterBigStepEnd(rootSession, invokedInterpreter, dbAdapter)
+}
+
+function initializeRootSessionToSerializeAutomaticallyOnBigStepEndAndInvokedSessionInitialized(parentSession, session, dbAdapter, handleParentSession){
+  if(handleParentSession) handleInterpreterBigStepEnd(parentSession, session, dbAdapter);
+  session.on('onInvokedSessionInitialized', handleInvokedSessionInitialized.bind(this, session, dbAdapter));
+}
+
+module.exports = {
+  initializeRootSessionToSerializeAutomaticallyOnBigStepEndAndInvokedSessionInitialized,
+  handleInterpreterBigStepEnd
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scion-scxml/express-middleware",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
@@ -9,10 +9,13 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@scion-scxml/core": "^2.6.22",
-    "@scion-scxml/dashboard": "^1.0.24",
-    "@scion-scxml/monitor-middleware": "^1.0.19",
-    "@scion-scxml/scxml": "^4.3.25",
-    "express": "^4.17.1"
-  }
+    "@scion-scxml/core": "^2.6.24",
+    "@scion-scxml/dashboard": "^1.0.26",
+    "@scion-scxml/monitor-middleware": "^1.0.21",
+    "@scion-scxml/scxml": "^4.3.27",
+    "express": "^4.17.1",
+    "mongodb": "^3.6.8",
+    "uuid": "^8.3.2"
+  },
+  "gitHead": "25f3db4baa9a9aae69b014b07c7533a18b73fc8c"
 }

package/test/app.js

@@ -1,3 +1,4 @@
+var MongoClient = require('mongodb').MongoClient;
 var path = require('path')
 var createError = require('http-errors');
 var express = require('express');
@@ -25,57 +26,45 @@ app.use(express.json());
 app.use(express.urlencoded({ extended: false }));
 app.use(cookieParser());
 
+const url = "mongodb://localhost:27017/";
+MongoClient.connect(url, function(err, db) {
+  if (err) throw err;
+  console.log("Database created!");
 
-//init the scion middleware
-scionMiddleware({
-  app,
-  scxml,
-  pathToScxmlSrcDir: path.join(__dirname, 'scxml')
-})
+  const dbo = db.db("mydb");
 
-app.use(express.static(path.join(__dirname, 'public')));
-
-app.use('/', indexRouter);
-app.use('/users', usersRouter);
-
-// catch 404 and forward to error handler
-app.use(function(req, res, next) {
-  next(createError(404));
-});
-
-// error handler
-app.use(function(err, req, res, next) {
-  // set locals, only providing error in development
-  res.locals.message = err.message;
-  res.locals.error = req.app.get('env') === 'development' ? err : {};
-
-  // render the error page
-  res.status(err.status || 500);
-  res.render('error');
-});
+  scionMiddleware({
+    app,
+    scxml,
+    pathToScxmlSrcDir: path.join(__dirname, 'scxml'),
+    db: dbo.collection('sessions')
+  })
 
+  app.use(express.static(path.join(__dirname, 'public')));
 
-//init an SCXML file and simulate it
-scxml.pathToModel(path.join(__dirname,'scxml', 'doc.scxml'), function(err,model){
-  if(err) throw err;
-  model.prepare((err, fnModel) => {
-    if(err) throw err;
+  app.use('/', indexRouter);
+  app.use('/users', usersRouter);
 
-    //instantiate the interpreter
-    const rootSession = new scxml.core.Statechart(fnModel);
+  // catch 404 and forward to error handler
+  app.use(function(req, res, next) {
+    next(createError(404));
+  });
 
-    rootSession.on('onInvokedSessionInitialized', function(invokedInterpreter){
-      invokedInterpreter._scriptingContext = rootSession._scriptingContext; //FIXME: workaround for bug in inter-session communication: https://gitlab.com/scion-scxml/scion/issues/3
-    });
+  // error handler
+  app.use(function(err, req, res, next) {
+    // set locals, only providing error in development
+    res.locals.message = err.message;
+    res.locals.error = req.app.get('env') === 'development' ? err : {};
 
-    //start the machine
-    rootSession.start();    
+    // render the error page
+    res.status(err.status || 500);
+    res.render('error');
+  });
+  
+});
 
-  }, {
-    console: console,
-  })
-})
 
 
 
 module.exports = app;
+

package/test/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scion-scxml/express-middleware-test",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "private": true,
   "scripts": {
     "start": "node ./bin/www"
@@ -12,6 +12,5 @@
     "http-errors": "~1.6.3",
     "jade": "~1.11.0",
     "morgan": "~1.9.1"
-  },
-  "private": true
+  }
 }

package/test/scxml/main.scxml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<scxml name="Scxml"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.w3.org/2005/07/scxml
+						https://www.w3.org/2011/04/SCXML/scxml.xsd"
+	xmlns="http://www.w3.org/2005/07/scxml"
+	xmlns:conf="http://www.w3.org/2005/scxml-conformance" datamodel="ecmascript" version="1.0">
+
+	<state>
+		<state id="m1">
+			<invoke id="sub1" type="http://www.w3.org/TR/scxml/" src="sub1.scxml" autoforward="true" />
+			<transition event="done.invoke.sub1" target="m2"/>
+		</state>
+
+		<state id="m2">
+			<invoke id="sub2" type="http://www.w3.org/TR/scxml/" src="sub2.scxml" autoforward="true" />
+			<transition event="done.invoke.sub2" target="m3"/>
+		</state>
+
+		<state id="m3">
+			<invoke id="sub3" type="http://www.w3.org/TR/scxml/" src="sub3.scxml" autoforward="true" />
+			<transition event="done.invoke.sub3" target="end"/>
+		</state>
+
+		<final id="end">
+			<onentry>
+				<log expr="'Done.'" label="INFO"/>
+			</onentry>
+		</final>
+
+	</state>
+</scxml>

package/test/scxml/sub1.scxml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<scxml name="Scxml"
+	xmlns="http://www.w3.org/2005/07/scxml"
+	xmlns:conf="http://www.w3.org/2005/scxml-conformance" datamodel="ecmascript" version="1.0">
+
+	<state>
+		<transition event="*">
+			<log expr="`sub1 EVENT: ${_event.name}, ${_event.data}`" label="INFO"/>
+		</transition>
+
+		<transition event="error.*">
+			<log expr="_event" label="ERROR"/>
+		</transition>
+
+		<state id="start">
+			<onentry>
+				<log expr="`Entered sub1 start`" label="INFO"/>
+			</onentry>
+
+			<transition event="tick" cond="_event.data === 1" target="end"/>
+		</state>
+
+	</state>
+  <final id="end"/>
+</scxml>

package/test/scxml/sub2.scxml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<scxml name="Scxml"
+	xmlns="http://www.w3.org/2005/07/scxml"
+	xmlns:conf="http://www.w3.org/2005/scxml-conformance" datamodel="ecmascript" version="1.0">
+
+	<state>
+		<transition event="*">
+			<log expr="`sub2 EVENT: ${_event.name}, ${_event.data}`" label="INFO"/>
+		</transition>
+
+		<transition event="error.*">
+			<log expr="_event" label="ERROR"/>
+		</transition>
+
+		<state id="start">
+			<onentry>
+				<log expr="`Entered sub2 start`" label="INFO"/>
+			</onentry>
+
+			<transition event="tick" cond="_event.data === 2" target="middle"/>
+		</state>
+
+		<state id="middle">
+			<onentry>
+				<log expr="`Entered sub2 middle`" label="INFO"/>
+			</onentry>
+
+			<transition event="tick" cond="_event.data === 3" target="end"/>
+		</state>
+
+	</state>
+  <final id="end"/>
+</scxml>

package/test/scxml/sub3.scxml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<scxml name="Scxml"
+	xmlns="http://www.w3.org/2005/07/scxml"
+	xmlns:conf="http://www.w3.org/2005/scxml-conformance" datamodel="ecmascript" version="1.0">
+
+	<state>
+		<transition event="*">
+			<log expr="`sub3 EVENT: ${_event.name}, ${_event.data}`" label="INFO"/>
+		</transition>
+
+		<transition event="error.*">
+			<log expr="_event" label="ERROR"/>
+		</transition>
+
+		<state id="start">
+			<onentry>
+				<log expr="`Entered sub3 start`" label="INFO"/>
+			</onentry>
+
+			<transition event="tick" cond="_event.data === 4" target="end"/>
+		</state>
+	</state>
+  <final id="end"/>
+</scxml>

package/test/scxml/test.scxml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<scxml 
+    datamodel="ecmascript"
+    xmlns="http://www.w3.org/2005/07/scxml"
+    version="1.0">
+
+    <state id="a">
+        <transition target="b" event="t1"/>
+    </state>
+
+    <state id="b">
+        <transition target="a" event="t2"/>
+    </state>
+
+</scxml>
+
+

package/test/scxml/test2.scxml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<scxml name="Scxml"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.w3.org/2005/07/scxml
+						https://www.w3.org/2011/04/SCXML/scxml.xsd"
+	xmlns="http://www.w3.org/2005/07/scxml"
+	xmlns:conf="http://www.w3.org/2005/scxml-conformance" datamodel="ecmascript" version="1.0">
+
+  <datamodel>
+    <data id="x" expr="0"/>
+  </datamodel>
+
+	<state>
+		<transition event="*">
+			<log expr="`test2 EVENT: ${_event.name}, ${JSON.stringify(_event.data)}`" label="INFO"/>
+		</transition>
+    <state id="m1">
+      <invoke id="test2sub1" type="http://www.w3.org/TR/scxml/" src="test2sub1.scxml"/>
+      <state id="m1.1">
+        <transition event="test2sub1.ready" target="m1.2"/>
+      </state>
+      <state id="m1.2">
+        <onentry>
+          <log label="x" expr="x"/>
+          <send target="#_test2sub1" event="foo" delay="1s">
+            <param name="x" expr="x+1"/>
+          </send>
+        </onentry>
+        <transition event="done.invoke.test2sub1" target="m1"/>
+      </state>
+    </state>
+  </state>
+</scxml>

package/test/scxml/test2sub1.scxml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<scxml name="Scxml"
+	xmlns="http://www.w3.org/2005/07/scxml"
+	xmlns:conf="http://www.w3.org/2005/scxml-conformance" datamodel="ecmascript" version="1.0">
+
+	<state>
+		<transition event="*">
+			<log expr="`test2sub1 EVENT: ${_event.name}, ${JSON.stringify(_event.data)}`" label="INFO"/>
+		</transition>
+    <state id="initial">
+      <onentry>
+        <send target="#_parent" event="test2sub1.ready" delay="1s"/>
+      </onentry>
+      <transition event="foo" target="end"/>
+    </state>
+  </state>
+
+  <final id="end"/>
+</scxml>
+