flor 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e6d591b2767c85e10b697b1839fb9142b52d0409bca73da41baa571f4e3aa8b
-  data.tar.gz: 6e9b4d916ccf37ee6189aed18a9365b98e79f8b6329cce4f1b4ed89f0acd4230
+  metadata.gz: 62c06708e2abc35f1b43c2cf9ecaf73d5f89633433c60af3864450d91ccabf47
+  data.tar.gz: 33d4531561c77d0f43cd97a51775d1079a41885650df73583c26050846177087
 SHA512:
-  metadata.gz: 1572f392ea4e391674b79b02d09992a3c27c64485c64132ac84c3d37a031436fec5090cf2e2932996c8ee7e2879ce5f502a7c037324d48cba505b15d3924a0bf
-  data.tar.gz: a8f1272f9b4a992fac31530d9e53b6e8c91fbd8032891087dd546c677fb1c9f8218a051eac9fe54c23c8bb8cdb6b3b727f269768f92fb62d8fb6cb1bdf1318f0
+  metadata.gz: b27557dcfbf250d1b0af9c4220a140b66e84aceb0506d947a51a1440fabf385f21b2ce125c08178bf68d5c13b87ee3d9967fdf0a46d5ef3b473991b3329139c4
+  data.tar.gz: 48fdc31b116360526afa4fe6b40e0b550c04bc451085aac55005f28add44bb30802029218f73fd898965b54f2a88acb95eb9420e73ca83d494b9fed1fdf64cf7

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 # CHANGELOG.md
 
 
+## flor 1.1.0  released 2021-01-06
+
+* Introduce Tasker #set_payload and #set_vars
+* Introduce the ModuleGanger
+* Allow for domain/dot.json taskers
+* Introduce Flor::StagedBasicTasker
+* Fix service/executor issue in Caller
+
+
 ## flor 1.0.1  released 2020-11-23
 
 * Accept sto_uri strings pointing to constant like 'DB'

data/lib/flor.rb

@@ -15,7 +15,7 @@ require 'dense'
 
 module Flor
 
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end
 
 require 'flor/colours'

data/lib/flor/core/texecutor.rb

@@ -254,7 +254,7 @@ module Flor
           o.each { |ee| ee['_path'] = path if ee.is_a?(Hash) }
         end
 
-        o
+        rework_conf(o)
       end
 
       def interpret_path(path, context=nil)
@@ -299,6 +299,31 @@ module Flor
 
         ps.last == 'etc' ? File.absolute_path(File.join(dir, '..')) : dir
       end
+
+      protected
+
+      # For now, only the return procedure has to be marshalled back
+      # to the "return" string, gh-36
+      #
+      def rework_conf(o)
+
+        case o
+        when Array
+          o.collect { |e|
+            rework_conf(e) }
+        when Hash
+          o.inject({}) { |h, (k, v)|
+            h[k] =
+              if Flor.is_proc_tree?(v) && v[1]['proc'] == 'return'
+                'return'
+              else
+                rework_conf(v)
+              end
+            h }
+        else
+          o
+        end
+      end
     end
   end
 end

data/lib/flor/flor.rb

@@ -20,7 +20,7 @@ module Flor
     signal cancel
     terminated failed ceased
     idle
-  ]
+      ].freeze
 
   class << self
 
@@ -279,13 +279,19 @@ module Flor
     #
     # functions about time
 
+    # Used by the storage in its next_time endeavours
+    #
+    def tstam
+      Time.now.utc.strftime('%FT%T')
+    end
+
     def isostamp(show_date, show_time, show_usec, time)
 
       t = (time || Time.now).utc
       s = StringIO.new
 
-      s << t.strftime('%Y-%m-%d') if show_date
-      s << t.strftime('T%H:%M:%S') if show_time
+      s << t.strftime('%F') if show_date   # YYYY-mm-dd
+      s << t.strftime('T%T') if show_time  # THH:MM:SS
       s << sprintf('.%06d', t.usec) if show_time && show_usec
       s << 'Z' if show_time
 
@@ -367,11 +373,18 @@ module Flor
       sub_domain?(dom, sub)
     end
 
