polyphony 0.22 → 0.23

data/lib/polyphony/extensions/io.rb

@@ -25,13 +25,16 @@ class ::IO
 
     alias_method :orig_foreach, :foreach
     def foreach(name, sep = $/, limit = nil, getline_args = EMPTY_HASH, &block)
-      if sep.is_a?(Integer)
-        sep = $/
-        limit = sep
-      end
-      File.open(name, 'r') do |f|
-        f.each_line(sep, limit, getline_args, &block)
-      end
+      # IO.orig_read(name).each_line(&block)
+      raise NotImplementedError
+
+      # if sep.is_a?(Integer)
+      #   sep = $/
+      #   limit = sep
+      # end
+      # File.open(name, 'r') do |f|
+      #   f.each_line(sep, limit, getline_args, &block)
+      # end
     end
 
     alias_method :orig_read, :read

data/lib/polyphony/extensions/openssl.rb

@@ -19,29 +19,24 @@ class ::OpenSSL::SSL::SSLSocket
   end
 
   def sysread(maxlen, buf)
+    read_watcher = nil
+    write_watcher = nil
     loop do
-      read_watcher = nil
-      write_watcher = nil
-      result = read_nonblock(maxlen, buf, exception: false)
-      if result == :wait_readable
-        read_watcher ||= Gyro::IO.new(io, :r)
-        read_watcher.await
-      elsif result == :wait_writable
-        write_watcher ||= Gyro::IO.new(io, :w)
-        write_watcher.await
-      else
-        return result
+      case (result = read_nonblock(maxlen, buf, exception: false))
+      when :wait_readable then (read_watcher ||= Gyro::IO.new(io, :r)).await
+      when :wait_writable then (write_watcher ||= Gyro::IO.new(io, :w)).await
+      else result
       end
     end
   end
 
   def flush
-  #   osync = @sync
-  #   @sync = true
-  #   do_write ""
-  #   return self
-  # ensure
-  #   @sync = osync
+    # osync = @sync
+    # @sync = true
+    # do_write ""
+    # return self
+    # ensure
+    # @sync = osync
   end
 
   # def do_write(s)
@@ -62,18 +57,13 @@ class ::OpenSSL::SSL::SSLSocket
   # end
 
   def syswrite(buf)
+    read_watcher = nil
+    write_watcher = nil
     loop do
-      read_watcher = nil
-      write_watcher = nil
-      result = write_nonblock(buf, exception: false)
-      if result == :wait_readable
-        read_watcher ||= Gyro::IO.new(io, :r)
-        read_watcher.await
-      elsif result == :wait_writable
-        write_watcher ||= Gyro::IO.new(io, :w)
-        write_watcher.await
-      else
-        return result
+      case (result = write_nonblock(buf, exception: false))
+      when :wait_readable then (read_watcher ||= Gyro::IO.new(io, :r)).await
+      when :wait_writable then (write_watcher ||= Gyro::IO.new(io, :w)).await
+      else result
       end
     end
   end

data/lib/polyphony/http/client/agent.rb

@@ -104,23 +104,27 @@ class Agent
     key = uri_key(ctx[:uri])
 
     @pools[key].acquire do |adapter|
-      response = adapter.request(ctx)
-      case response.status_code
-      when 200, 204
-        if block
-          block.(response)
-        else
-          # read body
-          response.body
-        end
-      end
-      response
+      send_request_and_check_response(adapter, ctx, &block)
     end
   rescue Exception => e
     p e
     puts e.backtrace.join("\n")
   end
 
+  def send_request_and_check_response(adapter, ctx, &block)
+    response = adapter.request(ctx)
+    case response.status_code
+    when 200, 204
+      if block
+        block.(response)
+      else
+        # read body
+        response.body
+      end
+    end
+    response
+  end
+
   def uri_key(uri)
     { scheme: uri.scheme, host: uri.host, port: uri.port }
   end

data/lib/polyphony/http/client/http2.rb

@@ -60,7 +60,7 @@ class HTTP2Adapter
     rescue Exception => e
       p e
       puts e.backtrace.join("\n")
-    # ensure
+      # ensure
       # stream.close
     end
 

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency  'localhost',          '1.1.4'
   s.add_development_dependency  'minitest',           '5.11.3'
   s.add_development_dependency  'minitest-reporters', '1.4.2'
