iopromise 0.1.0 → 0.1.4

data/lib/iopromise/deferred/promise.rb

@@ -5,10 +5,14 @@ require_relative 'executor_pool'
 module IOPromise
   module Deferred
     class DeferredPromise < ::IOPromise::Base
-      def initialize(&block)
+      def initialize(timeout: nil, &block)
         super()
     
         @block = block
+        
+        unless timeout.nil?
+          @defer_until = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        end
     
         ::IOPromise::ExecutorContext.current.register(self) unless @block.nil?
       end
@@ -26,13 +30,22 @@ module IOPromise
       end
 
       def run_deferred
-        return if @block.nil?
+        return if @block.nil? || !pending?
         begin
           fulfill(@block.call)
         rescue => exception
           reject(exception)
         end
       end
+
+      def time_until_execution
+        return 0 unless defined?(@defer_until)
+
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return 0 if now > @defer_until
+
+        @defer_until - now
+      end
     end
   end
 end

data/lib/iopromise/executor_context.rb

@@ -1,68 +1,73 @@
 # 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)
       @pending_registrations << promise
+      IOPromise::CancelContext.current&.subscribe(promise)
     end
 
     def wait_for_all_data(end_when_complete: nil)
+      unless end_when_complete.nil?
+        raise IOPromise::CancelledError if end_when_complete.cancelled?
+      end
+
       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,43 +77,26 @@ 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|
-        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
+        register_now(promise) unless promise.cancelled?
       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,42 @@
 # 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
+      def promise_cancelled(item)
         @pending.delete(item)
       end
 
@@ -28,15 +45,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/rack/context_middleware.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'iopromise'
 
 module IOPromise
   module Rack
@@ -7,13 +10,9 @@ module IOPromise
       end
     
       def call(env)
-        ::IOPromise::ExecutorContext.push
-        begin
-          status, headers, body = @app.call(env)
-        ensure
-          ::IOPromise::ExecutorContext.pop
+        IOPromise::CancelContext.with_new_context do
+          @app.call(env)
         end
-        [status, headers, body]
       end
     end
   end

data/lib/iopromise/version.rb

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

data/lib/iopromise/view_component/data_loader.rb

@@ -1,56 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "../data_loader"
 require "view_component/engine"
 
 module IOPromise
   module ViewComponent
     module DataLoader
-      module ClassMethods
-        def attr_promised_data(*args)
-          @promised_data ||= []
-          @promised_data.concat(args)
-
-          args.each do |arg|
-            self.class_eval("def #{arg};@#{arg}.sync;end")
-          end
-        end
-    
-        def promised_data_keys
-          @promised_data ||= []
-        end
-      end
+      include ::IOPromise::DataLoader
 
       def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      def data_as_promise
-        @data_promise ||= begin
-          promises = self.class.promised_data_keys.map do |k|
-            p = instance_variable_get('@' + k.to_s)
-            if p.is_a?(IOPromise::ViewComponent::DataLoader)
-              # recursively preload all nested data
-              p.data_as_promise
-            else
-              # for any local promises, we'll unwrap them before completing
-              p.then do |result|
-                if result.is_a?(IOPromise::ViewComponent::DataLoader)
-                  # likewise, if we resolved a promise that we can recurse, load that data too.
-                  result.data_as_promise
-                else
-                  result
-                end
-              end
-            end
-          end
-
-          Promise.all(promises)
-        end
-      end
-
-      def sync
-        data_as_promise.sync
-        self
+        base.extend(::IOPromise::DataLoader::ClassMethods)
       end
 
       def render_in(*)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iopromise
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Theo Julienne
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-27 00:00:00.000000000 Z
+date: 2021-07-28 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:
@@ -46,12 +60,8 @@ 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/cancel_context.rb
+- lib/iopromise/data_loader.rb
 - lib/iopromise/deferred.rb
 - lib/iopromise/deferred/executor_pool.rb
 - lib/iopromise/deferred/promise.rb
@@ -59,16 +69,6 @@ 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