+    def dot_join(*elts)
+
+      elts.collect(&:to_s).select { |e| e.length > 0 }.join('.')
+    end
+
     def sub_domain?(dom, sub)
 
-      dom == '' ||
-      sub == dom ||
-      sub[0, dom.length + 1] == dom + '.'
+      d = dom.is_a?(Array) ? dot_join(*dom) : dom.to_s
+
+      d == '' ||
+      sub == d ||
+      sub[0, d.length + 1] == d + '.'
     end
     alias subdomain? sub_domain?
 

data/lib/flor/log.rb

@@ -324,6 +324,7 @@ module Flor
     def msg_to_detail_s(executor, m, opts={})
 
       return if m['_detail_msg_flag']
+        #
       m['_detail_msg_flag'] = true if opts[:flag]
 
       o = StringIO.new

data/lib/flor/tools/firb.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'irb'
+
+#require 'sequel'
+require 'flor'
+require 'flor/unit'
+
+
+p [ RUBY_VERSION, RUBY_PLATFORM ]
+
+puts
+
+ENV.each do |k, v|
+  next unless k.match?(/RUBY|GEM/)
+  puts "* #{k}: #{v}"
+end
+
+ARGV.each do |arg|
+  if arg.match(/:/)
+    DB = Sequel.connect(arg)
+    p DB
+  end
+end
+
+#MODELS = [ :executions, :timers, :traces, :traps, :pointers, :messages ]
+if defined?(DB)
+  Flor::Message.dataset = DB[:flor_messages]
+end
+
+ARGV.clear
+IRB.start
+

data/lib/flor/tools/shell.rb

@@ -15,11 +15,16 @@ module Flor::Tools
     def initialize(argv=nil)
 
       env = ENV['FLOR_ENV'] || 'shell'
-      @root = "envs/#{env}"
+
+      @root = File.directory?(env) ? env : "envs/#{env}"
 
       prepare_home
 
-      @unit = Flor::Unit.new("#{@root}/etc/conf.json")
+      over_conf = {}
+        #
+      c = ENV['FLOR_STO_URI']; over_conf['sto_uri'] = c if c
+
+      @unit = Flor::Unit.new("#{@root}/etc/conf.json", over_conf)
 
       @unit.conf['unit'] = 'cli'
       #unit.hooker.add('journal', Flor::Journal)
@@ -31,7 +36,11 @@ module Flor::Tools
       @mute = false
       @paging = true
 
-      @unit.start
+      if ENV['FLOR_NO_START']
+        @unit.check_migration_version
+      else
+        @unit.start
+      end
 
       @flow_path = File.join(@root, 'home/scratch.flo')
       @ra_flow_path = File.join(@root, 'home/ra_scratch.flo')

data/lib/flor/unit.rb

@@ -22,6 +22,7 @@ require 'flor/unit/loader'
 require 'flor/unit/hloader'
 require 'flor/unit/ganger'
 require 'flor/unit/spooler'
+require 'flor/unit/gangers'
 require 'flor/unit/taskers'
 
 Flor.load_procedures('punit')

data/lib/flor/unit/caller.rb

@@ -107,9 +107,11 @@ module Flor
       #
       # call
 
