polyphony 0.31 → 0.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24126ff67fd9fd240299e1af8567da58f072c6c60df3f77b40f87ac108010f80
-  data.tar.gz: 95bcac53f361d65718aea1b55b557a7f68624d9815c38ee7c0cb79e11cb7bc96
+  metadata.gz: 75e18e7719d577fc1f07679874d2c3afe23b5a6b6184c1c6723006d0f9fcdf80
+  data.tar.gz: 347608163b6d0ec934b2a70d1b28ffd1c0056b3da51f242f6619ac4a8e94a3ad
 SHA512:
-  metadata.gz: 8849c26d4c2eccba56e786ac7ad76c2e2129244b619b988d649dca636491dd6158c0bed8feac191df9a7958f946592a8987a1e6709f27ef1383403b279f5595d
-  data.tar.gz: e8797e0b6e3852a208488213634b1360fc297e3ee9efa5c5e05d538a2684a02dfdf5efb00aca82b72064fc996a50c91de5c477a55ef5fd9dbf85275fd10e1f42
+  metadata.gz: 41cfdd7550a444c590b08eff7c2bf716ce42a19250074bca0425334be4b32b96efba4d60bbe9b1257cf3b8616be31da940695709a25af8c5d03c9803dff8fb80
+  data.tar.gz: 3a12af73aa84d4c3ae9e5c94c0dd55f99bd7eaf3ca49e1f59ab4b80d224dfe1dc068c68f4f8e09ab3d0bcc4996f61ae8d03c42158912f24458ad0ed1e09e6b2a

data/.rubocop.yml

@@ -7,7 +7,7 @@ AllCops:
     - 'test/**/*.rb'
     - 'examples/**/*.rb'
     - 'Gemfile*'
-    - lib/polyphony/http/agent.rb
+    - lib/polyphony/adapters/irb.rb
 
 Style/LambdaCall:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.32 2020-02-29
+
+* Accept optional throttling rate in `#spin_loop`
+* Remove CancelScope
+* Allow spinning fibers from a parent fiber other than the current
+* Add `#receive_pending` global API.
+* Prevent race condition in `Gyro::Queue`.
+* Improve signal handling - `INT`, `TERM` signals are now always handled in the
+  main fiber.
 * Fix adapter requires (redis and postgres).
 
 ## 0.31 2020-02-20

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.31)
+    polyphony (0.32)
       modulation (~> 1.0)
 
 GEM

data/TODO.md

@@ -1,56 +1,5 @@
 ## 0.32 Working Sinatra application
 
-  - Introduce mailbox limiting:
-    - add API for limiting mailbox size:
-
-      ```ruby
-      Fiber.current.mailbox_limit = 1000
-      ```
-
-    - Add the limit for `Gyro::Queue`
-
-      ```ruby
-      Gyro::Queue.new(1000)
-      ```
-
-    - Pushing to a limited queue will block if limit is reached
-
-  - Introduce selective receive:
-
-    ```ruby
-    # returns (or waits for) the first message for which the block returns true
-    (_, item) = receive { |msg| msg.first == ref }
-    ```
-
-    Possible implementation:
-
-    ```ruby
-    def receive
-      return @mailbox.shift unless block_given?
-      
-      loop
-        msg = @mailbox.shift
-        return msg if yield(msg)
-
-        # message didn't match condition, put it back in queue
-        @mailbox.push msg
-      end
-    end
-    ```
-
-- Test hypothetical situation 1:
-  - fiber A sends a request to fiber B
-  - fiber B terminates on a raised exception
-  - What happens to fiber A? (it should get the exception)
-
-- Accept rate/interval in `spin_loop` and `spin_worker_loop`:
-
-  ```ruby
-  spin_loop(10) { ... } # 10 times per second
-  spin_loop(rate: 10) { ... } # 10 times per second
-  spin_loop(interval: 10) { ... } # once every ten seconds
-  ```
-
 - Docs
   - landing page:
     - links to the interesting stuff
@@ -58,21 +7,21 @@
       - faq
       - benchmarks
   - explain difference between `sleep` and `suspend`
