iopromise 0.1.0

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "iopromise"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# bring up a memcached for testing
+docker run -d -p 11211:11211 memcached:alpine

data/iopromise.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "lib/iopromise/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "iopromise"
+  spec.version       = IOPromise::VERSION
+  spec.authors       = ["Theo Julienne"]
+  spec.email         = ["theo.julienne@gmail.com"]
+
+  spec.summary       = "Simple non-blocking IO promises for Ruby."
+  spec.description   = "This gem extends promise.rb promises to support an extremely simple pattern for \"continuing\" execution of the promise in an asynchronous non-blocking way."
+  spec.homepage      = "https://github.com/theojulienne/iopromise"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'promise.rb', '~> 0.7.4'
+end

data/lib/iopromise.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "promise"
+
+require_relative "iopromise/version"
+
+require_relative "iopromise/executor_context"
+require_relative "iopromise/executor_pool/base"
+require_relative "iopromise/executor_pool/batch"
+require_relative "iopromise/executor_pool/sequential"
+
+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?
+    end
+
+    def beginning
+      @instrument_begin.each { |cb| cb.call(self) }
+      @started_executing = true
+    end
+
+    def started_executing?
+      @started_executing
+    end
+
+    def notify_completion
+      @instrument_end.each { |cb| cb.call(self) }
+      @instrument_end = []
+    end
+
+    def fulfill(value)
+      notify_completion
+      super(value)
+    end
+
+    def reject(reason)
+      notify_completion
+      super(reason)
+    end
+  end
+end

data/lib/iopromise/dalli.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'dalli/client'
+
+module IOPromise
+  module Dalli
+    class << self
+      def new(*args, **kwargs)
+        ::IOPromise::Dalli::Client.new(*args, **kwargs)
+      end
+    end
+  end
+end

data/lib/iopromise/dalli/client.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'dalli'
+require_relative 'promise'
+require_relative 'patch_dalli'
+
+module IOPromise
+  module Dalli
+    class Client
+      # General note:
+      # There is no need for explicit get_multi or batching, as requests
+      # are sent as soon as the IOPromise is created, multiple can be
+      # awaiting response at any time, and responses are automatically demuxed.
+      def initialize(servers = nil, options = {})
+        @cache_nils = !!options[:cache_nils]
+        options[:iopromise_async] = true
+        @options = options
+        @client = ::Dalli::Client.new(servers, options)
+      end
+
+      # 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)
+      end
+
+      # Convenience function that attempts to fetch the given key, or set
+      # the key with a dynamically generated value if it does not exist.
+      # Either way, the returned promise will resolve to the cached or computed
+      # value.
+      #
+      # If the value does not exist then the provided block is run to generate
+      # the value (which can also be a promise), after which the value is set
+      # if it still doesn't exist.
+      def fetch(key, ttl = nil, options = nil, &block)
+        # match the Dalli behaviour exactly
+        options = options.nil? ? ::Dalli::Client::CACHE_NILS : options.merge(::Dalli::Client::CACHE_NILS) if @cache_nils
+        get(key, options).then do |response|
+          not_found = @options[:cache_nils] ?
+            !response.exist? :
+            response.value.nil?
+          if not_found && !block.nil?
+            Promise.resolve(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
+              # we do need to wait on the add promise to ensure it's sent.
+              add(key, new_val, ttl, options).then { new_val }
+            end
+          else
+            Promise.resolve(response.value)
+          end
+        end
+      end
+
+      # 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)
+      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)
+      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)
+      end
+
+      # Deletes the specified key, resolving the promise when complete.
+      def delete(key)
+        execute_as_promise(: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)
+        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)
+        end
+      end
+
+      ##
+      # Incr adds the given amount to the counter on the memcached server.
+      # Amt must be a positive integer value.
+      #
+      # If default is nil, the counter must already exist or the operation
+      # will fail and will return nil.  Otherwise this method will return
+      # the new value for the counter.
+      #
+      # Note that the ttl will only apply if the counter does not already
+      # exist.  To increase an existing counter and update its TTL, use
+      # #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)
+      end
+
+      ##
+      # Decr subtracts the given amount from the counter on the memcached server.
+      # Amt must be a positive integer value.
+      #
+      # memcached counters are unsigned and cannot hold negative values.  Calling
+      # decr on a counter which is 0 will just return 0.
+      #
+      # If default is nil, the counter must already exist or the operation
+      # will fail and will return nil.  Otherwise this method will return
+      # the new value for the counter.
+      #
+      # Note that the ttl will only apply if the counter does not already
+      # exist.  To decrease an existing counter and update its TTL, use
+      # #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)
+      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
+        raise ArgumentError, "Cannot convert ttl (#{ttl}) to an integer"
+      end
+    end
+  end
+end

