iopromise 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 323b4f0107580d674fa42c4f65644dcae302c822c9d370dd9e3effbf5b4c13eb
-  data.tar.gz: dc8b3937fea0505e598c0855ccc695b98dc837e221b8959a61acfbf18838c3b5
+  metadata.gz: 3fc60525e45ec8cfa8a6cd5ba34bf396b77e4d42f3fd566137f14367a2ba31ae
+  data.tar.gz: 1e70b2147a204a220be6b268ae62f67dc06b79065b8ec07636da414264ae626b
 SHA512:
-  metadata.gz: 8737b6c9a1e1ee2376f586ceca83a074679d6e0b53e073e07df8817f3f14fe261b606f5398618bcd984f2441b288b89fb9d660f499428d60c93cf35e7b561f7e
-  data.tar.gz: c82ed8d1da207ce2bfa766b8a1fd88aa4ba803565b749f4c77e0cb90a5b8f9c0289f60111260daf4acc5b7ddaae43b0ddcadd91212201778516b1637f9db2cb6
+  metadata.gz: b92e71ab4fa32e5c45f9b4a4fa607844f2558f270f69ddb3a63b1394633a4b3e7eb101f77b06e8bc4efe45ad657e00a7d4bad10f34374356f2dc660db17af525
+  data.tar.gz: 4034ef0ae2010b4cea930894d1f7cc05722e6dd0e3c112fe237ce6488441d24d670c098df525046c13d26514ff39ee672c3a26c49f601ddc40b757fbbe691079

data/Gemfile

@@ -23,4 +23,8 @@ group :development, :test do
   # view_component extensions
   gem "rails"
   gem "view_component", require: "view_component/engine"
+
+  # benchmarking
+  gem "benchmark-ips"
+  gem "stackprof"
 end

data/Gemfile.lock

@@ -8,8 +8,9 @@ GIT
 PATH
   remote: .
   specs:
-    iopromise (0.1.0)
-      promise.rb
+    iopromise (0.1.1)
+      nio4r
+      promise.rb (~> 0.7.4)
 
 GEM
   remote: https://rubygems.org/
@@ -73,6 +74,7 @@ GEM
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
+    benchmark-ips (2.9.1)
     builder (3.2.4)
     concurrent-ruby (1.1.8)
     crass (1.0.6)
@@ -161,6 +163,7 @@ GEM
       actionpack (>= 4.0)
       activesupport (>= 4.0)
       sprockets (>= 3.0.0)
+    stackprof (0.2.17)
     thor (1.1.0)
     typhoeus (1.4.0)
       ethon (>= 0.9.0)
@@ -177,6 +180,7 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  benchmark-ips
   dalli (= 2.7.11)
   faraday
   iopromise!
@@ -184,6 +188,7 @@ DEPENDENCIES
   rails
   rake (~> 13.0)
   rspec (~> 3.0)
+  stackprof
   typhoeus
   view_component
 

data/iopromise.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'promise.rb', '~> 0.7.4'
+  spec.add_dependency 'nio4r'
 end

data/lib/iopromise.rb

@@ -13,32 +13,31 @@ module IOPromise
   class Error < StandardError; end
 
   class Base < ::Promise
-    def initialize(*)
-      @instrument_begin = []
-      @instrument_end = []
-      @started_executing = false
-      
-      super
-    end
-
     def instrument(begin_cb = nil, end_cb = nil)
-      raise ::IOPromise::Error.new("Instrumentation called after promise already started executing") if @started_executing
-      @instrument_begin << begin_cb unless begin_cb.nil?
-      @instrument_end << end_cb unless end_cb.nil?
+      raise ::IOPromise::Error.new("Instrumentation called after promise already started executing") if started_executing?
+      unless begin_cb.nil?
+        @instrument_begin ||= []
+        @instrument_begin << begin_cb
+      end
+      unless end_cb.nil?
+        @instrument_end ||= []
+        @instrument_end << end_cb
+      end
     end
 
     def beginning
-      @instrument_begin.each { |cb| cb.call(self) }
+      @instrument_begin&.each { |cb| cb.call(self) }
+      @instrument_begin&.clear
       @started_executing = true
     end
 
     def started_executing?
-      @started_executing
+      !!@started_executing
     end
 
     def notify_completion(value: nil, reason: nil)
-      @instrument_end.each { |cb| cb.call(self, value: value, reason: reason) }
-      @instrument_end = []
+      @instrument_end&.each { |cb| cb.call(self, value: value, reason: reason) }
+      @instrument_end&.clear
     end
 
     def fulfill(value)

data/lib/iopromise/dalli/client.rb

