polyphony 0.68 → 0.72

data/test/test_supervise.rb

@@ -3,12 +3,6 @@
 require_relative 'helper'
 
 class SuperviseTest < MiniTest::Test
-  def test_supervise_with_no_arguments
-    assert_raises(RuntimeError) do
-      supervise
-    end
-  end
-  
   def test_supervise_with_block
     buffer = []
     f1 = spin(:f1) { receive }
@@ -26,79 +20,253 @@ class SuperviseTest < MiniTest::Test
     assert_equal [[f1, 'foo'], [f2, 'bar']], buffer
   end
 
-#   def test_supervise_with_restart
-#     watcher = spin { receive }
-#     parent = spin { supervise(restart: true, watcher: watcher) }
-#     snooze
-
-#     buffer = []
-#     f1 = parent.spin do
-#       buffer << 'f1'
-#     end
-
-#     f1.await
-#     assert_equal ['f1'], buffer
-#     watcher.await
-#     assert_equal ['f1', 'f1'], buffer
-#   end
-
-#   def test_supervise_with_restart_on_error
-#     parent = spin { supervise(restart: true) }
-#     snooze
-
-#     buffer = []
-#     f1 = parent.spin do
-#       buffer << 'f1'
-#       buffer << receive
-#     end
-
-#     snooze
-#     assert_equal ['f1'], buffer
-
-#     f1.raise 'foo'
-
-#     3.times { snooze }
-
-#     assert_equal ['f1', 'f1'], buffer
-#     assert_equal :dead, f1.state
-
-#     # f1 should have been restarted by supervisor
-#     f1 = parent.children.first
-#     assert_kind_of Fiber, f1
-
-#     f1 << 'foo'
-#     f1.await
-
-#     assert_equal ['f1', 'f1', 'foo'], buffer
-#   end
-
-#   def test_supervisor_termination
-#     f = nil
-#     p = spin do
-#       f = spin { sleep 1 }
-#       supervise
-#     end
-#     sleep 0.01
-
-#     p.terminate
-#     p.await
-
-#     assert :dead, f.state
-#     assert :dead, p.state
-#   end
-
-#   def test_supervisor_termination_with_restart
-#     f = nil
-#     p = spin do
-#       f = spin { sleep 1 }
-#       supervise(restart: true)
-#     end
-#     sleep 0.01
-
-#     p.terminate
-#     p.await
-
-#     assert :dead, f.state
-#     assert :dead, p.state
-#   end
+  def test_supervise_with_on_done
+    buffer = []
+    f1 = spin(:f1) { receive }
+    f2 = spin(:f2) { receive }
+    supervisor = spin(:supervisor) do
+      supervise(f1, f2, on_done: ->(*args) { buffer << args })
+    end
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    10.times { snooze }
+    assert_equal [[f1, 'foo']], buffer
+
+    f2 << 'bar'
+    f2.await
+    assert_equal [[f1, 'foo'], [f2, 'bar']], buffer
+  end
+
+  def test_supervise_with_on_error
+    buffer = []
+    f1 = spin(:f1) { receive }
+    f2 = spin(:f2) { receive }
+    supervisor = spin(:supervisor) do
+      supervise(f1, f2, on_error: ->(*args) { buffer << args })
+    end
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    10.times { snooze }
+    assert_equal [], buffer
+
+    e = RuntimeError.new('blah')
+    f2.raise(e)
+    3.times { snooze }
+    assert_equal [[f2, e]], buffer
+  end
+
+  def test_supervise_with_manual_restart
+    buffer = []
+    f1 = spin(:f1) { receive }
+    supervisor = spin(:supervisor) do
+      supervise(f1) do |f, r|
+        buffer << [f, r]
+        f.restart
+      end
+    end
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    snooze
+    assert_equal [[f1, 'foo']], buffer
+
+    10.times { snooze }
+
+    assert_equal 1, supervisor.children.size
+    f2 = supervisor.children.first
+    assert f1 != f2
+    assert_equal :f1, f2.tag
+    assert_equal supervisor, f2.parent
+
+    e = RuntimeError.new('bar')
+    f2.raise(e)
+    f2.await rescue nil
+    3.times { snooze }
+    assert_equal [[f1, 'foo'], [f2, e]], buffer
+
+    assert_equal 1, supervisor.children.size
+    f3 = supervisor.children.first
+    assert f2 != f3
+    assert f1 != f3
+    assert_equal :f1, f3.tag
+    assert_equal supervisor, f3.parent
+  end
+
+  def test_supervise_with_restart_always
+    buffer = []
+    f1 = spin(:f1) do
+      buffer << receive
+    rescue => e
+      buffer << e
+      e
+    end
+    supervisor = spin(:supervisor) { supervise(f1, restart: :always) }
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    snooze
+    assert_equal ['foo'], buffer
+
+    10.times { snooze }
+
+    assert_equal 1, supervisor.children.size
+    f2 = supervisor.children.first
+    assert f1 != f2
+    assert_equal :f1, f2.tag
+    assert_equal supervisor, f2.parent
+
+    e = RuntimeError.new('bar')
+    f2.raise(e)
+    f2.await rescue nil
+    3.times { snooze }
+    assert_equal ['foo', e], buffer
+
+    assert_equal 1, supervisor.children.size
+    f3 = supervisor.children.first
+    assert f2 != f3
+    assert f1 != f3
+    assert_equal :f1, f3.tag
+    assert_equal supervisor, f3.parent
+  end
+
+  def test_supervise_with_restart_true
+    buffer = []
+    f1 = spin(:f1) do
+      buffer << receive
+    rescue => e
+      buffer << e
+      e
+    end
+    supervisor = spin(:supervisor) { supervise(f1, restart: true) }
+
+    snooze
+    f1 << 'foo'
+    f1.await
+    snooze
+    assert_equal ['foo'], buffer
+
+    10.times { snooze }
+
+    assert_equal 1, supervisor.children.size
+    f2 = supervisor.children.first
+    assert f1 != f2
+    assert_equal :f1, f2.tag
+    assert_equal supervisor, f2.parent
+
+    e = RuntimeError.new('bar')
+    f2.raise(e)
+    f2.await rescue nil
+    3.times { snooze }
+    assert_equal ['foo', e], buffer
+
+    assert_equal 1, supervisor.children.size
+    f3 = supervisor.children.first
+    assert f2 != f3
+    assert f1 != f3
+    assert_equal :f1, f3.tag
+    assert_equal supervisor, f3.parent
+  end
+
+  def test_supervise_with_restart_on_error
+    buffer = []
+    f1 = spin(:f1) do
+      buffer << receive
+    rescue => e
+      buffer << e
+      e
+    end
+    supervisor = spin(:supervisor) { supervise(f1, restart: :on_error) }
+
+    snooze
+    e = RuntimeError.new('bar')
+    f1.raise(e)
+    f1.await rescue nil
+    snooze
+    assert_equal [e], buffer
+
+    10.times { snooze }
+
+    assert_equal 1, supervisor.children.size
+    f2 = supervisor.children.first
+    assert f1 != f2
+    assert_equal :f1, f2.tag
+    assert_equal supervisor, f2.parent
+
+    f2 << 'foo'
+    f2.await rescue nil
+    3.times { snooze }
+    assert_equal [e, 'foo'], buffer
+
+    assert_equal 0, supervisor.children.size
+  end
+
+  def test_supervise_terminate
+    buffer = []
+    f1 = spin(:f1) do
+      buffer << receive
+    rescue => e
+      buffer << e
+      e
+    end
+    supervisor = spin(:supervisor) { supervise(f1, restart: :on_error) }
+
+    sleep 0.05
+    supervisor.terminate
+    supervisor.await
+
+    assert_equal [], buffer
+  end
+
+  def test_supervise_without_explicit_fibers
+    buffer = []
+    first = nil
+    supervisor = spin do
+      3.times do |i|
+        f = spin do
+          first = Fiber.current if i == 0
+          receive
+          buffer << i
+        end
+      end
+      Fiber.current.parent << :ok
+      supervise(restart: :always)
+    end
+    msg = receive
+    assert_equal :ok, msg
+    assert_equal 3, supervisor.children.size
+
+    sleep 0.1
+    assert_equal [], buffer
+
+    old_first = first
+    first << :foo
+    first = nil
+    snooze
+    assert_equal [0], buffer
+
+    snooze
+    assert_equal 3, supervisor.children.size
+    snooze
+    assert first
+    assert first != old_first
+  end
+
+  def test_supervise_with_added_fibers
+    buffer = []
+    supervisor = spin do
+      supervise { |f, r| buffer << [f, r] }
+    end
+    snooze
+    f1 = supervisor.spin { snooze; :foo }
+    f2 = supervisor.spin { snooze; :bar }
+    Fiber.await(f1, f2)
+    snooze
+    assert_equal [[f1, :foo], [f2, :bar]], buffer
+  end
 end

