iopromise 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fc60525e45ec8cfa8a6cd5ba34bf396b77e4d42f3fd566137f14367a2ba31ae
-  data.tar.gz: 1e70b2147a204a220be6b268ae62f67dc06b79065b8ec07636da414264ae626b
+  metadata.gz: f58c2a28347c1f21fe6c660eff9f2b7ce1b078b1a06a37c91de0d6ec05db1c66
+  data.tar.gz: f5b2f6f66c5f79bb3f68f8cd041f6fecdde33dba2700b3f474ae9a76995378c9
 SHA512:
-  metadata.gz: b92e71ab4fa32e5c45f9b4a4fa607844f2558f270f69ddb3a63b1394633a4b3e7eb101f77b06e8bc4efe45ad657e00a7d4bad10f34374356f2dc660db17af525
-  data.tar.gz: 4034ef0ae2010b4cea930894d1f7cc05722e6dd0e3c112fe237ce6488441d24d670c098df525046c13d26514ff39ee672c3a26c49f601ddc40b757fbbe691079
+  metadata.gz: '09e91e024b854c41dd60942dc76af20795ca88807f3d6548bbf7d96982babd4c618e7054f9e63c640cca3eb4add0d08c347d8bb7a5ac5357c7969645817562c9'
+  data.tar.gz: d44281e24ab187944c15da2ceae76a1b8be8d8b54dd6a117f2783aec3418e12231283cfe3adc548d8d4d78536d5712c493126c0618f820f541e6142d33cc27dc

data/.github/workflows/main.yml

@@ -9,7 +9,6 @@ jobs:
     - uses: actions/checkout@v2
     - name: Install dependencies
       run: sudo apt-get install libcurl4-openssl-dev libsasl2-dev
-    - uses: niden/actions-memcached@v7
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:

data/Gemfile

@@ -10,16 +10,6 @@ gem "rake", "~> 13.0"
 gem "rspec", "~> 3.0"
 
 group :development, :test do
-  # faraday adapter
-  gem 'faraday'
-  gem 'typhoeus'
-
-  # memcached adapter
-  gem 'memcached', :git => 'https://github.com/theojulienne/memcached.git', :branch => 'continuable-get'
-
-  # dalli adapter
-  gem 'dalli', "= 2.7.11"
-
   # view_component extensions
   gem "rails"
   gem "view_component", require: "view_component/engine"

data/Gemfile.lock

@@ -1,14 +1,7 @@
-GIT
-  remote: https://github.com/theojulienne/memcached.git
-  revision: 18c1da3708f3e7dca316b2f0143b4f05116f7672
-  branch: continuable-get
-  specs:
-    memcached (2.0.0.alpha)
-
 PATH
   remote: .
   specs:
-    iopromise (0.1.1)
+    iopromise (0.1.3)
       nio4r
       promise.rb (~> 0.7.4)
 
@@ -78,21 +71,8 @@ GEM
     builder (3.2.4)
     concurrent-ruby (1.1.8)
     crass (1.0.6)
-    dalli (2.7.11)
     diff-lcs (1.4.4)
     erubi (1.10.0)
-    ethon (0.14.0)
-      ffi (>= 1.15.0)
-    faraday (1.4.1)
-      faraday-excon (~> 1.1)
-      faraday-net_http (~> 1.0)
-      faraday-net_http_persistent (~> 1.1)
-      multipart-post (>= 1.2, < 3)
-      ruby2_keywords (>= 0.0.4)
-    faraday-excon (1.1.0)
-    faraday-net_http (1.0.1)
-    faraday-net_http_persistent (1.1.0)
-    ffi (1.15.0)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
     i18n (1.8.10)
@@ -106,7 +86,6 @@ GEM
     method_source (1.0.0)
     mini_mime (1.0.3)
     minitest (5.14.4)
-    multipart-post (2.1.1)
     nio4r (2.5.7)
     nokogiri (1.11.3-x86_64-linux)
       racc (~> 1.4)
@@ -155,7 +134,6 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    ruby2_keywords (0.0.4)
     sprockets (4.0.2)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
@@ -165,8 +143,6 @@ GEM
       sprockets (>= 3.0.0)
     stackprof (0.2.17)
     thor (1.1.0)