@@ -21,7 +21,7 @@ module IOPromise
       # Returns a promise that resolves to a IOPromise::Dalli::Response with the
       # value for the given key, or +nil+ if the key is not found.
       def get(key, options = nil)
-        execute_as_promise(:get, key, options)
+        @client.perform(:get, key, options)
       end
 
       # Convenience function that attempts to fetch the given key, or set
@@ -40,7 +40,7 @@ module IOPromise
             !response.exist? :
             response.value.nil?
           if not_found && !block.nil?
-            Promise.resolve(block.call).then do |new_val|
+            block.call.then do |new_val|
               # delay the final resolution here until after the add succeeds,
               # to guarantee errors are caught. we could potentially allow
               # the add to resolve once it's sent (without confirmation), but
@@ -48,7 +48,7 @@ module IOPromise
               add(key, new_val, ttl, options).then { new_val }
             end
           else
-            Promise.resolve(response.value)
+            response.value
           end
         end
       end
@@ -56,40 +56,40 @@ module IOPromise
       # Unconditionally sets the +key+ to the +value+ specified.
       # Returns a promise that resolves to a IOPromise::Dalli::Response.
       def set(key, value, ttl = nil, options = nil)
-        execute_as_promise(:set, key, value, ttl_or_default(ttl), 0, options)
+        @client.perform(:set, key, value, ttl_or_default(ttl), 0, options)
       end
 
       # Conditionally sets the +key+ to the +value+ specified.
       # Returns a promise that resolves to a IOPromise::Dalli::Response.
       def add(key, value, ttl = nil, options = nil)
-        execute_as_promise(:add, key, value, ttl_or_default(ttl), options)
+        @client.perform(:add, key, value, ttl_or_default(ttl), options)
       end
 
       # Conditionally sets the +key+ to the +value+ specified only
       # if the key already exists.
       # Returns a promise that resolves to a IOPromise::Dalli::Response.
       def replace(key, value, ttl = nil, options = nil)
-        execute_as_promise(:replace, key, value, ttl_or_default(ttl), 0, options)
+        @client.perform(:replace, key, value, ttl_or_default(ttl), 0, options)
       end
 
       # Deletes the specified key, resolving the promise when complete.
       def delete(key)
-        execute_as_promise(:delete, key, 0)
+        @client.perform(:delete, key, 0)
       end
 
       # Appends a value to the specified key, resolving the promise when complete.
       # Appending only works for values stored with :raw => true.
       def append(key, value)
-        Promise.resolve(value).then do |resolved_value|
-          execute_as_promise(:append, key, resolved_value.to_s)
+        value.then do |resolved_value|
+          @client.perform(:append, key, resolved_value.to_s)
         end
       end
   
       # Prepend a value to the specified key, resolving the promise when complete.
       # Prepending only works for values stored with :raw => true.
       def prepend(key, value)
-        Promise.resolve(value).then do |resolved_value|
-          execute_as_promise(:prepend, key, resolved_value.to_s)
+        value.then do |resolved_value|
+          @client.perform(:prepend, key, resolved_value.to_s)
         end
       end
 
@@ -106,7 +106,7 @@ module IOPromise
       # #cas.
       def incr(key, amt = 1, ttl = nil, default = nil)
         raise ArgumentError, "Positive values only: #{amt}" if amt < 0
-        execute_as_promise(:incr, key, amt.to_i, ttl_or_default(ttl), default)
+        @client.perform(:incr, key, amt.to_i, ttl_or_default(ttl), default)
       end
 
       ##
@@ -125,17 +125,13 @@ module IOPromise
       # #cas.
       def decr(key, amt = 1, ttl = nil, default = nil)
         raise ArgumentError, "Positive values only: #{amt}" if amt < 0
-        execute_as_promise(:decr, key, amt.to_i, ttl_or_default(ttl), default)
+        @client.perform(:decr, key, amt.to_i, ttl_or_default(ttl), default)
       end
 
       # TODO: touch, gat, CAS operations
 
       private
 
-      def execute_as_promise(*args)
-        @client.perform_async(*args)
-      end
-
       def ttl_or_default(ttl)
         (ttl || @options[:expires_in]).to_i
       rescue NoMethodError

data/lib/iopromise/dalli/executor_pool.rb

@@ -3,10 +3,43 @@
 module IOPromise
   module Dalli
     class DalliExecutorPool < IOPromise::ExecutorPool::Base
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        dalli_server = @connection_pool
+      def initialize(*)
+        super
 
