iomultiplex 0.1.0

data/lib/iomultiplex/mixins/ioreactor/read.rb

@@ -0,0 +1,180 @@
+# 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
+  class NotEnoughData < StandardError; end
+
+  module Mixins
+    module IOReactor
+      # Read mixin for IOReactor
+      module Read
+        # TODO: Make these customisable?
+        READ_BUFFER_MAX = 16_384
+        READ_SIZE = 16_384
+
+        def handle_read
+          begin
+            do_read
+          rescue EOFError, IOError, Errno::ECONNRESET => e
+            read_exception e
+          end
+
+          handle_data
+          nil
+        end
+
+        def handle_data
+          @was_read_full = read_full?
+          process unless @read_buffer.empty?
+          nil
+        rescue NotEnoughData
+          return send_eof if @eof_scheduled
+
+          # Allow overfilling of the read buffer in the event
+          # read(>=READ_BUFFER_MAX) was called
+          reschedule_read true
+        else
+          return send_eof if @eof_scheduled && @read_buffer.empty?
+
+          reschedule_read
+        end
+
+        def read(n)
+          raise 'Socket is not attached' unless @attached
+          raise IOError, 'Socket is closed' if @io.closed?
+          raise NotEnoughData, 'Not enough data', nil if @read_buffer.length < n
+
+          @read_buffer.read n
+        end
+
+        def discard
+          @read_buffer.reset
+          nil
+        end
+
+        # Pause read processing
+        # Takes effect on the next reschedule, which occurs after each read
+        # processing takes place
+        def pause
+          return if @pause
+          log_debug 'pause read'
+          @pause = true
+          nil
+        end
+
+        # Resume read processing
+        def resume
+          return unless @pause
+          log_debug 'resume read'
+          @pause = false
+          reschedule_read
+          nil
+        end
+
+        def read_full?
+          @read_buffer.length >= READ_BUFFER_MAX
+        end
+
+        protected
+
+        def do_read
+          read_action
+        rescue IO::WaitReadable, Errno::EINTR, Errno::EAGAIN
+          return
+        end
+
+        def send_eof
+          unless @exception.nil?
+            exception @exception if respond_to?(:exception)
+            force_close
+            return
+          end
+
+          eof if respond_to?(:eof)
+          close
+          nil
+        end
+
+        # To balance threads, process is allowed to return without processing
+        # all data, and will get called again after one round even if read not
+        # ready again. This allows us to spread processing more evenly if the
+        # processor is smart
+        # If the read buffer is >=4096 we can also skip read polling otherwise
+        # we will add another 4096 bytes and not process it as fast as we are
+        # adding the data
+        # Also, allow the processor to pause read which has the same effect -
+        # it is expected a timer or something will then resume read - this can
+        # be if the client is waiting on a background thread
+        # NOTE: Processor should be careful, if it processes nothing this can
+        #       cause a busy loop
+        def reschedule_read(overfill = false)
+          if @pause
+            @multiplexer.stop_read self
+            return
+          end
+
+          if read_full? && !overfill
+            # Stop reading, the buffer is too full, let the processor catch up
+            log_info 'Holding read due to full read buffer'
+            @multiplexer.stop_read self
+            @multiplexer.defer self
+            return
+          end
+
+          # Only schedule read if write isn't full - this allows us to drain
+          # write buffer before reading again and prevents a client from sending
+          # large amounts of data without receiving responses
+          if @w && write_full?
+            log_info 'Holding read due to full write buffer'
+            @multiplexer.stop_read self
+            return
+          end
+
+          schedule_read
+        end
+
+        # Schedules the next read action, can be overrided if necessary to
+        # change how the next read should be scheduled
+        def schedule_read
+          @multiplexer.defer self unless @read_buffer.empty?
+
+          # Resume read signal if we had paused due to full buffer
+          @multiplexer.wait_read self if @was_read_full
+
+          nil
+        end
+
+        # Can be overridden for other IO objects
+        def read_nonblock(n)
+          log_debug 'read_nonblock', count: n
+          @io.read_nonblock(n)
+        end
+
+        # Can be overriden for other IO objects
+        def read_action
+          @read_buffer << read_nonblock(READ_SIZE)
+          nil
+        end
+
+        def read_exception(e)
+          @eof_scheduled = true
+          @exception = e unless e.is_a?(EOFError)
+          @multiplexer.stop_read self
+        end
+      end # ::Read
+    end # ::IOReactor
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/ioreactor/write.rb

