flor 0.0.1 → 0.9.0

data/lib/flor/unit/hooker.rb

@@ -0,0 +1,186 @@
+#--
+# Copyright (c) 2015-2017, John Mettraux, jmettraux+flor@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+module Flor
+
+  class Hooker
+
+    # NB: logger configuration entries start with "hok_"
+
+    def initialize(unit)
+
+      @unit = unit
+
+      @hooks = []
+    end
+
+    def shutdown
+
+      @hooks.each do |n, o, hook, b|
+
+        hook.shutdown if hook.respond_to?(:shutdown)
+      end
+    end
+
+    def [](name)
+
+      h = @hooks.find { |n, o, h, b| n == name }
+
+      h ? h[2] || h[3] : nil
+    end
+
+    def add(*args, &block)
+
+      name = nil
+      hook = nil
+      opts = {}
+
+      args.each do |arg|
+        case arg
+          when String then name = arg
+          when Hash then opts = arg
+          else hook = arg
+        end
+      end
+
+      hook = hook.new(@unit) if hook.is_a?(Class)
+
+      @hooks << [ name, opts, hook, block ]
+    end
+
+    def notify(executor, message)
+
+      (@hooks + executor.traps.collect(&:to_hook))
+        .inject([]) do |a, (_, opts, hook, block)|
+          # name of hook is piped into "_" oblivion
+
+          a.concat(
+            if ! match?(executor, hook, opts, message)
+              []
+            elsif hook.is_a?(Flor::Trap)
+              executor.trigger_trap(hook, message)
+            elsif hook
+              executor.trigger_hook(hook, message)
+            else # if block
+              r =
+                if block.arity == 1
+                  block.call(message)
+                elsif block.arity == 2
+                  block.call(message, opts)
+                else
+                  block.call(executor, message, opts)
+                end
+              r.is_a?(Array) && r.all? { |e| e.is_a?(Hash) } ? r : []
+                # be lenient with block hooks, help them return an array
+            end)
+        end
+    end
+
+    protected
+
+    def o(opts, *keys)
+
+      array = false
+      array = keys.pop if keys.last == []
+
+      r = nil
+      keys.each { |k| break r = opts[k] if opts.has_key?(k) }
+
+      return nil if r == nil
+      array ? Array(r) : r
+    end
+
+    def match?(executor, hook, opts, message)
+
+#p opts if hook.is_a?(Flor::Trap)
+      opts = hook.opts if hook.respond_to?(:opts) && opts.empty?
+
+      c = o(opts, :consumed, :c)
+      return false if c == true && ! message['consumed']
+      return false if c == false && message['consumed']
+
+      if hook.is_a?(Flor::Trap)
+        return false if message['point'] == 'trigger'
+        return false if hook.within_itself?(executor, message)
+      end
+
+#p :xxx if hook.is_a?(Flor::Trap)
+      ps = o(opts, :point, :p, [])
+      return false if ps && ! ps.include?(message['point'])
+
+      if exi = o(opts, :exid)
+        return false \
+          unless message['exid'] == exi
+      end
+
+      dm = Flor.domain(message['exid'])
+
+      if dm && ds = o(opts, :domain, :d, [])
+        return false \
+          unless ds.find { |d| d.is_a?(Regexp) ? (!! d.match(dm)) : (d == dm) }
+      end
+
+      if dm && sds = o(opts, :subdomain, :sd, [])
+        return false \
+          unless sds.find do |sd|
+            dm[0, sd.length] == sd
+          end
+      end
+
+      if ts = o(opts, :tag, :t, [])
+        return false unless %w[ entered left ].include?(message['point'])
+        return false unless (message['tags'] & ts).any?
+      end
+
+      if ns = o(opts, :name, :n)
+        return false unless ns.include?(message['name'])
+      end
+
+      node = nil
+
+      if hook.is_a?(Flor::Trap) && o(opts, :subnid)
+        if node = executor.node(message['nid'], true)
+          return false unless node.descendant_of?(hook.nid, true)
+          node = node.h
+        else
+          return false if hook.nid != '0'
+        end
+      end
+
+      if hps = o(opts, :heap, :hp, [])
+        return false unless node ||= executor.node(message['nid'])
+        return false unless hps.include?(node['heap'])
+      end
+#p :yyy if hook.is_a?(Flor::Trap)
+
+      if hts = o(opts, :heat, :ht, [])
+        return false unless node ||= executor.node(message['nid'])
+        return false unless hts.include?(node['heat0'])
+      end
+
+      true
+    end
+  end
+end
+

data/lib/flor/unit/journal.rb

