polyphony 0.57.0 → 0.60

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -29,13 +29,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency  'pry',                  '0.13.1'
   
   s.add_development_dependency  'msgpack',              '1.4.2'
-  s.add_development_dependency  'pg',                   '1.1.4'
-  s.add_development_dependency  'redis',                '4.1.0'
-  s.add_development_dependency  'hiredis',              '0.6.3'
-  s.add_development_dependency  'http_parser.rb',       '~>0.6.0'
-  s.add_development_dependency  'rack',                 '>=2.0.8', '<2.3.0'
-  s.add_development_dependency  'mysql2',               '0.5.3'
-  s.add_development_dependency  'sequel',               '5.34.0'
   s.add_development_dependency  'httparty',             '0.17.1'
   s.add_development_dependency  'localhost',            '~>1.1.4'
 

data/test/test_backend.rb

@@ -33,7 +33,7 @@ class BackendTest < MiniTest::Test
   def test_write_read_partial
     i, o = IO.pipe
     buf = +''
-    f = spin { @backend.read(i, buf, 5, false) }
+    f = spin { @backend.read(i, buf, 5, false, 0) }
     @backend.write(o, 'Hello world')
     return_value = f.await
     
@@ -44,7 +44,7 @@ class BackendTest < MiniTest::Test
   def test_write_read_to_eof_limited_buffer
     i, o = IO.pipe
     buf = +''
-    f = spin { @backend.read(i, buf, 5, true) }
+    f = spin { @backend.read(i, buf, 5, true, 0) }
     @backend.write(o, 'Hello')
     snooze
     @backend.write(o, ' world')
@@ -59,7 +59,7 @@ class BackendTest < MiniTest::Test
   def test_write_read_to_eof
     i, o = IO.pipe
     buf = +''
-    f = spin { @backend.read(i, buf, 10**6, true) }
+    f = spin { @backend.read(i, buf, 10**6, true, 0) }
     @backend.write(o, 'Hello')
     snooze
     @backend.write(o, ' world')
@@ -71,6 +71,33 @@ class BackendTest < MiniTest::Test
     assert_equal return_value, buf
   end
 
+  def test_write_read_with_buffer_position
+    i, o = IO.pipe
+    buf = +'abcdefghij'
+    f = spin { @backend.read(i, buf, 20, false, 0) }
+    @backend.write(o, 'blah')
+    return_value = f.await
+    
+    assert_equal 'blah', buf
+    assert_equal return_value, buf
+
+    buf = +'abcdefghij'
+    f = spin { @backend.read(i, buf, 20, false, -1) }
+    @backend.write(o, 'klmn')
+    return_value = f.await
+    
+    assert_equal 'abcdefghijklmn', buf
+    assert_equal return_value, buf
+
+    buf = +'abcdefghij'
+    f = spin { @backend.read(i, buf, 20, false, 3) }
+    @backend.write(o, 'DEF')
+    return_value = f.await
+    
+    assert_equal 'abcDEF', buf
+    assert_equal return_value, buf
+  end
+
   def test_waitpid
     pid = fork do
       @backend.post_fork
@@ -87,7 +114,7 @@ class BackendTest < MiniTest::Test
     buf = []
     f = spin do
       buf << :ready
-      @backend.read_loop(i) { |d| buf << d }
+      @backend.read_loop(i, 8192) { |d| buf << d }
       buf << :done
     end
 
@@ -107,7 +134,7 @@ class BackendTest < MiniTest::Test
     parent = spin do
       f = spin do
         buf << :ready
-        @backend.read_loop(i) { |d| buf << d }
+        @backend.read_loop(i, 8192) { |d| buf << d }
         buf << :done
       end
       suspend
@@ -125,6 +152,16 @@ class BackendTest < MiniTest::Test
     assert_equal [:ready, 'foo', 'bar'], buf
   end
 
