flor 0.9.2 → 0.9.3

data/lib/flor/punit/task.rb

@@ -51,7 +51,7 @@ class Flor::Pro::Task < Flor::Procedure
     # "clean up" assign: 'alan'
     # alan task: 'clean up'
 
-    #@executor.unit.tasker.has_tasker?(@executor.exid, key)
+    #@executor.unit.has_tasker?(@executor.exid, key)
 
     ni = att(nil)
     ta = att('by', 'for', 'assign')

data/lib/flor/unit.rb

@@ -38,7 +38,8 @@ require 'flor/unit/waiter'
 require 'flor/unit/scheduler'
 require 'flor/unit/models'
 require 'flor/unit/loader'
-require 'flor/unit/tasker'
+require 'flor/unit/ganger'
+require 'flor/unit/taskers'
 
 Flor.load_procedures('punit')
 

data/lib/flor/unit/executor.rb

@@ -28,6 +28,7 @@ module Flor
   class UnitExecutor < Flor::Executor
 
     attr_reader :exid
+    attr_reader :consumed
 
     def initialize(unit, exid)
 
@@ -66,7 +67,7 @@ module Flor
 
     def do_run
 
-      log_run_start if @unit.conf['log_run']
+      @unit.logger.log_run_start(self)
 
       counter_next('runs')
 
@@ -91,9 +92,6 @@ module Flor
         ms = process(m)
 
         @consumed << m
-          #
-        #@consumed << m unless ms.include?(m)
-          # TODO what if msg is held / pushed back?
 
         ims, oms = ms.partition { |m| m['exid'] == @exid }
           # qui est "in", qui est "out"?
@@ -112,7 +110,7 @@ module Flor
       @unit.storage.put_execution(@execution)
       @unit.storage.put_messages(@messages)
 
-      log_run_end(t0) if @unit.conf['log_run']
+      @unit.logger.log_run_end(self, t0)
 
       @consumed.clear
 
@@ -130,7 +128,6 @@ module Flor
         "#{self.class}#do_run()", exc, "(dumping to #{fn})")
 
       File.open(fn, 'wb') do |f|