@@ -0,0 +1,52 @@
+#--
+# Copyright (c) 2015-2017, John Mettraux, jmettraux+flor@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+module Flor
+
+  class Journal
+
+    attr_reader :messages
+
+    def initialize(unit)
+
+      unit.singleton_class.instance_eval do
+        define_method(:journal) do
+          @hooker['journal'].messages
+        end
+      end
+
+      @messages = []
+    end
+
+    def opts; { consumed: true }; end
+
+    def notify(executor, message)
+
+      @messages << Flor.dup(message)
+
+      [] # no new messages
+    end
+  end
+end
+

data/lib/flor/unit/loader.rb

@@ -0,0 +1,181 @@
+#--
+# Copyright (c) 2015-2017, John Mettraux, jmettraux+flor@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+module Flor
+
+  class Loader
+
+    # NB: tasker configuration entries start with "loa_"
+
+    def initialize(unit)
+
+      @unit = unit
+
+      @cache = {}
+      @mutex = Mutex.new
+    end
+
+    def shutdown
+    end
+
+    def variables(domain)
+
+      Dir[File.join(root, '**/*.json')]
+        .select { |f| f.index('/etc/variables/') }
+        .sort # just to be sure
+        .sort_by(&:length)
+        .select { |f| path_matches?(domain, f) }
+        .inject({}) { |vars, f| vars.merge!(interpret(f)) }
+    end
+
+    #def procedures(path)
+    #
+    #  # TODO
+    #  # TODO work with Flor.load_procedures
+    #end
+
+    def library(domain, name=nil)
+
+      domain, name = split_dn(domain, name)
+
+      path =
+        (Dir[File.join(root, '**/*.{flo,flor}')])
+          .sort
+          .sort_by(&:length)
+          .select { |f| f.index('/lib/') }
+          .select { |f| path_name_matches?(domain, name, f) }
+          .first
+
+      path ? File.read(path) : nil
+    end
+
+#    class FlowEnv
+#
+#      attr_accessor :path, :domain, :flow_name, :source, :variables, :payload
+#      alias :flow :flow_name
+#
+#      def initialize(loader, path)
+#
+#        @path = path
+#
+#        es = path.split('.')
+#        @domain, @flow_name = [ es[0..-2].join('.'), es[-1] ]
+#
+#        @source = loader.library(@domain, @flow_name)
+#        @variables = loader.variables(@domain)
+#        #@payload = ... # TODO at some point, if necessary...
+#
+#        fail ArgumentError.new(
+#          "could not find flow at #{@path.inspect}"
+#        ) unless @source
+#      end
+#
+#      def to_a
+#
+#        [ path, domain, flow, source, variables, payload ]
+#      end
+#    end
+#
+#    def flow_environment(path)
+#
+#      FlowEnv.new(self, path)
+#    end
+
+    def tasker(domain, name=nil)
+
+      domain, name = split_dn(domain, name)
+
+      path = Dir[File.join(root, '**/*.json')]
+        .select { |f| f.index('/lib/taskers/') }
+        .sort # just to be sure
+        .sort_by(&:length)
+        .select { |f| path_name_matches?(domain, name, f) }
+        .last
+
+      path ? interpret(path) : nil
+    end
+
+    protected
+
+    def split_dn(domain, name)
+
+      if name
+        [ domain, name ]
+      else
+        elts = domain.split('.')
+        [ elts[0..-2].join('.'), elts[-1] ]
+      end
+    end
+
+    def root
+
+      if lp = @unit.conf['lod_path']
+        File.absolute_path(lp)
+      else
+        File.dirname(File.absolute_path(@unit.conf['_path'] + '/..'))
+      end
+    end
+
+    def path_matches?(domain, f)
+
+      f = f[root.length..-1]
+      f = f[5..-1] if f[0, 5] == '/usr/'
+
+      f = f
+        .sub(/\/etc\/variables\//, '/')
+        .sub(/\/lib\/(flows|taskers)\//, '/')
+        .sub(/\/\z/, '')
+        .sub(/\/(flo|flor|dot)\.json\z/, '')
+        .sub(/\.(flo|flor|json)\z/, '')
+        .sub(/\A\//, '')
+        .gsub(/\//, '.')
+
+#p [ :pm, domain[0, f.length], f, '=>', domain[0, f.length] == f ]
+      domain[0, f.length] == f
+    end
+
+    def path_name_matches?(domain, name, f)
+
+      f = f.sub(/\/(flo|flor|dot)\.json\z/, '.json')
+
+      return false if File.basename(f).split('.').first != name
+
+      path_matches?(domain, File.dirname(f) + '/')
+    end
+
+    def interpret(path)
+
+      @mutex.synchronize do
+
+        mt1 = File.mtime(path)
+        val, mt0 = @cache[path]
+        #p [ :cached, path ] if val && mt1 == mt0
+        return val if val && mt1 == mt0
+
+        (@cache[path] = [ Flor::ConfExecutor.interpret(path), mt1 ]).first
+      end
+    end
+  end
+end
+

data/lib/flor/unit/logger.rb

@@ -0,0 +1,181 @@
+#--
+# Copyright (c) 2015-2017, John Mettraux, jmettraux+flor@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+module Flor
+
+  class Logger
+
+    # NB: logger configuration entries start with "log_"
+
+    def initialize(unit)
+
+      @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
+
+      @uni = @unit.identifier
+    end
+
+    def opts; { consumed: true }; end
+
+    def shutdown
+
+      @file.close if @file
+    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 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
+      end
+    end
+
+    def notify(executor, msg)
+
+      if msg['rewritten'] && @unit.conf['log_tree_rw']
+
+        Flor.print_compact_tree(
+          msg['rewritten'], msg['nid'],
+          ind: 6, title: "rewrote #{msg['exid']} #{msg['nid']}")
+        Flor.print_compact_tree(
+          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)
+      end
+
+      []
+    end
+
+    def db_log(level, msg)
+
+      return unless @unit.conf['log_sto']
+
+      _c = Flor.colours
+
+      #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
+        #
+        # with a fat blob, may lead to memory problems very quickly, hence:
+        #
+      msg = summarize_blob(msg)
+
+      puts "#{_c.blg}sto#{_c.rs} t#{Thread.current.object_id} #{level.upcase} #{msg}"
+    end
+
+    protected
+
+    def prepare_file(t)
+
+      @mutex.synchronize do
+
+        fn = File.join(
+          @dir,
+          "#{@unit.conf['env']}_#{t.strftime('%Y-%m-%d')}.log")
+
+        if fn != @fname
+          @file.close if @file
+          @file = nil
+          @fname = fn
+        end
+
+        @file ||= File.open(@fname, 'ab')
+      end
+    end
+
+    BLOB_CHARS = (('a'..'f').to_a + ('A'..'F').to_a + ('0'..'9').to_a).freeze
+
+    def summarize_blob(message)
+
+      #
+      # /!\ reminder: substitutes only one blob
+      #
+
+      i = message.index(' INSERT ') || message.index(' UPDATE ')
+      return message unless i
+
+      j = message.index(" x'") || message.index(" X'")
+      k = j || message.index(" 0x") || message.index(" 0X")
+      return message unless k
+
+      over = j ? [ "'" ] : [ ' ', nil ]
+
+      i = k + 3
+      loop do
+        c = message[i, 1]
+        break if over.include?(c)
+        return message unless BLOB_CHARS.index(c)
+        i = i + 1
+      end
+
+      message[0..k + 2 + 4] + "(...len#{i - (k + 2 + 1)})" + message[i..-1]
+    end
+  end
+end
+

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

@@ -0,0 +1,105 @@
+#--
+# Copyright (c) 2015-2017, John Mettraux, jmettraux+flor@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Flor
+
+  class Execution < FlorModel
+
+    def nodes; data['nodes']; end
+
+    def tags
+
+      data['nodes'].values.inject([]) do |a, n|
+        if ts = n['tags']; a.concat(ts); end
+        a
+      end
+    end
+
+    def failed?
+
+      !! nodes.values
+        .find { |n| n['failure'] && n['status'] != 'triggered-on-error' }
+    end
+
+    # class methods
+
+    def self.by_status(s)
+
+      self.where(status: s)
+    end
+
+    def self.terminated
+
+      by_status('terminated')
+    end
+
+    def self.by_tag(name)
+
+      exids = self.db[:flor_pointers]
+        .where(type: 'tag', name: name, value: nil)
+        .select(:exid)
+        .distinct
+
+      self.where(status: 'active', exid: exids)
+    end
+
+    def self.by_var(name, value=:no)
+
+      w = { type: 'var', name: name }
+
+      case value; when nil
+        w[:value] = nil
+      when :no
+        # no w[:value] "constraining"
+      else
+        w[:value] = value.to_s
+      end
+
+      exids = self.db[:flor_pointers]
+        .where(w)
+        .select(:exid)
+        .distinct
+
+      self.where(status: 'active', exid: exids)
+    end
+
+    def self.by_tasker(name, taskname=:no)
+
+      w = { type: 'tasker', name: name }
+      w[:value] = taskname if taskname != :no
+
+      exids = self.db[:flor_pointers]
+        .where(w)
+        .select(:exid)
+        .distinct
+
+      self.where(status: 'active', exid: exids)
+    end
+
+#    def self.by_task(name)
+#    end
+  end
+end
+