-    typhoeus (1.4.0)
-      ethon (>= 0.9.0)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     view_component (2.31.1)
@@ -181,15 +157,11 @@ PLATFORMS
 
 DEPENDENCIES
   benchmark-ips
-  dalli (= 2.7.11)
-  faraday
   iopromise!
-  memcached!
   rails
   rake (~> 13.0)
   rspec (~> 3.0)
   stackprof
-  typhoeus
   view_component
 
 BUNDLED WITH

data/README.md

@@ -1,6 +1,23 @@
-# iopromise
+# IOPromise
 
-This **experimental pre-release** gem extends promise.rb promises to support an extremely simple pattern for \"continuing\" execution of all pending promises in an asynchronous non-blocking way.
+IOPromise is a pattern that allows parallel execution of IO-bound requests (data store and RPCs) behind the abstraction of promises, without needing to introduce the complexity of threading. It uses [promise.rb](https://github.com/lgierth/promise.rb) for promises, and [nio4r](https://github.com/socketry/nio4r) to implement the IO loop.
+
+A simple example of this behaviour is using [iopromise-faraday](https://github.com/iopromise-ruby/iopromise-faraday) to perform concurrent HTTP requests:
+```ruby
+require 'iopromise/faraday'
+
+conn = IOPromise::Faraday.new('https://github.com/')
+
+promises = (1..3).map do
+  conn.get('/status')
+end
+
+Promise.all(promises).then do |responses|
+  responses.each_with_index do |response, i|
+    puts "#{i}: #{response.body.strip} #{response.headers["x-github-request-id"]}"
+  end
+end.sync
+```
 
 ## Installation
 
@@ -20,7 +37,9 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+IOPromise itself is a base library that makes it easy to wrap other IO-based workloads inside a promise-based API that back to an event loop. To use IOPromise, look at the following gems:
+
+ * [iopromise-faraday](https://github.com/iopromise-ruby/iopromise-faraday) supports [faraday](https://github.com/lostisland/faraday) HTTP requests, backed by libcurl/ethon/typhoeus.
 
 ## Development
 

data/bin/setup

@@ -4,6 +4,3 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
-
-# bring up a memcached for testing
-docker run -d -p 11211:11211 memcached:alpine

data/lib/iopromise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IOPromise
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iopromise
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Theo Julienne
@@ -60,12 +60,6 @@ files:
 - bin/setup
 - iopromise.gemspec
 - lib/iopromise.rb
-- lib/iopromise/dalli.rb
-- lib/iopromise/dalli/client.rb
-- lib/iopromise/dalli/executor_pool.rb
-- lib/iopromise/dalli/patch_dalli.rb
-- lib/iopromise/dalli/promise.rb
-- lib/iopromise/dalli/response.rb
 - lib/iopromise/deferred.rb
 - lib/iopromise/deferred/executor_pool.rb
 - lib/iopromise/deferred/promise.rb
@@ -73,10 +67,6 @@ files:
 - lib/iopromise/executor_pool/base.rb
 - lib/iopromise/executor_pool/batch.rb
 - lib/iopromise/executor_pool/sequential.rb
-- lib/iopromise/memcached.rb
-- lib/iopromise/memcached/client.rb
-- lib/iopromise/memcached/executor_pool.rb
-- lib/iopromise/memcached/promise.rb
 - lib/iopromise/version.rb
 - lib/iopromise/view_component.rb
 - lib/iopromise/view_component/data_loader.rb

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,142 +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)
-        @client.perform(: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?
-            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
-            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)
-        @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)
-        @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)
-        @client.perform(:replace, key, value, ttl_or_default(ttl), 0, options)
-      end
-
-      # Deletes the specified key, resolving the promise when complete.
-      def delete(key)
-        @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)
-        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)
-        value.then do |resolved_value|
-          @client.perform(: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
-        @client.perform(: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
-        @client.perform(:decr, key, amt.to_i, ttl_or_default(ttl), default)
-      end
-
-      # TODO: touch, gat, CAS operations
-
-      private
-
-      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,46 +0,0 @@
-# frozen_string_literal: true
-
-module IOPromise
-  module Dalli
-    class DalliExecutorPool < IOPromise::ExecutorPool::Base
-      def initialize(*)
-        super
-
-        @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
-end

data/lib/iopromise/dalli/patch_dalli.rb

@@ -1,353 +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(*)
-        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
-      end
-    end
-
-    module AsyncServer
-      def initialize(attribs, options = {})
-        @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
-      end
-
-      def async?
-        @async
-      end
-
-      def close
-        if async?
-          async_reset
-        end
-
-        super
-      end
-
-      def connect
-        super
-
-        if async?
-          @executor_pool.connected_socket(@sock)
-        end
-      end
-
-      def async_reset
-        @write_buffer.clear
-        @write_offset = 0
-
-        @read_buffer.clear
-        @read_offset = 0
-
-        @executor_pool.close_socket if defined? @executor_pool
-      end
-
-      def async_io_ready(readable, writable)
-        async_sock_write_nonblock if writable
-        async_sock_read_nonblock if readable
-      end
-
-      # 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.
-          op.in_select_loop
-
-          remaining = op.timeout_remaining
-          timeout = remaining if remaining < timeout
-
-          true # keep
-        end
-
-        @executor_pool.select_timeout = timeout
-        @executor_pool.set_interest(:r, !@pending_ops.empty?)
-      end
-
-      private
-
-      REQUEST = ::Dalli::Server::REQUEST
-      OPCODES = ::Dalli::Server::OPCODES
-      FORMAT  = ::Dalli::Server::FORMAT
-
-
-      def promised_request(key, &block)
-        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
-
-      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 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_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])
-          end
-        end
-      end
-
-      def set(key, value, ttl, cas, options)
-        return super unless async?
-        async_generic_write_op(:set, key, value, ttl, cas, options)
-      end
-
-      def add(key, value, ttl, options)
-        return super unless async?
-
-        async_generic_write_op(:add, key, value, ttl, 0, options)
-      end
-
-      def replace(key, value, ttl, cas, options)
-        return super unless async?
-
-        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 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
-      end
-
-      def append(key, value)
-        return super unless async?
-
-        async_append_prepend_op(:append, key, value)
-      end
-
-      def prepend(key, value)
-        return super unless async?
-
-        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 async_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?
-
-        async_decr_incr :decr, key, count, ttl, default
-      end
-  
-      def incr(key, count, ttl, default)
-        return super unless async?
-        
-        async_decr_incr :incr, key, count, ttl, default
-      end
-
-      def async_buffered_write(data)
-        @write_buffer << data
-        async_sock_write_nonblock
-      end
-
-      def async_sock_write_nonblock
-        remaining = @write_buffer.byteslice(@write_offset, @write_buffer.length)
-        begin
-          bytes_written = @sock.write_nonblock(remaining, exception: false)
-        rescue Errno::EINTR
-          retry
-        end
-
-        return if bytes_written == :wait_writable
-        
-        @write_offset += bytes_written
-        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 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.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
-            exists = (status != 1) # Key not found
-            this_pos = pos
-
-            # 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?
-
-            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
-
-              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,
-              )
-
-              promise.fulfill(response)
-            rescue => ex
-              promise.reject(ex)
-            end
-          else
-            # not enough data yet, wait for more
-            break
-          end
-        end
-
-        if pos == @read_buffer.length
-          @read_buffer.clear
-          @read_offset = 0
-        else
-          @read_offset = pos
-        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)
-          end
-          @pending_ops = {}
-        end
-
-        super
-      end
-
-      # 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}"
-        raise Dalli::ValueOverMaxSize, message
-      end
-    end
-  end
-end
-
-::Dalli::Server.prepend(IOPromise::Dalli::AsyncServer)
-::Dalli::Client.prepend(IOPromise::Dalli::AsyncClient)

