flor 0.15.0 → 0.16.0

data/lib/flor/punit/cron.rb

@@ -4,7 +4,7 @@ require 'flor/punit/schedule'
 
 class Flor::Pro::Cron < Flor::Macro::Schedule
   #
-  # "cron" is a macro procedure.
+  # A macro-procedure, rewriting itself to `schedule cron: ...`.
   #
   # ```
   # cron '0 0 1 jan *'

data/lib/flor/punit/every.rb

@@ -4,7 +4,7 @@ require 'flor/punit/schedule'
 
 class Flor::Pro::Every < Flor::Macro::Schedule
   #
-  # "every" is a macro procedure.
+  # A macro-procedure, rewriting itself to `schedule every: ...`.
   #
   # ```
   # every 'day at midnight'

data/lib/flor/punit/graft.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Graft < Flor::Procedure
   #
-  # Graft a subtree into the current flo
+  # Graft a subtree into the current execution.
   #
   # Given
   # ```
@@ -65,8 +65,7 @@ class Flor::Pro::Graft < Flor::Procedure
     # graft subtree into parent node
 
     parent_tree = lookup_tree(parent)
-    cid = Flor.child_id(nid)
-    parent_tree[1][cid] = tree
+    parent_tree[1][child_id] = tree
 
     # re-apply self with subtree
 

data/lib/flor/punit/on_timeout.rb

@@ -32,7 +32,11 @@ class Flor::Pro::OnTimeout < Flor::Procedure
 
     store_on(:timeout)
 
-    super
+    ms = super
+
+    ms.first['from_on'] = 'timeout'
+
+    ms
   end
 end
 

data/lib/flor/punit/part.rb

@@ -0,0 +1,63 @@
+
+class Flor::Pro::Part < Flor::Procedure
+
+  names %w[ part flank ]
+
+  #                              +-------------------+--------------------+
+  #   ruote           flor       | replies to parent | cancellable        |
+  # +-------+-------+------------+-------------------+--------------------+
+  # | fork  | part  | part       | immediately       | no (not reachable) |
+  # |       | flunk |   r: false | never             | no (not reachable) |
+  # | flank | flank | flank      | immediately       | yes                |
+  # | lose  | norep |   r: false | never             | yes                |
+  # +-------+-------+------------+-------------------+--------------------+
+  #
+  # reply/r: false, cancellable/c: false
+  #
+  # to part, to flank, the subject is the diverging branch
+
+  def pre_execute
+
+    @node['atts'] = []
+  end
+
+  def receive_last_att
+
+    @node['tree'] = Flor.dup(tree)
+    @node['replyto'] = nil
+
+    rep = true
+    @node['can'] = (heap == 'flank')
+
+    if (r = att('reply', 'rep', 'r')) != nil
+      rep = r
+    end
+    if (c = att('cancellable', 'can', 'c')) != nil
+      @node['can'] = c
+    end
+
+    fla = @node['can'] ? 'flank' : 'part'
+      # so it is possible to have `flank r: true c: false` (iow: `part`)...
+
+    (rep ? wrap('flavour' => fla, 'nid' => parent, 'ret' => nid) : []) +
+    super
+  end
+
+  def cancel
+
+    if @node['can'] || from != parent
+      #
+      # if the node is cancellable or the cancel comes not from the parent
+      # the cancelling goes on...
+      #
+      super
+
+    else
+      #
+      # else the cancelling does not proceed further (down)
+      #
+      []
+    end
+  end
+end
+

data/lib/flor/punit/schedule.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Schedule < Flor::Procedure
   #
-  # Schedules a function
+  # Schedules a function in time.
   #
   # ```
   # schedule cron: '0 0 1 jan *'  # every 1st day of the year, check systems

data/lib/flor/punit/task.rb

@@ -1,5 +1,39 @@
 
 class Flor::Pro::Task < Flor::Procedure
+  #
+  # Tasks a tasker with a task.
+  #
+  # ```
+  # task 'clean up' by: 'alan'
+  # task 'clean up' for: 'alan'
+  # task 'clean up' assign: 'alan'
+  # task 'alan' with: 'clean up'
+  # alan task: 'clean up'  # {tasker} task: {taskname}
+  # task 'alan'
+  # # ...
+  # ```
+  #
+  # Note that the quotes are the tasker name can be omitted:
+  # ```
+  # task 'clean up' by: alan
+  # task 'clean up' for: alan
+  # task 'clean up' assign: alan
+  # task alan with: 'clean up'
+  # alan task: 'clean up'  # {tasker} task: {taskname}
+  # task alan
+  # # ...
+  # ```
+  #
+  # Tasking hands a task (a message hash serializable to JSON) to a tasker.
+  # See [tasks](../tasks.md) for more information.
+  #
+  # Since routing tasks among taskers is flor essential "task", this "task"
+  # procedure is very important.
+  #
+  # Note that "task" can be implicit, as in:
+  # ```
+  # alan task: 'clean up'
+  # ```
 
   name 'task'
 
