concurrent-ruby 0.1.0 → 0.1.1.pre.1

data/lib/concurrent/defer.rb

@@ -1,69 +1,67 @@
-require 'thread'
-
-require 'concurrent/global_thread_pool'
-
-module Concurrent
-
-  IllegalMethodCallError = Class.new(StandardError)
-
-  class Defer
-
-    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
-      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
-      $GLOBAL_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
-
-module Kernel
-
-  def defer(*args, &block)
-    return Concurrent::Defer.new(*args, &block)
-  end
-  module_function :defer
-end
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  IllegalMethodCallError = Class.new(StandardError)
+
+  class Defer
+
+    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(thread_pool)
+      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(thread_pool = nil)
+      return nil if @running
+      atomic {
+        thread_pool ||= $GLOBAL_THREAD_POOL
+        @running = true
+        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

data/lib/concurrent/drb_async_demux.rb

@@ -0,0 +1,72 @@
+require 'drb/drb'
+require 'drb/acl'
+require 'functional'
+require 'concurrent/reactor'
+
+module Concurrent
+
+  class DRbAsyncDemux
+
+    behavior(:async_event_demux)
+
+    DEFAULT_URI = 'druby://localhost:12345'
+    DEFAULT_ACL = %[allow all]
+
+    def initialize(opts = {})
+      @uri = opts[:uri] || DEFAULT_URI
+      @acl = ACL.new(opts[:acl] || DEFAULT_ACL)
+    end
+
+    def set_reactor(reactor)
+      raise ArgumentError.new('invalid reactor') unless reactor.behaves_as?(:demux_reactor)
+      @reactor = reactor
+    end
+
+    def start
+      DRb.install_acl(@acl)
+      @service = DRb.start_service(@uri, Demultiplexer.new(@reactor))
+    end
+
+    def stop
+      @service = DRb.stop_service
+    end
+
+    def stopped?
+      return @service.nil?
+    end
+
+    private
+
+    class Demultiplexer
+
+      def initialize(reactor)
+        @reactor = reactor
+      end
+
+      Concurrent::Reactor::RESERVED_EVENTS.each do |event|
+        define_method(event){|*args| false }
+      end
+
+      def method_missing(method, *args, &block)
+        (class << self; self; end).class_eval do
+          define_method(method) do |*args|
+            result = @reactor.handle(method, *args)
+            case result.first
+            when :ok
+              return result.last
+            when :ex
+              raise result.last
+            when :noop
+              raise NoMethodError.new("undefined method '#{method}' for #{self}")
+            else
+              raise DRb::DRbUnknownError.new("unexpected error when calling method '#{method}'")
+            end
+          end
+        end
+        self.send(method, *args)
+      end
+    end
+  end
+
+  DRbAsyncDemultiplexer = DRbAsyncDemux
+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

@@ -0,0 +1,87 @@
+require 'thread'
+
+module Concurrent
+
+  module Executor
+    extend self
+
+    class ExecutionContext
+      attr_reader :name
+      attr_reader :execution_interval
+      attr_reader :timeout_interval
+
+      def initialize(name, execution_interval, timeout_interval, thread)
+        @name = name
+        @execution_interval = execution_interval
+        @timeout_interval = timeout_interval
+        @thread = thread
+        @thread[:stop] = false
+      end
+
+      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
+        @thread.kill
+        @thread = nil
+      end
+      alias_method :terminate, :kill
+      alias_method :stop, :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