flor 0.16.1 → 0.16.2

data/lib/flor/unit/hook.rb

@@ -14,21 +14,13 @@ module Flor
 
     def to_hook
 
-      opts = {}
-      opts[:consumed] = @h['consumed']
-      opts[:point] = Flor.h_fetch_a(@h, 'points', 'point', nil)
-      opts[:nid] = Flor.h_fetch_a(@h, 'nids', 'nid', nil)
-      opts[:heap] = Flor.h_fetch_a(@h, 'heaps', 'heap', nil)
-      opts[:heat] = Flor.h_fetch_a(@h, 'heats', 'heat', nil)
-      #opts[:name] = data['names']
-
-      #correct_points(opts)
-        #
-        # Necessary since "cancel" gets interpreted as
-        # [ '_proc', { 'proc' => 'cancel' }, @line ]
-        # ...
-
-      [ "hook#{object_id}", opts, self, nil ]
+      if @h['class']
+        class_to_hook
+      elsif @h['instance']
+        instance_to_hook
+      else
+        classical_to_hook
+      end
     end
 
     def notify(executor, message)
@@ -56,6 +48,73 @@ module Flor
 #      return point[1]['proc'] if point.is_a?(Array) && point[0] == '_proc'
 #      point
 #    end
+
+    def extract_filters(h)
+
+      r = {}
+      r[:consumed] = h['consumed']
+      r[:point] = Flor.h_fetch_a(h, 'points', 'point', nil)
+      r[:nid] = Flor.h_fetch_a(h, 'nids', 'nid', nil)
+      r[:heap] = Flor.h_fetch_a(h, 'heaps', 'heap', nil)
+      r[:heat] = Flor.h_fetch_a(h, 'heats', 'heat', nil)
+      #opts[:name] = data['names']
+
+      r
+    end
+
+    def class_to_hook
+
+      i = Flor::Hook.instantiate(@unit, @h['class'])
+
+      h = @h.dup
+      h.merge!(Flor.to_string_keyed_hash(i.opts)) if i.respond_to?(:opts)
+      opts = extract_filters(h)
+
+      [ "hooc#{object_id}", opts, i, nil ]
+    end
+
+    def instance_to_hook
+
+      i = @h['instance']
+
+      h = @h.dup
+      h.merge!(Flor.to_string_keyed_hash(i.opts)) if i.respond_to?(:opts)
+      opts = extract_filters(h)
+
+      [ "hooi#{object_id}", opts, i, nil ]
+    end
+
+    def classical_to_hook
+
+      opts = extract_filters(@h)
+
+      #correct_points(opts)
+        #
+        # Necessary since "cancel" gets interpreted as
+        # [ '_proc', { 'proc' => 'cancel' }, @line ]
+        # ...
+
+      [ "hook#{object_id}", opts, self, nil ]
+    end
+
+    class << self
+
+      def instantiate(unit, hook_class)
+
+        c =
+          case hook_class
+          when String then Flor.const_get(hook_class)
+          else hook_class
+          end
+        a =
+          case i = c.instance_method(:initialize).arity
+          when 0, 1 then [ unit ][0, i]
+          else []
+          end
+
+        c.new(*a)
+      end
+    end
   end
 end
 

data/lib/flor/unit/hooker.rb

@@ -9,6 +9,14 @@ module Flor
 
       @unit = unit
 
+      class << unit
+
+        def hook(*args, &block)
+
+          @hooker.add(*args, &block)
+        end
+      end
+
       @hooks = []
     end
 
@@ -46,7 +54,7 @@ module Flor
         end
       end
 
-      hook = instantiate_hook(hook) if hook.is_a?(Class)
+      hook = Flor::Hook.instantiate(@unit, hook) if hook.is_a?(Class)
 
       @hooks << [ name, opts, hook, block ]
     end
@@ -73,17 +81,6 @@ module Flor
 
     protected
 
-    def instantiate_hook(hook_class)
-
-      a =
-        case i = hook_class.instance_method(:initialize).arity
-        when 0, 1 then [ @unit ][0, i]
-        else []
-        end
-
-      hook_class.new(*a)
-    end
-
     def o(opts, *keys)
 
       array = false

data/lib/flor/unit/loader.rb

@@ -23,7 +23,7 @@ module Flor
       Dir[File.join(@root, '**/*.json')]
         .select { |f| f.index('/etc/variables/') }
         .collect { |pa| [ pa, expose_d(pa, {}) ] }
-        .select { |pa, d| is_subdomain?(domain, d) }
+        .select { |pa, d| Flor.sub_domain?(d, domain) }
         .sort_by { |pa, d| d.count('.') }
         .inject({}) { |vars, (pa, _)| vars.merge!(eval(pa, {})) }
     end