@@ -10,11 +44,15 @@ class Flor::Pro::Task < Flor::Procedure
 
   def receive
 
-    return wrap_reply('payload' => determine_reply_payload) \
-      if point == 'receive' && from == nil
-
-    super
+    return super if point != 'receive' || from != nil
       # which goes to #receive or #receive_when_status
+
+    pl = determine_reply_payload
+    #pl['ret'] = node_payload_ret
+      # No, let's leave it at last f.ret wins...
+
+    wrap_reply('payload' => pl)
+      # "task" done, reply to parent node
   end
 
   alias receive_when_closed receive_from_child_when_closed
@@ -25,21 +63,25 @@ class Flor::Pro::Task < Flor::Procedure
     # task 'clean up' for: 'alan'
     # task 'clean up' assign: 'alan'
     # task 'alan' with: 'clean up'
+    # alan task: 'clean up'
+      #
     # clean_up assign: 'alan'
     # "clean up" assign: 'alan'
-    # alan task: 'clean up'
 
-    ni = att(nil)
+    nis = atts(nil)
     ta = att('by', 'for', 'assign')
     tn = att('with', 'task')
 
-    tasker = ta || ni
-
-    taskname = tn || ni
-    taskname = nil if ta == nil && tasker == ni
+    tasker = ta || nis.shift
+    tasker = tasker[1]['tasker'] if Flor.is_tasker_tree?(tasker)
+      #
+    taskname = tn || nis.shift
 
     attl, attd = determine_atts
 
