flor 1.2.2 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1dae0857de545986e18ad31a41f37a6ead6687b34d3c06de22aafa606369283
-  data.tar.gz: 9843d0124a2c3948ffc6846e7854854f5eda37d95bd02bfc02cecfefab0e5ea1
+  metadata.gz: 352d4347077550a9e577689e8b1f11ad90b7efb0d6fa14e99a228b634852c55f
+  data.tar.gz: 81015d54353ff68b48108e09fdfc8933cae2b20ed48ccba1679bebc1b67258da
 SHA512:
-  metadata.gz: 185490e0054ffdfe7c078b71955834679a398266e613be5d8bb6b63bc626bf4727bd4fd45249e7dea14cdd91a85c5ad92a1f6b3b120117c7c274b41d5478ba31
-  data.tar.gz: e6dde7ae40f3ef6d2c7a620d6a07840c6591b745798962d039ac39fa426e4bcef51f3c67e97d9a367bb981918ec5fe98934393eec2cd7e87046b8d491b9a6511
+  metadata.gz: c322beec0f868fbf72c79678227cbf2a2fea34611fe340b1fdd680a7d6b1f5a09246af1a78f6923977a061772ef22fc8d20d2d13a0bad2145991f296b4cfd143
+  data.tar.gz: 3c3e2ce6a88acbaeeab0bb9d89f8c22e5dfd8fb1a81491f0d54983d21d692e3cd93262c842ed8dbc00e021b2fee1d5f3e3e791d8af72bfc6667c472d712d3541

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 # CHANGELOG.md
 
 
+## flor 1.5.0  released 2021-11-24
+
+* Add storage callbacks `on(:pointers, :any) { do_that }`
+* Add `on_receive` (and `on receive`)
+
+
+## flor 1.4.0  released 2021-11-10
+
+* Add :tree to Execution#to_h
+* Scaffold bin/flotojson
+
+
+## flor 1.3.1  released 2021-04-19
+
+* Fix flor_pointers var deletion mechanism (type = ' var ')
+
+
+## flor 1.3.0  released 2021-04-13
+
+* Insert a row flor_pointers for 'failure'
+
+
 ## flor 1.2.2  released 2021-03-29
 
 * Include data in flor_pointers

data/lib/flor/core/node.rb

@@ -88,7 +88,7 @@ class Flor::Node
   def domain; Flor.domain(@execution['exid']); end
 
   def point; @message['point']; end
-  def from; @message['from']; end
+  def from; @from || @message['from']; end
 
   def cnodes; @node['cnodes']; end
   def cnodes_any?; cnodes && cnodes.any?; end
@@ -149,7 +149,7 @@ class Flor::Node
     tree = lookup_tree(Flor.parent_nid(nid))
     return tree[1][cid] if tree
 
-    #tree = lookup_tree(Flor.parent_nid(nid, true))
+    #tree = lookup_tree(Flor.parent_nid(nid, remove_subnid=true))
     #return tree[1][cid] if tree
       #
       # might become necessary at some point

data/lib/flor/core/procedure.rb

@@ -5,7 +5,7 @@ class Flor::Procedure < Flor::Node
   # "Returning vars" variables to pass back to pass upon reply.
   # In the 'receive' messages, it's a hash under the key 'rvars'.
   #
-  RVARS = %w[ idx ]
+  RVARS = %w[ idx ].freeze
 
   # Attributes that when given alone are turned to "true" attributes.
   #
@@ -13,7 +13,7 @@ class Flor::Procedure < Flor::Node
   #
   # The transformation occurs in Flor::Pro::Att ("_att").
   #
-  TRUE_ATTS = %w[ flank off disabled ]
+  TRUE_ATTS = %w[ flank off disabled ].freeze
 
   class << self
 
@@ -381,8 +381,17 @@ class Flor::Procedure < Flor::Node
 
       receive_when_ended
 
+    elsif should_apply_on_receive?
+
+      apply_on_receive
+
     else
 
+      orn = @node['on_receive_nid']
+      @from = orn[1] if orn && orn[0] == from
+        #
+        # in order to move on to the next child...
+
       receive
     end
   end
@@ -550,6 +559,8 @@ class Flor::Procedure < Flor::Node
     wrap_reply
   end
 
+  IF_UNLESS = %w[ _if _unless ].freeze
+
   # Grab on_error proc from incoming payload and stores it into parent node.
   #
   # Has no effect if there is no parent node.
