polyphony 0.97 → 0.98

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a8218fc4160e0772ee3aada1f72ea9d063724ccf9b0aee7dfa6e9e4d69ebfe4
-  data.tar.gz: 74aae84e991cd4330ad282553061b29e71a6434ce2dafc9985c62feb3a966a68
+  metadata.gz: bf93e3d5dfd0a5e3a4a70ee66d62caddc1ea22e63cf1ce44a212a75f18c2ac76
+  data.tar.gz: 121f84bb920ccc6822cb43b772a68dd92b2f2d81ebf9e1a510c081481dd1e3b1
 SHA512:
-  metadata.gz: 772d0be4ef2f723fa27cc5ecb8ef9e9b5d012c501a364ab23dce7d145fc6d156d5e219e52e871a2aadb41a397c5fb044c8aaee9b42906f4894ff3447af0e93ba
-  data.tar.gz: b74d6958ea8a77ffee45aed8184091b5ef54cb4fcaca9798351533b13d2f2202f28ab95f56a26e09692bf40f00e723d2df9c99007dbe10631d1c69c523fb3a58
+  metadata.gz: 286d3cb30ecd19b8f046fe43761f6d2f243f3e3a8134d01ebe14fdfdf11d6d879000f51ba66c705b0ad425e3c6a51dff02781b47e8cf75e52bc4f0439dfffc0e
+  data.tar.gz: 7caf9e3b7294ece38c964dc0366011b07d8977f95ec8c92a22763b9ecccc33080de40b5ab19bb66223eb4bb27be0847c92879a173dceee1b3fda9e1b03b0cdcd

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.98 2023-03-08
+
+- Add basic support for UDP sockets
+- Fix `IO#read` to return empty string when reading length zero
+- Fix hang on `require 'polyphony'` in irb session
+
 ## 0.97 2023-02-28
 
 - Fix working with IRB (#5)

data/examples/io/irb.rb

@@ -2,7 +2,7 @@
 
 require 'bundler/setup'
 require 'irb'
-require 'polyphony/adapters/irb'
+require 'polyphony'
 
 $counter = 0
 timer = spin do

data/ext/polyphony/backend_common.c

@@ -501,6 +501,36 @@ int backend_getaddrinfo(VALUE host, VALUE port, struct sockaddr **ai_addr) {
   return addrinfo_result->ai_addrlen;
 }
 
+inline VALUE name_to_addrinfo(void *name, socklen_t len) {
+  switch(((struct sockaddr *)name)->sa_family) {
+    case AF_INET:
+    {
+      struct sockaddr_in *info = name;
+      char buf[INET_ADDRSTRLEN];
+
+      VALUE port = INT2NUM(ntohs(info->sin_port));
+      if (!inet_ntop(AF_INET, &info->sin_addr, buf, sizeof(buf)))
+        rb_raise(rb_eRuntimeError, "Failed to get AF_INET addr");
+      VALUE addr = rb_str_new_cstr(buf);
+      return rb_ary_new_from_args(4, rb_str_new_literal("AF_INET"), port, addr, addr);
+      RB_GC_GUARD(addr);
+    }
+    case AF_INET6:
+    {
+      struct sockaddr_in6 *info = name;
+      char buf[INET6_ADDRSTRLEN];
+
+      VALUE port = INT2NUM(ntohs(info->sin6_port));
+      if (!inet_ntop(AF_INET6, &info->sin6_addr, buf, sizeof(buf)))
+        rb_raise(rb_eRuntimeError, "Failed to get AF_INET addr");
+      VALUE addr = rb_str_new_cstr(buf);
+      return rb_ary_new_from_args(4, rb_str_new_literal("AF_INET6"), port, addr, addr);
+      RB_GC_GUARD(addr);
+    }
+  }
+  return Qnil;
+}
+
 inline struct backend_buffer_spec backend_get_buffer_spec(VALUE in, int rw) {
   if (FIXNUM_P(in)) {
     struct buffer_spec *spec = FIX2PTR(in);

data/ext/polyphony/backend_common.h

@@ -148,5 +148,6 @@ void set_fd_blocking_mode(int fd, int blocking);
 void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking);
 void backend_setup_stats_symbols();
 int backend_getaddrinfo(VALUE host, VALUE port, struct sockaddr **ai_addr);
+VALUE name_to_addrinfo(void *name, socklen_t len);
 
 #endif /* BACKEND_COMMON_H */

data/ext/polyphony/backend_io_uring.c

@@ -673,6 +673,67 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE buffer, VALUE length, VALUE pos)
   return buffer_spec.raw ? INT2FIX(total) : buffer;
 }
 
