oflow 0.6.0 → 0.8.0

data/lib/oflow/haserrorhandler.rb

@@ -7,25 +7,6 @@ module OFlow
   # the next Flow until an error handler is found.
   module HasErrorHandler
 
-    # Returns an error handler Task by checking for an @error_handler variable,
-    # then looking for a Task with a base name of :error in itself or any of the
-    # containing Flows.
-    # @return [Task|nil] Task to handle errors
-    def error_handler()
-      return @error_handler if instance_variable_defined?(:@error_handler) && !@error_handler.nil?
-      if instance_variable_defined?(:@flow)
-        if @flow.respond_to?(:find_task)
-          eh = @flow.find_task(:error)
-          return eh unless eh.nil?
-        end
-        if @flow.respond_to?(:error_handler)
-          eh = @flow.error_handler()
-          return eh unless eh.nil?
-        end
-      end      
-      nil
-    end
-
     # Sets avaliable for handling errors.
     # @param t [Task|nil] Task for handling error or nil to unset
     def error_handler=(t)
@@ -36,11 +17,11 @@ module OFlow
     # @param e [Exception] error to handle
     def handle_error(e)
       handler = error_handler()
-      unless handler.nil?
-        handler.receive(nil, Box.new([e, full_name()]))
-      else
+      if handler.nil?
         puts "** [#{full_name()}] #{e.class}: #{e.message}"
         e.backtrace.each { |line| puts "    #{line}" }
+      else
+        handler.receive(nil, Box.new([e, full_name()]))
       end
     end
 

data/lib/oflow/haslog.rb

@@ -4,26 +4,12 @@ module OFlow
   # Adds the ability to log by sending log requests to a log Task.
   module HasLog
 
-    # 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 if instance_variable_defined?(:@log) && !@log.nil?
-      # Log task take precedence over log variable.
-      if respond_to?(:find_task)
-        lg = find_task(:log)
-        return lg unless lg.nil?
-      end
-      return @flow.log if instance_variable_defined?(:@flow) && @flow.respond_to?(:log)
-      nil
-    end
-
     # Sets the log attribute.
     # @param t [Task] log Task
     def log=(t)
       @log = t
     end
-
+    
     # Lower level logging method. Generally only used when one of the primary
     # severity methods are called.
     # @param level [String] message severity or level
@@ -45,6 +31,26 @@ module OFlow
       end
     end
 
+    # @return true if errors would be logged.
+    def error?()
+      Env.log_level <= Logger::Severity::ERROR
+    end
+
+    # @return true if warn messages would be logged.
+    def warn?()
+      Env.log_level <= Logger::Severity::WARN
+    end
+
+    # @return true if info messages would be logged.
+    def info?()
+      Env.log_level <= Logger::Severity::INFO
+    end
+
+    # @return true if debug messages would be logged.
+    def debug?()
+      Env.log_level <= Logger::Severity::DEBUG
+    end
+
     # Logs the message if logging level is at least debug.
     # @param msg [String] message to log
     def debug(msg)

data/lib/oflow/inspector.rb

@@ -6,8 +6,9 @@ module OFlow
   class Inspector < ::OTerm::Executor
     attr_reader :running
 
-    def initialize(port=6060)
+    def initialize(env, port=6060)
       super()
+      @env = env
       @running = true
       
       register('busy', self, :busy, 'returns the busy state of the system.', nil)
@@ -44,7 +45,7 @@ available for sorting on name, activity, or queue size.|)
     def shutdown(listener, args)
       super
       @running = false
-      Env.shutdown()
+      @env.shutdown()
     end
 
     def greeting()
@@ -56,7 +57,7 @@ available for sorting on name, activity, or queue size.|)
     end
 
     def busy(listener, args)
-      if Env.busy?()
+      if @env.busy?()
         listener.out.pl("One or more Tasks is busy.")
       else
         listener.out.pl("All Tasks are idle.")
@@ -64,14 +65,14 @@ available for sorting on name, activity, or queue size.|)
     end
 
     def flows(listener, args)
-      Env.each_task() do |t|
+      @env.each_task() do |t|
         listener.out.pl(t.full_name)
       end
     end
 
     def list(listener, args)
       if nil == args
-        Env.each_task() do |task|
+        @env.each_task() do |task|
           listener.out.pl(task.full_name)
         end
         return
