flor 0.14.0 → 0.15.0

data/lib/flor/unit/logger.rb

@@ -1,45 +1,67 @@
 
 module Flor
 
-  # TODO I need levels, ::Logger has them
-  # TODO I need log rotation, ::Logger has then
-  # TODO I need line heads, ::Logger has them (and @progname)
   # TODO ::Logger has a formatting callback
-  # TODO I need simply @out.puts...
+
+  # No log rotation,
+  # just dump to stdout (or stderr), see https://12factor.net/logs
 
   class Logger
 
     # NB: logger configuration entries start with "log_"
 
+    LEVELS_I = %w[ DEBUG INFO WARN ERROR FATAL UNKNOWN ]
+
     def initialize(unit)
 
       @unit = unit
       @unit.hooker.add('logger', self)
 
-      @out = prepare_out
+      @out = Flor::Logger::Out.prepare(@unit)
 
       @uni = @unit.identifier
+
+      self.level = @unit.conf['log_level'] || 1
     end
 
     def opts; { consumed: true }; end
 
     def shutdown
 
-      #@file.close if @file
       @out.close
     end
 
+    attr_reader :level
+
+    def level=(i)
+
+      original = i
+      i = LEVELS_I.index(i.to_s.upcase) unless i.is_a?(Integer)
+
+      fail ArgumentError.new(
+        "'log_level' must be between 0 (DEBUG) and 4 (FATAL). " +
+        "#{original.inspect} not acceptable"
+      ) unless i.is_a?(Integer) && i > -1 && i < 6
+
+      @level = i
+    end
+
     def debug(*m); log(:debug, *m); end
-    def error(*m); log(:error, *m); end
     def info(*m); log(:info, *m); end
     def warn(*m); log(:warn, *m); end
+    def error(*m); log(:error, *m); end
+    def fatal(*m); log(:fatal, *m); end
+    def unknown(*m); log(:unknown, *m); end
 
     def log(level, *elts)
 
+      lvl = level.to_s.upcase
+      lvi = LEVELS_I.index(lvl)
+      return if lvi < @level
+
       n = Time.now.utc
       stp = Flor.tstamp(n)
 
-      lvl = level.to_s.upcase
       txt = elts.collect(&:to_s).join(' ')
       err = elts.find { |e| e.is_a?(Exception) }
 
@@ -59,21 +81,20 @@ module Flor
 
       if msg['rewritten'] && @unit.conf['log_tree_rw']
 
-        Flor.print_compact_tree(
-          msg['rewritten'], msg['nid'],
-          ind: 6, title: "rewrote #{msg['exid']} #{msg['nid']}",
-          out: @out)
-        Flor.print_compact_tree(
-          msg['tree'], msg['nid'],
-          ind: 6, title: "into #{msg['exid']} #{msg['nid']}",
-          close: true,
-          out: @out)
+        @out <<
+          Flor.to_compact_tree_s(
+            msg['rewritten'], msg['nid'],
+            ind: 6, title: "rewrote #{msg['exid']} #{msg['nid']}")
+        @out << "\n" <<
+          Flor.to_compact_tree_s(
+            msg['tree'], msg['nid'],
+            ind: 6, title: "into #{msg['exid']} #{msg['nid']}",
+            close: true)
       end
 
-      if @unit.conf['log_msg']
-
-        Flor.log_message(executor, msg, out: @out)
-      end
+      @out.puts(
+        Flor.message_to_one_line_s(executor, msg, out: @out)
+      ) if @unit.conf['log_msg'] && msg['point'] != 'end'
 
       [] # we're only logging, do not queue further messages
     end
@@ -160,21 +181,21 @@ module Flor
 
       return unless @unit.conf['log_err']
 
-      Flor.print_detail_msg(executor, message, opts.merge(out: @out))
+      @out.puts(Flor.msg_to_detail_s(executor, message, opts.merge(flag: true)))
     end
 
     def log_src(source, opts, log_opts={})
 
       return unless @unit.conf['log_src']
 
-      Flor.print_src(source, opts, log_opts.merge(out: @out))
+      @out.puts(Flor.src_to_s(source, opts, log_opts))
     end
 
     def log_tree(tree, nid='0', opts={})
 
       return unless @unit.conf['log_tree']
 
-      Flor.print_tree(tree, nid, opts.merge(out: @out))
+      @out.puts(Flor.tree_to_s(tree, nid, opts.merge(out: @out)))
     end
 
     protected
@@ -207,37 +228,43 @@ module Flor
       message[0..k + 2 + 4] + "(...len#{i - (k + 2 + 1)})" + message[i..-1]
     end
 