-      p = message['point']
-      ms = [ "on_#{p}", :on_message, :on, p ]
-      ms = ms + [ :on_cancel, :cancel ] if p == 'detask'
+      pt = message['point']
+
+      ms = [ "call_#{pt}", "on_#{pt}", :on_message, :on, pt ]
+      ms = ms + [ :on_cancel, :cancel ] if pt == 'detask'
+
       m = ms.find { |mm| o.respond_to?(mm) }
 
       fail(
@@ -121,7 +123,7 @@ module Flor
         case o.method(m).arity
         when 1 then o.send(m, message)
         when 2 then o.send(m, conf, message)
-        when 3 then o.send(m, executor, conf, message)
+        when 3 then o.send(m, service, conf, message)
         when -1 then o.send(m, {
           service: service, configuration: conf, message: message })
         else o.send(m)

data/lib/flor/unit/executor.rb

@@ -109,15 +109,13 @@ module Flor
     rescue Exception => exc
 
 # TODO eventually, have a dump dir
+
       fn =
-        [
-          'flor',
-          @unit.conf['env'], @unit.identifier, @exid,
-          'r' + counter('runs').to_s
-        ].collect(&:to_s).join('_') + '.dump'
+        [ 'flor', @unit.conf['env'], @unit.identifier, @exid,
+          'r' + counter('runs').to_s ].collect(&:to_s).join('_') + '.dump'
 
       @unit.logger.error(
-        "#{self.class}#do_run()", exc, "(dumping to #{fn})")
+        "#{self.class}#do_run()", exc, "(dumping to #{fn} ...)")
 
       File.open(fn, 'wb') do |f|
         f.puts(Flor.to_pretty_s({
@@ -134,19 +132,26 @@ module Flor
         f.puts(on_do_run_exc(exc))
       end
 
+      @unit.logger.error(
+        "#{self.class}#do_run()", exc, "(dumped to #{fn})")
+
       #puts on_do_run_exc(exc)
         # dump notification above
     end
 
     def task(message)
 
-      return error_reply(
-        node(message['nid']),
-        message,
-        "don't know how to apply #{message['tasker'].inspect}"
-      ) if message['routed'] == false
-        #
-        # use an error message similar to what the core executor would emit
+      if message['routed'] == false
+
+        t = message['tasker']
+        n = node(message['nid'])
+
+        msg = n['heat0'] != t ?
+          "tasker #{t.inspect} not found" :
+          "don't know how to apply #{t.inspect}"
+
+        return error_reply(n, message, msg)
+      end
 
       @unit.ganger.task(self, message)
     end

data/lib/flor/unit/ganger.rb

@@ -54,6 +54,9 @@ module Flor
          (@unit.loader.tasker(domain, 'ganger', message) ||
           @unit.loader.tasker(domain, 'tasker', message))) ||
         @unit.loader.tasker(domain, tname, message)
+#puts "=" * 80
+#pp tconf
+#puts "=" * 80
 
       fail ArgumentError.new(
         "tasker #{tname.inspect} not found"

data/lib/flor/unit/gangers.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Flor
+
+  # A ModuleGanger accepts a `module:` conf entry that points to a Ruby
+  # module. The tasker implementations are searched for among the classes
+  # in the given module.
+  #
+  # Among the tasker classes (classes that respond to on_task, on_detask, ...)
+  # it selects the first tasker that matches the tasker name.
+  #
+  class ModuleGanger
+
+    def initialize(service, conf, message)
+
+      @service = service
+      @conf = conf
+      @message = message
+    end
+
+    def task
+
+      tas = @message['tasker']
+      clas = list_tasker_classes
+      cla = clas.find { |c| tasker_name(c) == tas }
+
+      return [ Flor.dup_and_merge(@message, 'routed' => false) ] \
+        unless cla
+
+      call_tasker(cla)
+    end
+
+    alias detask task
+
+    protected
+
+    def list_tasker_classes
+
+      mod_name = @conf['module']
+
+      fail ArgumentError.new('ganger module: configuration entry missing') \
+        unless mod_name
+
+      mod = Flor.const_lookup(mod_name) rescue nil
+
+      fail ArgumentError.new("ganger cannot find module #{mod_name.inspect}") \
+        unless mod
+
+      list_classes(mod, [])
+    end
+
+    def list_classes(start, r)
+
+      # place leave classes on top if possible
+      # within a level, sort alphabetically
+
+      clas = start.constants.collect { |co| start.const_get(co) }
+      clas, mods = clas.partition { |c| c.is_a?(Class) }
+
+      mods.each { |m| list_classes(m, r) }
+      r.concat(clas.select { |c| tasker?(c) }.sort_by { |c| c.name })
+
+      r
+    end
+
+    TASKER_METHODS = [
+      :on, :on_message,
+      :task, :on_task,
+      :detask, :on_detask, :cancel, :on_cancel
+        ].freeze
+
+    def tasker?(cla)
+
+      return true if (TASKER_METHODS & cla.public_instance_methods).any?
+      return true if (TASKER_METHODS & cla.public_methods).any?
+      false
+    end
+
+    def tasker_name(cla)
+
+      if cla.public_instance_methods.include?(:tasker_name)
+
+        unless cla.respond_to?(:_ganged)
+          class << cla
+            attr_accessor :_ganged
+          end
+          cla._ganged = cla.allocate
+        end
+
+        call_tasker_name(cla._ganged)
+
+      elsif cla.public_methods.include?(:tasker_name)
+
+        call_tasker_name(cla)
+
+      else
+
+        cla.name.split('::').last.gsub(/Tasker\z/, '')
+          .gsub(/([a-z])([A-Z])/) { |_| $1 + '_' + $2.downcase }
+          .gsub(/([A-Z])/) { |c| c.downcase }
+      end
+    end
+
+    def call_tasker_name(o)
+
+      case i = o.method(:tasker_name).arity
+      when 1 then o.tasker_name(@message)
+      when 2 then o.tasker_name(@conf, @message)
+      when 3 then o.tasker_name(@service, @conf, @message)
+      when -1 then o.tasker_name(
+        service: @service, conf: @conf, message: @message)
+      else o.tasker_name
+      end
+    end
+
+    def call_tasker(c)
+
+      cnf = @conf.merge('class' => c)
+
+      @service.unit.caller
+        .call(@service, cnf, @message)
+    end
+  end
+end
+

data/lib/flor/unit/loader.rb

@@ -46,7 +46,7 @@ module Flor
         .collect { |pa| [ pa, expose_d(pa, {}) ] }
         .select { |pa, d| Flor.sub_domain?(d, domain) }
         .sort_by { |pa, d| d.count('.') }
-        .inject({}) { |vars, (pa, _)| vars.merge!(eval(pa, {})) }
+        .inject({}) { |vars, (pa, _)| vars.merge!(eval_variables(pa, {})) }
     end
 
     #def procedures(path)
@@ -87,25 +87,28 @@ module Flor
         .select { |pa| pa.index('/lib/taskers/') }
         .collect { |pa| [ pa, *expose_dn(pa, {}) ] }
         .select { |pa, d, n|
-          Flor.sub_domain?([ d, n ].join('.'), domain) ||
+          Flor.sub_domain?([ d, n ], domain) ||
           (n == name && Flor.sub_domain?(d, domain)) }
         .sort_by { |pa, d, n| d.count('.') }
         .last
 
       return nil unless pat
 
-      conf = eval(pat, message)
+      conf = eval_tasker_conf(pat, message)
 
       return conf if nam == name
 
-      conf = conf[name]
+      cnf = conf[name]
 
-      return nil unless conf
+      return nil unless cnf
 
-      (conf.is_a?(Array) ? conf : [ conf ])
-        .each { |h| h['_path'] = pat }
+      extras = conf.select { |_, v| ! v.is_a?(Hash) }
+      extras['_path'] = pat
 
-      conf
+      (cnf.is_a?(Array) ? cnf : [ cnf ])
+        .each { |h| h.merge!(extras) }
+
+      cnf
     end
 
     def hooks(domain)
@@ -119,8 +122,8 @@ module Flor
         .select { |pa, d| Flor.sub_domain?(d, domain) }
         .sort_by { |pa, d| d.count('.') }
         .collect { |pa, d|
-          eval(pa, {})
-            .each_with_index { |h, i| h['_path'] = pa + ":#{i}" } }
+          eval_hook_conf(pa, {})
+            .each_with_index { |h, i| h['_path'] = "#{pa}:#{i}" } }
         .flatten(1)
     end
 
@@ -247,6 +250,35 @@ module Flor
       end
     end
 
+    def eval_variables(path, context)
+      eval(path, context)
+    end
+    def eval_tasker_conf(path, context)
+      eval(path, context)
+    end
+# TODO like in eval_hook_conf, reject fautly tasker confs...
+# TODO like in eval_hook_conf, reject fautly variables...
+
+    def eval_hook_conf(path, context)
+
+      a = eval(path, context)
+
+      fail ArgumentError.new(
+        "hook conf at #{path} must be an array of hashes"
+      ) unless a.is_a?(Array)
+
+      a.each do |e|
+        fail ArgumentError.new(
+          "hook conf at #{path} has non-hash entry #{e.inspect}"
+        ) unless e.is_a?(Hash)
+        fail ArgumentError.new(
+          "hook conf at #{path} has incorrect point #{e['point'].inspect}"
+        ) unless e['point'].is_a?(String)
+      end
+
+      a
+    end
+
     def eval(path, context)
 
       ext =

data/lib/flor/unit/logger.rb

@@ -71,7 +71,8 @@ module Flor
       dbi = ' ' + dbi if dbi.length > 0
 
       txt = elts.collect(&:to_s).join(' ')
-      err = elts.find { |e| e.is_a?(Exception) }
+
+      err = find_err(elts)
 
       head = "#{stp} #{@uni}#{dbi} #{lvl} "
 
@@ -198,7 +199,8 @@ module Flor
 
       return unless @unit.conf['log_err']
 
-      @out.puts(Flor.msg_to_detail_s(executor, message, opts.merge(flag: true)))
+      s = Flor.msg_to_detail_s(executor, message, opts.merge(flag: true))
+      @out.puts(s) if s
     end
 
     def log_src(source, opts, log_opts={})
@@ -245,6 +247,13 @@ module Flor
       message[0..k + 2 + 4] + "(...len#{i - (k + 2 + 1)})" + message[i..-1]
     end
 
+    def find_err(elts)
+
+      elts.find { |e| e.is_a?(Exception) } ||
+      (defined?(Java) &&
+       elts.find { |e| e.class.ancestors.include?(Java::JavaLang::Error) })
+    end
+
     class Out
 
       attr_reader :unit

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+
 module Flor
 
   class Message < FlorModel
@@ -19,6 +20,10 @@ module Flor
     #
     #  index :exid
     #end
+
+    def nid; data['nid']; end
+    def tasker; data['tasker']; end
+    alias payload data
   end
 end
 

data/lib/flor/unit/scheduler.rb

@@ -138,11 +138,7 @@ module Flor
 
       # TODO heartbeat, every x minutes, when idle, log something
 
-      fail(
-        "database not ready, " +
-        "db ver: #{@storage.db_version.inspect}, " +
-        "mig ver: #{@storage.migration_version}"
-      ) if !! @conf['sto_migration_check'] && @storage.ready?
+      check_migration_version
 
       @thread_status = :running
 
@@ -162,6 +158,15 @@ module Flor
       self
     end
 
+    def check_migration_version
+
+      fail(
+        "database not ready, " +
+        "db ver: #{@storage.db_version.inspect}, " +
+        "mig ver: #{@storage.migration_version}"
+      ) if !! @conf['sto_migration_check'] && @storage.ready?
+    end
+
     def stop
 
       @thread_status = :stop
@@ -590,7 +595,7 @@ module Flor
 
     rescue Exception => ex
 
-      puts on_start_exc(ex)
+      puts(on_start_exc(ex))
     end
 
     def prepare_message(point, args)
@@ -678,9 +683,9 @@ module Flor
     def should_wake_up?
 
       return true if @wake_up
-      return true if Time.now - @reloaded_at >= reload_after
+      return true if (Time.now - @reloaded_at) >= reload_after
 
-      @next_time && @next_time <= Flor.tstamp.split('.').first
+      @next_time && (@next_time <= Flor.tstam)
     end
 
     def unreserve_messages

data/lib/flor/unit/storage.rb

@@ -7,6 +7,14 @@ module Flor
 
   class Storage
 
+    MESSAGE_COLUMNS = [
+      :domain, :exid, :point, :content,
+      :status, :ctime, :mtime, :cunit, :munit
+        ].freeze
+    POINTER_COLUMNS = [
+      :domain, :exid, :nid, :type, :name, :value, :ctime, :cunit
+        ].freeze
+
     attr_reader :unit, :db, :models
 
     attr_reader :mutex
@@ -352,8 +360,7 @@ module Flor
 
           @db[:flor_messages]
             .import(
-              [ :domain, :exid, :point, :content,
-                :status, :ctime, :mtime, :cunit, :munit ],
+              MESSAGE_COLUMNS,
               unstored.map { |m|
                 [ Flor.domain(m['exid']), m['exid'], m['point'], to_blob(m),
                   'created', n, n, u, u ] }) \
@@ -517,25 +524,6 @@ module Flor
       end
     end
 
-    def put_task_pointer(msg, tname, tconf)
-
-      exid = msg['exid']
-      dom = Flor.domain(exid)
-
-      synchronize do
-
-        @db[:flor_pointers]
-          .insert(
-            domain: dom,
-            exid: exid,
-            nid: msg['nid'],
-            type: 'tasker',
-            name: tname,
-            ctime: Flor.tstamp,
-            cunit: @unit.identifier)
-      end
-    end
-
     def fetch_next_time
 
       t =
@@ -598,14 +586,13 @@ module Flor
 
         @db[:flor_messages]
           .where(
-            id: messages.collect { |m| m['mid'] }.compact)
+            id: messages.collect { |m| m['mid'] }.uniq.compact)
           .update(
             status: 'consumed', mtime: n, munit: u)
 
         @db[:flor_messages]
           .import(
-            [ :domain, :exid, :point, :content,
-              :status, :ctime, :mtime, :cunit, :munit ],
+            MESSAGE_COLUMNS,
             messages
               .select { |m|
                 ! m['mid'] && POINTS_TO_ARCHIVE.include?(m['point']) }
@@ -621,19 +608,16 @@ module Flor
 
         @db[:flor_messages]
           .where(
-            id: messages.collect { |m| m['mid'] }.compact)
+            id: messages.collect { |m| m['mid'] }.uniq.compact)
           .delete
       end
     end
 
     def load_timers
 
-      now = Flor.tstamp
-      no = now[0, now.rindex('.')]
-
       timers
         .where(status: 'active')
-        .where { ntime <= no }
+        .where { ntime <= Flor.tstam }
         .order(:ntime)
         .all
 
@@ -703,9 +687,9 @@ module Flor
 
     def update_pointers(exe, status, now)
 
-# Q Should we archive old pointers?
-#   Well, it might be better to only archive the execution and leave
-#   in there enough information...
+# Q  Should we archive old pointers?
+# A  Well, it might be better to only archive the execution and leave
+#    in there enough information...
 
       exid = exe['exid']
 
@@ -731,23 +715,25 @@ module Flor
 
           ts = node['tags']
           ts.each { |t|
-            a << [ dom, exid, nid, 'tag', t, nil, now, u ] } if ts
+            a << [ dom, exid, nid, 'tag', t, nil, now, u, nil ] } if ts
 
           vs = nid == '0' ? node['vars'] : nil
           vs.each { |k, v|
             case v; when Numeric, String, TrueClass, FalseClass, NilClass
-              a << [ dom, exid, '0', 'var', k, v.to_s, now, u ]
+              a << [ dom, exid, '0', 'var', k, v.to_s, now, u, nil ]
             when Array, Hash
               s = '(array)'; s = '(object)' if v.is_a?(Hash)
-              a << [ dom, exid, '0', 'var', k, s, now, u ]
+              a << [ dom, exid, '0', 'var', k, s, now, u, nil ]
             else
-              a << [ dom, exid, '0', 'var', k, nil, now, u ]
+              a << [ dom, exid, '0', 'var', k, nil, now, u, nil ]
             end } if vs
 
