flor 0.16.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b973449e80aa849aee7d3fade7ab13fe57a0b6a1
-  data.tar.gz: a09d4a0b88d453b42742bb8814d5cee1f957c2c2
+SHA256:
+  metadata.gz: 7a1f76874a9957b7c15c59baf997e0e60ff4872b9109a7cd741692735a94565c
+  data.tar.gz: 7fd1552910609023dd8bce0de0d5b5fc1ebc5ae1674fc27f0d0cb932c4bab2a7
 SHA512:
-  metadata.gz: 139a8cf68527edcdff12137a9ac831eee6fb9867a49ed9fe24d462efce7f3d53f9396de2302b449f963c1e74fe4e67b5590f04ad5605a6996bb35e6e0f7015ad
-  data.tar.gz: 9de9e3bb4f12f2cb1b48ae0aa4d024ce4ce557b380d5b476c03dae7a7db63480ec041269702102a40165a3ed8ecb290d7b2c77299f999fdf605071976c2f99ea
+  metadata.gz: cbca621e72efc0bdf1df26a4554590032f7a42d76ca19b361305f519071f1f026678c55c2980e74661ebcd5ac018d9e3e892376ee69a07c91ebb1d2d809cbb75
+  data.tar.gz: b2c7cbe0a13c12f0e9b935c3d675f583d93a4f78f921982e75eb9050c84d97914c63cf9280667b5be977280cda9de27a57972f3f0d72b097710a6b3b1e45d67b

data/CHANGELOG.md

@@ -2,7 +2,50 @@
 # CHANGELOG.md
 
 
-## flor 1.0.0  not yet released
+## flor 0.19.0  not yet released
+
+
+## flor 0.18.0  released 2019-05-05
+
+* Refine BasicTasker#reply (more arg patterns)
+* Fix "signal" vs exid: and payload:
+* Make payload optional when cancelling
+* Unlock `signal exid: other_execution_id "xxx"`
+* Allow for `trap 'signal0' payload: { a: 'A' }`
+* Allow for "on" in blocking mode (no block given)
+* Turn "sequence" single string att results to tags
+* gh-26, refine cancel / on_cancel and payload return
+* Allow for custom :schema_info migration table
+* Introduce a dedicated #refresh for all flor models
+* Let scheduler sleep only 0.001s if @idle_count less than 1
+* Implement Scheduler #dump and #load
+* Default target #cancel and #kill to node '0'
+* Expose taskname to tasker on detasking (@Subtletree)
+* Refine BasicTasker#reply (more arg patterns)
+* Allow for `trap 'signal0' payload: { a: 'A' }`
+* Allow for "on" in blocking mode (no block given)
+* Unlock `signal exid: other_execution_id "xxx"`
+* Make payload optional when cancelling (default to payload as it was
+  upon reaching the cancelled node)
+
+
+## flor 0.17.0  released 2019-04-08
+
+- Switch to 0.17.x
+
+
+## flor 0.16.2  released 2019-04-08
+
+- Many improvements
+- Allow for `[ 'he' 'll' 'o' ] | + join: '.'` (yields "he.ll.o")
+- Allow for `[ 1 2 3 ] | + _` (yields `6`)
+- Make "child_on_error:"/"children_on_error:" a common attribute
+- Ensure "on_cancel" sets only one handler
+
+
+## flor 0.16.1  released 2019-02-05
+
+- Depend on Sequel 5 (Sequel 4 and 5 seem OK)
 
 
 ## flor 0.16.0  released 2019-02-04

data/CREDITS.md

@@ -3,6 +3,8 @@
 
 ## Contributors
 
+* Olle Jonsson - https://github.com/olleolleolle
+* Ryan Scott - https://github.com/Subtletree
 * Jeffrey Hicks - https://github.com/jrhicks
 * David Verrier - https://github.com/dverrier
 * Tsunehisa Doi - https://github.com/dmicky0419

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2015-2019, John Mettraux, jmettraux+flor@gmail.com
+Copyright (c) 2015-2020, John Mettraux, jmettraux+flor@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Makefile

@@ -32,7 +32,7 @@ build: gemspec_validate
 	mv $(NAME)-$(VERSION).gem pkg/
 
 push: build