-    def prepare_out
-
-      case (o = @unit.conf['log_out'] || 'stdout')
-        when false, 'null' then NoOut.new(@unit)
-        when true, 'stdout' then StdOut.new(@unit, $stdout)
-        when 'stderr' then StdOut.new(@unit, $stderr)
-        when /::/ then Flor.const_lookup(o).new(@unit)
-        else FileOut.new(@unit, o)
-      end
-    end
-
     class Out
+
       attr_reader :unit
+
       def initialize(unit); @unit = unit; end
       def log_colours?; @unit.conf.fetch('log_colours') { :no } == true; end
       def puts(s); end
       def flush; end
       def close; end
+
+      def self.prepare(unit)
+
+        case o = unit.conf.fetch('log_out', 1)
+        when false, 'null' then NoOut.new(unit)
+        when 1, true, 'stdout' then StdOut.new(unit, $stdout)
+        when 2, 'stderr' then StdOut.new(unit, $stderr)
+        when /::/ then Flor.const_lookup(o).new(unit)
+        else FileOut.new(unit, o)
+        end
+      end
     end
 
     class NoOut < Out
+
       def log_colours?; false; end
     end
 
     class StdOut < Out
+
       def initialize(unit, f); super(unit); @f = f; end
       def log_colours?
         lc = @unit.conf.fetch('log_colours') { :no }
         return lc if [ true, false ].include?(lc)
         @f.tty?
       end
+      def <<(s); @f << s; self; end
+      def print(s); @f.print(s); end
       def puts(s); @f.puts(s); end
       def flush; @f.flush; end
     end
@@ -274,7 +301,7 @@ module Flor
           @fname = fn
         end
 
-        @file ||= File.open(@fname, 'ab')
+        @file ||= File.open(@fname, 'ab:UTF-8')
       end
     end
   end

data/lib/flor/unit/models.rb

@@ -15,6 +15,11 @@ module Flor
     end
 
     def fetch_rows(sql); yield([]); end
+    #DJV 
+    # add mising methods from dummy adaptor
+    def typecast_value_boolean(opts={});true;end
+    def test_connection();true;end
+    #DJV
 
     DB = Sequel.connect(:adapter => Flor::DummySequelAdapter)
   end
@@ -47,7 +52,7 @@ module Flor
     end
   end
 
-  MODELS = [ :executions, :timers, :traces, :traps, :pointers ]
+  MODELS = [ :executions, :timers, :traces, :traps, :pointers, :messages ]
 
   dir = File.dirname(__FILE__)
   MODELS.each { |m| require File.join(dir, 'models', "#{m.to_s[0..-2]}.rb") }

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

@@ -4,6 +4,7 @@ module Flor
   class Execution < FlorModel
 
     def nodes; data['nodes']; end
+    def zero_node; nodes['0']; end
 
     def tags
 
@@ -19,6 +20,12 @@ module Flor
         .find { |n| n['failure'] && n['status'] != 'triggered-on-error' }
     end
 
+    def failed_nodes
+
+      nodes.values
+        .select { |n| n['failure'] && n['status'] != 'triggered-on-error' }
+    end
+
     def full_tree
 
       tree = nodes['0']['tree']
@@ -26,12 +33,16 @@ module Flor
       nodes.each do |nid, n|
         next if nid == '0'
         t = n['tree']; next unless t
-# TODO
       end
 
       tree
     end
 
+    def zero_variables
+
+      zero_node['vars']
+    end
+
     # class methods
 
     def self.by_status(s)

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

@@ -0,0 +1,7 @@
+
+module Flor
+
+  class Message < FlorModel
+  end
+end
+

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

@@ -10,21 +10,22 @@ module Flor
       opts[:consumed] = tconsumed
 
       opts[:point] = tpoints.split(',') if tpoints
-      opts[:heap] = theaps.split(',') if theaps
-      opts[:heat] = theats.split(',') if theats
+      opts[:tag] = do_split(ttags) if ttags
+      opts[:heap] = do_split(theaps) if theaps
+      opts[:heat] = do_split(theats) if theats
 
       opts[:name] = data['names']
 
       case trange
-        when 'execution'
-          opts[:exid] = exid
-        when 'subdomain'
-          opts[:subdomain] = Flor.domain(exid)
-        when 'domain'
-          opts[:domain] = Flor.domain(exid)
-        else #'subnid' # default
-          opts[:exid] = exid
-          opts[:subnid] = true
+      when 'execution'
+        opts[:exid] = exid
+      when 'subdomain'
+        opts[:subdomain] = Flor.domain(exid)
+      when 'domain'
+        opts[:domain] = Flor.domain(exid)
+      else #'subnid' # default
+        opts[:exid] = exid
+        opts[:subnid] = true
       end
 
       [ "trap#{id}", opts, self, nil ]