@@ -562,7 +573,7 @@ class Flor::Procedure < Flor::Node
       @node; loop do
         pnode = parent_node(pnode)
         return unless pnode
-        break unless %w[ _if _unless ].include?(pnode['heap'])
+        break unless IF_UNLESS.include?(pnode['heap'])
       end
 
     flavour = "on_#{key}"
@@ -598,6 +609,8 @@ class Flor::Procedure < Flor::Node
     wrap('point' => 'entered', 'nid' => nid, 'tags' => ret)
   end
 
+  WRAP_KEYS = %w[ error cancel timeout ].freeze
+
   def wrap(h={})
 
     m = {}
@@ -642,7 +655,7 @@ class Flor::Procedure < Flor::Node
       # was considering passing the whole vars back (as 'varz'), but
       # it got in the way... and it might be heavy
 
-    %w[ error cancel timeout ]
+    WRAP_KEYS
       .each { |k|
         co = @node["child_on_#{k}"]
         next unless co
@@ -978,6 +991,36 @@ class Flor::Procedure < Flor::Node
 
     []
   end
+
+  def should_apply_on_receive?
+
+    return false if @message['from_on'] == 'receive'
+      #
+      # no, since the message comes from an on_receive...
+      # how about nested on_receives?
+
+    orc = @node['on_receive']
+    return false if orc.nil? || orc.empty?
+
+    orn = @node['on_receive_nid']
+    return false if orn && orn[0] == from
+
+    true
+  end
+
+  def apply_on_receive
+
+    determine_fcid_and_ncid
+
+    args = [
+      [ 'msg', @message ],
+      [ 'fcid', @fcid ] ]
+
+    ms = apply(@node['on_receive'][0][1], args, tree[2])
+    @node['on_receive_nid'] = [ ms[0]['nid'], from ]
+
+    ms
+  end
 end
 
 

data/lib/flor/log.rb

@@ -343,7 +343,7 @@ module Flor
       o.puts(tree_to_s(node.lookup_tree(nid), nid, out: o)) if node
 
       o.puts "#{_c.dg}node:#{_c.yl}"
-      o.puts YAML.dump(n.merge('tree' => '(above)'))
+      o.puts n ? YAML.dump(n.merge('tree' => '(above)')) : 'nil'
 
       o.puts "#{_c.dg}nodes:#{_c.yl}"
       o.puts nods_to_s(executor, m, opts)

data/lib/flor/parser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Flor
 
   def self.parse(input, fname=nil, opts={})
@@ -727,3 +728,4 @@ fail "don't know how to invert #{operation.inspect}" # FIXME
     sio.string
   end
 end
+

data/lib/flor/pcore/_apply.rb

@@ -99,7 +99,7 @@ class Flor::Pro::UnderscoreApply < Flor::Procedure
 
     params.each do |param_key, param_tree|
       next if param_tree[0] == '_ref'
-      arg_i = args.index { |arg_key, arg_val| arg_key == param_key }
+      arg_i = args.index { |arg_key, _| arg_key == param_key }
       next unless arg_i
       arg_key, arg_val = args.delete_at(arg_i)
       seen << arg_key

data/lib/flor/pcore/on.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+
 class Flor::Pro::On < Flor::Macro
   #
   # Catches signals or errors.
@@ -132,7 +133,7 @@ class Flor::Pro::On < Flor::Macro
 
   protected
 
-  CATCHES = %w[ error cancel timeout ].freeze
+  CATCHES = %w[ error cancel timeout receive ].freeze
 
   def find_catch
 

data/lib/flor/pcore/on_receive.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+
+class Flor::Pro::OnReceive < Flor::Procedure
+  #
+  # Binds a function to the parent node, the function will be called each time
+  # the parent node "receives".
+  #
+  # ```
+  # set l []
+  # sequence
+  #   on_receive (def msg \ push l 'a')
+  #   push l 0
+  #   push l 1
+  #   push l 2
+  # ```
+  # will result in the variable `l` holding `[ 0, 'a', 1, 'a', 2, 'a' ]`.
+  #
+  # ```
+  # set l []
+  # sequence
+  #   push l 0
+  #   on_receive (def msg \ push l 'a')
+  #   push l 1
+  #   push l 2
+  # ```
+  # will result in the variable `l` holding `[ 0, 1, 'a', 2, 'a' ]`.
+  #
+  # It's meant to play well with a cursor:
+  # ```
+  # set l []
+  # cursor
+  #   on_receive (def \ break _ if l[-1] == 1)
+  #   push l 0
+  #   push l 1
+  #   push l 2
+  # push l 'z'
+  # ```
+  # will result in the variable `l` holding `[ 0, 1, 'z' ]`.
+  #
+  #
+  # ## arguments to the on_receive function
+  #
+  # `msg` and `fcid` (from child id) are passed to the function
+  # ```
+  # set l []
+  # cursor
+  #   on_receive (def msg, fcid \ push l [ msg.from, fcid ])
+  #   push l 0
+  #   push l 1
+  #   push l 2
+  # ```
+  # will result in the variable `l` holding
+  # `[ 0, [ '0_1_1', 1 ], 1, [ '0_1_2', 2 ], 2, [ '0_1_3', 3 ] ]`.
+  #
+  #
+  # ## on_receive and on receive
+  #
+  # A "lighter" notation is available (it's translated automatically to a
+  # `on_receive`):
+  # ```
+  # set l []
+  # cursor
+  #   on receive
+  #     push l $msg.from
+  #     break _ if l.-1 == 1
+  #   push l 0
+  #   push l 1
+  #   push l 2
+  # ```
+  #
+  # Please note the `$msg` variable made available to the `on receive` block.
+  #
+  #
+  # ## concurrence and on_receive
+  #
+  # Please not that `concurrence` has its own `on_receive` with a slightly
+  # different behaviour.
+
+  name 'on_receive'
+
+  def pre_execute
+
+    unatt_unkeyed_children
+
+    @node['rets'] = []
+  end
+
+  def receive_last
+
+    prc = @node['rets'].find { |r| Flor.is_func_tree?(r) }
+
+    store_on(:receive, prc)
+
+    ms = super
+
+    ms.first['from_on'] = 'receive'
+
+    ms
+  end
+end
+

data/lib/flor/punit/concurrence.rb

@@ -139,7 +139,7 @@ class Flor::Pro::Concurrence < Flor::Procedure
   #   + 12 34
   #   + 56 78
   # ```
-  # One can even express the function has a 'block':
+  # One can even express the function as a 'block':
   # ```
   # concurrence tag: 'x'
   #   on_receive

data/lib/flor/tools/flotojson.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# flotojson.rb
+
+require 'flor'
+
+FLAGS_WITH_VALUE = []
+
+flags = {}
+files = []
+
+if (ARGV & [ '-h', '--help']).any?
+  puts
+  puts "bin/flotojson [flags] filename"
+  puts
+  puts "  turns a flor .flo process definition to its tree representation"
+  puts
+  puts "  flags:"
+  puts "    --pp    pretty prints instead of dumping as JSON"
+  puts
+  puts "    --pj"
+  puts "    --jp    pretty prints the JSON output"
+  puts
+  puts "    -y"
+  puts "    -yaml   dumps as YAML"
+  puts
+  puts "    -h"
+  puts "    --help  prints this help message"
+  puts
+  exit 0
+end
+
+args = ARGV.dup
+
+loop do
+
+  a = args.shift; break unless a
+
+  if a.size > 1 && a[0, 1] == '-'
+    flags[a] = FLAGS_WITH_VALUE.include?(a) ? a.shift : true
+  else
+    files << a
+  end
+end
+
+#STDERR.puts flags.inspect
+#STDERR.puts files.inspect
+
+#    t =
+#      tree.is_a?(String) ?
+#      Flor.parse(tree, opts[:fname] || opts[:path], opts) :
+#      tree
+#
+#    unless t
+#
+#      #h = opts.merge(prune: false, rewrite: false, debug: 0)
+#      #Raabro.pp(Flor.parse(tree, h[:fname], h))
+#        # TODO re-parse and indicate what went wrong...
+#
+#      fail ArgumentError.new(
+#        "flow parsing failed: " + tree.inspect[0, 35] + '...')
+#    end
+
+fname = files.first
+
+content =
+  if fname
+    abort("File #{fname.inspect} not found") unless File.exist?(fname)
+    File.read(fname)
+  else
+    STDIN.read
+  end
+
+tree = Flor.parse(content, fname, {})
+
+if flags['--pp']
+  pp tree
+elsif flags['--jp'] || flags['--pj']
+  puts(
+    JSON.pretty_generate(tree)
+      .gsub(/\[\s+/, '[ ')
+      .gsub(/\]\s+/, ']')
+      .gsub(/,\s+(\d+)\s+\]/, ', \1]')
+        )
+elsif flags['-y'] || flags['--yaml']
+  puts YAML.dump(tree)
+else
+  puts JSON.dump(tree)
+end
+