+    @node['task'] =
+      { 'tasker' => tasker, 'name' => taskname }
+
     wrap(
       'point' => 'task',
       'exid' => exid, 'nid' => nid,

data/lib/flor/punit/trap.rb

@@ -8,9 +8,9 @@ class Flor::Pro::Trap < Flor::Procedure
   #
   # Once the trap is set (once the execution interprets its branch), it
   # will trigger for any matching message, unless the `count:` attribute
-  # is set.
+  # is set (it will trigger for the first {count} matching messages).
   #
-  # When the execution terminates, the trap is removed as well.
+  # When the execution terminates, the trap is removed.
   #
   # By default, the observation range is the execution, only messages
   # in the execution where the trap was set are considered.
@@ -195,8 +195,6 @@ class Flor::Pro::Trap < Flor::Procedure
 
   def receive_non_att
 
-    return execute_child(@ncid) if children[@ncid]
-
     fun = @fcid > 0 ? payload['ret'] : nil
 
     points = att_a('point', 'points', nil)
@@ -237,7 +235,7 @@ class Flor::Pro::Trap < Flor::Procedure
     count = 1 if fun == nil # blocking mode implies count: 1
     tra['count'] = count if count
 
-    tra['range'] = att('range') || att('scope') || 'subnid'
+    tra['range'] = att('range', 'scope') || 'subnid'
 
     @node['trapped'] = true
 
@@ -253,6 +251,7 @@ class Flor::Pro::Trap < Flor::Procedure
   def receive
 
     return [] if @node['trapped']
+
     super
   end
 

data/lib/flor/tools/shell.rb

@@ -217,9 +217,30 @@ module Flor::Tools
     def arg(line, index=1); args(line)[index]; end
     alias fname arg
 
+    def choose_execution_path(frag, option)
+
+      fail ArgumentError.new("'frag' argument missing") \
+        unless frag
+
+      exe = lookup_execution(frag)
+
+      fail ArgumentError.new("execution matching \"%#{frag}%\" not found") \
+        unless exe
+
+      d = File.join(@root, 'tmp')
+      FileUtils.mkdir_p(d)
+      fn = File.join(d, "exe__#{exe.exid}.rb")
+
+      File.open(fn, 'wb') { |f| PP.pp(exe.data, f, 79) } \
+        if ! File.exist?(fn) || option == 'force'
+
+      fn
+    end
+
     def choose_path(line)
 
       b = arg(line, 2)
+      c = arg(line, 3)
 
       case fname(line)
       when /\Av/,
@@ -232,14 +253,7 @@ module Flor::Tools
       when /\Ar/
         @ra_flow_path
       when /\Ae/
-        exe = lookup_execution(b)
-#p exe
-#pp exe.data
-#puts JSON.pretty_generate(exe.data)
-#puts JSON.dump(exe.data)
-#puts JSON.generate(exe.data, indent: '  ', space: ' ', object_nl: "\n", array_nl: "\n")
-puts Flor.to_d(exe.data, width: true, colours: true)
-fail NotImplementedError
+        choose_execution_path(b, c)
       else
         @flow_path
       end
@@ -442,8 +456,8 @@ fail NotImplementedError
     def cmd_launch(line)
 
       flow = File.read(@flow_path)
-      variables = Flor::ConfExecutor.interpret(@variables_path)
-      payload = Flor::ConfExecutor.interpret(@payload_path)
+      variables = Flor::ConfExecutor.interpret_path(@variables_path)
+      payload = Flor::ConfExecutor.interpret_path(@payload_path)
       domain = 'shell'
 
       vars = Flor::ConfExecutor.interpret_line("\n" + line[6..-1]) rescue {}
@@ -480,7 +494,7 @@ fail NotImplementedError
               o.puts "   #{@c.dark_gray(l)}"
             end
           end
-        rescue => err
+        rescue
           fail ArgumentError.new("no 'manual' for #{cmd.inspect}")
         end
 
@@ -489,9 +503,9 @@ fail NotImplementedError
         o.puts
         o.puts "## available commands:"
         o.puts
-        COMMANDS.each do |cmd|
-          o.print "* #{@c.yellow(cmd)}"
-          if hlp = (send("hlp_#{cmd}") rescue nil)
+        COMMANDS.each do |c|
+          o.print "* #{@c.yellow(c)}"
+          if hlp = (send("hlp_#{c}") rescue nil)
             o.print " - #{hlp.strip}"
           end
           o.puts
@@ -555,6 +569,10 @@ fail NotImplementedError
           edits the payload for the next execution
         * edit [f|flow]
           edits the flow for the next execution
+        * edit [e|exe] frag
+          edits the execution data
+        * edit [e|exe] frag force
+          edits the execution data (redump the data)
         * edit t|task frag
           edits a task currently under var/tasks/
         * edit r
@@ -583,7 +601,7 @@ fail NotImplementedError
     def cmd_cat(line)
 
       puts "  # #{@flow_path}\n"
-      File.readlines(@flow_path).each { |line| puts "  #{line}" }
+      File.readlines(@flow_path).each { |l| puts "  #{l}" }
     end
 
     def hlp_conf
@@ -624,7 +642,8 @@ fail NotImplementedError
       %{ prints the file hierarchy for #{@root} }
     end
     def cmd_t(line)
-      page(`tree -C #{@root}`)
+      #page(`tree -C #{@root}`)
+      page(`tree #{@root}`)
     end
 
     def hlp_tasks
@@ -829,7 +848,7 @@ fail NotImplementedError
     def cmd_hook(line)
 
       @hook =
-        case (a = arg(line))
+        case arg(line)
         when 'true', 'on'
           'on'
         when 'false', 'off'
@@ -1140,7 +1159,7 @@ Once edited (or not), a nato tasker task can be returned to flor (to the schedul
         }
       #Readline.completion_append_character =
       #  " "
-    rescue LoadError => le
+    rescue LoadError
       def prompt_and_read
         print(prompt)
         ($stdin.readline rescue false)

data/lib/flor/unit/caller.rb

@@ -26,7 +26,7 @@ module Flor
 
     rescue => err
 
-      [ Flor.to_error(err) ]
+      [ Flor.to_error_message(message, err) ]
     end
 
     protected
@@ -52,31 +52,36 @@ module Flor
         fail ArgumentError.new('".." not allowed in paths') if pa =~ /\.\./
         load(fjoin(root, pa)) }
 
+      #
+      # initialize
+
       k = Flor.const_lookup(conf['class'] || conf['module'])
 
       o =
         if k.class == Module
           k
         else
-          case k.instance_method(:initialize).arity
-          when 1 then k.new(service)
-          when 2 then k.new(service, conf)
-          when 3 then k.new(service, conf, message)
+          case i = k.instance_method(:initialize).arity
+          when 1, 2, 3 then k.new(
+            *[ service, conf, message ][0, i])
           when -1 then k.new({
             service: service, configuration: conf, message: message })
           else k.new
           end
         end
 
+      #
+      # call
+
       p = message['point']
-      m = :on
-      m = "on_#{p}" if ! o.respond_to?(m)
-      m = p if ! o.respond_to?(m)
-      m = :cancel if m == 'detask' && ! o.respond_to?(m)
+      ms = [ "on_#{p}", :on_message, :on, p ]
+      ms = ms + [ :on_cancel, :cancel ] if p == 'detask'
+      m = ms.find { |mm| o.respond_to?(mm) }
 
       fail(
-        "#{k.class.to_s.downcase} #{k} doesn't respond to on, on_#{p} or #{p}"
-      ) if ! o.respond_to?(m)
+        "#{k.class.to_s.downcase} #{k} doesn't respond to " +
+        ms[0..-2].collect { |e| "##{e}" }.join(', ') + ", or ##{ms[-1]}"
+      ) unless m
 
       r =
         case o.method(m).arity
@@ -88,6 +93,9 @@ module Flor
         else o.send(m)
         end
 
+      #
+      # reply
+
       to_messages(r)
     end
 
@@ -146,6 +154,10 @@ module Flor
       fail SpawnError.new(status, i.read, f.read) if status.exitstatus != 0
 
       [ i.read, status ]
+
+    ensure
+
+      [ i, o, f, e, r, w ].each { |x| x.close rescue nil }
     end
 
     class SpawnError < StandardError