@@ -81,7 +82,7 @@ available for sorting on name, activity, or queue size.|)
       if id.nil?
         flow = Env
       else
-        flow = Env.locate(id)
+        flow = @env.locate(id)
       end
       if flow.nil?
         listener.out.pl("--- No Flow or Task found for #{id}")
@@ -100,7 +101,7 @@ available for sorting on name, activity, or queue size.|)
       detail, id, ok = _parse_opt_id_args(args, 'v', listener)
       return unless ok
 
-      task = Env.locate(id)
+      task = @env.locate(id)
       if task.nil?
         listener.out.pl("--- Failed to find '#{id}'")
         return
@@ -110,11 +111,11 @@ available for sorting on name, activity, or queue size.|)
 
     def start(listener, args)
       if nil == args || 0 == args.size()
-        Env.start()
+        @env.start()
         listener.out.pl("All Tasks restarted")
       else
         args.strip!
-        task = Env.locate(args)
+        task = @env.locate(args)
         if task.nil?
           listener.out.pl("--- Failed to find '#{args}'")
         else
@@ -125,7 +126,7 @@ available for sorting on name, activity, or queue size.|)
     end
 
     def step(listener, args)
-      lg = Env.log()
+      lg = @env.log()
       stop_after = false
       if !lg.nil? && Task::STOPPED == lg.state
         lg.start()
@@ -136,7 +137,7 @@ available for sorting on name, activity, or queue size.|)
         task = Env
       else
         args.strip!
-        task = Env.locate(args)
+        task = @env.locate(args)
       end
       if task.nil?
         listener.out.pl("--- Failed to find '#{args}'")
@@ -153,11 +154,11 @@ available for sorting on name, activity, or queue size.|)
 
     def stop(listener, args)
       if nil == args || 0 == args.size()
-        Env.stop()
+        @env.stop()
         listener.out.pl("All Tasks stopped(paused)")
       else
         args.strip!
-        task = Env.locate(args)
+        task = @env.locate(args)
         if task.nil?
           listener.out.pl("--- Failed to find '#{args}'")
         else
@@ -168,7 +169,7 @@ available for sorting on name, activity, or queue size.|)
     end
 
     def verbosity(listener, args)
-      lg = Env.log
+      lg = @env.log
       if lg.nil?
         listener.out.pl("--- No logger")
         return
@@ -188,10 +189,10 @@ available for sorting on name, activity, or queue size.|)
     def watch(listener, args)
       tasks = []
       if args.nil? || 0 == args.size()
-        Env.walk_tasks() { |t| tasks << t }
+        @env.walk_tasks() { |t| tasks << t }
       else
         args.strip!
-        task = Env.locate(args)
+        task = @env.locate(args)
         if task.nil?
           listener.out.pl("--- Failed to find '#{args}'")
           return
@@ -388,7 +389,7 @@ available for sorting on name, activity, or queue size.|)
         names = ['fatal', 'error', 'warn', 'info', 'debug'].select { |s| s.start_with?(last.downcase()) }
       else # expect id or options
         with_colon = ':' == last[0]
-        Env.walk_tasks(false) do |t|
+        @env.walk_tasks(false) do |t|
           fn = t.full_name
           fn = fn[1..-1] unless with_colon
           names << fn if fn.start_with?(last)

data/lib/oflow/link.rb

@@ -7,24 +7,25 @@ module OFlow
     
     # Name of the target.
     attr_reader :target_name
+    # Name of the target's parent flow.
+    attr_reader :flow_name
     # Operation to provide the target.
     attr_reader :op
-    # The actual target Task or Flow.
+    # The actual target Task.
     attr_reader :target
-    # Flag indicating the Link is from a Flow to a Task contained in the Flow.
-    attr_reader :ingress
 
     # Creates a new Link. This is called from link() and route() methods on
     # Tasks and Flows.
+    # @param flow_name [Symbol|String] parent flow name to find the target task in or nil for this parent
     # @param target_name [Symbol] target Task base name
     # @param op [Symbol] operation to use on the target
     # @param ingress [true|false] indicates the Link is internal
     # @return [Link] new Link
-    def initialize(target_name, op, ingress=false)
+    def initialize(flow_name, target_name, op)
       @target_name = target_name
+      @flow_name = flow_name
       @op = op
       @target = nil
-      @ingress = ingress
     end
 
     # Delivers a package (Box) to the target.