data/lib/flor/unit/logger.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+
 module Flor
 
   # TODO ::Logger has a formatting callback
@@ -11,7 +12,7 @@ module Flor
 
     # NB: logger configuration entries start with "log_"
 
-    LEVELS_I = %w[ DEBUG INFO WARN ERROR FATAL UNKNOWN ]
+    LEVELS_I = %w[ DEBUG INFO WARN ERROR FATAL UNKNOWN ].freeze
 
     def initialize(unit)
 

data/lib/flor/unit/models/execution.rb

@@ -20,7 +20,29 @@ module Flor
     #end
 
     def nodes; data['nodes']; end
+
     def zero_node; nodes['0']; end
+
+    # Returns the nids, the lower in the tree, the earlier in the returned
+    # array.
+    #
+    def sorted_nids
+
+      nodes.keys
+        .inject([]) { |a, nid|
+          l = nid.split('_').length
+          (a[l] ||= []) << nid
+          a }
+        .compact
+        .collect(&:sort)
+        .flatten(1)
+    end
+
+    def lowest_node
+
+      nodes[sorted_nids.first]
+    end
+
     def closing_messages; data['closing_messages']; end
 
     def execution(reload=false); self; end
@@ -47,14 +69,16 @@ module Flor
 
     def full_tree
 
