polyphony 0.97 → 0.99

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a8218fc4160e0772ee3aada1f72ea9d063724ccf9b0aee7dfa6e9e4d69ebfe4
-  data.tar.gz: 74aae84e991cd4330ad282553061b29e71a6434ce2dafc9985c62feb3a966a68
+  metadata.gz: 4696bb7b13f68b379c29d5c38257e57c13aefd299f88727107e2f0f0a3c7d360
+  data.tar.gz: 94a3eeb8575d0d5fe6f143ab41351024b50c4c4cf919edec6c8155d9ead2831e
 SHA512:
-  metadata.gz: 772d0be4ef2f723fa27cc5ecb8ef9e9b5d012c501a364ab23dce7d145fc6d156d5e219e52e871a2aadb41a397c5fb044c8aaee9b42906f4894ff3447af0e93ba
-  data.tar.gz: b74d6958ea8a77ffee45aed8184091b5ef54cb4fcaca9798351533b13d2f2202f28ab95f56a26e09692bf40f00e723d2df9c99007dbe10631d1c69c523fb3a58
+  metadata.gz: 9e1798e18b0e7a35104009d6f480191f5ed5efd7dee69189d443cb57ab8ca2f8fd75105234cd60f52ecea2348a8c3d85f152aa869374ea8dfbab8895a2015b04
+  data.tar.gz: 835b2be245f60b04d5b750bcce6e679b11c671e31c3d0269aeafaa961c52c501193f67cf00f4f7cc5570cab499105d025863189767db8ae79f961a62d903b173

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## 0.99 2023-03-09
+
+- Add missing Mutex API methods (#76)
+- Fix `IO.foreach` and `IO#each_line` (#74)
+- Fix `SSLServer#accept_loop` (#59)
+- Update liburing
+
+## 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/https_server_sni_2.rb

@@ -27,15 +27,21 @@ server = Polyphony::Net.tcp_listen('localhost', 1234, opts)
 
 puts 'Serving HTTPS on port 1234'
 
-# server.accept_loop do |socket|
-server.accept_loop do |socket|
-# while (socket = (server.accept)
-  spin do
-    while (data = socket.gets("\n", 8192))
-      if data.chomp.empty?
-        socket << "HTTP/1.1 200 OK\nConnection: close\nContent-Length: 4\n\nfoo\n"
-        break
+begin
+  server.accept_loop(false) do |socket|
+    spin do
+      while (data = socket.gets("\n", 8192))
+        if data.chomp.empty?
+          socket << "HTTP/1.1 200 OK\nConnection: close\nContent-Length: 4\n\nfoo\n"
+          break
+        end
       end
+    rescue OpenSSL::SSL::SSLError
+      # ignore
     end
   end
+rescue => e
+  puts '*' * 40
+  p e
+  puts e.backtrace.join("\n")
 end

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

@@ -55,16 +55,17 @@ if config[:io_uring]
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
   $defs << "-DPOLYPHONY_LINUX" if config[:linux]
-  $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
-  $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
-  $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
+
+  $defs << "-DEV_STANDALONE" # prevent libev from assuming "config.h" exists
   $defs << '-DEV_USE_EPOLL'        if have_header('sys/epoll.h')
   $defs << '-DEV_USE_KQUEUE'       if have_header('sys/event.h') && have_header('sys/queue.h')
+  $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
+  $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')
   $defs << '-DEV_USE_PORT'         if have_type('port_event_t', 'port.h')
+  $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
+  
   $defs << '-DHAVE_SYS_RESOURCE_H' if have_header('sys/resource.h')
 
-  $defs << "-DEV_STANDALONE" # prevent libev from assuming "config.h" exists
-
   $CFLAGS << " -Wno-comment"
   $CFLAGS << " -Wno-unused-result"
   $CFLAGS << " -Wno-dangling-else"

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/libev.h

@@ -1,5 +1,3 @@
-#define EV_STANDALONE
-
 #ifdef POLYPHONY_BACKEND_LIBEV
 
 /* keeps ev from requiring config.h */

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/core/sync.rb

@@ -58,6 +58,58 @@ module Polyphony
       @holding_fiber
     end
 
+    # Obtains a lock. Raises `ThreadError` if mutex is locked by the current
+    # thread.
+    #
+    # @return [Mutex] self
+    def lock
+      raise ThreadError if owned?
+      
+      @token = @store.shift
+      @holding_fiber = Fiber.current
+      self
+    end
+
+    # Releases the lock. Raises `ThreadError` if mutex is not locked by the
+    # current thread.
+    #
+    # @return [Mutex] self
+    def unlock
+      raise ThreadError if !owned?
+
+      @holding_fiber = nil
+      @store << @token if @token
+      @token = nil
+    end
+
+    # Attempts to obtain the lock and returns immediately. Returns `true` if the
+    # lock was granted.
+    #
+    # @return [true, false]
+    def try_lock
+      return false if @holding_fiber
+
+      @token = @store.shift
+      @holding_fiber = Fiber.current
+      true
+    end
+
+    # Releases the lock and sleeps timeout seconds if it is given and non-nil or
+    # forever. Raises `ThreadError` if mutex wasn’t locked by the current
+    # thread.
+    #
+    # @param timeout [nil, Number] sleep timeout
+    # @return [Number] slept time in seconds
+    def sleep(timeout = nil)
+      unlock
+      t0 = Time.now
+      Kernel.sleep(timeout)
+      t1 = Time.now
+      lock
+
+      return t1 - t0
+    end
+
     private
 
     # Helper method for performing a `#synchronize` when not currently holding
@@ -72,6 +124,7 @@ module Polyphony
       ensure
         @holding_fiber = nil
         @store << @token if @token
+        @token = nil
       end
     end
   end

data/lib/polyphony/extensions/io.rb

@@ -25,20 +25,19 @@ class ::IO
 
     EMPTY_HASH = {}.freeze
 
-    # alias_method :orig_foreach, :foreach
-    # def foreach(_name, _sep = $/, _limit = nil, _getline_args = EMPTY_HASH,
-    #             &_block)
-    #   # IO.orig_read(name).each_line(&block)
-    #   raise NotImplementedError
-
-    #   # if sep.is_a?(Integer)
-    #   #   sep = $/
-    #   #   limit = sep
-    #   # end
-    #   # File.open(name, 'r') do |f|
-    #   #   f.each_line(sep, limit, getline_args, &block)
-    #   # end
-    # end
+    alias_method :orig_foreach, :foreach
+    def foreach(name, sep = $/, limit = nil, getline_args = EMPTY_HASH, &block)
+      # IO.orig_read(name).each_line(&block)
+      # raise NotImplementedError
+
+      if sep.is_a?(Integer)
+        sep = $/
+        limit = sep
+      end
+      File.open(name, 'r') do |f|
+        f.each_line(sep, limit, chomp: getline_args[:chomp], &block)
+      end
+    end
 
     alias_method :orig_read, :read
     def read(name, length = nil, offset = nil, opt = EMPTY_HASH)
@@ -143,6 +142,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
@@ -196,6 +197,30 @@ class ::IO
     return nil
   end
 
+  def each_line(sep = $/, limit = nil, chomp: false)
+    if sep.is_a?(Integer)
+      limit = sep
+      sep = $/
+    end
+    sep_size = sep.bytesize
+
+
+    @read_buffer ||= +''
+
+    while true
+      while (idx = @read_buffer.index(sep))
+        line = @read_buffer.slice!(0, idx + sep_size)
+        line = line.chomp if chomp
+        yield line
+      end
+
+      result = readpartial(8192, @read_buffer, -1)
+      return self if !result
+    end
+  rescue EOFError
+    return self
+  end
+
   # def print(*args)
   # end
 

data/lib/polyphony/extensions/openssl.rb

@@ -200,7 +200,7 @@ class ::OpenSSL::SSL::SSLServer
   def accept_loop(ignore_errors = true)
     loop do
       yield accept
-    rescue SystemCallError, StandardError => e
+    rescue OpenSSL::SSL::SSLError, SystemCallError => e
       raise e unless ignore_errors
     end
   end