flor 0.16.1 → 0.16.2

data/lib/flor/punit/graft.rb

@@ -64,8 +64,9 @@ class Flor::Pro::Graft < Flor::Procedure
 
     # graft subtree into parent node
 
-    parent_tree = lookup_tree(parent)
-    parent_tree[1][child_id] = tree
+    if parent_tree = lookup_tree(parent)
+      parent_tree[1][child_id] = tree
+    end
 
     # re-apply self with subtree
 

data/lib/flor/punit/m_ram.rb

@@ -0,0 +1,281 @@
+
+# Module extracted out of "concurrence", deals with receivers and mergers.
+#
+# Should it deal with remainder?
+#
+module Flor::Pro::ReceiveAndMerge
+
+  protected
+
+  def receive_from_branch
+
+    (@node['payloads'] ||= {})[from] = @message['payload']
+
+    apply_receiver
+  end
+
+  def apply_receiver
+
+    @node['receiver'] ||= determine_receiver
+
+    if @node['receiver'].is_a?(String)
+      apply_receiver_method
+    else
+      apply_receiver_function
+    end
+  end
+
+  def apply_receiver_method
+
+    ret = send('rm__' + @node['receiver'])
+    msg = { 'payload' => { 'ret' => ret } }
+
+    receive_from_receiver(msg)
+  end
+
+  def apply_receiver_function
+
+    (@node['on_receive_queue'] ||= []) << from
+
+    dequeue_receiver_function
+  end
+
+  def dequeue_receiver_function
+
+    if @node['on_receive_nids']
+      []
+    elsif f = (@node['on_receive_queue'] || []).shift
+      ms = apply(@node['receiver'], receiver_args(f), tree[2])
+      @node['on_receive_nids'] = [ ms.first['nid'], f ]
+      ms
+    else
+      []
+    end
+  end
+
+  def receiver_args(from)
+
+    rs = Flor.dup(@node['payloads'])
+
+    [ [ 'reply', rs[from] ],
+      [ 'from', from ],
+      [ 'replies', rs ],
+      [ 'branch_count', @node['branch_count'] ],
+      [ 'over', !! @node['over'] ] ]
+  end
+
+  def receive_from_receiver(msg=message)
+
+    ret = msg['payload']['ret']
+    over = @node['over']
+
+    if ret.is_a?(Hash) && ret.keys == %w[ done payload ]
+      over = over || ret['done']
+      from = @node['on_receive_nids'][1]
+      @node['payloads'][from] = ret['payload']
+    else
+      over = over || ret
+    end
+
+    @node['on_receive_nids'] = nil
+
+    just_over = over && ! @node['over']
+
+    @node['over'] ||= just_over
+
+    if just_over
+      apply_merger
+    elsif ! over
+      [] # wait for more branches
+    else
+      receive_from_merger(nil)
+    end +
+    dequeue_receiver_function
+  end
+
+  def apply_merger
+
+    if (m = determine_merger).is_a?(Hash)
+      apply_merger_method(m)
+    else
+      apply_merger_function(m)
+    end
+  end
+
+  def apply_merger_method(h)
+
+    o = h[:order] || h['order']
+    m = h[:merger] || h['merger']
+
+    payloads = send("mom__#{o}", h, Flor.dup(@node['payloads']))
+    payload = send("mmm__#{m}", h, payloads)
+    msg = { 'payload' => payload }
+
+    receive_from_merger(msg)
+  end
+
+  def apply_merger_function(func_tree)
+
+    @node['merging'] = true
+
+    apply(func_tree, merger_args, tree[2])
+  end
+
+  def merger_args
+
+    rs = Flor.dup(@node['payloads'])
+
+    [ [ 'rets', rs.inject({}) { |h, (k, v)| h[k] = v['ret']; h } ],
+      [ 'replies', rs ],
+      [ 'branch_count', @node['branch_count'] ] ]
+  end
+
+  def receive_from_merger(msg=message)
+
+    pl = msg ? msg['payload'] : {}
+    ret = pl['ret']
+
+    pl = ret['payload'] \
+      if ret.is_a?(Hash) && ret.keys == %w[ done payload ]
+
+    # TODO somehow, what if done is false, should we un-over the concurrence?
+
+    @node['merged_payload'] = pl \
+      if msg && ! @node.has_key?('merged_payload')
+
+    rem = determine_remainder
+
+    cancel_children(rem) + reply_to_parent(rem)
+  end
+
+  def rm__default_receive
+
+    @node['payloads'].size >= branch_count
+  end
+
+  def rm__expect_integer_receive
+
+    @node['payloads'].size >= att(:expect)
+  end
+
+  def determine_receiver
+
+    ex = att(:expect)
+
+    return 'expect_integer_receive' if ex && ex.is_a?(Integer) && ex > 0
+
+    att(:on_receive, :receiver) || 'default_receive'
+  end
+
+  # order:
+  # * first, last: first or last to reply
+  # * top/north/head, bottom/south/tail: position in concurrence, in collection
+  #
+  # merge:
+  # * deep
+  # * mix/plain
+  # * override
+  # * ignore
+  # * stack
+
+  STACK_REX = /\Astack(?::([-_a-zA-Z0-9]+))?\z/
+
+  TRANSLATORS = { STACK_REX => 'k', /\Atail\z/ => 'a' }
+
+  MORDERS = {
+    'f' => :first, 'l' => :last, /[tnh]/ => :north, /[bsa]/ => :south }
+  MMERGERS = {
+    'd' => :deep, /[mp]/ => :mix, 'o' => :override, 'i' => :ignore,
+    'k' => :stack }
+
+  def default_merger
+
+    { order: :first, merger: :deep }
+  end
+
+  def determine_merger
+
+    m = att(:on_merge, :merger, :merge)
+    h = default_merger
+
+    return h if m == nil
+    return m unless m.is_a?(String)
+
+    mm = m.split(/[-\s_]+/)
+    mm = mm[0].chars if mm.size == 1 && mm[0].size < 3
+      #
+    d = mm
+      .collect { |s| TRANSLATORS.inject(s) { |r, (k, v)| r.match(k) ? v : r } }
+      .collect { |s| s[0, 1] }.join
+
+    MORDERS.each do |rex, order|
+      if d.match(rex); h[:order] = order; break; end
+    end
+    MMERGERS.each do |rex, merger|
+      if d.match(rex); h[:merger] = merger; break; end
+    end
+
+    h[:key] = m.match(STACK_REX)[1] \
+      if h[:merger] == :stack
+
+    h
+  end
+
+  def mom__first(h, payloads)
+    mom__last(h, payloads).reverse
+  end
+  def mom__last(_, payloads)
+    payloads.values
+  end
+  def mom__north(h, payloads)
+    mom__south(h, payloads).reverse
+  end
+  def mom__south(_, payloads)
+    payloads.sort_by { |k, _| k }.collect(&:last)
+  end
+
+  def mmm__deep(_, ordered_payloads)
+    ordered_payloads.inject { |h, pl| Flor.deep_merge!(h, pl) }
+  end
+  def mmm__mix(_, ordered_payloads)
+    ordered_payloads.inject { |h, pl| h.merge!(pl) }
+  end
+  def mmm__override(_, ordered_payloads)
+    ordered_payloads.last
+  end
+  def mmm__ignore(_, _)
+    node_payload.copy
+  end
+  def mmm__stack(h, ordered_payloads)
+    k = h[:key] || 'ret'
+    node_payload.copy.merge!(k => ordered_payloads.reverse)
+  end
+
+  def determine_remainder
+
+    att(:remaining, :rem) || 'cancel'
+  end
+
+  def cancel_children(rem)
+
+    (rem && rem != 'forget') ? wrap_cancel_children : []
+  end
+
+  def reply_to_parent(rem)
+
+    return [] \
+      if @node['replied']
+    return [] \
+      if @node['payloads'].size < branch_count && ( ! rem || rem == 'wait')
+
+    @node['replied'] = true
+
+    wrap_reply('payload' => post_merge)
+  end
+
+  def post_merge
+
+    @node['merged_payload']
+  end
+end
+