@@ -35,7 +36,11 @@ module OFlow
 
     # Returns a string representation of the Link.
     def to_s()
-      "Link{ingress: #{@ingress}, target_name: #{@target_name}, op: #{op}, target: #{@target}}"
+      if @flow_name.nil?
+        "Link{target_name: #{@target_name}, op: #{op}, target: #{@target}}"
+      else
+        "Link{target_name: #{@flow_name}:#{@target_name}, op: #{op}, target: #{@target}}"
+      end
     end
     alias inspect to_s
 

data/lib/oflow/task.rb

@@ -6,11 +6,17 @@ module OFlow
   # data by the receive() method. The request is put on a queue and popped off
   # one at a time and handed to an Actor associatesd with the Task.
   class Task
-    include HasName
-    include HasLinks
+
     include HasErrorHandler
     include HasLog
 
+    # The name.
+    attr_reader :name
+
+    attr_accessor :bounds
+    attr_accessor :shape
+    attr_accessor :color
+
     # value of @state that indicates the Task is being created.
     STARTING = 0
     # value of @state that indicates the Task is not currently processing requests
@@ -36,7 +42,12 @@ module OFlow
     # @param actor_class [Class] _class Class of the Actor to create
     # @param options [Hash] additional options for the Task or Actor
     def initialize(flow, name, actor_class, options={})
+      @flow = flow
+      @name = name.to_sym
       @state = STARTING
+      @bounds = nil # [x, y, w, h] as fixnums
+      @color = nil  # [r, g, b] as floats
+      @shape = nil  # Rectangle is the default
       @queue = []
       @req_mutex = Mutex.new()
       @req_thread = nil
@@ -47,9 +58,10 @@ module OFlow
       @current_req = nil
       @proc_cnt = 0
       @loop = nil
+      @links = {}
+      @log = nil
+      @error_handler = nil
 
-      init_name(flow, name)
-      init_links()
       set_options(options)
 
       info("Creating actor #{actor_class} with options #{options}.")
@@ -57,6 +69,7 @@ module OFlow
       raise Exception.new("#{actor} does not respond to the perform() method.") unless @actor.respond_to?(:perform)
 
       @state = options.fetch(:state, RUNNING)
+
       return unless @actor.with_own_thread()
 
       @loop = Thread.start(self) do |me|
@@ -77,7 +90,11 @@ module OFlow
 
               @current_req = req
               begin
-                info("perform(#{req.op}, #{req.box})")
+                if debug?
+                  debug("perform(#{req.op}, #{req.box.nil? ? '<nil>' : req.box})")
+                else
+                  info("perform(#{req.op})")
+                end
                 @actor.perform(req.op, req.box) unless req.nil?
               rescue Exception => e
                 handle_error(e)
@@ -100,17 +117,63 @@ module OFlow
       end
     end
 
+    # Creates a Link identified by the label that has a target Task and
+    # operation.
+
+    # @param label [Symbol|String] identifer of the Link
+    # @param target [Symbol|String] identifer of the target Task
+    # @param op [Symbol|String] operation to perform on the target Task
+    # @param flow_name [Symbol|String] parent flow name to find the target task in or nil for this parent
+    def link(label, target, op, flow_name=nil)
+      label = label.to_sym unless label.nil?
+      op = op.to_sym unless op.nil?
+      flow_name = flow_name.to_sym unless flow_name.nil?
+      raise ConfigError.new("Link #{label} already exists.") unless @links[label].nil?
+      @links[label] = Link.new(flow_name, target.to_sym, op)
+    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()
+      if @flow.nil?
+        ':' + @name.to_s
+      else
+        @flow.full_name() + ':' + @name.to_s
+      end
+    end
+
+    # Returns a log Task by looking for that Task as an attribute and then in
+    # the parent Flow.
+    # @return [Task] log Task.
+    def log()
+      return @log unless @log.nil?
+      @flow.log()
+    end
+
+    # Returns an error handler Task by looking for that Task as an attribute and then in
+    # the parent Flow.
+    # @return [Task] error handler Task.
+    def error_handler()
+      return @error_handler unless @error_handler.nil?
+      @flow.error_handler()
+    end
+
     # Returns the state of the Task as a String.
     # @return [String] String representation of the state
     def state_string()
       ss = 'UNKNOWN'
       case @state
