uringmachine 1.0.2 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6230878feb2403c55f9e13ab254813d68b761691b4fdebd57f283a9ecfed7740
-  data.tar.gz: a507437c50dc56d5f04e9fcfc545d0d9a5ddd09357ce9bfef758bac36fd695f6
+  metadata.gz: 8c4ce5de22052f74a5386dafe18ff4f021db995b6a6b120516a98e0f81783222
+  data.tar.gz: 64b51a3e8c2e1d5392c6cd8c4c995c09b506de554a537bad14a3074702fb0926
 SHA512:
-  metadata.gz: bfa96e81a0165b32ec90cfe4a958b1412dfdb7bcee27b5afdff62d8b7b95e972aee7ce012d7a19bcbe425d5a0ef33e7abe89279862ba5e260629e50c8f0d64d7
-  data.tar.gz: 399e5b9c3338325db9ac508b4a4ca4a108798c6417887eb1353120582c646d2722a616a6bcc232167b7c8bee1383aca4776610bea96f47d538a824075999408e
+  metadata.gz: 458534cc0ceec394b4dcf32829f62708ac1c68a8e7adf71f4bb48fe00195594805fe22ecc990edc38790b44e9609eeee00ca0c537bc316136e00bb3e87b69577
+  data.tar.gz: d955545beb0ba009b85ae3fa11619bf3a8869ad97474dd041e57d2c903555418e40e22eae2707a4e936563196162cec197ba55f516fb475cdb6f71da62fb9e87

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 1.0.5 2026-10-01
+
+- Add support for regular files in UM::IO with :file mode
+
+# 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

data/TODO.md

@@ -1,14 +1,84 @@
-## immediate
+## Character scanning in UM::IO
+
+- Refactor character scanning
+  - functions/macros for iterating over segments
+
+  - SIMD?
+    - prep work for SIMD character scanning
+    - we'll probably need a bit of helper code for dealing with SIMD
+    - a good overview here: https://mitchellh.com/writing/everyone-should-know-simd
+    - SIMD prep work should be done once before iterating over segments
+
+```c
+// bitmaps for character types can be generated with a bit of Ruby:
+//
+// def t(r); (0..255).map { [it].pack('c') =~ r ? 1 : 0 }; end
+// def tn(r); (0..255).map { [it].pack('c') =~ r ? 0 : 1 }; end
+// def u64(bits); bits.reverse.join.to_i(2); end
+// def p(a); a.each_slice(64).map { u64(it) }; end
 
-- Add `IO#http_xxx` methods
-  - `#http_read_request_headers()`
-  - `#http_read_body(content_length)` (-1 means chunked TE)
+// usage:
+//
+//   p(t(/[a-zA-Z0-9]/)).map { format('%016X', it) }
+
+
+// /[a-zA-Z0-9]/
+uint64_t alpha_numeric[] = [
+  0x000000000000FFC0,
+  0x7FFFFFE07FFFFFE0,
+  0x0000000000000000,
+  0x0000000000000000
+];
+
+// HTTP method: /[a-zA-Z]/    (3-12 characters)
+// header-key:  /[a-zA-Z\-]/  ()
+// path:        /^($/
+
+// check if character is in bitmap
+inline int test_char(char c, uint64 *bitmap) {
+  return bitmap[c / 64] & (1UL << (c % 64));
+}
+```
+
+## IO methods
+
+- 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
+  ```
+
+- Add `IO#http1_xxx` methods
+  - `#http1_read_request_headers()`
+  - `#http1_read_body(content_length)` (-1 means chunked TE)
 
 - Add tests for support for Set in `machine#await`
 - Add tests for support for Set, Array in `machine#join`
-- Add `UM#read_file` for reading entire file
+  - Add `UM#read_file` for reading entire file
 - Add `UM#write_file` for writing entire file
 
+## 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`
+
 ## Balancing I/O with the runqueue
 
 - in some cases where there are many entries in the runqueue, this can
@@ -71,6 +141,7 @@
 - select on fibers:
   - select fibers that are done
   - select first done fiber