+  s.add_development_dependency  'simplecov',          '0.17.1'
   s.add_development_dependency  'pg',                 '1.1.3'
   s.add_development_dependency  'rake-compiler',      '1.0.5'
   s.add_development_dependency  'redis',              '4.1.0'

data/test/coverage.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'coverage'
+require 'simplecov'
+
+class << SimpleCov::LinesClassifier
+  alias_method :orig_whitespace_line?, :whitespace_line?
+  def whitespace_line?(line)
+    line.strip =~ /^(begin|end|ensure|else|\})|(\s*rescue\s.+)$/ || orig_whitespace_line?(line)
+  end
+end
+
+module Coverage
+  EXCLUDE = %w{coverage eg helper run
+  }.map { |n| File.expand_path("test/#{n}.rb") }
+
+  LIB_FILES = Dir["#{File.join(FileUtils.pwd, 'lib')}/polyphony/**/*.rb"]
+
+  class << self
+    def relevant_lines_for_filename(filename)
+      @classifier ||= SimpleCov::LinesClassifier.new
+      @classifier.classify(IO.read(filename).lines)
+    end
+
+    def start
+      @result = {}
+      trace = TracePoint.new(:line) do |tp|
+        next if tp.path =~ /\(/
+      
+        absolute = File.expand_path(tp.path)
+        next unless LIB_FILES.include?(absolute)# =~ /^#{LIB_DIR}/
+        
+        @result[absolute] ||= relevant_lines_for_filename(absolute)
+        @result[absolute][tp.lineno - 1] = 1
+      end
+      trace.enable
+    end
+
+    def result
+      @result
+    end
+  end
+end
+
+SimpleCov.start

data/test/helper.rb

@@ -2,13 +2,15 @@
 
 require 'bundler/setup'
 
+require 'fileutils'
+require_relative './eg'
+
+require_relative './coverage' if ENV['COVERAGE']
+
 require 'minitest/autorun'
 require 'minitest/reporters'
 
 require 'polyphony'
-require 'fileutils'
-
-require_relative './eg'
 
 ::Exception.__disable_sanitized_backtrace__ = true
 
@@ -18,8 +20,16 @@ Minitest::Reporters.use! [
 
 class MiniTest::Test
   def teardown
-    # wait for reactor loop to finish running
-    suspend
+    # wait for any remaining scheduled work
+    Gyro.run
     Polyphony.reset!
   end
 end
+
+module Kernel
+  def capture_exception
+    yield
+  rescue Exception => e
+    e
+  end
+end

data/test/test_async.rb

@@ -12,7 +12,7 @@ class AsyncTest < MiniTest::Test
     }
     snooze
     Thread.new do
-      sync_sleep 0.001
+      orig_sleep 0.001
       a.signal!
     end
     suspend
@@ -26,15 +26,15 @@ class AsyncTest < MiniTest::Test
       loop {
         a.await
         count += 1
-        after(0.01) { coproc.stop }
+        defer { coproc.stop }
       }
     }
     snooze
     Thread.new do
-      sync_sleep 0.001
+      orig_sleep 0.001
       3.times { a.signal! }
     end
-    suspend
+    coproc.await
     assert_equal(1, count)
   end
 end

data/test/test_cancel_scope.rb

