flor 0.0.1 → 0.9.0

data/lib/flor/core/texecutor.rb

@@ -0,0 +1,209 @@
+#--
+# 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 TransientExecutor < Executor
+
+    class TransientTasker
+
+      def has_tasker?(exid, tname); false; end
+    end
+
+    class TransientUnit
+
+      attr_accessor :conf, :opts
+      attr_reader :journal, :tasker, :loader
+      attr_accessor :archive
+
+      def initialize(conf)
+
+        @conf = conf
+        @opts = {}
+        @journal = []
+        @tasker = TransientTasker.new
+        @archive = nil
+      end
+
+      def notify(executor, o)
+
+        return [] if o['consumed']
+
+        Flor.log_message(executor, o) \
+          if @conf['log_msg']
+
+        @journal << o
+
+        []
+      end
+
+      def remove_node(exid, n)
+
+        (@archive[exid] ||= {})[n['nid']] = Flor.dup(n) if @archive
+      end
+    end
+
+    def initialize(conf={})
+
+      conf.merge!(Flor::Conf.read_env) unless conf['conf'] == true
+        # don't read FLOR_DEBUG if this executor is only meant to read the conf
+
+      super(
+        TransientUnit.new(conf),
+        [], # no traps
+        {
+          'exid' => Flor.generate_exid('eval', 'u0'),
+          'nodes' => {}, 'errors' => [], 'counters' => {},
+          #'ashes' => {},
+          'start' => Flor.tstamp
+        })
+    end
+
+    def journal; @unit.journal; end
+    def archive; @unit.archive[exid]; end
+
+    def launch(tree, opts={})
+
+      @unit.opts = opts
+      @unit.archive = {} if opts[:archive]
+
+      Flor.print_src(tree, opts) if conf['log_src']
+
+      messages = [ Flor.make_launch_msg(@execution['exid'], tree, opts) ]
+
+      Flor.print_tree(messages.first['tree']) if conf['log_tree']
+
+      walk(messages, opts)
+    end
+
+    def walk(messages, opts={})
+
+      loop do
+
+        message = messages.shift
+        return nil unless message
+
+        if message['point'] == 'terminated' && messages.any?
+          #
+          # try to handle 'terminated' last
+          #
+          messages << message
+          message = messages.shift
+        end
+
+        msgs = process(message)
+
+        messages.concat(msgs)
+
+        return messages if message_match?(message, opts[:until_after])
+        return messages if message_match?(messages, opts[:until])
+
+        return message \
+          if message['point'] == 'terminated'
+        return message \
+          if message['point'] == 'failed' && message['on_error'] == nil
+      end
+    end
+
+    def step(message)
+
+      process(message)
+    end
+
+    # Used in specs when testing multiple message arrival order on
+    # a "suite" of transient executors
+    #
+    def clone
+
+      c = TransientExecutor.allocate
+
+      c.instance_variable_set(:@unit, @unit)
+      c.instance_variable_set(:@traps, []) # not useful for a TransientEx clone
+      c.instance_variable_set(:@execution, Flor.dup(@execution))
+
+      c
+    end
+
+    protected
+
+    # TODO eventually merge with Waiter.parse_serie
+    #
+    def message_match?(msg_s, ountil)
+
+      return false unless ountil
+
+      ms = msg_s; ms = [ ms ] if ms.is_a?(Hash)
+
+      nid, point = ountil.split(' ')
+
+      ms.find { |m| m['nid'] == nid && m['point'] == point }
+    end
+  end
+
+  class ConfExecutor < TransientExecutor
+
+    def self.interpret(path)
+
+      s = path
+
+      s = File.read(s).strip unless s.match(/[\r\n]/)
+      s = "{\n#{s}\n}"
+
+      vs = Hash.new { |h, k| k }
+      class << vs
+        def has_key?(k); ! Flor::Procedure[k]; end
+      end
+
+      vs['root'] = determine_root(path)
+
+      vs['ruby_version'] = RUBY_VERSION
+      vs['ruby_platform'] = RUBY_PLATFORM
+
+      c = (ENV['FLOR_DEBUG'] || '').match(/conf/) ? false : true
+      r = (self.new('conf' => c)).launch(s, vars: vs)
+
+      unless r['point'] == 'terminated'
+        ae = ArgumentError.new("error while reading conf: #{r['error']['msg']}")
+        ae.set_backtrace(r['error']['trc'])
+        fail ae
+      end
+
+      h = Flor.dup(r['payload']['ret'])
+
+      h.merge!('_path' => path) unless path.match(/[\r\n]/)
+
+      h
+    end
+
+    def self.determine_root(path)
+
+      dir = File.absolute_path(File.dirname(path))
+      ps = dir.split(File::SEPARATOR)
+
+      ps.last == 'etc' ? File.absolute_path(File.join(dir, '..')) : dir
+    end
+  end
+end
+