-  - concurrency overview: add explanation about async vs sync
-
-- move all adapters into polyphony/adapters
+  - add explanation about async vs sync
+  - discuss using `snooze` for ensuring responsiveness when executing CPU-bound work
 
 - Check why first call to `#sleep` returns too early in tests. Check the
   sleep behaviour in a spawned thread.
-- sintra app with database access (postgresql)
 
-## 0.33 Sidekick
+## 0.33 Sinatra / Sidekiq
 
-Plan of action:
+- sintra app with database access (postgresql)
 
-- fork sidekiq, make adjustments to Polyphony code
-- test performance
-- proceed from there
+- sidekiq: Plan of action
+  - see if we can get by just writing an adapter
+  - if not, fork sidekiq, make adjustments to Polyphony code
+  - test performance
+  - proceed from there
 
 ## 0.34 Testing && Docs
 
@@ -112,10 +61,8 @@ Prior art:
 ### DNS server
 
 ```ruby
-Server = import('../../lib/polyphony/dns/server')
-
-server = Server.new do |transaction|
-  puts "got query from #{transaction.info[:client_ip_address]}"
+require 'polyphony/dns'
+server = Polyphony::DNS::Server.new do |transaction|
   transaction.questions.each do |q|
     respond(transaction, q[:domain], q[:resource_class])
   end
@@ -129,3 +76,55 @@ Prior art:
 
 - https://github.com/socketry/async-dns
 
+### Work on API
+
+  - Introduce mailbox limiting:
+    - add API for limiting mailbox size:
+
+      ```ruby
+      Fiber.current.mailbox_limit = 1000
+      ```
+
+    - Add the limit for `Gyro::Queue`
+
+      ```ruby
+      Gyro::Queue.new(1000)
+      ```
+
+    - Pushing to a limited queue will block if limit is reached
+
+  - Introduce selective receive:
+
+    ```ruby
+    # returns (or waits for) the first message for which the block returns true
+    (_, item) = receive { |msg| msg.first == ref }
+    ```
+
+    Possible implementation:
+
+    ```ruby
+    def receive
+      return @mailbox.shift unless block_given?
+      
+      loop
+        msg = @mailbox.shift
+        return msg if yield(msg)
+
+        # message didn't match condition, put it back in queue
+        @mailbox.push msg
+      end
+    end
+    ```
+
+- Add option for setting the exception raised on cancelling using `#cancel_after`:
+
+  ```ruby
+  cancel_after(3, with_error: MyErrorClass) do
+    do_my_thing
+  end
+
+  # or a RuntimeError with message
+  cancel_after(3, with_error: 'Cancelling due to timeout') do
+    do_my_thing
+  end
+  ```

data/docs/main-concepts/exception-handling.md

@@ -209,8 +209,39 @@ trace.
 To ensure correct behaviour for these two signals, polyphony installs signal
 handlers that ensure that the main thread's event loop stops if it's currently
 running, and that the corresponding exceptions (namely `SystemExit` and
-`Interrupt`) are handled correctly by propagating them using Polyphony's normal
-exception handling mechanisms.
+`Interrupt`) are handled correctly by passing them to the main fiber.
+
+### Graceful process termination
+
+In order to ensure your application terminates gracefully upon receiving an
+`INT` or `TERM` signal, you'll need to:
+
+1. Rescue the corresponding exceptions in the main fiber.
+2. Rescue `Polyphony::Terminate` exceptions in each fiber that needs to perform
+   operations such as handling any pending requests, etc.
+
+```ruby
+# In a worker fiber
+def do_work
+  loop do
+    req = receive
+    handle_req(req)
+  end
+rescue Polyphony::Terminate
+  # We still need to handle any pending request
+  receive_pending.each { handle_req(req) }
+end
+
+# on the main fiber
+begin
+  spin_up_lots_fibers
+rescue Interrupt, SystemExit
+  Fiber.current.terminate_all_children
+  Fiber.current.await_all_children
+end
+```
+
+### Handling other signals
 
 Care should be taken when handling other signals. There are two options for
 correctly handling the signals: using Ruby's stock `trap` method, and using
