uringmachine 0.6.1 → 0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 602ceb6207baea6b38287928500c73df48258ca2f8cf843f02b45fa65c591e3e
-  data.tar.gz: 78b2bc7a274b03e2ae51510e213be0d23911c4db102ad4ab7eee435f915bb5c0
+  metadata.gz: c901aae24c3fad58a2453333885d10c577448c910c069753188cf8a89b6a1f2e
+  data.tar.gz: '0804b7103ccf9ae6c244ef5a9677987af2944e508b63d98aeee5f19dee0f1f2e'
 SHA512:
-  metadata.gz: c0dcbb93493c9778cf4ac12769f88611364d4e190c9e9dfa666543643e3aa3b44fa01cc49cf1ea2a1ba4798c4893b75e8b47e5b1eeac23b48bc5a6d84046e458
-  data.tar.gz: 5b012fcc3e7fd1a6d4e68aae58b9d099f19d5a89670772cdfdd6ef4ac76ed9781f533fd576e2b19b02c7774ba31d3ce6ee06dc590e04ce07a62e3c7fb2394191
+  metadata.gz: 3a6934132fad56b013a8754c375b33acd2cefc28577879b7e05bbf0ded8e9b9cd8e50070ec398d67c00c07ebb15468347e96d27d6ba2ccdbfbc19b5a206aff6c
+  data.tar.gz: 9c54ade5eada0ce6238f6138f8be9c5857436668851154ead8a55b8d221d2f4f3d2318616d1fdc733e99562748c17b26eca7e171cf43ddeb34a80320df2e2b43

data/.github/workflows/test.yml

@@ -13,7 +13,7 @@ jobs:
       matrix:
         # macos-latest uses arm64, macos-13 uses x86
         os: [ubuntu-latest]
-        ruby: ['3.3', '3.4', 'head']
+        ruby: ['3.4', 'head']
 
     name: ${{matrix.os}}, ${{matrix.ruby}}
 

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 2025-05-03 Version 0.8
+
+- Add `#join`
+
+# 2025-04-28 Version 0.7
+
+- Add `#shutdown`
+
 # 2025-04-23 Version 0.6.1
 
 - Improve `#snooze` to prevent op completion starvation

data/TODO.md

@@ -1,3 +1,5 @@
+# ops
+
 - [ ] multishot timeout
   - [v] machine.periodically(interval) { ... }
   - [ ] machine.prep_timeout_multishot(interval)
@@ -14,5 +16,10 @@
 - fadvise
 - madvise
 - getxattr / setxattr
-- shutdown
 - send_bundle / recv_bundle (kernel >= 6.10)
+
+# actors
+
+When doing a `call`, we need to provide a mailbox for the response. can this be
+automatic?
+

data/ext/um/extconf.rb

@@ -6,61 +6,6 @@ require 'rbconfig'
 
 dir_config 'um_ext'
 
-def config_ssl
-  # don't use pkg_config('openssl') if '--with-openssl-dir' is used
-  has_openssl_dir = dir_config('openssl').any? ||
-    RbConfig::CONFIG['configure_args']&.include?('openssl')
-
-  found_pkg_config = !has_openssl_dir && pkg_config('openssl')
-
-  found_ssl = if !$mingw && found_pkg_config
-    puts '──── Using OpenSSL pkgconfig (openssl.pc) ────'
-    true
-  elsif have_library('libcrypto', 'BIO_read') && have_library('libssl', 'SSL_CTX_new')
-    true
-  elsif %w'crypto libeay32'.find {|crypto| have_library(crypto, 'BIO_read')} &&
-      %w'ssl ssleay32'.find {|ssl| have_library(ssl, 'SSL_CTX_new')}
-    true
-  else
-    puts '** Puma will be compiled without SSL support'
-    false
-  end
-
-  if found_ssl
-    have_header "openssl/bio.h"
-
-    ssl_h = "openssl/ssl.h".freeze
-
-    puts "\n──── Below are yes for 1.0.2 & later ────"
-    have_func "DTLS_method"                            , ssl_h
-    have_func "SSL_CTX_set_session_cache_mode(NULL, 0)", ssl_h
-
-    puts "\n──── Below are yes for 1.1.0 & later ────"
-    have_func "TLS_server_method"                      , ssl_h
-    have_func "SSL_CTX_set_min_proto_version(NULL, 0)" , ssl_h
-
-    puts "\n──── Below is yes for 1.1.0 and later, but isn't documented until 3.0.0 ────"
-    # https://github.com/openssl/openssl/blob/OpenSSL_1_1_0/include/openssl/ssl.h#L1159
-    have_func "SSL_CTX_set_dh_auto(NULL, 0)"           , ssl_h
-
-    puts "\n──── Below is yes for 1.1.1 & later ────"
-    have_func "SSL_CTX_set_ciphersuites(NULL, \"\")"   , ssl_h
-
-    puts "\n──── Below is yes for 3.0.0 & later ────"
-    have_func "SSL_get1_peer_certificate"              , ssl_h
-
-    puts ''
-
-    # Random.bytes available in Ruby 2.5 and later, Random::DEFAULT deprecated in 3.0
-    if Random.respond_to?(:bytes)
-      $defs.push "-DHAVE_RANDOM_BYTES"
-      puts "checking for Random.bytes... yes"
-    else
-      puts "checking for Random.bytes... no"
-    end
-  end
-end
-
 KERNEL_INFO_RE = /Linux (\d)\.(\d+)(?:\.)?((?:\d+\.?)*)(?:\-)?([\w\-]+)?/
 def get_config
   if RUBY_PLATFORM !~ /linux/
