iopromise 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f58c2a28347c1f21fe6c660eff9f2b7ce1b078b1a06a37c91de0d6ec05db1c66
-  data.tar.gz: f5b2f6f66c5f79bb3f68f8cd041f6fecdde33dba2700b3f474ae9a76995378c9
+  metadata.gz: 1189b2ad73f76eff39b347922c03e2e40fc188ff95b7a6771da921d193c88ed5
+  data.tar.gz: 169d59659740616c94508bdd3fabfd8fd1850c2a593dade86fda7267efa03eb7
 SHA512:
-  metadata.gz: '09e91e024b854c41dd60942dc76af20795ca88807f3d6548bbf7d96982babd4c618e7054f9e63c640cca3eb4add0d08c347d8bb7a5ac5357c7969645817562c9'
-  data.tar.gz: d44281e24ab187944c15da2ceae76a1b8be8d8b54dd6a117f2783aec3418e12231283cfe3adc548d8d4d78536d5712c493126c0618f820f541e6142d33cc27dc
+  metadata.gz: 11f75193659f6f37295faf3d0ecea8166aa446da826da462cfc8ea5631eae2f107a65c1d093f1c082ae1e2690166f124244ea2ddf9bcc837ae3c6763e13ae063
+  data.tar.gz: d16beca1753c4c31994801787925b25713ac315599cc246dc19a92169fab7afe5948717454e9511be59735e542e8eea4805660c86c6c8de7a906a4e376848dc4

data/.github/workflows/main.yml

@@ -8,7 +8,7 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: Install dependencies
-      run: sudo apt-get install libcurl4-openssl-dev libsasl2-dev
+      run: sudo apt-get update && sudo apt-get install libcurl4-openssl-dev libsasl2-dev
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    iopromise (0.1.3)
+    iopromise (0.1.4)
       nio4r
       promise.rb (~> 0.7.4)
 

data/README.md

@@ -40,6 +40,7 @@ Or install it yourself as:
 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.