+- we might want to rename `#select` to `#fdselect`
 
 ## ops still not implemented
 
@@ -84,21 +155,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
@@ -108,36 +164,3 @@ machine.shift_select(*queues) #=> [result, queue]
   #        ['1.1.1.1:80', '2.2.2.2:80']
   tcp_connect_he(*addrs)
   ```
-
-## Character scanning in UM::IO
-
-```c
-// bitmaps for character types can be generated with a bit of Ruby:
-//
-// def t(r); (0..255).map { [it].pack('c') =~ r ? 1 : 0 }; end
-// def tn(r); (0..255).map { [it].pack('c') =~ r ? 0 : 1 }; end
-// def u64(bits); bits.reverse.join.to_i(2); end
-// def p(a); a.each_slice(64).map { u64(it) }; end
-
-// usage:
-//
-//   p(t(/[a-zA-Z0-9]/)).map { format('%016X', it) }
-
-
-// /[a-zA-Z0-9]/
-uint64_t alpha_numeric[] = [
-  0x000000000000FFC0,
-  0x7FFFFFE07FFFFFE0,
-  0x0000000000000000,
-  0x0000000000000000
-];
-
-// HTTP method: /[a-zA-Z]/    (3-12 characters)
-// header-key:  /[a-zA-Z\-]/  ()
-// path:        /^($/
-
-// check if character is in bitmap
-inline int test_char(char c, uint64 *bitmap) {
-  return bitmap[c / 64] & (1UL << (c % 64));
-}
-```

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

@@ -83,6 +83,7 @@ enum um_io_mode {
   IO_FD,
   IO_SOCKET,
   IO_SSL,
+  IO_FILE,
   IO_STRING,
   IO_IO_BUFFER
 };
@@ -426,6 +427,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,7 +133,31 @@ void io_clear(struct um_io *io) {
   }
 }
 
-inline void io_await_segments(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;
+}
+
+static inline void io_await_segments(struct um_io *io) {
   if (unlikely(!io->op)) io_multishot_op_start(io);
 
   if (!OP_CQE_SEEN_P(io->op)) {
@@ -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;
   }
 }
 
@@ -212,11 +208,54 @@ int io_get_more_segments_ssl(struct um_io *io) {
   return 1;
 }
 
+int io_get_more_segments_file(struct um_io *io) {
+  if (!io->working_buffer)
+    io->working_buffer = bp_buffer_checkout(io->machine);
+
+  char *ptr = io->working_buffer->buf + io->working_buffer->pos;
+  size_t maxlen = io->working_buffer->len - io->working_buffer->pos;
+
+  struct um_op *op = um_op_acquire(io->machine);
+  um_prep_op(io->machine, op, OP_READ, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(io->machine, op);
+  io_uring_prep_read(sqe, io->fd, ptr, maxlen, -1);
+
+  VALUE ret = um_yield(io->machine);
+  int has_more = 0;
+
+  if (likely(um_verify_op_completion(io->machine, op, true))) {
+    int res = op->result.res;
+
+    if (res == 0) {
+      bp_buffer_checkin(io->machine, io->working_buffer);
+      io->working_buffer = NULL;
+      goto done;
+    }
+
+    struct um_segment *segment = bp_buffer_consume(io->machine, io->working_buffer, res);
+    io_add_segment(io, segment);
+
+    if ((size_t)res == maxlen) {
+      bp_buffer_checkin(io->machine, io->working_buffer);
+      io->working_buffer = NULL;
+    }
+    else has_more = 1;
+  }
+  um_op_release(io->machine, op);
+
+done:
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return has_more;
+}
+
 int io_get_more_segments(struct um_io *io) {
   switch (io->mode) {
     case IO_FD:
     case IO_SOCKET:
       return io_get_more_segments_bp(io);
+    case IO_FILE:
+      return io_get_more_segments_file(io);
     case IO_SSL:
       return io_get_more_segments_ssl(io);
     default:
@@ -254,9 +293,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 +322,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 +405,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);
 }
@@ -392,14 +481,15 @@ VALUE io_read(struct um_io *io, VALUE out_buffer, ssize_t len, size_t inc, int s
 
   while (true) {
     size_t segment_len = current->len - pos;
-    if (abs_len && segment_len > remaining_len) {
+    if (abs_len && segment_len > (size_t)remaining_len) {
       segment_len = remaining_len;
     }
     total_len += segment_len;
     if (abs_len) {
       remaining_len -= segment_len;
-      if (!remaining_len)
+      if (!remaining_len) {
         return io_consume_string(io, out_buffer, total_len, inc, safe_inc);
+      }
     }
 
     if (!current->next) {

data/ext/um/um_io_class.c

@@ -4,6 +4,7 @@ VALUE cIO;
 VALUE eIORESPError;
 
 VALUE SYM_fd;
+VALUE SYM_file;
 VALUE SYM_socket;
 VALUE SYM_ssl;
 
@@ -87,6 +88,7 @@ static inline void io_set_target(struct um_io *conn, VALUE target, enum um_io_mo
   conn->mode = mode;
   switch (mode) {
     case IO_FD:
+    case IO_FILE:
     case IO_SOCKET:
       conn->fd = NUM2INT(target);
       return;
@@ -109,6 +111,8 @@ static inline void io_setup(struct um_io *conn, VALUE target, VALUE mode) {
   }
   else if (mode == SYM_fd)
     io_set_target(conn, target, IO_FD);
+  else if (mode == SYM_file)
+    io_set_target(conn, target, IO_FILE);
   else if (mode == SYM_socket)
     io_set_target(conn, target, IO_SOCKET);
   else if (mode == SYM_ssl)
@@ -157,10 +161,11 @@ VALUE IO_initialize(int argc, VALUE *argv, VALUE self) {
 VALUE IO_mode(VALUE self) {
   struct um_io *conn = um_get_io(self);
   switch (conn->mode) {
-    case IO_FD:  return SYM_fd;
-    case IO_SOCKET:  return SYM_socket;
-    case IO_SSL:      return SYM_ssl;
-    default:              return Qnil;
+    case IO_FD:     return SYM_fd;
+    case IO_FILE:   return SYM_file;
+    case IO_SOCKET: return SYM_socket;
+    case IO_SSL:    return SYM_ssl;
+    default:        return Qnil;
   }
   return Qnil;
 }
@@ -242,6 +247,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 +416,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);
@@ -388,7 +432,8 @@ void Init_IO(void) {
 
   eIORESPError = rb_define_class_under(cIO, "RESPError", rb_eStandardError);
 
-  SYM_fd = ID2SYM(rb_intern("fd"));
-  SYM_socket = ID2SYM(rb_intern("socket"));
+  SYM_fd      = ID2SYM(rb_intern("fd"));
+  SYM_file    = ID2SYM(rb_intern("file"));
+  SYM_socket  = ID2SYM(rb_intern("socket"));
   SYM_ssl     = ID2SYM(rb_intern("ssl"));
 }

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/version.rb

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

data/test/test_io.rb

@@ -4,6 +4,7 @@ require_relative 'helper'
 require 'securerandom'
 require 'openssl'
 require 'localhost/authority'
+require 'tempfile'
 
 class IOBaseTest < UMBaseTest
   attr_reader :conn
@@ -305,6 +306,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
@@ -699,6 +716,23 @@ class IOModeTest < UMBaseTest
     sock2&.close rescue nil
   end
 
+  def test_io_file_mode
+    fn = Tempfile.new('uringmachine_test_io_from_file').path
+    IO.write(fn, (0..9).to_a.join)
+    fd = machine.open(fn, UM::O_RDONLY)
+    io = machine.io(fd, :file)
+    buf = io.read(3)
+    assert_equal '012', buf
+
+    buf = io.read(5)
+    assert_equal '34567', buf
+
+    buf = io.read(-4)
+    assert_equal '89', buf
+  ensure
+    machine.close(fd) if fd
+  end
+
   def test_io_socket_mode_non_socket
     r, w = UM.pipe
     machine.write(w, 'foobar')
@@ -806,3 +840,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.5
 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