@@ -90,8 +35,6 @@ def get_config
   }
 end
 
-# config_ssl
-
 config = get_config
 puts "Building UringMachine (\n#{config.map { |(k, v)| "  #{k}: #{v}\n"}.join})"
 

data/ext/um/um.c

@@ -549,6 +549,22 @@ VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
   return raise_if_exception(ret);
 }
 
+VALUE um_shutdown(struct um *machine, int fd, int how) {
+  VALUE ret = Qnil;
+
+  struct um_op op;
+  um_prep_op(machine, &op, OP_SHUTDOWN);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+  io_uring_prep_shutdown(sqe, fd, how);
+
+  ret = um_fiber_switch(machine);
+  if (um_check_completion(machine, &op))
+    ret = INT2NUM(op.result.res);
+
+  RB_GC_GUARD(ret);
+  return raise_if_exception(ret);
+}
+
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
   struct um_op op;
   um_prep_op(machine, &op, OP_BIND);

data/ext/um/um.h

@@ -37,6 +37,7 @@ enum op_kind {
   OP_LISTEN,
   OP_GETSOCKOPT,
   OP_SETSOCKOPT,
+  OP_SHUTDOWN,
 
   OP_FUTEX_WAIT,
   OP_FUTEX_WAKE,
@@ -220,6 +221,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);
 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);
 
 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);
@@ -244,6 +246,4 @@ VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
 
 void um_define_net_constants(VALUE mod);
 
-// void Init_micro_ssl(VALUE mod);
-
 #endif // UM_H

data/ext/um/um_class.c

@@ -150,6 +150,12 @@ VALUE UM_socket(VALUE self, VALUE domain, VALUE type, VALUE protocol, VALUE flag
   return um_socket(machine, NUM2INT(domain), NUM2INT(type), NUM2INT(protocol), NUM2UINT(flags));
 }
 
+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_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
   struct um *machine = um_get_machine(self);
 
@@ -350,6 +356,7 @@ void Init_UM(void) {
   rb_define_method(cUM, "send", UM_send, 4);
   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, "prep_timeout", UM_prep_timeout, 1);
 
@@ -361,7 +368,5 @@ void Init_UM(void) {
   rb_define_method(cUM, "unshift", UM_queue_unshift, 2);
   #endif
 
-  // Init_micro_ssl(cUM);
-
   um_define_net_constants(cUM);
 }

data/lib/uringmachine/actor.rb

@@ -10,6 +10,19 @@ class UringMachine
     actor
   end
 
+  def spin_thread_actor(mod, *a, **k)
+    machine = UM.new
+    target = Object.new.extend(mod)
+    mailbox = UM::Queue.new
+    actor = Actor.new
+    thread = Thread.new do
+      actor.run(machine, target, mailbox)
+    end
+    target.setup(*a, **k)
+    snooze
+    actor
+  end
+
   class Actor < Fiber
     def run(machine, target, mailbox)
       @machine = machine
@@ -23,30 +36,26 @@ class UringMachine
     end
 
     def cast(sym, *a, **k)
-      self << [:cast, nil, sym, a, k]
+      @machine.push @mailbox, [:cast, nil, sym, a, k]
       self
     end
 
-    def call(sym, *a, **k)
-      self << [:call, Fiber.current, sym, a, k]
-      @machine.yield
+    def call(response_mailbox, sym, *a, **k)
+      @machine.push @mailbox, [:call, response_mailbox, sym, a, k]
+      @machine.shift response_mailbox
     end
 
     private
 
     def process_message(msg)
-      type, fiber, sym, args, kwargs = msg
+      type, response_mailbox, sym, args, kwargs = msg
       case type
       when :cast
         @target.send(sym, *args, **kwargs)
       when :call
         res = @target.send(sym, *args, **kwargs)
-        @machine.schedule(fiber, res)
+        @machine.push(response_mailbox, res)
       end
     end