-      tree = nodes['0']['tree']
+      nids = sorted_nids
+      nid0 = nids.shift
 
-      #nodes.each do |nid, n|
-      #  next if nid == '0'
-      #  t = n['tree']; next unless t
-      #end
-        #
-        # FIXME
+      return nil unless nid0
+
+      tree = Flor.dup(nodes[nid0]['tree'])
+
+      nids.each { |nid|
+        next unless nid.split('_', 2).first == nid0
+        replace_sub_tree(tree, nid, nodes[nid]['tree']) }
 
       tree
     end
@@ -80,21 +104,22 @@ module Flor
       cs = m[:counts] = {}
       is = m[:nids] = { tasks: [], failures: [] }
 
-      fs = 0
-      ts = 0
+      cs[:failures] = 0
+      cs[:tasks] = 0
+      cs[:nodes] = nodes.count
+        #
       nodes.each do |k, v|
         if v['task']
-          ts += 1
+          cs[:tasks] += 1
           is[:tasks] << k
         end
         if v['failure']
-          fs += 1
+          cs[:failures] += 1
           is[:failures] << k
         end
       end
-      cs[:nodes] = nodes.count
-      cs[:failures] = fs
-      cs[:tasks] = ts
+
+      h[:tree] = full_tree
 
       h
     end
@@ -149,6 +174,30 @@ module Flor
       lookup_node(query, opts)['nid']
     end
 
+    protected
+
+    def replace_sub_tree(tree, nid, t)
+
+      return unless t
+      return if nid.index('-') # stay vanilla
+
+      snid = nid.split('_').collect(&:to_i)[1..-1]
+      a = get_child_array(tree, snid)
+
+      return unless a # shouldn't we fail?
+
+      a[snid.first] = Flor.dup(t)
+    end
+
+    def get_child_array(tree, snid)
+
+      return nil if tree.nil?
+      return nil if snid.length < 1
+      return nil unless tree[1].is_a?(Array)
+      return tree[1] if snid.length == 1
+      n = snid.shift; get_child_array(tree[1][n], snid)
+    end
+
     class << self
 
       def by_status(s)

data/lib/flor/unit/scheduler.rb

@@ -113,27 +113,6 @@ module Flor
       @ganger.shutdown
     end
 
