concurrent-ruby 0.2.0 → 0.2.1

data/lib/concurrent/reactor.rb

@@ -1,166 +1,166 @@
-require 'thread'
-require 'functional'
-require 'concurrent/supervisor'
-
-behavior_info(:sync_event_demux,
-              run: 0,
-              stop: 0,
-              running?: 0,
-              accept: 0,
-              respond: 2)
-
-behavior_info(:async_event_demux,
-              run: 0,
-              stop: 0,
-              running?: 0,
-              set_reactor: 1)
-
-behavior_info(:demux_reactor,
-              handle: -2)
-
-module Concurrent
-
-  class Reactor
-
-    behavior(:demux_reactor)
-    behavior(:runnable)
-
-    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 run
-      raise StandardError.new('already running') if self.running?
-      @sync ? (@running = true; run_sync) : (@running = true; run_async)
-    end
-    alias_method :run, :run
-
-    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.run
-
-      loop do
-        break unless @demux.running?
-        context = @demux.accept
-        begin
-          if context.nil?
-            @demux.stop
-          else
-            response = handle_event(context) do |result, message|
-              [result, message]
-            end
-            @demux.respond(*response)
-          end
-        rescue Exception => ex
-          @demux.respond(:abend, ex)
-        end
-      end
-
-      finalize_stop
-    end
-
-    def run_async
-      @demux.run 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
+require 'thread'
+require 'functional'
+require 'concurrent/supervisor'
+
+behavior_info(:sync_event_demux,
+              run: 0,
+              stop: 0,
+              running?: 0,
+              accept: 0,
+              respond: 2)
+
+behavior_info(:async_event_demux,
+              run: 0,
+              stop: 0,
+              running?: 0,
+              set_reactor: 1)
+
+behavior_info(:demux_reactor,
+              handle: -2)
+
+module Concurrent
+
+  class Reactor
+
+    behavior(:demux_reactor)
+    behavior(:runnable)
+
+    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 }.abort_on_exception = false}}
+    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 run
+      raise StandardError.new('already running') if self.running?
+      @sync ? (@running = true; run_sync) : (@running = true; run_async)
+    end
+    alias_method :run, :run
+
+    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.run
+
+      loop do
+        break unless @demux.running?
+        context = @demux.accept
+        begin
+          if context.nil?
+            @demux.stop
+          else
+            response = handle_event(context) do |result, message|
+              [result, message]
+            end
+            @demux.respond(*response)
+          end
+        rescue Exception => ex
+          @demux.respond(:abend, ex)
+        end
+      end
+
+      finalize_stop
+    end
+
+    def run_async
+      @demux.run 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,83 +1,83 @@
-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
+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