oflow 0.6.0 → 0.8.0

data/lib/oflow/flow.rb

@@ -5,47 +5,234 @@ module OFlow
   # be thought of as a container for Tasks where the Flow keeps track of the
   # Links between the Tasks.
   class Flow
-    include HasTasks
-    include HasLinks
-    include HasName
+
     include HasErrorHandler
     include HasLog
 
+    # The name.
+    attr_reader :name
+    attr_reader :env
+
     # Create a new Flow.
-    # @param flow [Flow] Flow containing the Flow
+    # @param env [Env] Env containing the Flow
     # @param name [name] Flow base name
-    # @param options [Hash] additional options for the Flow
-    def initialize(flow, name, options)
-      init_name(flow, name)
-      init_tasks()
-      init_links()
+    def initialize(env, name)
+      @name = name.to_sym
+      @tasks = {}
+      @prepared = false
+      @log = nil
+      @error_handler = nil
+      @env = env
+    end
+
+    # Similar to a full file path. The full_name described the containment of
+    # the named item.
+    # @return [String] full name of item
+    def full_name()
+      @name.to_s
+    end
+
+    # Returns a log Task by looking for that Task in an attribute and then in
+    # the contained Tasks or Tasks in outer Flows.
+    # @return [Task] log Task.
+    def log()
+      return @log unless @log.nil?
+      lg = find_task(:log)
+      return lg unless lg.nil?
+      @env.log
+    end
+
+    # Returns a error_handler Task by looking for that Task in an attribute and then in
+    # the contained Tasks or Tasks in outer Flows.
+    # @return [Task] error_handler Task.
+    def error_handler()
+      return @error_handler unless @error_handler.nil?
+      eh = find_task(:error)
+      return eh unless eh.nil?
+      @env.error_handler
+    end
+
+    # Creates a Task and yield to a block with the newly create Task. Used to
+    # configure Tasks.
+    # @param name [Symbol|String] base name for the Task
+    # @param actor_class [Class] Class to create an Actor instance of
+    # @param options [Hash] optional parameters
+    # @param block [Proc] block to yield to with the new Task instance
+    # @return [Task] new Task
+    def task(name, actor_class, options={}, &block)
+      has_state = options.has_key?(:state)
+      unless has_state
+        options = options.clone
+        options[:state] = Task::STOPPED
+      end
+      t = Task.new(self, name, actor_class, options)
+      @tasks[t.name] = t
+      yield(t) if block_given?
+      t
+    end
+
+    # Validates the container by verifying all links on a task have been set to
+    # a valid destination and that destination has been resolved.
+    # @raise [ValidateError] if there is an error in validation
+    def validate()
+      # collects errors and raises all errors at once if there are any
+      errors = _validation_errors()
+      raise ValidateError.new(errors) unless errors.empty?
+    end
+
+    # Returns an Array of validation errors.
+    def _validation_errors()
+      errors = []
+      @tasks.each_value { |t| errors += t._validation_errors() }
+      errors
+    end
+
+    # Resolves all the Links on all the Tasks and Flows being managed as well as
+    # any Links in the instance itself.
+    def resolve_all_links()
+      @tasks.each_value { |t|
+        t.resolve_all_links()
+      }
+      @prepared = true
+    end
+
+    # Iterates over each Task and yields to the provided block with each Task.
+    # @param blk [Proc] Proc to call on each iteration
+    def each_task(&blk)
+      @tasks.each { |name,task| blk.yield(task) }
+    end
+
+    # Performs a recursive walk over all Tasks and yields to the provided block
+    # for each. Flows are followed recusively.
+    # @param tasks_only [true|false] indicates on Tasks and not Flows are yielded to
+    # @param blk [Proc] Proc to call on each iteration
+    def walk_tasks(tasks_only=true, &blk)
+      @tasks.each_value do |t|
+        if t.is_a?(Task)
+          blk.yield(t)
+        else
+          blk.yield(t) unless tasks_only
+          t.walk_tasks(tasks_only, &blk)
+        end
+      end
+    end
+
+    # Locates and return a Task with the specified name.
+    # @param name [String] name of the Task
+    # @return [Task|nil] the Task with the name specified or nil
+    def find_task(name)
+      name = name.to_sym unless name.nil?
+      @tasks[name]
+    end
+
+    # Locates and return a Task with the specified full name.
+    # @param name [String] full name of the Task
+    # @return [Task|nil] the Task with the name specified or nil
+    def locate(name)
+      name = name[1..-1] if name.start_with?(':')
+      name = name[0..-2] if name.end_with?(':')
+      path = name.split(':')
+      _locate(path)
+    end
+
+    def _locate(path)
+      t = @tasks[path[0].to_sym]
+      return t if t.nil? || 1 == path.size
+      t._locate(path[1..-1])
+    end
+
+    # Returns the number of active Tasks.
+    def task_count()
+      @tasks.size
     end
 
