concurrent-ruby 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ace46fc451714785036604e4174b57f81ff2f3c6
-  data.tar.gz: f5278235efdd0cc59ae6645aace41c35ef61c8ef
+  metadata.gz: 336769e53b0dcf7aa0aa3952ca396deaabfd2886
+  data.tar.gz: a8f2de814918d3ab9849636741674d9731246c45
 SHA512:
-  metadata.gz: 48569321a92ec1304c60d425af98412f56dad24ce4fa6c17b149fa18cf40221df320a95ed806196a017a8f521c3d935433b02b626901ec28de5bac5ddcf92332
-  data.tar.gz: f5731e01e2a559c25d92d11f9c9693fafd8219aa681711962dc8d777a46198fb3e3c0d97e26461d4e4d05e3aad8c8cf8b6aee17fbb31441c83fb36bcc91da920
+  metadata.gz: 1f6696e6d00cc9126d247673a1f4cd90ec1ef822cd55c2fd30d45bf7b48f766fd6f0a712c884e68c9fe7e29dff005e501ed1299b9903502215f09db1a77dfd83
+  data.tar.gz: 5ad2e8367f7bca913db38ecfca31c77288e0029b624587c7196d0658e6d32fe8bb3709b33c7791c95e5c5b5dd494261e0b4130030718e8dbaf2fea9dc65fc5a8

data/README.md

