iopromise 0.1.0

data/lib/iopromise/dalli/promise.rb

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

@@ -0,0 +1,25 @@
+# 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/deferred.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'deferred/promise'
+
+module IOPromise
+  module Deferred
+    class << self
+      def new(&block)
+        ::IOPromise::Deferred::DeferredPromise.new(&block)
+      end
+    end
+  end
+end

data/lib/iopromise/deferred/executor_pool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module Deferred
+    class DeferredExecutorPool < ::IOPromise::ExecutorPool::Batch
+      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+        if @current_batch.empty?
+          next_batch
+        end
+
+        until @current_batch.empty?
+          # we are just running this in the sync cycle, in a blocking way.
+          @current_batch.each do |promise|
+            begin_executing(promise)
+            promise.run_deferred
+            complete(promise)
+          end
+
+          @current_batch = []
+
+          next_batch
+        end
+
+        # we always fully complete each cycle
+        return [[], [], [], nil]
+      end
+    end
+  end
+end

data/lib/iopromise/deferred/promise.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'executor_pool'
+
+module IOPromise
+  module Deferred
+    class DeferredPromise < ::IOPromise::Base
+      def initialize(&block)
+        super()
+    
+        @block = block
+    
+        ::IOPromise::ExecutorContext.current.register(self) unless @block.nil?
+      end
+    
+      def wait
+        if @block.nil?
+          super
+        else
+          ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
+        end
+      end
+    
+      def execute_pool
+        DeferredExecutorPool.for(Thread.current)
+      end
+
+      def run_deferred
+        return if @block.nil?
+        begin
+          fulfill(@block.call)
+        rescue => exception
+          reject(exception)
+        end
+      end
+    end
+  end
+end

data/lib/iopromise/executor_context.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module IOPromise
+  class ExecutorContext
+    class << self
+      def push
+        @contexts ||= []
+        @contexts << ExecutorContext.new
+      end
+
+      def current
+        @contexts.last
+      end
+
+      def pop
+        @contexts.pop
+      end
+    end
+
+    def initialize
+      @pools = Set.new
+
+      @pool_ready_readers = {}
+      @pool_ready_writers = {}
+      @pool_ready_exceptions = {}
+
+      @pending_registrations = []
+    end
+
+    def register(promise)
+      @pending_registrations << promise
+    end
+
+    def wait_for_all_data(end_when_complete: nil)
+      loop do
+        complete_pending_registrations
+
+        readers, writers, exceptions, wait_time = continue_to_read_pools
+
+        unless end_when_complete.nil?
+          return unless end_when_complete.pending?
+        end
+
+        break if readers.empty? && writers.empty? && exceptions.empty? && @pending_registrations.empty?
+
+        # if we have any pending promises to register, we'll not block at all so we immediately continue
+        wait_time = 0 unless @pending_registrations.empty?
+  
+        # we could be clever and decide which ones to "continue" on next
+        ready = IO.select(readers.keys, writers.keys, exceptions.keys, wait_time)
+        ready = [[], [], []] if ready.nil?
+        ready_readers, ready_writers, ready_exceptions = ready
+
+        # group by the pool object that provided the fd
+        @pool_ready_readers = ready_readers.group_by { |i| readers[i] }
+        @pool_ready_writers = ready_writers.group_by { |i| writers[i] }
+        @pool_ready_exceptions = ready_exceptions.group_by { |i| exceptions[i] }
+      end
+  
+      unless end_when_complete.nil?
+        raise ::IOPromise::Error.new('Internal error: IO loop completed without fulfilling the desired promise')
+      else
+        @pools.each do |pool|
+          pool.wait
+        end
+      end
+    ensure
+      complete_pending_registrations
+    end
+
+    private
+
+    def complete_pending_registrations
+      pending = @pending_registrations
+      @pending_registrations = []
+      pending.each do |promise|
+        register_now(promise)
+      end
+    end
+
+    def continue_to_read_pools
+      readers = {}
+      writers = {}
+      exceptions = {}
+      max_timeout = nil
+
+      @pools.each do |pool|
+        rd, wr, ex, ti = pool.execute_continue(@pool_ready_readers[pool], @pool_ready_writers[pool], @pool_ready_exceptions[pool])
+        rd.each do |io|
+          readers[io] = pool
+        end
+        wr.each do |io|
+          writers[io] = pool
+        end
+        ex.each do |io|
+          exceptions[io] = pool
+        end
+        if max_timeout.nil? || (!ti.nil? && ti < max_timeout)
+          max_timeout = ti
+        end
+      end
+
+      [readers, writers, exceptions, max_timeout]
+    end
+
+    def register_now(promise)
+      pool = promise.execute_pool
+      pool.register(promise)
+      @pools.add(pool)
+    end
+  end
+end

data/lib/iopromise/executor_pool/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module ExecutorPool
+    class Base
+      class << self
+        def for(connection_pool)
+          @executors ||= {}
+          @executors[connection_pool] ||= new(connection_pool)
+        end
+      end
+    
+      def initialize(connection_pool)
+        @connection_pool = connection_pool
+        @pending = []
+      end
+    
+      def register(item)
+        @pending << item
+      end
+
+      def complete(item)
+        @pending.delete(item)
+      end
+
+      def begin_executing(item)
+        item.beginning
+      end
+
+      # Continue execution of one or more pending IOPromises assigned to this pool.
+      # Returns [readers, writers, exceptions, max_timeout], which are arrays of the
+      # readers, writers, and exceptions to select on. The timeout specifies the maximum
+      # time to block waiting for one of these IO objects to become ready, after which
+      # this function is called again with empty "ready" arguments.
+      # Must be implemented by subclasses.
+      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+        raise NotImplementedError
+      end
+    
+      def sync
+        @pending.each do |promise|
+          promise.sync if promise.is_a?(Promise)
+        end
+      end
+    end
+  end
+end

data/lib/iopromise/executor_pool/batch.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module ExecutorPool
+    class Batch < Base
+      def initialize(connection_pool)
+        super(connection_pool)
+    
+        @current_batch = []
+      end
+    
+      def next_batch
+        # ensure that all current items are fully completed
+        @current_batch.each do |promise|
+          promise.wait
+        end
+        
+        # every pending operation becomes part of the current batch
+        @current_batch = @pending.dup
+      end
+    end
+  end
+end

data/lib/iopromise/executor_pool/sequential.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module ExecutorPool
+    class Sequential < Base
+      def execute_continue_item(item, ready_readers, ready_writers, ready_exceptions)
+        item.execute_continue(ready_readers, ready_writers, ready_exceptions)
+      end
+    
+      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+        @pending.dup.each do |active|
+          status = if active.fulfilled?
+            nil
+          else
+            execute_continue_item(active, ready_readers, ready_writers, ready_exceptions)
+          end
+          
+          unless status.nil?
+            # once we're waiting on our one next item, we're done
+            return status
+          else
+            # we're done with this one, so remove it
+            complete(active)
+          end
+        end
+    
+        # if we fall through to here, we have nothing to wait on.
+        [[], [], [], nil]
+      end
+    end
+  end
+end

data/lib/iopromise/faraday.rb

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

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

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