data/lib/flor/unit.rb

@@ -17,6 +17,7 @@ require 'flor/unit/waiter'
 require 'flor/unit/scheduler'
 require 'flor/unit/models'
 require 'flor/unit/loader'
+require 'flor/unit/hloader'
 require 'flor/unit/ganger'
 require 'flor/unit/spooler'
 require 'flor/unit/taskers'

data/lib/flor/unit/caller.rb

@@ -55,7 +55,12 @@ module Flor
       #
       # initialize
 
-      k = Flor.const_lookup(conf['class'] || conf['module'])
+      k =
+        case com = conf['class'] || conf['module']
+        when String then Flor.const_lookup(com)
+        when Class then com
+        else fail ArgumentError.new("don't know how to call #{com.inspect}")
+        end
 
       o =
         if k.class == Module

data/lib/flor/unit/executor.rb

@@ -16,12 +16,11 @@ module Flor
         unit.storage.fetch_traps(@exid),
         unit.storage.load_execution(@exid))
 
-      @messages =
-        messages.collect { |m|
+      @messages = messages
+        .collect { |m|
           Flor::Storage
             .from_blob(m[:content])
-            .tap { |mm| mm['mid'] = m[:id].to_i }
-        }
+            .tap { |mm| mm['mid'] = m[:id].to_i } }
       @consumed = []
 
       @alive = true