-
-    def <<(msg)
-      @machine.push(@mailbox, msg)
-    end
   end
 end

data/lib/uringmachine/version.rb

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

data/lib/uringmachine.rb

@@ -12,30 +12,85 @@ class UringMachine
     @@fiber_map
   end
 
+  class Terminate < Exception
+  end
+
   def spin(value = nil, fiber_class = Fiber, &block)
     f = fiber_class.new do |resume_value|
-      block.(resume_value)
+      f.set_result block.(resume_value)
     rescue Exception => e
-      STDERR.puts "Unhandled fiber exception: #{e.inspect}"
-      STDERR.puts e.backtrace.join("\n")
-      exit
+      f.set_result e
     ensure
+      f.mark_as_done
+      # cleanup
       @@fiber_map.delete(f)
-      # yield control
+      self.notify_done_listeners(f)
+      # transfer control to other fibers
       self.yield
-      p :bad_bad_bad
     end
-    schedule(f, value)
+    self.schedule(f, value)
     @@fiber_map[f] = true
     f
   end
 
+  def join(*fibers)
+    results = fibers.inject({}) { |h, f| h[f] = nil; h }
+    queue = nil
+    pending = nil
+    fibers.each do |f|
+      if f.done?
+        results[f] = f.result
+      else
+        (pending ||= []) << f
+        queue ||= UM::Queue.new
+        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
+    end
+    results.values
+  end
+
   def resolve(hostname, type = :A)
     @resolver ||= DNSResolver.new(self)
     @resolver.resolve(hostname, type)
   end
 
-  def ssl_accept(fd, ssl_ctx)
-    SSL::Connection.new(self, fd, ssl_ctx)
+  private
+
+  def notify_done_listeners(fiber)
+    listeners = fiber.done_listeners
+    return if !listeners
+
+    listeners.each { self.push(it, fiber) }
+  end
+
+  module FiberExtensions
+    attr_reader :result, :done, :done_listeners
+
+    def mark_as_done
+      @done = true
+    end
+
+    def set_result(value)
+      @result = value
+    end
+
+    def done?
+      @done
+    end
+
+    def add_done_listener(queue)
+      (@done_listeners ||= []) << queue
+    end
+  end
+
+  class ::Fiber
+    include UringMachine::FiberExtensions
   end
 end

data/test/test_actor.rb

@@ -7,7 +7,7 @@ require 'uringmachine/actor'
 class ActorTest < UMBaseTest
   module Counter
     def setup
-      @count = 0      
+      @count = 0
     end
 
     def incr
@@ -24,16 +24,17 @@ class ActorTest < UMBaseTest
   end
 
   def test_basic_actor_functionality
+    mailbox = UM::Queue.new
     actor = @machine.spin_actor(Counter)
     
     assert_kind_of Fiber, actor
 
-    assert_equal 0, actor.call(:get)
-    assert_equal 1, actor.call(:incr)
+    assert_equal 0, actor.call(mailbox, :get)
+    assert_equal 1, actor.call(mailbox, :incr)
     assert_equal actor, actor.cast(:incr)
-    assert_equal 2, actor.call(:get)
+    assert_equal 2, actor.call(mailbox, :get)
     assert_equal actor, actor.cast(:reset)
-    assert_equal 0, actor.call(:get)
+    assert_equal 0, actor.call(mailbox, :get)
   end
 
   module Counter2
@@ -57,7 +58,8 @@ class ActorTest < UMBaseTest
 
   def test_actor_with_args
     actor = @machine.spin_actor(Counter2, 43)
+    mailbox = UM::Queue.new
     
-    assert_equal 43, actor.call(:get)
+    assert_equal 43, actor.call(mailbox, :get)
   end
 end