@@ -219,16 +250,30 @@ usual, but making sure we're not inside the event loop:
 
 ```ruby
 trap('SIGHUP') do
-  Thread.current.break_out_of_ev_loop(nil)
+  Thread.current.break_out_of_ev_loop(Thread.current.main_fiber, nil)
   handle_hup_signal
 end
 ```
 
-The alternative is to use `Polyphony.wait_for_signal`:
+A second technique that might be useful is to use a `Gyro::Async` watcher and
+signal it when the process signal is trapped:
+
+```ruby
+sighup_async = Gyro::Async.new
+sighup_handler = spin_loop do
+  sighup_async.await
+  handle_sighup
+end
+
+trap('SIGHUP') { sighup_async.signal }
+```
+
+Another alternative is to use `Polyphony.wait_for_signal`, which uses a
+`Gyro::Signal` watcher under the hood:
 
 ```ruby
 hup_handler = spin_loop do
-  Polyphony.wait_for_signal
+  Polyphony.wait_for_signal('SIGHUP')
   handle_hup_signal
 end
 ```

data/ext/gyro/queue.c

@@ -58,7 +58,7 @@ VALUE Gyro_Queue_push(VALUE self, VALUE value) {
 
   if (RARRAY_LEN(queue->wait_queue) > 0) {
     VALUE async = rb_ary_shift(queue->wait_queue);
-    return rb_funcall(async, ID_signal_bang, 1, value);
+    rb_funcall(async, ID_signal_bang, 1, Qnil);
   }
   
   rb_ary_push(queue->queue, value);
@@ -69,15 +69,15 @@ VALUE Gyro_Queue_shift(VALUE self) {
   struct Gyro_Queue *queue;
   GetGyro_Queue(self, queue);
 
-  if (RARRAY_LEN(queue->queue) > 0) {
-    return rb_ary_shift(queue->queue);
+  while (1) {
+    if (RARRAY_LEN(queue->queue) > 0) {
+      return rb_ary_shift(queue->queue);
+    }
+    
+    VALUE async = rb_funcall(cGyro_Async, ID_new, 0);
+    rb_ary_push(queue->wait_queue, async);
+    Gyro_Async_await(async);
   }
-  
-  VALUE async = rb_funcall(cGyro_Async, ID_new, 0);
-  rb_ary_push(queue->wait_queue, async);
-  VALUE ret = Gyro_Async_await(async);
-  RB_GC_GUARD(async);
-  return ret;
 }
 
 VALUE Gyro_Queue_shift_no_wait(VALUE self) {

data/ext/gyro/thread.c

@@ -233,9 +233,11 @@ VALUE Thread_current_event_selector() {
   return rb_ivar_get(rb_thread_current(), ID_ivar_event_selector);
 }
 
-VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE resume_obj) {
+VALUE Thread_fiber_break_out_of_ev_loop(VALUE self, VALUE fiber, VALUE resume_obj) {
   VALUE selector = rb_ivar_get(self, ID_ivar_event_selector);
-  Thread_schedule_fiber_with_priority(self, rb_fiber_current(), resume_obj);
+  if (fiber != Qnil) {
+    Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
+  }
 
   if (Gyro_Selector_break_out_of_ev_loop(selector) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
@@ -273,7 +275,7 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "stop_event_selector", Thread_stop_event_selector, 0);
   rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
-  rb_define_method(rb_cThread, "break_out_of_ev_loop", Thread_fiber_break_out_of_ev_loop, 1);
+  rb_define_method(rb_cThread, "break_out_of_ev_loop", Thread_fiber_break_out_of_ev_loop, 2);
 
   rb_define_method(rb_cThread, "schedule_fiber", Thread_schedule_fiber, 2);
   rb_define_method(rb_cThread, "schedule_fiber_with_priority",

data/lib/polyphony.rb

@@ -28,15 +28,13 @@ module Polyphony
   Net = import './polyphony/net'
 
   auto_import(
-    CancelScope:  './polyphony/core/cancel_scope',
     Channel:      './polyphony/core/channel',
     FS:           './polyphony/adapters/fs',
     ResourcePool: './polyphony/core/resource_pool',
     Sync:         './polyphony/core/sync',
     ThreadPool:   './polyphony/core/thread_pool',
     Throttler:    './polyphony/core/throttler',
-    Trace:        './polyphony/adapters/trace',
-    Websocket:    './polyphony/websocket'
+    Trace:        './polyphony/adapters/trace'
   )
 
   class << self
@@ -70,7 +68,7 @@ end
 def install_terminating_signal_handler(signal, exception_class)
   trap(signal) do
     exception = exception_class.new
-    Thread.current.break_out_of_ev_loop(exception)
+    Thread.current.break_out_of_ev_loop(Thread.current.main_fiber, exception)
   end
 end
 

data/lib/polyphony/adapters/irb.rb

@@ -9,7 +9,7 @@ if Object.constants.include?(:Reline)
       raise if read_ios.size > 1
       raise if write_ios.size > 0
       raise if error_ios.size > 0
-      
+
       fiber = Fiber.current
       timer = spin do
         sleep timeout
@@ -43,9 +43,10 @@ else
     end
   end
 
+  # RubyLex patches
   class ::RubyLex
     class TerminateLineInput2 < RuntimeError
     end
     const_set(:TerminateLineInput, TerminateLineInput2)
   end
-end
+end

data/lib/polyphony/core/exceptions.rb

@@ -1,29 +1,28 @@
 # frozen_string_literal: true
 
-export :Interrupt, :MoveOn, :Cancel, :Terminate
+export :MoveOn, :Cancel, :Terminate
 
 # Common exception class for interrupting fibers. These exceptions allow
-# control of fibers. Interrupt exceptions can encapsulate a value and thus
+# control of fibers. BaseException exceptions can encapsulate a value and thus
 # provide a way to interrupt long-running blocking operations while still
-# passing a value back to the call site. Interrupt exceptions can also
+# passing a value back to the call site. BaseException exceptions can also
 # references a cancel scope in order to allow correct bubbling of exceptions
 # through nested cancel scopes.
-class Interrupt < ::Exception
-  attr_reader :scope, :value
+class BaseException < ::Exception
+  attr_reader :value
 
-  def initialize(scope = nil, value = nil)
-    @scope = scope
+  def initialize(value = nil)
     @value = value
   end
 end
 
 # MoveOn is used to interrupt a long-running blocking operation, while
 # continuing the rest of the computation.
-class MoveOn < Interrupt; end
+class MoveOn < BaseException; end
 
 # Cancel is used to interrupt a long-running blocking operation, bubbling the
 # exception up through cancel scopes and supervisors.
-class Cancel < Interrupt; end
+class Cancel < BaseException; end
 
 # Terminate is used to interrupt a fiber once its parent fiber has terminated.
-class Terminate < Interrupt; end
+class Terminate < BaseException; end

data/lib/polyphony/core/global_api.rb

@@ -32,8 +32,14 @@ module API
     Fiber.current.spin(tag, caller, &block)
   end
 
-  def spin_loop(tag = nil, &block)
-    Fiber.current.spin(tag, caller) { loop(&block) }
+  def spin_loop(tag = nil, rate: nil, &block)
+    if rate
+      Fiber.current.spin(tag, caller) do
+        throttled_loop(rate, &block)
+      end
+    else
+      Fiber.current.spin(tag, caller) { loop(&block) }
+    end
   end
 
   def every(interval)
@@ -50,7 +56,7 @@ module API
     fiber = ::Fiber.current
     canceller = spin do
       sleep interval
-      fiber.schedule Exceptions::MoveOn.new(nil, with_value)
+      fiber.schedule Exceptions::MoveOn.new(with_value)
     end
     block.call
   rescue Exceptions::MoveOn => e
@@ -63,6 +69,10 @@ module API
     Fiber.current.receive
   end
 
+  def receive_pending
+    Fiber.current.receive_pending
+  end
+
   def sleep(duration = nil)
     return sleep_forever unless duration
 

data/lib/polyphony/extensions/fiber.rb

@@ -23,7 +23,7 @@ module FiberControl
   def interrupt(value = nil)
     return if @running == false
 
-    schedule Exceptions::MoveOn.new(nil, value)
+    schedule Exceptions::MoveOn.new(value)
   end
   alias_method :stop, :interrupt
 
@@ -139,6 +139,10 @@ module FiberMessaging
   def receive
     @mailbox.shift
   end
+
+  def receive_pending
+    @mailbox.shift_each
+  end
 end
 
 # Methods for controlling child fibers
@@ -149,7 +153,7 @@ module ChildFiberControl
 
   def spin(tag = nil, orig_caller = caller, &block)
     f = Fiber.new { |v| f.run(v) }
-    f.prepare(tag, block, orig_caller)
+    f.prepare(tag, block, orig_caller, self)
     (@children ||= {})[f] = true
     f
   end
@@ -180,13 +184,13 @@ class ::Fiber
 
   extend FiberControlClassMethods
 
-  attr_accessor :tag, :thread
+  attr_accessor :tag, :thread, :parent
 
-  def prepare(tag, block, caller)
+  def prepare(tag, block, caller, parent)
     __fiber_trace__(:fiber_create, self)
     @thread = Thread.current
     @tag = tag
-    @parent = Fiber.current
+    @parent = parent
     @caller = caller
     @block = block
     @mailbox = Gyro::Queue.new

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.31'
+  VERSION = '0.32'
 end

data/test/test_fiber.rb

@@ -13,6 +13,24 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
+  def test_children_parent
+    assert_nil Fiber.current.parent
+
+    f1 = spin {}
+    f2 = spin {}
+
+    assert_equal [f1, f2], Fiber.current.children
+    assert_equal Fiber.current, f1.parent
+    assert_equal Fiber.current, f2.parent
+  end
+
+  def test_spin_from_different_fiber
+    f1 = spin { sleep }
+    f2 = f1.spin { sleep }
+    assert_equal f1, f2.parent
+    assert_equal [f2], f1.children
+  end
+
   def test_await
     result = nil
     f = Fiber.current.spin do
@@ -744,6 +762,36 @@ class MailboxTest < MiniTest::Test
     f.await
     assert_equal ['foo'] * 100, messages
   end
+
+  def test_receive_pending
+    assert_equal [], receive_pending
+
+    (1..5).each { |i| Fiber.current << i }
+    assert_equal (1..5).to_a, receive_pending
+    assert_equal [], receive_pending
+  end
+
+  def test_receive_pending_on_termination
+    buffer = []
+    worker = spin do
+      loop { buffer << receive }
+    rescue Polyphony::Terminate
+      receive_pending.each { |r| buffer << r }
+    end
+
+    worker << 1
+    worker << 2
+    10.times { snooze }
+    assert_equal [1, 2], buffer
+
+    worker << 3
+    worker << 4
+    worker << 5
+    worker.terminate
+    worker.await
+
+    assert_equal (1..5).to_a, buffer
+  end
 end
 
 class FiberControlTest < MiniTest::Test

data/test/test_global_api.rb

@@ -42,92 +42,6 @@ class SpinTest < MiniTest::Test
   end
 end
 
-class CancelScopeTest < Minitest::Test
-  def sleep_with_cancel(ctx, mode = nil)
-    Polyphony::CancelScope.new(mode: mode).call do |c|
-      ctx[:cancel_scope] = c
-      ctx[:result] = sleep(0.01)
-    end
-  end
-
-  def test_that_cancel_scope_cancels_fiber
-    ctx = {}
-    spin do
-      after(0.005) { ctx[:cancel_scope].cancel! }
-      sleep_with_cancel(ctx, :cancel)
-    rescue Exception => e
-      ctx[:result] = e
-      nil
-    end
-    assert_nil ctx[:result]
-    # async operation will only begin on next iteration of event loop
-    assert_nil ctx[:cancel_scope]
-
-    Thread.current.switch_fiber
-    assert_kind_of Polyphony::CancelScope, ctx[:cancel_scope]
-    assert_kind_of Polyphony::Cancel, ctx[:result]
-  end
-
-  def test_that_cancel_scope_cancels_async_op_with_stop
-    ctx = {}
-    spin do
-      after(0) { ctx[:cancel_scope].cancel! }
-      sleep_with_cancel(ctx, :stop)
-    end
-
-    Thread.current.switch_fiber
-    assert ctx[:cancel_scope]
-    assert_nil ctx[:result]
-  end
-
-  def test_that_cancel_after_raises_cancelled_exception
-    result = nil
-    spin do
-      cancel_after(0.01) do
-        sleep(1000)
-      end
-      result = 42
-    rescue Polyphony::Cancel
-      result = :cancelled
-    end
-    suspend
-    assert_equal :cancelled, result
-  end
-
-  # def test_that_cancel_scopes_can_be_nested
-  #   inner_result = nil
-  #   outer_result = nil
-  #   spin do
-  #     Polyphony::CancelScope.new(timeout: 0.01) do
-  #       Polyphony::CancelScope.new(timeout: 0.02) do
-  #         sleep(1000)
-  #       end
-  #       inner_result = 42
-  #     end
-  #     outer_result = 42
-  #   end
-  #   suspend
-  #   assert_nil inner_result
-  #   assert_equal 42, outer_result
-
-  #   Polyphony.reset!
-
-  #   outer_result = nil
-  #   spin do
-  #     move_on_after(0.02) do
-  #       move_on_after(0.01) do
-  #         sleep(1000)
-  #       end
-  #       inner_result = 42
-  #     end
-  #     outer_result = 42
-  #   end
-  #   suspend
-  #   assert_equal 42, inner_result
-  #   assert_equal 42, outer_result
-  # end
-end
-
 class ExceptionTest < MiniTest::Test
   def test_cross_fiber_backtrace
     error = nil
@@ -195,7 +109,9 @@ class MoveOnAfterTest < MiniTest::Test
     assert t1 - t0 < 0.02
     assert_equal :bar, v
   end
+end
 
+class SpinTest < MiniTest::Test
   def test_spin_without_tag
     f = spin { }
     assert_kind_of Fiber, f
@@ -207,7 +123,9 @@ class MoveOnAfterTest < MiniTest::Test
     assert_kind_of Fiber, f
     assert_equal :foo, f.tag
   end
+end
 
+class SpinLoopTest < MiniTest::Test
   def test_spin_loop
     buffer = []
     counter = 0
@@ -243,6 +161,17 @@ class MoveOnAfterTest < MiniTest::Test
     assert_equal :my_loop, f.tag
   end
 
+  def test_spin_loop_with_rate
+    buffer = []
+    counter = 0
+    f = spin_loop(rate: 50) { buffer << (counter += 1) }
+    sleep 0.1
+    f.stop
+    assert counter >= 5 && counter <= 6
+  end
+end
+
+class ThrottledLoopTest < MiniTest::Test
   def test_throttled_loop
     buffer = []
     counter = 0
@@ -263,7 +192,9 @@ class MoveOnAfterTest < MiniTest::Test
     f.await
     assert_equal [1, 2, 3, 4, 5], buffer    
   end
+end
 
+class GlobalAPIEtcTest < MiniTest::Test
   def test_every
     buffer = []
     f = spin do

data/test/test_signal.rb

@@ -38,7 +38,7 @@ class SignalTest < MiniTest::Test
 end
 
 class SignalTrapTest < Minitest::Test
-  def test_signal_exception_propagation
+  def test_signal_exception_handling
     i, o = IO.pipe
     pid = Polyphony.fork do
       i.close
@@ -46,12 +46,10 @@ class SignalTrapTest < Minitest::Test
         spin do
           sleep 1
         rescue ::Interrupt => e
+          # the signal will be trapped in the context of this fiber
           o.puts "1-interrupt"
           raise e
         end.await
-      rescue ::Interrupt => e
-        o.puts "2-interrupt"
-        raise e
       end.await
     rescue ::Interrupt => e
       o.puts "3-interrupt"
@@ -64,7 +62,36 @@ class SignalTrapTest < Minitest::Test
     Process.kill('INT', pid)
     watcher.await
     buffer = i.read
-    assert_equal "1-interrupt\n2-interrupt\n3-interrupt\n", buffer
+    assert_equal "3-interrupt\n", buffer
+  end
+
+  def test_signal_exception_with_cleanup
+    i, o = IO.pipe
+    pid = Polyphony.fork do
+      i.close
+      spin do
+        spin do
+          sleep
+        rescue Polyphony::Terminate
+          o.puts "1 - terminated"
+        end.await
+      rescue Polyphony::Terminate
+        o.puts "2 - terminated"
+      end.await
+    rescue Interrupt
+      o.puts "3 - interrupted"
+      Fiber.current.terminate_all_children
+      Fiber.current.await_all_children
+    ensure
+      o.close
+    end
+    sleep 0.01
+    o.close
+    watcher = Gyro::Child.new(pid)
+    Process.kill('INT', pid)
+    watcher.await
+    buffer = i.read
+    assert_equal "3 - interrupted\n2 - terminated\n1 - terminated\n", buffer
   end
 
   def test_signal_exception_possible_race_condition
@@ -106,6 +133,6 @@ class SignalTrapTest < Minitest::Test
     Process.kill('INT', pid)
     Gyro::Child.new(pid).await
     buffer = i.read
-    assert_equal "1-interrupt\n3-interrupt\n", buffer
+    assert_equal "3-interrupt\n", buffer
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.31'
+  version: '0.32'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-28 00:00:00.000000000 Z
+date: 2020-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: modulation
@@ -298,7 +298,6 @@ files:
 - examples/core/xx-queue-async.rb
 - examples/core/xx-readpartial.rb
 - examples/core/xx-recurrent-timer.rb
-- examples/core/xx-resource_cancel.rb
 - examples/core/xx-resource_delegate.rb
 - examples/core/xx-signals.rb
 - examples/core/xx-sleep-forever.rb
@@ -383,7 +382,6 @@ files:
 - lib/polyphony/adapters/postgres.rb
 - lib/polyphony/adapters/redis.rb
 - lib/polyphony/adapters/trace.rb
-- lib/polyphony/core/cancel_scope.rb
 - lib/polyphony/core/channel.rb
 - lib/polyphony/core/exceptions.rb
 - lib/polyphony/core/global_api.rb
@@ -405,7 +403,6 @@ files:
 - test/helper.rb
 - test/run.rb
 - test/test_async.rb
-- test/test_cancel_scope.rb
 - test/test_ext.rb
 - test/test_fiber.rb
 - test/test_global_api.rb

data/examples/core/xx-resource_cancel.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'polyphony'
-
-resource_count = 0
-Pool = Polyphony::ResourcePool.new(limit: 3) do
-  +"resource#{resource_count += 1}"
-end
-
-def user(number)
-  loop do
-    Polyphony::CancelScope.new(timeout: 0.2) do |scope|
-      scope.on_cancel { puts "#{number} (cancelled)" }
-      Pool.acquire do |r|
-        puts "#{number} #{r.inspect} >"
-        sleep(0.1 + rand * 0.2)
-        puts "#{number} #{r.inspect} <"
-      end
-    end
-  end
-end
-
-10.times do |x|
-  spin { user(x + 1) }
-end
-
-t0 = Time.now
-throttled_loop(0.1) { puts "uptime: #{Time.now - t0}" }

data/lib/polyphony/core/cancel_scope.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-export_default :CancelScope
-
-require 'fiber'
-
-Exceptions = import('./exceptions')
-
-# A cancellation scope that can be used to cancel an asynchronous task
-class CancelScope
-  def initialize(opts = {}, &block)
-    @opts = opts
-    @fibers = []
-    start_timeout_waiter if @opts[:timeout]
-    call(&block) if block
-  end
-
-  def error_class
-    @opts[:mode] == :cancel ? Exceptions::Cancel : Exceptions::MoveOn
-  end
-
-  def cancel!
-    @cancelled = true
-    @fibers.each do |f|
-      f.schedule error_class.new(self, @opts[:value])
-    end
-    @on_cancel&.()
-  end
-
-  def start_timeout_waiter
-    @timeout_waiter = spin do
-      sleep @opts[:timeout]
-      @timeout_waiter = nil
-      cancel!
-    end
-  end
-
-  def stop_timeout_waiter
-    return unless @timeout_waiter
-
-    @timeout_waiter.stop
-    @timeout_waiter = nil
-  end
-
-  def reset_timeout
-    return unless @timeout_waiter
-
-    @timeout_waiter.stop
-    start_timeout_waiter
-  end
-
-  # def disable
-  #   @timeout&.stop
-  # end
-
-  def call
-    fiber = Fiber.current
-    @fibers << fiber
-    yield self
-  rescue Exceptions::MoveOn => e
-    e.scope == self ? e.value : raise(e)
-  ensure
-    @fibers.delete fiber
-    stop_timeout_waiter if @fibers.empty? && @timeout_waiter
-  end
-
-  def on_cancel(&block)
-    @on_cancel = block
-  end
-
-  def cancelled?
-    @cancelled
-  end
-end

data/test/test_cancel_scope.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class CancelScopeTest < MiniTest::Test
-  def test_that_cancel_scope_can_cancel_provided_block
-    buffer = []
-    Polyphony::CancelScope.new { |scope|
-      spin { scope.cancel! }
-      buffer << 1
-      snooze
-      buffer << 2
-    }
-    assert_equal [1], buffer
-  end
-
-  def test_that_cancel_scope_can_cancel_multiple_fibers
-    buffer = []
-    scope = Polyphony::CancelScope.new
-    fibers = (1..3).map { |i|
-      spin {
-        scope.call do
-          buffer << i
-          snooze
-          buffer << i * 10
-        end
-      }
-    }
-    snooze
-    scope.cancel!
-    assert_equal [1, 2, 3], buffer
-  end
-
-  def test_that_cancel_scope_takes_timeout_option
-    buffer = []
-    Polyphony::CancelScope.new(timeout: 0.01) { |scope|
-      buffer << 1
-      sleep 0.02
-      buffer << 2
-    }
-    assert_equal [1], buffer
-  end
-
-  def test_that_cancel_scope_cancels_timeout_waiter_if_block_provided
-    buffer = []
-    t0 = Time.now
-    scope = Polyphony::CancelScope.new(timeout: 1) { |scope|
-      buffer << 1
-    }
-    assert_equal [1], buffer
-    assert Time.now - t0 < 1
-    assert_nil scope.instance_variable_get(:@timeout_waiter)
-  end
-
-  def test_that_cancel_scope_can_cancel_multiple_fibers_with_timeout
-    buffer = []
-    t0 = Time.now
-    scope = Polyphony::CancelScope.new(timeout: 0.02)
-    fibers = (1..3).map { |i|
-      spin {
-        scope.call do
-          buffer << i
-          sleep i
-          buffer << i * 10
-        end
-      }
-    }
-    Fiber.await(*fibers)
-    assert Time.now - t0 < 0.05
-    assert_equal [1, 2, 3], buffer
-  end
-
-  def test_reset_timeout
-    buffer = []
-    scope = Polyphony::CancelScope.new(timeout: 0.01)
-    t0 = Time.now
-    scope.call {
-      sleep 0.005
-      scope.reset_timeout
-      sleep 0.005
-    }
-
-    assert !scope.cancelled?
-  end
-
-  def test_on_cancel
-    buffer = []
-    Polyphony::CancelScope.new { |scope|
-      spin { scope.cancel! }
-      scope.on_cancel { buffer << :cancelled }
-      buffer << 1
-      snooze
-      buffer << 2
-    }
-    assert_equal [1, :cancelled], buffer
-  end
-
-  def test_cancelled?
-    scope = Polyphony::CancelScope.new
-    spin {
-      scope.call { sleep 1 }
-    }
-
-    snooze
-    assert !scope.cancelled?
-    scope.cancel!
-    assert scope.cancelled?
-  end
-end