polyphony 0.93 → 0.95

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb7ee7e43bec0bfffbcff8c78cdcdcc7d93f4283014bd9caebfcd94c3da6b96f
-  data.tar.gz: add731011308495bc5ec0f4f5bc1f7152cfaa1dddd0f53f8027b4a64ea0ba08f
+  metadata.gz: 554854ea3a7b1bc8dd555b24283e42019bb7bfb91953cd0b3e6ac49c9c59198b
+  data.tar.gz: 59a88ec85837e68ed50594ee892c814dee9e15ba19b4392d50436fb0b51b1d82
 SHA512:
-  metadata.gz: 108f69257c57caab18780bad60dbd6bed240dd8a45e05e54e54cbb4b90d31382c10c8f25d3c8bb92f8753e134054782eb4b9d47e79ec79da8938ac4c3d14f4a6
-  data.tar.gz: be78ce7748655d18014074fbb95bedecccab8af94b53e7a2db797cdb503a4f67c25a81b9e9b9154d6e1187efbc3c5fd1b4454e604ad068d51a0c3f411ee7c8ea
+  metadata.gz: 3637e9af046327dd642bb555224e4dd36169824a698b1176f57ebeb309e61d1ac6c50d2423c8ab2ac72abf9d8e9184f37ebf9ca8343032d7e40b3244d99f8ca7
+  data.tar.gz: 27fca71574396f73e783630691cbda094488ab19128c884ca2fdafd570b0df920f083e46750455a656c0f26c9acc6f11783634cb7d43b23f2689f000ee0c67ea

data/.github/workflows/test.yml

@@ -8,7 +8,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest]
-        ruby: ['2.7', '3.0', '3.1', 'head']
+        ruby: ['3.0', '3.1', '3.2']
 
     name: >-
       ${{matrix.os}}, ${{matrix.ruby}}
@@ -20,7 +20,7 @@ jobs:
 
     steps:
     - name: Setup machine
-      uses: actions/checkout@v1
+      uses: actions/checkout@v3
     - name: Setup Ruby
       uses: ruby/setup-ruby@v1
       with:

data/.gitignore

@@ -42,9 +42,9 @@ build-iPhoneSimulator/
 
 # for a library or gem, you might want to ignore these files since the code is
 # intended to run in multiple environments; otherwise, check them in:
