polyphony 0.43.6 → 0.44.0

data/lib/polyphony/extensions/thread.rb

@@ -18,7 +18,7 @@ class ::Thread
   def execute
     # agent must be created in the context of the new thread, therefore it
     # cannot be created in Thread#initialize
-    @agent = Polyphony::LibevAgent.new
+    @agent = Polyphony::Agent.new
     setup
     @ready = true
     result = @block.(*@args)

data/lib/polyphony/net.rb

@@ -35,9 +35,10 @@ module Polyphony
         ::Socket.new(:INET, :STREAM).tap do |s|
           s.reuse_addr if opts[:reuse_addr]
           s.dont_linger if opts[:dont_linger]
+          s.reuse_port if opts[:reuse_port]
           addr = ::Socket.sockaddr_in(port, host)
           s.bind(addr)
-          s.listen(0)
+          s.listen(opts[:backlog] || Socket::SOMAXCONN)
         end
       end
 

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -32,6 +32,8 @@ Gem::Specification.new do |s|
   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  'mysql2',               '0.5.3'
+  s.add_development_dependency  'sequel',               '5.34.0'
 
   s.add_development_dependency  'jekyll',               '~>3.8.6'
   s.add_development_dependency  'jekyll-remote-theme',  '~>0.4.1'

data/test/helper.rb

@@ -31,8 +31,8 @@ class MiniTest::Test
     end
     Fiber.current.setup_main_fiber
     Fiber.current.instance_variable_set(:@auto_watcher, nil)
-    Thread.current.agent = Polyphony::LibevAgent.new
-    sleep 0
+    Thread.current.agent = Polyphony::Agent.new
+    sleep 0 # apparently this helps with timer accuracy
   end
 
   def teardown

data/test/test_agent.rb

@@ -6,7 +6,7 @@ class AgentTest < MiniTest::Test
   def setup
     super
     @prev_agent = Thread.current.agent
-    @agent = Polyphony::LibevAgent.new
+    @agent = Polyphony::Agent.new
     Thread.current.agent = @agent
   end
 
@@ -97,7 +97,7 @@ class AgentTest < MiniTest::Test
     o.close
 
     # read_loop will snooze after every read
-    4.times { snooze }
+    6.times { snooze }
 
     assert_equal [:ready, 'foo', 'bar', :done], buf
   end

data/test/test_event.rb

@@ -34,6 +34,7 @@ class EventTest < MiniTest::Test
       }
     }
     snooze
+
     t = Thread.new do
       orig_sleep 0.001
       3.times { a.signal }
@@ -45,4 +46,15 @@ class EventTest < MiniTest::Test
     t&.kill
     t&.join
   end
+
+  def test_exception_while_waiting_for_event
+    e = Polyphony::Event.new
+
+    f = spin { e.await }
+    g = spin { f.raise 'foo' }
+
+    assert_raises(RuntimeError) do
+      f.await
+    end
+  end
 end

data/test/test_fiber.rb

@@ -413,6 +413,22 @@ class FiberTest < MiniTest::Test
     f2&.stop
   end
 
+  def test_interject
+    buf = []
+    f = spin_loop { sleep }
+    snooze
+    f.interject { buf << Fiber.current }
+    snooze
+    assert_equal [f], buf
+    assert_equal :waiting, f.state
+
+    f.interject { buf << :foo; raise Polyphony::MoveOn }
+    snooze
+
+    assert_equal [f, :foo], buf
+    assert_equal :dead, f.state
+  end
+
   def test_state
     counter = 0
     f = spin do
@@ -692,7 +708,7 @@ class FiberTest < MiniTest::Test
 
     f.schedule
     f << 'bar'
-    snooze
+    2.times { snooze }
     assert_equal ['bar'], buffer
   end
 end

data/test/test_io.rb

@@ -91,6 +91,20 @@ class IOTest < MiniTest::Test
 
     assert_raises(EOFError) { i.readpartial(1) }    
   end
+
+  # see https://github.com/digital-fabric/polyphony/issues/30
+  def test_reopened_tempfile
+    file = Tempfile.new
+    file << 'hello: world'
+    file.close
+
+    buf = nil
+    File.open(file, 'r:bom|utf-8') do |f|
+      buf = f.read(16384)
+    end
+
+    assert_equal 'hello: world', buf
+  end
 end
 
 class IOClassMethodsTest < MiniTest::Test

data/test/test_queue.rb