+  def test_read_loop_with_max_len
+    r, w = IO.pipe
+
+    w << 'foobar'
+    w.close
+    buf = []
+    @backend.read_loop(r, 3) { |data| buf << data }
+    assert_equal ['foo', 'bar'], buf
+  end
+
   Net = Polyphony::Net
 
   def test_accept
@@ -340,9 +377,38 @@ class BackendTest < MiniTest::Test
     # GC period.
     sleep 0.05
     assert_equal count + 1, GC.count
+
+    @backend.idle_gc_period = 0
+    count = GC.count
+    sleep 0.001
+    sleep 0.002
+    sleep 0.003
+    assert_equal count, GC.count
   ensure
     GC.enable
   end
+
+  def test_idle_proc
+    counter = 0
+
+    @backend.idle_proc = proc { counter += 1 }
+    
+    3.times { snooze }
+    assert_equal 0, counter
+
+    sleep 0.01
+    assert_equal 1, counter
+    sleep 0.01
+    assert_equal 2, counter
+
+    assert_equal 2, counter
+    3.times { snooze }
+    assert_equal 2, counter
+
+    @backend.idle_proc = nil
+    sleep 0.01
+    assert_equal 2, counter
+  end
 end
 
 class BackendChainTest < MiniTest::Test

data/test/test_ext.rb

@@ -42,7 +42,7 @@ class ExceptionTest < MiniTest::Test
 end
 
 class ProcessTest < MiniTest::Test
-  def test_detach
+  def test_process_detach
     pid = Polyphony.fork { sleep 0.05; exit! 42 }
     buffer = []
     spin { 3.times { |i| buffer << i; snooze } }

data/test/test_fiber.rb

