uringmachine 0.13 → 0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bce8525371c9f0aa2b279b815d04456573319b3eddaae14b79ddbf20ece1189f
-  data.tar.gz: dc1e70ca4101d607f2c04df639dabc917c379e3765a12c5440682a72cbb24316
+  metadata.gz: 1b3778bbf3b35b2f0855c5fdbe441df909a43866c56ceed16cacf502956566ba
+  data.tar.gz: 82b580cb610c11d5d05e69ab868ba70265fec92851cbdca7cf340bbde09c0b2c
 SHA512:
-  metadata.gz: 258605dfe54482f5330a7795e18efa3397692b0a306cf7fd1ad6a2408fe8c7e098abca78d66baaddd78faac74aae6beeda9fe6a3d2e39ab4e196b585810bc212
-  data.tar.gz: 6110908bf2c3d8a404f015429835dfb585ae711f14457b785d7e298f6caf2449341ca62ab3fa560054f51c9de6031195e8ead20afabace47cfe24cdf9fd6ae48
+  metadata.gz: 82fbdc455e76bd1adaf4668ae0d43c8c1e84f9c168c1d3e2f7a4924e672d5b77617ce720ac6fcb9257cc8e8edcf419f4267acdd7128d72a5d03c0b808f85ab4b
+  data.tar.gz: d56ba947a2d6ba974faa7e0594b506e0f7520815a995e263a7a9acf0658b73c057bd7d13f32e035376a4871dea6ff7824d04a621957707cb56a6f7e92581af1d

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2025-06-24 Version 0.15
+
+- Add support for sleeping forever when sleep duration is lte 0
+
+# 2025-06-09 Version 0.14
+
+- Add `#close_async`, `#shutdown_async`
+
 # 2025-06-07 Version 0.13
 
 - Add `#write_async`

data/ext/um/um.c

@@ -1,3 +1,4 @@
+#include <float.h>
 #include "um.h"
 #include "ruby/thread.h"
 
@@ -252,20 +253,14 @@ inline VALUE um_await(struct um *machine) {
   return raise_if_exception(v);
 }
 
-inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind) {
+inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags) {
   memset(op, 0, sizeof(struct um_op));
   op->kind = kind;
-  switch (kind) {
-    case OP_ACCEPT_MULTISHOT:
-    case OP_READ_MULTISHOT:
-    case OP_RECV_MULTISHOT:
-    case OP_TIMEOUT_MULTISHOT:
-    case OP_SLEEP_MULTISHOT:
-      op->flags |= OP_F_MULTISHOT;
-    default:
-  }
-  RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
-  op->value = Qnil;
+  op->flags = flags;
+
+  VALUE fiber = (flags & OP_F_FREE_ON_COMPLETE) ? Qnil : rb_fiber_current();
+  RB_OBJ_WRITE(machine->self, &op->fiber, fiber);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
 }
 
 inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
@@ -307,7 +302,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   if (!ID_new) ID_new = rb_intern("new");
 
   struct um_op *op = um_op_alloc(machine);
-  um_prep_op(machine, op, OP_TIMEOUT);
+  um_prep_op(machine, op, OP_TIMEOUT, 0);
   op->ts = um_double_to_timespec(NUM2DBL(interval));
   RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
   RB_OBJ_WRITE(machine->self, &op->value, rb_funcall(class, ID_new, 0));
@@ -323,9 +318,13 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
                          blocking singleshot ops
 *******************************************************************************/
 
