polyphony 0.79 → 0.81.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34ed5a7685a8986f1fe5fd6cd714ee049633952746ecb8bced1aee73553c6c99
-  data.tar.gz: 03ded408e8849a921d0cfbbe1a232c5cea83cfbd58710efade4900f6240f511c
+  metadata.gz: f4584f87975e018fe58887f4c6786bfe8c631a7d2fed3717e6822d72741fcc92
+  data.tar.gz: 9353ed759d256a035619d0b18dc53569fba6fdbb0709d79defb585fbf5f63f5a
 SHA512:
-  metadata.gz: 91fe5a0979c0158315e942bba88f563a47926e78ad3da0ff8e483ee91aff1482af1f2fc3e3aa4cacd49e787531627bfc3295d45439e99d8400b4736b1a749443
-  data.tar.gz: 3c1eaaccec661c4f3e4c07853fbaaaab19222837d5ac25b4098856bd1b1367833cbc35a58602fb9c30ff8e7cd63d04f79206bf07438a1e842eb86871c8036063
+  metadata.gz: c4d2d6e7457e49b4803b44e2125b54465a1104635b3d0a1d127538335401eeca6612095a2dcde9b6e149d939d15c6de2a1cbdf892a114535a5f0bd00ea1936e8
+  data.tar.gz: 5f4eb0a66dec6614d542d2c89cad791e2eb7e27ab9ae74f6bf60c8d4bd9831a098f531be6a619d4f13662631e86f1ac6ddc7bf5bf5f005b8926a4dfc3c7e43ef

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 0.81.1 2022-03-03
+
+- Fix `Backend_recv` regression
+
+## 0.81 2022-03-03
+
+- Restore public visibility for `Polyphony::Process.kill_process`
+- Restore public visibility for `Polyphony::Net.setup_alpn`
+
+## 0.80 2022-02-28
+
+- Prevent reentry into `trace_proc`
+- Rename `__parser_read_method__` to `__read_method__`
+- Rename `ResourcePool#preheat!` to `#fill`.
+- Remove ability to use `#cancel_after` or `#move_on` without a block
+- Add #move_on alias to `Fiber#interrupt`
+- Allow specifying exception in `Fiber#cancel`
+- Remove deprecated `Polyphony::Channel` class
+
 ## 0.79 2022-02-19
 
 - Overhaul trace events system (#73)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.79)
+    polyphony (0.81.1)
 
 GEM
   remote: https://rubygems.org/
@@ -60,6 +60,7 @@ GEM
     unicode-display_width (1.8.0)
 
 PLATFORMS
+  ruby
   universal-darwin
   universal-freebsd
   universal-linux

data/examples/core/raw_buffer_test.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+puts '* pre'
+Polyphony.backend_test(STDOUT, "Hello, world!\n")
+puts '* post'

data/examples/core/zlib_stream.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'zlib'
+
+r, w = IO.pipe
+writer = Zlib::GzipWriter.new(w)
+
+writer << 'chunk'
+writer.flush
+p pos: writer.pos
+# w.close
+writer.close
+
+p r.read

data/ext/polyphony/backend_common.c

@@ -17,6 +17,7 @@ inline void backend_base_initialize(struct Backend_base *base) {
   base->idle_gc_last_time = 0;
   base->idle_proc = Qnil;
   base->trace_proc = Qnil;
+  base->in_trace_proc = 0;
 }
 
 inline void backend_base_finalize(struct Backend_base *base) {
@@ -137,7 +138,7 @@ inline void backend_base_unpark_fiber(struct Backend_base *base, VALUE fiber) {
 }
 
 inline void backend_trace(struct Backend_base *base, int argc, VALUE *argv) {
-  if (base->trace_proc == Qnil) return;
+  if (base->trace_proc == Qnil || base->in_trace_proc) return;
 
   rb_funcallv(base->trace_proc, ID_call, argc, argv);
 }

data/ext/polyphony/backend_common.h

@@ -32,6 +32,7 @@ struct Backend_base {
   double idle_gc_last_time;
   VALUE idle_proc;
   VALUE trace_proc;
+  unsigned int in_trace_proc;
 };
 
 void backend_base_initialize(struct Backend_base *base);
@@ -46,8 +47,12 @@ void backend_trace(struct Backend_base *base, int argc, VALUE *argv);
 struct backend_stats backend_base_stats(struct Backend_base *base);
 
 // tracing
-#define SHOULD_TRACE(base) ((base)->trace_proc != Qnil)
-#define TRACE(base, ...)  rb_funcall((base)->trace_proc, ID_call, __VA_ARGS__)
+#define SHOULD_TRACE(base) ((base)->trace_proc != Qnil && !(base)->in_trace_proc)
+#define TRACE(base, ...) { \
+  (base)->in_trace_proc = 1; \
+  rb_funcall((base)->trace_proc, ID_call, __VA_ARGS__); \
+  (base)->in_trace_proc = 0; \
+}
 #define COND_TRACE(base, ...) if (SHOULD_TRACE(base)) { TRACE(base, __VA_ARGS__); }
 
 

data/ext/polyphony/backend_io_uring.c

@@ -102,6 +102,24 @@ static VALUE Backend_initialize(VALUE self) {
   return self;
 }
 
+static inline struct io_buffer get_io_buffer(VALUE in) {
+  if (FIXNUM_P(in)) {
+    struct raw_buffer *raw = (struct raw_buffer *)(FIX2LONG(in));
+    return (struct io_buffer){ raw->base, raw->size, 1 };
+  }
+  return (struct io_buffer){ RSTRING_PTR(in), RSTRING_LEN(in), 0 };
+}
+
+static inline VALUE coerce_io_string_or_buffer(VALUE buf) {
+  switch (TYPE(buf)) {
+    case T_STRING:
+    case T_FIXNUM:
+      return buf;
+    default:
+      return StringValue(buf);
+  }
+}
+
 VALUE Backend_finalize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -332,23 +350,37 @@ VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
 VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos) {
   Backend_t *backend;
   rb_io_t *fptr;
-  long dynamic_len = length == Qnil;
-  long buffer_size = dynamic_len ? 4096 : NUM2INT(length);
+  struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
-  int shrinkable;
-  char *buf;
+  int shrinkable_string = 0;
+  int expandable_buffer = 0;
   long total = 0;
   int read_to_eof = RTEST(to_eof);
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
-
-  if (str != Qnil) {
-    int current_len = RSTRING_LEN(str);
-    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
+  if (buffer.raw) {
+    if (buf_pos < 0 || buf_pos > buffer.size) buf_pos = buffer.size;
+    buffer.base += buf_pos;
+    buffer.size -= buf_pos;
+  }
+  else {
+    expandable_buffer = length == Qnil;
+    long expected_read_length = expandable_buffer ? 4096 : FIX2INT(length);
+    long string_cap = rb_str_capacity(str);
+    if (buf_pos < 0 || buf_pos > buffer.size) buf_pos = buffer.size;
+
+    if (string_cap < expected_read_length + buf_pos) {
+      shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
+      buffer.base = RSTRING_PTR(str) + buf_pos;
+      buffer.size = expected_read_length;
+    }
+    else {
+      buffer.base += buf_pos;
+      buffer.size = string_cap - buf_pos;
+      if (buffer.size > expected_read_length)
+        buffer.size = expected_read_length;
+    }
   }
-  else buf_pos = 0;
-  shrinkable = io_setstrbuf(&str, buf_pos + buffer_size);
-  buf = RSTRING_PTR(str) + buf_pos;
 
   GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
@@ -364,7 +396,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
     int result;
     int completed;
     
-    io_uring_prep_read(sqe, fptr->fd, buf, buffer_size - total, -1);
+    io_uring_prep_read(sqe, fptr->fd, buffer.base, buffer.size, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -383,26 +415,32 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       total += result;
       if (!read_to_eof) break;
 
-      if (total == buffer_size) {
-        if (!dynamic_len) break;
+      if (result == buffer.size) {
+        if (!expandable_buffer) break;
 
-        // resize buffer
-        rb_str_resize(str, buf_pos + total);
-        rb_str_modify_expand(str, buffer_size);
-        buf = RSTRING_PTR(str) + buf_pos + total;
-        shrinkable = 0;
-        buffer_size += buffer_size;
+        // resize buffer to double its capacity
+        rb_str_resize(str, total + buf_pos);
+        rb_str_modify_expand(str, rb_str_capacity(str));
+        shrinkable_string = 0;
+        buffer.base = RSTRING_PTR(str) + total + buf_pos;
+        buffer.size = rb_str_capacity(str) - total - buf_pos;
+      }
+      else {
+        buffer.base += result;
+        buffer.size -= result;
+        if (!buffer.size) break;
       }
-      else buf += result;
     }
   }
 
-  io_set_read_length(str, buf_pos + total, shrinkable);
-  io_enc_str(str, fptr);
+  if (!buffer.raw) {
+    io_set_read_length(str, buf_pos + total, shrinkable_string);
+    io_enc_str(str, fptr);
+  }
 
   if (!total) return Qnil;
 
-  return str;
+  return buffer.raw ? INT2FIX(total) : str;
 }
 
 VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
@@ -514,9 +552,9 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   rb_io_t *fptr;
   VALUE underlying_io;
-  char *buf = StringValuePtr(str);
-  long len = RSTRING_LEN(str);
-  long left = len;
+
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.size;
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -532,7 +570,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     int result;
     int completed;
 
-    io_uring_prep_write(sqe, fptr->fd, buf, left, 0);
+    io_uring_prep_write(sqe, fptr->fd, buffer.base, left, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -546,12 +584,13 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buf += result;
+      buffer.base += result;
+      buffer.size -= result;
       left -= result;
     }
   }
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.size);
 }
 
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {

data/ext/polyphony/polyphony.c

@@ -118,6 +118,12 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
   return Backend_write_m(argc, argv, BACKEND());
 }
 