data/test/test_sync.rb

@@ -104,12 +104,12 @@ class MutexTest < MiniTest::Test
     snooze
     assert !lock.locked?
     a << Fiber.current
-    
+
     receive
     assert lock.locked?
 
     a << Fiber.current
-    
+
     receive
     assert !lock.locked?
   end

data/test/test_thread.rb

@@ -180,7 +180,7 @@ class ThreadTest < MiniTest::Test
     assert_equal count, GC.count
     sleep 0.05
     assert_equal count, GC.count
-    
+
     return unless IS_LINUX
 
     # The idle tasks are ran at most once per fiber switch, before the backend
@@ -207,7 +207,7 @@ class ThreadTest < MiniTest::Test
     counter = 0
 
     Thread.current.on_idle { counter += 1 }
-    
+
     3.times { snooze }
     assert_equal 0, counter
 
@@ -220,4 +220,24 @@ class ThreadTest < MiniTest::Test
     3.times { snooze }
     assert_equal 2, counter
   end
+
+  def test_cross_thread_receive
+    buf = []
+    f = Fiber.current
+    t = Thread.new do
+      f << true
+      while (msg = receive)
+        buf << msg
+      end
+    end
+
+    receive # wait for thread to be ready
+    t << 1
+    t << 2
+    t << 3
+    t << nil
+
+    t.join
+    assert_equal [1, 2, 3], buf
+  end
 end

