opee 1.0.4 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f79910e2d461382014985e2657c734b30a03e8e1
+  data.tar.gz: e8b1bfbd4a6740d62ac533c0c2922c219d0ead73
+SHA512:
+  metadata.gz: 24d04957abaa2b38183ac5725d7bfc47d86911c507228676229bc4d3af91f0cd02e3cc0e285cba6a915fce3e2ec622894852477160ad47f274493fa5e6df8193
+  data.tar.gz: 3d7203e89585ed3343c7278cfc981d5bf92c4f76e08d62daf14d91e151c14ea7b5e2aea9a9906606666e0558d905b29e1b1c19a08336c1a042ec4373ce4c018b

data/README.md

@@ -20,17 +20,19 @@ Give it a try. Any comments, thoughts, or suggestions are welcome.
 
 ## <a name="links">Links of Interest</a>
 
-[Not Your Usual Threading](http://www.ohler.com/dev/http://www.ohler.com/dev/not_your_usual_threading/not_your_usual_threading.html) discussion about how OPEE use changes the way multi-threaded systems are designed.
+[Not Your Usual Threading](http://www.ohler.com/dev/not_your_usual_threading/not_your_usual_threading.html) discussion about how OPEE use changes the way multi-threaded systems are designed.
+
+[Open Remote Encrypted File Synchronization](http://www.ohler.com/orefs) is a sample application that makes use of the Opee gem.
 
 ## <a name="release">Release Notes</a>
 
-### Release 1.0.4
+### Release 1.1.0
 
- - Fixed a bug in queue size reporting for the Queue class.
+ - Added Inspector that uses the OTerm for real time interaction with Actors.
 
 # Plans and Notes
 
-- implement in C if there is enough interest
+- Implement in C if there is enough interest
 
 ### License:
 

data/lib/opee.rb

@@ -11,3 +11,4 @@ require 'opee/workqueue'
 require 'opee/askqueue'
 require 'opee/job'
 require 'opee/collector'
+require 'opee/inspector'

data/lib/opee/actor.rb

@@ -40,6 +40,7 @@ module Opee
       @state = RUNNING
       @busy = false
       @name = nil
+      @proc_cnt = 0
       Env.add_actor(self)
       set_options(options)
       @loop = Thread.start(self) do |me|
@@ -67,6 +68,7 @@ module Opee
               end
               @busy = true
               send(a.op, *a.args) unless a.nil?
+              @proc_cnt += 1
               @busy = false
               if STEP == @state
                 @step_thread.wakeup() unless @step_thread.nil?
@@ -102,6 +104,21 @@ module Opee
       @loop[:name] = name
     end
 
+    def state_string()
+      ss = 'UNKNOWN'
+      case @state
+      when STOPPED
+        ss = 'STOPPED'
+      when RUNNING
+        ss = 'RUNNING'
+      when CLOSING
+        ss = 'CLOSING'
+      when STEP
+        ss = 'STEP'
+      end
+      ss
+    end
+
     # Calls {#ask}() but uses the specified timeout instead of the default
     # {#ask_timeout} to determine how long to wait if the Actor's queue is full.
     # @param [Fixnum|Float] timeout maximum time to wait trying to add a request to the Actor's queue
@@ -169,6 +186,19 @@ module Opee
       @queue.length + @priority.length + @idle.length
     end
 
+    # Returns a score indicating how backed up the queue is. This is used for
+    # selecting an Actor when stepping from the Inspector.
+    def backed_up()
+      cnt = @queue.size()
+      return 0 if 0 == cnt
+      if @max_queue_count.nil? || 0 == @max_queue_count
+        cnt = 80 if 80 < cnt
+        cnt
+      else
+        cnt * 100 / @max_queue_count
+      end
+    end
+
     # Returns the true if any requests are queued or a request is being processed.
     # @return [true|false] true if busy, false otherwise
     def busy?()
@@ -189,6 +219,12 @@ module Opee
       @max_queue_count
     end
 
+    # Returns the total number of requested processed.
+    # @return [Fixnum] number of request processed
+    def proc_count()
+      @proc_cnt
+    end
+
     # Causes the Actor to stop processing any more requests after the current
     # request has finished.
     def stop()

data/lib/opee/env.rb

@@ -62,7 +62,11 @@ module Opee
     def self.shutdown()
       until @@actors.empty?
         a = @@actors.pop()
-        a.close()
+        begin
+          a.close()
+        rescue Exception => e
+          puts "*** shutdown error #{e.class}: #{e.message}"
+        end
       end
       @@log = nil
     end
@@ -211,7 +215,7 @@ module Opee
       @@actors.each { |a| a.wakeup() }
       while busy?
         sleep(0.2) # actors should wake up when queue is empty
-        if Logger::DEBUG >= @@log.severity
+        if !@@log.nil? && Logger::DEBUG >= @@log.severity
           now = Time.now
           if next_time <= now
             log_status()
@@ -224,10 +228,16 @@ module Opee
     # Wakes up the calling thread when an Actor is finished. It is called by
     # the Actor and should not be called by any other code.
     def self.wake_finish()
-      @@finish_thread.wakeup() unless @@finish_thread.nil?
+      unless @@finish_thread.nil?
+        # if thread has already exited the an exception will be raised. Ignore it.
+        begin
+          @@finish_thread.wakeup() 
+        rescue
+        end
+      end
     end
 
-    # Waits until all Actors are not longer busy and then closes all Actors.
+    # Waits until all Actors are no longer busy and then closes all Actors.
     def self.wait_close()
       while 0 < queue_count()
         wait_finish()

data/lib/opee/inspector.rb

@@ -0,0 +1,363 @@
+
+require 'oterm'
+
+module Opee
+
+  class SocketInspector < ::OTerm::Executor
+
+    def initialize(port=6060)
+      super()
+      register('actor_count', self, :actor_count, 'Returns the number of active Actors.', nil)
+      register('actors', self, :actors, 'Displays a list of all Actor names.', nil)
+      register('busy', self, :busy, 'Returns the busy state of the system.', nil)
+      register('queued', self, :queued, 'Returns the total number of queued requests.', nil)
+      register('show', self, :show, '<actor name> Shows the details of an Actor.',
+               %|[<actor name>] Shows the details of an Actor. Attributes are:
+    name        - identifies the Actor
+    state       - state of the Actor [ STOPPED \| RUNNING \| STEP \| CLOSING ]
+    busy        - true if the Actor has requested queued
+    queued      - number of requested in the queue
+    max queue   - maximum number of requested that can be queued
+    ask timeout - seconds to wait before rejecting an ask
+|)
+      register('start', self, :start, '[<actor name>] Start or restart an Actor.', nil)
+      register('status', self, :status, 'Displays status of all Actors.',
+               %|Displays the Actor name and queued count. If the terminal supports real time
+updates the displays stays active until the X character is pressed. While running
+options are available for sorting on name, activity, or queue size.|)
+      register('step', self, :step, '[<actor name>] Step once.',
+               %|Step once for the actor specfified or once for some actor that is
+waiting if not actor is identified.
+|)
+      register('stop', self, :stop, '[<actor name>] Stops an Actor.', nil)
+      register('verbosity', self, :verbosity, '[<level>] Show or set the verbosity or log level.', nil)
+
+      @server = ::OTerm::Server.new(self, port, false)
+    end
+
+    def join()
+      @server.join()
+    end
+
+    def shutdown(listener, args)
+      super
+      Env.shutdown()
+    end
+
+    def greeting()
+      "Welcome to the Inspector."
+    end
+
+    def tab(cmd, listener)
+      start = cmd.index(' ')
+      if nil == start
+        super
+      else
+        op = cmd[0...start]
+        until cmd.size <= start || ' ' != cmd[start]
+          start += 1
+        end
+        arg = cmd[start..-1]
+
+        if 'show' == op || 'start' == op || 'step' == op || 'stop' == op
+          names = []
+          Env.each_actor { |a| names << a.name if a.name.start_with?(arg) }
+          return if 0 == names.size
+          if 1 == names.size
+            listener.move_col(1000)
+            listener.insert(names[0][arg.size..-1])
+            listener.out.prompt()
+            listener.out.p(listener.buf)
+          else
+            listener.out.pl()
+            names.each do |name|
+              listener.out.pl("#{op} #{name}")
+            end
+            best = best_completion(arg, names)
+            if best == arg
+              listener.update_cmd(0)
+            else
+              listener.move_col(1000)
+              listener.insert(best[arg.size..-1])
+              listener.out.prompt()
+              listener.out.p(listener.buf)
+            end
+          end
+        end
+      end
+    end
+
+    def actor_count(listener, args)
+      listener.out.pl("There are currently #{Opee::Env.actor_count()} active Actors.")
+    end
+
+    def actors(listener, args)
+      max = 0
+      ::Opee::Env.each_actor() do |a|
+        max = a.name.size if max < a.name.size
+      end
+      ::Opee::Env.each_actor() do |a|
+        listener.out.pl("  %1$*2$s: %3$s" % [a.name, -max, a.class.to_s])
+      end
+    end
+
+    def queued(listener, args)
+      listener.out.pl("There are currently #{Opee::Env.queue_count()} unprocessed requests queued.")
+    end
+
+    def busy(listener, args)
+      if Opee::Env.busy?()
+        listener.out.pl("One or more actors is busy.")
+      else
+        listener.out.pl("All actors are idle.")
+      end
+    end
+
+    def stop(listener, args)
+      if nil == args || 0 == args.size()
+        ::Opee::Env.stop()
+        listener.out.pl("All Actors stopped(paused)")
+      else
+        args.strip!
+        a = ::Opee::Env.find_actor(args)
+        if nil == a
+          listener.out.pl("--- Failed to find '#{args}'")
+        else
+          a.stop()
+          listener.out.pl("#{a.name} stopped(paused)")
+        end
+      end
+    end
+
+    def start(listener, args)
+      if nil == args || 0 == args.size()
+        ::Opee::Env.start()
+        listener.out.pl("All Actors restarted")
+      else
+        args.strip!
+        a = ::Opee::Env.find_actor(args)
+        if nil == a
+          listener.out.pl("--- Failed to find '#{args}'")
+        else
+          a.start()
+          listener.out.pl("#{a.name} started")
+        end
+      end
+    end
+
+    def step(listener, args)
+      la = ::Opee::Env.logger()
+      stop_after = false
+      if ::Opee::Actor::STOPPED == la.state
+        la.start()
+        stop_after = true
+      end
+      if nil == args || 0 == args.size()
+        ma = nil
+        mb = 0
+        ::Opee::Env.each_actor() do |a|
+          next unless ::Opee::Actor::STOPPED == a.state
+          if ma.nil?
+            ma = a
+            mb = ma.backed_up()
+          else
+            b = a.backed_up()
+            if mb < b
+              ma = a 
+              mb = b
+            end
+          end
+        end
+        unless ma.nil? || 0 == ma.queue_count()
+          ma.step()
+          listener.out.pl("#{ma.name} stepped")
+        end
+      else
+        a = ::Opee::Env.find_actor(args)
+        if nil == a
+          listener.out.pl("--- Failed to find '#{args}'")
+        else
+          a.step()
+          listener.out.pl("#{a.name} stepped")
+        end
+      end
+      la.stop() if stop_after
+    end
+
+    def verbosity(listener, args)
+      v = ::Opee::Env.logger.severity
+      if nil != args && 0 < args.size()
+        args.strip!
+        begin
+          v = ::Opee::Env.logger.severity = args
+        rescue Exception
+          listener.out.pl("'#{line}' is not a value verbosity")
+        end
+      end
+      listener.out.pl("verbosity: #{v}")
+    end
+
+    def show(listener, args)
+      if nil == args
+        listener.out.pl("--- No Actor specified")
+        return
+      end
+      a = ::Opee::Env.find_actor(args)
+      if nil == a
+        listener.out.pl("--- Failed to find '#{args}'")
+      else
+        args.strip!
+        listener.out.pl("#{a.name}:")
+        listener.out.pl("  state:           #{a.state_string()}")
+        listener.out.pl("  busy?:           #{a.busy?()}")
+        listener.out.pl("  queued count:    #{a.queue_count()}")
+        listener.out.pl("  max queue count: #{a.max_queue_count()}")
+        listener.out.pl("  ask timeout:     #{a.ask_timeout()}")
+      end
+    end
+
+    def status(listener, args)
+      if listener.out.is_vt100?
+        dynamic_status(listener)
+      else
+        listener.out.pl("  %20s  %-11s  %5s  %5s" % ['Actor Name', 'Q-cnt/max', 'busy?', 'processed'])
+        ::Opee::Env.each_actor() do |a|
+          listener.out.pl("  %20s  %5d/%-5d  %5s  %5d" % [a.name, a.queue_count(), a.max_queue_count().to_i, a.busy?(), a.proc_count()])
+        end
+      end
+    end
+
+    BY_NAME = 'n'
+    BY_ACTIVITY = 'a'
+    BY_QUEUE = 'q'
+
+    def dynamic_status(listener)
+      o = listener.out
+      actors = [] # ActorStat
+      sort_by = BY_NAME
+      rev = false
+      delay = 0.4
+      max = 6
+      ::Opee::Env.each_actor() do |a|
+        actors << ActorStat.new(a)
+        max = a.name.size if max < a.name.size
+      end
+      lines = actors.size + 2
+      h, w = o.screen_size()
+      lines = h - 2 if lines > h - 2
+      o.clear_screen()
+      max_q = w - max - 4
+      done = false
+      until done
+        actors.each { |as| as.refresh() }
+        case sort_by
+        when BY_NAME
+          if rev
+            actors.sort! { |a,b| b.name <=> a.name }
+          else
+            actors.sort! { |a,b| a.name <=> b.name }
+          end
+        when BY_ACTIVITY
+          if rev
+            actors.sort! { |a,b| a.activity <=> b.activity }
+          else
+            actors.sort! { |a,b| b.activity <=> a.activity }
+          end
+        when BY_QUEUE
+          if rev
+            actors.sort! { |a,b| a.queued <=> b.queued }
+          else
+            actors.sort! { |a,b| b.queued <=> a.queued }
+          end
+        end
+        o.set_cursor(1, 1)
+        o.bold()
+        o.p("%1$*2$s @ Queued" % ['Actor', -max])
+        o.attrs_off()
+        i = 2
+        actors[0..lines].each do |as|
+          o.set_cursor(i, 1)
+          o.p("%1$*2$s " % [as.name, -max])
+          o.set_cursor(i, max + 2)
+          case as.activity
+          when 0
+            o.p(' ')
+          when 1
+            o.p('.')
+          when 2, 3
+            o.p('o')
+          else
+            o.p('O')
+          end
+          o.p(' ')
+          qlen = as.queued
+          qlen = max_q if max_q < qlen
+          if 0 < qlen
+            o.reverse()
+            o.p("%1$*2$d" % [as.queued, -qlen])
+            o.attrs_off()
+          end
+          o.clear_to_end()
+          i += 1
+        end
+        o.set_cursor(i, 1)
+        o.bold()
+        o.p('E) exit  N) by name  A) by activity  Q) by queued  R) reverse  ')
+        o.graphic_font()
+        o.p(::OTerm::VT100::PLUS_MINUS)
+        o.default_font()
+        o.p(") faster/slower [%0.1f]" % [delay])
+        o.attrs_off()
+        c = o.recv_wait(1, delay, /./)
+        unless c.nil?
+          case c[0]
+          when 'e', 'E'
+            done = true
+          when 'n', 'N'
+            sort_by = BY_NAME
+            rev = false
+          when 'a', 'A'
+            sort_by = BY_ACTIVITY
+            rev = false
+          when 'q', 'Q'
+            sort_by = BY_QUEUE
+            rev = false
+          when 'r', 'R'
+            rev = !rev
+          when 'f', 'F', '+'
+            delay /= 2.0 unless delay <= 0.1
+          when 's', 'S', '-'
+            delay *= 2.0 unless 3.0 <= delay
+          end
+        end
+      end
+      o.pl()
+    end
+
+    class ActorStat
+      attr_reader :actor
+      attr_reader :queued
+      attr_reader :activity
+
+      def initialize(a)
+        @actor = a
+        @proc_cnt = a.proc_count()
+        @activity = 0
+        @queued = a.queue_count()
+      end
+
+      def refresh()
+        cnt = @actor.proc_count()
+        @activity = cnt - @proc_cnt
+        @proc_cnt = cnt
+        @queued = @actor.queue_count()
+      end
+
+      def name()
+        @actor.name
+      end
+
+    end # ActorStat
+
+  end # SocketInspector
+end # Opee

data/lib/opee/log.rb

@@ -125,8 +125,13 @@ module Opee
           'ERROR' => Logger::Severity::ERROR,
           'WARN' => Logger::Severity::WARN,
           'INFO' => Logger::Severity::INFO,
-          'DEBUG' => Logger::Severity::DEBUG
-        }[level]
+          'DEBUG' => Logger::Severity::DEBUG,
+          '4' => Logger::Severity::FATAL,
+          '3' => Logger::Severity::ERROR,
+          '2' => Logger::Severity::WARN,
+          '1' => Logger::Severity::INFO,
+          '0' => Logger::Severity::DEBUG
+        }[level.upcase()]
         raise "#{level} is not a severity" if severity.nil?
         level = severity
       elsif level < Logger::Severity::DEBUG || Logger::Severity::FATAL < level

data/lib/opee/version.rb

@@ -1,5 +1,5 @@
 
 module Opee
   # Current version of the module. 
-  VERSION = '1.0.4'
+  VERSION = '1.1.0'
 end

data/test/inspector_test.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+
+$: << File.join(File.dirname(__FILE__), "../../oterm/lib")
+
+require 'opee'
+
+
+inspector = Opee::SocketInspector.new(6060)
+inspector.join()

metadata

@@ -1,34 +1,51 @@
 --- !ruby/object:Gem::Specification
 name: opee
 version: !ruby/object:Gem::Version
-  version: 1.0.4
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-03 00:00:00.000000000 Z
-dependencies: []
-description: ! 'An experimental Object-base Parallel Evaluation Environment. '
+date: 2013-12-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oterm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'An experimental Object-base Parallel Evaluation Environment. '
 email: peter@ohler.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- LICENSE
+- README.md
+- lib/opee.rb
 - lib/opee/actor.rb
 - lib/opee/askqueue.rb
 - lib/opee/collector.rb
 - lib/opee/env.rb
 - lib/opee/errors.rb
+- lib/opee/inspector.rb
 - lib/opee/job.rb
 - lib/opee/log.rb
 - lib/opee/queue.rb
 - lib/opee/version.rb
 - lib/opee/workqueue.rb
-- lib/opee.rb
+- test/inspector_test.rb
 - test/relay.rb
 - test/tc_opee_actor.rb
 - test/tc_opee_collector.rb
@@ -36,33 +53,29 @@ files:
 - test/tc_opee_log.rb
 - test/tc_opee_workqueue.rb
 - test/ts_opee.rb
-- LICENSE
-- README.md
 homepage: http://www.ohler.com/opee
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: opee
-rubygems_version: 1.8.21
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: An experimental Object-base Parallel Evaluation Environment.
 test_files: []
-has_rdoc: true