concurrent-ruby 0.2.2 → 0.3.0.pre.1

data/lib/concurrent/reactor/drb_async_demux.rb

@@ -1,83 +0,0 @@
-require 'drb/drb'
-require 'drb/acl'
-require 'functional'
-require 'concurrent/reactor'
-require 'concurrent/supervisor'
-
-module Concurrent
-  class Reactor
-
-    class DRbAsyncDemux
-
-      behavior(:async_event_demux)
-
-      DEFAULT_URI = 'druby://localhost:12345'
-      DEFAULT_ACL = %w{deny all allow 127.0.0.1}
-
-      attr_reader :uri
-      attr_reader :acl
-
-      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 run
-        raise StandardError.new('already running') if running?
-        DRb.install_acl(@acl)
-        @service = DRb.start_service(@uri, Demultiplexer.new(@reactor))
-      end
-
-      def stop
-        @service = DRb.stop_service
-      end
-
-      def running?
-        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|
-              begin
-                result = @reactor.handle(method, *args)
-              rescue Exception => ex
-                raise DRb::DRbRemoteError.new(ex)
-              end
-              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::DRbError.new("unexpected response from 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,131 +0,0 @@
-require 'socket'
-require 'drb/acl'
-require 'functional'
-require 'concurrent/reactor'
-require 'concurrent/supervisor'
-
-module Concurrent
-  class Reactor
-
-    class TcpSyncDemux
-
-      behavior(:sync_event_demux)
-
-      DEFAULT_HOST = '127.0.0.1'
-      DEFAULT_PORT = 12345
-      DEFAULT_ACL = %w{deny all allow 127.0.0.1}
-
-      attr_reader :host
-      attr_reader :port
-      attr_reader :acl
-
-      def initialize(opts = {})
-        @host = opts[:host] || DEFAULT_HOST
-        @port = opts[:port] || DEFAULT_PORT
-        @acl = ACL.new(opts[:acl] || DEFAULT_ACL)
-      end
-
-      def run
-        raise StandardError.new('already running') if running?
-        begin
-          @server = TCPServer.new(@host, @port)
-          return true
-        rescue Exception => ex
-          return false
-        end
-      end
-
-      def stop
-        begin
-          @socket.close unless @socket.nil?
-        rescue Exception => ex
-          # suppress
-        end
-
-        begin
-          @server.close unless @server.nil?
-        rescue Exception => ex
-          # suppress
-        end
-
-        @server = @socket = nil
-        return true
-      end
-
-      def reset
-        stop
-        sleep(1)
-        run
-      end
-
-      def running?
-        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)
-      rescue Exception => ex
-        reset
-        return nil
-      end
-
-      def respond(result, message)
-        return nil if @socket.nil?
-        @socket.puts(format_message(result, message))
-      rescue Exception => ex
-        reset
-      end
-
-      def self.format_message(event, *args)
-        event = event.to_s.strip
-        raise ArgumentError.new('nil or empty event') if event.empty?
-        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)
-        message = message.lines.map(&:chomp) if message.is_a?(String)
-        return [nil, []] if message.nil?
-        event = message.first.match(/^:?(\w+)/)
-        event = event[1].to_s.downcase.to_sym unless event.nil?
-        args = message.slice(1, message.length) || []
-        args.pop if args.last.nil? || args.last.empty?
-        return [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

data/lib/concurrent/utilities.rb

@@ -1,32 +0,0 @@
-module Kernel
-
-  # Perform the given block as though it were an atomic operation. This means
-  # that the Ruby scheduler cannot premept the block and context switch to
-  # another thread. Basically a light wrapper around Ruby's Fiber class.
-  #
-  # @note Be very careful about what operations you perform within an atomic
-  # block. Blocking operations such as I/O should *never* occur within an
-  # atomic block. In those cases the entire Ruby VM will lock until the
-  # blocking operation is complete. This would be bad.
-  #
-  # @yield calls the block
-  # @yieldparam args an arbitrary set of block arguments
-  #
-  # @param [Array] zero more more optional arguments to pass to the block
-  def atomic(*args)
-    raise ArgumentError.new('no block given') unless block_given?
-    return Fiber.new {
-      yield(*args)
-    }.resume
-  end
-  module_function :atomic
-end
-
-class Mutex
-
-  def sync_with_timeout(timeout, &block)
-    Timeout::timeout(timeout) {
-      synchronize(&block)
-    }
-  end
-end

data/md/defer.md

@@ -1,174 +0,0 @@
-# I Can't Think of a Movie or Music Reference for Defer
-
-In the pantheon of concurrency objects a `Defer` sits somewhere between `Future` and `Promise`.
-Inspired by [EventMachine's *defer* method](https://github.com/eventmachine/eventmachine/wiki/EM::Deferrable-and-EM.defer),
-a `Defer` can be considered a non-blocking `Future` or a simplified, non-blocking `Promise`. Defers run on the global thread pool.
-
-Unlike `Future` and `Promise` a defer is non-blocking. The deferred *operation* is performed on another
-thread. If the *operation* is successful an optional *callback* is called on the same thread as the *operation*.
-The result of the *operation* is passed to the *callbacl*. If the *operation* fails (by raising an exception)
-then an optional *errorback* (error callback) is called on the same thread as the *operation*. The raised
-exception is passed to the *errorback*. The calling thread is never aware of the result of the *operation*.
-This approach fits much more cleanly within an
-[event-driven](http://en.wikipedia.org/wiki/Event-driven_programming) application.
-
-The operation of a `Defer` can easily be simulated using either `Future` or `Promise` and traditional branching
-(if/then/else) logic. This approach works but it is more verbose and partitions the work across two threads.
-Whenever you find yourself checking the result of a `Future` or a `Promise` then branching based on the result,
-consider a `Defer` instead.
-
-For programmer convenience there are two syntaxes for creating and running a `Defer`. One is idiomatic of Ruby
-and uses chained method calls. The other is more isiomatic of [functional programming](http://en.wikipedia.org/wiki/Concurrentprogramming)
-and passes one or more `proc` objects as arguments. Do not mix syntaxes on a single `Defer` invocation.
-
-## Examples
-
-A simple `Defer` using idiomatic Ruby syntax:
-
-```ruby
-require 'concurrent'
-
-deferred = Concurrent::Defer.new{ puts 'w00t!' }
-# when using idiomatic syntax the #go method must be called
-deferred.go
-sleep(0.1)
-
-#=> 'w00t!'
-```
-
-A simple `Defer` using functional programming syntax:
-
-```ruby
-operation = proc{ puts 'w00t!' }
-Concurrent::Defer.new(operation) # NOTE: a call to #go is unnecessary
-sleep(0.1)
-
-#=> 'w00t!'
-
-defer(operation)
-sleep(0.1)
-
-#=> 'w00t!'
-```
-
-Adding a *callback*:
-
-```ruby
-Concurrent::Defer.new{ "Jerry D'Antonio" }.
-                  then{|result| puts "Hello, #{result}!" }.
-                  go
-
-#=> Hello, Jerry D'Antonio!
-
-operation = proc{ "Jerry D'Antonio" }
-callback = proc{|result| puts "Hello, #{result}!" }
-defer(operation, callback, nil)
-sleep(0.1)
-
-#=> Hello, Jerry D'Antonio!
-```
-
-Adding an *errorback*:
-
-```ruby
-Concurrent::Defer.new{ raise StandardError.new('Boom!') }.
-                  rescue{|ex| puts ex.message }.
-                  go
-sleep(0.1)
-
-#=> "Boom!"
-
-operation = proc{ raise StandardError.new('Boom!') }
-errorback = proc{|ex| puts ex.message }
-defer(operation, nil, errorback)
-
-#=> "Boom!"
-```
-
-Putting it all together:
-
-```ruby
-Concurrent::Defer.new{ "Jerry D'Antonio" }.
-                  then{|result| puts "Hello, #{result}!" }.
-                  rescue{|ex| puts ex.message }.
-                  go
-
-#=> Hello, Jerry D'Antonio!
-
-operation = proc{ raise StandardError.new('Boom!') }
-callback  = proc{|result| puts result }
-errorback = proc{|ex| puts ex.message }
-defer(operation, callback, errorback)
-sleep(0.1)
-
-#=> "Boom!"
-```
-
-Crossing the streams:
-
-```ruby
-operation = proc{ true }
-callback = proc{|result| puts result }
-errorback = proc{|ex| puts ex.message }
-
-Concurrent::Defer.new(operation, nil, nil){ false }
-#=> ArgumentError: two operations given
-
-defer(nil, callback, errorback)
-# => ArgumentError: no operation given
-
-Concurrent::Defer.new.go
-# => ArgumentError: no operation given
-
-defer(nil, nil, nil)
-# => ArgumentError: no operation given
-
-Concurrent::Defer.new(operation, nil, nil).
-                  then{|result| puts result }.
-                  go
-#=> Concurrent::IllegalMethodCallError: the defer is already running
-
-defer(callback, nil, nil).then{|result| puts result }
-#=> Concurrent::IllegalMethodCallError: the defer is already running
-
-Concurrent::Defer.new{ true }.
-                  then{|result| puts "Boom!" }.
-                  then{|result| puts "Bam!" }.
-                  go
-#=> Concurrent::IllegalMethodCallError: a callback has already been provided
-
-Concurrent::Defer.new{ raise StandardError }.
-                  rescue{|ex| puts "Boom!" }.
-                  rescue{|ex| puts "Bam!" }.
-                  go
-#=> Concurrent::IllegalMethodCallError: a errorback has already been provided
-```
-
-## Copyright
-
-*Concurrent Ruby* is Copyright © 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> Permission is hereby granted, free of charge, to any person obtaining a copy  
-> of this software and associated documentation files (the "Software"), to deal  
-> in the Software without restriction, including without limitation the rights  
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-> copies of the Software, and to permit persons to whom the Software is  
-> furnished to do so, subject to the following conditions:  
-> 
-> The above copyright notice and this permission notice shall be included in  
-> all copies or substantial portions of the Software.  
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-> THE SOFTWARE.  

data/spec/concurrent/defer_spec.rb

@@ -1,199 +0,0 @@
-require 'spec_helper'
-require_relative 'uses_global_thread_pool_shared'
-
-module Concurrent
-
-  describe Defer do
-
-    let!(:thread_pool_user){ Defer }
-    it_should_behave_like Concurrent::UsesGlobalThreadPool
-
-    before(:each) do
-      Defer.thread_pool = FixedThreadPool.new(1)
-    end
-
-    context '#initialize' do
-
-      it 'raises an exception if no block or operation given' do
-        lambda {
-          Defer.new
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'raises an exception if both a block and an operation given' do
-        lambda {
-          operation = proc{ nil }
-          Defer.new(op: operation){ nil }
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'starts the thread if an operation is given' do
-        Defer.thread_pool.should_receive(:post).once.with(any_args())
-        operation = proc{ nil }
-        Defer.new(op: operation)
-      end
-
-      it 'does not start the thread if neither a callback or errorback is given' do
-        Defer.thread_pool.should_not_receive(:post)
-        Defer.new{ nil }
-      end
-    end
-
-    context '#then' do
-
-      it 'raises an exception if no block given' do
-        lambda {
-          Defer.new{ nil }.then
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'raises an exception if called twice' do
-        lambda {
-          Defer.new{ nil }.then{|result| nil }.then{|result| nil }
-        }.should raise_error(IllegalMethodCallError)
-      end
-
-      it 'raises an exception if an operation was provided at construction' do
-        lambda {
-          operation = proc{ nil }
-          Defer.new(op: operation).then{|result| nil }
-        }.should raise_error(IllegalMethodCallError)
-      end
-
-      it 'raises an exception if a callback was provided at construction' do
-        lambda {
-          callback = proc{|result|nil }
-          Defer.new(callback: callback){ nil }.then{|result| nil }
-        }.should raise_error(IllegalMethodCallError)
-      end
-
-      it 'returns self' do
-        deferred = Defer.new{ nil }
-        deferred.then{|result| nil }.should eq deferred
-      end
-    end
-
-    context '#rescue' do
-
-      it 'raises an exception if no block given' do
-        lambda {
-          Defer.new{ nil }.rescue
-        }.should raise_error(ArgumentError)
-      end
-
-      it 'raises an exception if called twice' do
-        lambda {
-          Defer.new{ nil }.rescue{ nil }.rescue{ nil }
-        }.should raise_error(IllegalMethodCallError)
-      end
-
-      it 'raises an exception if an operation was provided at construction' do
-        lambda {
-          operation = proc{ nil }
-          Defer.new(op: operation).rescue{|ex| nil }
-        }.should raise_error(IllegalMethodCallError)
-      end
-
-      it 'raises an exception if an errorback was provided at construction' do
-        lambda {
-          errorback = proc{|ex| nil }
-          Defer.new(errorback: errorback){ nil }.rescue{|ex| nil }
-        }.should raise_error(IllegalMethodCallError)
-      end
-
-      it 'returns self' do
-        deferred = Defer.new{ nil }
-        deferred.rescue{|ex| nil }.should eq deferred
-      end
-
-      it 'aliases #catch' do
-        lambda {
-          Defer.new{ nil }.catch{|ex| nil }
-        }.should_not raise_error
-      end
-
-      it 'aliases #on_error' do
-        lambda {
-          Defer.new{ nil }.on_error{|ex| nil }
-        }.should_not raise_error
-      end
-    end
-
-    context '#go' do
-
-      it 'starts the thread if not started' do
-        deferred = Defer.new{ nil }
-        Defer.thread_pool.should_receive(:post).once.with(any_args())
-        deferred.go
-      end
-
-      it 'does nothing if called more than once' do
-        deferred = Defer.new{ nil }
-        deferred.go
-        Defer.thread_pool.should_not_receive(:post)
-        deferred.go
-      end
-
-      it 'does nothing if thread started at construction' do
-        operation = proc{ nil }
-        callback = proc{|result| nil }
-        errorback = proc{|ex| nil }
-        deferred = Defer.new(op: operation, callback: callback, errorback: errorback)
-        Defer.thread_pool.should_not_receive(:post)
-        deferred.go
-      end
-    end
-
-    context 'fulfillment' do
-
-      it 'runs the operation' do
-        @expected = false
-        Defer.new{ @expected = true }.go
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'calls the callback when the operation is successful' do
-        @expected = false
-        Defer.new{ true }.then{|result| @expected = true }.go
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'passes the result of the block to the callback' do
-        @expected = false
-        Defer.new{ 'w00t' }.then{|result| @expected = result }.go
-        sleep(0.1)
-        @expected.should eq 'w00t'
-      end
-
-      it 'does not call the errorback when the operation is successful' do
-        @expected = true
-        Defer.new{ nil }.rescue{|ex| @expected = false }.go
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'calls the errorback if the operation throws an exception' do
-        @expected = false
-        Defer.new{ raise StandardError }.rescue{|ex| @expected = true }.go
-        sleep(0.1)
-        @expected.should be_true
-      end
-
-      it 'passes the exception object to the errorback' do
-        @expected = nil
-        Defer.new{ raise StandardError }.rescue{|ex| @expected = ex }.go
-        sleep(0.1)
-        @expected.should be_a(StandardError)
-      end
-
-      it 'does not call the callback when the operation fails' do
-        @expected = true
-        Defer.new{ raise StandardError }.then{|result| @expected = false }.go
-        sleep(0.1)
-        @expected.should be_true
-      end
-    end
-  end
-end