uringmachine 1.0.1 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c4607791ec8b3aefe794167dc5a0ec500fe4ec4a58b56962d90d27fdd4c41a7
-  data.tar.gz: 151205d0887aef4cc0cf022baf295b9be8934f2bb895fd87bd98680a837349a0
+  metadata.gz: dea49e5d6f13c7919ccaa9765428bfc81058ad1fab0b3f1df07d0fd60a5b1cd3
+  data.tar.gz: 3cd06ca52b40e891807b589bc7d7f97cfc67be2d491e5855a9624de959f160a1
 SHA512:
-  metadata.gz: a4f580578fabf57dbc7c9c8d609a000b4b2ebc56ffb1273e3496137b7ba01f4ca71767e37d84d978dbf49b5012a211374cceb774b787f748c4b3351531a42c42
-  data.tar.gz: 0cc8a8d93345894b2f2b3570390ae829dea4bac1e975a0d777c7359e74161273df9658b0797bd2ecbe45a262efbd7588dd8f9ec673577d91e7e8030bd9ab15e4
+  metadata.gz: 06ef57453cc0986a0b047b9d91ab5add06cf64145d5fd17ba5d85edf1b01f1bde0cea060d3a54bc87cadc9fc4c0137350ad704b0f0c1421f51c9ef9158eed8c5
+  data.tar.gz: 65a8701e871902c7e726cdaebacebef4bde5c111b6a3393b92d40a9b5a3005535f240cb30574f34fa41048206430b8faa41203d23a2fab603285c88eb9e766b4

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 1.0.4 2026-08-24
+
+- Add `IO#read_uint_be` method
+
+# 1.0.3 2026-08-24
+
+- Add `IO#read_int_be` method
+- Don't schedule fiber for async multishot ops (fixes potential segfault when using UM::IO)
+
+# 1.0.2 2026-05-25
+
+- Fix DNS resolver
+
 # 1.0.1 2026-05-12
 
 - Fix Net::HTTP performance regression when running on fiber scheduler

data/TODO.md

@@ -1,5 +1,43 @@
 ## immediate
 
+- IO methods:
+  ```ruby
+  io.read_int_be(length)
+  io.read_uint_be(length)
+  io.read_int_le(length)
+  io.read_uint_le(length)
+  ```
+
+- It might be interesting to have a DSL where we can define a frame/header structure:
+
+  ```ruby
+  http2_transform = UM::IO.transform do
+    length    uint(24)
+    type      uint(8)
+    flags     uint(8)
+    stream_id uint(32)
+  end
+
+  frame = io.read(http2_transform)
+  raise if frame[:length] > MAX_LENGTH
+  raise if stream_id &  0x80000000
+  ```
+
+- SSL kTLS:
+  - discussion: https://share.gemini.google/tPWiFpr3bWeF
+  - API:
+
+    ```ruby
+    machine.ssl_setup_ktls(fd)
+
+    # then we can just use normal send/recv
+    machine.send(fd, "foo!")
+    ```
+
+- SSL custom BIO:
+  - release GVL before calling `SSL_read`, `SSL_write`
+  - reacquire GVL (`rb_thread_call_with_gvl`) in `um_bio_read`, `um_bio_write`
+
 - Add `IO#http_xxx` methods
   - `#http_read_request_headers()`
   - `#http_read_body(content_length)` (-1 means chunked TE)
@@ -84,21 +122,6 @@
 - madvise
 - getxattr / setxattr
 
-## actors
-
-When doing a `call`, we need to provide a mailbox for the response. can this be
-automatic?
-
-## Syntax / pattern for launching/supervising multiple operations
-
-Select (see above):
-
-```ruby
-# select
-machine.join_select(*fibers) #=> [result, fiber]
-machine.shift_select(*queues) #=> [result, queue]
-```
-
 ## Other abstractions
 
 - Happy eyeballs connect

data/examples/irb_fiber.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'uringmachine'
+require 'uringmachine/fiber_scheduler'
+require 'irb'
+
+@machine = UringMachine.new
+@scheduler = UM::FiberScheduler.new(@machine)
+Fiber.set_scheduler @scheduler
+
+f = @machine.spin { IRB.start }
+@machine.join(f)