-    # Add a Link from the edge of the Flow to a Task contained in the Flow.
-    # @param label [Symbol|String] identifier for the Link
-    # @param task_name [Symbol|String] _name base name of teh Task to link to
-    # @param op [Symbol|String] operation to call when forwarding a request to the target Task
-    def route(label, task_name, op)
-      op = op.to_sym unless op.nil?
-      label = label.to_sym unless label.nil?
-      raise ConfigError.new("Link #{label} already exists.") unless find_link(label).nil?
-      @links[label] = Link.new(task_name.to_sym, op, true)
+    # Returns the sum of all the requests in all the Tasks's queues.
+    # @return [Fixnum] total number of items waiting to be processed
+    def queue_count()
+      cnt = 0
+      @tasks.each_value { |task| cnt += task.queue_count() }
+      cnt
     end
 
-    # Receive a request which is redirected to a Linked target Task.
-    # @param op [Symbol] identifies the link that points to the destination Task or Flow
-    # @param box [Box] contents or data for the request
-    def receive(op, box)
-      box = box.receive(full_name, op)
-      lnk = find_link(op)
-      raise LinkError.new(op) if lnk.nil? || lnk.target.nil?
-      lnk.target.receive(lnk.op, box)
+    # Returns true of one or more Tasks is either processing a request or has a
+    # request waiting to be processed on it's input queue.
+    # @return [true|false] the busy state across all Tasks
+    def busy?
+      @tasks.each_value { |task| return true if task.busy? }
+      false
     end
 
-    # Returns true if the Flow has a Link identified by the op.
-    # @param op [Symbol] identifies the Link in question
-    def has_input(op)
-      !find_link(op).nil?
+    # Calls the stop() method on all Tasks.
+    def stop()
+      @tasks.each_value { |task| task.stop() }
+    end
+
+    # Calls the step() method one Task that is stopped and has an item in the
+    # queue. The Tasks with the highest backed_up() value is selected.
+    def step()
+      max = 0.0
+      best = nil
+      walk_tasks() do |t|
+        if Task::STOPPED == t.state
+          bu = t.backed_up()
+          if max < bu
+            best = t
+            max = bu
+          end
+        end
+      end
+      best.step() unless best.nil?
+      best
+    end
+
+    # Calls the start() method on all Tasks.
+    def start()
+      raise ValidateError.new("#{full_name} not validated.") unless @prepared
+      @tasks.each_value { |task| task.start() }
+    end
+
+    # Wakes up all the Tasks in the Flow.
+    def wakeup()
+      @tasks.each_value { |t| t.wakeup() }
+    end
+
+    # Wakes up all the Tasks in the Flow and waits for the system to become idle
+    # before returning.
+    def flush()
+      wakeup()
+      @tasks.each_value { |t| t.flush() }
+      while busy?
+        sleep(0.2)
+      end
+    end
+
+    # Sets the state of all Tasks recursively. This should not be called
+    # directly.
+    def state=(s)
+      @tasks.each_value do |task|
+        task.state = s
+      end
+    end
+
+    # Shuts down all Tasks.
+    # @param flush_first [true|false] flag indicating shutdown should occur after the system becomes idle
+    def shutdown(flush_first=false)
+      # block all tasks first so threads can empty queues
+      @tasks.each_value do |task|
+        task.state = Task::BLOCKED
+      end
+      # shutdown and wait for queues to empty if necessary
+      @tasks.each_value do |task|
+        task.shutdown(flush_first)
+      end
+      @tasks = {}
+    end
+
+    # Clears out all Tasks and Flows and resets the object back to a empty state.
+    def clear()
+      shutdown()
+      @tasks = {}
+      _clear()
     end
 
     # Returns a String describing the Flow.
@@ -57,13 +244,6 @@ module OFlow
       @tasks.each_value { |t|
         lines << t.describe(detail, indent + 2)
       }
