flor 0.17.0 → 1.1.1

data/lib/flor/unit/dump.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Flor
+
+  class << self
+
+    # See Scheduler#dump for the details
+    #
+    def dump(db_or_unit_or_uri, io=nil, opts=nil, &block)
+
+      derive_unit(db_or_unit_or_uri)
+        .dump(io, opts, &block)
+    end
+
+    # See Scheduler#load for the details
+    #
+    def load(db_or_unit_or_uri, string_or_io, opts={}, &block)
+
+      derive_unit(db_or_unit_or_uri)
+        .load(string_or_io, opts, &block)
+    end
+
+    protected
+
+    def derive_unit(db_or_unit_or_uri)
+
+      case o = db_or_unit_or_uri
+      when Flor::Unit then o
+      when Sequel::Database then Flor::Unit.new(sto_db: o)
+      when String then Flor::Unit.new(sto_uri: o)
+      else fail ArgumentError.new("cannot derive flor Unit out of #{o.inspect}")
+      end
+    end
+  end
+end
+

data/lib/flor/unit/executor.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -108,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({
@@ -133,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
@@ -153,11 +159,15 @@ module Flor
 
     def return(message)
 
-      [ { 'point' => 'receive',
-          'exid' => message['exid'],
-          'nid' => message['nid'],
-          'payload' => message['payload'],
-          'tasker' => message['tasker'] } ]
+      n = @execution['nodes'][message['nid']] || {}
+      m = n['message'] || {}
+      c = m['cause']
+
+      rm = message.dup
+      rm['point'] = 'receive'
+      rm['cause'] = c if c # preserve 'cause' for routing
+
+      [ rm ]
     end
 
     def schedule(message)

data/lib/flor/unit/ganger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -22,6 +23,12 @@ module Flor
     def shutdown
     end
 
+    # Used by flor when it looks up for a variable and finds nothing.
+    # The last step is to ask the ganger if it knows about a tasker under
+    # the given (domain and) name.
+    #
+    # If it returns true, flor knows there is a tasker under that name.
+    #
     def has_tasker?(exid, name)
 
       #return false if RESERVED_NAMES.include?(name)
@@ -34,6 +41,9 @@ module Flor
         @unit.loader.tasker(d, name))
     end
 
+    # Called by Flor::Scheduler. The ganger then has to hand the task
+    # (the message) to the proper tasker.
+    #
     def task(executor, message)
 
       domain = message['exid'].split('-', 2).first
@@ -44,25 +54,31 @@ 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"
       ) unless tconf
 
       if tconf.is_a?(Array)
-        tconf =
-          tconf.find { |h| h['point'] == message['point'] } ||
-          tconf.find { |h| h['point'] == nil }
-        tconf ||=
-          tconf.find { |h| h['point'] == 'cancel' } \
-            if message['point'] == 'detask'
+
+        points = [ nil, message['point'] ]
+        points << 'detask' if points.include?('cancel')
+
+        tconf = tconf.find { |h| points.include?(h['point']) }
       end
 
+      fail ArgumentError.new(
+        "tconf #{tconf.inspect} not a hash"
+      ) unless tconf.is_a?(Hash)
+
       message['tconf'] = tconf unless tconf['include_tconf'] == false
 
       message['vars'] = gather_vars(executor, tconf, message)
 
-      m = dup_message(message)
+      m = Flor.dup_message(message)
         #
         # the tasker gets a copy of the message (and it can play with it
         # to its heart content), meanwhile the message is handed to the
@@ -74,6 +90,9 @@ module Flor
         # especially if it's a domain tasker
     end
 
+    # Called by the tasker implementations when they're done with a task
+    # and want to hand it back to flor. It might be a failure message.
+    #
     def return(message)
 
       @unit.return(message)
@@ -81,17 +100,6 @@ module Flor
 
     protected
 
-    def dup_message(m)
-
-      tc = m.delete('tconf')
-      m1 = Flor.dup(m)
-      m1['tconf'] = tc.inject({}) { |h, (k, v)|
-        h[k] = k == 'class' ? v : Flor.dup(v); h } \
-          if tc
-
-      m1
-    end
-
     def var_match(k, filter)
 
       filter.each { |f| return true if (f.is_a?(String) ? k == f : f.match(k)) }
@@ -120,6 +128,10 @@ module Flor
       }.compact
     end
 
+    # By default, taskers don't see the flor variables in the execution.
+    # If 'include_vars' or 'exclude_vars' is present in the configuration
+    # of the tasker, some or all of the variables are passed.
+    #
     def gather_vars(executor, tconf, message)
 
       # try to return before a potentially costly call to executor.vars(nid)

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/hloader.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 
 module Flor
 
   # A loader which keeps everything in a Hash, while the traditional/default
   # Flor::Loader reads from a file tree.
   #
-  class HashLoader
+  class HashLoader < CoreLoader
 
     # NB: tasker configuration entries start with "loa_", like for Flor::Loader
 
@@ -27,9 +28,6 @@ module Flor
       self.environment = (@unit.conf['lod_environment'] || {})
     end
 