-        dalli_server.execute_continue(ready_readers, ready_writers, ready_exceptions)
+        @iop_monitor = nil
+      end
+
+      def dalli_server
+        @connection_pool
+      end
+
+      def execute_continue
+        dalli_server.execute_continue
+      end
+
+      def connected_socket(sock)
+        close_socket
+
+        @iop_monitor = ::IOPromise::ExecutorContext.current.register_observer_io(self, sock, :r)
+      end
+
+      def close_socket
+        unless @iop_monitor.nil?
+          @iop_monitor.close
+          @iop_monitor = nil
+        end
+      end
+
+      def monitor_ready(monitor, readiness)
+        dalli_server.async_io_ready(monitor.readable?, monitor.writable?)
+      end
+
+      def set_interest(direction, interested)
+        if interested
+          @iop_monitor.add_interest(direction)
+        else
+          @iop_monitor.remove_interest(direction)
+        end
       end
     end
   end

data/lib/iopromise/dalli/patch_dalli.rb

@@ -12,16 +12,16 @@ module IOPromise
         super
       end
 
-      def perform_async(*args)
-        if @async
-          perform(*args)
-        else
-          raise ArgumentError, "Cannot perform_async when async is not enabled."
+      def perform(*)
+        return super unless @async
+
+        begin
+          super
+        rescue => ex
+          # Wrap any connection errors into a promise, this is more forwards-compatible
+          # if we ever attempt to make connecting/server fallback nonblocking too.
+          Promise.new.tap { |p| p.reject(ex) }
         end
-      rescue => ex
-        # Wrap any connection errors into a promise, this is more forwards-compatible
-        # if we ever attempt to make connecting/server fallback nonblocking too.
-        Promise.new.tap { |p| p.reject(ex) }
       end
     end
 
@@ -30,10 +30,14 @@ module IOPromise
         @async = options.delete(:iopromise_async) == true
 
         if @async
+          @write_buffer = +""
+          @read_buffer = +""
           async_reset
 
           @next_opaque_id = 0
           @pending_ops = {}
+
+          @executor_pool = DalliExecutorPool.for(self)
         end
 
         super
@@ -51,60 +55,53 @@ module IOPromise
         super
       end
 
-      def async_reset
-        @write_buffer = +""
-        @write_offset = 0
-
-        @read_buffer = +""
-        @read_offset = 0
-      end
+      def connect
+        super
 
-      # called by ExecutorPool to continue processing for this server
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        unless ready_writers.nil? || ready_writers.empty?
-          # we are able to write, so write as much as we can.
-          sock_write_nonblock
+        if async?
+          @executor_pool.connected_socket(@sock)
         end
+      end
 
-        readers_empty = ready_readers.nil? || ready_readers.empty?
-        exceptions_empty = ready_exceptions.nil? || ready_exceptions.empty?
+      def async_reset
+        @write_buffer.clear
+        @write_offset = 0
 
-        if !readers_empty || !exceptions_empty
-          sock_read_nonblock
-        end
+        @read_buffer.clear
+        @read_offset = 0
 
-        readers = []
-        writers = []
-        exceptions = [@sock]
-        timeout = nil
+        @executor_pool.close_socket if defined? @executor_pool
+      end
 
-        to_timeout = @pending_ops.select { |key, op| op.timeout? }
-        to_timeout.each do |key, op|
-          @pending_ops.delete(key)
-          op.reject(Timeout::Error.new)
-          op.execute_pool.complete(op)
-        end
+      def async_io_ready(readable, writable)
+        async_sock_write_nonblock if writable
+        async_sock_read_nonblock if readable
+      end
 
-        unless @pending_ops.empty?
-          # wait for writability if we have pending data to write
-          writers << @sock if @write_buffer.bytesize > @write_offset
-          # and always call back when there is data available to read
-          readers << @sock
+      # called by ExecutorPool to continue processing for this server
+      def execute_continue
+        timeout = @options[:socket_timeout]
+        @pending_ops.select! do |key, op|
+          if op.timeout?
+            op.reject(Timeout::Error.new)
+            next false # this op is done
+          end
 
           # let all pending operations know that they are seeing the
           # select loop. this starts the timer for the operation, because
           # it guarantees we're now working on it.
           # this is more accurate than starting the timer when we buffer
           # the write.
-          @pending_ops.each do |_, op|
-            op.in_select_loop
-          end
+          op.in_select_loop
 
-          # mark the amount of time left of the closest to timeout.
-          timeout = @pending_ops.map { |_, op| op.timeout_remaining }.min
+          remaining = op.timeout_remaining
+          timeout = remaining if remaining < timeout
+
+          true # keep
         end
 
