iopromise 0.1.1 → 0.1.5

data/lib/iopromise/dalli.rb

@@ -1,13 +0,0 @@
-# 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

@@ -1,146 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,337 +0,0 @@
-# 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)