flor 0.14.0 → 0.15.0

data/lib/flor/tools/shell_out.rb

@@ -0,0 +1,31 @@
+
+module Flor::Tools
+
+  class ShellOut
+
+    def initialize(unit)
+
+      @file = File.open('.log.txt', 'ab')
+      @file.sync = true
+
+      #@unit.conf['fls_file']
+      #@unit.conf['fls_file_mode']
+    end
+
+    def tty?
+
+      $stdout.tty?
+    end
+
+    def puts(s)
+
+      $stdout.puts(s)
+      @file.puts(s)
+    end
+
+    def method_missing(*args)
+p [ 'MISSING>>>', args ]
+    end
+  end
+end
+

data/lib/flor/unit.rb

@@ -7,7 +7,7 @@ require 'fugit'
 require 'flor'
 require 'flor/unit/hook'
 require 'flor/unit/hooker'
-require 'flor/unit/runner'
+require 'flor/unit/caller'
 require 'flor/unit/wlist'
 require 'flor/unit/logger'
 require 'flor/unit/journal'

data/lib/flor/unit/caller.rb

@@ -0,0 +1,177 @@
+
+module Flor
+
+  # The caller calls Ruby or other scripts.
+  #
+  class Caller
+
+    # NB: tasker configuration entries start with "cal_"
+
+    def initialize(unit)
+
+      @unit = unit
+    end
+
+    def shutdown
+    end
+
+    def call(service, conf, message)
+
+      return ruby_call(service, conf, message) \
+        if conf['class'] || conf['module']
+      return cmd_call(service, conf, message) \
+        if conf['cmd']
+
+      fail ArgumentError.new("don't know how to call item at #{conf['_path']}")
+
+    rescue => err
+
+      [ Flor.to_error(err) ]
+    end
+
+    protected
+
+    def conf
+
+      @unit ? @unit.conf : {}
+    end
+
+    def fjoin(root, path)
+
+      root == '.' ? path : File.join(root, path)
+    end
+
+    def ruby_call(service, conf, message)
+
+      root = File.dirname(conf['_path'] || '.')
+
+      Flor.h_fetch_a(conf, 'require').each { |pa|
+        fail ArgumentError.new('".." not allowed in paths') if pa =~ /\.\./
+        require(fjoin(root, pa)) }
+      Flor.h_fetch_a(conf, 'load').each { |pa|
+        fail ArgumentError.new('".." not allowed in paths') if pa =~ /\.\./
+        load(fjoin(root, pa)) }
+
+      k = Flor.const_lookup(conf['class'] || conf['module'])
+
+      o =
+        if k.class == Module
+          k
+        else
+          case k.instance_method(:initialize).arity
+          when 1 then k.new(service)
+          when 2 then k.new(service, conf)
+          when 3 then k.new(service, conf, message)
+          when -1 then k.new({
+            service: service, configuration: conf, message: message })
+          else k.new
+          end
+        end
+
+      p = message['point']
+      m = :on
+      m = "on_#{p}" if ! o.respond_to?(m)
+      m = p if ! o.respond_to?(m)
+      m = :cancel if m == 'detask' && ! o.respond_to?(m)
+
+      fail(
+        "#{k.class.to_s.downcase} #{k} doesn't respond to on, on_#{p} or #{p}"
+      ) if ! o.respond_to?(m)
+
+      r =
+        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 -1 then o.send(m, {
+          service: service, configuration: conf, message: message })
+        else o.send(m)
+        end
+
+      to_messages(r)
+    end
+
+    def cmd_call(service, conf, message)
+
+      h = conf.dup # shallow
+      h['m'] = message
+      h['f'] = message['payload']
+      h['v'] = message['vars']
+      h['tag'] = (message['tags'] || []).first
+
+      cmd = h['cmd']
+
+      m = encode(conf, message)
+      out, _ = spawn(cmd, m)
+      r = decode(conf, out)
+
+      to_messages(r)
+    end
+
+    def encode(context, message)
+
+      coder =
+        Flor.h_fetch(context, 'encoder', 'coder') ||
+        Flor.h_fetch(conf, 'cal_encoder', 'cal_coder') ||
+        '::JSON'
+
+      Flor.const_get(coder)
+        .dump(message)
+    end
+
+    def decode(context, data)
+
+      coder =
+        Flor.h_fetch(context, 'decoder', 'coder', 'encoder') ||
+        Flor.h_fetch(conf, 'cal_decoder', 'cal_coder', 'cal_encoder') ||
+        '::JSON'
+
+      Flor.const_get(coder)
+        .load(data)
+    end
+
+    def spawn(cmd, data)
+
+      i, o = IO.pipe # _ / stdout
+      f, e = IO.pipe # _ / stderr
+      r, w = IO.pipe # stdin / _
+
+      pid = Kernel.spawn(cmd, in: r, out: o, err: e)
+      w.write(data)
+      w.close
+      o.close
+      e.close
+      _, status = Process.wait2(pid)
+
+      fail SpawnError.new(status, i.read, f.read) if status.exitstatus != 0
+
+      [ i.read, status ]
+    end
+
+    class SpawnError < StandardError
+
+      attr_reader :status, :out, :err
+
+      def initialize(status, out, err)
+
+        @status = status
+        @out = out
+        @err = err
+
+        msg = err.strip.split("\n").last
+
+        super("(code: #{status.exitstatus}, pid: #{status.pid}) #{msg}")
+      end
+    end
+
+    def to_messages(o)
+
+      case o
+      when Hash then [ o ]
+      when Array then o
+      else []
+      end
+    end
+  end
+end
+

