iopromise 0.1.1 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 323b4f0107580d674fa42c4f65644dcae302c822c9d370dd9e3effbf5b4c13eb
-  data.tar.gz: dc8b3937fea0505e598c0855ccc695b98dc837e221b8959a61acfbf18838c3b5
+  metadata.gz: 566685c55c8c71504647196e5cc9edcb96cde013c316a9b5a8b2ad771afde67e
+  data.tar.gz: 4928d07726ea8b3df4a79fa056fd3b0ce3c6e5b2493f166b5ea0d7261346b8c6
 SHA512:
-  metadata.gz: 8737b6c9a1e1ee2376f586ceca83a074679d6e0b53e073e07df8817f3f14fe261b606f5398618bcd984f2441b288b89fb9d660f499428d60c93cf35e7b561f7e
-  data.tar.gz: c82ed8d1da207ce2bfa766b8a1fd88aa4ba803565b749f4c77e0cb90a5b8f9c0289f60111260daf4acc5b7ddaae43b0ddcadd91212201778516b1637f9db2cb6
+  metadata.gz: 9b849e9d40682cda87bf901c734a65a7db10f27c9bcfa22f9760a06943c386c617dccc7f1f186fd92da6fa42956ac8b56384b7be0e4f081bd4e78e5cfd7ecf1f
+  data.tar.gz: 174b5ab72c8a3ef1c6de7a412bcaa35f2a1165066494b7b9e4cbe22d8b858ea57ed0fb274a20a34020dcaffdbd4e998ddd067512ac031174fb4b3ff9c069420a

data/.github/workflows/main.yml

@@ -8,8 +8,7 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: Install dependencies
-      run: sudo apt-get install libcurl4-openssl-dev libsasl2-dev
-    - uses: niden/actions-memcached@v7
+      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

@@ -10,17 +10,11 @@ gem "rake", "~> 13.0"
 gem "rspec", "~> 3.0"
 
 group :development, :test do
-  # faraday adapter
-  gem 'faraday'
-  gem 'typhoeus'
-
-  # memcached adapter
-  gem 'memcached', :git => 'https://github.com/theojulienne/memcached.git', :branch => 'continuable-get'
-
-  # dalli adapter
-  gem 'dalli', "= 2.7.11"
-
   # view_component extensions
   gem "rails"
   gem "view_component", require: "view_component/engine"
+
+  # benchmarking
+  gem "benchmark-ips"
+  gem "stackprof"
 end

data/Gemfile.lock

@@ -1,15 +1,9 @@
-GIT
-  remote: https://github.com/theojulienne/memcached.git
-  revision: 18c1da3708f3e7dca316b2f0143b4f05116f7672
-  branch: continuable-get
-  specs:
-    memcached (2.0.0.alpha)
-
 PATH
   remote: .
   specs:
-    iopromise (0.1.0)
-      promise.rb
+    iopromise (0.1.5)
+      nio4r
+      promise.rb (~> 0.7.4)
 
 GEM
   remote: https://rubygems.org/
@@ -73,24 +67,12 @@ GEM
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
+    benchmark-ips (2.9.1)
     builder (3.2.4)
     concurrent-ruby (1.1.8)
     crass (1.0.6)
-    dalli (2.7.11)
     diff-lcs (1.4.4)
     erubi (1.10.0)
-    ethon (0.14.0)
-      ffi (>= 1.15.0)
-    faraday (1.4.1)
-      faraday-excon (~> 1.1)
-      faraday-net_http (~> 1.0)
-      faraday-net_http_persistent (~> 1.1)
-      multipart-post (>= 1.2, < 3)
-      ruby2_keywords (>= 0.0.4)
-    faraday-excon (1.1.0)
-    faraday-net_http (1.0.1)
-    faraday-net_http_persistent (1.1.0)
-    ffi (1.15.0)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
     i18n (1.8.10)
@@ -104,7 +86,6 @@ GEM
     method_source (1.0.0)
     mini_mime (1.0.3)
     minitest (5.14.4)
-    multipart-post (2.1.1)
     nio4r (2.5.7)
     nokogiri (1.11.3-x86_64-linux)
       racc (~> 1.4)
@@ -153,7 +134,6 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.2)
-    ruby2_keywords (0.0.4)
     sprockets (4.0.2)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
@@ -161,9 +141,8 @@ GEM
       actionpack (>= 4.0)
       activesupport (>= 4.0)
       sprockets (>= 3.0.0)
+    stackprof (0.2.17)
     thor (1.1.0)
-    typhoeus (1.4.0)
-      ethon (>= 0.9.0)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     view_component (2.31.1)
@@ -177,14 +156,12 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
-  dalli (= 2.7.11)
-  faraday
+  benchmark-ips
   iopromise!
-  memcached!
   rails
   rake (~> 13.0)
   rspec (~> 3.0)