+VALUE Backend_recvmsg(VALUE self, VALUE io, VALUE buffer, VALUE maxlen, VALUE pos, VALUE flags, VALUE maxcontrollen, VALUE opts) {
+  Backend_t *backend;
+  int fd;
+  rb_io_t *fptr;
+  struct backend_buffer_spec buffer_spec = backend_get_buffer_spec(buffer, 0);
+  long total = 0;
+
+  GetBackend(self, backend);
+  backend_prepare_read_buffer(buffer, maxlen, &buffer_spec, FIX2INT(pos));
+  fd = fd_from_io(io, &fptr, 0, 0);
+
+  char addr_buffer[64];
+  struct iovec iov;
+  struct msghdr msg;
+
+  iov.iov_base = StringValuePtr(buffer);
+  iov.iov_len = maxlen;
+
+  msg.msg_name = addr_buffer;
+  msg.msg_namelen = sizeof(addr_buffer);
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+
+  while (1) {
+    VALUE resume_value = Qnil;
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
+    int result;
+    int completed;
+
+    io_uring_prep_recvmsg(sqe, fd, &msg, NUM2INT(flags));
+
+    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    completed = context_store_release(&backend->store, ctx);
+    if (!completed) {
+      context_attach_buffers(ctx, 1, &buffer);
+      RAISE_IF_EXCEPTION(resume_value);
+      return resume_value;
+    }
+    RB_GC_GUARD(resume_value);
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+    else {
+      total += result;
+      break;
+    }
+  }
+
+  if (!total) return Qnil;
+
+  if (!buffer_spec.raw) backend_finalize_string_buffer(buffer, &buffer_spec, total, fptr);
+  VALUE addr = name_to_addrinfo(msg.msg_name, msg.msg_namelen);
+  VALUE rflags = INT2NUM(msg.msg_flags);
+  return rb_ary_new_from_args(3, buffer, addr, rflags);
+  RB_GC_GUARD(addr);
+}
+
 VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
   int fd;
@@ -809,6 +870,68 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE buffer, VALUE flags) {
   return INT2FIX(buffer_spec.len);
 }
 
+VALUE Backend_sendmsg(VALUE self, VALUE io, VALUE buffer, VALUE flags, VALUE dest_sockaddr, VALUE controls) {
+  Backend_t *backend;
+  int fd;
+  rb_io_t *fptr;
+
+  struct backend_buffer_spec buffer_spec = backend_get_buffer_spec(buffer, 1);
+  long left = buffer_spec.len;
+  int flags_int = FIX2INT(flags);
+
+  GetBackend(self, backend);
+  fd = fd_from_io(io, &fptr, 1, 0);
+
+  struct iovec iov;
+  struct msghdr msg;
+
+  iov.iov_base = buffer_spec.ptr;
+  iov.iov_len = buffer_spec.len;
+
+  if (dest_sockaddr != Qnil) {
+    msg.msg_name = RSTRING_PTR(dest_sockaddr);
+    msg.msg_namelen = RSTRING_LEN(dest_sockaddr);
+  }
+  else {
+    msg.msg_name = 0;
+    msg.msg_namelen = 0;
+  }
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+
+  while (left > 0) {
+    VALUE resume_value = Qnil;
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
+    int result;
+    int completed;
+
+    io_uring_prep_sendmsg(sqe, fd, &msg, flags_int);
+
+    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    completed = context_store_release(&backend->store, ctx);
+    if (!completed) {
+      context_attach_buffers(ctx, 1, &buffer);
+      RAISE_IF_EXCEPTION(resume_value);
+      return resume_value;
+    }
+    RB_GC_GUARD(resume_value);
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+    else {
+      iov.iov_base += result;
+      iov.iov_len -= result;
+      left -= result;
+    }
+  }
+
+  return INT2FIX(buffer_spec.len);
+}
+
 VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {
   int server_fd;
   rb_io_t *server_fptr;
@@ -1727,9 +1850,11 @@ void Init_Backend(void) {
   rb_define_method(cBackend, "read", Backend_read, 5);
   rb_define_method(cBackend, "read_loop", Backend_read_loop, 2);
   rb_define_method(cBackend, "recv", Backend_recv, 4);
+  rb_define_method(cBackend, "recvmsg", Backend_recvmsg, 7);
   rb_define_method(cBackend, "recv_feed_loop", Backend_recv_feed_loop, 3);
   rb_define_method(cBackend, "recv_loop", Backend_recv_loop, 2);
   rb_define_method(cBackend, "send", Backend_send, 3);
+  rb_define_method(cBackend, "sendmsg", Backend_sendmsg, 5);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
 

data/ext/polyphony/backend_libev.c

@@ -350,6 +350,72 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE buffer, VALUE length, VALUE pos)
   return Backend_read(self, io, buffer, length, Qnil, pos);
 }
 