+ * [iopromise-dalli](https://github.com/iopromise-ruby/iopromise-dalli) supports [dalli](https://github.com/petergoldstein/dalli) memcached requests.
 
 ## Development
 

data/lib/iopromise.rb

@@ -4,6 +4,7 @@ require "promise"
 
 require_relative "iopromise/version"
 
+require_relative "iopromise/cancel_context"
 require_relative "iopromise/executor_context"
 require_relative "iopromise/executor_pool/base"
 require_relative "iopromise/executor_pool/batch"
@@ -11,6 +12,7 @@ require_relative "iopromise/executor_pool/sequential"
 
 module IOPromise
   class Error < StandardError; end
+  class CancelledError < Error; end
 
   class Base < ::Promise
     def instrument(begin_cb = nil, end_cb = nil)
@@ -41,13 +43,41 @@ module IOPromise
     end
 
     def fulfill(value)
+      return if cancelled?
       notify_completion(value: value)
       super(value)
     end
 
     def reject(reason)
+      return if cancelled?
       notify_completion(reason: reason)
       super(reason)
     end
+
+    def wait
+      raise IOPromise::CancelledError if cancelled?
+      super
+    end
+
+    # Subclasses are expected to implement 'execute_pool' to return an IOPromise::ExecutorPool
+    # that is responsible for completing the given promise.
+    def execute_pool
+      raise NotImplementedError
+    end
+
+    # makes this promise inert, ensuring that promise chains do not continue
+    # propegation once this promise has been cancelled.
+    def cancel
+      return unless pending?
+      
+      @cancelled = true
+      @observers = []
+
+      execute_pool.promise_cancelled(self)
+    end
+
+    def cancelled?
+      !!defined?(@cancelled)
+    end
   end
 end

data/lib/iopromise/cancel_context.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module IOPromise
+  class CancelContext
+    class << self
+      def context_stack
+        Thread.current[:iopromise_context_stack] ||= []
+      end
+
+      def current
+        context_stack.last
+      end
+
+      def push
+        new_ctx = CancelContext.new(current)
+        context_stack.push(new_ctx)
+        new_ctx
+      end
+
+      def pop
+        ctx = context_stack.pop
+        ctx.cancel
+        ctx
+      end
+
+      def with_new_context
+        ctx = push
+        yield ctx
+      ensure
+        pop
+      end
+    end
+
+    def initialize(parent)
+      parent.subscribe(self) unless parent.nil?
+    end
+
+    def subscribe(observer)
+      @observers ||= []
+      @observers.push observer
+    end
+
+    def cancel
+      return unless defined?(@observers)
+      @observers.each do |o|
+        o.cancel
+      end
+      @observers = []
+    end
+  end
+end

data/lib/iopromise/data_loader.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module DataLoader
+    module ClassMethods
+      def attr_promised_data(*args)
+        @promised_data_keys ||= []
+        @promised_data_keys.concat(args)
+
+        args.each do |arg|
+          self.class_eval("def #{arg};@#{arg}.sync;end")
+        end
+      end
+  
+      def promised_data_keys
+        @promised_data_keys ||= []
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def data_promises
+      self.class.promised_data_keys.flat_map do |k|
+        p = instance_variable_get('@' + k.to_s)
+        case p
+        when ::IOPromise::DataLoader
+          # greedily, recursively preload all nested data that we know about immediately
+          p.data_promises
+        when ::Promise
+          # allow nesting of dataloaders chained behind other promises
+          resolved = p.then do |result|
+            if result.is_a?(::IOPromise::DataLoader)
+              # likewise, if we resolved a promise that we can recurse, load that data too.
+              result.data_as_promise
+            else
+              result
+            end
+          end
+
+          [resolved]
+        else
+          raise TypeError.new("Instance variable #{k.to_s} used with attr_promised_data but was not a promise or a IOPromise::DataLoader.")
+        end
+      end
+    end
+
+    def data_as_promise
+      @data_as_promise ||= Promise.all(data_promises)
+    end
+
+    def sync
+      data_as_promise.sync
+      self
+    end
+  end
+end

data/lib/iopromise/deferred.rb

@@ -5,8 +5,8 @@ require_relative 'deferred/promise'
 module IOPromise
   module Deferred
     class << self
-      def new(&block)
-        ::IOPromise::Deferred::DeferredPromise.new(&block)
+      def new(*args, **kwargs, &block)
+        ::IOPromise::Deferred::DeferredPromise.new(*args, **kwargs, &block)
       end
     end
   end

data/lib/iopromise/deferred/executor_pool.rb

@@ -3,24 +3,42 @@
 module IOPromise
   module Deferred
     class DeferredExecutorPool < ::IOPromise::ExecutorPool::Batch
+      def initialize(*)
+        super
+
+        # register a dummy reader that never fires, to indicate to the event loop that
+        # there is a valid, active ExecutorPool.
+        @pipe_rd, @pipe_wr = IO.pipe
+        @iop_monitor = ::IOPromise::ExecutorContext.current.register_observer_io(self, @pipe_rd, :r)
+      end
+
       def execute_continue
         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|
+        # we are just running this in the sync cycle, in a blocking way.
+        timeouts = []
+        @current_batch.each do |promise|
+          time_until_execution = promise.time_until_execution
+          if time_until_execution <= 0
             begin_executing(promise)
             promise.run_deferred
+          else
+            timeouts << time_until_execution
           end
+        end
 
-          @current_batch = []
-
-          next_batch
+        if timeouts.empty?
+          @select_timeout = nil
+        else
+          # ensure we get back to this loop not too long after 
+          @select_timeout = timeouts.min
         end
 
-        # we always fully complete each cycle
+        # we reset the batch - the promises that are not completed will still be
+        # pending and will be available next time we are called.
+        @current_batch = []
       end
     end
   end

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
@@ -33,6 +37,15 @@ module IOPromise
           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

@@ -29,9 +29,14 @@ module IOPromise
 
     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
 
@@ -84,7 +89,7 @@ module IOPromise
       pending = @pending_registrations
       @pending_registrations = []
       pending.each do |promise|
-        register_now(promise)
+        register_now(promise) unless promise.cancelled?
       end
     end
 

data/lib/iopromise/executor_pool/base.rb

@@ -36,6 +36,9 @@ module IOPromise
       def promise_rejected(_reason, item)
         @pending.delete(item)
       end
+      def promise_cancelled(item)
+        @pending.delete(item)
+      end
 
       def begin_executing(item)
         item.beginning

data/lib/iopromise/rack/context_middleware.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'iopromise'
+
+module IOPromise
+  module Rack
+    class ContextMiddleware
+      def initialize(app)
+        @app = app
+      end
+    
+      def call(env)
+        IOPromise::CancelContext.with_new_context do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/iopromise/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IOPromise
-  VERSION = '0.1.3'
+  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.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Theo Julienne
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-06-18 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: promise.rb
@@ -60,6 +60,8 @@ files:
 - bin/setup
 - iopromise.gemspec
 - lib/iopromise.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
@@ -67,6 +69,7 @@ files:
 - lib/iopromise/executor_pool/base.rb
 - lib/iopromise/executor_pool/batch.rb
 - lib/iopromise/executor_pool/sequential.rb
+- lib/iopromise/rack/context_middleware.rb
 - lib/iopromise/version.rb
 - lib/iopromise/view_component.rb
 - lib/iopromise/view_component/data_loader.rb