@@ -96,4 +96,37 @@ class QueueTest < MiniTest::Test
     assert_nil f2.await
     assert_equal :bar, f3.await
   end
+
+  def test_fiber_removal_from_queue_simple
+    f1 = spin { @queue.shift }
+    
+    # let fibers run
+    snooze
+
+    f1.stop
+    snooze
+
+    @queue << :foo
+    assert_nil f1.await
+  end
+
+  def test_queue_size
+    assert_equal 0, @queue.size
+
+    @queue.push 1
+    
+    assert_equal 1, @queue.size
+
+    @queue.push 2
+    
+    assert_equal 2, @queue.size
+
+    @queue.shift
+
+    assert_equal 1, @queue.size
+
+    @queue.shift
+
+    assert_equal 0, @queue.size
+  end
 end

data/test/test_resource_pool.rb

@@ -12,29 +12,19 @@ class ResourcePoolTest < MiniTest::Test
     assert_equal 0, pool.size
 
     results = []
-    4.times {
-      spin {
-        snooze
+    4.times { |i|
+      spin(:"foo#{i}") {
         pool.acquire { |resource|
           results << resource
           snooze
         }
       }
     }
-    2.times { snooze }
-    assert_equal 2, pool.limit
-    assert_equal 0, pool.available
-    assert_equal 2, pool.size
-
-    2.times { snooze }
-
-    assert_equal ['a', 'b', 'a', 'b'], results
-
-    2.times { snooze }
-
+    Fiber.current.await_all_children
     assert_equal 2, pool.limit
     assert_equal 2, pool.available
     assert_equal 2, pool.size
+    assert_equal ['a', 'b', 'a', 'b'], results
   end
 
   def test_discard
@@ -46,40 +36,18 @@ class ResourcePoolTest < MiniTest::Test
       spin {
         snooze
         pool.acquire { |resource|
-          results << resource
-          resource.__discard__ if resource == 'b'
+        results << resource
+        pool.discard! if resource == 'b'
           snooze
         }
       }
     }
-    6.times { snooze }
+    Fiber.current.await_all_children
 
     assert_equal ['a', 'b', 'a', 'a'], results
     assert_equal 1, pool.size
   end
 
-  def test_add
-    resources = [+'a', +'b']
-    pool = Polyphony::ResourcePool.new(limit: 2) { resources.shift }
-
-    pool << +'c'
-
-    results = []
-    4.times {
-      spin {
-        snooze
-        pool.acquire { |resource|
-          results << resource
-          resource.__discard__ if resource == 'b'
-          snooze
-        }
-      }
-    }
-    6.times { snooze }
-
-    assert_equal ['c', 'a', 'c', 'a'], results
-  end
-
   def test_single_resource_limit
     resources = [+'a', +'b']
     pool = Polyphony::ResourcePool.new(limit: 1) { resources.shift }
@@ -94,7 +62,7 @@ class ResourcePoolTest < MiniTest::Test
         }
       }
     }
-    20.times { snooze }
+    Fiber.current.await_all_children
 
     assert_equal ['a'] * 10, results
   end
@@ -128,11 +96,34 @@ class ResourcePoolTest < MiniTest::Test
     resources = [+'a', +'b']
     pool = Polyphony::ResourcePool.new(limit: 1) { resources.shift }
 
+    results = []
     pool.acquire do |r|
-      assert_equal 'a', r
-      pool.acquire do |r|
-        assert_equal 'a', r
+      results << r
+      2.times do
+        pool.acquire do |r|
+          results << r
+        end
       end
     end
+    assert_equal ['a']*3, results
+  end
+
+  def test_overloaded_resource_pool
+    pool = Polyphony::ResourcePool.new(limit: 1) { 1 }
+
+    buf = []
+    fibers = 2.times.map do |i|
+      spin(:"foo#{i}") do
+        2.times do
+          pool.acquire do |r|
+            buf << r
+            snooze
+          end
+        end
+      end
+    end
+    Fiber.current.await_all_children
+
+    assert_equal [1, 1, 1, 1], buf
   end
 end

data/test/test_signal.rb

@@ -56,35 +56,11 @@ class SignalTrapTest < Minitest::Test
     assert_equal "3 - interrupted\n2 - terminated\n1 - terminated\n", buffer
   end
 
-  def test_signal_exception_possible_race_condition
+  def test_interrupt_signal_scheduling
     i, o = IO.pipe
     pid = Polyphony.fork do
       i.close