-          #ta = node['heap'] == 'task' ? node['task'] : nil
-          ta = node['task']
-          a << [ dom, exid, nid, 'tasker', ta['tasker'], ta['name'], now, u ] \
-            if ta
+          if ta = node['task']
+            tasker = ta['tasker']
+            name = ta['name']
+            content = { message: node['message'], atts: node['atts'] }
+            a << [ dom, exid, nid, 'tasker', tasker, name, now, u, content ]
+          end
 
           a }
 
@@ -755,17 +741,35 @@ module Flor
         .where(exid: exid)
         .select(:nid, :type, :name)
         .all
-      pointers.reject! { |_, _, ni, ty, na, _, _, _|
+      pointers.reject! { |_, _, ni, ty, na, _, _, _, _|
         cps.find { |cp| cp[:nid] == ni && cp[:type] == ty && cp[:name] == na } }
           #
           # 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(
-          [ :domain, :exid, :nid, :type, :name, :value, :ctime, :cunit ],
+          pointer_columns,
           pointers)
     end
 
+    def pointer_columns
+
+      @pointer_columns ||=
+        if @db[:flor_pointers].columns.include?(:content)
+          POINTER_COLUMNS + [ :content ]
+        else
+          POINTER_COLUMNS
+        end
+    end
+
     def determine_type_and_schedule(message)
 
       t, s = message['type'], message['string']