data/lib/iopromise/dalli/executor_pool.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module Dalli
+    class DalliExecutorPool < IOPromise::ExecutorPool::Base
+      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+        dalli_server = @connection_pool
+
+        dalli_server.execute_continue(ready_readers, ready_writers, ready_exceptions)
+      end
+    end
+  end
+end

data/lib/iopromise/dalli/patch_dalli.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require 'dalli'
+require_relative 'response'
+
+module IOPromise
+  module Dalli
+    module AsyncClient
+      def initialize(servers = nil, options = {})
+        @async = options[:iopromise_async] == true
+
+        super
+      end
+
+      def perform_async(*args)
+        if @async
+          perform(*args)
+        else
+          raise ArgumentError, "Cannot perform_async when async is not enabled."
+        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
+
+    module AsyncServer
+      def initialize(attribs, options = {})
+        @async = options.delete(:iopromise_async) == true
+
+        if @async
+          async_reset
+
+          @next_opaque_id = 0
+          @pending_ops = {}
+        end
+
+        super
+      end
+
+      def async?
+        @async
+      end
+
+      def close
+        if async?
+          async_reset
+        end
+
+        super
+      end
+
+      def async_reset
+        @write_buffer = +""
+        @write_offset = 0
+
+        @read_buffer = +""
+        @read_offset = 0
+      end
+
+      # 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
+        end
+
+        readers_empty = ready_readers.nil? || ready_readers.empty?
+        exceptions_empty = ready_exceptions.nil? || ready_exceptions.empty?
+
+        if !readers_empty || !exceptions_empty
+          sock_read_nonblock
+        end
+
+        readers = []
+        writers = []
+        exceptions = [@sock]
+        timeout = nil
+
+        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
+
+        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
+
+          # 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
+
+          # mark the amount of time left of the closest to timeout.
+          timeout = @pending_ops.map { |_, op| op.timeout_remaining }.min
+        end
+
+        [readers, writers, exceptions, timeout]
+      end
+
+      private
+
+      REQUEST = ::Dalli::Server::REQUEST
+      OPCODES = ::Dalli::Server::OPCODES
+      FORMAT  = ::Dalli::Server::FORMAT
+
+
+      def promised_request(key, &block)
+        promise, opaque = new_pending(key)
+        buffered_write(block.call(opaque))
+        promise
+      end
+
+      def get(key, options = nil)
+        return super unless async?
+
+        promised_request(key) do |opaque|
+          [REQUEST, OPCODES[:get], key.bytesize, 0, 0, 0, key.bytesize, opaque, 0, key].pack(FORMAT[:get])
+        end
+      end
+
+      def generic_write_op(op, key, value, ttl, cas, options)
+        Promise.resolve(value).then do |value|
+          (value, flags) = serialize(key, value, options)
+          ttl = sanitize_ttl(ttl)
+    
+          guard_max_value(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])
+          end
+        end
+      end
+
+      def set(key, value, ttl, cas, options)
+        return super unless 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)
+      end
+
+      def replace(key, value, ttl, cas, options)
+        return super unless async?
+
+        generic_write_op(:replace, key, value, ttl, cas, options)
+      end
+
+      def delete(key, cas)
+        return super unless async?
+
+        promised_request(key) do |opaque|
+          [REQUEST, OPCODES[:delete], key.bytesize, 0, 0, 0, key.bytesize, opaque, cas, key].pack(FORMAT[:delete])
+        end
+      end
+
+      def 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
+      end
+
+      def append(key, value)
+        return super unless async?
+
+        append_prepend_op(:append, key, value)
+      end
+
+      def prepend(key, value)
+        return super unless async?
+
+        append_prepend_op(:prepend, key, value)
+      end
+
+      def flush
+        return super unless async?
+
+        promised_request(nil) do |opaque|
+          [REQUEST, OPCODES[:flush], 0, 4, 0, 0, 4, opaque, 0, 0].pack(FORMAT[:flush])
+        end
+      end
+
+      def decr_incr(opcode, key, count, ttl, default)
+        expiry = default ? sanitize_ttl(ttl) : 0xFFFFFFFF
+        default ||= 0
+        (h, l) = split(count)
+        (dh, dl) = split(default)
+        promised_request(key) do |opaque|
+          req = [REQUEST, OPCODES[opcode], key.bytesize, 20, 0, 0, key.bytesize + 20, opaque, 0, h, l, dh, dl, expiry, key].pack(FORMAT[opcode])
+        end
+      end
+  
+      def decr(key, count, ttl, default)
+        return super unless 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]
+      end
+
+      def buffered_write(data)
+        @write_buffer << data
+        sock_write_nonblock
+      end
+
+      def sock_write_nonblock
+        begin
+          bytes_written = @sock.write_nonblock(@write_buffer.byteslice(@write_offset..-1))
+        rescue IO::WaitWritable, Errno::EINTR
+          return # no room to write immediately
+        end
+        
+        @write_offset += bytes_written
+        if @write_offset == @write_buffer.length
+          @write_buffer = +""
+          @write_offset = 0
+        end
+      rescue SystemCallError, Timeout::Error => e
+        failure!(e)
+      end
+
+      FULL_HEADER = 'CCnCCnNNQ'
+
+      def sock_read_nonblock
+        @read_buffer << @sock.read_available
+
+        buf = @read_buffer
+        pos = @read_offset
+
+        while buf.bytesize - pos >= 24
+          header = buf.slice(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
+
+            key = buf.slice(pos + 24 + extra_length, key_length)
+            value = buf.slice(pos + 24 + extra_length + key_length, body_length - key_length - extra_length)
+
+            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
+              final_value = nil
+              if opcode == OPCODES[:incr] || opcode == OPCODES[:decr]
+                final_value = value.unpack1("Q>")
+              elsif exists
+                final_value = deserialize(value, flags)
+              end
+
+              ::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)
+          else
+            # not enough data yet, wait for more
+            break
+          end
+        end
+
+        @read_offset = pos
+
+        if @read_offset == @read_buffer.length
+          @read_buffer = +""
+          @read_offset = 0
+        end
+
+      rescue SystemCallError, Timeout::Error, EOFError => e
+        failure!(e)
+      end
+
+      def failure!(ex)
+        if async?
+          # 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
+
+        super
+      end
+
+      # FIXME: this is from the master version, rather than using the yield block.
+      def guard_max_value(key, value)
+        return if value.bytesize <= @options[:value_max_bytes]
+  
+        message = "Value for #{key} over max size: #{@options[:value_max_bytes]} <= #{value.bytesize}"
+        raise Dalli::ValueOverMaxSize, message
+      end
+    end
+  end
+end
+
+::Dalli::Server.prepend(IOPromise::Dalli::AsyncServer)
+::Dalli::Client.prepend(IOPromise::Dalli::AsyncClient)