data/lib/iopromise/dalli/promise.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'executor_pool'
-
-module IOPromise
-  module Dalli
-    class DalliPromise < ::IOPromise::Base
-      attr_reader :key
-
-      def initialize(server = nil, key = nil)
-        super()
-
-        # when created from a 'then' call, initialize nothing
-        return if server.nil? || key.nil?
-
-        @server = server
-        @key = key
-        @start_time = nil
-        
-        ::IOPromise::ExecutorContext.current.register(self)
-      end
-    
-      def wait
-        unless defined?(@server)
-          super
-        else
-          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
-        end
-      end
-    
-      def execute_pool
-        return @pool if defined?(@pool)
-        if defined?(@server)
-          @pool = DalliExecutorPool.for(@server)
-        else
-          @pool = nil
-        end
-      end
-
-      def in_select_loop
-        if @start_time.nil?
-          @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        end
-      end
-
-      def timeout_remaining
-        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        elapsed = now - @start_time
-        remaining = @server.options[:socket_timeout] - elapsed
-        return 0 if remaining < 0
-        remaining
-      end
-
-      def timeout?
-        return false if @start_time.nil?
-        timeout_remaining <= 0
-      end
-    end
-  end
-end

data/lib/iopromise/dalli/response.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module IOPromise
-  module Dalli
-    class Response
-      attr_reader :key, :value, :cas
-
-      def initialize(key:, value:, exists: false, stored: false, cas: nil)
-        @key = key
-        @value = value
-        @exists = exists
-        @stored = stored
-        @cas = cas
-      end
-
-      def exist?
-        @exists
-      end
-
-      def stored?
-        @stored
-      end
-    end
-  end
-end