+VALUE Backend_recvmsg(VALUE self, VALUE io, VALUE buffer, VALUE maxlen, VALUE pos, VALUE flags, VALUE maxcontrollen, VALUE opts) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  int fd;
+  rb_io_t *fptr;
+
+  struct backend_buffer_spec buffer_spec = backend_get_buffer_spec(buffer, 0);
+  long total = 0;
+  VALUE switchpoint_result = Qnil;
+  
+  GetBackend(self, backend);
+  backend_prepare_read_buffer(buffer, maxlen, &buffer_spec, FIX2INT(pos));
+  fd = fd_from_io(io, &fptr, 0, 1);
+  watcher.fiber = Qnil;
+
+  char addr_buffer[64];
+  struct iovec iov;
+  struct msghdr msg;
+
+  iov.iov_base = StringValuePtr(buffer);
+  iov.iov_len = maxlen;
+
+  msg.msg_name = addr_buffer;
+  msg.msg_namelen = sizeof(addr_buffer);
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+
+  while (1) {
+    backend->base.op_count++;
+    ssize_t result = recvmsg(fd, &msg, NUM2INT(flags));
+    if (result < 0) {
+      int e = errno;
+      if (e != EWOULDBLOCK && e != EAGAIN) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_READ);
+
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      switchpoint_result = backend_snooze(&backend->base);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      if (!result) break; // EOF
+
+      total += result;
+      break;
+    }
+  }
+
+  if (!total) return Qnil;
+  
+  if (!buffer_spec.raw) backend_finalize_string_buffer(buffer, &buffer_spec, total, fptr);
+  VALUE addr = name_to_addrinfo(msg.msg_name, msg.msg_namelen);
+  VALUE rflags = INT2NUM(msg.msg_flags);
+
+  return rb_ary_new_from_args(3, buffer, addr, rflags);
+  RB_GC_GUARD(addr);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
@@ -768,6 +834,73 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+VALUE Backend_sendmsg(VALUE self, VALUE io, VALUE buffer, VALUE flags, VALUE dest_sockaddr, VALUE controls) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  int fd;
+  rb_io_t *fptr;
+  VALUE switchpoint_result = Qnil;
+
+  struct backend_buffer_spec buffer_spec = backend_get_buffer_spec(buffer, 1);
+  long left = buffer_spec.len;
+  int flags_int = FIX2INT(flags);
+
+  GetBackend(self, backend);
+  fd = fd_from_io(io, &fptr, 1, 0);
+  watcher.fiber = Qnil;
+
+  struct iovec iov;
+  struct msghdr msg;
+
+  iov.iov_base = buffer_spec.ptr;
+  iov.iov_len = buffer_spec.len;
+
+  if (dest_sockaddr != Qnil) {
+    msg.msg_name = RSTRING_PTR(dest_sockaddr);
+    msg.msg_namelen = RSTRING_LEN(dest_sockaddr);
+  }
+  else {
+    msg.msg_name = 0;
+    msg.msg_namelen = 0;
+  }
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+
+  while (left > 0) {
+    backend->base.op_count++;
+    ssize_t result = sendmsg(fd, &msg, flags_int);
+    if (result < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_WRITE);
+
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      iov.iov_base = (buffer_spec.ptr += result);
+      iov.iov_len -= result;
+      left -= result;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze(&backend->base);
+
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2FIX(buffer_spec.len);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 struct libev_rw_ctx {
   int ref_count;
   VALUE fiber;
@@ -1502,9 +1635,11 @@ void Init_Backend(void) {
   rb_define_method(cBackend, "read", Backend_read, 5);
   rb_define_method(cBackend, "read_loop", Backend_read_loop, 2);
   rb_define_method(cBackend, "recv", Backend_recv, 4);
+  rb_define_method(cBackend, "recvmsg", Backend_recvmsg, 7);
   rb_define_method(cBackend, "recv_loop", Backend_read_loop, 2);
   rb_define_method(cBackend, "recv_feed_loop", Backend_feed_loop, 3);
   rb_define_method(cBackend, "send", Backend_send, 3);
+  rb_define_method(cBackend, "sendmsg", Backend_sendmsg, 5);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
 

data/ext/polyphony/io_extensions.c

@@ -21,7 +21,9 @@ ID ID_write;
 
 VALUE SYM_backend_read;
 VALUE SYM_backend_recv;
+VALUE SYM_backend_recvmsg;
 VALUE SYM_backend_send;
+VALUE SYM_backend_sendmsg;
 VALUE SYM_backend_write;
 VALUE SYM_call;
 VALUE SYM_comment;

data/ext/polyphony/polyphony.c

@@ -66,6 +66,10 @@ VALUE Polyphony_backend_recv(VALUE self, VALUE io, VALUE buffer, VALUE length, V
   return Backend_recv(BACKEND(), io, buffer, length, pos);
 }
 
+VALUE Polyphony_backend_recvmsg(VALUE self, VALUE io, VALUE buffer, VALUE maxlen, VALUE pos, VALUE flags, VALUE maxcontrollen, VALUE opts) {
+  return Backend_recvmsg(BACKEND(), io, buffer, maxlen, pos, flags, maxcontrollen, opts);
+}
+
 VALUE Polyphony_backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
   return Backend_recv_loop(BACKEND(), io, maxlen);
 }
@@ -78,6 +82,10 @@ VALUE Polyphony_backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags) {
   return Backend_send(BACKEND(), io, msg, flags);
 }
 
+VALUE Polyphony_backend_sendmsg(VALUE self, VALUE io, VALUE msg, VALUE flags, VALUE dest_sockaddr, VALUE controls) {
+  return Backend_sendmsg(BACKEND(), io, msg, flags, dest_sockaddr, controls);
+}
+
 VALUE Polyphony_backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
   return Backend_sendv(BACKEND(), io, ary, flags);
 }
