polyphony 0.48.0 → 0.50.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a699d313072b1beba17c900491dd2a4f454bc8faea69eb157634e98cba7ee90
-  data.tar.gz: 3d8579b2c927c34876560ce878e960b9bc48a857ce43890dc069b4f0fa5ad75f
+  metadata.gz: 126431d6f1b6c547d57dd99834c5a2371b4f2b3399df5556f55fdf7ff8465702
+  data.tar.gz: bf4e8d8cbde0a0d25930996f21ca723ffb68c065688ea2423f96b2a1e8946a80
 SHA512:
-  metadata.gz: d6efca5f42f21fe25ab5e6064675c2806dcad9d86e2e80c908987fcce855dd520ab51c4913e5a9001d3e4a84880a6606d124fa46dedff7c2e437a1ef6e156a82
-  data.tar.gz: 73ad6c59d4f7e9f8f0d317f480be1ba33c1a70dcf130a717693c2bb5a9ef3e226bfff3bdb635461b505bd2e9bbec7a2174c6a206bee2a94709ba9739ab087956
+  metadata.gz: 9b6cb2b64ac16e70941195aa17c019abdb026bac2d440550841f839bae96d248b87609979e6e9d7c57f9905845209714d90f74caa4488d8ba66afa96c35aa425
+  data.tar.gz: '093360cb9c3f5e81d7d23f1e707bf6399608475822b56d0171438748e65752adb2784b1ab36ce850a26840c615f73ce1fcc74ca842018361019269f7d3c31aa9'

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 0.50.1
+
+- Set `IOSQE_ASYNC` flag in io_uring backend
+- Fix error handling in `Backend#waitpid`
+- Reimplement libev backend's `#waitpid` by using pidfd_open (in similar manner
+  to the io_uring backend)
+
+## 0.50.0
+
+- Use `Process::CLOCK_MONOTONIC` in Timer
+- Add `Timer#sleep`, `Timer#after`, `Timer#every`
+- Prevent fiber from being resumed after terminating
+- Add `Thread#fiber_index_of` method
+- Use `Backend#wait_event` in `Fiber#await`
+
+## 0.49.2
+
+- Fix hang with 100s or more child fibers when terminating
+- Fix double pending_count increment in io_uring backend
+
+## 0.49.1
+
+- Use `TCPSocket` instead of `Socket` in `Net.tcp_connect`
+- Catch `Errno::ERSCH` in `Process.kill_and_await`
+- Set io_uring queue size to 2048
+
+## 0.49.0
+
+- Implement `Polyphony::Timer` for performant timeouts
+
 ## 0.48.0
 
 - Implement graceful shutdown

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.48.0)
+    polyphony (0.50.1)
 
 GEM
   remote: https://rubygems.org/

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Sharon Rosner
+Copyright (c) 2021 Sharon Rosner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/TODO.md

@@ -1,4 +1,10 @@
-- Override stock `SizedQueue` impl with Queue with capacity
+- Check segfault when resetting a `cancel_after` timeout lots of times at very high rate
+- Check why `throttled_loop` inside of `move_on_after` fails to stop
+
+- Commented out `io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);` in `io_uring_backend_defer_submit_and_await`:
+  - This flag should be set for I/O ops, not for other stuff
+
+- Override stock `::SizedQueue` impl with Queue with capacity
 
 - Add support for `break` and `StopIteration` in all loops (with tests)
 

data/examples/core/nested.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+def process
+  p :b_start
+  sleep 1
+  p :b_stop
+end
+
+spin do
+  p :a_start
+  spin { process }
+  sleep 60
+  p :a_stop
+end
+
+p :main_start
+sleep 120
+p :main_stop

data/examples/core/suspend.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+main = Fiber.current
+spin do
+  sleep 0.1
+  main.schedule(:foo)
+end
+
+v = suspend
+puts "v => #{v.inspect}"

data/examples/core/terminate_main_fiber.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+main = Fiber.current
+spin do
+  sleep 0.1
+  main.terminate
+end
+
+sleep

