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

data/lib/concurrent.rb

@@ -11,16 +11,17 @@ require 'concurrent/future'
 require 'concurrent/goroutine'
 require 'concurrent/promise'
 require 'concurrent/obligation'
-require 'concurrent/reactor'
 require 'concurrent/smart_mutex'
 require 'concurrent/utilities'
 
-require 'concurrent/drb_async_demux'
-require 'concurrent/tcp_sync_demux'
+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

@@ -1,6 +1,7 @@
 require 'observer'
 require 'thread'
 
+require 'concurrent/global_thread_pool'
 require 'concurrent/utilities'
 
 module Concurrent
@@ -13,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,7 +28,7 @@ module Concurrent
       @validator = nil
       @queue = Queue.new
 
-      @thread = Thread.new{ work }
+      Agent.thread_pool.post{ work }
     end
 
     def value(timeout = 0) return @value; end

data/lib/concurrent/defer.rb

@@ -7,6 +7,7 @@ module Concurrent
   IllegalMethodCallError = Class.new(StandardError)
 
   class Defer
+    include UsesGlobalThreadPool
 
     def initialize(opts = {}, &block)
       operation = opts[:op] || opts[:operation]
@@ -22,7 +23,7 @@ module Concurrent
       if operation.nil?
         @running = false
       else
-        self.go(thread_pool)
+        self.go
       end
     end
 
@@ -44,12 +45,11 @@ module Concurrent
     alias_method :catch, :rescue
     alias_method :on_error, :rescue
 
-    def go(thread_pool = nil)
+    def go
       return nil if @running
       atomic {
-        thread_pool ||= $GLOBAL_THREAD_POOL
         @running = true
-        thread_pool.post { Thread.pass; fulfill }
+        Defer.thread_pool.post { Thread.pass; fulfill }
       }
       return nil
     end

data/lib/concurrent/executor.rb

@@ -10,6 +10,8 @@ module Concurrent
       attr_reader :execution_interval
       attr_reader :timeout_interval
 
+      protected
+
       def initialize(name, execution_interval, timeout_interval, thread)
         @name = name
         @execution_interval = execution_interval
@@ -18,6 +20,8 @@ module Concurrent
         @thread[:stop] = false
       end
 
+      public
+
       def status
         return @thread.status unless @thread.nil?
       end

data/lib/concurrent/functions.rb

@@ -12,11 +12,11 @@ module Kernel
   end
   module_function :agent
 
-  def post(agent, &block)
-    if agent.respond_to?(:post)
-      return agent.post(&block)
+  def post(object, &block)
+    if object.respond_to?(:post)
+      return object.post(&block)
     else
-      return nil
+      raise ArgumentError.new('object does not support #post')
     end
   end
   module_function :post
@@ -44,53 +44,53 @@ module Kernel
 
   ## obligation
 
-  def deref(obligation, timeout = nil)
-    if obligation.respond_to?(:deref)
-      return obligation.deref(timeout)
-    elsif obligation.respond_to?(:value)
-      return obligation.deref(timeout)
+  def deref(object, timeout = nil)
+    if object.respond_to?(:deref)
+      return object.deref(timeout)
+    elsif object.respond_to?(:value)
+      return object.value(timeout)
     else
-      return nil
+      raise ArgumentError.new('object does not support #deref')
     end
   end
   module_function :deref
 
-  def pending?(obligation)
-    if obligation.respond_to?(:pending?)
-      return obligation.pending?
+  def pending?(object)
+    if object.respond_to?(:pending?)
+      return object.pending?
     else
-      return false
+      raise ArgumentError.new('object does not support #pending?')
     end
   end
   module_function :pending?
 
-  def fulfilled?(obligation)
-    if obligation.respond_to?(:fulfilled?)
-      return obligation.fulfilled?
-    elsif obligation.respond_to?(:realized?)
-      return obligation.realized?
+  def fulfilled?(object)
+    if object.respond_to?(:fulfilled?)
+      return object.fulfilled?
+    elsif object.respond_to?(:realized?)
+      return object.realized?
     else
-      return false
+      raise ArgumentError.new('object does not support #fulfilled?')
     end
   end
   module_function :fulfilled?
 
-  def realized?(obligation)
-    if obligation.respond_to?(:realized?)
-      return obligation.realized?
-    elsif obligation.respond_to?(:fulfilled?)
-      return obligation.fulfilled?
+  def realized?(object)
+    if object.respond_to?(:realized?)
+      return object.realized?
+    elsif object.respond_to?(:fulfilled?)
+      return object.fulfilled?
     else
-      return false
+      raise ArgumentError.new('object does not support #realized?')
     end
   end
   module_function :realized?
 
-  def rejected?(obligation)
-    if obligation.respond_to?(:rejected?)
-      return obligation.rejected?
+  def rejected?(object)
+    if object.respond_to?(:rejected?)
+      return object.rejected?
     else
-      return false
+      raise ArgumentError.new('object does not support #rejected?')
     end
   end
   module_function :rejected?

data/lib/concurrent/future.rb

@@ -8,22 +8,17 @@ module Concurrent
 
   class Future
     include Obligation
+    include UsesGlobalThreadPool
+
     behavior(:future)
 
     def initialize(*args, &block)