data/test/test_fiber.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'socket'
+
+class FiberSpinTest < UMBaseTest
+  def test_spin
+    x = nil
+    f = machine.spin do
+      x = :foo
+    end
+
+    assert_kind_of Fiber, f
+    assert_nil x
+
+    machine.snooze
+
+    assert_equal :foo, x
+  end
+
+  def test_spin_with_initial_value
+    x = nil
+    f = machine.spin(42) do |v|
+      x = v
+    end
+
+    assert_kind_of Fiber, f
+    assert_nil x
+
+    machine.snooze
+    assert_equal 42, x
+  end
+
+  class MyFiber < Fiber
+  end
+
+  def test_spin_with_custom_class
+    f = machine.spin(nil, MyFiber) do
+    end
+
+    assert_kind_of MyFiber, f
+  end
+end
+
+class FiberTerminateTest < UMBaseTest
+  def test_terminate_fiber
+    x = nil
+    f = machine.spin do
+      x = 1
+      machine.sleep 0.01
+    ensure
+      x = 0
+    end
+
+    assert_nil x
+    machine.snooze
+    assert_equal 1, x
+    
+    machine.schedule(f, UM::Terminate.new)
+    2.times { machine.snooze }
+
+    assert_equal 0, x
+  end
+end
+
+class JoinTest < UMBaseTest
+  def test_join
+    q = UM::Queue.new
+    x = nil
+
+    f = machine.spin do
+      x = 1
+      machine.push q, machine.shift(q) + 1
+      42
+    ensure
+      x = 0
+    end
+
+    assert_nil x
+    machine.snooze
+    assert_equal 1, x
+
+    machine.spin do
+      x = 2
+      machine.push q, 2
+    end
+
+    res = machine.join(f)
+    assert_equal 0, x
+    assert_equal 3, machine.shift(q)
+    assert_equal [42], res
+  end
+
+  def test_join_multiple
+    f1 = machine.spin do
+      :foo
+    end
+
+    f2 = machine.spin do
+      machine.sleep(0.001)
+      :bar
+    end
+
+    f3 = machine.spin do
+      :baz
+    end
+
+    res = machine.join(f1, f2, f3)
+    assert_equal [:foo, :bar, :baz], res
+  end
+
+  def test_join_cross_thread
+    q = UM::Queue.new
+
+    t2 = Thread.new do
+      m2 = UM.new
+      f = m2.spin do
+        m2.push(q, f)
+        m2.snooze
+        :foo
+      end
+      m2.join(f)
+    end
+
+    f = machine.shift(q)
+    assert_kind_of Fiber, f
+    res = machine.join(f)
+    assert_equal [:foo], res
+  ensure
+    t2.join
+  end
+
+  def test_join_with_exception
+    f = machine.spin do
+      raise "Foobar"
+    end
+
+    res = machine.join(f)
+    e = res.first
+    assert_kind_of RuntimeError, e
+    assert_equal 'Foobar', e.message
+  end
+end
+
+class ScopeTest < UMBaseTest
+  def test_scope
+    skip
+
+    x1 = nil
+    x2 = nil
+
+    machine.scope do
+      f1 = machine.spin do
+        x1 = 1
+        machine.sleep 0.01
+      ensure
+        x1 = 0
+      end
+
+      f2 = machine.spin do
+        x2 = 1
+        machine.sleep 0.01
+      ensure
+        x2 = 0
+      end
+    end
+
+    assert_equal 0, x1
+    assert_equal 0, x2
+  end
+end

data/test/test_um.rb

@@ -514,7 +514,7 @@ class WriteTest < UMBaseTest
   end
 end
 
-class Closetest < UMBaseTest
+class CloseTest < UMBaseTest
   def test_close
     r, w = IO.pipe
     machine.write(w.fileno, 'foo')
@@ -529,6 +529,54 @@ class Closetest < UMBaseTest
   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)
+
+    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
+
+  def test_shutdown
+    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(c_fd, UM::SHUT_WR)
+    assert_equal 0, res
+
+    assert_raises(Errno::EPIPE) { @machine.send(c_fd, 'abc', 3, 0) }
+
+    res = @machine.shutdown(s_fd, UM::SHUT_RD)
+    assert_equal 0, res
+
+    res = @machine.recv(s_fd, buf, 256, 0)
+    assert_equal 0, res
+
+    res = @machine.shutdown(c_fd, UM::SHUT_RDWR)
+    assert_equal 0, res
+
+    assert_raises(Errno::EINVAL) { @machine.shutdown(c_fd, -9999) }
+  ensure
+    @machine.close(c_fd)
+    @machine.close(s_fd)
+  end
+end
+
 class AcceptTest < UMBaseTest
   def setup
     super
@@ -1028,6 +1076,30 @@ class QueueTest < UMBaseTest
     assert_equal :bar, machine.shift(q)
     assert_equal :foo, machine.shift(q)
   end
+
+  def test_cross_thread_push_shift
+    q = UM::Queue.new
+
+    t1 = Thread.new {
+      m = UM.new
+      3.times { m.push(q, it); m.sleep(0.01) }
+    }
+
+    items = []
+
+    t2 = Thread.new {
+      m = UM.new
+      3.times {
+        i = m.pop(q)
+        items << i
+        m.sleep(0.01)
+      }
+    }
+
+    [t1, t2].each(&:join)
+
+    assert_equal [0, 1, 2], items
+  end
 end
 
 class OpenTest < UMBaseTest

data/uringmachine.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.md"]
   s.extensions = ["ext/um/extconf.rb"]
   s.require_paths = ["lib"]
-  s.required_ruby_version = '>= 3.3'
+  s.required_ruby_version = '>= 3.4'
 
   s.add_development_dependency  'rake-compiler',        '1.2.9'
   s.add_development_dependency  'minitest',             '5.25.4'