-      @links.each { |local,link|
-        if link.ingress
-          lines << "  #{i}#{local} * #{link.target_name}:#{link.op}"
-        else
-          lines << "  #{i}#{local} => #{link.target_name}:#{link.op}"
-        end
-      }
       lines << i + "}"
       lines.join("\n")
     end

data/lib/oflow/graffle.rb

@@ -0,0 +1,293 @@
+
+require 'ox'
+
+module OFlow
+
+  class Graffle
+    attr_accessor :name
+    attr_accessor :line_info
+    attr_accessor :task_info
+
+    def self.load(env, filename)
+      doc = Ox.load_file(filename, mode: :generic)
+      g = Graffle.new(env, filename, doc)
+      env.debug(g.to_s()) if Logger::Severity::DEBUG >= ::OFlow::Env.log_level
+    end
+
+    def initialize(env, filename, doc)
+      @line_info = { } # key is id
+      @task_info = { } # key is id
+      @name = File.basename(filename, '.graffle')
+
+      nodes = doc.locate('plist/dict')[0].nodes
+      nodes = Graffle.get_key_value(nodes, 'GraphicsList')
+
+      raise ConfigError.new("Empty flow.") if nodes.nil?
+      
+      nodes.each do |node|
+        load_node(node)
+      end
+
+      # set label in lines
+      task_info.each do |id,ti|
+        next if ti.line_id.nil?
+        if !(li = line_info[ti.line_id]).nil?
+          li.label, li.op = ti.first_option
+        end
+      end
+      task_info.each do |_, ti|
+        if ti.name.nil? && !(n = ti.options[:flow]).nil?
+          @name = n.strip
+        end
+      end
+      env.flow(@name.to_sym) { |f|
+        task_info.each_value { |ti|
+          next unless ti.line_id.nil?
+          next if ti.name.nil?
+          c = ti.get_class()
+          next if c.nil?
+          f.task(ti.name, c, ti.options) { |t|
+            t.bounds = ti.bounds
+            t.color = ti.color
+            t.shape = ti.shape
+            line_info.each_value { |li|
+              next unless li.tail == ti.id
+              target_info = task_info[li.head]
+              if target_info.nil?
+                flow_name, task_name, op = li.op.split('/')
+                t.link(li.label, task_name, op, flow_name)
+              else
+                t.link(li.label, target_info.name, li.op)
+              end
+            }
+          }
+        }
+      }
+    end
+
+    def load_node(node)
+      nodes = node.nodes
+      case Graffle.get_key_value(nodes, 'Class')
+      when 'LineGraphic'
+        line = LineInfo.new(nodes)
+        @line_info[line.id] = line
+      when 'ShapedGraphic'
+        task = TaskInfo.new(nodes)
+        @task_info[task.id] = task unless task.nil?
+      end
+    end
+
+    def to_s()
+      s = "Graffle{\n  name: #{@name}\n  tasks{\n"
+      task_info.each { |_,ti| s += "    #{ti}\n" }
+      s += "  }\n  lines{\n"
+      line_info.each { |_,li| s += "    #{li}\n" }
+      s += "  }\n}\n"
+      s
+    end
+
+    def self.get_key_value(nodes, key)
+      return if nodes.nil?
+      nodes.each_with_index do |node,i|
+        next unless 'key' == node.name && key == node.text
+        n = nodes[i + 1]
+        if 'dict' == n.name || 'array' == n.name
+          return n.nodes
+        else
+          return n.text
+        end
+      end
+      nil
+    end
+
+    def self.get_text(nodes)
+      return nil if nodes.nil?
+      strip_rtf(get_key_value(nodes, 'Text'))
+    end
+
+    def self.strip_rtf(rtf)
+      return rtf unless rtf.start_with?('{\rtf')
+      depth = 0
+      txt = ''
+      ctrl = nil
+      str = nil
+      rtf.each_char do |c|
+        case c
+        when ' '
+          if !str.nil?
+            str << ' ' unless 1 < depth
+          elsif !ctrl.nil?
+            txt << rtf_ctrl_char(ctrl) unless 1 < depth
+            ctrl = nil
+            str = ''
+          else
+            str = ''
+          end
+        when "\n", "\r"
+          if !str.nil? # should not happen but...
+            str << "\n" unless 1 < depth
+          elsif !ctrl.nil?
+            txt << rtf_ctrl_char(ctrl) unless 1 < depth
+            ctrl = nil
+          end
+        when '\\'
+          if !str.nil?
+            txt << str unless 1 < depth
+            str = nil
+          elsif !ctrl.nil?
+            txt << rtf_ctrl_char(ctrl) unless 1 < depth
+          end
+          ctrl = ''
+        when '{'
+          if !ctrl.nil?
+            txt << rtf_ctrl_char(ctrl) unless 1 < depth
+            ctrl = nil
+          end
+          depth += 1
+        when '}'
+          if !ctrl.nil?
+            txt << rtf_ctrl_char(ctrl) unless 1 < depth
+            ctrl = nil
+          end
+          depth -= 1
+        else
+          if !ctrl.nil?
+            ctrl << c
+          elsif 1 < depth
+            # ignore
+          else
+            str = '' if str.nil?
+            str << c
+          end
+        end
+      end
+      txt << str unless str.nil?
+      txt
+    end
+
+    def self.rtf_ctrl_char(ctrl)
+      c = ''
+      case ctrl
+      when '', 'line'
+        c = "\n"
+      when 'tab'
+        c = "\t"
+      else
+        if "'" == ctrl[0]
+          c = ctrl[1..3].hex().chr
+        end
+      end
+      c
+    end
+
+    class Element
+      attr_accessor :id
+
+      def initialize(nodes)
+        return if nodes.nil?
+        @id = Graffle.get_key_value(nodes, 'ID')
+      end
+      
+    end # Element
+
+    class LineInfo < Element
+      attr_accessor :tail
+      attr_accessor :head
+      attr_accessor :label
+      attr_accessor :op
+
+      def initialize(nodes)
+        super
+        @tail = Graffle.get_key_value(Graffle.get_key_value(nodes, 'Tail'), 'ID')
+        @head = Graffle.get_key_value(Graffle.get_key_value(nodes, 'Head'), 'ID')
+      end
+      
+      def to_s()
+        "LineInfo{id:#{@id}, tail:#{@tail}, head:#{@head}, label: #{label}:#{op}}"
+      end
+    end # LineInfo
+
+    class TaskInfo < Element
+      attr_accessor :line_id
+      attr_accessor :name
+      attr_accessor :options
+      attr_accessor :color
+      attr_accessor :shape
+      attr_accessor :bounds
+      
+      def initialize(nodes)
+        super
+        if (ln = Graffle.get_key_value(nodes, 'Line')).nil?
+          @line_id = nil
+        else
+          @line_id = Graffle.get_key_value(ln, 'ID')
+        end
+        @shape = Graffle.get_key_value(nodes, 'Shape')
+        color_node = Graffle.get_key_value(Graffle.get_key_value(Graffle.get_key_value(nodes, 'Style'), 'fill'), 'Color')
+        if color_node.nil?
+          @color = nil
+        else
+          @color = [Graffle.get_key_value(color_node, 'r').to_f,
+                    Graffle.get_key_value(color_node, 'g').to_f,
+                    Graffle.get_key_value(color_node, 'b').to_f]
+        end
+        unless (@bounds = Graffle.get_key_value(nodes, 'Bounds')).nil?
+          @bounds = @bounds.delete('{}').split(',')
+          @bounds.map! { |s| s.to_i }
+        end
+        @options = { }
+        text = Graffle.get_text(Graffle.get_key_value(nodes, 'Text'))
+        unless text.nil?
+          text.split("\n").each do |line|
+            pair = line.split(':', 2)
+            if 1 == pair.length
+              @name = pair[0]
+            else
+              k = pair[0]
+              if 0 == k.length
+                k = nil
+              else
+                k = k.to_sym
+              end
+              @options[k] = pair[1]
+            end
+          end
+        end
+      end
+
+      def first_option()
+        target = nil
+        op = nil
+        if name.nil?
+          options.each { |k,v| target, op = k, v; break }
+        else
+          target = name
+        end
+        [target, op]
+      end
+
+      def get_class()
+        return nil if options.nil?
+        return nil if (s = options[:class]).nil?
+        s.strip!
+        c = nil
+        begin
+          # TBD search all modules and classes for a match that is also an Actor
+
+          # Assume the environment is safe since it is being used to create
+          # processes from user provided code anyway.
+          c = Object.class_eval(s)
+        rescue Exception
+          c = ::OFlow::Actors.module_eval(s)
+        end
+        c
+      end
+
+      def to_s()
+        "TaskInfo{id:#{@id}, line_id:#{line_id}, name: #{name}, options: #{options}, bounds: #{@bounds}, shape: #{@shape}, color: #{@color}}"
+      end
+
+    end # TaskInfo
+
+  end # Graffle
+end # OFlow