data/examples/performance/thread-vs-fiber/polyphony_server.rb

@@ -26,15 +26,13 @@ def write_response(socket)
   socket.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
-server = TCPServer.open('0.0.0.0', 1234)
-puts "pid #{Process.pid} Polyphony (#{Thread.current.backend.kind}) listening on port 1234"
+server = TCPServer.open('0.0.0.0', 4411)
+puts "pid #{Process.pid} Polyphony (#{Thread.current.backend.kind}) listening on port 4411"
 
 spin_loop(interval: 10) do
   p Thread.current.fiber_scheduling_stats
 end
 
-GC.disable
-
 server.accept_loop do |c|
   spin { handle_client(c) }
 end

data/ext/polyphony/backend_common.h

@@ -3,6 +3,14 @@
 #include "ruby.h"
 #include "ruby/io.h"
 
+#ifndef __NR_pidfd_open
+#define __NR_pidfd_open 434   /* System call # on most architectures */
+#endif
+
+static int pidfd_open(pid_t pid, unsigned int flags) {
+  return syscall(__NR_pidfd_open, pid, flags);
+}
+
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 // the following is copied verbatim from the Ruby source code (io.c)
@@ -114,7 +122,7 @@ inline double current_time() {
   struct timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
   long long ns = ts.tv_sec;
-  ns = ns * 1000000000 + ts.tv_nsec;
+  ns = ns * 1e9 + ts.tv_nsec;
   double t = ns;
   return t / 1e9;
 }
@@ -126,4 +134,16 @@ inline VALUE backend_timeout_exception(VALUE exception) {
     return rb_funcall(exception, ID_new, 0);
   else
     return rb_funcall(rb_eRuntimeError, ID_new, 1, exception);
-}
+}
+
+VALUE Backend_timeout_safe(VALUE arg) {
+  return rb_yield(arg);
+}
+
+VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
+  return exception;
+}
+
+VALUE Backend_timeout_ensure_safe(VALUE arg) {
+  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
+}

data/ext/polyphony/backend_io_uring.c

@@ -19,14 +19,6 @@
 #include "ruby/thread.h"
 #include "backend_io_uring_context.h"
 
-#ifndef __NR_pidfd_open
-#define __NR_pidfd_open 434   /* System call # on most architectures */
-#endif
-
-static int pidfd_open(pid_t pid, unsigned int flags) {
-  return syscall(__NR_pidfd_open, pid, flags);
-}
-
 VALUE SYM_io_uring;
 
 typedef struct Backend_t {
@@ -72,7 +64,7 @@ static VALUE Backend_initialize(VALUE self) {
   backend->pending_count = 0;
   backend->poll_no_wait_count = 0;
   backend->pending_sqes = 0;
-  backend->prepared_limit = 256;
+  backend->prepared_limit = 2048;
 
   context_store_initialize(&backend->store);
   io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
@@ -260,12 +252,10 @@ int io_uring_backend_defer_submit_and_await(
   VALUE switchpoint_result = Qnil;
 
   io_uring_sqe_set_data(sqe, ctx);
-  // io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
   io_uring_backend_defer_submit(backend);
 
-  backend->pending_count++;
   switchpoint_result = backend_await(backend);
-  backend->pending_count--;
 
   if (!ctx->completed) {
     ctx->result = -ECANCELED;
@@ -813,18 +803,6 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   }
 }
 
-VALUE Backend_timeout_safe(VALUE arg) {
-  return rb_yield(arg);
-}
-
-VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
-  return exception;
-}
-
-VALUE Backend_timeout_ensure_safe(VALUE arg) {
-  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
-}
-
 struct Backend_timeout_ctx {
   Backend_t *backend;
   op_context_t *ctx;
@@ -863,7 +841,6 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_sqe_set_data(sqe, ctx);
-  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
   io_uring_backend_defer_submit(backend);
 
   struct Backend_timeout_ctx timeout_ctx = {backend, ctx};
@@ -881,19 +858,28 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
-  Backend_t *backend;
   int pid_int = NUM2INT(pid);
   int fd = pidfd_open(pid_int, 0);
-  GetBackend(self, backend);
-  
-  VALUE resume_value = io_uring_backend_wait_fd(backend, fd, 0);
-  close(fd);
 
-  RAISE_IF_EXCEPTION(resume_value);
-  RB_GC_GUARD(resume_value);
+  if (fd >= 0) {
+    Backend_t *backend;
+    GetBackend(self, backend);
 
+    VALUE resume_value = io_uring_backend_wait_fd(backend, fd, 0);
+    close(fd);
+    RAISE_IF_EXCEPTION(resume_value);
+    RB_GC_GUARD(resume_value);
+  }
+  
   int status;
   pid_t ret = waitpid(pid_int, &status, WNOHANG);
+  if (ret < 0) {
+    int e = errno;
+    if (e == ECHILD)
+      ret = pid_int;
+    else
+      rb_syserr_fail(e, strerror(e));
+  }
   return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
 }
 

data/ext/polyphony/backend_libev.c

@@ -8,6 +8,8 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdnoreturn.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
@@ -685,26 +687,12 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     RB_GC_GUARD(switchpoint_result);
 
     rb_yield(Qnil);
-
-    while (1) {
+    do {
       next_time += interval_d;
-      if (next_time > now) break;
-    }
+    } while (next_time <= now);
   }
 }
 