@@ -48,6 +47,11 @@ module Flor
 
     protected
 
+    CLOSING_POINTS = %w[ task terminated ceased ]
+      #
+      # point for messages that, after consumption, are conserved
+      # in the execution's "closing_messages" array
+
     def do_run
 
       @unit.logger.log_run_start(self)
@@ -84,6 +88,10 @@ module Flor
 
       @alive = false
 
+      @execution.merge!(
+        closing_messages: @consumed.select { |m|
+          CLOSING_POINTS.include?(m['point']) })
+
       @unit.storage.put_execution(@execution)
       @unit.storage.consume(@consumed)
 
@@ -170,6 +178,11 @@ module Flor
       [ m ]
     end
 
+    def add(message)
+
+      apply(@execution['nodes'][message['nid']], message)
+    end
+
     def on_do_run_exc(e)
 
       io = StringIO.new

data/lib/flor/unit/ganger.rb

@@ -62,7 +62,7 @@ module Flor
 
       message['vars'] = gather_vars(executor, tconf, message)
 
-      m = Flor.dup(message)
+      m = 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
@@ -81,6 +81,17 @@ 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

@@ -0,0 +1,251 @@
+
+module Flor
+
+  # A loader which keeps everything in a Hash, while the traditional/default
+  # Flor::Loader reads from a file tree.
+  #
+  class HashLoader
+
+    # NB: tasker configuration entries start with "loa_", like for Flor::Loader
+
+    attr_reader :environment
+
+    def environment=(h)
+
+      @environment = Flor.to_string_keyed_hash(h)
+        .inject({}) { |r, (cat, v)|
+          r[cat] = recompose(v)
+          r }
+    end
+
+    def initialize(unit)
+
+      @unit = unit
+
+      class << @unit; include Flor::HashLoader::UnitAdders; end
+
+      self.environment = (@unit.conf['lod_environment'] || {})
+    end
+
+    def shutdown
+    end
+
+    HCATS = {
+      'v' => 'variables',
+      'var' => 'variables',
+      'variable' => 'variables',
+      'flo' => 'libraries',
+      'flow' => 'libraries',
+      'lib' => 'libraries',
+      'library' => 'libraries',
+      'sub' => 'sublibraries',
+      'sublib' => 'sublibraries',
+      'sublibrary' => 'sublibraries',
+      'tasker' => 'taskers',
+      'hook' => 'hooks' }
+    CATS =
+      HCATS.values.uniq
+
+    def add(cat, path, value, &block)
+
+      c = recat(cat)
+
+      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)
+
+      e = (@environment[c] ||= [])
+      e << [ *split(path), value ]
+      e.sort_by! { |pa, _, _| pa.count('.') }
+    end
+
+    def remove(cat, path)
+
+      c = recat(cat)
+
+      e = @environment[c]
+      return [] unless e
+
+      pa, ke = split(path)
+
+      e.reject! { |epa, eke, _| epa == pa && eke == ke }
+    end
+
+    def variables(domain)
+
+      entries('variables', domain)
+        .inject({}) { |h, (_, k, v)| h[k] = v; h }
+    end
+
+    #def procedures(path)
+    #
+    #  # TODO
+    #  # TODO work with Flor.load_procedures
+    #end
+
+    # If found, returns [ source_path, path ]
+    #
+    def library(domain, name=nil, opts={})
+
+      path, key = split(domain, name)
+
+      libs = entries('libraries', path)
+      if opts[:subflows] # used by "graft"/"import"
+        libs += entries('sublibraries', path)
+        libs = libs.sort_by { |pa, _, _| pa.count('.') }
+      end
+
+      libs
+        .each { |pa, ke, va|
+          next unless ke == key
+          return [ [ pa, ke ].join('.'), va ] }
+
+      nil
+    end
+
+    def tasker(domain, name, message={})
+
+      path, key = split(domain, name)
+
+      entries('taskers', path)
+        .reverse # FIXME
+        .each { |pa, ke, va|
+          next unless ke == key
+          return to_conf_h('taskers', pa, va, message) }
+
+      nil
+    end
+
+    def hooks(domain)
+
+      entries('hooks', domain)
+        .collect { |_, _, va| to_conf_h('hooks', domain, va, {}) }
+        .flatten(1)
+    end
+
+    def load_hooks(exid)
+
+      hooks(Flor.domain(exid))
+        .collect { |h| Flor::Hook.new(@unit, exid, h) }
+    end
+
+    protected
+
+    def recompose(h)
+
+      deflate(h, {}, nil)
+        .sort_by { |k, _| k.count('.') }
+        .collect { |k, v| [ *split(k), v ] }
+    end
+
+    def deflate(h, out, path)
+
+      h
+        .inject(out) { |r, (k, v)|
+          pathk = path ? [ path, k ].join('.') : k
+          if v.is_a?(Hash)
+            deflate(v, r, pathk)
+          else
+            r[pathk] = v
+          end
+          r }
+    end
+
+    def recat(cat)
+
+      c = cat.to_s
+      c = HCATS[c] || c
+
+      fail ArgumentError.new("unknown category #{cat.to_s.inspect}") \
+        unless CATS.include?(c)
+
+      c
+    end
+
+    def split(path, key=nil)
+
+      return [ path, key ] if key
+
+      i = path.rindex('.') || 0
+
+      [ path[0, i], path[(i == 0 ? i : i + 1)..-1] ]
+    end
+
+    def entries(cat, domain)
+
+      (@environment[cat.to_s] || [])
+        .select { |path, _, _| Flor.sub_domain?(path, domain) }
+    end
+
+    def to_conf_h(cat, path, value, context)
+
+      is_array = value.is_a?(Array)
+
+      a = (is_array ? value : [ value ])
+        .collect { |v|
+          h =
+            case v
+            when String then eval(path, v, context)
+            when Class then { 'class' => v }
+            when Hash then v
+            else { 'instance' => v }
+            end
+          h['_path'] = path
+          h['root'] = nil
+          h }
+
+      is_array ? a : a.first
+    end
+
+    def eval(path, code, context)
+
+      code = Flor::ConfExecutor.load(code)
+
+      Flor::ConfExecutor.interpret(path, code, context)
+    end
+
+    def block_to_class(cat, block)
+
+      c =
+        cat == 'taskers' ?
+        Class.new(Flor::BasicTasker) :
+        Class.new
+
+      class << c; attr_accessor :source_location; end
+      c.source_location = block.source_location
+      c.send(:define_method, :on_message, &block)
+
+      c
+    end
+
+    module UnitAdders
+
+      def add_variable(path, value)
+        self.loader.add(:variable, path, value)
+      end
+      def add_library(path, value)
+        self.loader.add(:library, path, value)
+      end
+      def add_sublibrary(path, value)
+        self.loader.add(:sublibrary, path, value)
+      end
+      def add_tasker(path, value=nil, &block)
+        self.loader.add(:tasker, path, value, &block)
+      end
+      def add_hook(path, value=nil, &block)
+        self.loader.add(:hook, path, value, &block)
+      end
+
+      alias add_var add_variable
+      alias add_lib add_library
+      alias add_sub add_sublibrary
+      alias add_sub_lib add_sublibrary
+
+      # to remove: unit.loader.remove(:tasker, path)
+    end
+  end
+end
+