data/lib/flor/unit/executor.rb

@@ -141,6 +141,7 @@ module Flor
     def trigger(message)
 
       m = message['message']
+      m['cause'] = message['cause']
 
       m['nid'] = Flor.sub_nid(m['nid'], counter_next('subs')) \
         if m['point'] == 'execute'

data/lib/flor/unit/ganger.rb

@@ -1,6 +1,11 @@
 
 module Flor
 
+  # ganger | ˈɡaNGər | \ noun British \ the foreman of a gang of laborers.
+  #
+  # The ganger receives the tasks from the flor executor, decides what
+  # tasker will be invoked and hands it the task.
+  #
   class Ganger
 
     # NB: tasker configuration entries start with "gan_"
@@ -23,8 +28,10 @@ module Flor
 
       d = Flor.domain(exid)
 
-      #!! @unit.loader.tasker(d, name)
-      !! (@unit.loader.tasker(d, 'tasker') || @unit.loader.tasker(d, name))
+      !! (
+        @unit.loader.tasker(d, 'ganger') ||
+        @unit.loader.tasker(d, 'tasker') ||
+        @unit.loader.tasker(d, name))
     end
 
     def task(executor, message)
@@ -33,10 +40,10 @@ module Flor
       tname = message['tasker']
 
       tconf =
-        ( ! message['routed'] && @unit.loader.tasker(domain, 'tasker')) ||
-        @unit.loader.tasker(domain, tname)
-          #
-          # TODO `.tasker(domain, 'ganger')`
+        ( ! message['routed'] &&
+         (@unit.loader.tasker(domain, 'ganger', message) ||
+          @unit.loader.tasker(domain, 'tasker', message))) ||
+        @unit.loader.tasker(domain, tname, message)
 
       fail ArgumentError.new(
         "tasker #{tname.inspect} not found"
@@ -55,13 +62,7 @@ module Flor
 
       message['vars'] = gather_vars(executor, tconf, message)
 
-      r = @unit.runner.run(self, tconf, message)
-
-      if is_a_message_array?(r)
-        r
-      else
-        []
-      end
+      @unit.caller.call(self, tconf, message)
     end
 
     def return(message)
@@ -71,13 +72,6 @@ module Flor
 
     protected
 
-    def is_a_message_array?(o)
-
-      o.is_a?(Array) &&
-      o.first.is_a?(Hash) &&
-      o.first['point'].is_a?(String)
-    end
-
     def var_match(k, filter)
 
       filter.each { |f| return true if (f.is_a?(String) ? k == f : f.match(k)) }
@@ -108,7 +102,7 @@ module Flor
 
     def gather_vars(executor, tconf, message)
 
-      # try to return before calling executor.vars(nid) which my be costly...
+      # try to return before a potentially costly call to executor.vars(nid)
 
       return nil if (tconf.keys & %w[ include_vars exclude_vars ]).empty?
         # default behaviour, don't pass variables to taskers

data/lib/flor/unit/hook.rb

@@ -32,7 +32,7 @@ module Flor
 
     def notify(executor, message)
 
-      @unit.runner.run(executor, @h, message)
+      @unit.caller.call(executor, @h, message)
     end
 
   # Avoid the proc/cancel problem upstreams in ConfExecutor, by ignoring

data/lib/flor/unit/hooker.rb

@@ -40,9 +40,9 @@ module Flor
 
       args.each do |arg|
         case arg
-          when String then name = arg
-          when Hash then opts = arg
-          else hook = arg
+        when String then name = arg
+        when Hash then opts = arg
+        else hook = arg
         end
       end
 
@@ -56,7 +56,7 @@ module Flor
       (
         @hooks + executor.traps_and_hooks
       )
-        .inject([]) do |a, (_, opts, hook, block)|
+        .inject([]) { |a, (_, opts, hook, block)|
           # name of hook is piped into "_" oblivion
 
           a.concat(
@@ -68,8 +68,7 @@ module Flor
               executor.trigger_hook(hook, message)
             else
               executor.trigger_block(block, opts, message)
-            end)
-        end
+            end) }
     end
 
     protected
@@ -86,6 +85,12 @@ module Flor
       array ? Array(r) : r
     end
 
+    def includes?(arr, value)
+
+      Array(value)
+        .find { |v| arr.find { |e| e.is_a?(Regexp) ? e.match(v) : e == v } }
+    end
+
     def match?(executor, hook, opts, message)
 
       opts = hook.opts if hook.respond_to?(:opts) && opts.empty?
@@ -128,11 +133,18 @@ module Flor
 
       if ts = o(opts, :tag, :t, [])
         return false unless %w[ entered left ].include?(message['point'])
-        return false unless (message['tags'] & ts).any?
+        return false unless includes?(ts, message['tags'])
       end
 
       if ns = o(opts, :name, :n)
-        return false unless ns.include?(message['name'])
+        name = message['name']
+        return false \
+          unless ns.find { |n|
+            case n
+            when String then name == n
+            when Array then name.match(Flor.to_regex(n))
+            else false
+            end }
       end
 
       node = nil
@@ -148,12 +160,12 @@ module Flor
 
       if hps = o(opts, :heap, :hp, [])
         return false unless node ||= executor.node(message['nid'])
-        return false unless hps.include?(node['heap'])
+        return false unless includes?(hps, node['heap'])
       end
 
       if hts = o(opts, :heat, :ht, [])
         return false unless node ||= executor.node(message['nid'])
-        return false unless hts.include?(node['heat0'])
+        return false unless includes?(hts, node['heat0'])
       end
 
       true

data/lib/flor/unit/loader.rb

@@ -25,7 +25,7 @@ module Flor
         .collect { |pa| [ pa, expose_d(pa, {}) ] }
         .select { |pa, d| is_subdomain?(domain, d) }
         .sort_by { |pa, d| d.count('.') }
-        .inject({}) { |vars, (pa, d)| vars.merge!(interpret(pa)) }
+        .inject({}) { |vars, (pa, d)| vars.merge!(eval(pa, {})) }
     end
 
     #def procedures(path)
@@ -55,7 +55,7 @@ module Flor
       path ? [ Flor.relativize_path(path), File.read(path) ] : nil
     end
 
-    def tasker(domain, name=nil)
+    def tasker(domain, name, message={})
 
       # NB: do not relativize path, because Ruby load path != cwd,
       # stay absolute for `require` and `load`
@@ -73,23 +73,18 @@ module Flor
 
       return nil unless path
 
-      conf = interpret(path)
+      conf = eval(path, message)
 
       return conf if n == name
 
-      con = conf[name]
+      conf = conf[name]
 
-      return nil unless con
+      return nil unless conf
 
-      pa = conf['_path']
+      (conf.is_a?(Array) ? conf : [ conf ])
+        .each { |h| h['_path'] = path }
 
-      if con.is_a?(Array)
-        con.each { |c| c['_path'] = pa }
-      else
-        con['_path'] = pa
-      end
-
-      con
+      conf
     end
 
     def hooks(domain, name=nil)
@@ -103,7 +98,7 @@ module Flor
         .select { |pa, d| is_subdomain?(domain, d) }
         .sort_by { |pa, d| d.count('.') }
         .collect { |pa, d|
-          interpret(pa).each_with_index { |h, i|
+          eval(pa, {}).each_with_index { |h, i|
             h['_path'] = pa + ":#{i}" } }
         .flatten(1)
     end
@@ -166,17 +161,22 @@ module Flor
       end
     end
 
-    def interpret(path)
+    def eval(path, context)
 
-      @mutex.synchronize do
+      src =
+        @mutex.synchronize do
 
-        mt1 = File.mtime(path)
-        val, mt0 = @cache[path]
-        #p [ :cached, path ] if val && mt1 == mt0
-        return val if val && mt1 == mt0
+          mt1 = File.mtime(path)
+          val, mt0 = @cache[path]
 
-        (@cache[path] = [ Flor::ConfExecutor.interpret(path), mt1 ]).first
-      end
+          if val && mt1 == mt0
+            val
+          else
+            (@cache[path] = [ Flor::ConfExecutor.load(path), mt1 ]).first
+          end
+        end
+
+      Flor::ConfExecutor.interpret(path, src, context)
     end
   end
 end