-VALUE Backend_timeout_safe(VALUE arg) {
-  return rb_yield(arg);
-}
-
-VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
-  return exception;
-}
-
-VALUE Backend_timeout_ensure_safe(VALUE arg) {
-  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
-}
-
 struct libev_timeout {
   struct ev_timer timer;
   VALUE fiber;
@@ -759,38 +747,29 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
   return result;
 }
 
-struct libev_child {
-  struct ev_child child;
-  VALUE fiber;
-};
-
-void Backend_child_callback(EV_P_ ev_child *w, int revents)
-{
-  struct libev_child *watcher = (struct libev_child *)w;
-  int exit_status = WEXITSTATUS(w->rstatus);
-  VALUE status;
-
-  status = rb_ary_new_from_args(2, INT2NUM(w->rpid), INT2NUM(exit_status));
-  Fiber_make_runnable(watcher->fiber, status);
-}
-
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
-  Backend_t *backend;
-  struct libev_child watcher;
-  VALUE switchpoint_result = Qnil;
-  GetBackend(self, backend);
-
-  watcher.fiber = rb_fiber_current();
-  ev_child_init(&watcher.child, Backend_child_callback, NUM2INT(pid), 0);
-  ev_child_start(backend->ev_loop, &watcher.child);
-
-  switchpoint_result = backend_await(backend);
+  int pid_int = NUM2INT(pid);
+  int fd = pidfd_open(pid_int, 0);
+  if (fd >= 0) {
+    Backend_t *backend;
+    GetBackend(self, backend);
+
+    VALUE resume_value = libev_wait_fd(backend, fd, EV_READ, 0);
+    close(fd);
+    RAISE_IF_EXCEPTION(resume_value);
+    RB_GC_GUARD(resume_value);
+  }
 
-  ev_child_stop(backend->ev_loop, &watcher.child);
-  RAISE_IF_EXCEPTION(switchpoint_result);
-  RB_GC_GUARD(watcher.fiber);
-  RB_GC_GUARD(switchpoint_result);
-  return switchpoint_result;
+  int status = 0;
+  pid_t ret = waitpid(pid_int, &status, WNOHANG);
+  if (ret < 0) {
+    int e = errno;
+    if (e == ECHILD)
+      ret = pid_int;
+    else
+      rb_syserr_fail(e, strerror(e));
+  }
+  return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
 }
 
 void Backend_async_callback(EV_P_ ev_async *w, int revents) { }

data/ext/polyphony/fiber.c

@@ -101,7 +101,8 @@ VALUE Fiber_await(VALUE self) {
   }
   rb_hash_aset(waiting_fibers, fiber, Qtrue);
 