@@ -43,6 +43,14 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
+  def test_await_dead_children
+    f1 = spin { :foo }
+    f2 = spin { :bar }
+    2.times { snooze }
+    
+    assert_equal [:foo, :bar], Fiber.await(f1, f2)
+  end
+
   def test_await_from_multiple_fibers
     buffer = []
     f1 = spin {
@@ -348,12 +356,12 @@ class FiberTest < MiniTest::Test
     assert_equal [:foo, :terminate], buffer
   end
 
-  CMD_TERMINATE_MAIN_FIBER = <<~BASH
-    ruby -rbundler/setup -rpolyphony -e"spin { sleep 0.1; Thread.current.main_fiber.terminate }; begin; sleep; rescue Polyphony::Terminate; STDOUT << 'terminated'; end" 2>&1
+  CMD_TERMINATE_CHILD_FIBER = <<~BASH
+    ruby -rbundler/setup -rpolyphony -e'f = spin { sleep }; spin { sleep 0.1; f.terminate }; f.await' 2>&1
   BASH
 
-  CMD_TERMINATE_CHILD_FIBER = <<~BASH
-    ruby -rbundler/setup -rpolyphony -e"f = spin { sleep }; spin { sleep 0.1; f.terminate }; f.await" 2>&1
+  CMD_TERMINATE_MAIN_FIBER = <<~BASH
+    ruby -rbundler/setup -rpolyphony -e"spin { sleep 0.1; Thread.current.main_fiber.terminate }; begin; sleep; rescue Polyphony::Terminate; STDOUT << 'terminated'; end" 2>&1
   BASH
 
   def test_terminate_main_fiber
@@ -547,24 +555,38 @@ class FiberTest < MiniTest::Test
     assert f.location =~ location
   end
 
-  def test_when_done
-    flag = nil
-    values = []
-    f = spin do
-      snooze until flag
+  def test_monitor
+    child = nil
+    parent = spin do
+      child = spin { receive }
+      child.await
     end
-    f.when_done { values << 42 }
 
     snooze
-    assert values.empty?
-    snooze
-    flag = true
-    assert values.empty?
-    assert f.alive?
+    child.monitor
+    spin { child << :foo }
+
+    msg = receive
+    assert_equal [child, :foo], msg
+  end
 
+  def test_unmonitor
+    child = nil
+    parent = spin(:parent) do
+      child = spin(:child) { receive }
+      child.await
+    end
+
+    snooze
+    child.monitor
+    spin { child << :foo }
     snooze
-    assert_equal [42], values
-    assert !f.running?
+
+    child.unmonitor
+
+    Fiber.current << :bar
+    msg = receive
+    assert_equal :bar, msg
   end
 
   def test_children
@@ -732,6 +754,72 @@ class FiberTest < MiniTest::Test
     assert_equal ['bar'], buffer
     snooze
   end
+
+  def test_detach
+    buf = []
+    child = nil
+    parent = spin(:parent) do
+      buf << :hi_from_parent
+      child = spin(:child) do
+        buf << :hi_from_child
+        # wait for message (from main fiber)
+        buf << receive
+      end
+      snooze
+      buf << :bye_from_parent
+    end
+
+    snooze
+    assert_equal parent, child.parent
+    child.detach 
+    assert_equal Fiber.current, child.parent
+    parent.await
+    
+    child << :bye
+    child.await
+
+    assert_equal [
+      :hi_from_parent,
+      :hi_from_child,
+      :bye_from_parent,
+      :bye
+    ], buf
+  end
+
+  def test_attach
+    buf = []
+    child = nil
+    parent = spin(:parent) do
+      buf << :hi_from_parent
+      child = spin(:child) do
+        buf << :hi_from_child
+        # wait for message (from main fiber)
+        buf << receive
+      end
+      snooze
+      buf << :bye_from_parent
+    end
+
+    new_parent = spin(:new_parent) { buf << receive }
+
+    snooze
+    assert_equal parent, child.parent
+    child.attach(new_parent)
+    assert_equal new_parent, child.parent
+    parent.await
+    
+    child << :bye
+    new_parent << :bye_new_parent
+    snooze
+
+    assert_equal [
+      :hi_from_parent,
+      :hi_from_child,
+      :bye_from_parent,
+      :bye,
+      :bye_new_parent
+    ], buf
+  end
 end
 
 class MailboxTest < MiniTest::Test
@@ -964,7 +1052,7 @@ class FiberControlTest < MiniTest::Test
     assert_equal 'foo', result.message
     assert_equal f1, result.source_fiber
     assert_equal :dead, f1.state
-    assert_equal :dead, f2.state
+    assert_equal :waiting, f2.state
   end
 
   def test_select_with_interruption

data/test/test_global_api.rb

@@ -372,7 +372,7 @@ class SpinScopeTest < MiniTest::Test
     rescue => e
       buffer << e.message
     end
-    6.times { snooze }
+    10.times { snooze }
     assert_equal 0, Fiber.current.children.size
     assert_equal ['foobar'], buffer
   end

data/test/test_io.rb

@@ -416,4 +416,33 @@ class IOClassMethodsTest < MiniTest::Test
     assert_equal "foo\nbar\n", pipe_read { |f| f.puts 'foo', 'bar' }
     assert_equal "foo\nbar\n", pipe_read { |f| f.puts 'foo', "bar\n" }
   end
+
+  def test_read_loop
+    i, o = IO.pipe
+
+    buf = []
+    f = spin do
+      buf << :ready
+      i.read_loop { |d| buf << d }
+      buf << :done
+    end
+
+    # writing always causes snoozing
+    o << 'foo'
+    o << 'bar'
+    o.close
+
+    f.await
+    assert_equal [:ready, 'foo', 'bar', :done], buf
+  end
+
+  def test_read_loop_with_max_len
+    r, w = IO.pipe
+
+    w << 'foobar'
+    w.close
+    buf = []
+    r.read_loop(3) { |data| buf << data }
+    assert_equal ['foo', 'bar'], buf
+  end
 end

data/test/test_supervise.rb

@@ -2,103 +2,103 @@
 
 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
-    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
+#     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