data/ext/um/um.c

@@ -192,7 +192,7 @@ static inline void um_process_cqe(struct um *machine, struct io_uring_cqe *cqe)
     um_op_multishot_results_push(machine, op, cqe->res, cqe->flags);
 
     op->flags |= done ? (OP_F_CQE_SEEN | OP_F_CQE_DONE) : OP_F_CQE_SEEN;
-    if (!OP_SCHEDULED_P(op)) um_schedule_op(machine, op);
+    if (!(op->flags & (OP_F_SCHEDULED | OP_F_ASYNC))) um_schedule_op(machine, op);
   }
   else {
     // single shot

data/ext/um/um.h

@@ -426,6 +426,8 @@ VALUE io_read(struct um_io *io, VALUE out_buffer, ssize_t len, size_t inc, int s
 VALUE io_read_to_delim(struct um_io *io, VALUE out_buffer, VALUE delim, ssize_t maxlen);
 void io_skip(struct um_io *io, size_t inc, int safe_inc);
 void io_read_each(struct um_io *io);
+VALUE io_read_int_be(struct um_io *io, size_t len);
+VALUE io_read_uint_be(struct um_io *io, size_t len);
 size_t io_write_raw(struct um_io *io, const char *buffer, size_t len);
 VALUE io_writev(struct um_io *io, int argc, VALUE *argv);
 VALUE resp_read(struct um_io *io, VALUE out_buffer);

data/ext/um/um_io.c

@@ -74,13 +74,12 @@ void um_io_cleanup(struct um_io *io) {
     um_segment_checkin(io->machine, io->head);
     io->head = next;
   }
+  io->tail = NULL;
   io->pending_bytes = 0;
 }
 
 // returns true if case of ENOBUFS error, sets more to true if more data forthcoming
-inline int io_process_segments(
-  struct um_io *io, size_t *total_bytes, int *more) {
-
+inline int io_process_segments(struct um_io *io, size_t *total_bytes, int *more) {
   *more = 0;
   struct um_op_result *result = &io->op->result;
   io->op->flags &= ~OP_F_CQE_SEEN;
@@ -125,6 +124,7 @@ void io_clear(struct um_io *io) {
     um_segment_checkin(io->machine, io->head);
     io->head = next;
   }
+  io->tail = NULL;
   io->pending_bytes = 0;
 
   if (io->working_buffer) {
@@ -133,6 +133,30 @@ void io_clear(struct um_io *io) {
   }
 }
 
+inline void io_handle_enobufs(struct um_io *io) {
+  // we want to restart only if in case we don't already have lots of pending
+  // bytes in the stream. This heuristic might need a closer look to determine
+  // if this is the correct behavior.
+  int should_restart = io->pending_bytes < (io->machine->bp_buffer_size * 4);
+
+  // fprintf(stderr, "%p enobufs total: %ld pending: %ld threshold: %ld bc: %d (same: %d, restart: %d)\n",
+  //   io,
+  //   total_bytes, io->pending_bytes, io->machine->bp_commit_level,
+  //   io->machine->bp_buffer_count,
+  //   same_threshold, should_restart
+  // );
+
+  if (should_restart) {
+    // If multiple IO ops are happening at the same time, they'll all get
+    // ENOBUFS! We track the buffer pool commit level in the op in order to
+    // prevent running bp_handle_enobufs() more than once.
+    if (io->op->bp_commit_level == io->machine->bp_commit_level)
+      bp_handle_enobufs(io->machine);
+  }
+  um_op_release(io->machine, io->op);
+  io->op = NULL;
+}
+
 inline void io_await_segments(struct um_io *io) {
   if (unlikely(!io->op)) io_multishot_op_start(io);
 
@@ -156,40 +180,12 @@ int io_get_more_segments_bp(struct um_io *io) {
     io_await_segments(io);
     enobufs = io_process_segments(io, &total_bytes, &more);
     um_op_multishot_results_clear(io->machine, io->op);
-    if (unlikely(enobufs)) {
-      int should_restart = io->pending_bytes < (io->machine->bp_buffer_size * 4);
-      // int same_threshold = io->op->bp_commit_level == io->machine->bp_commit_level;
-
-      // fprintf(stderr, "%p enobufs total: %ld pending: %ld threshold: %ld bc: %d (same: %d, restart: %d)\n",
-      //   io,
-      //   total_bytes, io->pending_bytes, io->machine->bp_commit_level,
-      //   io->machine->bp_buffer_count,
-      //   same_threshold, should_restart
-      // );
-
-      // If multiple IO ops are happening at the same time, they'll all
-      // get ENOBUFS! We track the commit threshold in the op in order to
-      // prevent running bp_handle_enobufs() more than once.
-
-      if (should_restart) {
-        if (io->op->bp_commit_level == io->machine->bp_commit_level)
-          bp_handle_enobufs(io->machine);
-
-        um_op_release(io->machine, io->op);
-        io->op = NULL;
-      }
-      else {
-        um_op_release(io->machine, io->op);
-        io->op = NULL;
-      }
 
-      if (total_bytes) return total_bytes;
-    }
-    else {
-      if (more)
-        io->op->flags &= ~OP_F_CQE_SEEN;
-      if (total_bytes || io->eof) return total_bytes;
-    }
+    if (unlikely(enobufs))
+      io_handle_enobufs(io);
+    else if (more)
+      io->op->flags &= ~OP_F_CQE_SEEN;
+    if (total_bytes || io->eof) return total_bytes;
   }
 }
 
@@ -254,9 +250,7 @@ inline void io_skip(struct um_io *io, size_t inc, int safe_inc) {
     io->pending_bytes -= inc_len;
     if (io->pos == io->head->len) {
       io_shift_head(io);
-      if (inc && safe_inc && !io->head) {
-        if (!io_get_more_segments(io)) break;
-      }
+      if (inc && safe_inc && !io->head && !io_get_more_segments(io)) break;
     }
   }
 }
@@ -285,6 +279,58 @@ inline void io_read_each(struct um_io *io) {
   RB_GC_GUARD(buffer);
 }
 
+VALUE io_read_int_be(struct um_io *io, size_t len) {
+  if (unlikely(io->eof && !io->head)) return Qnil;
+  if (!io->tail && !io_get_more_segments(io)) return Qnil;
+
+  long value = 0;
+  struct um_segment *current = io->head;
+
+  while (true) {
+    size_t segment_len = current->len - io->pos;
+    int pos = 0;
+    while (segment_len > 0 && len > 0) {
+      value = value * 0x100 + *(unsigned char *)(current->ptr + io->pos + pos);
+      len--;
+      segment_len--;
+      pos++;
+    }
+    if (pos > 0) io_skip(io, pos, true);
+
+    if (len == 0) return LONG2NUM(value);
+
+    if (!io->head && !io_get_more_segments(io))
+      return Qnil;
+    current = io->head;
+  }
+}
+
+VALUE io_read_uint_be(struct um_io *io, size_t len) {
+  if (unlikely(io->eof && !io->head)) return Qnil;
+  if (!io->tail && !io_get_more_segments(io)) return Qnil;
+
+  unsigned long value = 0;
+  struct um_segment *current = io->head;
+
+  while (true) {
+    size_t segment_len = current->len - io->pos;
+    int pos = 0;
+    while (segment_len > 0 && len > 0) {
+      value = value * 0x100 + *(unsigned char *)(current->ptr + io->pos + pos);
+      len--;
+      segment_len--;
+      pos++;
+    }
+    if (pos > 0) io_skip(io, pos, true);
+
+    if (len == 0) return ULONG2NUM(value);
+
+    if (!io->head && !io_get_more_segments(io))
+      return Qnil;
+    current = io->head;
+  }
+}
+
 inline void io_copy(struct um_io *io, char *dest, size_t len) {
   while (len) {
     char *segment_ptr = io->head->ptr + io->pos;
@@ -316,7 +362,7 @@ VALUE io_consume_string(struct um_io *io, VALUE out_buffer, size_t len, size_t i
   char *dest = RSTRING_PTR(str);
 
   io_copy(io, dest, len);
-  io_skip(io, inc, safe_inc);
+  if (inc) io_skip(io, inc, safe_inc);
   return str;
   RB_GC_GUARD(str);
 }

data/ext/um/um_io_class.c

@@ -242,6 +242,42 @@ VALUE IO_read_each(VALUE self) {
   return self;
 }
 
+#define MAX_INT_SIZE 8
+
+/* call-seq:
+ *   conn.read_int_be(len) -> int
+ *
+ * Reads a signed integer from the target in big endian notation. The len
+ * parameter indicates the integer field length in bytes, with an upper limit of
+ * 8 bytes. If EOF is encountered before enough bytes are read, returns nil.
+ *
+ * @param len [Integer] number of bytes to read
+ * @return [Integer, nil] integer value or nil if EOF
+ */
+VALUE IO_read_int_be(VALUE self, VALUE len) {
+  struct um_io *conn = um_get_io(self);
+  size_t len_i = NUM2UINT(len);
+  if (unlikely(len_i > MAX_INT_SIZE)) rb_raise(eUMError, "Invalid length given");
+  return io_read_int_be(conn, len_i);
+}
+
+/* call-seq:
+ *   conn.read_uint_be(len) -> int
+ *
+ * Reads an unsigned integer from the target in big endian notation. The len
+ * parameter indicates the integer field length in bytes, with an upper limit
+ * of 8 bytes. If EOF is encountered before enough bytes are read, returns nil.
+ *
+ * @param len [Integer] number of bytes to read
+ * @return [Integer, nil] integer value or nil if EOF
+ */
+VALUE IO_read_uint_be(VALUE self, VALUE len) {
+  struct um_io *conn = um_get_io(self);
+  size_t len_i = NUM2UINT(len);
+  if (unlikely(len_i > MAX_INT_SIZE)) rb_raise(eUMError, "Invalid length given");
+  return io_read_uint_be(conn, len_i);
+}
+
 /* call-seq:
  *   conn.write(*bufs) -> len
  *
@@ -375,6 +411,9 @@ void Init_IO(void) {
   rb_define_method(cIO, "skip", IO_skip, 1);
   rb_define_method(cIO, "read_each", IO_read_each, 0);
 
+  rb_define_method(cIO, "read_int_be", IO_read_int_be, 1);
+  rb_define_method(cIO, "read_uint_be", IO_read_uint_be, 1);
+
   rb_define_method(cIO, "write", IO_write, -1);
 
   rb_define_method(cIO, "resp_read", IO_resp_read, 0);

data/ext/um/um_op.c

@@ -156,9 +156,8 @@ inline void um_op_multishot_results_push(struct um *machine, struct um_op *op, _
   result->res   = res;
   result->flags = flags;
   result->next  = NULL;
-  if (op->flags & OP_F_BUFFER_POOL && res >= 0) {
+  if (op->flags & OP_F_BUFFER_POOL && res >= 0)
     result->segment = bp_get_op_result_segment(machine, op, res, flags);
-  }
 
   op->multishot_result_tail = result;
   op->multishot_result_count++;

data/lib/uringmachine/dns_resolver.rb

@@ -44,7 +44,7 @@ class UringMachine
     # @return [Array<String>] name servers
     def get_nameservers
       nameservers = []
-      IO.readlines('/etc/resolv.conf').each do |line|
+      ::IO.readlines('/etc/resolv.conf').each do |line|
         if line =~ /^nameserver (.+)$/
           nameservers << $1.split(/\s+/).first
         end

data/lib/uringmachine/version.rb

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

data/test/test_io.rb

@@ -305,6 +305,22 @@ class IOTest < IOBaseTest
     machine.terminate(f)
     machine.join(f)
   end
+
+  def test_io_read_segfault
+    machine.write(@wfd, "abcd")
+    conn.read(4)
+
+    machine.write(@wfd, "\x00\x01\x05\xdf")
+    conn.read(4)
+
+    f = machine.spin do
+      machine.write(@wfd, "\xde")
+      machine.snooze
+      machine.write(@wfd, "\x90\x03")
+    end
+    value = conn.read(3)
+    assert_equal "\xde\x90\x03".b, value
+  end  
 end
 
 class IOWriteTest < UMBaseTest
@@ -806,3 +822,113 @@ class IOByteCountsTest < IOBaseTest
     assert_equal 0, conn.pending
   end
 end
+
+class IOIntTest < IOBaseTest
+  def test_io_read_int_be
+    machine.write(@wfd, "abcd")
+    conn.read(4)
+
+    machine.write(@wfd, "\x00\x01\x05\xdf")
+    value = conn.read_int_be(2)
+    assert_equal 0x0001, value
+    value = conn.read_int_be(2)
+    assert_equal 0x05df, value
+
+    machine.write(@wfd, "\x00\x01\x05\xdf")
+    value = conn.read_int_be(4)
+    assert_equal 0x000105df, value
+
+    machine.write(@wfd, "\xde\xfa")
+    machine.snooze
+    machine.write(@wfd, "\xdd\x03")
+    machine.snooze
+    value = conn.read_int_be(4)
+    assert_equal 0xdefadd03, value
+
+    machine.write(@wfd, "\xed\xcb\xa9")
+    value = conn.read_int_be(3)
+    assert_equal 0xedcba9, value
+
+    f = machine.spin do
+      machine.write(@wfd, "\xde")
+      machine.snooze
+      machine.write(@wfd, "\x90\x03")
+    end
+    value = conn.read_int_be(3)
+    machine.join(f)
+    assert_equal 0xde9003, value
+
+    machine.write(@wfd, "\xde\xfa")
+    machine.close(@wfd)
+    assert_nil conn.read_int_be(4)
+  end
+
+  def test_io_read_int_be_invalid_length
+    machine.write(@wfd, (1..8).to_a.pack('C*'))
+    assert_raises(UM::Error) { conn.read_int_be(-1) }
+    assert_raises(UM::Error) { conn.read_int_be(20) }
+    assert_raises(UM::Error) { conn.read_int_be(9) }
+
+    # 8 is my limit on Schnitzengruben
+    value = conn.read_int_be(8)
+    assert_equal 0x0102030405060708, value
+  end
+
+  def test_io_read_uint_be
+    machine.write(@wfd, "abcd")
+    conn.read(4)
+
+    machine.write(@wfd, "\x00\x01\x05\xdf")
+    value = conn.read_uint_be(2)
+    assert_equal 0x0001, value
+    value = conn.read_uint_be(2)
+    assert_equal 0x05df, value
+
+    machine.write(@wfd, "\x00\x01\x05\xdf")
+    value = conn.read_uint_be(4)
+    assert_equal 0x000105df, value
+
+    machine.write(@wfd, "\xde\xfa")
+    machine.snooze
+    machine.write(@wfd, "\xdd\x03")
+    machine.snooze
+    value = conn.read_uint_be(4)
+    assert_equal 0xdefadd03, value
+
+    machine.write(@wfd, "\xed\xcb\xa9")
+    value = conn.read_uint_be(3)
+    assert_equal 0xedcba9, value
+
+    f = machine.spin do
+      machine.write(@wfd, "\xde")
+      machine.snooze
+      machine.write(@wfd, "\x90\x03")
+    end
+    value = conn.read_uint_be(3)
+    machine.join(f)
+    assert_equal 0xde9003, value
+
+    machine.write(@wfd, "\xff" * 8)
+    value = conn.read_uint_be(8)
+    assert_equal 0xffffffffffffffff, value
+
+    machine.write(@wfd, "\x80\x00\x00\x00\x00\x00\x00\x00")
+    value = conn.read_uint_be(8)
+    assert_equal 0x8000000000000000, value
+
+    machine.write(@wfd, "\xde\xfa")
+    machine.close(@wfd)
+    assert_nil conn.read_uint_be(4)
+  end
+
+  def test_io_read_uint_be_invalid_length
+    machine.write(@wfd, (0xf1..0xf8).to_a.pack('C*'))
+    assert_raises(UM::Error) { conn.read_uint_be(-1) }
+    assert_raises(UM::Error) { conn.read_uint_be(20) }
+    assert_raises(UM::Error) { conn.read_uint_be(9) }
+
+    # 8 is my limit on Schnitzengruben
+    value = conn.read_uint_be(8)
+    assert_equal 0xf1f2f3f4f5f6f7f8, value
+  end
+end

data/test/test_um.rb

@@ -3277,6 +3277,23 @@ class FileWatchTest < UMBaseTest
         name: 'foo.txt'
       }
     ], events
+
+    fn = File.join(@root, '.bar')
+    IO.write(fn, 'barbar')
+
+    events = machine.inotify_get_events(fd)
+    assert_equal [
+      {
+        wd: wd,
+        mask: UM::IN_CREATE,
+        name: '.bar'
+      },
+      {
+        wd: wd,
+        mask: UM::IN_CLOSE_WRITE,
+        name: '.bar'
+      }
+    ], events
   end
 
   def write_file(fn, data)
@@ -3386,6 +3403,25 @@ class FileWatchTest < UMBaseTest
       { mask: UM::IN_CREATE, fn: File.join(@root, 'bar/baz.txt') },
       { mask: UM::IN_CLOSE_WRITE, fn: File.join(@root, 'bar/baz.txt') },
     ], events
+
+    fn = File.join(@root, 'bar/.dotfile')
+    write_file(fn, 'dotdot')
+    machine.sleep(0.05)
+    assert_equal [
+      { mask: UM::IN_CLOSE_WRITE, fn: File.join(@root, 'foo.txt') },
+      { mask: UM::IN_CLOSE_WRITE, fn: File.join(@root, 'foo/baz.txt') },
+      { mask: UM::IN_CREATE | UM::IN_ISDIR, fn: File.join(@root, 'bar') },
+      { mask: UM::IN_CREATE, fn: File.join(@root, 'bar/baz.txt') },
+      { mask: UM::IN_CLOSE_WRITE, fn: File.join(@root, 'bar/baz.txt') },
+      { mask: UM::IN_DELETE, fn: File.join(@root, 'foo/baz.txt') },
+      { mask: UM::IN_DELETE, fn: File.join(@root, 'bar/baz.txt') },
+      { mask: UM::IN_DELETE | UM::IN_ISDIR, fn: File.join(@root, 'bar') },
+      { mask: UM::IN_CREATE | UM::IN_ISDIR, fn: File.join(@root, 'bar') },
+      { mask: UM::IN_CREATE, fn: File.join(@root, 'bar/baz.txt') },
+      { mask: UM::IN_CLOSE_WRITE, fn: File.join(@root, 'bar/baz.txt') },
+      { mask: UM::IN_CREATE, fn: File.join(@root, 'bar/.dotfile') },
+      { mask: UM::IN_CLOSE_WRITE, fn: File.join(@root, 'bar/.dotfile') },
+    ], events
   ensure
     machine.schedule(f, UM::Terminate.new)
     machine.join(f)
@@ -3397,22 +3433,26 @@ class SetChildSubreaperTest < Minitest::Test
     r, w = IO.pipe
     UM.pr_set_child_subreaper(true)
 
-    child_pid = fork {
+    child_pid = fork do
       r2, w2 = IO.pipe
-      pid = fork {
+      pid = fork do
         r.close
         w.close
         w2.close
         r2.read
         r2.close
         sleep(0.01)
-      }
+      ensure
+        exit!
+      end
       w << pid
       w.close
       r2.close
       w2 << 'done'
       w2.close
-    }
+    ensure
+      exit!
+    end
     Process.wait(child_pid)
 
     w.close
@@ -3635,4 +3675,11 @@ class FsyncTest < UMBaseTest
   def test_fsync_bad_args
     assert_raises(Errno::EINVAL) { machine.fsync(1) }
   end
-end
+end
+
+class ResolveTest < UMBaseTest
+  def test_resolve_ipv4
+    ip = machine.resolve('localhost')
+    assert_equal ['127.0.0.1'], ip
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.4
 platform: ruby
 authors:
 - Sharon Rosner
@@ -103,6 +103,7 @@ files:
 - examples/http_server.rb
 - examples/inout.rb
 - examples/io_uring_simple.c
+- examples/irb_fiber.rb
 - examples/nc.rb
 - examples/nc_ssl.rb
 - examples/pg.rb
@@ -505,7 +506,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: A lean, mean io_uring machine
 test_files: []