-      f1 = nil
-      f2 = spin do
-        # this fiber will try to create a race condition by
-        # - being scheduled before f1 is scheduled with the Interrupt exception
-        # - scheduling f1 without an exception
-        suspend
-        f1.schedule
-      rescue ::Interrupt => e
-        o.puts '2-interrupt'
-        raise e
-      end
-      f1 = spin do
-        # this fiber is the one that will be current when the
-        # signal is trapped
-        sleep 1
-        o << 'boom'
-      rescue ::Interrupt => e
-        o.puts '1-interrupt'
-        raise e
-      end
-      old_trap = trap('INT') do
-        f2.schedule
-        old_trap.()
-      end
-      Fiber.current.await_all_children
+      sleep
     rescue ::Interrupt => e
       o.puts '3-interrupt'
     ensure

data/test/test_socket.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'helper'
-require 'localhost/authority'
 
 class SocketTest < MiniTest::Test
   def setup
@@ -32,46 +31,4 @@ class SocketTest < MiniTest::Test
     server_fiber&.await
     server&.close
   end
-
-  def test_openssl
-    authority = Localhost::Authority.fetch
-    context = authority.server_context
-    port = rand(1234..5678)
-    sock = TCPServer.new('127.0.0.1', port)
-    server = OpenSSL::SSL::SSLServer.new(sock, context)
-
-    server_fiber = spin do
-      while (socket = server.accept)
-        puts "accepted: #{socket.inspect}"
-        spin do
-          while (data = socket.gets(8192))
-            socket << data
-          end
-        end
-      end
-    end
-
-    snooze
-    p 1
-    sock = TCPSocket.new('127.0.0.1', port)
-    p 2
-    sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-    context = OpenSSL::SSL::SSLContext.new
-    context.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    client = OpenSSL::SSL::SSLSocket.new(sock, context)
-    client.sync_close = true
-    client.hostname = 'localhost'
-    p 3
-    client.connect
-    p 4
-    client.write("GET / HTTP/1.0\r\nHost: realiteq.net\r\n\r\n")#("1234\n")
-    p 5
-    assert_equal "1234\n", client.readpartial(8192)
-    p 6
-    client.close
-  ensure
-    server_fiber&.stop
-    server_fiber&.await
-    server&.close
-  end
 end

data/test/test_trace.rb

@@ -34,7 +34,8 @@ class TraceTest < MiniTest::Test
 
   def test_2_fiber_trace
     records = []
-    t = Polyphony::Trace.new(:fiber_all) { |r| records << r if r[:event] =~ /^fiber_/ }
+    thread = Thread.current
+    t = Polyphony::Trace.new(:fiber_all) { |r| records << r if Thread.current == thread && r[:event] =~ /^fiber_/ }
     t.enable
     Polyphony.trace(true)
 
@@ -42,23 +43,23 @@ class TraceTest < MiniTest::Test
     suspend
     sleep 0
 
-    events = records.map { |r| [r[:fiber], r[:event]] }
+    events = records.map { |r| [r[:fiber] == f ? :f : :current, r[:event]] }
     assert_equal [
-      [f, :fiber_create],
-      [f, :fiber_schedule],
-      [Fiber.current, :fiber_switchpoint],
-      [f, :fiber_run],
-      [f, :fiber_switchpoint],
-      [f, :fiber_ev_loop_enter],
-      [f, :fiber_schedule],
-      [f, :fiber_ev_loop_leave],
-      [f, :fiber_run],
-      [f, :fiber_terminate],
-      [Fiber.current, :fiber_switchpoint],
-      [Fiber.current, :fiber_ev_loop_enter],
-      [Fiber.current, :fiber_schedule],
-      [Fiber.current, :fiber_ev_loop_leave],
-      [Fiber.current, :fiber_run]
+      [:f, :fiber_create],
+      [:f, :fiber_schedule],
+      [:current, :fiber_switchpoint],
+      [:f, :fiber_run],
+      [:f, :fiber_switchpoint],
+      [:f, :fiber_ev_loop_enter],
+      [:f, :fiber_schedule],
+      [:f, :fiber_ev_loop_leave],
+      [:f, :fiber_run],
+      [:f, :fiber_terminate],
+      [:current, :fiber_switchpoint],
+      [:current, :fiber_ev_loop_enter],
+      [:current, :fiber_schedule],
+      [:current, :fiber_ev_loop_leave],
+      [:current, :fiber_run]
     ], events
   ensure
     t&.disable