-        #f.puts(JSON.pretty_generate({
         f.puts(Flor.to_pretty_s({
           execution: @execution,
           messages: @messages,
@@ -145,7 +142,8 @@ module Flor
         f.puts(on_do_run_exc(exc))
       end
 
-      puts on_do_run_exc(exc)
+      #puts on_do_run_exc(exc)
+        # dump notification above
     end
 
     def schedule(message)
@@ -165,60 +163,6 @@ module Flor
       [ m ]
     end
 
-    def log_run_start
-
-      _c = Flor.colours
-
-      s = StringIO.new
-
-      s << _c.dg
-      s << "    /--- #{_c.lg}run starts#{_c.dg} "
-      s << "#{self.class} #{self.object_id} #{@exid}"
-      s << "\n    |   "
-      s << { thread: Thread.current.object_id }.inspect
-      s << "\n    |   "
-      s << {
-        counters: @execution['counters'],
-        nodes: @execution['nodes'].size,
-        size: @execution['size']
-      }.inspect
-      s << _c.rs
-
-      puts s.string
-    end
-
-    def log_run_end(t0)
-
-      _c = Flor.colours
-
-      s = StringIO.new
-
-      s << _c.dg
-      s << "    |   run ends #{self.class} #{self.object_id} #{@exid}"
-      s << "\n    |   "; s << { took: Time.now - t0 }.inspect
-      s << "\n    |   "; s << {
-        thread: Thread.current.object_id,
-        consumed: @consumed.size,
-        traps: @traps.size,
-      }.inspect
-      s << "\n    |   "; s << {
-        #own_traps: @traps.reject { |t| t.texid == nil }.size, # FIXME
-        counters: @execution['counters'],
-        nodes: @execution['nodes'].size,
-        size: @execution['size']
-      }.inspect
-      if @unit.archive
-        s << "\n    |   "
-        s << {
-          archive_size: @unit.archive[@exid].size
-        }.inspect
-      end
-      s << "\n    \\--- ."
-      s << _c.rs
-
-      puts s.string
-    end
-
     def on_do_run_exc(e)
 
       io = StringIO.new

data/lib/flor/unit/{tasker.rb → ganger.rb}

@@ -24,9 +24,11 @@
 
 module Flor
 
-  class Tasker
+  class Ganger
 
-    # NB: tasker configuration entries start with "tsk_"
+    # NB: tasker configuration entries start with "gan_"
+
+    attr_reader :unit
 
     def initialize(unit)
 
@@ -51,6 +53,8 @@ module Flor
       tconf =
         ( ! message['routed'] && @unit.loader.tasker(domain, 'tasker')) ||
         @unit.loader.tasker(domain, tname)
+          #
+          # TODO `.tasker(domain, 'ganger')`
 
       fail ArgumentError.new(
         "tasker #{tname.inspect} not found"
@@ -115,13 +119,18 @@ module Flor
       k = tconf['on_task']['class']
       k = Flor.const_lookup(k)
 
-      tasker = k.new(self, tconf)
+      ka = k.instance_method(:initialize).arity
+
+      m =
+        message['point'] == 'detask' ?
+        :cancel :
+        :task
 
       r =
-        if message['point'] == 'detask'
-          tasker.cancel(message)
-        else
-          tasker.task(message)
+        if ka == 2
+          k.new(self, tconf).send(m, message)
+        else # ka == 3
+          k.new(self, tconf, message).send(m)
         end
 
       # if the tasker returns something intelligible, use it

data/lib/flor/unit/logger.rb

@@ -32,17 +32,7 @@ module Flor
 
       @unit = unit
 
-      @dir = @unit.conf['log_dir'] || 'tmp'
-      @dir = '.' unless @dir.is_a?(String) && File.exist?(@dir)
-
-      @fname = nil
-      @file = nil
-
-      @mutex = Mutex.new
-
-      @unit.singleton_class.instance_eval do
-        define_method(:logger) { @hooker['logger'] }
-      end
+      @out = prepare_out
 
       @uni = @unit.identifier
     end
@@ -51,7 +41,8 @@ module Flor
 
     def shutdown
 
-      @file.close if @file
+      #@file.close if @file
+      @out.close
     end
 
     def debug(*m); log(:debug, *m); end
@@ -61,63 +52,55 @@ module Flor
 
     def log(level, *elts)
 
-      return if [ nil, 'null', false ].include?(@dir)
-
       n = Time.now.utc
       stp = Flor.tstamp(n)
 
-      out =
-        case @dir
-          when 'stdout' then $stdout
-          when 'stderr' then $stderr
-          else prepare_file(n)
-        end
-
       lvl = level.to_s.upcase
       txt = elts.collect(&:to_s).join(' ')
       err = elts.find { |e| e.is_a?(Exception) }
 
       line = "#{stp} #{@uni} #{lvl} #{txt}"
 
-      @mutex.synchronize do
-        if err
-          sts = ' ' * stp.length
-          lvs = ' ' * (@uni.length + 1 + lvl.length)
-          dig = lvl[0, 1] + Digest::MD5.hexdigest(line)[0, 4]
-          out.puts("#{stp} #{@uni} #{lvl} #{dig} #{txt}")
-          err.backtrace.each { |lin| out.puts("#{sts} #{lvs} #{dig} #{lin}") }
-        else
-          out.puts(line)
-        end
+      if err
+        sts = ' ' * stp.length
+        lvs = ' ' * (@uni.length + 1 + lvl.length)
+        dig = lvl[0, 1] + Digest::MD5.hexdigest(line)[0, 4]
+        @out.puts("#{stp} #{@uni} #{lvl} #{dig} #{txt}")
+        err.backtrace.each { |lin| @out.puts("  #{dig} #{@uni} #{lin}") }
+      else
+        @out.puts(line)
       end
     end
 
     def notify(executor, msg)
 
+# TODO log to outfile
       if msg['rewritten'] && @unit.conf['log_tree_rw']
 
         Flor.print_compact_tree(
           msg['rewritten'], msg['nid'],
-          ind: 6, title: "rewrote #{msg['exid']} #{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)
+          close: true,
+          out: @out)
       end
 
       if @unit.conf['log_msg']
 
-        Flor.log_message(executor, msg)
+        Flor.log_message(executor, msg, out: @out)
       end
 
-      []
+      [] # we're only logging, do not queue further messages
     end
 
     def db_log(level, msg)
 
       return unless @unit.conf['log_sto']
 
-      _c = Flor.colours
+      _c = Flor.colours(out: @out)
 
       #m = msg.match(/ (INSERT|UPDATE) .+ (0?[xX]'?[a-fA-F0-9]+'?)/)
       #msg = msg.sub(m[2], "#{m[2][0, 14]}(...len#{m[2].length})") if m
@@ -126,29 +109,90 @@ module Flor
         #
       msg = summarize_blob(msg)
 
-      puts "#{_c.blg}sto#{_c.rs} t#{Thread.current.object_id} #{level.upcase} #{msg}"
+      @out.puts "#{_c.blg}sto#{_c.rs} t#{Thread.current.object_id} #{level.upcase} #{msg}"
     end
 
-    protected
+    def log_run_start(executor)
 
-    def prepare_file(t)
+      return unless @unit.conf['log_run']
 
-      @mutex.synchronize do
+      execution = executor.execution
+      _c = Flor.colours(out: @out)
+      s = StringIO.new
 
-        fn = File.join(
-          @dir,
-          "#{@unit.conf['env']}_#{t.strftime('%Y-%m-%d')}.log")
+      s << _c.dg
+      s << "    /--- #{_c.lg}run starts#{_c.dg} "
+      s << "#{executor.class} #{executor.object_id} #{execution['exid']}"
+      s << "\n    |   "
+      s << { thread: Thread.current.object_id }.inspect
+      s << "\n    |   "
+      s << {
+        counters: execution['counters'],
+        nodes: execution['nodes'].size,
+        size: execution['size']
+      }.inspect
+      s << _c.rs
 
-        if fn != @fname
-          @file.close if @file
-          @file = nil
-          @fname = fn
-        end
+      @out.puts(s.string)
+    end
 
-        @file ||= File.open(@fname, 'ab')
+    def log_run_end(executor, t0)
+
+      return unless @unit.conf['log_run']
+
+      execution = executor.execution
+      _c = Flor.colours(out: @out)
+      s = StringIO.new
+
+      s << _c.dg
+      s << "    |   run ends #{self.class} #{self.object_id} #{@exid}"
+      s << "\n    |   "; s << { took: Time.now - t0 }.inspect
+      s << "\n    |   "; s << {
+        thread: Thread.current.object_id,
+        consumed: executor.consumed.count,
+        traps: executor.traps.count,
+      }.inspect
+      s << "\n    |   "; s << {
+        #own_traps: @traps.reject { |t| t.texid == nil }.size, # FIXME
+        counters: execution['counters'],
+        nodes: execution['nodes'].size,
+        size: execution['size']
+      }.inspect
+      if @unit.archive
+        s << "\n    |   "
+        s << {
+          archive_size: @unit.archive[@exid].size
+        }.inspect
       end
+      s << "\n    \\--- ."
+      s << _c.rs
+
+      @out.puts(s.string)
+    end
+
+    def log_err(executor, message, opts={})
+
+      return unless @unit.conf['log_err']
+
+      Flor.print_detail_msg(executor, message, opts.merge(out: @out))
+    end
+
+    def log_src(source, opts, log_opts={})
+
+      return unless @unit.conf['log_src']
+
+      Flor.print_src(source, opts, log_opts.merge(out: @out))
+    end
+
+    def log_tree(tree, nid='0', opts={})
+
+      return unless @unit.conf['log_tree']
+
+      Flor.print_tree(tree, nid, opts.merge(out: @out))
     end
 
+    protected
+
     BLOB_CHARS = (('a'..'f').to_a + ('A'..'F').to_a + ('0'..'9').to_a).freeze
 
     def summarize_blob(message)
@@ -176,6 +220,77 @@ 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
+    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 puts(s); @f.puts(s); end
+      def flush; @f.flush; end
+    end
+
+    class FileOut < Out
+
+      def initialize(unit, dir)
+
+        super(unit)
+        @dir = dir
+
+        @mutex = Mutex.new
+        @file = nil
+        @fname = nil
+      end
+
+      def flush; @mutex.synchronize { @file.flush if @file }; end
+      def close; @mutex.synchronize { @file.close if @file }; end
+
+      def puts(s)
+        @mutex.synchronize { prepare_file.puts(s) }
+      end # TODO tstamp!
+
+      protected
+
+      def prepare_file
+
+        fn = File.join(
+          @dir, "#{@unit.env}_#{Time.now.strftime('%Y-%m-%d')}.log")
+
+        if fn != @fname
+          @file.close if @file
+          @file = nil
+          @fname = fn
+        end
+
+        @file ||= File.open(@fname, 'ab')
+      end
+    end
   end
 end