concurrent-ruby 0.1.1 → 0.2.0

data/lib/concurrent/reactor.rb

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

data/lib/concurrent/reactor/drb_async_demux.rb

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

data/lib/concurrent/reactor/tcp_sync_demux.rb

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

@@ -0,0 +1,100 @@
+require 'thread'
+require 'functional'
+
+behavior_info(:runnable,
+              run: 0,
+              stop: 0,
+              running?: 0)
+
+module Concurrent
+
+  class Supervisor
+
+    DEFAULT_MONITOR_INTERVAL = 1
+
+    behavior(:runnable)
+
+    WorkerContext = Struct.new(:worker, :thread)
+
+    attr_reader :monitor_interval
+
+    def initialize(opts = {})
+      @mutex = Mutex.new
+      @workers = []
+      @running = false
+      @monitor = nil
+      @monitor_interval = opts[:monitor] || opts[:monitor_interval] || DEFAULT_MONITOR_INTERVAL
+      add_worker(opts[:worker]) unless opts[:worker].nil?
+    end
+
+    def run!
+      raise StandardError.new('already running') if running?
+      @running = true
+      @monitor = Thread.new{ monitor }
+      Thread.pass
+    end
+
+    def run
+      raise StandardError.new('already running') if running?
+      @running = true
+      monitor
+    end
+
+    def stop
+      return true unless running?
+      @running = false
+      @mutex.synchronize do
+        Thread.kill(@monitor) unless @monitor.nil?
+        @monitor = nil
+
+        until @workers.empty?
+          context = @workers.pop
+          begin
+            context.worker.stop
+            Thread.pass
+          rescue Exception => ex
+            # suppress
+          ensure
+            Thread.kill(context.thread) unless context.thread.nil?
+          end
+        end
+      end
+    end
+
+    def running?
+      return @running
+    end
+
+    def length
+      return @workers.length
+    end
+    alias_method :size, :length
+
+    def add_worker(worker)
+      if worker.nil? || running? || ! worker.behaves_as?(:runnable)
+        return false
+      else
+        @mutex.synchronize {
+          @workers << WorkerContext.new(worker)
+        }
+        return true
+      end
+    end
+
+    private
+
+    def monitor
+      loop do
+        @mutex.synchronize do
+          @workers.each do |context|
+            unless context.thread && context.thread.alive?
+              context.thread = Thread.new{ context.worker.run }
+              context.thread.abort_on_exception = false
+            end
+          end
+        end
+        sleep(@monitor_interval)
+      end
+    end
+    end
+  end