iopromise 0.1.1 → 0.1.2

data/lib/iopromise/dalli/promise.rb

@@ -9,16 +9,19 @@ module IOPromise
 
       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) unless @server.nil? || @key.nil?
+        
+        ::IOPromise::ExecutorContext.current.register(self)
       end
     
       def wait
-        if @server.nil? || @key.nil?
+        unless defined?(@server)
           super
         else
           ::IOPromise::ExecutorContext.current.wait_for_all_data(end_when_complete: self)
@@ -26,7 +29,12 @@ module IOPromise
       end
     
       def execute_pool
-        DalliExecutorPool.for(@server)
+        return @pool if defined?(@pool)
+        if defined?(@server)
+          @pool = DalliExecutorPool.for(@server)
+        else
+          @pool = nil
+        end
       end
 
       def in_select_loop

data/lib/iopromise/deferred/executor_pool.rb

@@ -3,7 +3,7 @@
 module IOPromise
   module Deferred
     class DeferredExecutorPool < ::IOPromise::ExecutorPool::Batch
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+      def execute_continue
         if @current_batch.empty?
           next_batch
         end
@@ -13,7 +13,6 @@ module IOPromise
           @current_batch.each do |promise|
             begin_executing(promise)
             promise.run_deferred
-            complete(promise)
           end
 
           @current_batch = []
@@ -22,7 +21,6 @@ module IOPromise
         end
 
         # we always fully complete each cycle
-        return [[], [], [], nil]
       end
     end
   end

data/lib/iopromise/deferred/promise.rb

@@ -26,7 +26,7 @@ module IOPromise
       end
 
       def run_deferred
-        return if @block.nil?
+        return if @block.nil? || !pending?
         begin
           fulfill(@block.call)
         rescue => exception

data/lib/iopromise/executor_context.rb

@@ -1,32 +1,30 @@
 # frozen_string_literal: true
 
 require 'set'
+require 'nio'
 
 module IOPromise
   class ExecutorContext
     class << self
-      def push
-        @contexts ||= []
-        @contexts << ExecutorContext.new
-      end
-
       def current
-        @contexts.last
-      end
-
-      def pop
-        @contexts.pop
+        @context ||= ExecutorContext.new
       end
     end
 
     def initialize
-      @pools = Set.new
-
-      @pool_ready_readers = {}
-      @pool_ready_writers = {}
-      @pool_ready_exceptions = {}
+      @pools = {}
 
       @pending_registrations = []
+
+      @selector = NIO::Selector.new
+
+      super
+    end
+
+    def register_observer_io(observer, io, interest)
+      monitor = @selector.register(io, interest)
+      monitor.value = observer
+      monitor
     end
 
     def register(promise)
@@ -37,32 +35,34 @@ module IOPromise
       loop do
         complete_pending_registrations
 
-        readers, writers, exceptions, wait_time = continue_to_read_pools
-
+        @pools.each do |pool, _|
+          pool.execute_continue
+        end
+        
         unless end_when_complete.nil?
           return unless end_when_complete.pending?
         end
-
-        break if readers.empty? && writers.empty? && exceptions.empty? && @pending_registrations.empty?
+        
+        break if @selector.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] }
+        unless @pending_registrations.empty?
+          wait_time = 0
+        else
+          wait_time = nil
+          @pools.each do |pool, _|
+            timeout = pool.select_timeout
+            wait_time = timeout if wait_time.nil? || (!timeout.nil? && timeout < wait_time)
+          end
+        end
+        
+        ready_count = select(wait_time)
       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|
+        @pools.each do |pool, _|
           pool.wait
         end
       end
@@ -72,7 +72,15 @@ module IOPromise
 
     private
 
+    def select(wait_time)
+      @selector.select(wait_time) do |monitor|
+        observer = monitor.value
+        observer.monitor_ready(monitor, monitor.readiness)
+      end
+    end
+
     def complete_pending_registrations
+      return if @pending_registrations.empty?
       pending = @pending_registrations
       @pending_registrations = []
       pending.each do |promise|
@@ -80,35 +88,10 @@ module IOPromise
       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)
+      @pools[pool] = true
     end
   end
 end

data/lib/iopromise/executor_pool/base.rb

@@ -1,25 +1,39 @@
 # frozen_string_literal: true
 
+require 'promise/observer'
+
 module IOPromise
   module ExecutorPool
     class Base
+      include Promise::Observer
+
       class << self
         def for(connection_pool)
           @executors ||= {}
           @executors[connection_pool] ||= new(connection_pool)
         end
       end
+
+      attr_accessor :select_timeout
     
       def initialize(connection_pool)
         @connection_pool = connection_pool
         @pending = []
