flor 0.11.0 → 0.12.0

data/lib/flor/punit/trace.rb

@@ -21,7 +21,7 @@ class Flor::Pro::Trace < Flor::Procedure
 
     payload['ret'] = node_payload_ret
 
-    reply
+    wrap
   end
 end
 

data/lib/flor/punit/trap.rb

@@ -42,13 +42,14 @@ class Flor::Pro::Trap < Flor::Procedure
 
     msg =
       if fun
-        apply(fun, [], tree[2], false).first.merge('noreply' => true)
+        apply(fun, [], tree[2], false).first
       else
-        reply.first
+        wrap_reply.first
       end
 
     tra = {}
-    tra['bnid'] = parent || '0' # shouldn't it be [the real] root?
+    tra['nid'] = nid
+    tra['bnid'] = parent || '0'
     tra['points'] = points
     tra['tags'] = tags
     tra['heaps'] = heaps
@@ -63,14 +64,29 @@ class Flor::Pro::Trap < Flor::Procedure
 
     tra['range'] = att('range') || att('scope') || 'subnid'
 
-    reply('point' => 'trap','nid' => nid, 'trap' => tra) +
-    (fun ? reply : [])
+    @node['trapped'] = true
+
+    wrap('point' => 'trap', 'nid' => nid, 'trap' => tra) +
+    (fun ? flank : [])
   end
 
   def receive_last
 
-    #fail ArgumentError.new('trap requires a function')
     receive_non_att
   end
+
+  def receive
+
+    return [] if @node['trapped']
+    super
+  end
+
+  # "trap" keeps track of its children, but does not cascade 'cancel' to them,
+  # unless the cancel flavour is 'kill'.
+  #
+  def wrap_cancel_children(h={})
+
+    h['flavour'] == 'kill' ? super : []
+  end
 end
 

data/lib/flor/to_string.rb

@@ -37,8 +37,9 @@ module Flor
 
   def self.node_status_to_s(n)
 
-    s = StringIO.new
     stas = n['status'].reverse
+
+    s = StringIO.new
     while sta = stas.shift
       s << '(status ' << (sta['status'] || 'o') # o for open
       s << ' pt:' << sta['point']

data/lib/flor/unit/executor.rb

@@ -70,8 +70,6 @@ module Flor
           m = @messages.shift
         end
 
-        point = m['point']
-
         ms = process(m)
 
         @consumed << m
@@ -86,11 +84,11 @@ module Flor
         @unit.storage.put_messages(oms)
       end
 
-      @unit.storage.consume(@consumed)
-
       @alive = false
 
       @unit.storage.put_execution(@execution)
+      @unit.storage.consume(@consumed)
+
       @unit.storage.put_messages(@messages)
 
       du = Time.now - t0
@@ -135,7 +133,7 @@ module Flor
 
     def schedule(message)
 
-      @unit.put_timer(message)
+      @unit.schedule(message)
 
       []
     end

data/lib/flor/unit/hooker.rb

@@ -134,10 +134,10 @@ module Flor
 
       if hook.is_a?(Flor::Trap) && o(opts, :subnid)
         if node = executor.node(message['nid'], true)
-          return false unless node.descendant_of?(hook.nid, true)
+          return false unless node.descendant_of?(hook.bnid, true)
           node = node.h
         else
-          return false if hook.nid != '0'
+          return false if hook.bnid != '0'
         end
       end
 
@@ -145,7 +145,6 @@ module Flor
         return false unless node ||= executor.node(message['nid'])
         return false unless hps.include?(node['heap'])
       end
-#p :yyy if hook.is_a?(Flor::Trap)
 
       if hts = o(opts, :heat, :ht, [])
         return false unless node ||= executor.node(message['nid'])

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

@@ -5,17 +5,23 @@ module Flor
 
     def to_trigger_message
 
-      m = self.data(false)['message']
+      d = self.data(false)
+
+      m = d['message']
       m['timer_id'] = self.id
 
+      sm = d['m']
+
       {
         'point' => 'trigger',
         'exid' => self.exid,
-        'nid' => self.nid,
+        'nid' => self.onid,
+        'bnid' => self.nid,
         'type' => self.type,
         'schedule' => self.schedule,
         'timer_id' => self.id,
-        'message' => m
+        'message' => m,
+        'sm' => sm
       }
     end
 

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

@@ -89,6 +89,7 @@ module Flor
         'trap' => to_hash,
         'trap_id' => self.id,
         'message' => msg,
+        'sm' => message['m'],
         #'dbg' => xx
       }#.tap { |m| pp m }
     end

data/lib/flor/unit/scheduler.rb

@@ -14,9 +14,7 @@ module Flor
 
     def initialize(conf={}, over_conf={})
 