@@ -181,9 +189,11 @@ void Init_Polyphony(void) {
   rb_define_singleton_method(mPolyphony, "backend_read", Polyphony_backend_read, 5);
   rb_define_singleton_method(mPolyphony, "backend_read_loop", Polyphony_backend_read_loop, 2);
   rb_define_singleton_method(mPolyphony, "backend_recv", Polyphony_backend_recv, 4);
+  rb_define_singleton_method(mPolyphony, "backend_recvmsg", Polyphony_backend_recvmsg, 7);
   rb_define_singleton_method(mPolyphony, "backend_recv_loop", Polyphony_backend_recv_loop, 2);
   rb_define_singleton_method(mPolyphony, "backend_recv_feed_loop", Polyphony_backend_recv_feed_loop, 3);
   rb_define_singleton_method(mPolyphony, "backend_send", Polyphony_backend_send, 3);
+  rb_define_singleton_method(mPolyphony, "backend_sendmsg", Polyphony_backend_sendmsg, 5);
   rb_define_singleton_method(mPolyphony, "backend_sendv", Polyphony_backend_sendv, 3);
   rb_define_singleton_method(mPolyphony, "backend_sleep", Polyphony_backend_sleep, 1);
   rb_define_singleton_method(mPolyphony, "backend_splice", Polyphony_backend_splice, 3);

data/ext/polyphony/polyphony.h

@@ -100,9 +100,11 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
 VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos);
 VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen);
 VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos);