-    def on_start_exc(e)
-
-      io = StringIO.new
-
-      head, kind =
-        e.is_a?(StandardError) ? [ '=sch', 'error' ] : [ '!sch', 'exception' ]
-      thr = Thread.current
-
-      t = head[0, 2] + Time.now.to_f.to_s.split('.').last
-      io.puts ' /' + t + ' ' + head * 17
-      io.puts " |#{t} + in #{self.class}#start"
-      io.puts " |#{t} db: #{@storage.db.class} #{@storage.db.object_id}"
-      io.puts " |#{t} thread: t#{thr.object_id} #{thr.inspect}"
-      io.puts " |#{t} #{kind}: #{e.inspect}"
-      io.puts " |#{t} backtrace:"
-      e.backtrace.each { |l| io.puts "|#{t} #{l}" }
-      io.puts ' \\' + t + ' ' + (head * 17) + ' .'
-
-      io.string
-    end
-
     def start
 
       # TODO heartbeat, every x minutes, when idle, log something
@@ -242,18 +221,18 @@ module Flor
       end
     end
 
+    RETURN_KEYS = %w[ exid nid payload tasker cause ].freeze
+
     def return(message)
 
-      m =
+      queue(
         if message['point'] == 'failed'
           message
         else
           message
-            .select { |k, _| %w[ exid nid payload tasker cause ].include?(k) }
+            .select { |k, _| RETURN_KEYS.include?(k) }
             .merge!('point' => 'return')
-        end
-
-      queue(m)
+        end)
 
       nil
     end
@@ -432,7 +411,7 @@ module Flor
       ex ? ex.execution : nil
     end
 
-    DUMP_KEYS = %w[ timestamp executions timers traps pointers ]
+    DUMP_KEYS = %w[ timestamp executions timers traps pointers ].freeze
 
     # Dumps all or some of the executions to a JSON string.
     # See Scheduler#load for importing.
@@ -557,6 +536,27 @@ module Flor
 
     protected
 
+    def on_start_exc(e)
+
+      io = StringIO.new
+
+      head, kind =
+        e.is_a?(StandardError) ? [ '=sch', 'error' ] : [ '!sch', 'exception' ]
+      thr = Thread.current
+
+      t = head[0, 2] + Time.now.to_f.to_s.split('.').last
+      io.puts ' /' + t + ' ' + head * 17
+      io.puts " |#{t} + in #{self.class}#start"
+      io.puts " |#{t} db: #{@storage.db.class} #{@storage.db.object_id}"
+      io.puts " |#{t} thread: t#{thr.object_id} #{thr.inspect}"
+      io.puts " |#{t} #{kind}: #{e.inspect}"
+      io.puts " |#{t} backtrace:"
+      e.backtrace.each { |l| io.puts "|#{t} #{l}" }
+      io.puts ' \\' + t + ' ' + (head * 17) + ' .'
+
+      io.string
+    end
+
     def extract_dump_and_load_filters(opts)
 
       o = lambda { |k| v = opts[k] || opts["#{k}s".to_sym]; v ? Array(v) : nil }
@@ -598,6 +598,8 @@ module Flor
       puts(on_start_exc(ex))
     end
 
+    PREP_KEYS = %w[ exid name nid payload on_receive_last ].freeze
+
     def prepare_message(point, args)
 
       h = args
@@ -612,7 +614,7 @@ module Flor
       opts = {}
 
       h.each do |k, v|
-        if %w[ exid name nid payload on_receive_last ].include?(k)
+        if PREP_KEYS.include?(k)
           msg[k] = v
         else
           opts[k.to_sym] = v

data/lib/flor/unit/storage.rb

@@ -16,7 +16,7 @@ module Flor
         :content
           ].freeze
 
-    attr_reader :unit, :db, :models
+    attr_reader :unit, :db, :models, :callbacks
 
     attr_reader :mutex
       # might be useful for some implementations
@@ -31,6 +31,8 @@ module Flor
       @archive = @unit.conf['sto_archive']
       @mutex = @unit.conf['sto_sync'] ? Mutex.new : nil
 
+      @callbacks = {}
+
       connect
     end
 
@@ -191,6 +193,8 @@ module Flor
               mtime: now,
               munit: u)
 
+          callback(:executions, :update, id)
+
         else
 
           exe['id'] =
@@ -205,6 +209,8 @@ module Flor
                 cunit: u,
                 munit: u)
               .to_i
+
+          callback(:executions, :insert, exe['id'])
         end
 
         remove_nodes(exe, status, now)
@@ -220,6 +226,9 @@ module Flor
       raise err
     end
 
+    CRECON_STATUSES = %w[ created consumed ].freeze
+    RESCON_STATUSES = %w[ reserved consumed ].freeze
+
     def load_messages(exe_count)
 
       exe_count += 2