data/lib/flor/unit/taskers.rb

@@ -29,6 +29,29 @@ module Flor
     alias task_name taskname
 
     def vars; @message['vars']; end
+    alias variables vars
+
+    def set_payload(h)
+      fail TypeError.new("not a hash but a #{fs.class}") unless h.is_a?(Hash)
+      @message['payload'] = h
+    end
+    alias set_fields set_payload
+
+    def set_vars(h)
+      fail TypeError.new("not a hash but a #{fs.class}") unless h.is_a?(Hash)
+      @message['vars'] = h
+    end
+    alias set_variables set_vars
+
+    #def merge_into_payload(h)
+    #  @message['payload'].merge(h)
+    #end
+    #alias merge_into_fields merge_into_payload
+    #def merge_into_vars(h)
+    #  @message['vars'].merge(h)
+    #end
+      #
+      # no for now, payload.merge(h) and vars.merge(h) do suffice
 
     def execution
 
@@ -112,5 +135,50 @@ module Flor
       h
     end
   end
+
+  # A BasicTasker with stages (pre / on / post)
+  #
+  class StagedBasicTasker < BasicTasker
+
+    def call_task
+
+      call_one_of(:pre_task)
+      call_one_of(:on_task, :task)
+    end
+
+    def call_detask
+
+      call_one_of(:pre_detask, :pre_cancel)
+      call_one_of(:on_detask, :on_cancel, :detask, :cancel)
+    end
+
+    protected
+
+    def call_one_of(*ms)
+
+      m = ms.flatten.find { |mm| respond_to?(mm) }
+
+      send(m) if m
+    end
+
+    def reply(message=@message, force=false)
+
+      fail ArgumentError.new(
+        "argument to reply must be a Hash but is #{message.class}"
+      ) unless message.is_a?(Hash)
+
+      pt = @message['point']
+
+      ms = [ "post_#{pt}" ]; ms << :post_cancel if pt == 'detask'
+        #
+      call_one_of(ms)
+
+      msg = derive_message(message)
+
+      @ganger.return(msg) if force || @ganger
+
+      [] # very important, return no further messages
+    end
+  end
 end
 

data/lib/flor/unit/waiter.rb

@@ -53,7 +53,7 @@ module Flor
 
       @mutex.synchronize do
 
-        return false unless match?(message)
+        return false unless msg_match?(message)
 
         @serie.shift
         return false if @serie.any?
@@ -151,7 +151,7 @@ module Flor
 
     protected
 
-    def match?(message)
+    def msg_match?(message)
 
       mpoint = message['point']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flor
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-23 00:00:00.000000000 Z
+date: 2021-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: munemo
@@ -248,6 +248,7 @@ files:
 - lib/flor/punit/trap.rb
 - lib/flor/to_string.rb
 - lib/flor/tools/env.rb
+- lib/flor/tools/firb.rb
 - lib/flor/tools/shell.rb
 - lib/flor/tools/shell_out.rb
 - lib/flor/tt.rb
@@ -257,6 +258,7 @@ files:
 - lib/flor/unit/dump.rb
 - lib/flor/unit/executor.rb
 - lib/flor/unit/ganger.rb
+- lib/flor/unit/gangers.rb
 - lib/flor/unit/hloader.rb
 - lib/flor/unit/hook.rb
 - lib/flor/unit/hooker.rb