-        [readers, writers, exceptions, timeout]
+        @executor_pool.select_timeout = timeout
+        @executor_pool.set_interest(:r, !@pending_ops.empty?)
       end
 
       private
@@ -115,8 +112,14 @@ module IOPromise
 
 
       def promised_request(key, &block)
-        promise, opaque = new_pending(key)
-        buffered_write(block.call(opaque))
+        promise = ::IOPromise::Dalli::DalliPromise.new(self, key)
+        
+        new_id = @next_opaque_id
+        @pending_ops[new_id] = promise
+        @next_opaque_id = (@next_opaque_id + 1) & 0xffff_ffff
+        
+        async_buffered_write(block.call(new_id))
+
         promise
       end
 
@@ -128,12 +131,12 @@ module IOPromise
         end
       end
 
-      def generic_write_op(op, key, value, ttl, cas, options)
-        Promise.resolve(value).then do |value|
+      def async_generic_write_op(op, key, value, ttl, cas, options)
+        value.then do |value|
           (value, flags) = serialize(key, value, options)
           ttl = sanitize_ttl(ttl)
     
-          guard_max_value(key, value)
+          guard_max_value_with_raise(key, value)
 
           promised_request(key) do |opaque|
             [REQUEST, OPCODES[op], key.bytesize, 8, 0, 0, value.bytesize + key.bytesize + 8, opaque, cas, flags, ttl, key, value].pack(FORMAT[op])
@@ -143,20 +146,19 @@ module IOPromise
 
       def set(key, value, ttl, cas, options)
         return super unless async?
-
-        generic_write_op(:set, key, value, ttl, cas, options)
+        async_generic_write_op(:set, key, value, ttl, cas, options)
       end
 
       def add(key, value, ttl, options)
         return super unless async?
 
-        generic_write_op(:add, key, value, ttl, 0, options)
+        async_generic_write_op(:add, key, value, ttl, 0, options)
       end
 
       def replace(key, value, ttl, cas, options)
         return super unless async?
 
-        generic_write_op(:replace, key, value, ttl, cas, options)
+        async_generic_write_op(:replace, key, value, ttl, cas, options)
       end
 
       def delete(key, cas)
@@ -167,7 +169,7 @@ module IOPromise
         end
       end
 
-      def append_prepend_op(op, key, value)
+      def async_append_prepend_op(op, key, value)
         promised_request(key) do |opaque|
           [REQUEST, OPCODES[op], key.bytesize, 0, 0, 0, value.bytesize + key.bytesize, opaque, 0, key, value].pack(FORMAT[op])
         end
@@ -176,13 +178,13 @@ module IOPromise
       def append(key, value)
         return super unless async?
 
-        append_prepend_op(:append, key, value)
+        async_append_prepend_op(:append, key, value)
       end
 
       def prepend(key, value)
         return super unless async?
 
-        append_prepend_op(:prepend, key, value)
+        async_append_prepend_op(:prepend, key, value)
       end
 
       def flush
@@ -193,7 +195,7 @@ module IOPromise
         end
       end
 
-      def decr_incr(opcode, key, count, ttl, default)
+      def async_decr_incr(opcode, key, count, ttl, default)
         expiry = default ? sanitize_ttl(ttl) : 0xFFFFFFFF
         default ||= 0
         (h, l) = split(count)
@@ -206,103 +208,118 @@ module IOPromise
       def decr(key, count, ttl, default)
         return super unless async?
 
-        decr_incr :decr, key, count, ttl, default
+        async_decr_incr :decr, key, count, ttl, default
       end
   
       def incr(key, count, ttl, default)
         return super unless async?
         
-        decr_incr :incr, key, count, ttl, default
-      end
-
-      def new_pending(key)
-        promise = ::IOPromise::Dalli::DalliPromise.new(self, key)
-        new_id = @next_opaque_id
-        @pending_ops[new_id] = promise
-        @next_opaque_id = (@next_opaque_id + 1) & 0xffff_ffff
-        [promise, new_id]
+        async_decr_incr :incr, key, count, ttl, default
       end
 
-      def buffered_write(data)
+      def async_buffered_write(data)
         @write_buffer << data
-        sock_write_nonblock
+        async_sock_write_nonblock
       end
 
-      def sock_write_nonblock
+      def async_sock_write_nonblock
+        remaining = @write_buffer.byteslice(@write_offset, @write_buffer.length)
         begin
-          bytes_written = @sock.write_nonblock(@write_buffer.byteslice(@write_offset..-1))
-        rescue IO::WaitWritable, Errno::EINTR
-          return # no room to write immediately
+          bytes_written = @sock.write_nonblock(remaining, exception: false)
+        rescue Errno::EINTR
+          retry
         end
+
+        return if bytes_written == :wait_writable
         
         @write_offset += bytes_written
-        if @write_offset == @write_buffer.length
-          @write_buffer = +""
+        completed = (@write_offset == @write_buffer.length)
+        if completed
+          @write_buffer.clear
           @write_offset = 0
         end
+        @executor_pool.set_interest(:w, !completed)
       rescue SystemCallError, Timeout::Error => e
         failure!(e)
       end
 
       FULL_HEADER = 'CCnCCnNNQ'
 
-      def sock_read_nonblock
-        @read_buffer << @sock.read_available
+      def read_available
+        loop do
+          result = @sock.read_nonblock(8196, exception: false)
+          if result == :wait_readable
+            break
+          elsif result == :wait_writable
+            break
+          elsif result
+            @read_buffer << result
+          else
+            raise Errno::ECONNRESET, "Connection reset: #{safe_options.inspect}"
+          end
+        end
+      end
+
+      def async_sock_read_nonblock
+        read_available
 
         buf = @read_buffer
         pos = @read_offset
 
         while buf.bytesize - pos >= 24
-          header = buf.slice(pos, 24)
+          header = buf.byteslice(pos, 24)
           (magic, opcode, key_length, extra_length, data_type, status, body_length, opaque, cas) = header.unpack(FULL_HEADER)
 
           if buf.bytesize - pos >= 24 + body_length
-            flags = 0
-            if extra_length >= 4
-              flags = buf.slice(pos + 24, 4).unpack1("N")
-            end
+            exists = (status != 1) # Key not found
+            this_pos = pos
 
-            key = buf.slice(pos + 24 + extra_length, key_length)
-            value = buf.slice(pos + 24 + extra_length + key_length, body_length - key_length - extra_length)
+            # key = buf.byteslice(this_pos + 24 + extra_length, key_length)
+            value = buf.byteslice(this_pos + 24 + extra_length + key_length, body_length - key_length - extra_length) if exists
 
             pos = pos + 24 + body_length
 
             promise = @pending_ops.delete(opaque)
             next if promise.nil?
 
-            result = Promise.resolve(true).then do # auto capture exceptions below
-              raise Dalli::DalliError, "Response error #{status}: #{Dalli::RESPONSE_CODES[status]}" unless [0,1,2,5].include?(status)
-
-              exists = (status != 1) # Key not found
+            begin
+              raise Dalli::DalliError, "Response error #{status}: #{Dalli::RESPONSE_CODES[status]}" unless status == 0 || status == 1 || status == 2 || status == 5
+              
               final_value = nil
               if opcode == OPCODES[:incr] || opcode == OPCODES[:decr]
                 final_value = value.unpack1("Q>")
               elsif exists
+                flags = if extra_length >= 4
+                  buf.byteslice(this_pos + 24, 4).unpack1("N")
+                else
+                  0
+                end
                 final_value = deserialize(value, flags)
               end
 
-              ::IOPromise::Dalli::Response.new(
+              response = ::IOPromise::Dalli::Response.new(
                 key: promise.key,
                 value: final_value,
                 exists: exists,
                 stored: !(status == 2 || status == 5), # Key exists or Item not stored
                 cas: cas,
               )
-            end
 
-            promise.fulfill(result)
-            promise.execute_pool.complete(promise)
+              promise.fulfill(response)
+            rescue => ex
+              promise.reject(ex)
+            end
           else
             # not enough data yet, wait for more
             break
           end
         end
 
-        @read_offset = pos
-
-        if @read_offset == @read_buffer.length
-          @read_buffer = +""
+        if pos == @read_buffer.length
+          @read_buffer.clear
           @read_offset = 0
+        else
+          @read_offset = pos
         end
 
       rescue SystemCallError, Timeout::Error, EOFError => e
@@ -314,7 +331,6 @@ module IOPromise
           # all pending operations need to be rejected when a failure occurs
           @pending_ops.each do |op|
             op.reject(ex)
-            op.execute_pool.complete(op)
           end
           @pending_ops = {}
         end
@@ -322,8 +338,8 @@ module IOPromise
         super
       end
 
-      # FIXME: this is from the master version, rather than using the yield block.
-      def guard_max_value(key, value)
+      # this is guard_max_value from the master version, rather than using the yield block.
+      def guard_max_value_with_raise(key, value)
         return if value.bytesize <= @options[:value_max_bytes]
   
         message = "Value for #{key} over max size: #{@options[:value_max_bytes]} <= #{value.bytesize}"