-  result = Thread_switch_fiber(rb_thread_current());
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  result = Backend_wait_event(backend, Qnil);
 
   rb_hash_delete(waiting_fibers, fiber);
   RAISE_IF_EXCEPTION(result);

data/ext/polyphony/polyphony.h

@@ -84,6 +84,7 @@ void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule);
 void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule);
 runqueue_entry Runqueue_shift(VALUE self);
 void Runqueue_delete(VALUE self, VALUE fiber);
+int Runqueue_index_of(VALUE self, VALUE fiber);
 void Runqueue_clear(VALUE self);
 long Runqueue_len(VALUE self);
 int Runqueue_empty_p(VALUE self);

data/ext/polyphony/runqueue.c

@@ -74,6 +74,12 @@ void Runqueue_delete(VALUE self, VALUE fiber) {
   runqueue_ring_buffer_delete(&runqueue->entries, fiber);
 }
 
+int Runqueue_index_of(VALUE self, VALUE fiber) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  return runqueue_ring_buffer_index_of(&runqueue->entries, fiber);
+}
+
 void Runqueue_clear(VALUE self) {
   Runqueue_t *runqueue;
   GetRunqueue(self, runqueue);

data/ext/polyphony/runqueue_ring_buffer.c

@@ -80,6 +80,15 @@ void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
   }
 }
 
+int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    unsigned int idx = (buffer->head + i) % buffer->size;
+    if (buffer->entries[idx].fiber == fiber)
+      return i;
+  }
+  return -1;
+}
+
 void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
   buffer->count = buffer->head = buffer->tail = 0;
 }

data/ext/polyphony/runqueue_ring_buffer.h

@@ -27,5 +27,6 @@ void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VAL
 void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value);
 
 void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber);
+int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber);
 
 #endif /* RUNQUEUE_RING_BUFFER_H */

data/ext/polyphony/thread.c

@@ -59,6 +59,18 @@ void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
   }
 }
 
+VALUE Thread_fiber_scheduling_index(VALUE self, VALUE fiber) {
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+
+  return INT2NUM(Runqueue_index_of(runqueue, fiber));
+}
+
+VALUE Thread_fiber_unschedule(VALUE self, VALUE fiber) {
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+  Runqueue_delete(runqueue, fiber);
+  return self;
+}
+
 VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
   schedule_fiber(self, fiber, value, 0);
   return self;
@@ -135,6 +147,8 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "schedule_fiber_with_priority",
     Thread_schedule_fiber_with_priority, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
+  rb_define_method(rb_cThread, "fiber_scheduling_index", Thread_fiber_scheduling_index, 1);
+  rb_define_method(rb_cThread, "fiber_unschedule", Thread_fiber_unschedule, 1);
 
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 

data/lib/polyphony.rb

@@ -14,6 +14,7 @@ Thread.current.backend = Polyphony::Backend.new
 require_relative './polyphony/core/global_api'
 require_relative './polyphony/core/resource_pool'
 require_relative './polyphony/core/sync'
+require_relative './polyphony/core/timer'
 require_relative './polyphony/net'
 require_relative './polyphony/adapters/process'
 
@@ -43,7 +44,7 @@ module Polyphony
       rescue SystemExit
         # fall through to ensure
       rescue Exception => e
-        warn e.full_message
+        STDERR << e.full_message
         exit!
       ensure
         exit_forked_process

data/lib/polyphony/adapters/process.rb

@@ -24,6 +24,8 @@ module Polyphony
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
         Thread.current.backend.waitpid(pid)
+      rescue Errno::ERSCH
+        # ignore
       end
     end
   end

data/lib/polyphony/core/exceptions.rb

@@ -13,6 +13,7 @@ module Polyphony
     def initialize(value = nil)
       @caller_backtrace = caller
       @value = value
+      super
     end
   end
 

data/lib/polyphony/core/global_api.rb

