iopromise 0.1.1 → 0.1.5

data/lib/iopromise/dalli/promise.rb

@@ -1,52 +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()
-    
-        @server = server
-        @key = key
-        @start_time = nil
-    
-        ::IOPromise::ExecutorContext.current.register(self) unless @server.nil? || @key.nil?
-      end
-    
-      def wait
-        if @server.nil? || @key.nil?
-          super
-        else
-          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
-        end
-      end
-    
-      def execute_pool
-        DalliExecutorPool.for(@server)
-      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/faraday.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'faraday/connection'
-
-module IOPromise
-  module Faraday
-    class << self
-      def new(url = nil, options = {}, &block)
-        options = ::Faraday.default_connection_options.merge(options)
-        ::IOPromise::Faraday::Connection.new(url, options) do |faraday|
-          faraday.adapter :typhoeus
-          block.call unless block.nil?
-        end
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/connection.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-
-require_relative 'promise'
-
-module IOPromise
-  module Faraday
-    class Connection < ::Faraday::Connection
-      def with_deferred_parallel
-        @parallel_manager = FaradayPromise.parallel_manager
-        yield
-      ensure
-        @parallel_manager = nil
-      end
-      
-      def get_as_promise(*args, **kwargs)
-        @parallel_manager = FaradayPromise.parallel_manager
-        FaradayPromise.new(get(*args, **kwargs))
-      ensure
-        @parallel_manager = nil
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/continuable_hydra.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'typhoeus'
-require_relative 'multi_socket_action'
-
-module IOPromise
-  module Faraday
-    class ContinuableHydra < Typhoeus::Hydra
-      class << self
-        def for_current_thread
-          Thread.current[:faraday_promise_typhoeus_hydra] ||= new
-        end
-      end
-    
-      def initialize(options = {})
-        super(options)
-        
-        @multi = MultiSocketAction.new(options.reject{|k,_| k==:max_concurrency})
-      end
-    
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        # fill up the curl easy handle as much as possible
-        dequeue_many
-    
-        @multi.execute_continue(ready_readers, ready_writers, ready_exceptions)
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/executor_pool.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'continuable_hydra'
-
-module IOPromise
-  module Faraday
-    class FaradayExecutorPool < IOPromise::ExecutorPool::Base
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        # mark all pending promises as executing since they could be started any time now.
-        # ideally we would do this on dequeue.
-        @pending.each do |promise|
-          begin_executing(promise) unless promise.started_executing?
-        end
-
-        ContinuableHydra.for_current_thread.execute_continue(ready_readers, ready_writers, ready_exceptions)
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/multi_socket_action.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'ethon'
-
-Ethon::Curl.ffi_lib 'curl'
-Ethon::Curl.attach_function :multi_socket_action, :curl_multi_socket_action, [:pointer, :int, :int, :pointer], :multi_code
-
-module IOPromise
-  module Faraday
-    class MultiSocketAction < Ethon::Multi
-      CURL_POLL_NONE = 0
-      CURL_POLL_IN = 1
-      CURL_POLL_OUT = 2
-      CURL_POLL_INOUT = 3
-      CURL_POLL_REMOVE = 4
-    
-      CURL_SOCKET_BAD = -1
-      CURL_SOCKET_TIMEOUT = CURL_SOCKET_BAD
-    
-      CURLM_OK = 0
-
-      CURL_CSELECT_IN  = 0x01
-      CURL_CSELECT_OUT = 0x02
-      CURL_CSELECT_ERR = 0x04
-      
-      def initialize(options = {})
-        super(options)
-    
-        @read_fds = {}
-        @write_fds = {}
-        @select_timeout = nil
-    
-        self.socketfunction = @keep_socketfunction = proc do |handle, sock, what, userp, socketp|
-          if what == CURL_POLL_REMOVE
-            @read_fds.delete(sock)
-            @write_fds.delete(sock)
-          else
-            # reuse existing if we have it anywhere
-            io = @read_fds[sock] || @write_fds[sock] || IO.for_fd(sock).tap { |io| io.autoclose = false }
-            if what == CURL_POLL_INOUT
-              @read_fds[sock] = io
-              @write_fds[sock] = io
-            elsif what == CURL_POLL_IN
-              @read_fds[sock] = io
-              @write_fds.delete(sock)
-            elsif what == CURL_POLL_OUT
-              @read_fds.delete(sock)
-              @write_fds[sock] = io
-            end
-          end
-          CURLM_OK
-        end
-    
-        self.timerfunction = @keep_timerfunction = proc do |handle, timeout_ms, userp|
-          if timeout_ms > 0x7fffffffffffffff # FIXME: wrongly encoded
-            @select_timeout = nil
-          else
-            @select_timeout = timeout_ms.to_f / 1_000
-          end
-          CURLM_OK
-        end
-      end
-    
-      def perform
-        # stubbed out, we don't want any of the multi_perform logic
-      end
-    
-      def run
-        # stubbed out, we don't want any of the multi_perform logic
-      end
-    
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        running_handles = ::FFI::MemoryPointer.new(:int)
-        
-        flags = Hash.new(0)
-    
-        unless ready_readers.nil?
-          ready_readers.each do |s|
-            flags[s.fileno] |= CURL_CSELECT_IN
-          end
-        end
-        unless ready_writers.nil?
-          ready_writers.each do |s|
-            flags[s.fileno] |= CURL_CSELECT_OUT
-          end
-        end
-        unless ready_exceptions.nil?
-          ready_exceptions.each do |s|
-            flags[s.fileno] |= CURL_CSELECT_ERR
-          end
-        end
-        
-        flags.each do |fd, bitmask|
-          Ethon::Curl.multi_socket_action(handle, fd, bitmask, running_handles)
-        end
-    
-        if flags.empty?
-          Ethon::Curl.multi_socket_action(handle, CURL_SOCKET_TIMEOUT, 0, running_handles)
-        end
-    
-        check
-    
-        [@read_fds.values, @write_fds.values, [], @select_timeout]
-      end
-    end
-  end
-end

data/lib/iopromise/faraday/promise.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'continuable_hydra'
-require_relative 'executor_pool'
-
-module IOPromise
-  module Faraday
-    class FaradayPromise < ::IOPromise::Base
-      def self.parallel_manager
-        ContinuableHydra.for_current_thread
-      end
-    
-      def initialize(response = nil)
-        super()
-    
-        @response = response
-        @started = false
-
-        unless @response.nil?
-          @response.on_complete do |response_env|
-            fulfill(@response)
-            execute_pool.complete(self)
-          end
-        end
-    
-        ::IOPromise::ExecutorContext.current.register(self) unless @response.nil?
-      end
-    
-      def wait
-        if @response.nil?
-          super
-        else
-          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
-        end
-      end
-    
-      def execute_pool
-        FaradayExecutorPool.for(Thread.current)
-      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,61 +0,0 @@
-# frozen_string_literal: true
-
-module IOPromise
-  module Memcached
-    class MemcacheExecutorPool < ::IOPromise::ExecutorPool::Batch
-      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)
-              complete(promise)
-              @current_batch.delete(promise)
-            end
-
-            @keys_to_promises = nil
-          end
-        end
-      end
-
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
-        if @current_batch.empty?
-          next_batch
-        end
-
-        return [[], [], [], nil] if @current_batch.empty?
-
-        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)
-            complete(promise)
-            @current_batch.delete(promise)
-          end
-        end
-
-        [readers, writers, [], nil]
-      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