polyphony 0.50.0 → 0.53.1

data/lib/polyphony/core/throttler.rb

@@ -12,7 +12,7 @@ module Polyphony
     def call
       now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       delta = @next_time - now
-      Thread.current.backend.sleep(delta) if delta > 0
+      Polyphony.backend_sleep(delta) if delta > 0
       yield self
 
       while true

data/lib/polyphony/core/timer.rb

@@ -18,7 +18,7 @@ module Polyphony
         interval: duration,
         target_stamp: now + duration
       }
-      Thread.current.backend.wait_event(true)
+      Polyphony.backend_wait_event(true)
     ensure
       @timeouts.delete(fiber)
     end
@@ -38,7 +38,7 @@ module Polyphony
         recurring: true
       }
       while true
-        Thread.current.backend.wait_event(true)
+        Polyphony.backend_wait_event(true)
         yield
       end
     ensure

data/lib/polyphony/extensions/core.rb

@@ -55,7 +55,7 @@ module ::Process
   class << self
     alias_method :orig_detach, :detach
     def detach(pid)
-      fiber = spin { Thread.current.backend.waitpid(pid) }
+      fiber = spin { Polyphony.backend_waitpid(pid) }
       fiber.define_singleton_method(:pid) { pid }
       fiber
     end

data/lib/polyphony/extensions/io.rb

@@ -101,7 +101,7 @@ class ::IO
     return @read_buffer.slice!(0) if @read_buffer && !@read_buffer.empty?
     
     @read_buffer ||= +''
-    Thread.current.backend.read(self, @read_buffer, 8192, false)
+    Polyphony.backend_read(self, @read_buffer, 8192, false)
     return @read_buffer.slice!(0) if !@read_buffer.empty?
 
     nil
@@ -110,7 +110,7 @@ class ::IO
   alias_method :orig_read, :read
   def read(len = nil)
     @read_buffer ||= +''
-    result = Thread.current.backend.read(self, @read_buffer, len, true)
+    result = Polyphony.backend_read(self, @read_buffer, len, true)
     return nil unless result
 
     already_read = @read_buffer
@@ -120,7 +120,7 @@ class ::IO
 
   alias_method :orig_readpartial, :read
   def readpartial(len, str = +'')
-    result = Thread.current.backend.read(self, str, len, false)
+    result = Polyphony.backend_read(self, str, len, false)
     raise EOFError unless result
 
     result
@@ -128,12 +128,12 @@ class ::IO
 
   alias_method :orig_write, :write
   def write(str, *args)
-    Thread.current.backend.write(self, str, *args)
+    Polyphony.backend_write(self, str, *args)
   end
 
   alias_method :orig_write_chevron, :<<
   def <<(str)
-    Thread.current.backend.write(self, str)
+    Polyphony.backend_write(self, str)
     self
   end
 
@@ -217,30 +217,21 @@ class ::IO
   end
 
   def read_loop(&block)
-    Thread.current.backend.read_loop(self, &block)
+    Polyphony.backend_read_loop(self, &block)
   end
 
-  # alias_method :orig_read, :read
-  # def read(length = nil, outbuf = nil)
-  #   if length
-  #     return outbuf ? readpartial(length) : readpartial(length, outbuf)
-  #   end
-
-  #   until eof?
-  #     outbuf ||= +''
-  #     outbuf << readpartial(8192)
-  #   end
-  #   outbuf
-  # end
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_feed_loop(self, receiver, method, &block)
+  end
 
   def wait_readable(timeout = nil)
     if timeout
       move_on_after(timeout) do
-        Thread.current.backend.wait_io(self, false)
+        Polyphony.backend_wait_io(self, false)
         self
       end
     else
-      Thread.current.backend.wait_io(self, false)
+      Polyphony.backend_wait_io(self, false)
       self
     end
   end
@@ -248,12 +239,20 @@ class ::IO
   def wait_writable(timeout = nil)
     if timeout
       move_on_after(timeout) do
-        Thread.current.backend.wait_io(self, true)
+        Polyphony.backend_wait_io(self, true)
         self
       end
     else
-      Thread.current.backend.wait_io(self, true)
+      Polyphony.backend_wait_io(self, true)
       self
     end
   end
+
+  def splice(src, maxlen)
+    Polyphony.backend_splice(src, self, maxlen)
+  end
+
+  def splice_to_eof(src, chunksize = 8192)
+    Polyphony.backend_splice_to_eof(src, self, chunksize)
+  end
 end

data/lib/polyphony/extensions/openssl.rb

@@ -28,8 +28,8 @@ class ::OpenSSL::SSL::SSLSocket
     while true
       result = accept_nonblock(exception: false)
       case result
-      when :wait_readable then Thread.current.backend.wait_io(io, false)
-      when :wait_writable then Thread.current.backend.wait_io(io, true)
+      when :wait_readable then Polyphony.backend_wait_io(io, false)
+      when :wait_writable then Polyphony.backend_wait_io(io, true)
       else
         return result
       end
@@ -46,8 +46,8 @@ class ::OpenSSL::SSL::SSLSocket
   def sysread(maxlen, buf = +'')
     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)
+      when :wait_readable then Polyphony.backend_wait_io(io, false)
+      when :wait_writable then Polyphony.backend_wait_io(io, true)
       else return result
       end
     end
@@ -57,8 +57,8 @@ class ::OpenSSL::SSL::SSLSocket
   def syswrite(buf)
     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)
+      when :wait_readable then Polyphony.backend_wait_io(io, false)
+      when :wait_writable then Polyphony.backend_wait_io(io, true)
       else
         return result
       end

data/lib/polyphony/extensions/socket.rb

@@ -8,57 +8,60 @@ require_relative '../core/thread_pool'
 # Socket overrides (eventually rewritten in C)
 class ::Socket
   def accept
-    Thread.current.backend.accept(self, TCPSocket)
+    Polyphony.backend_accept(self, TCPSocket)
   end
 
   def accept_loop(&block)
-    Thread.current.backend.accept_loop(self, TCPSocket, &block)
+    Polyphony.backend_accept_loop(self, TCPSocket, &block)
   end
 
   NO_EXCEPTION = { exception: false }.freeze
 
   def connect(addr)
     addr = Addrinfo.new(addr) if addr.is_a?(String)
-    Thread.current.backend.connect(self, addr.ip_address, addr.ip_port)
+    Polyphony.backend_connect(self, addr.ip_address, addr.ip_port)
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
-    Thread.current.backend.recv_loop(self, &block)
+    Polyphony.backend_recv_loop(self, &block)
   end
   alias_method :read_loop, :recv_loop
 
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
+  end
+
   def recvfrom(maxlen, flags = 0)
     @read_buffer ||= +''
     while true
       result = recvfrom_nonblock(maxlen, flags, @read_buffer, **NO_EXCEPTION)
       case result
       when nil then raise IOError
-      when :wait_readable then Thread.current.backend.wait_io(self, false)
+      when :wait_readable then Polyphony.backend_wait_io(self, false)
       else
         return result
       end
     end
   end
 
-  def send(mesg, flags = 0)
-    Thread.current.backend.send(self, mesg)
-  end
+  # def send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # 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 write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
+
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
 
   def readpartial(maxlen, str = +'')
-    Thread.current.backend.recv(self, str, maxlen)
+    Polyphony.backend_recv(self, str, maxlen)
   end
 
   ZERO_LINGER = [0, 0].pack('ii').freeze
@@ -138,30 +141,33 @@ class ::TCPSocket
   end
 
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
-    Thread.current.backend.recv_loop(self, &block)
+    Polyphony.backend_recv_loop(self, &block)
   end
   alias_method :read_loop, :recv_loop
 
-  def send(mesg, flags = 0)
-    Thread.current.backend.send(self, mesg)
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
   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 send(mesg, flags)
+  #   Polyphony.backend_send(self, mesg, flags)
+  # end
+
+  # def write(*args)
+  #   Polyphony.backend_sendv(self, args, 0)
+  # end
+
+  # def <<(mesg)
+  #   Polyphony.backend_send(self, mesg, 0)
+  # end
 
   def readpartial(maxlen, str = nil)
     @read_buffer ||= +''
-    result = Thread.current.backend.recv(self, @read_buffer, maxlen)
+    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
     raise EOFError unless result
 
     if str
@@ -192,12 +198,12 @@ class ::TCPServer
 
   alias_method :orig_accept, :accept
   def accept
-    Thread.current.backend.accept(@io, TCPSocket)
+    Polyphony.backend_accept(@io, TCPSocket)
     # @io.accept
   end
 
   def accept_loop(&block)
-    Thread.current.backend.accept_loop(@io, TCPSocket, &block)
+    Polyphony.backend_accept_loop(@io, TCPSocket, &block)
   end
 
   alias_method :orig_close, :close
@@ -209,40 +215,43 @@ end
 class ::UNIXServer
   alias_method :orig_accept, :accept
  def accept
-    Thread.current.backend.accept(self, UNIXSocket)
+    Polyphony.backend_accept(self, UNIXSocket)
   end
 
   def accept_loop(&block)
-    Thread.current.backend.accept_loop(self, UNIXSocket, &block)
+    Polyphony.backend_accept_loop(self, UNIXSocket, &block)
   end
 end
 
 class ::UNIXSocket
   def recv(maxlen, flags = 0, outbuf = nil)
-    Thread.current.backend.recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen)
   end
 
   def recv_loop(&block)
-    Thread.current.backend.recv_loop(self, &block)
+    Polyphony.backend_recv_loop(self, &block)
   end
   alias_method :read_loop, :recv_loop
 
-  def send(mesg, flags = 0)
-    Thread.current.backend.send(self, mesg)
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_recv_feed_loop(self, receiver, method, &block)
   end
 
-  def write(str, *args)
-    if args.empty?
-      Thread.current.backend.send(self, str)
-    else
-      Thread.current.backend.send(self, str + args.join)
-    end
+  def send(mesg, flags)
+    Polyphony.backend_send(self, mesg, flags)
+  end
+
+  def write(*args)
+    Polyphony.backend_sendv(self, args, 0)
+  end
+
+  def <<(mesg)
+    Polyphony.backend_send(self, mesg, 0)
   end
-  alias_method :<<, :write
 
   def readpartial(maxlen, str = nil)
     @read_buffer ||= +''
-    result = Thread.current.backend.recv(self, @read_buffer, maxlen)
+    result = Polyphony.backend_recv(self, @read_buffer, maxlen)
     raise EOFError unless result
 
     if str

data/lib/polyphony/version.rb

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

data/polyphony.gemspec

@@ -22,12 +22,13 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.6'
 
   s.add_development_dependency  'rake-compiler',        '1.1.1'
-  s.add_development_dependency  'minitest',             '5.13.0'
+  s.add_development_dependency  'minitest',             '5.14.4'
   s.add_development_dependency  'minitest-reporters',   '1.4.2'
   s.add_development_dependency  'simplecov',            '0.17.1'
   s.add_development_dependency  'rubocop',              '0.85.1'
   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'
@@ -37,8 +38,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency  'sequel',               '5.34.0'
   s.add_development_dependency  'httparty',             '0.17.1'
 
-  s.add_development_dependency  'jekyll',               '~>3.8.6'
-  s.add_development_dependency  'jekyll-remote-theme',  '~>0.4.1'
-  s.add_development_dependency  'jekyll-seo-tag',       '~>2.6.1'
-  s.add_development_dependency  'just-the-docs',        '~>0.3.0'
+  # s.add_development_dependency  'jekyll',               '~>3.8.6'
+  # s.add_development_dependency  'jekyll-remote-theme',  '~>0.4.1'
+  # s.add_development_dependency  'jekyll-seo-tag',       '~>2.6.1'
+  # s.add_development_dependency  'just-the-docs',        '~>0.3.0'
 end

data/test/helper.rb

@@ -52,7 +52,7 @@ class MiniTest::Test
     Fiber.current.instance_variable_set(:@auto_watcher, nil)
     Thread.current.backend.finalize
     Thread.current.backend = Polyphony::Backend.new
-    sleep 0
+    sleep 0.001
   end
 
   def teardown

data/test/stress.rb

@@ -8,6 +8,8 @@ def run_test(count)
   puts "#{count}: running tests..."
   # sleep 1
   system(TEST_CMD)
+  puts
+
   return if $?.exitstatus == 0
 
   puts "Failure after #{count} tests"

data/test/test_backend.rb

@@ -125,12 +125,15 @@ class BackendTest < MiniTest::Test
     assert_equal [:ready, 'foo', 'bar'], buf
   end
 