@@ -0,0 +1,109 @@
+# 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|
+      defer { scope.cancel! }
+      buffer << 1
+      snooze
+      buffer << 2
+    }
+    assert_equal [1], buffer
+  end
+
+  def test_that_cancel_scope_can_cancel_multiple_coprocesses
+    buffer = []
+    scope = Polyphony::CancelScope.new
+    coprocs = (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_coprocs_with_timeout
+    buffer = []
+    t0 = Time.now
+    scope = Polyphony::CancelScope.new(timeout: 0.02)
+    coprocs = (1..3).map { |i|
+      spin {
+        scope.call do
+          buffer << i
+          sleep i
+          buffer << i * 10
+        end
+      }
+    }
+    Polyphony::Coprocess.await(*coprocs)
+    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.010
+    }
+
+    assert !scope.cancelled?
+  end
+
+  def test_on_cancel
+    buffer = []
+    Polyphony::CancelScope.new { |scope|
+      defer { 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

data/test/test_coprocess.rb

@@ -2,8 +2,6 @@
 
 require_relative 'helper'
 
-STDOUT.sync = true
-
 class CoprocessTest < MiniTest::Test
   def test_that_root_fiber_has_associated_coprocess
     assert_equal(Fiber.current, Polyphony::Coprocess.current.fiber)
@@ -230,6 +228,16 @@ class CoprocessTest < MiniTest::Test
     assert_equal('foo', raised_error.message)
   end
 
+  def test_that_coprocess_can_be_cancelled_before_first_scheduling
+    buffer = []
+    coproc = spin { buffer << 1 }
+    coproc.stop
+
+    snooze
+    assert_nil coproc.alive?
+    assert_equal [], buffer
+  end
+
   def test_exception_propagation_for_orphan_fiber
     raised_error = nil
     spin do
@@ -255,6 +263,15 @@ class CoprocessTest < MiniTest::Test
     assert_equal %i{foo bar baz}, result
   end
 
+  def test_join_multiple_coprocesses
+    cp1 = spin { sleep 0.01; :foo }
+    cp2 = spin { sleep 0.01; :bar }
+    cp3 = spin { sleep 0.01; :baz }
+
+    result = Polyphony::Coprocess.join(cp1, cp2, cp3)
+    assert_equal %i{foo bar baz}, result
+  end
+
   def test_caller
     location = /^#{__FILE__}:#{__LINE__ + 1}/
     cp = spin do
@@ -263,7 +280,7 @@ class CoprocessTest < MiniTest::Test
     snooze
 
     caller = cp.caller
-    assert caller[0] =~ location
+    assert_match location, caller[0]
   end
 
   def test_location
@@ -275,39 +292,6 @@ class CoprocessTest < MiniTest::Test
 
     assert cp.location =~ location
   end
-end
-
-class MailboxTest < MiniTest::Test
-  def test_that_coprocess_can_receive_messages
-    msgs = []
-    coproc = spin { loop { msgs << receive } }
-
-    snooze # allow coproc to start
-
-    3.times do |i|
-      coproc << i
-      snooze
-    end
-
-    assert_equal([0, 1, 2], msgs)
-  ensure
-    coproc&.stop
-  end
-
-  def test_that_multiple_messages_sent_at_once_arrive_in_order
-    msgs = []
-    coproc = spin { loop { msgs << receive } }
-
-    snooze # allow coproc to start
-
-    3.times { |i| coproc << i }
-
-    snooze
-
-    assert_equal([0, 1, 2], msgs)
-  ensure
-    coproc&.stop
-  end
 
   def test_when_done
     flag = nil
@@ -394,3 +378,63 @@ class MailboxTest < MiniTest::Test
     assert_equal :ok, value
   end
 end
+
+class MailboxTest < MiniTest::Test
+  def test_that_coprocess_can_receive_messages
+    msgs = []
+    coproc = spin { loop { msgs << receive } }
+
+    snooze # allow coproc to start
+
+    3.times do |i|
+      coproc << i
+      snooze
+    end
+
+    assert_equal([0, 1, 2], msgs)
+  ensure
+    coproc&.stop
+  end
+
+  def test_that_multiple_messages_sent_at_once_arrive_in_order
+    msgs = []
+    coproc = spin { loop { msgs << receive } }
+
+    snooze # allow coproc to start
+
+    3.times { |i| coproc << i }
+
+    snooze
+
+    assert_equal([0, 1, 2], msgs)
+  ensure
+    coproc&.stop
+  end
+
+  def test_that_sent_message_are_queued_before_calling_receive
+    buffer = []
+    receiver = spin { suspend; 3.times { buffer << receive } }
+    sender = spin { 3.times { |i| receiver << (i * 10) } }
+
+    sender.await
+    receiver.schedule
+    receiver.await
+
+    assert_equal [0, 10, 20], buffer
+  end
+
+  def test_map_and_count
+    assert_equal 1, Polyphony::Coprocess.count
+    map = { Fiber.current => Polyphony::Coprocess.current }
+    assert_equal map, Polyphony::Coprocess.map
+
+    cp = spin { sleep 1 }
+    snooze
+    assert_equal 2, Polyphony::Coprocess.count
+    assert_equal cp, Polyphony::Coprocess.map[cp.fiber]
+
+    cp.stop
+    snooze
+    assert_equal 1, Polyphony::Coprocess.count
+  end
+end