@@ -230,12 +239,12 @@ module Flor
         _exids_being_processed =
           @db[:flor_messages]
             .select(:exid)
-            .exclude(status: %w[ created consumed ])
+            .exclude(status: CRECON_STATUSES)
         _exids =
           @db[:flor_messages]
             .select(:exid)
             .exclude(exid: _exids_being_processed)
-            .exclude(status: %w[ reserved consumed ])
+            .exclude(status: RESCON_STATUSES)
             .limit(exe_count)
         @db[:flor_messages]
           .where(exid: _exids, status: 'created')
@@ -318,7 +327,7 @@ module Flor
       []
     end
 
-    POINTS_TO_ARCHIVE = %w[ terminated failed ceased ]
+    POINTS_TO_ARCHIVE = %w[ terminated failed ceased ].freeze
 
     def consume(messages)
 
@@ -415,26 +424,29 @@ module Flor
       now = Flor.tstamp
       u = @unit.identifier
 
-      synchronize do
+      id =
+        synchronize do
 
-        @db[:flor_timers]
-          .insert(
-            domain: Flor.domain(message['exid']),
-            exid: message['exid'],
-            nid: message['nid'],
-            onid: message['onid'] || message['nid'],
-            bnid: message['nid'],
-            type: type,
-            schedule: string,
-            ntime: next_time,
-            content: to_blob(message),
-            count: 0,
-            status: 'active',
-            ctime: now,
-            mtime: now,
-            cunit: u,
-            munit: u)
-      end
+          @db[:flor_timers]
+            .insert(
+              domain: Flor.domain(message['exid']),
+              exid: message['exid'],
+              nid: message['nid'],
+              onid: message['onid'] || message['nid'],
+              bnid: message['nid'],
+              type: type,
+              schedule: string,
+              ntime: next_time,
+              content: to_blob(message),
+              count: 0,
+              status: 'active',
+              ctime: now,
+              mtime: now,
+              cunit: u,
+              munit: u)
+        end
+
+      callback(:timers, :insert, id)
 
       @unit.wake_up
 
@@ -499,6 +511,8 @@ module Flor
               munit: u)
         end
 
+      callback(:traps, :insert, id)
+
       traps[id]
 
     rescue => err
@@ -545,6 +559,21 @@ module Flor
       nil
     end
 
+    def on(key, actions=[], &block)
+
+      as =
+        case actions
+        when :any, 'any' then []
+        when Array then actions
+        when Symbol then [ actions ]
+        when String then actions.split(/\s*[;,]\s*/)
+        else []
+        end
+          .collect(&:to_sym)
+
+      (@callbacks[key] ||= []) << [ as, block ]
+    end
+
     protected
 
     def migration_table_and_column(opts={})
@@ -637,10 +666,11 @@ module Flor
     def reschedule_timer(t)
 
       w = { id: t.id.to_i, status: 'active', mtime: t.mtime, munit: t.munit }
+      r = nil
 
       if t.type != 'at' && t.type != 'in'
 
-        @db[:flor_timers]
+        r = @db[:flor_timers]
           .where(w)
           .update(
             count: t.count.to_i + 1,
@@ -649,9 +679,11 @@ module Flor
             mtime: Flor.tstamp,
             munit: @unit.identifier)
 
+        callback(:timers, :update, w, t)
+
       elsif @archive
 
-        @db[:flor_timers]
+        r = @db[:flor_timers]
           .where(w)
           .update(
             count: t.count.to_i + 1,
@@ -659,12 +691,18 @@ module Flor
             mtime: Flor.tstamp,
             munit: @unit.identifier)
 
+        callback(:timers, :update, w, t)
+
       else
 
-        @db[:flor_timers]
+        r = @db[:flor_timers]
           .where(w)
           .delete
+
+        callback(:timers, :delete, w, t)
       end
+
+      r
     end
 
     def remove_nodes(exe, status, now)
@@ -686,6 +724,8 @@ module Flor
         # done in update_pointers
     end
 
+    FP_TYPES = %w[ var ].freeze
+
     def update_pointers(exe, status, now)
 
 # Q  Should we archive old pointers?
@@ -701,7 +741,7 @@ module Flor
 
       @db[:flor_pointers]
         .where(exid: exid)