+      when STARTING
+        ss = 'STARTING'
       when STOPPED
         ss = 'STOPPED'
       when RUNNING
         ss = 'RUNNING'
       when CLOSING
         ss = 'CLOSING'
+      when BLOCKED
+        ss = 'BLOCKED'
       when STEP
         ss = 'STEP'
       end
@@ -124,7 +187,11 @@ module OFlow
       i = ' ' * indent
       lines = ["#{i}#{name} (#{actor.class}) {"]
       @links.each { |local,link|
-        lines << "  #{i}#{local} => #{link.target_name}:#{link.op}"
+        if link.flow_name.nil?
+          lines << "  #{i}#{local} => :#{link.target_name}:#{link.op}"
+        else
+          lines << "  #{i}#{local} => #{link.flow_name}:#{link.target_name}:#{link.op}"
+        end
       }
       if 1 <= detail
         lines << "  #{i}queued: #{queue_count()} (#{busy? ? 'busy' : 'idle'})"
@@ -281,8 +348,11 @@ module OFlow
     # @param op [Symbol] operation to perform
     # @param box [Box] contents or data for the request
     def receive(op, box)
-      info("receive(#{op}, #{box}) #{state_string}")
-
+      if debug?
+        debug("receive(#{op}, #{box.nil? ? '<nil>' : box}) #{state_string}")
+      else
+        info("receive(#{op})")
+      end
       return if CLOSING == @state
 
       raise BlockedError.new() if BLOCKED == @state
@@ -317,7 +387,11 @@ module OFlow
       box.freeze() unless box.nil?
       link = resolve_link(dest)
       raise LinkError.new(dest) if link.nil? || link.target.nil?
-      info("shipping #{box} to #{link.target_name}:#{link.op}")
+      if debug?
+        debug("shipping #{box} to #{link.target_name}:#{link.op}")
+      else
+        info("shipping to #{link.target_name}:#{link.op}")
+      end
       link.target.receive(link.op, box)
       link
     end
@@ -333,6 +407,17 @@ module OFlow
       @req_timeout = options.fetch(:request_timeout, @req_timeout).to_f
     end
     
+    def set_option(key, value)
+      case key.to_sym()
+      when :max_queue_count
+        @max_queue_count = value.to_i
+      when :request_timeout
+        @req_timeout = value.to_f
+      else
+        @actor.set_option(key, value)
+      end
+    end
+
     def _validation_errors()
       errors = []
       @links.each_value { |lnk| _check_link(lnk, errors) }
@@ -377,6 +462,46 @@ module OFlow
       }
     end
 
+    # Attempts to find and resolve the Link identified by the label. Resolving a
+    # Link uses the target identifier to find the target Task and save that in
+    # the Link.
+    # @param label [Symbol|String] identifer of the Link
+    # @return [Link] returns the Link for the label
+    def resolve_link(label)
+      label = label.to_sym unless label.nil?
+      lnk = @links[label] || @links[nil]
+      return nil if lnk.nil?
+      set_link_target(lnk) if lnk.target.nil?
+      lnk
+    end
+
+    # Sets the target Task for a Link.
+    # @param lnk [Link] Link to find the target Task for.
+    def set_link_target(lnk)
+      f = @flow
+      f = @flow.env.find_flow(lnk.flow_name) unless lnk.flow_name.nil?
+      raise ConfigError.new("Flow '#{lnk.flow_name}' not found.") if f.nil?
+      lnk.instance_variable_set(:@target, f.find_task(lnk.target_name))
+    end
+
+    # Attempts to find the Link identified by the label.
+    # @param label [Symbol|String] identifer of the Link
+    # @return [Link] returns the Link for the label
+    def find_link(label)
+      label = label.to_sym unless label.nil?
+      @links[label] || @links[nil]
+    end
+
+    # Returns the Links.
+    # @return [Hash] Hash of Links with the keys as Symbols that are the labels of the Links.
+    def links()
+      @links
+    end
+
+    def has_links?()
+      !@links.nil? && !@links.empty?
+    end
+
     private
 
     # Internal class used to store information about asynchronous method
@@ -404,18 +529,5 @@ module OFlow
 
     end # Request
 
-    class Link
-      attr_reader :name
-      attr_reader :task
-      attr_reader :op
-
-      def initialize(name, task, op)
-        @name = name
-        @task = task
-        @op = op
-      end
-
-    end # Link
-
   end # Task
 end # OFlow