@@ -72,8 +73,13 @@ module Flor
       msg['trap_id'] = self.id
 
       if vs = msg['vars']
+
         k = vs.keys.find { |k| k != 'arguments' } || 'msg'
         vs[k] = message
+
+        if sig = message['point'] == 'signal' && message['name']
+          vs['sig'] = sig
+        end
       end
 
       if dat['pl'] == 'event'
@@ -81,22 +87,30 @@ module Flor
         msg['payload'] = Flor.dup(message['payload'])
       end
 
-      {
-        'point' => 'trigger',
+      { 'point' => 'trigger',
         'exid' => self.exid,
         'nid' => self.nid,
         'type' => 'trap',
         'trap' => to_hash,
         'trap_id' => self.id,
         'message' => msg,
-        'sm' => message['m'],
-        #'dbg' => xx
-      }#.tap { |m| pp m }
+        'sm' => message['m'] }
+            #'dbg' => xx
+          #.tap { |m| pp m['message'] }
+          #.tap { |m| pp m }
     end
 
     def to_hash
 
-      values.inject({}) { |h, (k, v)| h[k.to_s ] = v if k != :content; h }
+      values
+        .inject({}) { |h, (k, v)| h[k.to_s ] = v if k != :content; h }
+    end
+
+    def do_split(v)
+
+      v
+        .split(',')
+        .collect { |e| Flor.is_regex_string?(e) ? Flor.to_regex(e) : e }
     end
   end
 end

data/lib/flor/unit/scheduler.rb

@@ -5,7 +5,7 @@ module Flor
 
     attr_reader :conf, :env
 
-    attr_reader :hooker, :storage, :loader, :ganger, :runner
+    attr_reader :hooker, :storage, :loader, :ganger, :caller
     attr_reader :logger
 
     attr_reader :thread_status
@@ -27,8 +27,8 @@ module Flor
 
       @loader =
         (Flor::Conf.get_class(@conf, 'loader') || Flor::Loader).new(self)
-      @runner =
-        (Flor::Conf.get_class(@conf, 'runner') || Flor::Runner).new(self)
+      @caller =
+        (Flor::Conf.get_class(@conf, 'caller') || Flor::Caller).new(self)
       @hooker =
         (Flor::Conf.get_class(@conf, 'hooker') || Flor::Hooker).new(self)
       @storage =
@@ -257,6 +257,11 @@ module Flor
       queue(*prepare_message('cancel', [ exid, *as ]))
     end
 
+    def kill(exid, *as)
+
+      queue(*prepare_message('kill', [ exid, *as ]))
+    end
+
     def signal(name, h={})
 
       h[:payload] ||= {}
@@ -358,20 +363,18 @@ module Flor
       puts on_start_exc(ex)
     end
 
-    def prepare_on_receive_last(msg, opts)
+    def prepare_re_apply_messages(msg, opts)
 
       fail ArgumentError.new("missing 'payload' to re_apply") \
         unless msg['payload']
 
-      t = Flor::Lang.parse(opts[:tree], 're_apply', {})
+      t = Flor.parse(opts[:tree], 're_apply', {})
 
-      [
-        { 'point' => 'execute',
+      [ { 'point' => 'execute',
           'exid' => msg['exid'], 'nid' => msg['nid'],
           'from' => 'parent',
           'tree' => t,
-          'payload' => msg['payload'] }
-      ]
+          'payload' => msg['payload'] } ]
     end
 
     def prepare_message(point, args)
@@ -387,6 +390,11 @@ module Flor
       msg = { 'point' => point }
       opts = {}
 
+      if point == 'kill'
+        msg['point'] = 'cancel'
+        msg['flavour'] = 'kill'
+      end
+
       h.each do |k, v|
         if %w[ exid name nid payload on_receive_last ].include?(k)
           msg[k] = v
@@ -396,7 +404,7 @@ module Flor
       end
 
       if opts[:re_apply]
-        msg['on_receive_last'] = prepare_on_receive_last(msg, opts)
+        msg['on_receive_last'] = prepare_re_apply_messages(msg, opts)
       end
 
       fail ArgumentError.new('missing :exid key') \

data/lib/flor/unit/storage.rb

@@ -11,6 +11,8 @@ module Flor
     attr_reader :mutex
       # might be useful for some implementations
 
+    attr_accessor :archive
+
     def initialize(unit)
 
       @unit = unit