@@ -55,6 +55,7 @@ Several features from Erlang, Go, Clojure, Java, and JavaScript have been implem
 * Go inspired [Goroutine](https://github.com/jdantonio/concurrent-ruby/blob/master/md/goroutine.md)
 * JavaScript inspired [Promise](https://github.com/jdantonio/concurrent-ruby/blob/master/md/promise.md)
 * Java inspired [Thread Pools](https://github.com/jdantonio/concurrent-ruby/blob/master/md/thread_pool.md)
+* Scheduled task execution with the [Executor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/executor.md) service
 
 ### Is it any good?
 
@@ -62,7 +63,11 @@ Several features from Erlang, Go, Clojure, Java, and JavaScript have been implem
 
 ### Supported Ruby versions
 
-Optimized for and tested under MRI Ruby 1.9.x and 2.0.
+MRI 1.9.2, 1.9.3, and 2.0. This library is pure Ruby and has minimal gem dependencies. It should be
+fully compatible with any Ruby interpreter that is 1.9.x compliant. I simply don't know enough
+about JRuby, Rubinius, or the others to fully support them. I can promise good karma and
+attribution on this page to anyone wishing to take responsibility for verifying compaitibility
+with any Ruby other than MRI.
 
 ### Install
 
@@ -84,6 +89,25 @@ Once you've installed the gem you must `require` it in your project:
 require 'concurrent'
 ```
 
+### Kernel Methods
+
+Many Ruby developers consider it bad form to add function to the global (Kernel) namespace.
+I don't necessarily agree. If the function acts like a low-level feature of the language
+I think it is OK to add the method to the `Kernel` module. To support my personal programming
+style I have chosen to implement `Kernel` methods to instance many of the objects in this
+library. Out of respect for the larger Ruby community I have made these methods optional.
+They are not imported with the normal `require 'concurrent'` directive. To import these
+functions you must import the `concurrent/functions` library.
+
+```ruby
+require 'concurrent'
+score = agent(10) #=> NoMethodError: undefined method `agent' for main:Object
+
+require 'concurrent/functions'
+score = agent(10) #=> #<Concurrent::Agent:0x35b2b28 ...
+score.value #=> 10
+```
+
 ### Examples
 
 For complete examples, see the specific documentation linked above. Below are a few examples to whet your appetite.
@@ -103,6 +127,7 @@ sleep(0.1)
 
 ```ruby
 require 'concurrent'
+require 'concurrent/functions'
 
 score = agent(10)
 score.value #=> 10
@@ -124,6 +149,7 @@ score.value #=> 170
 
 ```ruby
 require 'concurrent'
+require 'concurrent/functions'
 
 Concurrent::Defer.new{ "Jerry D'Antonio" }.
                   then{|result| puts "Hello, #{result}!" }.
@@ -145,6 +171,7 @@ sleep(0.1)
 
 ```ruby
 require 'concurrent'
+require 'concurrent/functions'
 
 count = future{ sleep(1); 10 }
 count.state #=> :pending
@@ -157,6 +184,7 @@ deref count #=> 10
 
 ```ruby
 require 'concurrent'
+require 'concurrent/functions'
 
 p = promise("Jerry", "D'Antonio"){|a, b| "#{a} #{b}" }.
     then{|result| "Hello #{result}." }.
@@ -190,6 +218,25 @@ sleep(1)
 @expected #=> 30
 ```
 
+#### Executor
+
+```ruby
+require 'concurrent'
+
+ec = Concurrent::Executor.run('Foo'){ puts 'Boom!' }
+
+ec.name               #=> "Foo"
+ec.execution_interval #=> 60 == Concurrent::Executor::EXECUTION_INTERVAL
+ec.timeout_interval   #=> 30 == Concurrent::Executor::TIMEOUT_INTERVAL
+ec.status             #=> "sleep"
+
+# wait 60 seconds...
+#=> 'Boom!'
+#=> ' INFO (2013-08-02 23:20:15) Foo: execution completed successfully'
+
+ec.kill #=> true
+```
+
 ## Contributing
 
 1. Fork it

data/lib/concurrent.rb

@@ -6,15 +6,22 @@ require 'concurrent/event'
 
 require 'concurrent/agent'
 require 'concurrent/defer'
+require 'concurrent/executor'
 require 'concurrent/future'
 require 'concurrent/goroutine'
-require 'concurrent/promise'
 require 'concurrent/obligation'
+require 'concurrent/promise'
+require 'concurrent/supervisor'
 require 'concurrent/utilities'
 
+require 'concurrent/reactor'
+require 'concurrent/reactor/drb_async_demux'
+require 'concurrent/reactor/tcp_sync_demux'
+
 require 'concurrent/thread_pool'
 require 'concurrent/cached_thread_pool'
 require 'concurrent/fixed_thread_pool'
+require 'concurrent/null_thread_pool'
 
 require 'concurrent/global_thread_pool'
 

data/lib/concurrent/agent.rb

@@ -14,6 +14,7 @@ module Concurrent
   # A good example of an agent is a shared incrementing counter, such as the score in a video game.
   class Agent
     include Observable
+    include UsesGlobalThreadPool
 
     TIMEOUT = 5
 
@@ -26,15 +27,20 @@ module Concurrent
       @rescuers = []
       @validator = nil
       @queue = Queue.new
+      @mutex = Mutex.new
 
-      $GLOBAL_THREAD_POOL << proc{ work }
+      Agent.thread_pool.post{ work }
     end
 
     def value(timeout = 0) return @value; end
     alias_method :deref, :value
 
     def rescue(clazz = Exception, &block)
-      @rescuers << Rescuer.new(clazz, block) if block_given?
+      if block_given?
+        @mutex.synchronize do
+          @rescuers << Rescuer.new(clazz, block)
+        end
+      end
       return self
     end
     alias_method :catch, :rescue
@@ -50,10 +56,10 @@ module Concurrent
 
     def post(&block)
       return @queue.length unless block_given?
-      return atomic {
+      return @mutex.synchronize do
         @queue << block
         @queue.length
-      }
+      end
     end
 
     def <<(block)
@@ -62,7 +68,7 @@ module Concurrent
     end
 
     def length
-      @queue.length
+      return @queue.length
     end
     alias_method :size, :length
     alias_method :count, :length
@@ -76,7 +82,9 @@ module Concurrent
 
     # @private
     def try_rescue(ex) # :nodoc:
-      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
+      rescuer = @mutex.synchronize do
+        @rescuers.find{|r| ex.is_a?(r.clazz) }
+      end
       rescuer.block.call(ex) if rescuer
     rescue Exception => e
       # supress
@@ -85,18 +93,17 @@ module Concurrent
     # @private
     def work # :nodoc:
       loop do
-        Thread.pass
         handler = @queue.pop
         begin
-          result = Timeout.timeout(@timeout){
+          result = Timeout.timeout(@timeout) do
             handler.call(@value)
-          }
+          end
           if @validator.nil? || @validator.call(result)
-            atomic {
+            @mutex.synchronize do
               @value = result
               changed
-            }
-            notify_observers(Time.now, @value)
+              notify_observers(Time.now, @value)
+            end
           end
         rescue Exception => ex
           try_rescue(ex)
@@ -105,31 +112,3 @@ module Concurrent
     end
   end
 end
-
-module Kernel
-
-  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
-    return Concurrent::Agent.new(initial, timeout)
-  end
-  module_function :agent
-
-  def deref(agent, timeout = nil)
-    if agent.respond_to?(:deref)
-      return agent.deref(timeout)
-    elsif agent.respond_to?(:value)
-      return agent.deref(timeout)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-
-  def post(agent, &block)
-    if agent.respond_to?(:post)
-      return agent.post(&block)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-end

data/lib/concurrent/cached_thread_pool.rb

@@ -24,12 +24,11 @@ module Concurrent
       @thread_idletime = (opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME).freeze
       super()
       @working = 0
-      @mutex = Mutex.new
     end
 
     def kill
       @status = :killed
-      @mutex.synchronize do
+      mutex.synchronize do
         @pool.each{|t| Thread.kill(t.thread) }
       end
     end
@@ -42,7 +41,7 @@ module Concurrent
       raise ArgumentError.new('no block given') unless block_given?
       if running?
         collect_garbage if @pool.empty?
-        @mutex.synchronize do
+        mutex.synchronize do
           if @working >= @pool.length
             create_worker_thread
           end
@@ -56,7 +55,7 @@ module Concurrent
 
     # @private
     def status # :nodoc:
-      @mutex.synchronize do
+      mutex.synchronize do
         @pool.collect do |worker|
           [
             worker.status,
@@ -80,31 +79,31 @@ module Concurrent
         loop do
           task = @queue.pop
 
-          atomic {
+          mutex.synchronize do
             @working += 1
             me.status = :working
-          }
+          end
 
           if task == :stop
             me.status = :stopping
             break
           else
             task.last.call(*task.first)
-            atomic {
+            mutex.synchronize do
               @working -= 1
               me.status = :idle
               me.idletime = timestamp
-            }
+            end
           end
         end
 
-        atomic {
+        mutex.synchronize do
           @pool.delete(me)
           if @pool.empty?
             @termination.set
             @status = :shutdown unless killed?
           end
-        }
+        end
       end
 
       @pool << worker
@@ -115,7 +114,7 @@ module Concurrent
       @collector = Thread.new do
         loop do
           sleep(@gc_interval)
-          @mutex.synchronize do
+          mutex.synchronize do
             @pool.reject! do |worker|
               worker.thread.status.nil? ||
                 (worker.status == :idle && @thread_idletime >= delta(worker.idletime, timestamp))

data/lib/concurrent/defer.rb

@@ -7,14 +7,18 @@ module Concurrent
   IllegalMethodCallError = Class.new(StandardError)
 
   class Defer
+    include UsesGlobalThreadPool
+
+    def initialize(opts = {}, &block)
+      operation = opts[:op] || opts[:operation]
+      @callback = opts[:cback] || opts[:callback]
+      @errorback = opts[:eback] || opts[:error] || opts[:errorback]
+      thread_pool = opts[:pool] || opts[:thread_pool]
 
-    def initialize(operation = nil, callback = nil, errorback = nil, &block)
       raise ArgumentError.new('no operation given') if operation.nil? && ! block_given?
       raise ArgumentError.new('two operations given') if ! operation.nil? && block_given?
 
       @operation = operation || block
-      @callback = callback
-      @errorback = errorback
 
       if operation.nil?
         @running = false
@@ -44,7 +48,7 @@ module Concurrent
     def go
       return nil if @running
       @running = true
-      $GLOBAL_THREAD_POOL.post { Thread.pass; fulfill }
+      Defer.thread_pool.post { fulfill }
       return nil
     end
 
@@ -59,11 +63,3 @@ module Concurrent
     end
   end
 end
-
-module Kernel
-
-  def defer(*args, &block)
-    return Concurrent::Defer.new(*args, &block)
-  end
-  module_function :defer
-end

data/lib/concurrent/executor.rb

@@ -0,0 +1,95 @@
+require 'thread'
+
+module Concurrent
+
+  module Executor
+    extend self
+
+    class ExecutionContext
+      attr_reader :name
+      attr_reader :execution_interval
+      attr_reader :timeout_interval
+
+      protected
+
+      def initialize(name, execution_interval, timeout_interval, thread)
+        @name = name
+        @execution_interval = execution_interval
+        @timeout_interval = timeout_interval
+        @thread = thread
+        @thread[:stop] = false
+      end
+
+      public
+
+      def status
+        return @thread.status unless @thread.nil?
+      end
+
+      def join(limit = nil)
+        if @thread.nil?
+          return nil
+        elsif limit.nil?
+          return @thread.join
+        else
+          return @thread.join(limit)
+        end
+      end
+
+      def stop
+        @thread[:stop] = true
+      end
+
+      def kill
+        unless @thread.nil?
+          stop
+          Thread.kill(@thread)
+          @thread = nil
+        end
+      end
+      alias_method :terminate, :kill
+    end
+
+    EXECUTION_INTERVAL = 60
+    TIMEOUT_INTERVAL = 30
+
+    STDOUT_LOGGER = proc do |name, level, msg|
+      print "%5s (%s) %s: %s\n" % [level.upcase, Time.now.strftime("%F %T"), name, msg]
+    end
+
+    def run(name, opts = {})
+      raise ArgumentError.new('no block given') unless block_given?
+
+      execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
+      run_now = opts[:now] || opts[:run_now] || false
+      logger = opts[:logger] || STDOUT_LOGGER
+      block_args = opts[:args] || opts [:arguments] || []
+
+      executor = Thread.new(*block_args) do |*args|
+        sleep(execution_interval) unless run_now == true
+        loop do
+          break if Thread.current[:stop]
+          begin
+            worker = Thread.new{ yield(*args) }
+            worker.abort_on_exception = false
+            if worker.join(timeout_interval).nil?
+              logger.call(name, :warn, "execution timed out after #{timeout_interval} seconds")
+            else
+              logger.call(name, :info, 'execution completed successfully')
+            end
+          rescue Exception => ex
+            logger.call(name, :error, "execution failed with error '#{ex}'")
+          ensure
+            Thread.kill(worker)
+            worker = nil
+          end
+          break if Thread.current[:stop]
+          sleep(execution_interval)
+        end
+      end
+
+      return ExecutionContext.new(name, execution_interval, timeout_interval, executor)
+    end
+  end
+end