polyphony 0.47.3 → 0.49.0

data/lib/polyphony/core/thread_pool.rb

@@ -45,7 +45,9 @@ module Polyphony
     end
 
     def thread_loop
-      loop { run_queued_task }
+      while true
+        run_queued_task
+      end
     end
 
     def run_queued_task

data/lib/polyphony/core/throttler.rb

@@ -15,7 +15,7 @@ module Polyphony
       Thread.current.backend.sleep(delta) if delta > 0
       yield self
 
-      loop do
+      while true
         @next_time += @min_dt
         break if @next_time > now
       end

data/lib/polyphony/core/timer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Polyphony
+  # Implements a common timer for running multiple timeouts
+  class Timer
+    def initialize(resolution:)
+      @fiber = spin_loop(interval: resolution) { update }
+      @timeouts = {}
+    end
+
+    def stop
+      @fiber.stop
+    end
+  
+    def cancel_after(duration, with_exception: Polyphony::Cancel)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        duration: duration,
+        target_stamp: Time.now + duration,
+        exception: with_exception
+      }
+      yield
+    ensure
+      @timeouts.delete(fiber)
+    end
+
+    def move_on_after(duration, with_value: nil)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        duration: duration,
+        target_stamp: Time.now + duration,
+        value: with_value
+      }
+      yield
+    rescue Polyphony::MoveOn => e
+      e.value
+    ensure
+      @timeouts.delete(fiber)
+    end
+  
+    def reset
+      record = @timeouts[Fiber.current]
+      return unless record
+  
+      record[:target_stamp] = Time.now + record[:duration]
+    end
+  
+    private
+
+    def timeout_exception(record)
+      case (exception = record[:exception])
+      when Class then exception.new
+      when Array then exception[0].new(exception[1])
+      when nil then Polyphony::MoveOn.new(record[:value])
+      else RuntimeError.new(exception)
+      end
+    end
+
+    def update
+      now = Time.now
+      # elapsed = nil
+      @timeouts.each do |fiber, record|
+        next if record[:target_stamp] > now
+
+        exception = timeout_exception(record)
+        # (elapsed ||= []) << fiber
+        fiber.schedule exception
+      end
+      # elapsed&.each { |f| @timeouts.delete(f) }
+    end
+  end
+end

data/lib/polyphony/extensions/fiber.rb

@@ -34,9 +34,18 @@ module Polyphony
       schedule Polyphony::Cancel.new
     end
 
-    def terminate
+    def graceful_shutdown=(graceful)
+      @graceful_shutdown = graceful
+    end
+
+    def graceful_shutdown?
+      @graceful_shutdown
+    end
+
+    def terminate(graceful = false)
       return if @running == false
 
+      @graceful_shutdown = graceful
       schedule Polyphony::Terminate.new
     end
 
@@ -66,20 +75,32 @@ module Polyphony
       @on_child_done = proc do |fiber, result|
         self << fiber unless result.is_a?(Exception)
       end
-      loop { supervise_perform(opts) }
+      while true
+        supervise_perform(opts)
+      end
+    rescue Polyphony::MoveOn
+      # generated in #supervise_perform to stop supervisor
     ensure
       @on_child_done = nil
     end
 
     def supervise_perform(opts)
       fiber = receive
-      restart_fiber(fiber, opts) if fiber
+      if fiber && opts[:restart]
+        restart_fiber(fiber, opts)
+      elsif Fiber.current.children.empty?
+        Fiber.current.stop
+      end
     rescue Polyphony::Restart
       restart_all_children
     rescue Exception => e
       Kernel.raise e if e.source_fiber.nil? || e.source_fiber == self
 
-      restart_fiber(e.source_fiber, opts)
+      if opts[:restart]
+        restart_fiber(e.source_fiber, opts)
+      elsif Fiber.current.children.empty?
+        Fiber.current.stop
+      end
     end
 
     def restart_fiber(fiber, opts)
@@ -200,11 +221,14 @@ module Polyphony
       @on_child_done&.(child_fiber, result)
     end
 
-    def terminate_all_children
+    def terminate_all_children(graceful = false)
       return unless @children
 
       e = Polyphony::Terminate.new
-      @children.each_key { |c| c.raise e }
+      @children.each_key do |c|
+        c.graceful_shutdown = true if graceful
+        c.raise e
+      end
     end
 
     def await_all_children