-        .where(Sequel.|({ type: %w[ var ] }, Sequel.~(nid: exe['nodes'].keys)))
+        .where(Sequel.|({ type: FP_TYPES }, Sequel.~(nid: exe['nodes'].keys)))
         .delete
           #
           # Delete all pointer to vars, their value might have changed,
@@ -714,10 +754,14 @@ module Flor
       pointers = exe['nodes']
         .inject([]) { |a, (nid, node)|
 
+          # add a pointer for each tag
+
           ts = node['tags']
           ts.each { |t|
             a << [ dom, exid, nid, 'tag', t, nil, now, u, nil ] } if ts
 
+          # add a pointer for each var (if nid == '0')
+
           vs = nid == '0' ? node['vars'] : nil
           vs.each { |k, v|
             case v; when Numeric, String, TrueClass, FalseClass, NilClass
@@ -729,6 +773,8 @@ module Flor
               a << [ dom, exid, '0', 'var', k, nil, now, u, v ]
             end } if vs
 
+          # add a pointer for the task if any
+
           if ta = node['task']
             tasker = ta['tasker']
             n = ta['name']; name = n.is_a?(String) ? n : JSON.dump(n)
@@ -736,6 +782,29 @@ module Flor
             a << [ dom, exid, nid, 'tasker', tasker, name, now, u, content ]
           end
 
+          # add a pointer for the error if any
+
+          if fa = node['failure']
+
+#puts "-" * 80; pp node; puts "-" * 80
+            a <<
+              if er = fa['error']
+                ni = fa['from'] || nid # not nid /!\
+                nam = "#{er['kla']} l#{er['lin']}"
+                val = er['msg']
+                con = { error: fa, nid: ni }
+                [ dom, exid, ni, 'failure', nam, val, now, u, con ]
+              else
+                nam = fa['tasker'] || 'failure'
+                val = [ fa['attl'] || [], fa['attd'] || {} ]
+                  .collect(&:inspect).join(' ')
+                con = { error: fa, nid: nid }
+                [ dom, exid, nid, 'failure', nam, val, now, u, con ]
+              end
+          end
+
+          # done
+
           a }
 
       cps = @db[:flor_pointers] # current pointers
@@ -747,20 +816,14 @@ module Flor
           #
           # don't insert when already inserted
 
-      #if pointer_columns.include?(:content)
       pointers.each { |ptr| c = ptr[8]; ptr[8] = to_blob(c) if c }
-      #else
-      #  pointers.each { |ptr| ptr.pop }
-      #end
-
-      #@db[:flor_pointers]
-      #  .import(
-      #    pointer_columns,
-      #    pointers)
+
       @db[:flor_pointers]
         .import(
           POINTER_COLUMNS,
           pointers)
+
+      callback(:pointers, :update, exid)
     end
 
     #def pointer_columns
@@ -809,6 +872,23 @@ module Flor
         .inject([]) { |a, elt| a << [ a.last, elt ].compact.join('.'); a }
     end
 
+    def callback(table, action, *rest)
+
+      (@callbacks[table] || [])
+        .each { |as, block|
+          call_back(block, table, action, *rest) \
+            if as.empty? || as.include?(action) }
+    end
+
+    def call_back(block, table, action, *rest)
+
+      block.call(
+        *(
+          block.arity < 0 ?
+          [ table, action, *rest ] :
+          [ table, action, *rest ][0, block.arity]))
+    end
+
     class DbLogger
 
       def initialize(unit); @unit = unit; end

data/lib/flor.rb

@@ -16,7 +16,7 @@ require 'dense'
 
 module Flor
 
-  VERSION = '1.2.2'
+  VERSION = '1.5.0'
 end
 
 require 'flor/colours'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flor
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.5.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-29 00:00:00.000000000 Z
+date: 2021-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: munemo
@@ -204,6 +204,7 @@ files:
 - lib/flor/pcore/on.rb
 - lib/flor/pcore/on_cancel.rb
 - lib/flor/pcore/on_error.rb
+- lib/flor/pcore/on_receive.rb
 - lib/flor/pcore/push.rb
 - lib/flor/pcore/rand.rb
 - lib/flor/pcore/range.rb
@@ -249,6 +250,7 @@ files:
 - lib/flor/to_string.rb
 - lib/flor/tools/env.rb
 - lib/flor/tools/firb.rb
+- lib/flor/tools/flotojson.rb
 - lib/flor/tools/shell.rb
 - lib/flor/tools/shell_out.rb
 - lib/flor/tt.rb