concurrent-ruby 0.1.0 → 0.1.1.pre.1

data/lib/concurrent/reactor.rb

@@ -0,0 +1,162 @@
+require 'thread'
+require 'functional'
+require 'concurrent/smart_mutex'
+
+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 = SmartMutex.new
+    end
+
+    def add_handler(event, &block)
+      event = event.to_sym
+      raise ArgumentError.new("'#{event}' is a reserved event") if RESERVED_EVENTS.include?(event)
+      raise ArgumentError.new('no block given') unless block_given?
+      @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){ self.stop } }
+    end
+
+    def handle_event(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
+    alias_method :handle, :handle_event
+
+    def running?
+      return @running
+    end
+
+    def start
+      raise StandardError.new('already running') if self.running?
+      @sync ? (@running = true; run_sync) : (@running = true; run_async)
+    end
+
+    def stop
+      return unless self.running?
+      if @sync
+        @demux.stop
+      else
+        @queue.push(:stop)
+      end
+      return nil
+    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
+      atomic {
+        @running = false
+        @demux.stop unless @demux.nil?
+        @demux = nil
+      }
+    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/smart_mutex.rb

@@ -0,0 +1,66 @@
+require 'thread'
+require 'concurrent/utilities'
+
+module Concurrent
+
+  class SmartMutex
+
+    def initialize
+      @mutex = Mutex.new
+    end
+
+    def alone?
+      Thread.list.length <= 1
+    end
+
+    def lock
+      atomic do
+        @mutex.lock unless alone?
+        self
+      end
+    end
+
+    def locked?
+      atomic do
+        if alone?
+          false
+        else
+          @mutex.locked?
+        end
+      end
+    end
+
+    def sleep(timeout)
+      if alone?
+        Kernel.sleep(timeout)
+      else
+        @mutex.sleep(timeout)
+      end
+    end
+
+    def synchronize(&block)
+      if alone?
+        yield
+      else
+        @mutex.synchronize(&block)
+      end
+    end
+
+    def try_lock
+      atomic do
+        if alone?
+          true
+        else
+          @mutex.try_lock
+        end
+      end
+    end
+
+    def unlock
+      atomic do
+        @mutex.unlock unless alone?
+        self
+      end
+    end
+  end
+end

data/lib/concurrent/tcp_sync_demux.rb

@@ -0,0 +1,96 @@
+require 'socket'
+require 'drb/acl'
+require 'functional'
+require 'concurrent/reactor'
+
+module Concurrent
+
+  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

data/lib/concurrent/thread_pool.rb

@@ -1,61 +1,65 @@
-require 'functional/behavior'
-require 'concurrent/event'
-
-behavior_info(:thread_pool,
-              running?: 0,
-              shutdown?: 0,
-              killed?: 0,
-              shutdown: 0,
-              kill: 0,
-              size: 0,
-              wait_for_termination: -1,
-              post: -1,
-              :<< => 1,
-              status: 0)
-
-behavior_info(:global_thread_pool,
-              post: -1,
-              :<< => 1)
-
-module Concurrent
-
-  class ThreadPool
-
-    def initialize
-      @status = :running
-      @queue = Queue.new
-      @termination = Event.new
-      @pool = []
-    end
-
-    def running?
-      return @status == :running
-    end
-
-    def shutdown?
-      return ! running?
-    end
-
-    def killed?
-      return @status == :killed
-    end
-
-    def shutdown
-      @pool.size.times{ @queue << :stop }
-      @status = :shuttingdown
-    end
-
-    def wait_for_termination(timeout = nil)
-      if shutdown? || killed?
-        return true
-      else
-        return @termination.wait(timeout)
-      end
-    end
-
-    def <<(block)
-      self.post(&block)
-      return self
-    end
-  end
-end
+require 'functional/behavior'
+
+require 'concurrent/event'
+require 'concurrent/utilities'
+
+behavior_info(:thread_pool,
+              running?: 0,
+              shutdown?: 0,
+              killed?: 0,
+              shutdown: 0,
+              kill: 0,
+              size: 0,
+              wait_for_termination: -1,
+              post: -1,
+              :<< => 1,
+              status: 0)
+
+behavior_info(:global_thread_pool,
+              post: -1,
+              :<< => 1)
+
+module Concurrent
+
+  class ThreadPool
+
+    def initialize
+      @status = :running
+      @queue = Queue.new
+      @termination = Event.new
+      @pool = []
+    end
+
+    def running?
+      return @status == :running
+    end
+
+    def shutdown?
+      return ! running?
+    end
+
+    def killed?
+      return @status == :killed
+    end
+
+    def shutdown
+      atomic {
+        @pool.size.times{ @queue << :stop }
+        @status = :shuttingdown
+      }
+    end
+
+    def wait_for_termination(timeout = nil)
+      if shutdown? || killed?
+        return true
+      else
+        return @termination.wait(timeout)
+      end
+    end
+
+    def <<(block)
+      self.post(&block)
+      return self
+    end
+  end
+end