-	gem push pkg/$(NAME)-$(VERSION).gem
+	gem push --otp "$(OTP)" pkg/$(NAME)-$(VERSION).gem
 
 
 ## flor tasks ##
@@ -71,7 +71,7 @@ mk:
 	$(RUBY) -Ilib -e "require 'flor/tools/env'; Flor::Tools::Env.make('tmp', '$(FLOR_ENV)', gitkeep: true)"
 
 doc:
-	$(RUBY) -Imak -r 'doc' -e "make_procedures_doc()"
+	$(RUBY) -Imak -r 'doc_procedures' -e "make_doc_procedures()"
 doct:
 	@$(RUBY) mak/ptree.rb
 

data/README.md

@@ -10,10 +10,22 @@ Flor is a "Ruby workflow engine", if that makes any sense.
 * [floraison mailing list](https://groups.google.com/forum/#!forum/floraison)
 * [twitter.com/@flor_workflow](https://twitter.com/flor_workflow)
 
-## Design
+
+## use
+
+As a workflow engine, flor takes as input process definitions and executes them. Those executions may in turn call pieces of Ruby code or external scripts that perform the actual work. Those pieces of code and scripts are called "taskers".
+
+The classical way to use a language interpreter is to instantiate it as needed and let it die as the host execution ends. A workflow engine is more like a server, it may host multiple executions. And if the workflow engine stops, it may be restarted and pick the work back, when it was when it stopped.
+
+Flor process definitions are written in the flor language, a programming language mostly inspired by Scheme and Ruby. As always with programming languages, readability is hoped for, for a workflow engine this is especially necessary since those business processes are the bread and butter of business users.
+
+Using flor in your Ruby project requires you to clearly separate business process definitions from taskers. Since a flor instance may host multiple process executions based on one or more process definitions, many of the taskers may be reused from one definition to the other. For instance, if a "send-invoice-to-customer" tasker is created it might get used in the "process-retail-order" and the "process-big-distribution-order" processes.
+
+
+## design
 
 * Strives to propose a scheming interpreter for long running executions
-* Is written in Ruby a rather straightforward language with at least two
+* Is written in Ruby, a rather straightforward language with at least two
   wonderful implementations (MRI and JRuby, which is enterprise-friendly)
 * Stores everything as JSON (if it breaks it's still readable)
 * Stores in any database supported by [Sequel](http://sequel.jeremyevans.net/)
@@ -22,24 +34,120 @@ Flor is a "Ruby workflow engine", if that makes any sense.
 * All in all should be easy to maintain (engine itself and executions running
   on top of it)
 
-## Quickstart
 
-See [quickstart/](quickstart/).
+## quickstart
+
+This quickstart sets up a flor unit tied to a SQLite database, resets the databse, binds two taskers and then launches a flow execution involving the two taskers. Finally, it prints out the resulting workitem as the execution has just terminated.
+
+```ruby
+require 'flor/unit'
+
+#ENV['FLOR_DEBUG'] = 'dbg,sto,stdout' # full sql + flor debug output
+#ENV['FLOR_DEBUG'] = 'dbg,stdout' # flor debug output
+  # uncomment to see the flor activity
+
+sto_uri = 'sqlite://flor_qs.db'
+sto_uri = 'jdbc:sqlite://flor_qs.db' if RUBY_PLATFORM.match(/java/)
+
+flor = Flor::Unit.new(loader: Flor::HashLoader, sto_uri: sto_uri)
+  # instantiate flor unit
+
+flor.storage.delete_tables
+flor.storage.migrate
+  # blank slate database
+
+class DemoTasker < Flor::BasicTasker
+  def task(message)
+    (attd['times'] || 1).times do
+      message['payload']['log'] << "#{tasker}: #{task_name}"
+    end
+    reply
+  end
+end
+flor.add_tasker(:alice, DemoTasker)
+flor.add_tasker(:bob, DemoTasker)
+  # a simple logging tasker implementation bound under
+  # two different tasker names
+
+flor.start
+  # start the flor unit, so that it can process executions
+
+exid = flor.launch(
+  %q{
+    sequence
+      alice 'hello' times: 2
+      bob 'world'
+  },
+  payload: { log: [ "started at #{Time.now}" ] })
+    # launch a new execution, one that chains alice and bob work
+
+#r = flor.wait(exid, 'terminated')
+r = flor.wait(exid)
+  # wait for the execution to terminate or to fail
 
-## Documentation
+p r['point']
+  # "terminated" hopefully
+p r['payload']['log']
+  # [ "started at 2019-03-31 10:20:18 +0900",
+  #   "alice: hello", "alice: hello",
+  #   "bob: world" ]
+```
+
+This quickstart is at [doc/quickstart0/](doc/quickstart0/), it's a minimal, one-file Ruby quickstart.
+
+There is also [doc/quickstart1/](doc/quickstart1/), a more complex example, that shows a flor setup, where taskers and flows are layed out in a flor directory tree.
+
+
+## documentation
 
 See [doc/](doc/).
 
+* [doc/procedures/](doc/procedures/#procedures) - the basic building blocks of the flor language
+* [doc/glossary](doc/glossary.md) - words and their meaning in the flor context
+* [doc/patterns](doc/patterns.md) - workflow patterns and their flor (tentative) implementations
+
+
+## related projects
+
+* [mantor/floristry](https://github.com/mantor/floristry) - visualize and interact with flor through Rails facilities
+* [floraison/pollen](https://github.com/floraison/pollen) - a set of flor hooks that emit over the http
+* [floraison/florist](https://github.com/floraison/florist) - a flor worklist implementation
+* [floraison/flack](https://github.com/floraison/flack) - a flor wrapping [Rack](https://github.com/rack/rack) app
+* [floraison/fugit](https://github.com/floraison/fugit) - a time library for flor and [rufus-scheduler](https://github.com/jmettraux/rufus-scheduler)
+* [floraison/raabro](https://github.com/floraison/raabro) - the PEG library flor uses for its parsing needs
+
+
 ## blog posts and presentations
 
-* [the flor language](http://jmettraux.skepti.ch/20180927.html?t=the_flor_language) - on the flor workflow definition language itself
+* [flor workflow engine](http://jmettraux.skepti.ch/20190407.html?t=flor_workflow_engine&f=readme) - on flor itself
+* [the flor language](http://jmettraux.skepti.ch/20180927.html?t=the_flor_language&f=readme) - on the flor workflow definition language itself
+* [reddit answer on workflow engines](http://jmettraux.skepti.ch/20190416.html?t=reddit_answer_on_workflow_engines&f=readme) - an answer to a Reddit question on workflow engines, archived as a post
 * [Flor, hubristic interpreter](http://rubykaigi.org/2017/presentations/jmettraux.html) - RubyKaigi 2017, Hiroshima - presentation
 * [flor design 0](http://jmettraux.skepti.ch/20171021.html?t=flor_design_0&f=readme) - running a simple execution, what happens - blog post
 * [flor, branch to branch](https://speakerdeck.com/jmettraux/flor-branch-to-branch) - q1 2017 - very dry deck
 * [flor 2017](https://speakerdeck.com/jmettraux/flor-2017) - q1 2017 - very dry deck
 
 
-## LICENSE
+## other Ruby projects about workflows
+
+There are various other Ruby and Ruby on Rails projects about workflows and business processes, each with its own take on them.
+
+* [Dynflow](http://dynflow.github.io/) - "Dynflow (DYNamic workFLOW) is a workflow engine written in Ruby"
+* [rails_workflow](https://github.com/madzhuga/rails_workflow) - "Rails Workflow Engine allows you to organize your application business logic by joining user- and auto- operations in processes"
+* [rails_engine/flow_core](https://github.com/rails-engine/flow_core) - "A multi purpose, extendable, Workflow-net-based workflow engine for Rails applications"
+* [Trailblazer](http://trailblazer.to/) - "The Advanced Business Logic Framework"
+* [Petri Flow](https://github.com/hooopo/petri_flow) - "Petri Net Workflow Engine for Ruby" (Rails)
+* [Pallets](https://github.com/linkyndy/pallets) - "Simple and reliable workflow engine, written in Ruby"
+* [Gush](https://github.com/chaps-io/gush) - "Fast and distributed workflow runner using ActiveJob and Redis"
+
+There is a [workflow engine](https://ruby.libhunt.com/categories/5786-workflow-engine) category on [Awesome Ruby](https://ruby.libhunt.com/).
+
+If you want your engine/library to be added in this list, don't hesitate to ask me on [Gitter](https://gitter.im/floraison/flor) or via a pull request.
+
+It's not limited to Ruby, but there is a wider list at [meirwah/awesome-workflow-engines](https://github.com/meirwah/awesome-workflow-engines).
+
+
+## license
 
 MIT, see [LICENSE.txt](LICENSE.txt)
 

data/flor.gemspec

@@ -10,8 +10,7 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.authors = [ 'John Mettraux' ]
   s.email = [ 'jmettraux+flor@gmail.com' ]
-  s.homepage = 'http://github.com/floraison'
-  #s.rubyforge_project = 'flor'
+  s.homepage = 'https://github.com/floraison'
   s.license = 'MIT'
   s.summary = 'A Ruby workflow engine'
 
@@ -38,16 +37,16 @@ A Ruby workflow engine (ruote next generation)
     "#{s.name}.gemspec",
   ]
 
-  s.add_runtime_dependency 'munemo', '~> 1.0', '>= 1.0.1'
-  s.add_runtime_dependency 'raabro', '~> 1.1', '>= 1.1.5'
   #s.add_runtime_dependency 'rufus-lru', '~> 1.1'
-  s.add_runtime_dependency 'fugit', '~> 1.1', '>= 1.1.8'
-  s.add_runtime_dependency 'dense', '~> 1.1', '>= 1.1.6'
+  s.add_runtime_dependency 'munemo', '~> 1.0' # >= 1.0 and < 2
+  s.add_runtime_dependency 'raabro', '~> 1.1' # >= 1.1 and < 2
+  s.add_runtime_dependency 'fugit', '~> 1.2' # >= 1.2 and < 2
+  s.add_runtime_dependency 'dense', '~> 1.1' # >= 1.1 and < 2
 
-  s.add_runtime_dependency 'sequel', '~> 4'
+  s.add_runtime_dependency 'sequel', '~> 5.0' # >= 5.0 and < 6
 
-  s.add_development_dependency 'rspec', '~> 3.7'
-  s.add_development_dependency 'terminal-table'
+  s.add_development_dependency 'rspec', '~> 3.8' # >= 3.8 and < 4
+  s.add_development_dependency 'terminal-table', '~> 1.8' # >= 1.8 and < 2
 
   s.require_path = 'lib'
 end

data/lib/flor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require 'pp'
 require 'json'
@@ -14,8 +15,7 @@ require 'dense'
 
 module Flor
 
-  VERSION = '0.16.0'
-  #VERSION = '1.0.0'
+  VERSION = '1.0.0'
 end
 
 require 'flor/colours'

data/lib/flor/colours.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 
 module Flor
 
   COLS = Hash[*%w[
 
     reset 0;0
-    bright 1 dim 2 underlined 4 blink 5 reverse 7 hidden 8 default 39
+    bright 1 dim 2 underlined 4 blink 5 reverse 7 hidden 8 strike 9 default 39
     black 30 red 31 green 32 yellow 33 blue 34 magenta 35 cyan 36
     light_gray 37 dark_gray 90 light_red 91 light_green 92
     light_yellow 93 light_blue 94 light_magenta 95 light_cyan 96 white 97
@@ -17,7 +18,8 @@ module Flor
     brown yellow purple magenta dark_grey dark_gray light_grey light_gray
 
     rd red bl blue bu blue ba black bk black gn green gr green dg dark_gray
-    gy light_gray lg light_gray yl yellow y yellow ma magenta rs reset
+    gy light_gray lg light_gray yl yellow y yellow ma magenta wt white
+    rs reset
     br bright bri bright un underlined rv reverse bn blink blg bg_light_gray
     und underlined rev reverse
   ]]
@@ -28,7 +30,7 @@ module Flor
       if v.match(/\A\d/)
         class_eval(%{
           def #{k}(s=nil)
-           s ? "[#{v}m" + s + "" : "[#{v}m"
+           s ? "[#{v}m" + s + "" : "[#{v}m"
            end })
       else
         class_eval(

data/lib/flor/conf.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -48,6 +49,15 @@ module Flor
     #   "reserved" state, messages are put back in the "created" state
     #   (by a running unit (scheduler) if any).
     #
+    # * :db_migration / :sto_migration / :db_migration_dir / :sto_migration_dir
+    #   (Flor::Storage#migrate option)
+    #   Points the migrator to its Ruby Sequel migration directory.
+    #
+    # * :db_sparse_migrations / :sto_sparse_migrations
+    #   (Flor::Storage#migrate option)
+    #   Setting this to true is equivalent to calling
+    #   `unit.storage.migration(allow_missing_migration_files: true)`
+    #
     # And finally:
     #
     # * :flor_debug or :debug
@@ -71,8 +81,12 @@ module Flor
 
       def prepare(conf, over_conf)
 
-        c = conf
-        c = Flor::ConfExecutor.interpret_path_or_source(c) if c.is_a?(String)
+        c =
+          case conf
+          when String then Flor::ConfExecutor.interpret_path_or_source(conf)
+          when Hash then Flor.to_string_keyed_hash(conf)
+          else conf
+          end
 
         fail ArgumentError.new(
           "cannot extract conf out of #{c.inspect} (#{conf.class})"
@@ -92,10 +106,10 @@ module Flor
 
       def get_class(conf, key)
 
-        if v = conf[key]
-          Flor.const_lookup(v)
-        else
-          nil
+        case v = conf[key]
+        when Class then v
+        when String then Flor.const_lookup(v)
+        else nil
         end
       end
 

data/lib/flor/core.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -28,7 +29,7 @@ module Flor
 
     t =
       tree.is_a?(String) ?
-      Flor.parse(tree, opts[:fname], opts) :
+      Flor.parse(tree, opts[:fname] || opts[:path], opts) :
       tree
 
     unless t
@@ -51,13 +52,13 @@ module Flor
       "given launch variables should come in a Hash, but it's a #{vs.class}"
     ) unless vs.is_a?(Hash)
 
-    msg =
-      { 'point' => 'execute',
-        'exid' => exid,
-        'nid' => '0',
-        'tree' => t,
-        'payload' => pl,
-        'vars' => vs }
+    msg = {
+      'point' => 'execute',
+      'exid' => exid,
+      'nid' => '0',
+      'tree' => t,
+      'payload' => pl,
+      'vars' => vs }
 
     msg['vdomain'] = opts[:vdomain] \
       if opts.has_key?(:vdomain)

data/lib/flor/core/executor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -69,18 +70,31 @@ module Flor
 
     def trigger_hook(hook, message)
 
-      hook.notify(self, message)
+      m =
+        case
+        when hook.respond_to?(:notify) then :notify
+        when hook.respond_to?(:on_message) then :on_message
+        else :on
+        end
+      as =
+        case hook.method(m).arity
+        when 3 then [ @unit, self, message ]
+        when 2 then [ self, message ]
+        else [ message ]
+        end
+
+      r = hook.send(m, *as)
+
+      Flor.is_array_of_messages?(r) ? r : []
     end
 
     def trigger_block(block, opts, message)
 
       r =
-        if block.arity == 1
-          block.call(message)
-        elsif block.arity == 2
-          block.call(message, opts)
-        else
-          block.call(self, message, opts)
+        case block.arity
+        when 1 then block.call(message)
+        when 2 then block.call(message, opts)
+        else block.call(self, message, opts)
         end
 
       r.is_a?(Array) && r.all? { |e| e.is_a?(Hash) } ? r : []
@@ -146,9 +160,10 @@ module Flor
         # cnid: closure nid
         # dbg: used to debug messages (useful @node['dbg'] when 'receive')
 
-      if oeh = message['on_error_handler']
-        node['on_error'] = [ [ [ '*' ], oeh ] ]
-      end
+      %w[ error cancel timeout ]
+        .each { |k|
+          h = message["on_#{k}_handler"]
+          node["on_#{k}"] = [ h ] if h }
 
       @execution['nodes'][nid] = node
     end
@@ -197,7 +212,8 @@ module Flor
         #
         # tag: et al
 
-        node['tree'] = message['tree'] = t = [ '_sqs', tree[0], tree[2] ]
+        node['tree'] = message['tree'] = t =
+          [ '_sqs', tree[0], tree[2] ]
 
         node['heat0'] = t[0]
         node['heat'] = h = n.deref(t[0])
@@ -207,14 +223,16 @@ module Flor
         #
         # rewrite `alpha` into `task alpha`
 
-        l = message['tree'][2]
+        mt = message['tree']
+        l = mt[2]
 
-        message['otree'] = Flor.dup(message['tree'])
+        message['otree'] = mt
 
-        message['tree'][0] =
-          'task'
-        message['tree'][1].unshift(
-          [ '_att', [ [ '_sqs', heat[1]['tasker'], l ] ], l ])
+        node['tree'] = message['tree'] =
+          [ 'task', [
+            [ '_att', [ [ '_sqs', heat[1]['tasker'], l ] ], l ],
+            *mt[1]
+          ], l ]
       end
     end
 
@@ -228,6 +246,19 @@ module Flor
       heap = node['heap']
 
       heac = Flor::Procedure[heap]
+unless heac
+  puts "v" * 80
+  puts "===node:"
+  p node['nid']
+  p heap
+  puts "."
+  pp node
+  puts "===message:"
+  p message['point']
+  puts "."
+  pp message
+  puts "." * 80
+end
       fail NameError.new("unknown procedure #{heap.inspect}") unless heac
 
       head = heac.new(self, node, message)
@@ -260,9 +291,8 @@ module Flor
 
     def receive(message)
 
-      messages = leave_node(message)
-
       nid = message['nid']
+      messages = leave_node(message)
 
       return messages + toc_messages(message) unless nid
         # 'terminated' or 'ceased'
@@ -292,7 +322,9 @@ module Flor
       cls = node['closures']
 
       pro = Flor::Procedure.make(self, node, message)
+
       pro.end
+        # do end the node
 
       cancels = pro.send(:wrap_cancel_children, 'cancel_trailing' => true)
 
@@ -353,12 +385,7 @@ module Flor
 
     def error_reply(node, message, err)
 
-      m = message
-        .select { |k, v| %w[ sm exid nid from payload tree ].include?(k) }
-
-      m['point'] = 'failed'
-      m['fpoint'] = message['point']
-      m['error'] = Flor.to_error(err)
+      m = Flor.to_error_message(message, err)
 
       @unit.logger.log_err(self, m, flag: true)
 
@@ -392,15 +419,14 @@ module Flor
 
       last = (message['cause'] ||= [])[0]
 
-      c = {
-        'cause' => cause,
-        'm' => message['m'],
-        'nid' => message['nid'],
-        'type' => message['type'],
-        'at' => last && last['at'] }
+      c = { 'cause' => cause, 'at' => last && last['at'] }
+      %w[ m sm nid type ].each { |k| c[k] = message[k] }
 
       return if c == last
 
+      # argh, the causes in the messages go most recent first
+      # while the statuses in the nodes go most recent last
+
       message['cause'] =
         [ c.tap { |h| h['at'] = Flor.tstamp } ] +
         message['cause']
@@ -421,12 +447,16 @@ module Flor
         stack_cause(message) \
           if %w[ trigger cancel ].include?(message['point'])
 
-        determine_heat(message)
+        begin
+          determine_heat(message)
+        rescue => e
+          raise e unless message['point'] == 'failed'
+        end
 
         ms = []
         ms += @unit.notify(self, message) # pre
 
-        ms += self.send(message['point'], message)
+        ms += send(message['point'], message)
 
         message['payload'] = message.delete('pld') if message.has_key?('pld')
         message['consumed'] = Flor.tstamp
@@ -456,11 +486,6 @@ module Flor
       []
     end
 
-    def entered(message); []; end
-    def left(message); []; end
-
-    def ceased(message); []; end
-
     def terminated(message)
 
       message['vars'] = @execution['nodes']['0']['vars']
@@ -496,6 +521,13 @@ module Flor
     end
 
     def signal(message); []; end
+    def entered(message); []; end
+    def left(message); []; end
+    def ceased(message); []; end
+      #
+      # Return an empty array of new messages. No direct effect.
+      #
+      # Some trap, hook, and/or waiter might lie in wait though.
 
     def lookup_on_error_parent(message)