polyphony 0.59.1 → 0.63

data/lib/polyphony/extensions/io.rb

@@ -101,16 +101,20 @@ class ::IO
     return @read_buffer.slice!(0) if @read_buffer && !@read_buffer.empty?
     
     @read_buffer ||= +''
-    Polyphony.backend_read(self, @read_buffer, 8192, false)
+    Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
     return @read_buffer.slice!(0) if !@read_buffer.empty?
 
     nil
   end
 
   alias_method :orig_read, :read
-  def read(len = nil)
+  def read(len = nil, buf = nil, buf_pos = 0)
+    if buf
+      return Polyphony.backend_read(self, buf, len, true, buf_pos)
+    end
+    
     @read_buffer ||= +''
-    result = Polyphony.backend_read(self, @read_buffer, len, true)
+    result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
     return nil unless result
 
     already_read = @read_buffer
@@ -119,8 +123,8 @@ class ::IO
   end
 
   alias_method :orig_readpartial, :read
-  def readpartial(len, str = +'')
-    result = Polyphony.backend_read(self, str, len, false)
+  def readpartial(len, str = +'', buffer_pos = 0)
+    result = Polyphony.backend_read(self, str, len, false, buffer_pos)
     raise EOFError unless result
 
     result
@@ -151,9 +155,10 @@ class ::IO
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      data = readpartial(8192, +'')
-      return nil unless data
-      @read_buffer << data
+      result = readpartial(8192, @read_buffer, -1)
+        
+      #Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
+      return nil unless result
     end
   rescue EOFError
     return nil
@@ -216,8 +221,8 @@ class ::IO
     buf ? readpartial(maxlen, buf) : readpartial(maxlen)
   end
 
-  def read_loop(&block)
-    Polyphony.backend_read_loop(self, &block)
+  def read_loop(maxlen = 8192, &block)
+    Polyphony.backend_read_loop(self, maxlen, &block)
   end
 
   def feed_loop(receiver, method = :call, &block)

data/lib/polyphony/extensions/openssl.rb

@@ -64,13 +64,37 @@ class ::OpenSSL::SSL::SSLSocket
     # @sync = osync
   end
 
-  def readpartial(maxlen, buf = +'')
-    result = sysread(maxlen, buf)
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return readpartial(maxlen, buf, buf_pos) if buf
+
+    buf = +''
+    return readpartial(maxlen, buf) if maxlen
+
+    while true
+      readpartial(4096, buf, -1)
+    end
+  rescue EOFError
+    buf
+  end
+
+  def readpartial(maxlen, buf = +'', buffer_pos = 0)
+    if buffer_pos != 0
+      if (result = sysread(maxlen, +''))
+        if buffer_pos == -1
+          result = buf + result
+        else
+          result = buf[0...buffer_pos] + result
+        end
+      end
+    else
+      result = sysread(maxlen, buf)
+    end
     result || (raise EOFError)
   end
 
-  def read_loop
-    while (data = sysread(8192))
+  def read_loop(maxlen = 8192)
+    while (data = sysread(maxlen))
       yield data
     end
   end

data/lib/polyphony/extensions/socket.rb

@@ -22,12 +22,29 @@ class ::Socket
     Polyphony.backend_connect(self, addr.ip_address, addr.ip_port)
   end
 
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return Polyphony.backend_recv(self, buf, maxlen, buf_pos) if buf
+    return Polyphony.backend_recv(self, buf || +'', maxlen, 0) if maxlen
+    
+    buf = +''
+    len = buf.bytesize
+    while true
+      Polyphony.backend_recv(self, buf, maxlen || 4096, -1)
+      new_len = buf.bytesize
+      break if new_len == len
+
+      len = new_len
+    end
+    buf
+  end
+
   def recv(maxlen, flags = 0, outbuf = nil)
-    Polyphony.backend_recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
 
-  def recv_loop(&block)
-    Polyphony.backend_recv_loop(self, &block)
+  def recv_loop(maxlen = 8192, &block)
+    Polyphony.backend_recv_loop(self, maxlen, &block)
   end
   alias_method :read_loop, :recv_loop
 
@@ -60,8 +77,8 @@ class ::Socket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'')
-    Polyphony.backend_recv(self, str, maxlen)
+  def readpartial(maxlen, str = +'', buffer_pos = 0)
+    Polyphony.backend_recv(self, str, maxlen, buffer_pos)
   end
 
   ZERO_LINGER = [0, 0].pack('ii').freeze