-      if args.first.behaves_as?(:global_thread_pool)
-        thread_pool = args.first
-        args = args.slice(1, args.length)
-      else
-        thread_pool = $GLOBAL_THREAD_POOL
-      end
-
       unless block_given?
         @state = :fulfilled
       else
         @value = nil
         @state = :pending
-        thread_pool.post do
+        Future.thread_pool.post(*args) do
           Thread.pass
           work(*args, &block)
         end

data/lib/concurrent/global_thread_pool.rb

@@ -1,3 +1,16 @@
 require 'concurrent/cached_thread_pool'
 
 $GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new
+
+module Concurrent
+
+  module UsesGlobalThreadPool
+
+    def self.included(base)
+      class << base
+        attr_accessor :thread_pool
+      end
+      base.thread_pool = $GLOBAL_THREAD_POOL
+    end
+  end
+end

data/lib/concurrent/null_thread_pool.rb

@@ -0,0 +1,22 @@
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  class NullThreadPool
+    behavior(:global_thread_pool)
+
+    def self.post(*args, &block)
+      Thread.new(*args, &block)
+      return true
+    end
+
+    def post(*args, &block)
+      return NullThreadPool.post(*args, &block)
+    end
+
+    def <<(block)
+      NullThreadPool.post(&block)
+      return self
+    end
+  end
+end

data/lib/concurrent/promise.rb

@@ -1,5 +1,6 @@
 require 'thread'
 
+require 'concurrent/global_thread_pool'
 require 'concurrent/obligation'
 require 'concurrent/utilities'
 
@@ -7,6 +8,8 @@ module Concurrent
 
   class Promise
     include Obligation
+    include UsesGlobalThreadPool
+
     behavior(:future)
     behavior(:promise)
 
@@ -90,15 +93,6 @@ module Concurrent
     # @private
     Rescuer = Struct.new(:clazz, :block)
 
-    # @private
-    def root # :nodoc:
-      return atomic {
-        current = self
-        current = current.parent until current.root?
-        current
-      }
-    end
-
     # @private
     def root? # :nodoc:
       @parent.nil?
@@ -148,7 +142,7 @@ module Concurrent
 
     # @private
     def realize(*args) # :nodoc:
-      Thread.new(@chain, @mutex, args) do |chain, mutex, args|
+      Promise.thread_pool.post(@chain, @mutex, args) do |chain, mutex, args|
         result = args.length == 1 ? args.first : args
         index = 0
         loop do

data/lib/concurrent/reactor/drb_async_demux.rb

@@ -0,0 +1,74 @@
+require 'drb/drb'
+require 'drb/acl'
+require 'functional'
+require 'concurrent/reactor'
+
+module Concurrent
+  class Reactor
+
+    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
+end

data/lib/concurrent/reactor/tcp_sync_demux.rb

@@ -0,0 +1,98 @@
+require 'socket'
+require 'drb/acl'
+require 'functional'
+require 'concurrent/reactor'
+
+module Concurrent
+  class Reactor
+
+    class TcpSyncDemux
+
+      behavior(:sync_event_demux)
+
+      DEFAULT_HOST = '127.0.0.1'
+      DEFAULT_PORT = 12345
+      DEFAULT_ACL = %[allow all]
+
+      def initialize(opts = {})
+        @host = opts[:host] || DEFAULT_HOST
+        @port = opts[:port] || DEFAULT_PORT
+        @acl = ACL.new(opts[:acl] || DEFAULT_ACL)
+      end
+
+      def start
+        @server = TCPServer.new(@host, @port)
+      end
+
+      def stop
+        atomic {
+          @socket.close unless @socket.nil?
+          @server.close unless @server.nil?
+          @server = @socket = nil
+        }
+      end
+
+      def stopped?
+        return @server.nil?
+      end
+
+      def accept
+        @socket = @server.accept if @socket.nil?
+        return nil unless @acl.allow_socket?(@socket)
+        event, args = get_message(@socket)
+        return nil if event.nil?
+        return Reactor::EventContext.new(event, args)
+      end
+
+      def respond(result, message)
+        return nil if @socket.nil?
+        @socket.puts(format_message(result, message))
+      end
+
+      def close
+        @socket.close
+        @socket = nil
+      end
+
+      def self.format_message(event, *args)
+        args = args.reduce('') do |memo, arg|
+          memo << "#{arg}\r\n"
+        end
+        return ":#{event}\r\n#{args}\r\n"
+      end
+      def format_message(*args) self.class.format_message(*args); end
+
+      def self.parse_message(message)
+        return atomic {
+          event = message.first.match /^:?(\w+)/
+          event = event[1].to_s.downcase.to_sym unless event.nil?
+
+          args = message.slice(1, message.length) || []
+
+          [event, args]
+        }
+      end
+      def parse_message(*args) self.class.parse_message(*args); end
+
+      def self.get_message(socket)
+        message = []
+        while line = socket.gets
+          if line.nil? || (line = line.strip).empty?
+            break
+          else
+            message << line
+          end
+        end
+
+        if message.empty?
+          return nil
+        else
+          return parse_message(message)
+        end
+      end
+      def get_message(*args) self.class.get_message(*args); end
+    end
+
+    TcpSyncDemultiplexer = TcpSyncDemux
+  end
+end