data/lib/flor/core.rb

@@ -0,0 +1,93 @@
+#--
+# 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
+
+  def self.generate_exid(domain, unit)
+
+    @exid_counter ||= 0
+    @exid_mutex ||= Mutex.new
+
+    t = Time.now.utc
+
+    sus =
+      @exid_mutex.synchronize do
+
+        sus = t.sec * 100000000 + t.usec * 100 + @exid_counter
+
+        @exid_counter = @exid_counter + 1
+        @exid_counter = 0 if @exid_counter > 99
+
+        Munemo.to_s(sus)
+      end
+
+    t = t.strftime('%Y%m%d.%H%M')
+
+    "#{domain}-#{unit}-#{t}.#{sus}"
+  end
+
+  def self.make_launch_msg(exid, tree, opts)
+
+    t =
+      tree.is_a?(String) ?
+      Flor::Lang.parse(tree, opts[:fname], opts) :
+      tree
+
+    unless t
+      #h = opts.merge(prune: false, rewrite: false)
+      #p Flor::Lang.parse(tree, h[:fname], h)
+        # TODO re-parse and indicate what went wrong...
+      fail ArgumentError.new('flor parse failure')
+    end
+
+    pl = opts[:payload] || opts[:fields] || {}
+    vs = opts[:variables] || opts[:vars] || {}
+
+    msg =
+      { 'point' => 'execute',
+        'exid' => exid,
+        'nid' => '0',
+        'tree' => t,
+        'payload' => pl,
+        'vars' => vs }
+
+    msg['vdomain'] = opts[:vdomain] \
+      if opts.has_key?(:vdomain)
+
+    msg
+  end
+
+  def self.load_procedures(dir)
+
+    dirpath =
+      if dir.match(/\A[.\/]/)
+        File.join(dir, '*.rb')
+      else
+        File.join(File.dirname(__FILE__), dir, '*.rb')
+      end
+
+    Dir[dirpath].each { |path| require(path) }
+  end
+end
+

data/lib/flor/dollar.rb