@@ -48,7 +48,7 @@ module Flor
       path, _, _ = (Dir[File.join(@root, '**/*.{flo,flor}')])
         .select { |f| f.index('/lib/') }
         .collect { |pa| [ pa, *expose_dn(pa, opts) ] }
-        .select { |pa, d, n| n == name && is_subdomain?(domain, d) }
+        .select { |pa, d, n| n == name && Flor.sub_domain?(d, domain) }
         .sort_by { |pa, d, n| d.count('.') }
         .last
 
@@ -62,12 +62,12 @@ module Flor
 
       domain, name = split_dn(domain, name)
 
-      pat, _, nam = Dir[File.join(@root, '**/*.json')]
+      pat, _, nam = Dir[File.join(@root, '**/*.{json,rb}')]
         .select { |pa| pa.index('/lib/taskers/') }
         .collect { |pa| [ pa, *expose_dn(pa, {}) ] }
         .select { |pa, d, n|
-          is_subdomain?(domain, [ d, n ].join('.')) ||
-          (n == name && is_subdomain?(domain, d)) }
+          Flor.sub_domain?([ d, n ].join('.'), domain) ||
+          (n == name && Flor.sub_domain?(d, domain)) }
         .sort_by { |pa, d, n| d.count('.') }
         .last
 
@@ -87,7 +87,7 @@ module Flor
       conf
     end
 
-    def hooks(domain, name=nil)
+    def hooks(domain)
 
       # NB: do not relativize path, because Ruby load path != cwd,
       # stay absolute for `require` and `load`
@@ -95,7 +95,7 @@ module Flor
       Dir[File.join(@root, '**/*.json')]
         .select { |f| f.index('/lib/hooks/') }
         .collect { |pa| [ pa, expose_d(pa, {}) ] }
