iomultiplex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e3ac2bf50945d2563b5ba09b1343fdb23dcdeff5
+  data.tar.gz: 68c237d349ea45972799c40028ceeb4d03fa4e2a
+SHA512:
+  metadata.gz: 3a32b0d814b4de29daa438646e88dcde578003dadea981c604e5fe4069f30a2bf9e8224f2f2035a4d5f1b0d937d7f1a8d706ce67f2e373fb5d2096bb69a68d53
+  data.tar.gz: 3f94d132f6d4d62208a9b0295b6cf462901d39292326f08280429c93a206bb1b14c97bff14d21bad281223a9c3be38e303ed01bd73d5cab1d566c7a52dfc813c

data/lib/iomultiplex.rb

@@ -0,0 +1,26 @@
+# 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 'cabin'
+require 'iomultiplex/mixins/callback'
+require 'iomultiplex/mixins/logslow'
+require 'iomultiplex/mixins/post'
+require 'iomultiplex/mixins/select'
+require 'iomultiplex/mixins/state'
+require 'iomultiplex/mixins/timer'
+require 'iomultiplex/iomultiplex'
+require 'iomultiplex/ioreactor'
+require 'iomultiplex/tcplistener'

data/lib/iomultiplex/iomultiplex.rb

@@ -0,0 +1,126 @@
+# 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
+  # A single multiplexer that can process hundreds of clients in a single thread
+  class Multiplexer
+    include Mixins::Logger
+    include Mixins::State
+    include Mixins::Select
+    include Mixins::Post
+    include Mixins::Timer
+    include Mixins::Callback
+
+    attr_reader :id
+
+    def initialize(options = {})
+      @mutex = Mutex.new
+      @connections = 0
+
+      initialize_logger options[:logger], options[:logger_context]
+
+      initialize_state
+      initialize_select options
+      initialize_post
+      initialize_timers
+      initialize_callbacks
+
+      @id = options[:id] || object_id
+      add_logger_context 'multiplexer', @id
+      nil
+    end
+
+    def run
+      run_once until @shutdown
+
+      log_debug 'Shutdown'
+
+      # Forced shutdown
+      each_registered_client(&:force_close)
+      nil
+    end
+
+    def add(client)
+      raise ArgumentError,
+            'Client must be an instance of IOMultiplex::IOReactor' \
+            unless client.is_a? IOReactor
+      raise ArgumentError,
+            'Client is already attached' \
+            unless get_state(client).nil?
+
+      register_state client
+      client.attach self
+
+      @mutex.synchronize do
+        @connections += 1
+      end
+      nil
+    end
+
+    def remove(client)
+      must_get_state(client)
+
+      @mutex.synchronize do
+        @connections -= 1
+      end
+
+      client.detach
+      stop_all client
+      remove_post client
+      remove_timer client
+      deregister_state client
+      nil
+    end
+
+    def connections
+      @mutex.synchronize do
+        @connections
+      end
+    end
+
+    def shutdown
+      @shutdown = true
+      @nio.wakeup
+      nil
+    end
+
+    protected
+
+    def run_once
+      # If post processing is scheduled, do not block on select
+      # Otherwise, only block until next timer
+      # And if no timers, bock indefinitely
+      timeout = nil
+      if schedule_post_processing
+        timeout = 0
+      else
+        timeout = next_timer
+        unless timeout.nil?
+          timeout = (timeout - Time.now).ceil
+          timeout = 0 if timeout < 0
+        end
+      end
+
+      select_io timeout
+
+      trigger_post_processing
+
+      # Trigger callbacks and timers
+      trigger_callbacks
+      trigger_timers
+    end
+  end
+end

data/lib/iomultiplex/ioreactor.rb

@@ -0,0 +1,118 @@
+# 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 'iomultiplex/mixins/ioreactor/read'
+require 'iomultiplex/mixins/ioreactor/write'
+require 'iomultiplex/stringbuffer'
+
+module IOMultiplex
+  # IOReactor - reactor style wrapper around IO objects
+  class IOReactor
+    include Mixins::Logger
+    include Mixins::IOReactor::Read
+    include Mixins::IOReactor::Write
+
+    attr_reader :id
+    attr_reader :io
+    attr_reader :mode
+    attr_reader :peer
+
+    def initialize(io, mode = 'rw', id = nil)
+      @io = io
+      @multiplexer = nil
+      @attached = false
+      @close_scheduled = false
+      @eof_scheduled = false
+      @exception = nil
+
+      @r = mode.index('r').nil? ? false : true
+      @w = mode.index('w').nil? ? false : true
+
+      if @r
+        @read_buffer = StringBuffer.new
+        @pause = false
+      end
+      if @w
+        @write_buffer = StringBuffer.new
+        @write_immediately = true
+      end
+
+      @id = id || calculate_id
+      nil
+    end
+
+    def addr
+      @io.addr
+    end
+
+    def peeraddr
+      @io.peeraddr
+    end
+
+    def attach(multiplexer)
+      raise ArgumentError, 'Socket is already attached' if @attached
+
+      @multiplexer = multiplexer
+      initialize_logger multiplexer.logger, multiplexer.logger_context.dup
+      add_logger_context 'client', @id
+
+      @multiplexer.wait_read self if @r
+
+      @attached = true
+      nil
+    end
+
+    def detach
+      raise ArgumentError, 'Socket is not yet attached' unless @attached
+      @attached = false
+      nil
+    end
+
+    def close
+      @read_buffer.reset
+      if !@w
+        @close_scheduled = true
+      else
+        force_close
+      end
+      nil
+    end
+
+    def force_close
+      @multiplexer.remove self
+      @io.close unless @io.closed?
+      nil
+    end
+
+    protected
+
+    def calculate_id
+      if @io.respond_to?(:peeraddr)
+        begin
+          peer = @io.peeraddr(:numeric)
+          # IPv4 format
+          return "#{peer[2]}:#{peer[1]}" if peer[2].index(':').nil?
+          # IPv6 format
+          return "[#{peer[2]}]:#{peer[1]}"
+        rescue NotImplementedError, Errno::ENOTCONN
+          return @io.inspect
+        end
+      end
+
+      @io.inspect
+    end
+  end # ::IOReactor
+end # ::IOMultiplex

data/lib/iomultiplex/ioreactor/buffered.rb

@@ -0,0 +1,55 @@
+# 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 'iomultiplex/ioreactor'
+
+module IOMultiplex
+  class IOReactor
+    # Wraps around a buffered IO object
+    # When the read signal triggers for the IO object, it will continuously read
+    # in the main loops post processing until it receives a WaitReadable signal.
+    # This ensures any data left in the IO buffer after a read is correctly read
+    # without waiting for a read signal
+    class Buffered < IOReactor
+      def initialize(io, mode = 'rw', id = nil)
+        super io, mode, id
+      end
+
+      protected
+
+      def do_read
+        read_action
+      rescue IO::WaitReadable, Errno::EINTR, Errno::EAGAIN
+        @wait_readable = true
+      else
+        @wait_readable = false
+      end
+
+      def schedule_read
+        @multiplexer.defer self unless @read_buffer.empty?
+
+        # Keep forcing reads until we hit a WaitReadable, in case there is
+        # buffered data in the IO
+        if @wait_readable
+          @multiplexer.wait_read self
+        else
+          @multiplexer.stop_read self
+          @multiplexer.force_read self
+        end
+      end
+    end # ::Buffered
+  end # ::IOReactor
+end # ::IOMultiplex

data/lib/iomultiplex/ioreactor/openssl.rb

@@ -0,0 +1,91 @@
+# 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 'iomultiplex/ioreactor/buffered'
+require 'iomultiplex/mixins/openssl'
+
+module IOMultiplex
+  class IOReactor
+    # Wraps an OpenSSL IO object which receives TLS connections
+    class OpenSSL < Buffered
+      include Mixins::OpenSSL
+
+      def initialize(io, _ = nil, id = nil, ssl_ctx = nil)
+        # OpenSSL is implicitly read/write due to key-exchange so we ignore the
+        # mode parameter
+        super io, 'rw', id
+        initialize_ssl ssl_ctx
+      end
+
+      protected
+
+      def read_nonblock(n)
+        ssl_read_nonblock n
+      end
+
+      def write_nonblock(data)
+        ssl_write_nonblock data
+      end
+
+      def read_action
+        return super if @handshake_completed
+
+        process_handshake
+        super
+      end
+    end # ::OpenSSL
+
+    # OpenSSLUpgrading wraps an IO object that acts like a regular
+    # IOReactor but can be upgraded to a TLS connection mid-connection
+    class OpenSSLUpgrading < Buffered
+      include Mixins::OpenSSL
+
+      def initialize(io, _ = nil, id = nil)
+        # OpenSSL is implicitly read/write due to key-exchange so we ignore the
+        # mode parameter
+        super io, 'rw', id
+        @ssl_enabled = false
+      end
+
+      def start_ssl(ssl_ctx)
+        raise 'SSL already started', nil if @ssl_enabled
+        initialize_ssl ssl_ctx
+        @ssl_enabled = true
+        log_debug 'Upgrading connection to SSL'
+        nil
+      end
+
+      private
+
+      def read_nonblock(n)
+        return super(n) unless @ssl_enabled
+        ssl_read_nonblock n
+      end
+
+      def write_nonblock(data)
+        return super(data) unless @ssl_enabled
+        ssl_write_nonblock data
+      end
+
+      def read_action
+        return super unless @ssl_enabled && !@handshake_completed
+
+        process_handshake
+        super
+      end
+    end # ::OpenSSLUpgrading
+  end # ::IOReactor
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/callback.rb

@@ -0,0 +1,44 @@
+# 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
+    # Callback methods
+    # Depends on Mixins::State
+    module Callback
+      # Run a callback on the IO thread
+      # Can be safely triggered from any thread
+      def callback(&block)
+        @callbacks.push block
+        @nio.wakeup
+        nil
+      end
+
+      protected
+
+      def initialize_callbacks
+        @callbacks = []
+      end
+
+      def trigger_callbacks
+        return if @callbacks.empty?
+        @callbacks.each(&:call)
+        @callbacks = []
+        nil
+      end
+    end # ::Callback
+  end # ::Mixins
+end # ::IOMultiplex