concurrent-ruby 0.1.1.pre.3 → 0.1.1.pre.4

data/lib/concurrent/defer.rb

@@ -1,67 +1,65 @@
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-
-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]
-
-      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
-
-      if operation.nil?
-        @running = false
-      else
-        self.go
-      end
-    end
-
-    def then(&block)
-      raise IllegalMethodCallError.new('a callback has already been provided') unless @callback.nil?
-      raise IllegalMethodCallError.new('the defer is already running') if @running
-      raise ArgumentError.new('no block given') unless block_given?
-      @callback = block
-      return self
-    end
-
-    def rescue(&block)
-      raise IllegalMethodCallError.new('a errorback has already been provided') unless @errorback.nil?
-      raise IllegalMethodCallError.new('the defer is already running') if @running
-      raise ArgumentError.new('no block given') unless block_given?
-      @errorback = block
-      return self
-    end
-    alias_method :catch, :rescue
-    alias_method :on_error, :rescue
-
-    def go
-      return nil if @running
-      atomic {
-        @running = true
-        Defer.thread_pool.post { Thread.pass; fulfill }
-      }
-      return nil
-    end
-
-    private
-
-    # @private
-    def fulfill # :nodoc:
-      result = @operation.call
-      @callback.call(result) unless @callback.nil?
-    rescue Exception => ex
-      @errorback.call(ex) unless @errorback.nil?
-    end
-  end
-end
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+
+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]
+
+      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
+
+      if operation.nil?
+        @running = false
+      else
+        self.go
+      end
+    end
+
+    def then(&block)
+      raise IllegalMethodCallError.new('a callback has already been provided') unless @callback.nil?
+      raise IllegalMethodCallError.new('the defer is already running') if @running
+      raise ArgumentError.new('no block given') unless block_given?
+      @callback = block
+      return self
+    end
+
+    def rescue(&block)
+      raise IllegalMethodCallError.new('a errorback has already been provided') unless @errorback.nil?
+      raise IllegalMethodCallError.new('the defer is already running') if @running
+      raise ArgumentError.new('no block given') unless block_given?
+      @errorback = block
+      return self
+    end
+    alias_method :catch, :rescue
+    alias_method :on_error, :rescue
+
+    def go
+      return nil if @running
+      @running = true
+      Defer.thread_pool.post { fulfill }
+      return nil
+    end
+
+    private
+
+    # @private
+    def fulfill # :nodoc:
+      result = @operation.call
+      @callback.call(result) unless @callback.nil?
+    rescue Exception => ex
+      @errorback.call(ex) unless @errorback.nil?
+    end
+  end
+end

data/lib/concurrent/event.rb

@@ -1,60 +1,60 @@
-require 'thread'
-require 'timeout'
-
-module Concurrent
-
-  class Event
-
-    def initialize
-      @set = false
-      @notifier = Queue.new
-      @mutex = Mutex.new
-      @waiting = 0
-    end
-
-    def set?
-      return @set == true
-    end
-
-    def set(pulse = false)
-      return true if set?
-      @mutex.synchronize {
-        @set = true
-        while @waiting > 0
-          @notifier << :set
-          @waiting -= 1
-        end
-        @set = ! pulse
-      }
-      return true
-    end
-
-    def reset
-      @mutex.synchronize {
-        @set = false
-      }
-      return true
-    end
-
-    def pulse
-      return set(true)
-    end
-
-    def wait(timeout = nil)
-      return true if set?
-
-      if timeout.nil?
-        @waiting += 1
-        @notifier.pop
-      else
-        Timeout::timeout(timeout) do
-          @waiting += 1
-          @notifier.pop
-        end
-      end
-      return true
-    rescue Timeout::Error
-      return false
-    end
-  end
-end
+require 'thread'
+require 'timeout'
+
+module Concurrent
+
+  class Event
+
+    def initialize
+      @set = false
+      @notifier = Queue.new
+      @mutex = Mutex.new
+      @waiting = 0
+    end
+
+    def set?
+      return @set == true
+    end
+
+    def set(pulse = false)
+      return true if set?
+      @mutex.synchronize {
+        @set = true
+        while @waiting > 0
+          @notifier << :set
+          @waiting -= 1
+        end
+        @set = ! pulse
+      }
+      return true
+    end
+
+    def reset
+      @mutex.synchronize {
+        @set = false
+      }
+      return true
+    end
+
+    def pulse
+      return set(true)
+    end
+
+    def wait(timeout = nil)
+      return true if set?
+
+      if timeout.nil?
+        @waiting += 1
+        @notifier.pop
+      else
+        Timeout::timeout(timeout) do
+          @waiting += 1
+          @notifier.pop
+        end
+      end
+      return true
+    rescue Timeout::Error
+      return false
+    end
+  end
+end

data/lib/concurrent/event_machine_defer_proxy.rb

@@ -1,23 +1,23 @@
-require 'concurrent/global_thread_pool'
-
-module Concurrent
-
-  class EventMachineDeferProxy
-    behavior(:global_thread_pool)
-
-    def post(*args, &block)
-      if args.empty?
-        EventMachine.defer(block)
-      else
-        new_block = proc{ block.call(*args) }
-        EventMachine.defer(new_block)
-      end
-      return true
-    end
-
-    def <<(block)
-      EventMachine.defer(block)
-      return self
-    end
-  end
-end
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  class EventMachineDeferProxy
+    behavior(:global_thread_pool)
+
+    def post(*args, &block)
+      if args.empty?
+        EventMachine.defer(block)
+      else
+        new_block = proc{ block.call(*args) }
+        EventMachine.defer(new_block)
+      end
+      return true
+    end
+
+    def <<(block)
+      EventMachine.defer(block)
+      return self
+    end
+  end
+end

data/lib/concurrent/executor.rb

@@ -1,95 +1,93 @@
-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?
-          atomic do
-            stop
-            Thread.kill(@thread)
-            @thread = nil
-          end
-        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
-      logger = opts[:logger] || STDOUT_LOGGER
-      block_args = opts[:args] || opts [:arguments] || []
-
-      executor = Thread.new(*block_args) do |*args|
-        loop do
-          sleep(execution_interval)
-          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]
-        end
-      end
-
-      return ExecutionContext.new(name, execution_interval, timeout_interval, executor)
-    end
-  end
-end
+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
+      logger = opts[:logger] || STDOUT_LOGGER
+      block_args = opts[:args] || opts [:arguments] || []
+
+      executor = Thread.new(*block_args) do |*args|
+        loop do
+          sleep(execution_interval)
+          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]
+        end
+      end
+
+      return ExecutionContext.new(name, execution_interval, timeout_interval, executor)
+    end
+  end
+end