-# Gemfile.lock
-# .ruby-version
-# .ruby-gemset
+Gemfile.lock
+.ruby-version
+.ruby-gemset
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.95 2023-01-16
+
+- Remove support for Ruby 2.7
+- Add support for explicit Enumerator (external enumeration) (#93)
+- Fix `Socket#readpartial`
+- Fix `receive_all_pending` docs (#92)
+- Improve linux kernel version detection
+- Update liburing
+- Always reset SQE user data in io_uring backend
+
+## 0.94 2022-10-03
+
+- Fix linux kernel version detection (#89)
+
 ## 0.93 2022-04-05
 
 - Add support for IO::Buffer in Ruby 3.1 (#80)

data/docs/api-reference/fiber.md

@@ -212,7 +212,7 @@ spin { Fiber.current.parent << 'hello from child' }
 message = receive #=> 'hello from child'
 ```
 
-### #receive_pending → [*object]
+### #receive_all_pending → [*object]
 
 Returns all messages currently in the mailbox, emptying the mailbox. This method
 does not block if no the mailbox is already empty. This method may be used to
@@ -225,7 +225,7 @@ worker = spin do
     handle_job(job)
   end
 rescue Polyphony::Terminate => e
-  receive_pending.each { |job| handle_job(job) }
+  receive_all_pending.each { |job| handle_job(job) }
 end
 ```
 

data/docs/api-reference/object.md

@@ -63,9 +63,9 @@ result #=> 'bar'
 
 Shortcut for `Fiber.current.receive`
 
-### #receive_pending → [*object]
+### #receive_all_pending → [*object]
 
-Shortcut for `Fiber.current.receive_pending`
+Shortcut for `Fiber.current.receive_all_pending`
 
 ### #sleep(duration = nil) → fiber
 
@@ -96,4 +96,4 @@ returns. Otherwise, the loop is infinite (unless an exception is raised).
 ```ruby
 # twice a second
 throttled_loop(2) { puts 'hello world' }
-```
+```

data/docs/main-concepts/exception-handling.md

@@ -229,7 +229,7 @@ def do_work
   end
 rescue Polyphony::Terminate
   # We still need to handle any pending request
-  receive_pending.each { handle_req(req) }
+  receive_all_pending.each { handle_req(req) }
 end
 
 # on the main fiber
@@ -288,4 +288,4 @@ loop.
 To ensure proper thread termination, including the termination of all the
 thread's fibers, Polyphony patches the `Thread#kill` and `Thread#raise` methods
 to schedule the thread's main fiber with the corresponding exceptions, thus
-ensuring an orderly termination or exception handling.
+ensuring an orderly termination or exception handling.

data/examples/pipes/echo_server.rb

@@ -17,4 +17,4 @@ def handle_client(conn)
 end
 
 puts "Serving echo on port 1234..."
-TCPServer.new('127.0.0.1', 1234).accept_loop { |c| handle_client(c) }
+TCPServer.new('0.0.0.0', 1234).accept_loop { |c| handle_client(c) }

data/examples/pipes/http_server.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  gem 'h1p'
+  gem 'polyphony', path: '.'
+end
+
+require 'polyphony'
+require 'h1p'
+
+def handle_client(conn)
+  spin do
+    parser = H1P::Parser.new(conn, :server)
+    
+    while true # assuming persistent connection
+      headers = parser.parse_headers
+      break unless headers
+
+      parser.read_body unless parser.complete?
+
+      conn << "HTTP/1.1 200 OK\r\nContent-Length: 14\r\n\r\nHello, world!\n"
+    end
+  rescue H1P::Error
+    puts 'Got invalid request, closing connection...'
+  ensure
+    conn.close
+  end
+end
+
+puts "Serving HTTP on port 1234..."
+TCPServer.new('0.0.0.0', 1234).accept_loop { |c| handle_client(c) }

data/ext/polyphony/backend_common.c

@@ -280,7 +280,7 @@ inline void rectify_io_file_pos(rb_io_t *fptr) {
   }
 }
 
-inline double current_time() {
+inline double current_time(void) {
   struct timespec ts;
   double t;
   uint64_t ns;
@@ -292,7 +292,7 @@ inline double current_time() {
   return t / 1e9;
 }
 
-inline uint64_t current_time_ns() {
+inline uint64_t current_time_ns(void) {
   struct timespec ts;
   uint64_t ns;
 
@@ -439,7 +439,7 @@ VALUE Backend_verify_blocking_mode(VALUE self, VALUE io, VALUE blocking) {
   return self;
 }
 
-void backend_setup_stats_symbols() {
+void backend_setup_stats_symbols(void) {
   SYM_runqueue_size       = ID2SYM(rb_intern("runqueue_size"));
   SYM_runqueue_length     = ID2SYM(rb_intern("runqueue_length"));
   SYM_runqueue_max_length = ID2SYM(rb_intern("runqueue_max_length"));
@@ -479,10 +479,10 @@ int backend_getaddrinfo(VALUE host, VALUE port, struct sockaddr **ai_addr) {
   return addrinfo_result->ai_addrlen;
 }
 
-struct io_buffer get_io_buffer(VALUE in, int rw) {
+inline struct backend_buffer_spec backend_get_buffer_spec(VALUE in, int rw) {
   if (FIXNUM_P(in)) {
-    struct raw_buffer *raw = FIX2PTR(in);
-    return (struct io_buffer){ raw->ptr, raw->len, 1 };
+    struct buffer_spec *spec = FIX2PTR(in);
+    return (struct backend_buffer_spec){ spec->ptr, spec->len, 1 };
   }
 
   #ifdef HAVE_RUBY_IO_BUFFER_H
@@ -493,11 +493,56 @@ struct io_buffer get_io_buffer(VALUE in, int rw) {
       rb_io_buffer_get_bytes_for_reading(in, (const void **)&ptr, &len);
     else
       rb_io_buffer_get_bytes_for_writing(in, &ptr, &len);
-    return (struct io_buffer){ ptr, len, 1 };
+    return (struct backend_buffer_spec){ ptr, len, 1 };
   }
   #endif
 
-  return (struct io_buffer){ (unsigned char *)RSTRING_PTR(in), RSTRING_LEN(in), 0 };
+  return (struct backend_buffer_spec){ (unsigned char *)RSTRING_PTR(in), RSTRING_LEN(in), 0 };
+}
+
+inline void backend_prepare_read_buffer(VALUE buffer, VALUE length, struct backend_buffer_spec *buffer_spec, int pos) {
+  buffer_spec->pos = pos;
+  buffer_spec->expandable = 0;
+  buffer_spec->shrinkable = 0;
+  if (buffer_spec->raw) {
+    if (buffer_spec->pos < 0 || buffer_spec->pos > buffer_spec->len)
+      buffer_spec->pos = buffer_spec->len;
+    buffer_spec->ptr += buffer_spec->pos;
+    buffer_spec->len -= buffer_spec->pos;
+  }
+  else {
+    buffer_spec->expandable = length == Qnil;
+    long expected_read_length = buffer_spec->expandable ? 4096 : FIX2INT(length);
+    long string_cap = rb_str_capacity(buffer);
+    if (buffer_spec->pos < 0 || buffer_spec->pos > buffer_spec->len)
+      buffer_spec->pos = buffer_spec->len;
+
+    if (string_cap < expected_read_length + buffer_spec->pos) {
+      buffer_spec->shrinkable = io_setstrbuf(&buffer, expected_read_length + buffer_spec->pos);
+      buffer_spec->ptr = (unsigned char *)RSTRING_PTR(buffer) + buffer_spec->pos;
+      buffer_spec->len = expected_read_length;
+    }
+    else {
+      buffer_spec->ptr += buffer_spec->pos;
+      buffer_spec->len = string_cap - buffer_spec->pos;
+      if (buffer_spec->len > expected_read_length)
+        buffer_spec->len = expected_read_length;
+    }
+  }
+}
+
+inline void backend_grow_string_buffer(VALUE buffer, struct backend_buffer_spec *buffer_spec, int total) {
+  // resize buffer to double its capacity
+  rb_str_resize(buffer, total + buffer_spec->pos);
+  rb_str_modify_expand(buffer, rb_str_capacity(buffer));
+  buffer_spec->shrinkable = 0;
+  buffer_spec->ptr = (unsigned char *)RSTRING_PTR(buffer) + total + buffer_spec->pos;
+  buffer_spec->len = rb_str_capacity(buffer) - total - buffer_spec->pos;
+}
+
+inline void backend_finalize_string_buffer(VALUE buffer, struct backend_buffer_spec *buffer_spec, int total, rb_io_t *fptr) {
+  io_set_read_length(buffer, buffer_spec->pos + total, buffer_spec->shrinkable);
+  if (fptr) io_enc_str(buffer, fptr);
 }
 
 VALUE coerce_io_string_or_buffer(VALUE buf) {

data/ext/polyphony/backend_common.h

@@ -55,23 +55,31 @@ struct backend_stats backend_base_stats(struct Backend_base *base);
 }
 #define COND_TRACE(base, ...) if (SHOULD_TRACE(base)) { TRACE(base, __VA_ARGS__); }
 
-// raw buffers
+// buffers
 
-struct raw_buffer {
+struct buffer_spec {
   unsigned char *ptr;
   int len;
 };
 
-struct io_buffer {
+struct backend_buffer_spec {
   unsigned char *ptr;
   int len;
   int raw;
+  int pos;
+  int expandable:1;
+  int shrinkable:1;
+  int reserved:30;
 };
 
 #define FIX2PTR(v) ((void *)(FIX2LONG(v)))
 #define PTR2FIX(p) LONG2FIX((long)p)
 
-struct io_buffer get_io_buffer(VALUE in, int rw);
+struct backend_buffer_spec backend_get_buffer_spec(VALUE in, int rw);
+void backend_prepare_read_buffer(VALUE buffer, VALUE length, struct backend_buffer_spec *buffer_spec, int pos);
+void backend_grow_string_buffer(VALUE buffer, struct backend_buffer_spec *buffer_spec, int total);
+void backend_finalize_string_buffer(VALUE buffer, struct backend_buffer_spec *buffer_spec, int total, rb_io_t *fptr);
+
 VALUE coerce_io_string_or_buffer(VALUE buf);
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
@@ -106,23 +114,23 @@ VALUE backend_snooze(struct Backend_base *backend);
 
 // macros for doing read loops
 #define READ_LOOP_PREPARE_STR() { \
-  str = Qnil; \
-  shrinkable = io_setstrbuf(&str, len); \
-  buf = RSTRING_PTR(str); \
+  buffer = Qnil; \
+  shrinkable = io_setstrbuf(&buffer, len); \
+  ptr = RSTRING_PTR(buffer); \
   total = 0; \
 }
 
 #define READ_LOOP_YIELD_STR() { \
-  io_set_read_length(str, total, shrinkable); \
-  if (fptr) io_enc_str(str, fptr); \
-  rb_yield(str); \
+  io_set_read_length(buffer, total, shrinkable); \
+  if (fptr) io_enc_str(buffer, fptr); \
+  rb_yield(buffer); \
   READ_LOOP_PREPARE_STR(); \
 }
 
 #define READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id) { \
-  io_set_read_length(str, total, shrinkable); \
-  if (fptr) io_enc_str(str, fptr); \
-  rb_funcall_passing_block(receiver, method_id, 1, &str); \
+  io_set_read_length(buffer, total, shrinkable); \
+  if (fptr) io_enc_str(buffer, fptr); \
+  rb_funcall_passing_block(receiver, method_id, 1, &buffer); \
   READ_LOOP_PREPARE_STR(); \
 }