@@ -29,7 +29,7 @@ module Polyphony
       spin do
         sleep interval
         exception = cancel_exception(with_exception)
-        exception.__raising_fiber__ = nil
+        exception.raising_fiber = nil
         fiber.schedule exception
       end
     end

data/lib/polyphony/core/timer.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Polyphony
+  # Implements a common timer for running multiple timeouts
+  class Timer
+    def initialize(resolution:)
+      @fiber = spin_loop(interval: resolution) { update }
+      @timeouts = {}
+    end
+
+    def stop
+      @fiber.stop
+    end
+
+    def sleep(duration)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: duration,
+        target_stamp: now + duration
+      }
+      Thread.current.backend.wait_event(true)
+    ensure
+      @timeouts.delete(fiber)
+    end
+
+    def after(interval, &block)
+      spin do
+        self.sleep interval
+        block.()
+      end
+    end
+
+    def every(interval)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: interval,
+        target_stamp: now + interval,
+        recurring: true
+      }
+      while true
+        Thread.current.backend.wait_event(true)
+        yield
+      end
+    ensure
+      @timeouts.delete(fiber)
+    end
+  
+    def cancel_after(interval, with_exception: Polyphony::Cancel)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: interval,
+        target_stamp: now + interval,
+        exception: with_exception
+      }
+      yield
+    ensure
+      @timeouts.delete(fiber)
+    end
+
+    def move_on_after(interval, with_value: nil)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        interval: interval,
+        target_stamp: now + interval,
+        exception: [Polyphony::MoveOn, with_value]
+      }
+      yield
+    rescue Polyphony::MoveOn => e
+      e.value
+    ensure
+      @timeouts.delete(fiber)
+    end
+
+    def reset
+      record = @timeouts[Fiber.current]
+      return unless record
+  
+      record[:target_stamp] = now + record[:interval]
+    end
+
+    private
+
+    def now
+      ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+
+    def timeout_exception(record)
+      case (exception = record[:exception])
+      when Array
+        exception[0].new(exception[1])
+      when Class
+        exception.new
+      else
+        RuntimeError.new(exception)
+      end
+    end
+
+    def update
+      return if @timeouts.empty?
+
+      @timeouts.each do |fiber, record|
+        next if record[:target_stamp] > now
+
+        value = record[:exception] ? timeout_exception(record) : record[:value]
+        fiber.schedule value
+
+        next unless record[:recurring]
+
+        while record[:target_stamp] <= now
+          record[:target_stamp] += record[:interval]
+        end
+      end
+    end
+  end
+end

data/lib/polyphony/extensions/core.rb

@@ -12,11 +12,11 @@ class ::Exception
     attr_accessor :__disable_sanitized_backtrace__
   end
 
-  attr_accessor :source_fiber, :__raising_fiber__
+  attr_accessor :source_fiber, :raising_fiber
 
   alias_method :orig_initialize, :initialize
   def initialize(*args)
-    @__raising_fiber__ = Fiber.current
+    @raising_fiber = Fiber.current
     orig_initialize(*args)
   end
 
@@ -31,10 +31,10 @@ class ::Exception
   end
 
   def sanitized_backtrace
-    return sanitize(orig_backtrace) unless @__raising_fiber__
+    return sanitize(orig_backtrace) unless @raising_fiber
 
     backtrace = orig_backtrace || []
-    sanitize(backtrace + @__raising_fiber__.caller)
+    sanitize(backtrace + @raising_fiber.caller)
   end
 
   POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))

data/lib/polyphony/extensions/fiber.rb

@@ -245,8 +245,12 @@ module Polyphony
     end
 
     def shutdown_all_children(graceful = false)
-      terminate_all_children(graceful)
-      await_all_children
+      return unless @children
+
+      @children.keys.each do |c|
+        c.terminate(graceful)
+        c.await
+      end
     end
   end
 
@@ -312,6 +316,8 @@ module Polyphony
       @running = false
       inform_dependants(result, uncaught_exception)
     ensure
+      # Prevent fiber from being resumed after terminating
+      @thread.fiber_unschedule(self)
       Thread.current.switch_fiber
     end
 
@@ -319,13 +325,10 @@ module Polyphony
     # the children are shut down, it is returned along with the uncaught_exception
     # flag set. Otherwise, it returns the given arguments.
     def finalize_children(result, uncaught_exception)
-      begin
-        shutdown_all_children
-      rescue Exception => e
-        result = e
-        uncaught_exception = true
-      end
+      shutdown_all_children
       [result, uncaught_exception]
+    rescue Exception => e
+      [e, true]
     end
 
     def inform_dependants(result, uncaught_exception)

data/lib/polyphony/extensions/thread.rb

@@ -41,8 +41,7 @@ class ::Thread
 
   def finalize(result)
     unless Fiber.current.children.empty?
-      Fiber.current.terminate_all_children
-      Fiber.current.await_all_children
+      Fiber.current.shutdown_all_children
     end
     @finalization_mutex.synchronize do
       @terminated = true

data/lib/polyphony/net.rb

@@ -8,10 +8,7 @@ module Polyphony
   module Net
     class << self
       def tcp_connect(host, port, opts = {})
-        socket = ::Socket.new(:INET, :STREAM).tap do |s|
-          addr = ::Socket.sockaddr_in(port, host)
-          s.connect(addr)
-        end
+        socket = TCPSocket.new(host, port)
         if opts[:secure_context] || opts[:secure]
           secure_socket(socket, opts[:secure_context], opts.merge(host: host))
         else
@@ -23,7 +20,7 @@ module Polyphony
         host ||= '0.0.0.0'
         raise 'Port number not specified' unless port
 
-        socket = socket_from_options(host, port, opts)
+        socket = listening_socket_from_options(host, port, opts)
         if opts[:secure_context] || opts[:secure]
           secure_server(socket, opts[:secure_context], opts)
         else
@@ -31,7 +28,7 @@ module Polyphony
         end
       end
 
-      def socket_from_options(host, port, opts)
+      def listening_socket_from_options(host, port, opts)
         ::Socket.new(:INET, :STREAM).tap do |s|
           s.reuse_addr if opts[:reuse_addr]
           s.dont_linger if opts[:dont_linger]

data/lib/polyphony/version.rb

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

data/test/helper.rb

@@ -57,8 +57,7 @@ class MiniTest::Test
 
   def teardown
     # trace "* teardown #{self.name}"
-    Fiber.current.terminate_all_children
-    Fiber.current.await_all_children
+    Fiber.current.shutdown_all_children
     Fiber.current.instance_variable_set(:@auto_watcher, nil)
   rescue => e
     puts e

data/test/test_backend.rb

@@ -100,6 +100,31 @@ class BackendTest < MiniTest::Test
     assert_equal [:ready, 'foo', 'bar', :done], buf
   end
 
+  def test_read_loop_terminate
+    i, o = IO.pipe
+
+    buf = []
+    parent = spin do
+      f = spin do
+        buf << :ready
+        @backend.read_loop(i) { |d| buf << d }
+        buf << :done
+      end
+      suspend
+    end
+
+    # writing always causes snoozing
+    o << 'foo'
+    sleep 0.01
+    o << 'bar'
+    sleep 0.01
+
+    parent.stop
+
+    parent.await
+    assert_equal [:ready, 'foo', 'bar'], buf
+  end
+
   def test_accept_loop
     server = TCPServer.new('127.0.0.1', 1234)
 

data/test/test_fiber.rb

@@ -349,6 +349,22 @@ class FiberTest < MiniTest::Test
     assert_equal [:foo, :terminate], buffer
   end
 
+  CMD_TERMINATE_MAIN_FIBER = <<~BASH
+    ruby -rbundler/setup -rpolyphony -e"spin { sleep 0.1; Thread.current.main_fiber.terminate }; begin; sleep; rescue Polyphony::Terminate; STDOUT << 'terminated'; end" 2>&1
+  BASH
+
+  CMD_TERMINATE_CHILD_FIBER = <<~BASH
+    ruby -rbundler/setup -rpolyphony -e"f = spin { sleep }; spin { sleep 0.1; f.terminate }; f.await" 2>&1
+  BASH
+
+  def test_terminate_main_fiber
+    output = `#{CMD_TERMINATE_CHILD_FIBER}`
+    assert_equal '', output
+
+    output = `#{CMD_TERMINATE_MAIN_FIBER}`
+    assert_equal 'terminated', output
+  end
+
   def test_interrupt_timer
     result = []
     f = Fiber.current.spin do
@@ -639,7 +655,6 @@ class FiberTest < MiniTest::Test
         i.close
         f.await
       rescue Exception => e
-        trace e
         o << e.class.name
         o.close
       end
@@ -1039,6 +1054,21 @@ class RestartTest < MiniTest::Test
   end
 end
 
+class ChildrenTerminationTest < MiniTest::Test
+  def test_shutdown_all_children
+    f = spin do
+      1000.times { spin { suspend } }
+      suspend
+    end
+
+    snooze
+    assert_equal 1000, f.children.size
+
+    f.shutdown_all_children
+    assert_equal 0, f.children.size
+  end
+end
+
 class GracefulTerminationTest < MiniTest::Test
   def test_graceful_termination
     buffer = []

data/test/test_io.rb

@@ -110,7 +110,7 @@ class IOTest < MiniTest::Test
     assert_equal [], buf
     
     o << "ulous\n"
-    10.times { snooze }
+    15.times { snooze }
     assert_equal ["fabulous\n"], buf
 
     o.close

data/test/test_signal.rb

@@ -46,8 +46,7 @@ class SignalTrapTest < Minitest::Test
       end.await
     rescue Interrupt
       o.puts "3 - interrupted"
-      Fiber.current.terminate_all_children
-      Fiber.current.await_all_children
+      Fiber.current.shutdown_all_children
     ensure
       o.close
     end

data/test/test_socket.rb

@@ -63,14 +63,15 @@ class HTTPClientTest < MiniTest::Test
   require 'json'
 
   def test_http
-    res = HTTParty.get('http://worldtimeapi.org/api/timezone/Europe/Paris')
+    res = HTTParty.get('http://ipinfo.io/')
+
     response = JSON.load(res.body)
-    assert_equal "CET", response['abbreviation']
+    assert_equal 'https://ipinfo.io/missingauth', response['readme']
   end
 
   def test_https
-    res = HTTParty.get('https://worldtimeapi.org/api/timezone/Europe/Paris')
+    res = HTTParty.get('https://ipinfo.io/')
     response = JSON.load(res.body)
-    assert_equal "CET", response['abbreviation']
+    assert_equal 'https://ipinfo.io/missingauth', response['readme']
   end
 end

data/test/test_timer.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TimerMoveOnAfterTest < MiniTest::Test
+  def setup
+    @timer = Polyphony::Timer.new(resolution: 0.01)
+  end
+
+  def teardown
+    @timer.stop
+  end
+
+  def test_timer_move_on_after
+    t0 = Time.now
+    v = @timer.move_on_after(0.1) do
+      sleep 1
+      :foo
+    end
+    t1 = Time.now
+
+    assert_in_range 0.1..0.15, t1 - t0
+    assert_nil v
+  end
+
+  def test_timer_move_on_after_with_value
+    t0 = Time.now
+    v = @timer.move_on_after(0.01, with_value: :bar) do
+      sleep 1
+      :foo
+    end
+    t1 = Time.now
+
+    assert_in_range 0.01..0.025, t1 - t0
+    assert_equal :bar, v
+  end
+
+  def test_timer_move_on_after_with_reset
+    t0 = Time.now
+    v = @timer.move_on_after(0.01, with_value: :moved_on) do
+      sleep 0.007
+      @timer.reset
+      sleep 0.007
+      @timer.reset
+      sleep 0.007
+      nil
+    end
+    t1 = Time.now
+
+    assert_nil v
+    assert_in_range 0.015..0.03, t1 - t0
+  end
+end
+
+class TimerCancelAfterTest < MiniTest::Test
+  def setup
+    @timer = Polyphony::Timer.new(resolution: 0.01)
+  end
+
+  def teardown
+    @timer.stop
+  end
+
+  def test_timer_cancel_after
+    t0 = Time.now
+
+    assert_raises Polyphony::Cancel do
+      @timer.cancel_after(0.01) do
+        sleep 1
+        :foo
+      end
+    end
+    t1 = Time.now
+    assert_in_range 0.01..0.03, t1 - t0
+  end
+
+  def test_timer_cancel_after_with_reset
+    t0 = Time.now
+    @timer.cancel_after(0.01) do
+      sleep 0.007
+      @timer.reset
+      sleep 0.007
+    end
+    t1 = Time.now
+    assert_in_range 0.013..0.024, t1 - t0
+  end
+
+  class CustomException < Exception
+  end
+
+  def test_timer_cancel_after_with_custom_exception
+    assert_raises CustomException do
+      @timer.cancel_after(0.01, with_exception: CustomException) do
+        sleep 1
+        :foo
+      end
+    end
+
+    begin
+      err = nil
+      @timer.cancel_after(0.01, with_exception: [CustomException, 'custom message']) do
+        sleep 1
+        :foo
+      end
+    rescue Exception => err
+    ensure
+      assert_kind_of CustomException, err
+      assert_equal 'custom message', err.message
+    end
+
+
+    begin
+      e = nil
+      @timer.cancel_after(0.01, with_exception: 'foo') do
+        sleep 1
+        :foo
+      end
+    rescue => e
+    ensure
+      assert_kind_of RuntimeError, e
+      assert_equal 'foo', e.message
+    end
+  end
+end
+
+class TimerMiscTest < MiniTest::Test
+  def setup
+    @timer = Polyphony::Timer.new(resolution: 0.001)
+    sleep 0
+  end
+  
+  def teardown
+    @timer.stop
+  end
+    
+  def test_timer_after
+    buffer = []
+    f = @timer.after(0.01) { buffer << 2 }
+    assert_kind_of Fiber, f
+    snooze
+    assert_equal [], buffer
+    sleep 0.1
+    p :post_sleep
+    assert_equal [2], buffer
+  end
+
+  def test_timer_every
+    buffer = []
+    t0 = Time.now
+    f = spin do
+      @timer.every(0.01) { buffer << 1 }
+    end
+    sleep 0.05
+    f.stop
+    assert_in_range 4..6, buffer.size
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.48.0
+  version: 0.50.1
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2021-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -353,6 +353,7 @@ files:
 - examples/core/forking.rb
 - examples/core/handling-signals.rb
 - examples/core/interrupt.rb
+- examples/core/nested.rb
 - examples/core/pingpong.rb
 - examples/core/recurrent-timer.rb
 - examples/core/resource_delegate.rb
@@ -360,6 +361,8 @@ files:
 - examples/core/spin_error_backtrace.rb
 - examples/core/supervise-process.rb
 - examples/core/supervisor.rb
+- examples/core/suspend.rb
+- examples/core/terminate_main_fiber.rb
 - examples/core/thread-sleep.rb
 - examples/core/thread_pool.rb
 - examples/core/throttling.rb
@@ -476,6 +479,7 @@ files:
 - lib/polyphony/core/sync.rb
 - lib/polyphony/core/thread_pool.rb
 - lib/polyphony/core/throttler.rb
+- lib/polyphony/core/timer.rb
 - lib/polyphony/extensions/core.rb
 - lib/polyphony/extensions/debug.rb
 - lib/polyphony/extensions/fiber.rb
@@ -510,6 +514,7 @@ files:
 - test/test_thread.rb
 - test/test_thread_pool.rb
 - test/test_throttler.rb
+- test/test_timer.rb
 - test/test_trace.rb
 homepage: https://digital-fabric.github.io/polyphony
 licenses: