iomultiplex 0.1.0

data/lib/iomultiplex/mixins/post.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+# Copyright 2014-2016 Jason Woods
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module IOMultiplex
+  module Mixins
+    # Post processing - used by OpenSSL etc to force a read until wait required
+    # in case there is buffered data
+    module Post
+      def defer(client)
+        post_process client, POST_DEFER
+      end
+
+      def force_read(client)
+        post_process client, POST_FORCE_READ
+      end
+
+      def remove_post(client)
+        @post_processing.delete client
+        return if @scheduled_post_processing.nil?
+        @scheduled_post_processing.delete client
+        nil
+      end
+
+      protected
+
+      POST_DEFER = 1
+      POST_FORCE_READ = 2
+
+      def initialize_post
+        @post_processing = {}
+        @scheduled_post_processing = nil
+      end
+
+      def schedule_post_processing
+        return false if @post_processing.empty?
+
+        # Run deferred after we finish this loop
+        # New defers then carry to next loop
+        @scheduled_post_processing = @post_processing
+        @post_processing = {}
+        true
+      end
+
+      def trigger_post_processing
+        return if @scheduled_post_processing.nil?
+
+        @scheduled_post_processing.each do |client, flag|
+          # During handle_read a handle_data happens so if we have both defer
+          # and read we also should use handle_read
+          if flag & POST_FORCE_READ != 0
+            log_debug 'Post processing', :client => client.id, :what => 'read'
+            client.handle_read
+          else
+            log_debug 'Post processing', :client => client.id, :what => 'defer'
+            client.handle_data
+          end
+        end
+
+        @scheduled_post_processing = nil
+      end
+
+      def post_process(client, flag)
+        current = @post_processing.key?(client) ? @post_processing[client] : nil
+        return if !current.nil? && current & flag != 0
+
+        log_debug 'Scheduled post processing',
+                  :client => client.id,
+                  :what => flag & POST_FORCE_READ != 0 ? 'read' : 'defer'
+
+        @post_processing[client] ||= 0
+        @post_processing[client] |= flag
+        nil
+      end
+    end # ::Post
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/select.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+# Copyright 2014-2016 Jason Woods
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'nio'
+
+module IOMultiplex
+  module Mixins
+    # IO Select mixin
+    # Depends on Mixins::State
+    module Select
+      def wait_read(client)
+        set_wait client, State::STATE_WAIT_READ, true
+      end
+
+      def wait_write(client)
+        set_wait client, State::STATE_WAIT_WRITE, true
+      end
+
+      def stop_read(client)
+        set_wait client, State::STATE_WAIT_READ, false
+      end
+
+      def stop_write(client)
+        set_wait client, State::STATE_WAIT_WRITE, false
+      end
+
+      def stop_all(client)
+        state = must_get_state(client)
+        return if \
+          state & (State::STATE_WAIT_READ | State::STATE_WAIT_WRITE) == 0
+
+        state = remove_state client,
+                             State::STATE_WAIT_READ | State::STATE_WAIT_WRITE
+        update_select client, state
+      end
+
+      protected
+
+      def initialize_select(options)
+        setup_select_logslow options if options[:log_slow]
+
+        @nio = NIO::Selector.new
+      end
+
+      def set_wait(client, flag, desired)
+        state = must_get_state(client)
+
+        if desired
+          return unless state & flag == 0
+          state = add_state(client, flag)
+        else
+          return if state & flag == 0
+          state = remove_state(client, flag)
+        end
+
+        update_select client, state
+        nil
+      end
+
+      def update_select(client, state)
+        @nio.deregister client.io
+
+        if state & State::STATE_WAIT_READ == 0 &&
+           state & State::STATE_WAIT_WRITE == 0
+          log_debug 'NIO::Select interest updated',
+                    :client => client.id, :interests => nil
+          return
+        elsif state & State::STATE_WAIT_READ == 0
+          interests = :w
+        elsif state & State::STATE_WAIT_WRITE == 0
+          interests = :r
+        else
+          interests = :rw
+        end
+
+        monitor = @nio.register(client.io, interests)
+        monitor.value = client
+        log_debug 'NIO::Select interest updated',
+                  :client => client.id, :interests => interests
+      end
+
+      def select_io(timeout)
+        log_debug 'NIO::Select enter', :timeout => timeout
+
+        @nio.select(timeout) do |monitor|
+          next if get_state(monitor.value).nil?
+          if monitor.readable?
+            log_debug 'NIO::Select signalling',
+                      :what => :read, :client => monitor.value.id
+            monitor.value.handle_read
+          end
+
+          # Check we didn't remove the socket before we call monitor.writable?
+          # otherwise it will throw a Java CancelledKeyException wrapped in
+          # NativeException because we tried to access a removed monitor
+          next if get_state(monitor.value).nil? || !monitor.writable?
+          log_debug 'NIO::Select signalling',
+                    :what => :write, :client => monitor.value.id
+          monitor.value.handle_write
+        end
+        nil
+      end
+
+      def setup_select_logslow
+        require 'iomultiplex/logslow.rb'
+        class <<self
+          extend LogSlow
+
+          private
+
+          alias_method :_orig_select_io, :select_io
+          define_method :select_io do |next_timer|
+            log_slow _orig_select_io, [next_timer], 100, _select_io_diagnostics
+          end
+
+          define_method :_select_io_diagnostics do
+            timeout = next_timer
+            if timeout.nil?
+              timer_due = 'None'
+              timer_delay = 'N/A'
+            else
+              timer_due = timeout.to_f.ceil
+              timer_delay = now > timer ? ((now - timeout) * 1000).to_i : 'None'
+            end
+            { :timer_due => timer_due, :timer_delay => timer_delay }
+          end
+        end # <<self
+        nil
+      end
+    end # ::Select
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/state.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+# Copyright 2014-2016 Jason Woods
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module IOMultiplex
+  module Mixins
+    # State handling methods
+    module State
+      protected
+
+      STATE_REGISTERED = 0
+      STATE_WAIT_READ = 1
+      STATE_WAIT_WRITE = 2
+      STATE_TIMER = 4
+
+      def initialize_state
+        @lookup = Hash.new do |h, k|
+          h[k] = STATE_REGISTERED
+        end
+      end
+
+      # Returns the state for a given client or throws an exception if it
+      # isn't registered
+      def must_get_state(client)
+        lookup = get_state client
+        raise ArgumentError, 'Client is not registered' if lookup.nil?
+        lookup
+      end
+
+      # Return the state for a given client
+      # Returns nil if the client is not registered
+      def get_state(client)
+        @lookup.key?(client) ? @lookup[client] : nil
+      end
+
+      # Adds a state flag for a client
+      # If the client is not registered, creates a registration
+      def add_state(client, flag)
+        @lookup[client] |= flag
+      end
+
+      # Removes a state flag for a client
+      # If the client is not registered, creates a registration
+      def remove_state(client, flag)
+        @lookup[client] ^= flag
+      end
+
+      # Register a client
+      def register_state(client)
+        raise ArgumentError, 'Client is already registered' if get_state(client)
+        @lookup[client]
+      end
+
+      # Deregister a client
+      def deregister_state(client)
+        @lookup.delete client
+      end
+
+      # Loop registered clients (non-timer clients)
+      def each_registered_client
+        @lookup.each do |client, state|
+          yield client unless state & STATE_REGISTERED == 0
+        end
+      end
+    end # ::State
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/timer.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+# Copyright 2014-2016 Jason Woods
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module IOMultiplex
+  module Mixins
+    # Timer handling methods
+    # Depends on Mixins::State
+    # TODO: We should use monotonic clock here!
+    module Timer
+      def add_timer(timer, at)
+        raise ArgumentError, 'Timer must response to "timer"' \
+          unless timer.respond_to? :timer
+
+        state = get_state(timer)
+        exists = state & State::STATE_TIMER != 0
+        @timers.delete [@timers_time[timer], timer] if exists
+
+        entry = [at, timer]
+        @timers.add entry
+        @timers_time[timer] = at
+
+        add_state timer, State::STATE_TIMER unless exists
+        nil
+      end
+
+      def remove_timer(timer)
+        state = must_get_state(timer)
+        return unless state & State::STATE_TIMER != 0
+
+        entry = [@timers_time[timer], timer]
+        remove_timer_state entry
+        nil
+      end
+
+      protected
+
+      def initialize_timers
+        @timers = SortedSet.new
+        @timers_time = {}
+      end
+
+      def next_timer
+        entry = @timers.first
+        entry.nil? ? nil : entry[0]
+      end
+
+      # Trigger available timers
+      def trigger_timers
+        return if @timers.empty?
+
+        now = Time.now
+        until @timers.empty?
+          entry = @timers.first
+          break if entry[0] > now
+          remove_timer_state entry
+          entry[1].timer
+        end
+
+        nil
+      end
+
+      # Remove a timer from the internal state
+      def remove_timer_state(entry)
+        timer = entry[1]
+        @timers.delete entry
+        @timers_time.delete timer
+
+        state = remove_state(timer, State::STATE_TIMER)
+        deregister_state timer if state == 0
+        nil
+      end
+    end # ::Timer
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/pool.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+# Copyright 2014-2016 Jason Woods
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# TODO: Refactor and finish
+
+require 'iomultiplex/mixins/logger'
+
+module IOMultiplex
+  # A pool of multiplexers amongst which incoming connections can be distributed
+  class MultiplexerPool
+    include Mixins::Logger
+
+    attr_reader :id
+
+    def initialize(options)
+      %w(num_workers).each do |k|
+        raise ArgumentError, "Required option missing: #{k}" \
+          unless options[k.to_sym]
+      end
+
+      initialize_logger options[:logger], options[:logger_context]
+
+      @id = options[:id] || object_id
+      add_logger_context 'multiplexer_pool', @id
+
+      @num_workers = options[:num_workers]
+      @queued_clients = []
+
+      reset_state
+    end
+
+    def start
+      raise 'Already started' unless @workers.empty?
+
+      @num_workers.times do |i|
+        @workers[i] = Multiplexer.new \
+          logger: logger,
+          logger_context: logger_context,
+          id: "Worker-#{i}"
+
+        @queues[i] = Queue.new
+
+        @threads[i] = Thread.new(@workers[i], &:run)
+      end
+
+      distribute_queued_clients
+      nil
+    end
+
+    def distribute(client)
+      return queue_client(client) if @workers.empty?
+
+      s = nil
+      c = 0
+      @workers.each_index do |i|
+        connections = @workers[i].connections
+        # TODO: Make customisable this maxmium
+        next unless connections < 1000 && (s.nil? || c > connections)
+        s = i
+        c = connections
+      end
+
+      return false if s.nil?
+      worker = @workers[s]
+
+      log_debug 'Distributing new client',
+                :client => client.id, :worker => worker.id
+      @queues[s] << client
+      worker.callback do
+        process s
+      end
+      true
+    end
+
+    def shutdown
+      raise 'Not started' if @workers.empty?
+
+      # Raise shutdown in all client threads and join then
+      @workers.each(&:shutdown)
+      @threads.each(&:join)
+
+      reset_state
+      nil
+    end
+
+    private
+
+    def reset_state
+      @workers = []
+      @queues = []
+      @threads = []
+    end
+
+    def queue_client(client)
+      @queued_clients << client
+      nil
+    end
+
+    def distribute_queued_clients
+      distribute @queued_clients.pop until @queued_clients.empty?
+      nil
+    end
+
+    def process(i)
+      # Sockets for the worker
+      log_debug 'Receiving new sockets', length: @queues[i].length
+      @workers[i].add @queues[i].pop until @queues[i].empty?
+      nil
+    end
+  end
+end