@@ -220,8 +244,8 @@ module Polyphony
       results.values
     end
 
-    def shutdown_all_children
-      terminate_all_children
+    def shutdown_all_children(graceful = false)
+      terminate_all_children(graceful)
       await_all_children
     end
   end

data/lib/polyphony/extensions/io.rb

@@ -119,18 +119,11 @@ class ::IO
   end
 
   alias_method :orig_readpartial, :read
-  def readpartial(len, str = nil)
-    @read_buffer ||= +''
-    result = Thread.current.backend.read(self, @read_buffer, len, false)
+  def readpartial(len, str = +'')
+    result = Thread.current.backend.read(self, str, len, false)
     raise EOFError unless result
 
-    if str
-      str << @read_buffer
-    else
-      str = @read_buffer
-    end
-    @read_buffer = +''
-    str
+    result
   end
 
   alias_method :orig_write, :write
@@ -154,15 +147,16 @@ class ::IO
 
     @read_buffer ||= +''
 
-    loop do
+    while true
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      data = readpartial(8192)
+      data = readpartial(8192, +'')
+      return nil unless data
       @read_buffer << data
-    rescue EOFError
-      return nil
     end
+  rescue EOFError
+    return nil
   end
 
   # def print(*args)

data/lib/polyphony/extensions/openssl.rb

@@ -25,7 +25,7 @@ class ::OpenSSL::SSL::SSLSocket
 
   alias_method :orig_accept, :accept
   def accept
-    loop do
+    while true
       result = accept_nonblock(exception: false)
       case result
       when :wait_readable then Thread.current.backend.wait_io(io, false)
@@ -37,14 +37,14 @@ class ::OpenSSL::SSL::SSLSocket
   end
 
   def accept_loop
-    loop do
+    while true
       yield accept
     end
   end
 
   alias_method :orig_sysread, :sysread
   def sysread(maxlen, buf = +'')
-    loop do
+    while true
       case (result = read_nonblock(maxlen, buf, exception: false))
       when :wait_readable then Thread.current.backend.wait_io(io, false)
       when :wait_writable then Thread.current.backend.wait_io(io, true)
@@ -55,7 +55,7 @@ class ::OpenSSL::SSL::SSLSocket
 
   alias_method :orig_syswrite, :syswrite
   def syswrite(buf)
-    loop do
+    while true
       case (result = write_nonblock(buf, exception: false))
       when :wait_readable then Thread.current.backend.wait_io(io, false)
       when :wait_writable then Thread.current.backend.wait_io(io, true)

data/lib/polyphony/extensions/socket.rb

@@ -8,7 +8,11 @@ require_relative '../core/thread_pool'
 # Socket overrides (eventually rewritten in C)
 class ::Socket
   def accept
-    Thread.current.backend.accept(self)
+    Thread.current.backend.accept(self, TCPSocket)
+  end
+
+  def accept_loop(&block)
+    Thread.current.backend.accept_loop(self, TCPSocket, &block)
   end
 
   NO_EXCEPTION = { exception: false }.freeze
@@ -19,17 +23,7 @@ class ::Socket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, buf || +'', maxlen)
-    # outbuf ||= +''
-    # loop do
-    #   result = recv_nonblock(maxlen, flags, outbuf, **NO_EXCEPTION)
-    #   case result
-    #   when nil then raise IOError
-    #   when :wait_readable then Thread.current.backend.wait_io(self, false)
-    #   else
-    #     return result
-    #   end
-    # end
+    Thread.current.backend.recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
@@ -39,7 +33,7 @@ class ::Socket
 
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
-    loop do
+    while true
       result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
       case result
       when nil then raise IOError
@@ -144,7 +138,7 @@ class ::TCPSocket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, buf || +'', maxlen)
+    Thread.current.backend.recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
@@ -198,11 +192,12 @@ class ::TCPServer
 
   alias_method :orig_accept, :accept
   def accept
-    @io.accept
+    Thread.current.backend.accept(@io, TCPSocket)
+    # @io.accept
   end
 
   def accept_loop(&block)
-    Thread.current.backend.accept_loop(@io, &block)
+    Thread.current.backend.accept_loop(@io, TCPSocket, &block)
   end
 
   alias_method :orig_close, :close
@@ -210,3 +205,60 @@ class ::TCPServer
     @io.close
   end
 end