data/test/test_thread_pool.rb

@@ -67,7 +67,7 @@ class ThreadPoolTest < MiniTest::Test
 
     assert_in_range 0.0..0.009, elapsed
     assert buffer.size < 2
-    
+
     sleep 0.15 # allow time for threads to spawn
     assert_equal @pool.size, threads.uniq.size
     assert_equal (0..9).to_a, buffer.sort if IS_LINUX

data/test/test_throttler.rb

@@ -34,7 +34,7 @@ class ThrottlerTest < MiniTest::Test
     f = spin { loop { t.process { buffer << 1 } } }
     sleep 0.02
     f.stop
-    assert_in_range 2..3, buffer.size
+    assert_in_range 2..4, buffer.size
   ensure
     t.stop
   end

data/test/test_timer.rb

@@ -137,11 +137,11 @@ class TimerMiscTest < MiniTest::Test
     @timer = Polyphony::Timer.new(resolution: 0.001)
     sleep 0
   end
-  
+
   def teardown
     @timer.stop
   end
-    
+
   def test_timer_after
     buffer = []
     f = @timer.after(0.01) { buffer << 2 }

data/test/test_trace.rb

@@ -7,7 +7,7 @@ class TraceTest < MiniTest::Test
     events = []
     Thread.backend.trace_proc = proc { |*e| events << e }
     snooze
-    
+
     assert_equal [
       [:fiber_schedule, Fiber.current, nil, false],
       [:fiber_switchpoint, Fiber.current],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.68'
+  version: '0.72'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-13 00:00:00.000000000 Z
+date: 2021-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -144,6 +144,7 @@ extensions:
 extra_rdoc_files:
 - README.md
 files:
+- ".github/FUNDING.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".gitmodules"
@@ -215,6 +216,9 @@ files:
 - examples/adapters/sequel_mysql_pool.rb
 - examples/adapters/sequel_pg.rb
 - examples/core/await.rb
+- examples/core/calc.rb
+- examples/core/calc_with_restart.rb
+- examples/core/calc_with_supervise.rb
 - examples/core/channels.rb
 - examples/core/deferring-an-operation.rb
 - examples/core/enumerable.rb
@@ -421,7 +425,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Fine grained concurrency for Ruby