-  typhoeus
+  stackprof
   view_component
 
 BUNDLED WITH

data/README.md

@@ -1,6 +1,23 @@
-# iopromise
+# IOPromise
 
-This **experimental pre-release** gem extends promise.rb promises to support an extremely simple pattern for \"continuing\" execution of all pending promises in an asynchronous non-blocking way.
+IOPromise is a pattern that allows parallel execution of IO-bound requests (data store and RPCs) behind the abstraction of promises, without needing to introduce the complexity of threading. It uses [promise.rb](https://github.com/lgierth/promise.rb) for promises, and [nio4r](https://github.com/socketry/nio4r) to implement the IO loop.
+
+A simple example of this behaviour is using [iopromise-faraday](https://github.com/iopromise-ruby/iopromise-faraday) to perform concurrent HTTP requests:
+```ruby
+require 'iopromise/faraday'
+
+conn = IOPromise::Faraday.new('https://github.com/')
+
+promises = (1..3).map do
+  conn.get('/status')
+end
+
+Promise.all(promises).then do |responses|
+  responses.each_with_index do |response, i|
+    puts "#{i}: #{response.body.strip} #{response.headers["x-github-request-id"]}"
+  end
+end.sync
+```
 
 ## Installation
 
@@ -20,7 +37,10 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+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/bin/setup

@@ -4,6 +4,3 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
-
-# bring up a memcached for testing
-docker run -d -p 11211:11211 memcached:alpine

data/iopromise.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'promise.rb', '~> 0.7.4'
+  spec.add_dependency 'nio4r'
 end

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,44 +12,72 @@ require_relative "iopromise/executor_pool/sequential"
 
 module IOPromise
   class Error < StandardError; end
+  class CancelledError < Error; end
 
   class Base < ::Promise
-    def initialize(*)
-      @instrument_begin = []
-      @instrument_end = []
-      @started_executing = false
-      
-      super
-    end
-
     def instrument(begin_cb = nil, end_cb = nil)
-      raise ::IOPromise::Error.new("Instrumentation called after promise already started executing") if @started_executing
-      @instrument_begin << begin_cb unless begin_cb.nil?
-      @instrument_end << end_cb unless end_cb.nil?
+      raise ::IOPromise::Error.new("Instrumentation called after promise already started executing") if started_executing?
+      unless begin_cb.nil?
+        @instrument_begin ||= []
+        @instrument_begin << begin_cb
+      end
+      unless end_cb.nil?
+        @instrument_end ||= []
+        @instrument_end << end_cb
+      end
     end
 
     def beginning
-      @instrument_begin.each { |cb| cb.call(self) }
+      @instrument_begin&.each { |cb| cb.call(self) }
+      @instrument_begin&.clear
       @started_executing = true
     end
 
     def started_executing?
-      @started_executing
+      !!@started_executing
     end
 
     def notify_completion(value: nil, reason: nil)
-      @instrument_end.each { |cb| cb.call(self, value: value, reason: reason) }
-      @instrument_end = []
+      @instrument_end&.each { |cb| cb.call(self, value: value, reason: reason) }
+      @instrument_end&.clear
     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,65 @@
+# frozen_string_literal: true
+
+module IOPromise
+  module DataLoader
+    module ClassMethods
+      def attr_async(attr_name, build_func = nil)
+        self.attr_async_names << attr_name
+
+        if build_func.nil?
+          self.class_eval("def async_#{attr_name};@#{attr_name};end")
+        else
+          self.define_method("async_#{attr_name}") do
+            @attr_async_memo ||= {}
+            @attr_async_memo[attr_name] ||= self.instance_exec(&build_func)
+          end
+        end
+
+        self.class_eval("def #{attr_name};async_#{attr_name}.sync;end")
+      end
+  
+      def attr_async_names
+        @attr_async_names ||= []
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def async_attributes
+      @async_attributes ||= Promise.all(attr_async_promises)
+    end
+
+    def sync
+      async_attributes.sync
+      self
+    end
+
+    protected
+    def attr_async_promises
+      self.class.attr_async_names.flat_map do |k|
+        p = send("async_#{k}")
+        case p
+        when ::IOPromise::DataLoader
+          # greedily, recursively preload all nested data that we know about immediately
+          p.attr_async_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.async_attributes
+            else
+              result
+            end
+          end
+
+          [resolved]
+        else
+          raise TypeError.new("Instance variable #{k.to_s} used with attr_async but was not a promise or a IOPromise::DataLoader.")
+        end
+      end
+    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,26 +3,42 @@
 module IOPromise
   module Deferred
     class DeferredExecutorPool < ::IOPromise::ExecutorPool::Batch
-      def execute_continue(ready_readers, ready_writers, ready_exceptions)
+      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
-            complete(promise)
+          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
-        return [[], [], [], nil]
+        # 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