+VALUE Polyphony_backend_test(VALUE self, VALUE io, VALUE str) {
+  struct raw_buffer buffer = { RSTRING_PTR(str), RSTRING_LEN(str) };
+  VALUE args[2] = { io, LONG2FIX((long)&buffer) };
+  return Polyphony_backend_write(2, args, self);
+}
+
 // VALUE Polyphony_backend_close(VALUE self, VALUE io) {
 //   return Backend_close(BACKEND(), io);
 // }
@@ -149,6 +155,8 @@ void Init_Polyphony() {
   // rb_define_singleton_method(mPolyphony, "backend_close", Polyphony_backend_close, 1);
   rb_define_singleton_method(mPolyphony, "backend_verify_blocking_mode", Backend_verify_blocking_mode, 2);
 
+  rb_define_singleton_method(mPolyphony, "backend_test", Polyphony_backend_test, 2);
+
   rb_define_global_function("snooze", Polyphony_snooze, 0);
   rb_define_global_function("suspend", Polyphony_suspend, 0);
 

data/ext/polyphony/polyphony.h

@@ -135,4 +135,15 @@ VALUE Thread_switch_fiber(VALUE thread);
 
 VALUE Polyphony_snooze(VALUE self);
 
+struct raw_buffer {
+  char *base;
+  int size;
+};
+
+struct io_buffer {
+  char *base;
+  int size;
+  int raw;
+};
+
 #endif /* POLYPHONY_H */

data/lib/polyphony/adapters/fs.rb

@@ -6,6 +6,8 @@ require_relative '../core/thread_pool'
 
 ::File.singleton_class.instance_eval do
   alias_method :orig_stat, :stat
+
+  # Offloads `File.stat` to the default thread pool.
   def stat(path)
     ThreadPool.process { orig_stat(path) }
   end
@@ -13,6 +15,8 @@ end
 
 ::IO.singleton_class.instance_eval do
   alias_method :orig_read, :read
+
+  # Offloads `IO.read` to the default thread pool.
   def read(path)
     ThreadPool.process { orig_read(path) }
   end

data/lib/polyphony/adapters/process.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
 module Polyphony
-  # Process patches
+  # Process extensions
   module Process
     class << self
+
+      # Watches a forked or spawned process, waiting for it to terminate. If
+      # `cmd` is given it is spawned, otherwise the process is forked with the
+      # given block.
+      # 
+      # If the operation is interrupted for any reason, the spawned or forked
+      # process is killed.
+      #
+      # @param cmd [String, nil] command to spawn
+      # @param &block [Proc] block to fork
+      # @return [void]
       def watch(cmd = nil, &block)
         terminated = nil
         pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
@@ -21,6 +32,8 @@ module Polyphony
         kill_and_await(-9, pid)
       end
 
+      private
+
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
         Polyphony.backend_waitpid(pid)

data/lib/polyphony/adapters/redis.rb

@@ -7,6 +7,10 @@ require 'hiredis/reader'
 
 # Polyphony-based Redis driver
 class Polyphony::RedisDriver
+
+  # Connects to a Redis server using the given config.
+  #
+  # @return [TCPSocket, UNIXSocket, SSLSocket] client connectio
   def self.connect(config)
     raise 'unix sockets not supported' if config[:scheme] == 'unix'
 
@@ -20,28 +24,49 @@ class Polyphony::RedisDriver
     # connection.connect(config[:host], config[:port], connect_timeout)
   end
 
+  # Initializes a Redis client connection.
+  #
+  # @param host [String] hostname
+  # @param port [Integer] port number
   def initialize(host, port)
     @connection = Polyphony::Net.tcp_connect(host, port)
     @reader = ::Hiredis::Reader.new
   end
 
+  # Returns true if connected to server.
+  #
+  # @return [bool] is connected to server
   def connected?
     @connection && !@connection.closed?
   end
 
+  # Sets a timeout for the connection.
+  #
+  # @return [void]
   def timeout=(timeout)
     # ignore timeout for now
   end
 
+  # Disconnects from the server.
+  #
+  # @return [void]
   def disconnect
     @connection.close
     @connection = nil
   end
 
+  # Sends a command to the server.
+  #
+  # @param command [Array] Redis command
+  # @return [void]
   def write(command)
     @connection.write(format_command(command))
   end
 
+  # Formats a command for sending to server.
+  #
+  # @param args [Array] command
+  # @return [String] formatted command
   def format_command(args)
     args = args.flatten
     (+"*#{args.size}\r\n").tap do |s|
@@ -52,6 +77,9 @@ class Polyphony::RedisDriver
     end
   end
 
+  # Reads from the connection, feeding incoming data to the parser.
+  #
+  # @return [void]
   def read
     reply = @reader.gets
     return reply if reply

data/lib/polyphony/adapters/sequel.rb

@@ -4,14 +4,23 @@ require_relative '../../polyphony'
 require 'sequel'
 
 module Polyphony
+  
   # Sequel ConnectionPool that delegates to Polyphony::ResourcePool.
   class FiberConnectionPool < Sequel::ConnectionPool
+  
+    # Initializes the connection pool.
+    #
+    # @param db [any] db to connect to
+    # @opts [Hash] connection pool options
     def initialize(db, opts = OPTS)
       super
       max_size = Integer(opts[:max_connections] || 4)
       @pool = Polyphony::ResourcePool.new(limit: max_size) { make_new(:default) }
     end
 
+    # Holds a connection from the pool, passing it to the given block.
+    #
+    # @return [any] block's return value
     def hold(_server = nil)
       @pool.acquire do |conn|
         yield conn
@@ -23,16 +32,25 @@ module Polyphony
       end
     end
 
+    # Returns the pool's size.
+    #
+    # @return [Integer] size of pool
     def size
       @pool.size
     end
 
+    # Returns the pool's maximal size.
+    #
+    # @return [Integer] maximum pool size
     def max_size
       @pool.limit
     end
 
+    # Fills pool and preconnects all db instances in pool.
+    #
+    # @return [void]
     def preconnect(_concurrent = false)
-      @pool.preheat!
+      @pool.fill!
     end
   end