+#define SLEEP_FOREVER_DURATION (86400*10000)
+
 VALUE um_sleep(struct um *machine, double duration) {
+  if (duration <= 0) duration = SLEEP_FOREVER_DURATION;
+
   struct um_op op;
-  um_prep_op(machine, &op, OP_SLEEP);
+  um_prep_op(machine, &op, OP_SLEEP, 0);
   op.ts = um_double_to_timespec(duration);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_timeout(sqe, &op.ts, 0, 0);
@@ -344,7 +343,7 @@ VALUE um_sleep(struct um *machine, double duration) {
 
 inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_READ);
+  um_prep_op(machine, &op, OP_READ, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   void *ptr = um_prepare_read_buffer(buffer, maxlen, buffer_offset);
   io_uring_prep_read(sqe, fd, ptr, maxlen, -1);
@@ -363,7 +362,7 @@ inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int b
 
 inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_READ);
+  um_prep_op(machine, &op, OP_READ, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_read(sqe, fd, buffer, maxlen, -1);
 
@@ -379,7 +378,7 @@ inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen)
 
 VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_WRITE);
+  um_prep_op(machine, &op, OP_WRITE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   const int str_len = RSTRING_LEN(str);
   if (len > str_len) len = str_len;
@@ -397,10 +396,7 @@ VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
 
 VALUE um_write_async(struct um *machine, int fd, VALUE str) {
   struct um_op *op = um_op_alloc(machine);
-  memset(op, 0, sizeof(struct um_op));
-  op->kind = OP_WRITE_ASYNC;
-  op->flags = OP_F_FREE_ON_COMPLETE;
-  op->fiber = Qnil;
+  um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_FREE_ON_COMPLETE);
   RB_OBJ_WRITE(machine->self, &op->value, str);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
@@ -410,7 +406,7 @@ VALUE um_write_async(struct um *machine, int fd, VALUE str) {
 
 VALUE um_close(struct um *machine, int fd) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_CLOSE);
+  um_prep_op(machine, &op, OP_CLOSE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_close(sqe, fd);
 
@@ -422,9 +418,19 @@ VALUE um_close(struct um *machine, int fd) {
   return raise_if_exception(ret);
 }
 
+VALUE um_close_async(struct um *machine, int fd) {
+  struct um_op *op = um_op_alloc(machine);
+  um_prep_op(machine, op, OP_CLOSE_ASYNC, OP_F_FREE_ON_COMPLETE);
+
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_close(sqe, fd);
+
+  return INT2NUM(fd);
+}
+
 VALUE um_accept(struct um *machine, int fd) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_ACCEPT);
+  um_prep_op(machine, &op, OP_ACCEPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_accept(sqe, fd, NULL, NULL, 0);
 
@@ -438,7 +444,7 @@ VALUE um_accept(struct um *machine, int fd) {
 
 VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_SOCKET);
+  um_prep_op(machine, &op, OP_SOCKET, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_socket(sqe, domain, type, protocol, flags);
 
@@ -452,7 +458,7 @@ VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint fla
 
 VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, socklen_t addrlen) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_CONNECT);
+  um_prep_op(machine, &op, OP_CONNECT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_connect(sqe, fd, addr, addrlen);
 
@@ -466,7 +472,7 @@ VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, sockle
 
 VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_SEND);
+  um_prep_op(machine, &op, OP_SEND, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_send(sqe, fd, RSTRING_PTR(buffer), len, flags);
 
@@ -481,7 +487,7 @@ VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags) {
 
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_RECV);
+  um_prep_op(machine, &op, OP_RECV, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   void *ptr = um_prepare_read_buffer(buffer, maxlen, 0);
   io_uring_prep_recv(sqe, fd, ptr, maxlen, flags);
@@ -499,7 +505,7 @@ VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
 
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_BIND);
+  um_prep_op(machine, &op, OP_BIND, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_bind(sqe, fd, addr, addrlen);
 
@@ -513,7 +519,7 @@ VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrl
 
 VALUE um_listen(struct um *machine, int fd, int backlog) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_BIND);
+  um_prep_op(machine, &op, OP_BIND, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_listen(sqe, fd, backlog);
 
@@ -531,7 +537,7 @@ VALUE um_getsockopt(struct um *machine, int fd, int level, int opt) {
 
 #ifdef HAVE_IO_URING_PREP_CMD_SOCK
   struct um_op op;
-  um_prep_op(machine, &op, OP_GETSOCKOPT);
+  um_prep_op(machine, &op, OP_GETSOCKOPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_cmd_sock(sqe, SOCKET_URING_OP_GETSOCKOPT, fd, level, opt, &value, sizeof(value));
 
@@ -555,7 +561,7 @@ VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
 
 #ifdef HAVE_IO_URING_PREP_CMD_SOCK
   struct um_op op;
-  um_prep_op(machine, &op, OP_SETSOCKOPT);
+  um_prep_op(machine, &op, OP_SETSOCKOPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_cmd_sock(sqe, SOCKET_URING_OP_SETSOCKOPT, fd, level, opt, &value, sizeof(value));
 
@@ -577,7 +583,7 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
   VALUE ret = Qnil;
 
   struct um_op op;
-  um_prep_op(machine, &op, OP_SHUTDOWN);
+  um_prep_op(machine, &op, OP_SHUTDOWN, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_shutdown(sqe, fd, how);
 
@@ -589,9 +595,19 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
   return raise_if_exception(ret);
 }
 
+VALUE um_shutdown_async(struct um *machine, int fd, int how) {
+  struct um_op *op = um_op_alloc(machine);
+  um_prep_op(machine, op, OP_SHUTDOWN_ASYNC, OP_F_FREE_ON_COMPLETE);
+
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_shutdown(sqe, fd, how);
+
+  return INT2NUM(fd);
+}
+
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_OPEN);
+  um_prep_op(machine, &op, OP_OPEN, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_open(sqe, StringValueCStr(pathname), flags, mode);
 
@@ -605,7 +621,7 @@ VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
 
 VALUE um_waitpid(struct um *machine, int pid, int options) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_WAITPID);
+  um_prep_op(machine, &op, OP_WAITPID, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
   siginfo_t infop;
@@ -646,7 +662,7 @@ VALUE statx_to_hash(struct statx *stat) {
 
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_STATX);
+  um_prep_op(machine, &op, OP_STATX, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
   struct statx stat;
@@ -721,7 +737,7 @@ VALUE multishot_complete(VALUE arg) {
 
 VALUE um_accept_each(struct um *machine, int fd) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_ACCEPT_MULTISHOT);
+  um_prep_op(machine, &op, OP_ACCEPT_MULTISHOT, OP_F_MULTISHOT);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .read_buf = NULL };
   return rb_ensure(accept_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
@@ -734,7 +750,7 @@ int um_read_each_singleshot_loop(struct op_ctx *ctx) {
   int total = 0;
 
   while (1) {
-    um_prep_op(ctx->machine, ctx->op, OP_READ);
+    um_prep_op(ctx->machine, ctx->op, OP_READ, 0);
     struct io_uring_sqe *sqe = um_get_sqe(ctx->machine, ctx->op);
     io_uring_prep_read(sqe, ctx->fd, ctx->read_buf, ctx->read_maxlen, -1);
 
@@ -824,7 +840,7 @@ VALUE read_recv_each_start(VALUE arg) {
 
 VALUE um_read_each(struct um *machine, int fd, int bgid) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_READ_MULTISHOT);
+  um_prep_op(machine, &op, OP_READ_MULTISHOT, OP_F_MULTISHOT);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .bgid = bgid, .read_buf = NULL };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
@@ -832,7 +848,7 @@ VALUE um_read_each(struct um *machine, int fd, int bgid) {
 
 VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_RECV_MULTISHOT);
+  um_prep_op(machine, &op, OP_RECV_MULTISHOT, OP_F_MULTISHOT);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .fd = fd, .bgid = bgid, .read_buf = NULL, .flags = flags };
   return rb_ensure(read_recv_each_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
@@ -871,10 +887,9 @@ VALUE periodically_start(VALUE arg) {
 
 VALUE um_periodically(struct um *machine, double interval) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_SLEEP_MULTISHOT);
+  um_prep_op(machine, &op, OP_SLEEP_MULTISHOT, OP_F_MULTISHOT);
   op.ts = um_double_to_timespec(interval);
 
   struct op_ctx ctx = { .machine = machine, .op = &op, .ts = op.ts, .read_buf = NULL };
   return rb_ensure(periodically_start, (VALUE)&ctx, multishot_complete, (VALUE)&ctx);
 }
-

data/ext/um/um.h

@@ -30,6 +30,7 @@ enum op_kind {
   OP_WRITE,
   OP_WRITE_ASYNC,
   OP_CLOSE,
+  OP_CLOSE_ASYNC,
   OP_STATX,
 
   OP_ACCEPT,
@@ -42,6 +43,7 @@ enum op_kind {
   OP_GETSOCKOPT,
   OP_SETSOCKOPT,
   OP_SHUTDOWN,
+  OP_SHUTDOWN_ASYNC,
   
   OP_WAITPID,
 
@@ -202,7 +204,7 @@ VALUE um_raise_exception(VALUE v);
 
 #define raise_if_exception(v) (um_value_is_exception_p(v) ? um_raise_exception(v) : v)
 
-void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind);
+void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags);
 void um_raise_on_error_result(int result);
 void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs);
 void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, __s32 result, __u32 flags);
@@ -229,6 +231,7 @@ size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
 VALUE um_write(struct um *machine, int fd, VALUE str, int len);
 VALUE um_close(struct um *machine, int fd);
+VALUE um_close_async(struct um *machine, int fd);
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode);
 VALUE um_waitpid(struct um *machine, int pid, int options);
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
@@ -246,6 +249,7 @@ VALUE um_listen(struct um *machine, int fd, int backlog);
 VALUE um_getsockopt(struct um *machine, int fd, int level, int opt);
 VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value);
 VALUE um_shutdown(struct um *machine, int fd, int how);
+VALUE um_shutdown_async(struct um *machine, int fd, int how);
 
 void um_async_op_set(VALUE self, struct um *machine, struct um_op *op);
 VALUE um_async_op_await(struct um_async_op *async_op);

data/ext/um/um_async_op.c

@@ -6,9 +6,8 @@ VALUE um_prep_timeout(struct um *machine, double interval) {
   if (!ID_new) ID_new = rb_intern("new");
 
   struct um_op *op = malloc(sizeof(struct um_op));
-  um_prep_op(machine, op, OP_TIMEOUT);
+  um_prep_op(machine, op, OP_TIMEOUT, OP_F_TRANSIENT | OP_F_ASYNC);
   op->ts = um_double_to_timespec(interval);
-  op->flags = OP_F_TRANSIENT | OP_F_ASYNC;
 
   VALUE obj = rb_funcall(cAsyncOp, rb_intern_const("new"), 0);
   um_async_op_set(obj, machine, op);

data/ext/um/um_class.c

@@ -44,7 +44,7 @@ inline struct um *um_get_machine(VALUE self) {
   struct um *um;
   TypedData_Get_Struct(self, struct um, &UringMachine_type, um);
   if (!um->ring_initialized) rb_raise(rb_eRuntimeError, "Machine not initialized");
-  
+
   return um;
 }
 
@@ -146,6 +146,11 @@ VALUE UM_close(VALUE self, VALUE fd) {
   return um_close(machine, NUM2INT(fd));
 }
 
+VALUE UM_close_async(VALUE self, VALUE fd) {
+  struct um *machine = um_get_machine(self);
+  return um_close_async(machine, NUM2INT(fd));
+}
+
 VALUE UM_accept(VALUE self, VALUE fd) {
   struct um *machine = um_get_machine(self);
   return um_accept(machine, NUM2INT(fd));
@@ -164,7 +169,11 @@ VALUE UM_socket(VALUE self, VALUE domain, VALUE type, VALUE protocol, VALUE flag
 VALUE UM_shutdown(VALUE self, VALUE fd, VALUE how) {
   struct um *machine = um_get_machine(self);
   return um_shutdown(machine, NUM2INT(fd), NUM2INT(how));
+}
 
+VALUE UM_shutdown_async(VALUE self, VALUE fd, VALUE how) {
+  struct um *machine = um_get_machine(self);
+  return um_shutdown_async(machine, NUM2INT(fd), NUM2INT(how));
 }
 
 VALUE UM_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
@@ -347,6 +356,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "yield", UM_yield, 0);
 
   rb_define_method(cUM, "close", UM_close, 1);
+  rb_define_method(cUM, "close_async", UM_close_async, 1);
   rb_define_method(cUM, "open", UM_open, 2);
   rb_define_method(cUM, "read", UM_read, -1);
   rb_define_method(cUM, "read_each", UM_read_each, 2);
@@ -370,6 +380,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);
   rb_define_method(cUM, "socket", UM_socket, 4);
   rb_define_method(cUM, "shutdown", UM_shutdown, 2);
+  rb_define_method(cUM, "shutdown_async", UM_shutdown_async, 2);
 
   rb_define_method(cUM, "prep_timeout", UM_prep_timeout, 1);
 

data/ext/um/um_sync.c

@@ -6,7 +6,7 @@
 
 void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_FUTEX_WAIT);
+  um_prep_op(machine, &op, OP_FUTEX_WAIT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   io_uring_prep_futex_wait(
     sqe, (uint32_t *)futex, expect, FUTEX_BITSET_MATCH_ANY,
@@ -27,7 +27,7 @@ void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
 
 void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_FUTEX_WAKE);
+  um_prep_op(machine, &op, OP_FUTEX_WAKE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   // submit futex_wait
   io_uring_prep_futex_wake(

data/lib/uringmachine/version.rb

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

data/lib/uringmachine.rb

@@ -35,14 +35,15 @@ class UringMachine
         f.add_done_listener(queue)
       end
     end
-    return results.values if !pending
-
-    while !pending.empty?
-      f = self.shift(queue)
-      pending.delete(f)
-      results[f] = f.result
+    if pending
+      while !pending.empty?
+        f = self.shift(queue)
+        pending.delete(f)
+        results[f] = f.result
+      end
     end
-    results.values
+    values = results.values
+    fibers.size == 1 ? values.first : values
   end
 
   def resolve(hostname, type = :A)

data/test/helper.rb

@@ -74,4 +74,20 @@ class UMBaseTest < Minitest::Test
       @@port += 1
     end
   end
+
+  def make_socket_pair
+    port = 10000 + rand(30000)
+    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    @machine.bind(server_fd, '127.0.0.1', port)
+    @machine.listen(server_fd, UM::SOMAXCONN)
+
+    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+    server_conn_fd = @machine.accept(server_fd)
+
+    @machine.close(server_fd)
+    [client_conn_fd, server_conn_fd]
+  end
 end

data/test/test_fiber.rb

@@ -88,7 +88,7 @@ class FiberJoinTest < UMBaseTest
     res = machine.join(f)
     assert_equal 0, x
     assert_equal 3, machine.shift(q)
-    assert_equal [42], res
+    assert_equal 42, res
   end
 
   def test_join_multiple
@@ -125,7 +125,7 @@ class FiberJoinTest < UMBaseTest
     f = machine.shift(q)
     assert_kind_of Fiber, f
     res = machine.join(f)
-    assert_equal [:foo], res
+    assert_equal :foo, res
   ensure
     t2.join
   end
@@ -135,8 +135,7 @@ class FiberJoinTest < UMBaseTest
       raise "Foobar"
     end
 
-    res = machine.join(f)
-    e = res.first
+    e = machine.join(f)
     assert_kind_of RuntimeError, e
     assert_equal 'Foobar', e.message
   end

data/test/test_um.rb

@@ -25,6 +25,12 @@ class SpinTest < UMBaseTest
 
     assert_equal :foo, x
   end
+
+  def test_spin_with_unhandled_exception
+    f = machine.spin { raise 'foo' }
+    result = machine.join(f)
+    assert_kind_of RuntimeError, result
+  end
 end
 
 class SnoozeTest < UMBaseTest
@@ -228,6 +234,20 @@ class SleepTest < UMBaseTest
     assert_in_range 0.02..0.04, t1 - t0
     assert_kind_of D, ret
   end
+
+  def test_sleep_forever
+    t0 = monotonic_clock
+    ret = begin
+      machine.timeout(0.03, D) do
+        machine.sleep 0
+      end
+    rescue => e
+      e
+    end
+    t1 = monotonic_clock
+    assert_in_range 0.02..0.04, t1 - t0
+    assert_kind_of D, ret
+  end
 end
 
 class PeriodicallyTest < UMBaseTest
@@ -271,7 +291,7 @@ class PeriodicallyTest < UMBaseTest
     rescue Cancel
       cancel = 1
     end
-    2.times { machine.snooze }
+    5.times { machine.snooze }
     assert_equal 0, machine.pending_count
     t1 = monotonic_clock
     assert_in_range 0.05..0.08, t1 - t0
@@ -569,25 +589,31 @@ class CloseTest < UMBaseTest
 
     assert_raises(Errno::EBADF) { machine.close(w.fileno) }
   end
-end
 
-class ShutdownTest < UMBaseTest
-  def make_socket_pair
-    port = 10000 + rand(30000)
-    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
-    @machine.bind(server_fd, '127.0.0.1', port)
-    @machine.listen(server_fd, UM::SOMAXCONN)
+  def test_close_bad_fd
+    r, w = IO.pipe
+    machine.close(w.fileno)
 
-    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-    @machine.connect(client_conn_fd, '127.0.0.1', port)
+    assert_raises(Errno::EBADF) { machine.close(w.fileno) }
+  end
+end
 
-    server_conn_fd = @machine.accept(server_fd)
+class CloseAsyncTest < UMBaseTest
+  def test_close_async
+    r, w = IO.pipe
+    machine.write(w.fileno, 'foo')
+    assert_equal 'foo', r.readpartial(3)
 
-    @machine.close(server_fd)
-    [client_conn_fd, server_conn_fd]
+    assert_equal 0, machine.pending_count
+    machine.close_async(w.fileno)
+    assert_equal 1, machine.pending_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal '', r.read
   end
+end
 
+class ShutdownTest < UMBaseTest
   def test_shutdown
     c_fd, s_fd = make_socket_pair
     res = @machine.send(c_fd, 'abc', 3, 0)
@@ -619,6 +645,37 @@ class ShutdownTest < UMBaseTest
   end
 end
 
+class ShutdownAsyncTest < UMBaseTest
+  def test_shutdown_async
+    c_fd, s_fd = make_socket_pair
+    res = @machine.send(c_fd, 'abc', 3, 0)
+    assert_equal 3, res
+
+    buf = +''
+    res = @machine.recv(s_fd, buf, 256, 0)
+    assert_equal 3, res
+    assert_equal 'abc', buf
+
+    res = @machine.shutdown_async(c_fd, UM::SHUT_WR)
+    assert_equal c_fd, res
+
+    machine.sleep(0.01)
+    assert_raises(Errno::EPIPE) { @machine.send(c_fd, 'abc', 3, 0) }
+
+    res = @machine.shutdown_async(s_fd, UM::SHUT_RD)
+    assert_equal s_fd, res
+
+    res = @machine.recv(s_fd, buf, 256, 0)
+    assert_equal 0, res
+
+    res = @machine.shutdown_async(c_fd, UM::SHUT_RDWR)
+    assert_equal c_fd, res
+  ensure
+    @machine.close(c_fd)
+    @machine.close(s_fd)
+  end
+end
+
 class AcceptTest < UMBaseTest
   def setup
     super
@@ -1273,7 +1330,7 @@ class WaitTest < UMBaseTest
     ret = machine.read(rfd, buf, 8192)
     assert_equal msg.bytesize, ret
     assert_equal msg, buf
-    
+
   ensure
     Process.wait(pid) rescue Errno::ECHILD
   end
@@ -1361,4 +1418,4 @@ class ForkTest < UMBaseTest
     Process.wait(child_pid) rescue Errno::ECHILD
   end
 
-end
+end

metadata

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