polyphony 0.17 → 0.19

data/ext/ev/extconf.rb

@@ -16,4 +16,4 @@ $defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
 CONFIG["optflags"] << " -fno-strict-aliasing"
 
 dir_config "ev_ext"
-create_makefile "ev_ext"
+create_makefile "ev_ext"

data/ext/ev/io.c

@@ -26,7 +26,6 @@ static VALUE EV_IO_initialize(VALUE self, VALUE io, VALUE event_mask);
 
 static VALUE EV_IO_start(VALUE self);
 static VALUE EV_IO_stop(VALUE self);
-static VALUE EV_IO_await(VALUE self);
 
 void EV_IO_callback(ev_loop *ev_loop, struct ev_io *io, int revents);
 
@@ -38,9 +37,6 @@ static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io);
 static VALUE IO_write(int argc, VALUE *argv, VALUE io);
 static VALUE IO_write_chevron(VALUE io, VALUE str);
 
-static VALUE IO_read_watcher(VALUE self);
-static VALUE IO_write_watcher(VALUE self);
-
 void Init_EV_IO() {
   mEV = rb_define_module("EV");
   cEV_IO = rb_define_class_under(mEV, "IO", rb_cData);
@@ -164,7 +160,7 @@ static VALUE EV_IO_stop(VALUE self) {
   return self;
 }
 
-static VALUE EV_IO_await(VALUE self) {
+VALUE EV_IO_await(VALUE self) {
   struct EV_IO *io;
   VALUE ret;
   
@@ -221,7 +217,7 @@ struct io_internal_read_struct {
     size_t capa;
 };
 
-static int io_setstrbuf(VALUE *str, long len) {
+int io_setstrbuf(VALUE *str, long len) {
   #ifdef _WIN32
     len = (len + 1) & ~1L;	/* round up for wide char */
   #endif
@@ -249,7 +245,7 @@ static void io_shrink_read_string(VALUE str, long n) {
   }
 }
 
-static void io_set_read_length(VALUE str, long n, int shrinkable) {
+void io_set_read_length(VALUE str, long n, int shrinkable) {
   if (RSTRING_LEN(str) != n) {
     rb_str_modify(str);
     rb_str_set_len(str, n);
@@ -257,17 +253,14 @@ static void io_set_read_length(VALUE str, long n, int shrinkable) {
   }
 }
 
-static rb_encoding*
-io_read_encoding(rb_io_t *fptr)
-{
+static rb_encoding* io_read_encoding(rb_io_t *fptr) {
     if (fptr->encs.enc) {
 	return fptr->encs.enc;
     }
     return rb_default_external_encoding();
 }
 
-static VALUE io_enc_str(VALUE str, rb_io_t *fptr)
-{
+VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
     OBJ_TAINT(str);
     rb_enc_associate(str, io_read_encoding(fptr));
     return str;
@@ -277,6 +270,9 @@ static VALUE io_enc_str(VALUE str, rb_io_t *fptr)
 //////////////////////////////////////////////////////////////////////
 
 static VALUE IO_read(int argc, VALUE *argv, VALUE io) {
+  VALUE underlying_io = rb_iv_get(io, "@io");
+  if (!NIL_P(underlying_io)) io = underlying_io;
+
   long len = argc == 1 ? NUM2LONG(argv[0]) : 8192;
 
   rb_io_t *fptr;
@@ -291,7 +287,7 @@ static VALUE IO_read(int argc, VALUE *argv, VALUE io) {
   VALUE str = argc >= 2 ? argv[1] : Qnil;
 
   shrinkable = io_setstrbuf(&str, len);
-  // OBJ_TAINT(str);
+  OBJ_TAINT(str);
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
   rb_io_set_nonblock(fptr);
@@ -308,8 +304,7 @@ static VALUE IO_read(int argc, VALUE *argv, VALUE io) {
       int e = errno;
       if ((e == EWOULDBLOCK || e == EAGAIN)) {
         if (read_watcher == Qnil)
-          // read_watcher = IO_read_watcher(io);
-          read_watcher = rb_funcall(io, ID_read_watcher, 0);
+          read_watcher = IO_read_watcher(io);
         EV_IO_await(read_watcher);
       }
       else
@@ -337,6 +332,9 @@ static VALUE IO_read(int argc, VALUE *argv, VALUE io) {
 }
 
 static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
+  VALUE underlying_io = rb_iv_get(io, "@io");
+  if (!NIL_P(underlying_io)) io = underlying_io;
+
   long len = argc == 1 ? NUM2LONG(argv[0]) : 8192;
 
   rb_io_t *fptr;
@@ -363,10 +361,9 @@ static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
     n = read(fptr->fd, RSTRING_PTR(str), len);
     if (n < 0) {
       int e = errno;
-      if ((e == EWOULDBLOCK || e == EAGAIN)) {
+      if (e == EWOULDBLOCK || e == EAGAIN) {
         if (read_watcher == Qnil)
-          // read_watcher = IO_read_watcher(io);
-          read_watcher = rb_funcall(io, ID_read_watcher, 0);
+          read_watcher = IO_read_watcher(io);
         EV_IO_await(read_watcher);
       }
       else
@@ -387,6 +384,9 @@ static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
 }
 
 static VALUE IO_write(int argc, VALUE *argv, VALUE io) {
+  VALUE underlying_io = rb_iv_get(io, "@io");
+  if (!NIL_P(underlying_io)) io = underlying_io;
+
   long i;
   long n;
   long total = 0;
@@ -413,8 +413,8 @@ static VALUE IO_write(int argc, VALUE *argv, VALUE io) {
         int e = errno;
         if (e == EWOULDBLOCK || e == EAGAIN) {
           if (write_watcher == Qnil)
-            // write_watcher = IO_write_watcher(io);
-            write_watcher = rb_funcall(io, ID_write_watcher, 0);
+            write_watcher = IO_write_watcher(io);
+            // write_watcher = rb_funcall(io, ID_write_watcher, 0);
           EV_IO_await(write_watcher);
         }
         else {
@@ -441,7 +441,7 @@ static VALUE IO_write_chevron(VALUE io, VALUE str) {
   return io;
 }
 
-static VALUE IO_read_watcher(VALUE self) {
+VALUE IO_read_watcher(VALUE self) {
   VALUE watcher = rb_iv_get(self, "@read_watcher");
   if (watcher == Qnil) {
     watcher = rb_funcall(cEV_IO, rb_intern("new"), 2, self, ID2SYM(rb_intern("r")));
@@ -450,11 +450,11 @@ static VALUE IO_read_watcher(VALUE self) {
   return watcher;
 }
 
-static VALUE IO_write_watcher(VALUE self) {
+VALUE IO_write_watcher(VALUE self) {
   VALUE watcher = rb_iv_get(self, "@write_watcher");
   if (watcher == Qnil) {
     watcher = rb_funcall(cEV_IO, rb_intern("new"), 2, self, ID2SYM(rb_intern("w")));
     rb_iv_set(self, "@write_watcher", watcher);
   }
   return watcher;
-}
+}

data/ext/ev/signal.c

@@ -116,4 +116,4 @@ static VALUE EV_Signal_stop(VALUE self) {
   }
 
   return self;
-}
+}

data/ext/ev/socket.c

@@ -0,0 +1,161 @@
+#include "ev.h"
+#include <sys/socket.h>
+
+static VALUE BasicSocket_send(int argc, VALUE *argv, VALUE io);
+static VALUE BasicSocket_recv(int argc, VALUE *argv, VALUE io);
+
+void Init_Socket() {
+  rb_require("socket");
+  VALUE cBasicSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
+
+  rb_define_method(cBasicSocket, "send", BasicSocket_send, -1);
+  rb_define_method(cBasicSocket, "recv", BasicSocket_recv, -1);
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+struct rsock_send_arg {
+    int fd, flags;
+    VALUE mesg;
+    struct sockaddr *to;
+    socklen_t tolen;
+};
+
+#define StringValue(v) rb_string_value(&(v))
+#define IS_ADDRINFO(obj) rb_typeddata_is_kind_of((obj), &addrinfo_type)
+
+VALUE
+rsock_sockaddr_string_value(volatile VALUE *v)
+{
+    // VALUE val = *v;
+    // if (IS_ADDRINFO(val)) {
+    //     *v = addrinfo_to_sockaddr(val);
+    // }
+    StringValue(*v);
+    return *v;
+}
+
+#define SockAddrStringValue(v) rsock_sockaddr_string_value(&(v))
+#define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
+#ifndef RSTRING_SOCKLEN
+#  define RSTRING_SOCKLEN (socklen_t)RSTRING_LENINT
+#endif
+
+#if defined __APPLE__
+# define do_write_retry(code) do {ret = code;} while (ret == -1 && errno == EPROTOTYPE)
+#else
+# define do_write_retry(code) ret = code
+#endif
+
+VALUE
+rsock_sendto_blocking(void *data)
+{
+    struct rsock_send_arg *arg = data;
+    VALUE mesg = arg->mesg;
+    ssize_t ret;
+    do_write_retry(sendto(arg->fd, RSTRING_PTR(mesg), RSTRING_LEN(mesg),
+			  arg->flags, arg->to, arg->tolen));
+    return (VALUE)ret;
+}
+
+VALUE
+rsock_send_blocking(void *data)
+{
+    struct rsock_send_arg *arg = data;
+    VALUE mesg = arg->mesg;
+    ssize_t ret;
+    do_write_retry(send(arg->fd, RSTRING_PTR(mesg), RSTRING_LEN(mesg),
+			arg->flags));
+    return (VALUE)ret;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+static VALUE BasicSocket_send(int argc, VALUE *argv, VALUE sock) {
+  VALUE underlying_socket = rb_iv_get(sock, "@socket");
+  if (!NIL_P(underlying_socket)) sock = underlying_socket;
+  struct rsock_send_arg arg;
+  VALUE flags, to;
+  rb_io_t *fptr;
+  ssize_t n;
+  rb_blocking_function_t *func;
+  const char *funcname;
+  VALUE write_watcher = Qnil;
+  
+  rb_scan_args(argc, argv, "21", &arg.mesg, &flags, &to);
+
+  StringValue(arg.mesg);
+  if (!NIL_P(to)) {
+    SockAddrStringValue(to);
+    to = rb_str_new4(to);
+    arg.to = (struct sockaddr *)RSTRING_PTR(to);
+    arg.tolen = RSTRING_SOCKLEN(to);
+    func = rsock_sendto_blocking;
+    funcname = "sendto(2)";
+  }
+  else {
+    func = rsock_send_blocking;
+    funcname = "send(2)";
+  }
+  GetOpenFile(sock, fptr);
+  rb_io_set_nonblock(fptr);
+  arg.fd = fptr->fd;
+  arg.flags = NUM2INT(flags);
+  while ((n = (ssize_t)func(&arg)) < 0) {
+    if (write_watcher == Qnil)
+      write_watcher = IO_write_watcher(sock);
+    EV_IO_await(write_watcher);
+  }
+  return SSIZET2NUM(n);
+}
+
+static VALUE BasicSocket_recv(int argc, VALUE *argv, VALUE sock) {
+  VALUE underlying_socket = rb_iv_get(sock, "@socket");
+  if (!NIL_P(underlying_socket)) sock = underlying_socket;
+  long len = argc >= 1 ? NUM2LONG(argv[0]) : 8192;
+  if (len < 0) {
+    rb_raise(rb_eArgError, "negative length %ld given", len);
+  }
+
+  rb_io_t *fptr;
+  long n;
+  int shrinkable;
+  VALUE read_watcher = Qnil;
+
+
+  VALUE str = argc >= 3 ? argv[2] : Qnil;
+
+  shrinkable = io_setstrbuf(&str, len);
+  OBJ_TAINT(str);
+  GetOpenFile(sock, fptr);
+  // rb_io_set_nonblock(fptr);
+  rb_io_check_byte_readable(fptr);
+
+  if (len == 0)
+  	return str;
+
+  while (1) {
+    n = recv(fptr->fd, RSTRING_PTR(str), len, MSG_DONTWAIT);
+    if (n < 0) {
+      int e = errno;
+      if (e == EWOULDBLOCK || e == EAGAIN) {
+        if (read_watcher == Qnil)
+          read_watcher = IO_read_watcher(sock);
+        EV_IO_await(read_watcher);
+      }
+      else
+        rb_syserr_fail(e, strerror(e));
+        // rb_syserr_fail_path(e, fptr->pathv);
+    }
+    else
+      break;
+  }
+
+  io_set_read_length(str, n, shrinkable);
+  io_enc_str(str, fptr);
+
+  if (n == 0)
+    return Qnil;
+
+  return str;
+}

data/lib/polyphony/core/coprocess.rb

@@ -20,7 +20,7 @@ class Coprocess
   def run(&block2)
     @caller = caller if Exceptions.debug
 
-    @fiber = FiberPool.spawn do
+    @fiber = FiberPool.run do
       @fiber.coprocess = self
       @result = (@block || block2).call(self)
     rescue Exceptions::MoveOn, Exceptions::Stop => e

data/lib/polyphony/core/fiber_pool.rb

@@ -4,7 +4,7 @@ export  :available,
         :checked_out,
         :reset!,
         :size,
-        :spawn
+        :run
 
 require 'fiber'
 
@@ -48,7 +48,7 @@ EV.unref
 # Invokes the given block using a fiber taken from the fiber pool. If the pool
 # is exhausted, a new fiber will be created.
 # @return [Fiber]
-def spawn(&block)
+def run(&block)
   fiber = @pool.empty? ? new_fiber : @pool.shift
   fiber.next_job = block
   fiber

data/lib/polyphony/core/supervisor.rb

@@ -25,30 +25,14 @@ class Supervisor
     end
   end
 
-  def spawn(proc = nil, &block)
-    if proc.is_a?(Coprocess)
-      spawn_coprocess(proc)
-    else
-      spawn_proc(block || proc)
-    end
-  end
-
-  def spawn_coprocess(proc)
+  def spin(proc = nil, &block)
+    proc = Coprocess.new(&(proc || block)) unless proc.is_a?(Coprocess)
     @coprocesses << proc
     proc.when_done { task_completed(proc) }
     proc.run unless proc.running?
     proc
   end
 
-  def spawn_proc(proc)
-    @coprocesses << coproc do |coprocess|
-      proc.call(coprocess)
-      task_completed(coprocess)
-    rescue Exception => e
-      task_completed(coprocess)
-    end
-  end
-
   def still_running?
     !@coprocesses.empty?
   end

data/lib/polyphony/extensions/io.rb

@@ -30,18 +30,20 @@ class ::IO
 
     alias_method :orig_read, :read
     def read(name, length = nil, offset = nil, opt = EMPTY_HASH)
+      opt, length = length, nil if length.is_a?(Hash)
       File.open(name, opt[:mode] || 'r') do |f|
         f.seek(offset) if offset
         length ? f.read(length) : f.read
       end
     end
 
-    alias_method :orig_readlines, :readlines
-    def readlines(name, sep = $/, limit = nil, getline_args = EMPTY_HASH)
-      File.open(name, 'r') do |f|
-        f.readlines(sep, limit, getline_args)
-      end
-    end
+    # alias_method :orig_readlines, :readlines
+    # def readlines(name, sep = $/, limit = nil, getline_args = EMPTY_HASH)
+    #   File.open(name, 'r') do |f|
+    #     puts "readlines(#{sep.inspect}, #{limit.inspect}, #{getline_args.inspect}"
+    #     f.readlines(sep, limit, getline_args)
+    #   end
+    # end
 
     alias_method :orig_write, :write
     def write(name, string, offset = nil, opt = EMPTY_HASH)
@@ -141,4 +143,15 @@ class ::IO
 
   # def readlines(sep = $/, limit = nil, chomp: nil)
   # end
+
+  def write_nonblock(string, options = {})
+    # STDOUT << '>'
+    write(string, 0)
+  end
+
+  def read_nonblock(maxlen, buf = nil, options = nil)
+    # STDOUT << '<'
+    buf ? readpartial(maxlen, buf) : readpartial(maxlen)
+  end
+
 end

data/lib/polyphony/extensions/kernel.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fiber'
+require 'timeout'
 
 CancelScope = import('../core/cancel_scope')
 Coprocess   = import('../core/coprocess')
@@ -56,7 +57,7 @@ end
 
 module ::Process
   def self.detach(pid)
-    coproc {
+    spin {
       EV::Child.new(pid).await
     }
   end
@@ -93,7 +94,7 @@ module ::Kernel
     CancelScope.new(timeout: duration, mode: :cancel).(&block)
   end
 
-  def coproc(proc = nil, &block)
+  def spin(proc = nil, &block)
     if proc.is_a?(Coprocess)
       proc.run
     else
@@ -139,10 +140,12 @@ module ::Kernel
     nil
   end
 
-  def throttled_loop(rate, &block)
+  def throttled_loop(rate, count: nil, &block)
     throttler = Throttler.new(rate)
-    loop do
-      throttler.(&block)
+    if count
+      count.times { throttler.(&block) }
+    else
+      loop { throttler.(&block) }
     end
   end
 
@@ -155,3 +158,12 @@ module ::Kernel
   end
 end
 
+module ::Timeout
+  def self.timeout(sec, klass = nil, message = nil, &block)
+    cancel_after(sec, &block)
+  rescue Exceptions::Cancel => e
+    error = klass ? klass.new(message) : ::Timeout::Error.new
+    error.set_backtrace(e.backtrace)
+    raise error
+  end
+end