-    def shutdown
-    end
-
     HCATS = {
       'v' => 'variables',
       'var' => 'variables',
@@ -53,9 +51,14 @@ module Flor
       path = path.to_s
       path = path + '.' if c == 'hooks' && path.length > 0 && path[-1, 1] != '.'
 
-      value = block ?
-        block_to_class(c, block) :
-        Flor.to_string_keyed_hash(value)
+      value =
+        if block
+          block_to_class(c, block)
+        elsif value.is_a?(Proc)
+          block_to_class(c, value)
+        else
+          Flor.to_string_keyed_hash(value)
+        end
 
       e = (@environment[c] ||= [])
       e << [ *split(path), value ]
@@ -132,6 +135,30 @@ module Flor
         .collect { |h| Flor::Hook.new(@unit, exid, h) }
     end
 
+    def domains(start=nil)
+
+      start ||= ''
+
+      @environment.values
+        .flatten(1)
+        .collect { |x| x.first }
+        .select { |dm| dm && dm.length > 0 }
+        .select { |dm| Flor.sub_domain?(start, dm) }
+        .uniq
+        .sort
+    end
+
+    def definitions(start=nil)
+
+      start ||= ''
+
+      @environment.values
+        .flatten(1)
+        .collect { |x| x[0, 2].join('.') }
+        .select { |fl| Flor.sub_domain?(start, fl) }
+        .sort
+    end
+
     protected
 
     def recompose(h)

data/lib/flor/unit/hook.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -14,6 +15,8 @@ module Flor
 
     def to_hook
 
+      @unit.loader.require(@h)
+
       if @h['class']
         class_to_hook
       elsif @h['instance']

data/lib/flor/unit/hooker.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -5,6 +6,22 @@ module Flor
 
     # NB: logger configuration entries start with "hok_"
 
+    attr_reader :hooks
+
+    KEYS = {
+      consumed:   [:consumed, :c].freeze,
+      point:      [:point, :p].freeze,
+      nid:        [:nid].freeze,
+      exid:       [:exid].freeze,
+      domain:     [:domain, :d].freeze,
+      subdomain:  [:subdomain, :sd].freeze,
+      tag:        [:tag, :t].freeze,
+      name:       [:name, :n].freeze,
+      subnid:     [:subnid].freeze,
+      heap:       [:heap, :hp].freeze,
+      heat:       [:heat, :ht].freeze
+    }.freeze
+
     def initialize(unit)
 
       @unit = unit
@@ -54,7 +71,11 @@ module Flor
         end
       end
 
-      hook = Flor::Hook.instantiate(@unit, hook) if hook.is_a?(Class)
+      hook = Flor::Hook.instantiate(@unit, hook) \
+        if hook.is_a?(Class)
+
+      name ||= hook.name \
+        if hook.respond_to?(:name) && hook.method(:name).arity < 1
 
       @hooks << [ name, opts, hook, block ]
     end
@@ -81,13 +102,10 @@ module Flor
 
     protected
 
-    def o(opts, *keys)
-
-      array = false
-      array = keys.pop if keys.last == []
+    def o(opts, key, array: false)
 
       r = nil
-      keys.each { |k| break r = opts[k] if opts.has_key?(k) }
+      KEYS[key].each { |k| break r = opts[k] if opts.has_key?(k) }
 
       return nil if r == nil
       array ? Array(r) : r
@@ -103,7 +121,7 @@ module Flor
 
       opts = hook.opts if hook.respond_to?(:opts) && opts.empty?
 
-      c = o(opts, :consumed, :c)
+      c = o(opts, :consumed)
       return false if c == true && ! message['consumed']
       return false if c == false && message['consumed']
 
@@ -112,7 +130,7 @@ module Flor
         return false if hook.within_itself?(executor, message)
       end
 
-      ps = o(opts, :point, :p, [])
+      ps = o(opts, :point, array: true)
       return false if ps && ! ps.include?(message['point'])
 
       if nid = o(opts, :nid)
@@ -127,24 +145,24 @@ module Flor
 
       dm = Flor.domain(message['exid'])
 
-      if dm && ds = o(opts, :domain, :d, [])
+      if dm && ds = o(opts, :domain, array: true)
         return false \
           unless ds.find { |d| d.is_a?(Regexp) ? (!! d.match(dm)) : (d == dm) }
       end
 
-      if dm && sds = o(opts, :subdomain, :sd, [])
+      if dm && sds = o(opts, :subdomain, array: true)
         return false \
           unless sds.find do |sd|
             dm[0, sd.length] == sd
           end
       end
 
-      if ts = o(opts, :tag, :t, [])
+      if ts = o(opts, :tag, array: true)
         return false unless %w[ entered left ].include?(message['point'])
         return false unless includes?(ts, message['tags'])
       end
 
-      if ns = o(opts, :name, :n)
+      if ns = o(opts, :name)
         name = message['name']
         return false \
           unless ns.find { |n|
@@ -166,12 +184,12 @@ module Flor
         end
       end
 
-      if hps = o(opts, :heap, :hp, [])
+      if hps = o(opts, :heap, array: true)
         return false unless node ||= executor.node(message['nid'])
         return false unless includes?(hps, node['heap'])
       end
 
-      if hts = o(opts, :heat, :ht, [])
+      if hts = o(opts, :heat, array: true)
         return false unless node ||= executor.node(message['nid'])
         return false unless includes?(hts, node['heat0'])
       end
@@ -180,4 +198,3 @@ module Flor
     end
   end
 end
-