@@ -0,0 +1,248 @@
+#--
+# 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 Dollar
+
+    module Parser include Raabro
+
+#static fabr_tree *_str(fabr_input *i)
+#{
+#  return fabr_rex("s", i,
+#    "("
+#      "\\\\\\)" "|"
+#      "[^\\$\\)]" "|"
+#      "\\$[^\\(]"
+#    ")+");
+#}
+      def istr(i)
+        rex(:str, i, %r{
+          ( \\\) | [^\$)] | \$[^(] )+
+        }x)
+      end
+
+#static fabr_tree *_outerstr(fabr_input *i)
+#{
+#  return fabr_rex("s", i,
+#    "("
+#      "[^\\$]" "|" // doesn't mind ")"
+#      "\\$[^\\(]"
+#    ")+");
+#}
+      def ostr(i)
+        rex(:str, i, %r{
+          ( [^\$] | \$(?!\() )+
+        }x)
+      end
+        #
+        # ( [^\$] | \$(?!\() )+
+        # one or more of (not a dollar or a dollar followed by sthing else
+        # than a parenthesis opening)
+
+      def pe(i); str(nil, i, ')'); end
+      def dois(i); alt(nil, i, :dollar, :istr); end
+      def span(i); rep(:span, i, :dois, 0); end
+      def dps(i); str(nil, i, '$('); end
+      def dollar(i); seq(:dollar, i, :dps, :span, :pe); end
+      def doos(i); alt(nil, i, :dollar, :ostr); end
+      def outer(i); rep(:span, i, :doos, 0); end
+
+      def rewrite_str(t)
+        t.string
+      end
+      def rewrite_dollar(t)
+        cn = rewrite(t.children[1])
+        c = cn.first
+        if cn.size == 1 && c.is_a?(String)
+          [ :dol, c ]
+        else
+          [ :dol, cn ]
+        end
+      end
+      def rewrite_span(t)
+        t.children.collect { |c| rewrite(c) }
+      end
+    end
+
+    module PipeParser include Raabro
+
+      def elt(i); rex(:elt, i, /[^|]+/); end
+      def pipe(i); rex(:pipe, i, /\|\|?/); end
+      def elts(i); jseq(:elts, i, :elt, :pipe); end
+
+      def rewrite_elt(t); t.string; end
+      def rewrite_pipe(t); t.string == '|' ? :pipe : :dpipe; end
+      def rewrite_elts(t); t.children.collect { |e| rewrite(e) }; end
+    end
+
+    #def lookup(s)
+    #  # ...
+    #end
+      #
+      # the signature
+
+    # Called when joining multiple results in a string. Easily overwritable.
+    #
+    def stringify(v)
+
+      case v
+        when Array, Hash then JSON.dump(v)
+        else v.to_s
+      end
+    end
+
+    def quote(s, force)
+
+      return s if force == false && s[0, 1] == '"' && s[-1, 1] == '"'
+
+      JSON.dump([ s ])[1..-2]
+    end
+
+    def match(rex, s)
+
+      s.match(rex) ? s : false
+    end
+
+    def substitute(pat, rpl, gix, s)
+
+      ops =
+        (gix.index('i') ? Regexp::IGNORECASE : 0) |
+        (gix.index('x') ? Regexp::EXTENDED : 0)
+
+      rex = Regexp.new(pat, ops)
+
+      gix.index('g') ? s.gsub(rex, rpl) : s.sub(rex, rpl)
+    end
+
+    def lfilter(s, cmp, len)
+
+      l = s.length
+
+      case cmp
+        when '>' then l > len
+        when '>=' then l >= len
+        when '<' then l < len
+        when '<=' then l <= len
+        when '=', '==' then l == len
+        when '!=', '<>' then l != len
+        else false
+      end
+    end
+
+    def to_json(o)
+
+      case o
+        when Array, Hash then JSON.dump(o)
+        else JSON.dump([ o ])[1..-2]
+      end
+    end
+
+    def call(fun, o)
+
+      # NB: yes, $1..$9 are thread-safe (and local, not global)
+
+      case fun
+
+        when 'u' then o.to_s.upcase
+        when 'd' then o.to_s.downcase
+        when 'r' then o.reverse
+        when 'c' then o.to_s.capitalize.gsub(/\s[a-z]/) { |c| c.upcase }
+        when 'q' then quote(o, false)
+        when 'Q' then quote(o, true)
+
+        when 'json' then to_json(o)
+
+        when /^j(.+)/
+          o.respond_to?(:join) ? o.join($1) : o
+
+        when /\Am\/(.+)\/\z/
+          match($1, o.to_s)
+        when /\As\/(.*[^\\]\/)(.+)\/([gix]*)\z/
+          substitute($1.chop, $2, $3, o.to_s)
+
+        when /\A-?\d+\z/ then o.to_s[fun.to_i]
+        when /\A(-?\d+), *(-?\d+)\z/ then o.to_s[$1.to_i, $2.to_i]
+        when /\A(-?\d+)\.\.(-?\d+)\z/ then o.to_s[$1.to_i..$2.to_i]
+
+        when /\A\s*l\s*([><=!]=?|<>)\s*(\d+)\z/
+          lfilter(o.to_s, $1, $2.to_i) ? o.to_s : nil
+
+        else o
+      end
+    end
+
+    def unescape(s)
+
+      s.gsub(/\\[\$)]/) { |m| m[1, 1] }
+    end
+
+    def do_eval(t)
+
+      #return t if t.is_a?(String)
+      return unescape(t) if t.is_a?(String)
+
+      return t.collect { |c| stringify(do_eval(c)) }.join if t[0] != :dol
+
+      k = do_eval(t[1])
+      ks = PipeParser.parse(k)
+
+      result = nil
+      mode = :lookup # vs :call
+
+      ks.each do |k|
+
+        if k == :pipe then mode = :call; next; end
+        if k == :dpipe && result then break; end
+        if k == :dpipe then mode = :lookup; next; end
+
+        result =
+          if mode == :lookup
+            #k[0, 1] == "'" ? k[1..-1] : do_lookup(k)
+            k[0, 1] == "'" ? k[1..-1] : lookup(k)
+          else # :call
+            call(k, result)
+          end
+      end
+
+      result
+    end
+
+    def expand(s)
+
+      return s unless s.index('$')
+
+      #Raabro.pp(Parser.parse(s, debug: 2))
+      t = Parser.parse(s)
+
+      return s unless t
+
+      t = t.first if t.size == 1
+
+      do_eval(t)
+    end
+  end
+end
+

data/lib/flor/errors.rb

@@ -0,0 +1,36 @@
+#--
+# 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.
+#++
+
+
+class Flor::FlorError < StandardError
+
+  attr_reader :node
+
+  def initialize(message, node=nil)
+
+    super(message)
+    @node = node
+  end
+end
+