+VALUE Backend_recvmsg(VALUE self, VALUE io, VALUE buffer, VALUE maxlen, VALUE pos, VALUE flags, VALUE maxcontrollen, VALUE opts);
 VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen);
 VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
 VALUE Backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags);
+VALUE Backend_sendmsg(VALUE self, VALUE io, VALUE msg, VALUE flags, VALUE dest_sockaddr, VALUE controls);
 VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
 VALUE Backend_sleep(VALUE self, VALUE duration);
 VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen);

data/lib/polyphony/adapters/irb.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'polyphony'
-
 module Kernel
   alias_method :gets, :orig_gets
 end

data/lib/polyphony/extensions/io.rb

@@ -143,6 +143,8 @@ class ::IO
 
   alias_method :orig_read, :read
   def read(len = nil, buf = nil, buf_pos = 0)
+    return '' if len == 0
+
     if buf
       return Polyphony.backend_read(self, buf, len, true, buf_pos)
     end

data/lib/polyphony/extensions/socket.rb

@@ -742,4 +742,33 @@ class ::UNIXSocket
   def write_nonblock(buf, exception: true)
     @io.write_nonblock(buf, exception: exception)
   end
-end
+end
+
+class ::UDPSocket
+  def recvfrom(maxlen, flags = 0)
+    buf = +''
+    Polyphony.backend_recvmsg(self, buf, maxlen, 0, flags, 0, nil)
+  end
+
+  def recvmsg(maxlen = nil, flags = 0, maxcontrollen = nil, opts = {})
+    buf = +''
+    Polyphony.backend_recvmsg(self, buf, maxlen || 4096, 0, flags, maxcontrollen, opts)
+  end
+
+  def sendmsg(msg, flags = 0, dest_sockaddr = nil, *controls)
+    Polyphony.backend_sendmsg(self, msg, flags, dest_sockaddr, controls)
+  end
+
+  def send(msg, flags, *addr)
+    sockaddr =  case addr.size
+    when 2
+      Socket.sockaddr_in(addr[1], addr[0])
+    when 1
+      addr[0]
+    else
+      nil
+    end
+
+    Polyphony.backend_sendmsg(self, msg, flags, sockaddr, nil)
+  end
+end

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.97'
+  VERSION = '0.98'
 end

data/lib/polyphony.rb

@@ -133,3 +133,7 @@ if (debug_socket_path = ENV['POLYPHONY_DEBUG_SOCKET_PATH'])
   require 'polyphony/debugger'
   Polyphony.start_debug_server(debug_socket_path)
 end
+
+if Object.const_defined?(:IRB)
+  require_relative './polyphony/adapters/irb'
+end

data/test/test_io.rb

@@ -93,6 +93,13 @@ class IOTest < MiniTest::Test
     assert_equal 'deffoobar', buf
   end
   
+  def test_read_zero
+    i, o = IO.pipe
+
+    o << 'hi'
+    assert_equal '', i.read(0)
+  end
+  
   def test_readpartial
     i, o = IO.pipe
     
@@ -658,6 +665,7 @@ class IOClassMethodsTest < MiniTest::Test
     
     # writing always causes snoozing
     o << 'foo'
+    3.times { snooze }
     o << 'bar'
     o.close
     

data/test/test_socket.rb

@@ -4,11 +4,7 @@ require_relative 'helper'
 require 'fileutils'
 require 'msgpack'
 
-class SocketTest < MiniTest::Test
-  def setup
-    super
-  end
-
+class TCPSocketTest < MiniTest::Test
   def start_tcp_server_on_random_port(host = '127.0.0.1')
     port = rand(1100..60000)
     server = TCPServer.new(host, port)
@@ -41,13 +37,13 @@ class SocketTest < MiniTest::Test
   end
 
   def test_tcpsocket_open_with_hostname