-      @conf = conf.is_a?(Hash) ? conf : Flor::Conf.read(conf)
-      @conf.merge!(Flor::Conf.read_env)
-      @conf.merge!(over_conf)
+      @conf = Flor::Conf.prepare(conf, over_conf)
 
       fail ArgumentError.new(
         "invalid domain name #{@conf['domain']}"
@@ -65,7 +63,7 @@ module Flor
         #
       Kernel.const_set(c, self) if c
 
-      @archive = nil # used, so far, only for testing
+      @archive = @conf['archive'] ? {} : nil # used, so far, only for testing
     end
 
     def name
@@ -254,27 +252,26 @@ module Flor
       nil
     end
 
-    def cancel(h)
+    def cancel(exid, *as)
 
-      queue(prepare_message('cancel', h), h)
+      queue(*prepare_message('cancel', [ exid, *as ]))
     end
 
     def signal(name, h={})
 
       h[:payload] ||= {}
       h[:name] ||= name
-      queue(prepare_message('signal', h), h)
+
+      queue(*prepare_message('signal', [ h ]))
     end
 
-    def re_apply(h)
+    def re_apply(exid, *as)
 
-      queue(prepare_message('cancel', h.merge(re_apply: true)), h)
+      queue(*prepare_message('cancel', [ exid, *as, { re_apply: true } ]))
     end
 
-    def put_timer(message)
+    def schedule(message)
 
-      #timer = @storage.put_timer(message)
-      #@mutex.synchronize { @timers.push(timer).sort_by!(&:ntime) }
       @storage.put_timer(message)
     end
 
@@ -304,16 +301,14 @@ module Flor
       @storage.put_trap(node, tra)
     end
 
-    def remove_node(exid, n)
+    def archive_node(exid, node)
 
-      #@storage.remove_node(exid, n)
-        # done in Storage#put_execution
+      (@archive[exid] ||= {})[node['nid']] = Flor.dup(node) if @archive
+    end
 
-      #@mutex.synchronize do
-      #  @timers.reject! { |t| t.exid == exid && t.nid == n['nid'] }
-      #end
+    def archived_node(exid, nid)
 
-      (@archive[exid] ||= {})[n['nid']] = Flor.dup(n) if @archive
+      (@archive[exid] || {})[nid]
     end
 
     def executor(exid)
@@ -362,35 +357,45 @@ module Flor
       puts on_start_exc(ex)
     end
 
-    def prepare_on_receive_last(h)
+    def prepare_on_receive_last(msg, opts)
 
-      ei = h[:exid] || h['exid']
-      ni = h[:nid] || h['nid']
-      t = h[:tree] || h['tree']
-      pl = h[:payload] || h['payload']
+      fail ArgumentError.new("missing 'payload' to re_apply") \
+        unless msg['payload']
 
-      fail ArgumentError.new('missing :payload to re_apply') unless pl
-
-      t = Flor::Lang.parse(t, 're_apply', {})
+      t = Flor::Lang.parse(opts[:tree], 're_apply', {})
 
       [
         { 'point' => 'execute',
-          'exid' => ei, 'nid' => ni,
+          'exid' => msg['exid'], 'nid' => msg['nid'],
           'from' => 'parent',
           'tree' => t,
-          'payload' => pl }
+          'payload' => msg['payload'] }
       ]
     end
 
-    def prepare_message(point, h)
+    def prepare_message(point, args)
+
+      h =
+        args.inject({}) { |hh, a|
+          if a.is_a?(Hash) then a.each { |k, v| hh[k.to_s] = v }
+          elsif ! hh.has_key?('exid') then hh['exid'] = a
+          elsif ! hh.has_key?('nid') then hh['nid'] = a
+          end
+          hh }
 
       msg = { 'point' => point }
+      opts = {}
 
-      [ :exid, :name, :nid, :payload, :on_receive_last ]
-        .each { |k| v = h[k] || h[k.to_s]; msg[k.to_s] = v if v }
+      h.each do |k, v|
+        if %w[ exid name nid payload on_receive_last ].include?(k)
+          msg[k] = v
+        else
+          opts[k.to_sym] = v
+        end
+      end
 
-      if h[:re_apply]
-        msg['on_receive_last'] = prepare_on_receive_last(h)
+      if opts[:re_apply]
+        msg['on_receive_last'] = prepare_on_receive_last(msg, opts)
       end
 
       fail ArgumentError.new('missing :exid key') \
@@ -398,7 +403,7 @@ module Flor
       fail ArgumentError.new('missing :name string key') \
         if point == 'signal' && ! msg['name'].is_a?(String)
 
-      msg
+      [ msg, opts ]
     end
 
     def make_idle_message

data/lib/flor/unit/storage.rb

@@ -121,27 +121,25 @@ module Flor
       end
     end
 
-    def put_execution(ex)
+    def put_execution(exe)
 
       status =
-        if ex['nodes']['0'] && ex['nodes']['0']['removed']
-          'terminated'
-        else
-          'active'
-        end
+        exe['nodes'].find { |_, n| n['status'].last['status'] != 'ended' } ?
+        'active' :
+        'terminated'
 
-      id = ex['id']
+      id = exe['id']
 
       if id
 
-        ex['end'] ||= Flor.tstamp \
+        exe['end'] ||= Flor.tstamp \
           if status == 'terminated'
-        ex['duration'] = Time.parse(ex['end']) - Time.parse(ex['start']) \
-          if ex['end']
+        exe['duration'] = Time.parse(exe['end']) - Time.parse(exe['start']) \
+          if exe['end']
       end
 
-      data = to_blob(ex)
-      ex['size'] = data.length
+      data = to_blob(exe)
+      exe['size'] = data.length
       u = @unit.identifier
 
       transync do
@@ -160,13 +158,13 @@ module Flor
 
         else
 
-          ex['id'] =
+          exe['id'] =
             @db[:flor_executions]
               .insert(
-                domain: Flor.domain(ex['exid']),
-                exid: ex['exid'],
+                domain: Flor.domain(exe['exid']),
+                exid: exe['exid'],
                 content: data,
-                status: 'active',
+                status: status,
                 ctime: now,
                 mtime: now,
                 cunit: u,
@@ -174,15 +172,15 @@ module Flor
               .to_i
         end
 
-        remove_nodes(ex, status, now)
-        update_pointers(ex, status, now)
+        remove_nodes(exe, status, now)
+        update_pointers(exe, status, now)
       end
 
-      ex
+      exe
 
     rescue => err
 
-      Thread.current[:sto_errored_items] = [ ex ]
+      Thread.current[:sto_errored_items] = [ exe ]
       raise err
     end
 
@@ -351,6 +349,13 @@ module Flor
           .where { mtime < tstamp }
           .update(status: 'created')
       end
+
+    rescue => err
+
+      @unit.logger.warn(
+        "#{self.class}#unreserve_messages(#{max_sec})", err, '(returning nil)')
+
+      -1 # not zero, to indicate a problem
     end
 
     def put_timer(message)
@@ -364,20 +369,23 @@ module Flor
 
       synchronize do
 
-        @db[:flor_timers].insert(
-          domain: Flor.domain(message['exid']),
-          exid: message['exid'],
-          nid: 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)
+        @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
 
       @unit.wake_up
@@ -414,22 +422,24 @@ module Flor
       id =
         synchronize do
 
-          @db[:flor_traps].insert(
-            domain: dom,
-            exid: exid,
-            nid: tra['bnid'],
-            onid: node['nid'],
-            trange: tra['range'],
-            tpoints: tra['points'],
-            ttags: tra['tags'],
-            theats: tra['heats'],
-            theaps: tra['heaps'],
-            content: to_blob(tra),
-            status: 'active',
-            ctime: now,
-            mtime: now,
-            cunit: u,
-            munit: u)
+          @db[:flor_traps]
+            .insert(
+              domain: dom,
+              exid: exid,
+              nid: tra['nid'],
+              onid: tra['onid'] || tra['nid'],
+              bnid: tra['bnid'],
+              trange: tra['range'],
+              tpoints: tra['points'],
+              ttags: tra['tags'],
+              theats: tra['heats'],
+              theaps: tra['heaps'],
+              content: to_blob(tra),
+              status: 'active',
+              ctime: now,
+              mtime: now,
+              cunit: u,
+              munit: u)
         end
 
       traps[id]
@@ -446,14 +456,15 @@ module Flor
 
       synchronize do
 
-        @db[:flor_traces].insert(
-          domain: Flor.domain(exid),
-          exid: exid,
-          nid: nid,
-          tracer: tracer,
-          text: text,
-          ctime: Flor.tstamp,
-          cunit: @unit.identifier)
+        @db[:flor_traces]
+          .insert(
+            domain: Flor.domain(exid),
+            exid: exid,
+            nid: nid,
+            tracer: tracer,
+            text: text,
+            ctime: Flor.tstamp,
+            cunit: @unit.identifier)
       end
     end
 
@@ -558,7 +569,7 @@ module Flor
 
       exid = exe['exid']
 
-      x = status == 'terminated' ? {} : { nid: exe['nodes'].keys }
+      x = (status == 'terminated') ? {} : { nid: exe['nodes'].keys }
         # if 'terminated' include all nodes
 
       if @archive