@@ -0,0 +1,109 @@
+# 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
+    module IOReactor
+      # Write mixin for IOReactor
+      module Write
+        # TODO: Make these customisable?
+        WRITE_BUFFER_MAX = 16_384
+        WRITE_SIZE = 4_096
+
+        def handle_write
+          begin
+            do_write
+          rescue IOError, Errno::ECONNRESET => e
+            write_exception e
+          end
+
+          nil
+        end
+
+        def write(data)
+          raise 'Socket is not attached' unless @attached
+          raise IOError, 'Socket is closed' if @io.closed?
+
+          @write_buffer.push data
+          handle_write if @write_immediately
+
+          # Write buffer too large - pause read polling
+          if @r && write_full?
+            log_debug 'write buffer full, pausing read',
+                      count: @write_buffer.length
+            @multiplexer.stop_read self
+            @multiplexer.remove_post self
+          end
+          nil
+        end
+
+        def write_full?
+          @write_buffer.length >= WRITE_BUFFER_MAX
+        end
+
+        protected
+
+        def reading?
+          @r && !@pause
+        end
+
+        def do_write
+          @was_read_held = reading? && write_full?
+          @write_buffer.shift write_action
+
+          if @write_buffer.empty?
+            force_close if @close_scheduled
+            return
+          end
+
+          check_read_throttle
+        rescue IO::WaitWritable, Errno::EINTR, Errno::EAGAIN
+          # Wait for write
+          @write_immediately = false
+          @multiplexer.wait_write self
+        else
+          @write_immediately = true
+          @multiplexer.stop_write self
+        end
+
+        def check_read_throttle
+          return unless @was_read_held && !write_full?
+
+          log_debug 'write buffer no longer full, resuming read',
+                    count: @write_buffer.length
+          @multiplexer.wait_read self
+          reschedule_read
+        end
+
+        # Can be overridden for other IO objects
+        def write_nonblock(data)
+          log_debug 'write_nonblock', count: data.length
+          @io.write_nonblock(data)
+        end
+
+        # Can be overriden for other IO objects
+        def write_action
+          write_nonblock @write_buffer.peek(WRITE_SIZE)
+        end
+
+        def write_exception(e)
+          exception e if respond_to?(:exception)
+          force_close
+        end
+      end # ::Write
+    end # ::IOReactor
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/logger.rb

@@ -0,0 +1,64 @@
+# 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
+    # Logger provides ability for object specific context in logs
+    module Logger
+      attr_reader :logger
+      attr_reader :logger_context
+
+      protected
+
+      def initialize_logger(logger = nil, logger_context = nil)
+        @logger = logger || Cabin::Channel.get(IOMultiplex)
+        @logger_context = logger_context.nil? ? {} : logger_context
+      end
+
+      def add_logger_context(key, value)
+        @logger_context[key] = value
+      end
+
+      def clear_logger_context
+        @logger_context = nil
+      end
+
+      %w(fatal error warn info debug).each do |level|
+        method = ('log_' + level).to_sym
+        pmethod = ('log_' + level + '?').to_sym
+        logger_method = level.to_sym
+        logger_pmethod = (level + '?').to_sym
+
+        define_method(method) do |*args|
+          return unless @logger.send(logger_pmethod)
+
+          args[1] ||= {}
+
+          unless args[1].is_a?(Hash)
+            raise ArgumentError 'Second argument must be a hash'
+          end
+
+          args[1].merge! @logger_context unless @logger_context.nil?
+          @logger.send logger_method, *args
+        end
+
+        define_method(pmethod) do
+          @logger.send logger_pmethod
+        end
+      end
+    end # ::Logger
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/logslow.rb

@@ -0,0 +1,40 @@
+# 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
+    # LogSlow mixin to log slow function calls
+    module LogSlow
+      protected
+
+      # Wrap a method and report to the logger if it runs slowly
+      def log_slow(func, args = [], max_duration = 100, diagnostics = nil)
+        sub_start_time = Time.now
+        func.call(*args)
+        duration = ((Time.now - sub_start_time) * 1000).to_i
+        return unless duration > max_duration
+        extra = {
+          :duration_ms => duration,
+          :client => monitor.value.id
+        }
+        extra = diagnostics.call unless diagnostics.nil?
+        log_warn \
+          'Slow ' + func.to_s,
+          extra
+      end
+    end # ::LogSlow
+  end # ::Mixins
+end # ::IOMultiplex