-        .select { |pa, d| is_subdomain?(domain, d) }
+        .select { |pa, d| Flor.sub_domain?(d, domain) }
         .sort_by { |pa, d| d.count('.') }
         .collect { |pa, d|
           eval(pa, {}).each_with_index { |h, i|
@@ -111,15 +111,6 @@ module Flor
 
     protected
 
-    # is da a subdomain of db?
-    #
-    def is_subdomain?(da, db)
-
-      da == db ||
-      db == '' ||
-      da[0, db.length + 1] == db + '.'
-    end
-
     def split_dn(domain, name)
 
       if name
@@ -145,7 +136,7 @@ module Flor
         .sub(libregex, '/')
         .sub(/\/\z/, '')
         .sub(/\/(flo|flor|dot|hooks)\.json\z/, '')
-        .sub(/\.(flo|flor|json)\z/, '')
+        .sub(/\.(flo|flor|json|rb)\z/, '')
         .sub(/\A\//, '')
         .gsub(/\//, '.')
     end
@@ -163,6 +154,9 @@ module Flor
 
     def eval(path, context)
 
+      ext =
+        File.extname(path)
+
       src =
         @mutex.synchronize do
 
@@ -171,13 +165,43 @@ module Flor
 
           if val && mt1 == mt0
             val
+          elsif ext == '.rb'
+            (@cache[path] = [ File.read(path), mt1 ]).first
           else
             (@cache[path] = [ Flor::ConfExecutor.load(path), mt1 ]).first
           end
         end
 
+      case ext
+      when '.rb' then eval_ruby(path, src, context)
+      else eval_json(path, src, context)
+      end
+    end
+
+    def eval_json(path, src, context)
+
       Flor::ConfExecutor.interpret(path, src, context)
     end
+
+    def eval_ruby(path, src, context)
+
+      ks = context.keys.select { |k| k.match(/\A[a-z][a-zA-Z0-9_]+\z/) }
+
+      s = StringIO.new
+      s << "lambda {\n"
+      ks.each { |k| s << k << " = " << context[k].inspect << "\n" }
+      s << src
+      s << "\n}.call\n"
+
+      r = Kernel.module_eval(s.string, path, - ks.size)
+
+      r = JSON.parse(JSON.dump(r)) #if r.keys.find { |k| k.is_a?(Symbol) }
+        #
+        # so that symbols may be used in the .rb file, but plain JSON-like
+        # string keys are on the output
+
+      r.merge!('_path' => path)
+    end
   end
 end
 

data/lib/flor/unit/models.rb

@@ -28,10 +28,46 @@ module Flor
 
     self.require_valid_table = false
 
+    class << self
+
+      attr_accessor :unit
+    end
+
+    def unit; self.class.unit; end
+    def storage; unit.storage; end
+
+    # Return a Flor::Execution instance linked to this model
+    #
+    def execution(reload=false)
+
+      exid = @values[:exid]; return nil unless exid
+
+      @execution = nil if reload
+
+      @execution ||= unit.executions[exid: exid]
+    end
+
+    # Returns the node hash linked to this model
+    #
+    def node(reload=false)
+
+      nid = @values[:nid]; return nil unless nid
+      exe = execution(reload); return nil unless exe
+
+      nodes = exe.data['nodes']; return nil unless nodes
+      nodes[nid]
+    end
+
+    def payload(reload=false)
+
+      nod = node(reload)
+      nod ? nod['payload'] : nil
+    end
+
     def _data
 
       d = Flor::Storage.from_blob(content)
-      d['id'] = id
+      d['id'] = id if d.is_a?(Hash)
 
       d
     end
@@ -59,31 +95,31 @@ module Flor
   dir = File.dirname(__FILE__)
   MODELS.each { |m| require File.join(dir, 'models', "#{m.to_s[0..-2]}.rb") }
 
-  class Storage
+  def self.add_model(key, parent_module=Flor, table_prefix='flor_')
 
-    MODELS.each do |k|
+    Flor::Storage.send(:define_method, key) do
 
-      define_method(k) do
+      s = self
+      c = Flor.to_camel_case(key.to_s[0..-2])
 
-        s = self
-        c = k.to_s[0..-2].capitalize
+      @models[key] ||=
+        parent_module.const_set(
+          "#{c}#{@db.object_id.to_s.gsub('-', 'M')}",
+          Class.new(parent_module.const_get(c)) do
+            self.dataset = s.db["#{table_prefix}#{key}".to_sym]
+            self.unit = s.unit
+          end)
+    end
 
-        @models[k] ||=
-          Flor.const_set(
-            "#{c}#{@db.object_id.to_s.gsub('-', 'M')}",
-            Class.new(Flor.const_get(c)) do
-              self.dataset = s.db["flor_#{k}".to_sym]
-            end)
-      end
+    Flor::Scheduler.send(:define_method, key) do
+
+      @storage.send(key)
     end
   end
 
-  class Scheduler
+  MODELS.each do |k|
 
-    MODELS.each do |k|
-
-      define_method(k) { @storage.send(k) }
-    end
+    add_model(k)
   end
 end
 

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

@@ -20,6 +20,9 @@ module Flor
 
     def nodes; data['nodes']; end
     def zero_node; nodes['0']; end
+    def closing_messages; data['closing_messages']; end
+
+    def execution(reload=false); self; end
 
     def tags
 
@@ -45,14 +48,22 @@ module Flor
 
       tree = nodes['0']['tree']
 
-      nodes.each do |nid, n|
-        next if nid == '0'
-        t = n['tree']; next unless t
-      end
+      #nodes.each do |nid, n|
+      #  next if nid == '0'
+      #  t = n['tree']; next unless t
+      #end
+        #
+        # FIXME
 
       tree
     end
 
+    def lookup_tree(nid)
+
+      Flor::Node.new(self.data, nodes[nid], nil)
+        .lookup_tree(nid)
+    end
+
     def zero_variables
 
       zero_node['vars']

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

@@ -12,6 +12,7 @@ module Flor
     #  String :type, null: false  # task, tasked, tag, var
     #  String :name, null: false # task name, tasked name, tag name, var name
     #  String :value
+    #  File :content
     #  String :ctime, null: false
     #
     #  # no :status, no :mtime
@@ -26,6 +27,16 @@ module Flor
     #  #unique [ :exid, :type, :name, :value ]
     #    # we don't care, pointers are cleaned anyway when the flow dies
     #end
+
+    # If the pointer is a "var" pointer, returns the full value
+    # for the variable, as fund in the execution's node "0".
+    #
+    def full_value
+
+      return nil unless type == 'var'
+
+      node['vars'][name]
+    end
   end
 end
 

data/lib/flor/unit/scheduler.rb

@@ -111,11 +111,6 @@ module Flor
       @ganger.shutdown
     end
 
-    def hook(*args, &block)
-
-      @hooker.add(*args, &block)
-    end
-
     def on_start_exc(e)
 
       io = StringIO.new
@@ -182,13 +177,9 @@ module Flor
 
       source, domain, flow_name =
         if df = Flor.split_flow_name(source_or_path)
-          [ source_or_path,
-            opts[:domain] || df[0],
-            df[1] ]
+          [ source_or_path, opts[:domain] || df[0], df[1] ]
         else
-          [ source_or_path,
-            opts[:domain] || @conf['domain'] || 'domain0',
-            nil ]
+          [ source_or_path, opts[:domain] || @conf['domain'] || 'domain0', nil ]
         end
 
       fail ArgumentError.new(
@@ -280,6 +271,68 @@ module Flor
     end
     alias reapply re_apply
 
+    def add_branches(exid, *as)
+
+      m = prepare_message('add-branches', [ exid, *as ]).first
+
+      exe = @storage.executions[exid: m['exid']]
+      pnid = m['nid']
+      ptree = exe.lookup_tree(pnid)
+
+      fail ArgumentError.new(
+        "parent #{pnid} is a leaf, cannot add branch at #{tnid}"
+      ) unless ptree[1].is_a?(Array)
+        #
+        # not likely to happen, since leaves reply immediately
+
+      size = ptree[1].size
+      tnid = (m['tnid'] ||= Flor.make_child_nid(pnid, size))
+
+      cid = Flor.child_id(tnid)
+
+      tide, tcid = nil
+        (0..size - 1).reverse_each do |i|
+          tcid = Flor.make_child_nid(pnid, i)
+          next unless exe.nodes[tcid]
+          tide = i; break
+        end
+
+      fail ArgumentError.new(
+        "target #{tnid} too low, execution has already reached #{tcid}"
+      ) if tide && cid < tide
+
+      fail ArgumentError.new(
+        "target #{tnid} is off by #{cid - size}, " +
+        "node #{pnid} has #{size} branch#{size == 1 ? '' : 'es'}"
+      ) if cid > size
+
+      queue(m)
+    end
+    alias add_branch add_branches
+
+    def add_iterations(exid, *as)
+
+      m = prepare_message('add-iterations', [ exid, *as ]).first
+
+      exe = @storage.executions[exid: m['exid']]
+      nid = m['nid']
+
+      fail ArgumentError.new(
+        "cannot add iteration to missing execution #{m['exid'].inspect}"
+      ) unless exe
+
+      fail ArgumentError.new(
+        "missing nid: or pnid:"
+      ) unless nid
+
+      fail ArgumentError.new(
+        "cannot add iteration to missing node #{nid.inspect}"
+      ) unless exe.lookup_tree(nid)
+
+      queue(m)
+    end
+    alias add_iteration add_iterations
+
     def schedule(message)
 
       @storage.put_timer(message)
@@ -367,20 +420,6 @@ module Flor
       puts on_start_exc(ex)
     end
 
-    def prepare_re_apply_messages(msg, opts)
-
-      fail ArgumentError.new("missing 'payload' to re_apply") \
-        unless msg['payload']
-
-      t = Flor.parse(opts[:tree], 're_apply', {})
-
-      [ { 'point' => 'execute',
-          'exid' => msg['exid'], 'nid' => msg['nid'],
-          'from' => 'parent',
-          'tree' => t,
-          'payload' => msg['payload'] } ]
-    end
-
     def prepare_message(point, args)
 
       h =
@@ -394,11 +433,6 @@ 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
@@ -407,7 +441,30 @@ module Flor
         end
       end
 
+      if point == 'kill'
+
+        msg['point'] = 'cancel'
+        msg['flavour'] = 'kill'
+
+      elsif point == 'add-branches'
+
+        msg['point'] = 'add'
+        msg['trees'] = prepare_trees(opts)
+
+        msg['tnid'] = tnid =
+          opts.delete(:tnid) || msg.delete('nid')
+        msg['nid'] =
+          msg.delete('nid') || opts.delete(:pnid) || Flor.parent_nid(tnid)
+
+      elsif point == 'add-iterations'
+
+        msg['point'] = 'add'
+        msg['elements'] = prepare_elements(opts)
+        msg['nid'] = msg.delete('nid') || opts.delete(:pnid)
+      end
+
       if opts[:re_apply]
+
         msg['on_receive_last'] = prepare_re_apply_messages(msg, opts)
       end
 
@@ -419,6 +476,45 @@ module Flor
       [ msg, opts ]
     end
 
+    def prepare_trees(opts)
+
+      fname = Flor.caller_fname
+
+      ts = (opts[:trees] || [ opts[:tree] ].compact)
+        .collect { |t| Flor.parse(t, fname, {}) }
+
+      fail ArgumentError.new('missing trees: or tree:') if ts.empty?
+
+      ts
+    end
+
+    def prepare_elements(opts)
+
+      elts =
+        opts[:elements] || opts[:elts] ||
+        opts[:element] || opts[:elt]
+
+      fail ArgumentError.new('missing elements: or element:') unless elts
+
+      elts = [ elts ] unless elts.is_a?(Array)
+
+      elts
+    end
+
+    def prepare_re_apply_messages(msg, opts)
+
+      fail ArgumentError.new("missing 'payload' to re_apply") \
+        unless msg['payload']
+
+      t = Flor.parse(opts[:tree], Flor.caller_fname, {})
+
+      [ { 'point' => 'execute',
+          'exid' => msg['exid'], 'nid' => msg['nid'],
+          'from' => 'parent',
+          'tree' => t,
+          'payload' => msg['payload'] } ]
+    end
+
     def make_idle_message
 
       m = {}