+
+class ::UNIXServer
+  alias_method :orig_accept, :accept
+ def accept
+    Thread.current.backend.accept(self, UNIXSocket)
+  end
+
+  def accept_loop(&block)
+    Thread.current.backend.accept_loop(self, UNIXSocket, &block)
+  end
+end
+
+class ::UNIXSocket
+  def recv(maxlen, flags = 0, outbuf = nil)
+    Thread.current.backend.recv(self, outbuf || +'', maxlen)
+  end
+
+  def recv_loop(&block)
+    Thread.current.backend.recv_loop(self, &block)
+  end
+  alias_method :read_loop, :recv_loop
+
+  def send(mesg, flags = 0)
+    Thread.current.backend.send(self, mesg)
+  end
+
+  def write(str, *args)
+    if args.empty?
+      Thread.current.backend.send(self, str)
+    else
+      Thread.current.backend.send(self, str + args.join)
+    end
+  end
+  alias_method :<<, :write
+
+  def readpartial(maxlen, str = nil)
+    @read_buffer ||= +''
+    result = Thread.current.backend.recv(self, @read_buffer, maxlen)
+    raise EOFError unless result
+
+    if str
+      str << @read_buffer
+    else
+      str = @read_buffer
+    end
+    @read_buffer = +''
+    str
+  end
+
+  def read_nonblock(len, str = nil, exception: true)
+    @io.read_nonblock(len, str, exception: exception)
+  end
+
+  def write_nonblock(buf, exception: true)
+    @io.write_nonblock(buf, exception: exception)
+  end
+end

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.licenses    = ['MIT']
   s.summary     = 'Fine grained concurrency for Ruby'
   s.author      = 'Sharon Rosner'
-  s.email       = 'ciconia@gmail.com'
+  s.email       = 'sharon@noteflakes.com'
   s.files       = `git ls-files`.split
   s.homepage    = 'https://digital-fabric.github.io/polyphony'
   s.metadata    = {

data/test/helper.rb

@@ -4,6 +4,7 @@ require 'bundler/setup'
 
 require_relative './coverage' if ENV['COVERAGE']
 
+require 'httparty'
 require 'polyphony'
 
 require 'fileutils'

data/test/test_backend.rb

@@ -105,7 +105,7 @@ class BackendTest < MiniTest::Test
 
     clients = []
     server_fiber = spin do
-      @backend.accept_loop(server) { |c| clients << c }
+      @backend.accept_loop(server, TCPSocket) { |c| clients << c }
     end
 
     c1 = TCPSocket.new('127.0.0.1', 1234)

data/test/test_fiber.rb

@@ -639,7 +639,6 @@ class FiberTest < MiniTest::Test
         i.close
         f.await
       rescue Exception => e
-        trace e
         o << e.class.name
         o.close
       end
@@ -1038,3 +1037,67 @@ class RestartTest < MiniTest::Test
     assert_equal [f, 'foo', 'bar', :done, f2, 'baz', 42, :done], buffer
   end
 end
+
+class GracefulTerminationTest < MiniTest::Test
+  def test_graceful_termination
+    buffer = []
+    f = spin do
+      buffer << 1
+      snooze
+      buffer << 2
+      sleep 3
+      buffer << 3
+    ensure
+      buffer << 4 if Fiber.current.graceful_shutdown?
+    end
+
+    3.times { snooze }
+    f.terminate(false)
+    f.await
+    assert_equal [1, 2], buffer
+
+    buffer = []
+    f = spin do
+      buffer << 1
+      snooze
+      buffer << 2
+      sleep 3
+      buffer << 3
+    ensure
+      buffer << 4 if Fiber.current.graceful_shutdown?
+    end
+
+    3.times { snooze }
+    f.terminate(true)
+    f.await
+    assert_equal [1, 2, 4], buffer
+  end
+
+  def test_graceful_child_shutdown
+    buffer = []
+    f0 = spin do
+      f1 = spin do
+        sleep
+      ensure
+        buffer << 1 if Fiber.current.graceful_shutdown?
+      end
+
+      f2 = spin do
+        sleep
+      ensure
+        buffer << 2 if Fiber.current.graceful_shutdown?
+      end
+
+      sleep
+    ensure
+      Fiber.current.terminate_all_children(true) if Fiber.current.graceful_shutdown?
+      Fiber.current.await_all_children
+    end
+
+    3.times { snooze }
+    f0.terminate(true)
+    f0.await
+
+    assert_equal [1, 2], buffer
+  end
+end