flor 0.18.0 → 1.0.0

data/lib/flor/unit/caller_jruby.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Flor
+
+  class Caller
+
+    def split_cmd(cmd)
+
+      #cmd.split(/ +/)
+        # too naive
+
+#Raabro.pp(Flor::Caller::CmdParser.parse(cmd, debug: 3), colours: true)
+      Flor::Caller::CmdParser.parse(cmd)
+    end
+
+    class ProcessStatus
+
+      attr_reader :process, :exitstatus
+
+      def initialize(process, exitstatus)
+
+        @process = process
+        @exitstatus = exitstatus
+      end
+
+      def pid; @process.pid; end
+    end
+
+    def spawn(conf, data)
+
+      t0 = Time.now
+
+      cmd = conf['cmd']
+      henv, *acmd = split_cmd(cmd)
+
+      to = Fugit.parse(conf['timeout'] || '14s')
+      to = to.is_a?(Fugit::Duration) ? to.to_sec : 14
+      to = 0 if to < 0 # no timeout
+
+      builder = java.lang.ProcessBuilder.new(*acmd)
+      henv.each { |k, v| builder.environment.put(k, v) }
+
+      process = builder.start
+      pid = process.pid
+
+      o = process.outputStream.to_io
+      i = process.inputStream.to_io
+      f = process.errorStream.to_io
+
+      o.write(data)
+      o.close
+
+      ex = timeout(to) { process.waitFor }
+
+      status = ProcessStatus.new(process, ex)
+
+      fail SpawnNonZeroExitError.new(conf, { to: to, t0: t0 }, status, i, f) \
+        if status.exitstatus != 0
+
+      [ i.read, status ]
+
+    rescue => err
+
+      Process.detach(pid) \
+        if pid
+      (Process.kill(9, pid) rescue nil) \
+        unless Flor.no?(conf['on_error_kill'])
+
+      raise err if err.is_a?(SpawnError)
+      raise WrappedSpawnError.new(conf, { to: to, t0: t0, pid: pid }, err)
+
+    ensure
+
+      [ i, o, f ].each { |x| x.close rescue nil }
+
+    end
+
+    module CmdParser include Raabro
+
+      # parsing
+
+      def separator(i); rex(nil, i, /[ 	]+/); end
+
+      def dqstring(i); rex(:string, i, /"(\\"|[^"])*"/); end
+      def sqstring(i); rex(:string, i, /'(\\'|[^'])*'/); end
+
+      def word(i); rex(:word, i, /[^ 	"']+/); end
+      def item(i); alt(nil, i, :word, :sqstring, :dqstring); end
+      def cmd(i); jseq(:cmd, i, :item, :separator); end
+
+      def equal(i); rex(nil, i, /[ 	]*=[ 	]*/); end
+      def vval(i); alt(:vval, i, :word, :sqstring, :dqstring); end
+      def vkey(i); rex(:vkey, i, /[a-zA-Z_][a-zA-Z_0-9]*/); end
+      def var(i); seq(:var, i, :vkey, :equal, :vval, :separator); end
+
+      def cmdline(i); seq(:cmdline, i, :var, '*', :cmd) end
+
+      # rewriting
+
+      def rewrite_word(t); t.string; end
+
+      def rewrite_string(t)
+        s = t.string[1..-2]
+        s == 'sleep' ? t.string : s # ah, the awful thing :-(
+      end
+        #
+        # because of `ruby -e "sleep"` :-( is there another way?
+
+      def rewrite_cmd(t)
+
+        t.subgather(nil).collect { |tt| rewrite(tt) }
+      end
+
+      def rewrite_vars(ts)
+
+        ts.inject({}) { |h, t|
+          k = t.lookup(:vkey).string
+          v = t.lookup(:vval).string; v = v[1..-2] unless t.lookup(:word)
+          h[k] = v
+          h }
+      end
+
+      def rewrite_cmdline(t)
+
+#Raabro.pp(t, colours: true)
+        [ rewrite_vars(t.subgather(:var)),
+          *t.lookup(:cmd).subgather(nil).collect { |tt| rewrite(tt) } ]
+      end
+    end
+  end
+end
+

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
 

data/lib/flor/unit/ganger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 module Flor
 
@@ -66,11 +67,15 @@ module Flor
         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
@@ -92,17 +97,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)) }

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
-

data/lib/flor/unit/journal.rb

@@ -1,13 +1,24 @@
+# frozen_string_literal: true
 
 module Flor
 
+  # A Journal hook, receives only "consumed" messages and
+  # keeps a copy of all of them.
+  #
+  # Used in specs, do not uses as-is in production, since it simply
+  # grows in memory...
+  #
   class Journal
 
     attr_reader :messages
 
     def initialize(unit)
 
+      # Add a #journal method to the flor unit so that
+      # `unit.journal` yields the message list.
+      #
       unit.singleton_class.instance_eval do
+
         define_method(:journal) do
           @hooker['journal'].messages
         end
@@ -16,11 +27,23 @@ module Flor
       @messages = []
     end
 
+    # Tells the hooker that this hook is only interested in message that
+    # have been "consumed", remember, the hooker passes messages to
+    # hooks before consumption and after consumption. In this case only
+    # consumed messages are passed.
+    #
+    # Other hooks may declare they are only interested in messages
+    # belonging to a certain domain or having a certain tag.
+    # See spec/unit/unit_hooks_spec.rb for more filtering examples.
+    #
     def opts; { consumed: true }; end
 
+    # The method used by the hooker to give consumed messages to this journal
+    #
     def notify(executor, message)
 
       @messages << Flor.dup(message)
+        # stores a deep clone of each consumed message
 
       [] # no new messages
     end