@@ -199,6 +201,7 @@ module Flor
           @db[:flor_messages]
             .select(:exid)
             .exclude(exid: _exids_being_processed)
+            .exclude(status: %w[ reserved consumed ])
             .limit(exe_count)
         @db[:flor_messages]
           .where(exid: _exids, status: 'created')
@@ -281,22 +284,14 @@ module Flor
       []
     end
 
-    def consume(messages)
+    POINTS_TO_ARCHIVE = %w[ terminated failed ceased ]
 
-      synchronize do
+    def consume(messages)
 
-        if @archive
-          @db[:flor_messages]
-            .where(
-              id: messages.collect { |m| m['mid'] }.compact)
-            .update(
-              status: 'consumed', mtime: Flor.tstamp, munit: @unit.identifier)
-        else
-          @db[:flor_messages]
-            .where(
-              id: messages.collect { |m| m['mid'] }.compact)
-            .delete
-        end
+      if @archive
+        consume_and_archive(messages)
+      else
+        consume_and_discard(messages)
       end
 
     rescue => err
@@ -422,6 +417,15 @@ module Flor
       id =
         synchronize do
 
+    #points = att_a('point', 'points', nil)  ### TODO
+    #tags = att_a('tag', 'tags', nil)        #
+    #heats = att_a('heat', 'heats', nil)     #
+    #heaps = att_a('heap', 'heaps', nil)     #
+    #names = att_a('name', 'names', nil)     #
+        #
+      #opts[:heap] = theaps.split(',') if theaps
+      #opts[:heat] = theats.split(',') if theats
+            #
           @db[:flor_traps]
             .insert(
               domain: dom,
@@ -430,10 +434,10 @@ module Flor
               onid: tra['onid'] || tra['nid'],
               bnid: tra['bnid'],
               trange: tra['range'],
-              tpoints: tra['points'],
-              ttags: tra['tags'],
-              theats: tra['heats'],
-              theaps: tra['heaps'],
+              tpoints: commaify(tra['points']),
+              ttags: commaify(tra['tags']),
+              theats: commaify(tra['heats']),
+              theaps: commaify(tra['heaps']),
               content: to_blob(tra),
               status: 'active',
               ctime: now,
@@ -509,6 +513,62 @@ module Flor
 
     protected
 
+    def _commaify(o)
+
+      if Flor.is_regex_tree?(o)
+        o[1].to_s
+      else #if o.is_a?(String)
+        o.split(/\s*,\s*/).join(',')
+      end
+    end
+
+    def commaify(o)
+
+      return nil unless o
+
+      o = [ o ] if Flor.is_regex_tree?(o)
+      o = [ o ] unless o.is_a?(Array)
+
+      o.collect { |e| _commaify(e) }.join(',')
+    end
+
+    def consume_and_archive(messages)
+
+      transync do
+
+        n = Flor.tstamp
+        u = @unit.identifier
+
+        @db[:flor_messages]
+          .where(
+            id: messages.collect { |m| m['mid'] }.compact)
+          .update(
+            status: 'consumed', mtime: n, munit: u)
+
+        @db[:flor_messages]
+          .import(
+            [ :domain, :exid, :point, :content,
+              :status, :ctime, :mtime, :cunit, :munit ],
+            messages
+              .select { |m|
+                ! m['mid'] && POINTS_TO_ARCHIVE.include?(m['point']) }
+              .map { |m|
+                [ Flor.domain(m['exid']), m['exid'], m['point'], to_blob(m),
+                  'consumed', n, n, u, u ] })
+      end
+    end
+
+    def consume_and_discard(messages)
+
+      synchronize do
+
+        @db[:flor_messages]
+          .where(
+            id: messages.collect { |m| m['mid'] }.compact)
+          .delete
+      end
+    end
+
     def load_timers
 
       now = Flor.tstamp
@@ -664,11 +724,11 @@ module Flor
 
       f =
         case type
-          when 'cron' then Fugit.parse_cron(string) || Fugit.parse_nat(string)
-          when 'at' then Fugit.parse_at(string)
-          when 'in' then Fugit.parse_duration(string)
-          #when 'every' then Fugit.parse_duration(string)
-          else Fugit.parse(string)
+        when 'cron' then Fugit.parse_cron(string) || Fugit.parse_nat(string)
+        when 'at' then Fugit.parse_at(string)
+        when 'in' then Fugit.parse_duration(string)
+        #when 'every' then Fugit.parse_duration(string)
+        else Fugit.parse(string)
         end
 
       nt = f.is_a?(Time) ? f : f.next_time(from || Time.now) # local...