+
+        @monitors = {}
+
+        @select_timeout = nil
       end
     
       def register(item)
         @pending << item
+        item.subscribe(self, item, item)
       end
 
-      def complete(item)
+      def promise_fulfilled(_value, item)
+        @pending.delete(item)
+      end
+      def promise_rejected(_reason, item)
         @pending.delete(item)
       end
 
@@ -28,15 +42,17 @@ module IOPromise
       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.
+      # Implementations may choose to pre-register IO handled using:
+      #   ExecutorContext.current.register_observer_io(...)
+      # Alternatively, they can be registered when this function is called.
+      # During this function, implementations should check for timeouts and run
+      # any housekeeping operations.
+      #
       # Must be implemented by subclasses.
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+      def execute_continue
         raise NotImplementedError
       end
-    
+      
       def sync
         @pending.each do |promise|
           promise.sync if promise.is_a?(Promise)

data/lib/iopromise/executor_pool/batch.rb

@@ -3,8 +3,8 @@
 module IOPromise
   module ExecutorPool
     class Batch < Base
-      def initialize(connection_pool)
-        super(connection_pool)
+      def initialize(*)
+        super
     
         @current_batch = []
       end
@@ -16,7 +16,9 @@ module IOPromise
         end
         
         # every pending operation becomes part of the current batch
-        @current_batch = @pending.dup
+        # we don't include promises with a source set, because that
+        # indicates that they depend on another promise now.
+        @current_batch = @pending.select { |p| p.pending? && p.source.nil? }
       end
     end
   end

data/lib/iopromise/executor_pool/sequential.rb

@@ -3,29 +3,21 @@
 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)
+      def execute_continue_item(item)
+        item.execute_continue
       end
     
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+      def execute_continue
         @pending.dup.each do |active|
-          status = if active.fulfilled?
-            nil
-          else
-            execute_continue_item(active, ready_readers, ready_writers, ready_exceptions)
-          end
+          execute_continue_item(active)
           
-          unless status.nil?
+          unless active.fulfilled?
             # 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)
+            return
           end
         end
     
         # if we fall through to here, we have nothing to wait on.
-        [[], [], [], nil]
       end
     end
   end

data/lib/iopromise/memcached/executor_pool.rb

@@ -3,6 +3,12 @@
 module IOPromise
   module Memcached
     class MemcacheExecutorPool < ::IOPromise::ExecutorPool::Batch
+      def initialize(*)
+        super
+
+        @monitors = {}
+      end
+
       def next_batch
         super
 
@@ -14,7 +20,6 @@ module IOPromise
           rescue => e
             @keys_to_promises.values.flatten.each do |promise|
               promise.reject(e)
-              complete(promise)
               @current_batch.delete(promise)
             end
 
@@ -23,12 +28,17 @@ module IOPromise
         end
       end
 
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+      def execute_continue
         if @current_batch.empty?
           next_batch
         end
 
-        return [[], [], [], nil] if @current_batch.empty?
+        if @current_batch.empty?
+          @monitors.each do |_, monitor|
+            monitor.interests = nil
+          end
+          return
+        end
 
         so_far, readers, writers = memcache_client.continue_get_multi
 
@@ -45,12 +55,23 @@ module IOPromise
             next if promise.fulfilled?
 
             promise.fulfill(value)
-            complete(promise)
             @current_batch.delete(promise)
           end
         end
 
-        [readers, writers, [], nil]
+        @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

data/lib/iopromise/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iopromise
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Theo Julienne
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-27 00:00:00.000000000 Z
+date: 2021-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: promise.rb
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.4
+- !ruby/object:Gem::Dependency
+  name: nio4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 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.
 email:
@@ -59,17 +73,10 @@ files:
 - lib/iopromise/executor_pool/base.rb
 - lib/iopromise/executor_pool/batch.rb
 - lib/iopromise/executor_pool/sequential.rb
-- lib/iopromise/faraday.rb
-- lib/iopromise/faraday/connection.rb
-- lib/iopromise/faraday/continuable_hydra.rb
-- lib/iopromise/faraday/executor_pool.rb
-- lib/iopromise/faraday/multi_socket_action.rb
-- lib/iopromise/faraday/promise.rb
 - lib/iopromise/memcached.rb
 - lib/iopromise/memcached/client.rb
 - lib/iopromise/memcached/executor_pool.rb
 - lib/iopromise/memcached/promise.rb
-- lib/iopromise/rack/context_middleware.rb
 - lib/iopromise/version.rb
 - lib/iopromise/view_component.rb
 - lib/iopromise/view_component/data_loader.rb