data/lib/iopromise/memcached.rb

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

data/lib/iopromise/memcached/client.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'memcached'
-require_relative 'promise'
-
-module IOPromise
-  module Memcached
-    class Client
-      def initialize(*args, **kwargs)
-        if args.first.is_a?(::Memcached::Client)
-          @client = args.first.clone
-        else
-          @client = ::Memcached::Client.new(*args, **kwargs)
-        end
-      end
-
-      def get_as_promise(key)
-        MemcachePromise.new(@client, key)
-      end
-    end
-  end
-end

data/lib/iopromise/memcached/executor_pool.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module IOPromise
-  module Memcached
-    class MemcacheExecutorPool < ::IOPromise::ExecutorPool::Batch
-      def initialize(*)
-        super
-
-        @monitors = {}
-      end
-
-      def next_batch
-        super
-
-        unless @current_batch.empty?
-          @keys_to_promises = @current_batch.group_by { |promise| promise.key }
-          @current_batch.each { |promise| begin_executing(promise) }
-          begin
-            memcache_client.begin_get_multi(@keys_to_promises.keys)
-          rescue => e
-            @keys_to_promises.values.flatten.each do |promise|
-              promise.reject(e)
-              @current_batch.delete(promise)
-            end
-
-            @keys_to_promises = nil
-          end
-        end
-      end
-
-      def execute_continue
-        if @current_batch.empty?
-          next_batch
-        end
-
-        if @current_batch.empty?
-          @monitors.each do |_, monitor|
-            monitor.interests = nil
-          end
-          return
-        end
-
-        so_far, readers, writers = memcache_client.continue_get_multi
-
-        # when we're done (nothing to wait on), fill in any remaining keys with nil for completions to occur
-        if readers.empty? && writers.empty?
-          @keys_to_promises.each do |key, _|
-            so_far[key] = nil unless so_far.include? key
-          end
-        end
-
-        so_far.each do |key, value|
-          next unless @keys_to_promises[key]
-          @keys_to_promises[key].each do |promise|
-            next if promise.fulfilled?
-
-            promise.fulfill(value)
-            @current_batch.delete(promise)
-          end
-        end
-
-        @monitors.each do |_, monitor|
-          monitor.interests = nil
-        end
-
-        readers.each do |reader|
-          @monitors[reader] ||= ::IOPromise::ExecutorContext.current.register_observer_io(self, reader, :r)
-          @monitors[reader].add_interest(:r)
-        end
-
-        writers.each do |writer|
-          @monitors[writer] ||= ::IOPromise::ExecutorContext.current.register_observer_io(self, writer, :w)
-          @monitors[writer].add_interest(:w)
-        end
-      end
-
-      def memcache_client
-        @connection_pool
-      end
-    end
-  end
-end

data/lib/iopromise/memcached/promise.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'executor_pool'
-
-module IOPromise
-  module Memcached
-    class MemcachePromise < ::IOPromise::Base
-      attr_reader :key
-
-      def initialize(client = nil, key = nil)
-        super()
-    
-        @client = client
-        @key = key
-    
-        ::IOPromise::ExecutorContext.current.register(self) unless @client.nil? || @key.nil?
-      end
-    
-      def wait
-        if @client.nil? || @key.nil?
-          super
-        else
-          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
-        end
-      end
-    
-      def execute_pool
-        MemcacheExecutorPool.for(@client)
-      end
-    end
-  end
-end