concurrent-ruby 0.1.1.pre.5 → 0.1.1

data/lib/concurrent/functions.rb

@@ -1,120 +0,0 @@
-require 'concurrent/agent'
-require 'concurrent/defer'
-require 'concurrent/future'
-require 'concurrent/promise'
-
-module Kernel
-
-  ## agent
-
-  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
-    return Concurrent::Agent.new(initial, timeout)
-  end
-  module_function :agent
-
-  def post(object, &block)
-    if object.respond_to?(:post)
-      return object.post(&block)
-    else
-      raise ArgumentError.new('object does not support #post')
-    end
-  end
-  module_function :post
-
-  ## defer
-
-  def defer(*args, &block)
-    return Concurrent::Defer.new(*args, &block)
-  end
-  module_function :defer
-
-  ## executor
-
-  def executor(*args, &block)
-    return Concurrent::Executor.run(*args, &block)
-  end
-  module_function :executor
-
-  ## future
-
-  def future(*args, &block)
-    return Concurrent::Future.new(*args, &block)
-  end
-  module_function :future
-
-  ## obligation
-
-  def deref(object, timeout = nil)
-    if object.respond_to?(:deref)
-      return object.deref(timeout)
-    elsif object.respond_to?(:value)
-      return object.value(timeout)
-    else
-      raise ArgumentError.new('object does not support #deref')
-    end
-  end
-  module_function :deref
-
-  def pending?(object)
-    if object.respond_to?(:pending?)
-      return object.pending?
-    else
-      raise ArgumentError.new('object does not support #pending?')
-    end
-  end
-  module_function :pending?
-
-  def fulfilled?(object)
-    if object.respond_to?(:fulfilled?)
-      return object.fulfilled?
-    elsif object.respond_to?(:realized?)
-      return object.realized?
-    else
-      raise ArgumentError.new('object does not support #fulfilled?')
-    end
-  end
-  module_function :fulfilled?
-
-  def realized?(object)
-    if object.respond_to?(:realized?)
-      return object.realized?
-    elsif object.respond_to?(:fulfilled?)
-      return object.fulfilled?
-    else
-      raise ArgumentError.new('object does not support #realized?')
-    end
-  end
-  module_function :realized?
-
-  def rejected?(object)
-    if object.respond_to?(:rejected?)
-      return object.rejected?
-    else
-      raise ArgumentError.new('object does not support #rejected?')
-    end
-  end
-  module_function :rejected?
-
-  ## promise
-
-  # Creates a new promise object. "A promise represents the eventual
-  # value returned from the single completion of an operation."
-  # Promises can be chained in a tree structure where each promise
-  # has zero or more children. Promises are resolved asynchronously
-  # in the order they are added to the tree. Parents are guaranteed
-  # to be resolved before their children. The result of each promise
-  # is passes to each of its children when the child resolves. When
-  # a promise is rejected all its children will be summarily rejected.
-  # A promise added to a rejected promise will immediately be rejected.
-  # A promise that is neither resolved or rejected is pending.
-  #
-  # @param args [Array] zero or more arguments for the block
-  # @param block [Proc] the block to call when attempting fulfillment
-  #
-  # @see Promise
-  # @see http://wiki.commonjs.org/wiki/Promises/A
-  def promise(*args, &block)
-    return Concurrent::Promise.new(*args, &block)
-  end
-  module_function :promise
-end

data/lib/concurrent/null_thread_pool.rb

@@ -1,22 +0,0 @@
-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/reactor.rb

@@ -1,161 +0,0 @@
-require 'thread'
-require 'functional'
-
-behavior_info(:sync_event_demux,
-              start: 0,
-              stop: 0,
-              stopped?: 0,
-              accept: 0,
-              respond: 2,
-              close: 0)
-
-behavior_info(:async_event_demux,
-              start: 0,
-              stop: 0,
-              stopped?: 0,
-              set_reactor: 1)
-
-behavior_info(:demux_reactor,
-              handle: -2)
-
-module Concurrent
-
-  class Reactor
-
-    behavior(:demux_reactor)
-
-    RESERVED_EVENTS = [ :stop ]
-
-    EventContext = Struct.new(:event, :args, :callback)
-
-    def initialize(demux = nil)
-      @demux = demux
-      if @demux.nil? || @demux.behaves_as?(:async_event_demux)
-        @sync = false
-        @queue = Queue.new
-        @demux.set_reactor(self) unless @demux.nil?
-      elsif @demux.behaves_as?(:sync_event_demux)
-        @sync = true
-      else
-        raise ArgumentError.new("invalid event demultiplexer '#{@demux}'")
-      end
-
-      @running = false
-      @handlers = Hash.new
-      @mutex = Mutex.new
-    end
-
-    def running?
-      return @running
-    end
-
-    def add_handler(event, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      event = event.to_sym
-      raise ArgumentError.new("'#{event}' is a reserved event") if RESERVED_EVENTS.include?(event)
-      @mutex.synchronize {
-        @handlers[event] = block
-      }
-      return true
-    end
-
-    def remove_handler(event)
-      handler = @mutex.synchronize {
-        @handlers.delete(event.to_sym)
-      }
-      return ! handler.nil?
-    end
-
-    def stop_on_signal(*signals)
-      signals.each{|signal| Signal.trap(signal){ Thread.new{ self.stop }}}
-    end
-
-    def handle(event, *args)
-      raise NotImplementedError.new("demultiplexer '#{@demux.class}' is synchronous") if @sync 
-      return [:stopped, 'reactor not running'] unless running?
-      context = EventContext.new(event.to_sym, args.dup, Queue.new)
-      @queue.push(context)
-      return context.callback.pop
-    end
-
-    def start
-      raise StandardError.new('already running') if self.running?
-      @sync ? (@running = true; run_sync) : (@running = true; run_async)
-    end
-    alias_method :run, :start
-
-    def stop
-      return true unless self.running?
-      if @sync
-        @demux.stop
-      else
-        @queue.push(:stop)
-      end
-      return true
-    end
-
-    private
-
-    def handle_event(context)
-      raise ArgumentError.new('no block given') unless block_given?
-
-      handler = @mutex.synchronize {
-        @handlers[context.event]
-      }
-
-      if handler.nil?
-        response = yield(:noop, "'#{context.event}' handler not found")
-      else
-        begin
-          result = handler.call(*context.args)
-          response = yield(:ok, result)
-        rescue Exception => ex
-          response = yield(:ex, ex)
-        end
-      end
-
-      return response
-    end
-
-    def finalize_stop
-      @mutex.synchronize do
-        @running = false
-        @demux.stop unless @demux.nil?
-        @demux = nil
-      end
-    end
-
-    def run_sync
-      @demux.start
-
-      loop do
-        break if @demux.stopped?
-        context = @demux.accept
-        if context.nil?
-          @demux.close
-        else
-          response = handle_event(context) do |result, message|
-            [result, message]
-          end
-          @demux.respond(*response)
-        end
-      end
-
-      finalize_stop
-    end
-
-    def run_async
-      @demux.start unless @demux.nil?
-
-      loop do
-        context = @queue.pop
-        break if context == :stop
-        handle_event(context) do |result, message|
-          context.callback.push([result, message])
-        end
-      end
-
-      finalize_stop
-    end
-  end
-end

data/lib/concurrent/reactor/drb_async_demux.rb

@@ -1,74 +0,0 @@
-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 = %w[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

@@ -1,98 +0,0 @@
-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