data/lib/iomultiplex/mixins/openssl.rb

@@ -0,0 +1,148 @@
+# 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 'openssl'
+
+module IOMultiplex
+  module Mixins
+    # OpenSSL mixin, shared code amongst the OpenSSL IOReactors
+    module OpenSSL
+      def handle_read
+        if @write_on_read
+          handle_write
+
+          # Still need more reads to complete a write?
+          return if @write_on_read
+        end
+
+        super
+
+        # If we were waiting for a write signal so we could complete a read
+        # call, clear it since we now completed it
+        reset_read_on_write if @read_on_write
+      rescue IO::WaitWritable
+        # TODO: handle_data should really be triggered
+        # This captures an OpenSSL read wanting a write
+        @multiplexer.stop_read self
+        @multiplexer.wait_write self
+        @read_on_write = true
+
+        log_debug 'OpenSSL wants read on write'
+      end
+
+      def handle_write
+        if @read_on_write
+          handle_read
+
+          # Still need more writes to complete a read?
+          return if @read_on_write
+        end
+
+        super
+
+        # If we were waiting for a read signal so we could complete a write
+        # call, clear it since we now completed it
+        reset_write_on_read if @write_on_read
+      rescue IO::WaitReadable
+        # Write needs a read
+        @multiplexer.stop_write self
+        @multiplexer.wait_read self
+        @write_on_read = true
+
+        log_debug 'OpenSSL wants write on read'
+      end
+
+      def peer_cert
+        @ssl.peer_cert
+      end
+
+      def peer_cert_cn
+        return nil unless peer_cert
+        return @peer_cert_cn unless @peer_cert_cn.nil?
+        @peer_cert_cn = peer_cert.subject.to_a.find do |oid, value|
+          return value if oid == 'CN'
+          nil
+        end
+      end
+
+      def handshake_completed?
+        @handshake_completed
+      end
+
+      protected
+
+      def initialize_ssl(ssl_ctx)
+        @ssl = ::OpenSSL::SSL::SSLSocket.new(@io, ssl_ctx)
+        @ssl_ctx = ssl_ctx
+        @handshake_completed = false
+        @read_on_write = false
+        nil
+      end
+
+      def ssl_read_nonblock(n)
+        read = @ssl.read_nonblock n
+      rescue IO::WaitReadable
+        # OpenSSL wraps these, keep it flowing throw
+        raise
+      rescue ::OpenSSL::SSL::SSLError => e
+        # Throw back OpenSSL errors as IOErrors
+        raise IOError, "#{e.class.name}: #{e}"
+      ensure
+        log_debug 'SSL read_nonblock',
+                  count: n, read: read.nil? ? nil : read.length
+      end
+
+      def ssl_write_nonblock(data)
+        written = @ssl.write_nonblock data
+      rescue IO::WaitWritable
+        # OpenSSL wraps these, keep it flowing throw
+        raise
+      rescue ::OpenSSL::SSL::SSLError => e
+        # Throw back OpenSSL errors as IOErrors
+        raise IOError, "#{e.class.name}: #{e}"
+      ensure
+        log_debug 'SSL write_nonblock',
+                  count: data.length, written: written
+      end
+
+      def reset_read_on_write
+        @read_on_write = false
+        @multiplexer.wait_read self unless write_full?
+      end
+
+      def reset_write_on_read
+        @write_on_read = false
+        @write_immediately = true
+      end
+
+      def process_handshake
+        @ssl.accept_nonblock
+        @handshake_completed = true
+        add_logger_context 'peer_cert_cn', peer_cert_cn
+
+        handshake_completed if respond_to?(:handshake_completed)
+
+        log_debug 'Handshake completed'
+      rescue IO::WaitReadable, IO::WaitWritable
+        # OpenSSL wraps these, keep it flowing throw
+        raise
+      rescue ::OpenSSL::SSL::SSLError => e
+        # Throw back OpenSSL errors as IOErrors
+        raise IOError, "#{e.class.name}: #{e}"
+      end
+    end # ::OpenSSL
+  end # ::Mixins
+end # ::IOMultiplex