@@ -140,12 +157,29 @@ class ::TCPSocket
     setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_REUSEPORT, 1)
   end
 
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return Polyphony.backend_recv(self, buf, maxlen, buf_pos) if buf
+    return Polyphony.backend_recv(self, buf || +'', maxlen, 0) if maxlen
+    
+    buf = +''
+    len = buf.bytesize
+    while true
+      Polyphony.backend_recv(self, buf, maxlen || 4096, -1)
+      new_len = buf.bytesize
+      break if new_len == len
+
+      len = new_len
+    end
+    buf
+  end
+
   def recv(maxlen, flags = 0, outbuf = nil)
-    Polyphony.backend_recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
 
-  def recv_loop(&block)
-    Polyphony.backend_recv_loop(self, &block)
+  def recv_loop(maxlen = 8192, &block)
+    Polyphony.backend_recv_loop(self, maxlen, &block)
   end
   alias_method :read_loop, :recv_loop
 
@@ -165,8 +199,8 @@ class ::TCPSocket
   #   Polyphony.backend_send(self, mesg, 0)
   # end
 
-  def readpartial(maxlen, str = +'')
-    result = Polyphony.backend_recv(self, str, maxlen)
+  def readpartial(maxlen, str = +'', buffer_pos = 0)
+    result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError unless result
 
     str
@@ -217,12 +251,29 @@ class ::UNIXServer
 end
 
 class ::UNIXSocket
+  alias_method :orig_read, :read
+  def read(maxlen = nil, buf = nil, buf_pos = 0)
+    return Polyphony.backend_recv(self, buf, maxlen, buf_pos) if buf
+    return Polyphony.backend_recv(self, buf || +'', maxlen, 0) if maxlen
+    
+    buf = +''
+    len = buf.bytesize
+    while true
+      Polyphony.backend_recv(self, buf, maxlen || 4096, -1)
+      new_len = buf.bytesize
+      break if new_len == len
+
+      len = new_len
+    end
+    buf
+  end
+
   def recv(maxlen, flags = 0, outbuf = nil)
-    Polyphony.backend_recv(self, outbuf || +'', maxlen)
+    Polyphony.backend_recv(self, outbuf || +'', maxlen, 0)
   end
 
-  def recv_loop(&block)
-    Polyphony.backend_recv_loop(self, &block)
+  def recv_loop(maxlen = 8192, &block)
+    Polyphony.backend_recv_loop(self, maxlen, &block)
   end
   alias_method :read_loop, :recv_loop
 
@@ -242,8 +293,8 @@ class ::UNIXSocket
     Polyphony.backend_send(self, mesg, 0)
   end
 
-  def readpartial(maxlen, str = +'')
-    result = Polyphony.backend_recv(self, str, maxlen)
+  def readpartial(maxlen, str = +'', buffer_pos = 0)
+    result = Polyphony.backend_recv(self, str, maxlen, buffer_pos)
     raise EOFError unless result
 
     str

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.59.1'
+  VERSION = '0.63'
 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

@@ -26,14 +26,14 @@ class BackendTest < MiniTest::Test
       @backend.sleep 0.01
       count += 1
     }.await
-    assert_in_delta 0.03, Time.now - t0, 0.01
+    assert_in_range 0.02..0.04, Time.now - t0
     assert_equal 3, count
   end
 
   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,59 @@ 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_read_concat_big
+    i, o = IO.pipe
+
+    body = " " * 4000
+
+    data = "post /?q=time&blah=blah HTTP/1\r\nHost: dev.realiteq.net\r\n\r\n" +
+           "get /?q=time HTTP/1.1\r\nContent-Length: #{body.bytesize}\r\n\r\n#{body}" +
+           "get /?q=time HTTP/1.1\r\nCookie: foo\r\nCookie: bar\r\n\r\n"
+
+    o << data
+    o.close
+    
+    buf = +''
+
+    @backend.read(i, buf, 4096, false, -1)
+    assert_equal 4096, buf.bytesize
+    
+    @backend.read(i, buf, 1, false, -1)
+    assert_equal 4097, buf.bytesize
+
+    @backend.read(i, buf, 4096, false, -1)
+
+    assert_equal data.bytesize, buf.bytesize
+    assert_equal data, buf
+  end
+
   def test_waitpid
     pid = fork do
       @backend.post_fork
@@ -87,7 +140,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 +160,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 +178,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

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