-  def test_accept_loop
-    server = TCPServer.new('127.0.0.1', 1234)
+  Net = Polyphony::Net
+
+  def test_accept
+    server = Net.listening_socket_from_options('127.0.0.1', 1234, reuse_addr: true)
 
     clients = []
-    server_fiber = spin do
-      @backend.accept_loop(server, TCPSocket) { |c| clients << c }
+    server_fiber = spin_loop do
+      c = @backend.accept(server, TCPSocket)
+      clients << c
     end
 
     c1 = TCPSocket.new('127.0.0.1', 1234)
@@ -146,7 +149,32 @@ class BackendTest < MiniTest::Test
   ensure
     c1&.close
     c2&.close
-    server_fiber.stop
+    server_fiber&.stop
+    snooze
+    server&.close
+  end
+
+  def test_accept_loop
+    server = Net.listening_socket_from_options('127.0.0.1', 1235, reuse_addr: true)
+
+    clients = []
+    server_fiber = spin do
+      @backend.accept_loop(server, TCPSocket) { |c| clients << c }
+    end
+
+    c1 = TCPSocket.new('127.0.0.1', 1235)
+    sleep 0.01
+
+    assert_equal 1, clients.size
+
+    c2 = TCPSocket.new('127.0.0.1', 1235)
+    sleep 0.01
+
+    assert_equal 2, clients.size
+  ensure
+    c1&.close
+    c2&.close
+    server_fiber&.stop
     snooze
     server&.close
   end
@@ -209,4 +237,123 @@ class BackendTest < MiniTest::Test
     end
     assert_equal [1], buffer
   end
+
+  def test_splice
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+    len = nil
+
+    spin {
+      len = o2.splice(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foobar')
+    result = i2.read
+
+    assert_equal 'foobar', result
+    assert_equal 6, len
+  end
+
+  def test_splice_to_eof
+    i1, o1 = IO.pipe
+    i2, o2 = IO.pipe
+    len = nil
+
+    f = spin {
+      len = o2.splice_to_eof(i1, 1000)
+      o2.close
+    }
+
+    o1.write('foo')
+    result = i2.readpartial(1000)
+    assert_equal 'foo', result
+
+    o1.write('bar')
+    result = i2.readpartial(1000)
+    assert_equal 'bar', result
+    o1.close
+    f.await
+    assert_equal 6, len
+  ensure
+    if f.alive?
+      f.interrupt
+      f.await
+    end
+  end
+end
+
+class BackendChainTest < MiniTest::Test
+  def setup
+    super
+    @prev_backend = Thread.current.backend
+    @backend = Polyphony::Backend.new
+    Thread.current.backend = @backend
+  end
+
+  def teardown
+    @backend.finalize
+    Thread.current.backend = @prev_backend
+  end
+
+  def test_simple_write_chain
+    i, o = IO.pipe
+
+    result = Thread.backend.chain(
+      [:write, o, 'hello'],
+      [:write, o, ' world']
+    )
+
+    assert_equal 6, result
+    o.close
+    assert_equal 'hello world', i.read
+  end
+
+  def chunk_header(len)
+    "Content-Length: #{len}\r\n\r\n"
+  end
+
+  def serve_io(from, to)
+    i, o = IO.pipe
+    backend = Thread.current.backend
+    while true
+      len = o.splice(from, 8192)
+      break if len == 0
+      
+      backend.chain(
+        [:write, to, chunk_header(len)],
+        [:splice, i, to, len]
+      )
+    end
+    to.close
+  end
+
+  def test_chain_with_splice
+    from_r, from_w = IO.pipe
+    to_r, to_w = IO.pipe
+
+    result = nil
+    f = spin { serve_io(from_r, to_w) }
+
+    from_w << 'Hello world!'
+    from_w.close
+
+    assert_equal "Content-Length: 12\r\n\r\nHello world!", to_r.read
+  end
+
+  def test_invalid_op
+    i, o = IO.pipe
+
+    assert_raises(RuntimeError) {
+      Thread.backend.chain(
+        [:read, o]
+      )
+    }
+
+    assert_raises(TypeError) {
+      Thread.backend.chain(
+        [:write, o]
+      )
+    }
+  end
 end