uringmachine 0.26.0 → 0.28.0

data/ext/um/um_op.c

@@ -18,9 +18,11 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     case OP_STATX:              return "OP_STATX";
     case OP_ACCEPT:             return "OP_ACCEPT";
     case OP_RECV:               return "OP_RECV";
+    case OP_RECVMSG:            return "OP_RECVMSG";
     case OP_SEND:               return "OP_SEND";
-    case OP_SENDV:              return "OP_SENDV";
     case OP_SEND_BUNDLE:        return "OP_SEND_BUNDLE";
+    case OP_SENDMSG:            return "OP_SENDMSG";
+    case OP_SENDV:              return "OP_SENDV";
     case OP_SOCKET:             return "OP_SOCKET";
     case OP_CONNECT:            return "OP_CONNECT";
     case OP_BIND:               return "OP_BIND";

data/ext/um/um_stream.c

@@ -19,6 +19,7 @@ static inline void stream_check_truncate_buffer(struct um_stream *stream) {
   }
 }
 
+// returns true if eof
 int stream_read_more(struct um_stream *stream) {
   stream_check_truncate_buffer(stream);
 
@@ -104,6 +105,16 @@ VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len) {
   return buf;
 }
 
+VALUE stream_skip(struct um_stream *stream, size_t len) {
+  while (stream->len - stream->pos < len)
+    if (!stream_read_more(stream)) {
+      return Qnil;
+    }
+
+  stream->pos += len;
+  return NUM2INT(len);
+}
+
 VALUE resp_get_line(struct um_stream *stream, VALUE out_buffer) {
   char *start = RSTRING_PTR(stream->buffer) + stream->pos;
   while (true) {

data/ext/um/um_stream_class.c

@@ -65,6 +65,14 @@ VALUE Stream_get_string(VALUE self, VALUE buf, VALUE len) {
   return stream_get_string(stream, buf, NUM2LONG(len));
 }
 
+// skips `len` bytes in the stream. This function returns nil if eof is
+// encountered.
+VALUE Stream_skip(VALUE self, VALUE len) {
+  struct um_stream *stream = Stream_data(self);
+
+  return stream_skip(stream, NUM2LONG(len));
+}
+
 VALUE Stream_resp_decode(VALUE self) {
   struct um_stream *stream = Stream_data(self);
   if (unlikely(stream->eof)) return Qnil;
@@ -104,6 +112,7 @@ void Init_Stream(void) {
 
   rb_define_method(cStream, "get_line", Stream_get_line, 2);
   rb_define_method(cStream, "get_string", Stream_get_string, 2);
+  rb_define_method(cStream, "skip", Stream_skip, 1);
 
   rb_define_method(cStream, "resp_decode", Stream_resp_decode, 0);
 

data/grant-2025/tasks.md

@@ -129,10 +129,10 @@
 
     - [v] Postgres test
 
-- [ ] Ruby Fiber::Scheduler interface
+- [v] Ruby Fiber::Scheduler interface
   - [v] Make a PR for resetting the scheduler and resetting the fiber non-blocking flag.
   - [v] hook for close
-  - [ ] hooks for send/recv/sendmsg/recvmsg
+  - [x] hooks for send/recv/sendmsg/recvmsg (Ruby core PR pending for send/recv)
 
 - [v] SSL
   - [v] setup custom BIO
@@ -147,22 +147,9 @@
   - [ ] docs (similar to papercraft docs)
 
 - [ ] Uma - web server
-  - [ ] child process workers
-  - [ ] reforking (following https://github.com/Shopify/pitchfork)
-        see also: https://byroot.github.io/ruby/performance/2025/03/04/the-pitchfork-story.html
-        - Monitor worker memory usage - how much is shared
-        - Choose worker with most served request count as "mold" for next generation
-        - Perform GC out of band, preferably when there are no active requests
-          https://railsatscale.com/2024-10-23-next-generation-oob-gc/
-        - When a worker is promoted to "mold", it:
-          - Stops `accept`ing requests
-          - When finally idle, calls `Process.warmup`
-          - Starts replacing sibling workers with forked workers
-        see also: https://www.youtube.com/watch?v=kAW5O2dkSU8
-  - [ ] Each worker is single-threaded (except for worker threads)
   - [ ] Rack 3.0-compatible
         see: https://github.com/socketry/protocol-rack
   - [ ] Rails integration (Railtie)
         see: https://github.com/socketry/falcon
   - [ ] Benchmarks
-  - [ ] Add to the TechEmpower bencchmarks
+  - [ ] Add to the TechEmpower benchmarks

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.26.0'
+  VERSION = '0.28.0'
 end

data/lib/uringmachine.rb

@@ -36,6 +36,11 @@ class UringMachine
     fiber
   end
 
+  def terminate(*fibers)
+    exception = UM::Terminate.new
+    fibers.each { schedule(it, exception) }
+  end
+
   # Runs the given block in the given fiber. This method is used to run fibers
   # indirectly.
   #

data/test/test_async_op.rb

@@ -60,7 +60,7 @@ class AsyncOpTest < UMBaseTest
     assert_equal true, @op.cancelled?
   end
 
-  class TOError < RuntimeError; end
+  class TOError < StandardError; end
 
   def test_async_op_await_with_timeout
     e = nil

data/test/test_stream.rb

@@ -98,6 +98,23 @@ class StreamTest < StreamBaseTest
     ret = @stream.get_string(nil, -4)
     assert_nil ret
   end
+
+  def test_skip
+    machine.write(@wfd, "foobar")
+    machine.close(@wfd)
+
+    ret = @stream.get_string(nil, 2)
+    assert_equal 'fo', ret
+
+    ret = @stream.skip(2)
+    assert_equal 2, ret
+
+    ret = @stream.get_string(nil, 2)
+    assert_equal 'ar', ret
+
+    ret = @stream.skip(2)
+    assert_nil ret
+  end
 end
 
 class StreamRespTest < StreamBaseTest

data/test/test_um.rb

@@ -238,7 +238,38 @@ class ScheduleTest < UMBaseTest
     assert_in_range 0..0.1, t1 - t0
   end
 
-  class TOError < RuntimeError; end
+  def test_terminate
+    e = nil
+    f = machine.spin do
+      machine.sleep(1)
+    rescue UM::Terminate => e
+    end
+
+    machine.snooze
+    machine.terminate(f)
+    machine.snooze
+    assert_kind_of UM::Terminate, e
+    assert_equal true, f.done?
+  end
+
+  def test_terminate_multi
+    f1 = machine.spin { machine.sleep(1) }
+    f2 = machine.spin { machine.sleep(1) }
+    f3 = machine.spin { machine.sleep(1) }
+
+    machine.snooze
+    machine.terminate(f1, f2)
+    machine.snooze
+    assert_equal true, f1.done?
+    assert_equal true, f2.done?
+    assert_nil f3.done?
+
+    machine.terminate(f3)
+    machine.snooze
+    assert_equal true, f3.done?
+  end
+
+  class TOError < StandardError; end
 
   def test_timeout
     buf = []
@@ -299,8 +330,8 @@ class ScheduleTest < UMBaseTest
     assert_equal 0, machine.metrics[:ops_pending]
   end
 
-  class TO2Error < RuntimeError; end
-  class TO3Error < RuntimeError; end
+  class TO2Error < StandardError; end
+  class TO3Error < StandardError; end
 
   def test_timeout_nested
     e = nil
@@ -351,7 +382,7 @@ class SleepTest < UMBaseTest
     assert_kind_of C, ret
   end
 
-  class D < RuntimeError; end
+  class D < StandardError; end
 
   def test_sleep_with_timeout
     t0 = monotonic_clock
@@ -733,7 +764,7 @@ class ReadEachTest < UMBaseTest
   class TOError < StandardError; end
 
   def test_read_each_timeout
-    r, w = IO.pipe
+    r, _w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
 
     bufs = []
@@ -955,7 +986,7 @@ class WritevTest < UMBaseTest
     machine.join(f)
   end
 
-  class TOError < RuntimeError; end
+  class TOError < StandardError; end
 
   def test_writev_timeout
     r, w = UM.pipe
@@ -1344,7 +1375,7 @@ class AcceptEachTest < UMBaseTest
   def test_accept_each_closed
     count = 0
     done = nil
-    f = @machine.spin do
+    @machine.spin do
       machine.accept_each(@server.fileno) do |fd|
         count += 1
       end
@@ -1639,8 +1670,6 @@ class SendvTest < UMBaseTest
   end
 
   def test_sendv
-    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
-
     ret = machine.sendv(@s1, 'foo', 'bar', 'baz')
     assert_equal 9, ret
 
@@ -1653,8 +1682,6 @@ class SendvTest < UMBaseTest
   end
 
   def test_sendv_io_buffer
-    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
-
     buf1 = IO::Buffer.new(6)
     buf1.set_string('foobar')
 
@@ -1673,8 +1700,6 @@ class SendvTest < UMBaseTest
   end
 
   def test_sendv_invalid_buffer
-    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
-
     assert_raises(UM::Error) { machine.sendv(@s1, [], 'abc') }
     assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 0, machine.metrics[:ops_free]
@@ -1816,7 +1841,7 @@ class RecvEachTest < UMBaseTest
 
   def test_recv_each_timeout
     t = Thread.new do
-      conn = @server.accept
+      @server.accept
       sleep
     end
 
@@ -1847,7 +1872,7 @@ class RecvEachTest < UMBaseTest
 
   def test_recv_each_shutdown
     t = Thread.new do
-      conn = @server.accept
+      @server.accept
       sleep
     end
 
@@ -1861,7 +1886,7 @@ class RecvEachTest < UMBaseTest
     bufs = []
     e = nil
 
-    f = machine.spin {
+    machine.spin {
       machine.sleep(0.01)
       machine.shutdown(fd, UM::SHUT_RDWR)
     }
@@ -1881,6 +1906,244 @@ class RecvEachTest < UMBaseTest
   end
 end
 
+class SendRecvFdTest < UMBaseTest
+  def setup
+    @s1_fd, @s2_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
+    super
+  end
+
+  def teardown
+    [@s1_fd, @s2_fd].each { machine.close(it) rescue nil }
+    super
+  end
+
+  class TOError < StandardError; end
+
+  def test_send_recv_fd
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+
+    fd = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, fd
+    refute_equal w_fd, fd
+
+    machine.close(w_fd)
+    machine.write(fd, 'foobar')
+    machine.close(fd)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  end
+
+  def test_send_recv_fd_multi
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+
+    w_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, w_fd2
+    refute_equal w_fd, w_fd2
+
+    res = machine.send_fd(@s1_fd, r_fd)
+    assert_equal r_fd, res
+
+    r_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, r_fd2
+    refute_equal r_fd, r_fd2
+
+    machine.close(w_fd)
+    machine.write(w_fd2, 'foobar')
+    machine.close(w_fd2)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  ensure
+    machine.close(r_fd) if r_fd rescue nil
+    machine.close(w_fd) if w_fd rescue nil
+    machine.close(r_fd2) if r_fd2 rescue nil
+    machine.close(w_fd2) if w_fd2 rescue nil
+
+  end
+
+  def test_send_recv_fd_mixed_multi
+    r_fd, w_fd = UM.pipe
+
+    machine.send(@s1_fd, 'hi', 2, 0)
+    buf = +''
+    ret = machine.recv(@s2_fd, buf, 2, 0)
+    assert_equal 2, ret
+    assert_equal 'hi', buf
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+
+    w_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, w_fd2
+    refute_equal w_fd, w_fd2
+
+    res = machine.send_fd(@s1_fd, r_fd)
+    assert_equal r_fd, res
+
+    r_fd2 = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, r_fd2
+    refute_equal r_fd, r_fd2
+
+    machine.close(w_fd)
+    machine.write(w_fd2, 'foobar')
+    machine.close(w_fd2)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  ensure
+    machine.close(r_fd) if r_fd rescue nil
+    machine.close(w_fd) if w_fd rescue nil
+    machine.close(r_fd2) if r_fd2 rescue nil
+    machine.close(w_fd2) if w_fd2 rescue nil
+
+  end
+
+  def test_send_recv_fd_inverse
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s2_fd, w_fd)
+    assert_equal w_fd, res
+
+    fd = machine.recv_fd(@s1_fd)
+    assert_kind_of Integer, fd
+    refute_equal w_fd, fd
+
+    machine.close(w_fd)
+    machine.write(fd, 'foobar')
+    machine.close(fd)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  end
+
+  def test_send_recv_fd_fork
+    pid = fork do
+      m = UM.new
+      fd = m.recv_fd(@s2_fd)
+      m.write(fd, 'Hello!')
+    ensure
+      m.close(fd) rescue nil
+    end
+
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+    Process.wait(pid)
+    pid = nil
+    machine.close(w_fd)
+
+    buf = +''
+    len = machine.timeout(1, TOError) { machine.read(r_fd, buf, 12) }
+    assert_equal 6, len
+    assert_equal 'Hello!', buf
+  ensure
+    if pid
+      Process.kill('KILL', pid) rescue nil
+      Process.wait(pid) rescue nil
+    end
+    machine.close(r_fd) rescue nil
+    machine.close(w_fd) rescue nil
+  end
+
+  def test_send_recv_fd_fork_mixed_msgs
+    skip
+
+    pid = fork do
+      m = UM.new
+      buf = +''
+      ret = m.recv(@s2_fd, buf, 128, 0)
+      p forked_recv: buf, ret: ret
+      ret = m.send(@s2_fd, buf, buf.bytesize, 0)
+      p forked_send: buf, ret: ret
+      fd = m.recv_fd(@s2_fd)
+      p forked_recv_fd: fd
+      ret = m.send(@s2_fd, buf, buf.bytesize, 0)
+      p forked_send: buf, ret: ret
+
+      m.write(fd, 'foo')
+    ensure
+      m.close(fd) if fd rescue nil
+    end
+
+    buf = +''
+    
+    machine.send(@s1_fd, 'coocoo', 6, 0)
+    machine.recv(@s1_fd, buf, 128, 0)
+    assert_equal 'coocoo', buf
+
+    r_fd, w_fd = UM.pipe
+    machine.send_fd(@s1_fd, w_fd)
+    machine.recv(@s1_fd, buf, 128, 0)
+    assert_equal 'coocoo', buf
+
+    machine.read(r_fd, buf, 128)
+    assert_equal 'foo', buf
+  ensure
+    if pid
+      Process.kill('KILL', pid) rescue nil
+      Process.wait(pid) rescue nil
+    end
+    machine.close(r_fd) rescue nil
+    machine.close(w_fd) rescue nil
+  end
+
+  def test_send_recv_fd_fork_inverse
+    pid = fork do
+      m = UM.new
+      r, w = UM.pipe
+      m.send_fd(@s2_fd, r)
+
+      buf = +''
+      m.read(r, buf, 128)
+      m.send(@s2_fd, buf)
+    end
+
+    assert_raises(Errno::EINVAL) { machine.recv_fd(@s1_fd) }
+  ensure
+    if pid
+      Process.kill('KILL', pid) rescue nil
+      Process.wait(pid) rescue nil
+    end
+    machine.close(w) rescue nil
+  end
+
+  def test_send_fd_bad_sock_fd
+    _r_fd, w_fd = UM.pipe
+    assert_raises(Errno::ENOTSOCK) { machine.send_fd(0, w_fd) }
+  end
+
+  def test_send_fd_bad_fd
+    assert_raises(TypeError) { machine.send_fd(@s1_fd, nil) }
+    assert_raises(Errno::EBADF) { machine.send_fd(@s1_fd, 1111) }
+  end
+
+  def test_recv_fd_bad_msg
+    buf = "\0" * 1000
+    machine.write(@s1_fd, buf)
+    
+    assert_raises(Errno::EINVAL) {
+      res = machine.recv_fd(@s2_fd)
+      p res: res
+    }
+  end
+end
+
 class BindTest < UMBaseTest
   def setup
     super
@@ -2836,23 +3099,6 @@ class SendBundleTest < UMBaseTest
   end
 end
 
-class NonBlockTest < UMBaseTest
-  def test_io_nonblock?
-    assert_equal false, UM.io_nonblock?(STDIN)
-  end
-
-  def test_io_set_nonblock
-    r, _w = IO.pipe
-    assert_equal true, UM.io_nonblock?(r)
-
-    UM.io_set_nonblock(r, false)
-    assert_equal false, UM.io_nonblock?(r)
-
-    UM.io_set_nonblock(r, true)
-    assert_equal true, UM.io_nonblock?(r)
-  end
-end
-
 class MetricsTest < UMBaseTest
   def test_metrics_empty
     assert_equal({
@@ -3159,3 +3405,39 @@ class FileWatchTest < UMBaseTest
     machine.join(f)
   end
 end
+
+class SetChildSubreaperTest < Minitest::Test
+  def test_pr_set_child_subreaper
+    r, w = IO.pipe
+    UM.pr_set_child_subreaper(true)
+    
+    child_pid = fork {
+      r2, w2 = IO.pipe
+      pid = fork {
+        r.close
+        w.close
+        w2.close
+        r2.read
+        r2.close
+        sleep(0.01)
+      }
+      w << pid
+      w.close
+      r2.close
+      w2 << 'done'
+      w2.close
+    }
+    Process.wait(child_pid)
+
+    w.close
+    msg = r.read
+    r.close
+
+    refute msg.empty?
+    grand_child_pid = msg.to_i
+    refute_equal 0, grand_child_pid
+
+    res = Process.wait(grand_child_pid)
+    assert_equal grand_child_pid, res
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.28.0
 platform: ruby
 authors:
 - Sharon Rosner