-    client = TCPSocket.open('google.com', 80)
-    client.write("GET / HTTP/1.0\r\nHost: google.com\r\n\r\n")
+    client = TCPSocket.open('ipinfo.io', 80)
+    client.write("GET / HTTP/1.0\r\nHost: ipinfo.io\r\n\r\n")
     result = nil
     move_on_after(3) {
       result = client.read
     }
-    assert result =~ /HTTP\/1.0 301 Moved Permanently/
+    assert result =~ /HTTP\/1.0 200 OK/
   end
 
   def test_tcp_ipv6
@@ -166,7 +162,9 @@ class SocketTest < MiniTest::Test
     server_fiber&.await
     server&.close
   end
+end
 
+class UNIXSocketTest < MiniTest::Test
   def test_unix_socket
     path = '/tmp/test_unix_socket'
     FileUtils.rm(path) rescue nil
@@ -193,7 +191,7 @@ class SocketTest < MiniTest::Test
   end
 end
 
-class SocketWithRawBufferTest < MiniTest::Test
+class TCPSocketWithRawBufferTest < MiniTest::Test
   def start_tcp_server_on_random_port(host = '127.0.0.1')
     port = rand(1100..60000)
     server = TCPServer.new(host, port)
@@ -243,6 +241,68 @@ class SocketWithRawBufferTest < MiniTest::Test
   end
 end
 
+class UDPSocketTest < MiniTest::Test
+  def test_udp_recvfrom
+    u1 = UDPSocket.new
+    u1.bind('127.0.0.1', 0)
+
+    server_fiber = spin do
+      msg, peer_addr = u1.recvfrom(256)
+      u1.send(msg, 0, peer_addr[3], peer_addr[1])
+    end
+
+    server_addr = u1.addr
+    u2 = UDPSocket.new
+    u2.bind('127.0.0.1', 0)
+    u2.send('foobar', 0, server_addr[3], server_addr[1])
+
+    msg, addr = u2.recvfrom(256)
+
+    assert_equal 'foobar', msg
+    assert_equal server_addr, addr
+  end
+
+  def test_udp_recvmsg
+    u1 = UDPSocket.new
+    u1.bind('127.0.0.1', 0)
+
+    server_fiber = spin do
+      msg, peer_addr = u1.recvmsg(256)
+      u1.send(msg, 0, peer_addr[3], peer_addr[1])
+    end
+
+    server_addr = u1.addr
+    u2 = UDPSocket.new
+    u2.bind('127.0.0.1', 0)
+    u2.send('foobar', 0, server_addr[3], server_addr[1])
+
+    msg, addr = u2.recvmsg(256)
+
+    assert_equal 'foobar', msg
+    assert_equal server_addr, addr
+  end
+
+  def test_udp_recvfrom_ipv6
+    u1 = UDPSocket.new :INET6
+    u1.bind('::1', 0)
+
+    server_fiber = spin do
+      msg, peer_addr = u1.recvfrom(256)
+      u1.send(msg, 0, peer_addr[3], peer_addr[1])
+    end
+
+    server_addr = u1.addr
+    u2 = UDPSocket.new :INET6
+    u2.bind('::1', 0)
+    u2.send('foobar', 0, server_addr[3], server_addr[1])
+
+    msg, addr = u2.recvfrom(256)
+
+    assert_equal 'foobar', msg
+    assert_equal server_addr, addr
+  end
+end
+
 if IS_LINUX
   class HTTPClientTest < MiniTest::Test
 
@@ -261,4 +321,4 @@ if IS_LINUX
       assert_equal 'https://ipinfo.io/missingauth', response['readme']
     end
   end
-end
+end

data/test/test_thread.rb

@@ -40,13 +40,14 @@ class ThreadTest < MiniTest::Test
 
   def test_thread_join_with_timeout
     buffer = []
-    spin { (1..3).each { |i| snooze; buffer << i } }
+    f = spin { (1..3).each { |i| snooze; buffer << i } }
     t = Thread.new { sleep 1; buffer << 4 }
     t0 = Time.now
     r = t.join(0.01)
     t = nil
 
     assert Time.now - t0 < 0.2
+    f.join
     assert_equal [1, 2, 3], buffer
     assert_nil r
   ensure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.97'
+  version: '0.98'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-28 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler