polyphony 0.66 → 0.70

data/test/test_process_supervision.rb

@@ -6,7 +6,7 @@ class ProcessSupervisionTest < MiniTest::Test
   def test_process_supervisor_with_block
     i, o = IO.pipe
 
-    f = spin do
+    watcher = spin do
       Polyphony.watch_process do
         i.close
         sleep 5
@@ -14,31 +14,60 @@ class ProcessSupervisionTest < MiniTest::Test
         o << 'foo'
         o.close
       end
-      supervise(on_error: :restart)
     end
 
+    supervisor = spin { supervise(watcher, restart: :always) }
+
     sleep 0.05
-    f.terminate
-    f.await
+    supervisor.terminate
+    supervisor.await
 
     o.close
     msg = i.read
-    i.close
     assert_equal 'foo', msg
   end
 
+  def test_process_supervisor_restart_with_block
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+
+    count = 0
+    watcher = spin do
+      count += 1
+      Polyphony.watch_process do
+        i1.gets
+        o2.puts count
+      end
+    end
+
+    supervisor = spin { supervise(watcher, restart: :always) }
+
+    o1.puts
+    l = i2.gets
+    assert_equal "1\n", l
+
+    o1.puts
+    l = i2.gets
+    assert_equal "2\n", l
+
+    o1.puts
+    l = i2.gets
+    assert_equal "3\n", l
+  end
+
   def test_process_supervisor_with_cmd
     fn = '/tmp/test_process_supervisor_with_cmd'
     FileUtils.rm(fn) rescue nil
 
-    f = spin do
+    watcher = spin do
       Polyphony.watch_process("echo foo >> #{fn}")
-      supervise(on_error: :restart)
     end
 
+    supervisor = spin { supervise(watcher) }
+
     sleep 0.05
-    f.terminate
-    f.await
+    supervisor.terminate
+    supervisor.await
 
     assert_equal "foo\n", IO.read(fn)
 

data/test/test_supervise.rb

@@ -2,103 +2,186 @@
 
 require_relative 'helper'
 
-# class SuperviseTest < MiniTest::Test
-#   def test_supervise
-#     p = spin { supervise }
-#     snooze
-#     f1 = p.spin { receive }
-#     f2 = p.spin { receive }
-
-#     snooze
-#     assert_equal p.state, :waiting
-#     f1 << 'foo'
-#     f1.await
-#     snooze
-
-#     assert_equal :waiting, p.state
-#     assert_equal :waiting, f2.state
-
-#     f2 << 'bar'
-#     f2.await
-#     assert_equal :runnable, p.state
-    
-#     3.times { snooze }
-#     assert_equal :dead, p.state
-#   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
-# end
+class SuperviseTest < MiniTest::Test
+  def test_supervise_with_block
+    buffer = []
+    f1 = spin(:f1) { receive }
+    f2 = spin(:f2) { receive }
+    supervisor = spin(:supervisor) { supervise(f1, f2) { |*args| buffer << args } }
+
+    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_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_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
+end

data/test/test_thread_pool.rb

@@ -70,7 +70,7 @@ class ThreadPoolTest < MiniTest::Test
     
     sleep 0.15 # allow time for threads to spawn
     assert_equal @pool.size, threads.uniq.size
-    assert_equal (0..9).to_a, buffer.sort
+    assert_equal (0..9).to_a, buffer.sort if IS_LINUX
   end
 
   def test_busy?

data/test/test_throttler.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.66'
+  version: '0.70'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-01 00:00:00.000000000 Z
+date: 2021-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -156,6 +156,7 @@ files:
 - README.md
 - Rakefile
 - TODO.md
+- bin/pdbg
 - bin/polyphony-debug
 - bin/stress.rb
 - bin/test
@@ -356,6 +357,7 @@ files:
 - lib/polyphony/core/thread_pool.rb
 - lib/polyphony/core/throttler.rb
 - lib/polyphony/core/timer.rb
+- lib/polyphony/debugger.rb
 - lib/polyphony/extensions/core.rb
 - lib/polyphony/extensions/debug.rb
 - lib/polyphony/extensions/fiber.rb