polyphony 0.86 → 0.90

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b87dae4e2c17055e8206c820a4281774cdf3127195173948c97df4eb09a2bd13
-  data.tar.gz: 2e7bd958ec7435569423398069223eda41e9c2d89f580627bc22e9054276dd1c
+  metadata.gz: d9f125403a124d0374ebef23adfd4fe7f553767797003d63513ef780a248370b
+  data.tar.gz: 682134740af1614ac5e31d49c7d6a8ac8b881bbc26e5911e2f12a81f5ea52b27
 SHA512:
-  metadata.gz: 48f6489939da965463735c83acb4372263eb44b48b5a16da1e704a15e3af971a5d43abd7da5e44f2455b40d880413c6fa8159794e663176c83a11eddebdebc7d
-  data.tar.gz: 3ada5f9041041e91b6b2a7f31ec609352752317e87c51df090517c9e2b556d9ef69ef8842babd15f25b2257c4226431520ff15df505748cb38bb4a1d5a19063c
+  metadata.gz: d6292c9f2ddd6faf3d8df9565f8e6dce3be9ecd64fff95201bd2907cfacdb46eac5ef87a9281a3e88324471951493b6ebaa150dad40afb6a19958dd1e5992c0c
+  data.tar.gz: 10f8e607a0bd403664318e03abd4bbb4ab16704a69d1c0858ce5c9269c5c883e081dd95c51488dce7732ae471bf04cd139c0cbfb9623d6751a857551304e60f5

data/.github/workflows/test_io_uring.yml

@@ -8,15 +8,19 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        ruby: [2.6, 2.7, 3.0]
+        ruby: ['2.7', '3.0', '3.1', 'head']
 
     name: >-
       ${{matrix.os}}, ${{matrix.ruby}}
 
     runs-on: ${{matrix.os}}
     steps:
-    - uses: actions/checkout@v1
-    - uses: ruby/setup-ruby@v1
+    - name: Checkout repository and submodules
+      uses: actions/checkout@v2
+      with:
+        submodules: recursive
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{matrix.ruby}}
         bundler-cache: true # 'bundle install' and cache
@@ -29,4 +33,4 @@ jobs:
     - name: Compile C-extension
       run: bundle exec rake compile
     - name: Run tests
-      run:  bundle exec rake test
+      run:  bundle exec ruby test/run.rb --verbose --name test_sleep

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 0.90 2022-03-21
+
+- Fix possible compilation error on Ruby 2.7.5 (#79)
+
+## 0.89 2022-03-21
+
+- Implement compression/decompression to/from strings (#86)
+
+## 0.88 2022-03-18
+
+- Improve IO stream compression utilities (release GVL, cleanup on exception)
+
+## 0.87 2022-03-17
+
+- Fix compilation on non-Linux OSes
+
 ## 0.86 2022-03-14
 
 - Fix gemspec

data/Gemfile.lock

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

data/examples/io/http1_splice_chunked.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+require 'polyphony'
+
+IO.http1_splice_chunked(STDIN, STDOUT, 16384)

data/examples/io/static_web_server.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'polyphony'
+require 'h1p'
+
+server = Polyphony::Net.tcp_listen('localhost', 1234,
+  reuse_addr: true, reuse_port: true, dont_linger: true
+)
+puts 'Serving HTTP on port 1234'
+
+def respond_default(conn)
+  conn << "HTTP/1.1 204\r\n\r\n"
+end
+
+def respond_splice(conn, path)
+  f = File.open(path, 'r') do |f|
+    conn << "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n"
+    IO.http1_splice_chunked(f, conn, 16384)
+  end
+rescue => e
+  p e
+  # conn << "HTTP/1.1 500\r\nContent-Length: 0\r\n\r\n"
+end
+
+def handle_client(conn)
+  parser = H1P::Parser.new(conn, :server)
+  while true
+    headers = parser.parse_headers
+    break unless headers
+
+    case headers[':path']
+    when /^\/splice\/(.+)$/
+      respond_splice(conn, $1)
+    else
+      respond_default(conn)
+    end
+  end
+rescue Errno::ECONNRESET
+  # ignore
+end
+
+server.accept_loop do |conn|
+  handle_client(conn)
+end

data/ext/polyphony/backend_common.c

@@ -363,8 +363,6 @@ inline void set_fd_blocking_mode(int fd, int blocking) {
 }
 
 inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
-  int flags;
-  int is_nonblocking;
   VALUE blocking_mode = rb_ivar_get(io, ID_ivar_blocking_mode);
   if (blocking == blocking_mode) return;
 
@@ -481,7 +479,7 @@ struct io_buffer get_io_buffer(VALUE in) {
     struct raw_buffer *raw = FIX2PTR(in);
     return (struct io_buffer){ raw->ptr, raw->len, 1 };
   }
-  return (struct io_buffer){ RSTRING_PTR(in), RSTRING_LEN(in), 0 };
+  return (struct io_buffer){ (unsigned char *)RSTRING_PTR(in), RSTRING_LEN(in), 0 };
 }
 
 VALUE coerce_io_string_or_buffer(VALUE buf) {

data/ext/polyphony/backend_io_uring.c

@@ -262,6 +262,21 @@ inline struct backend_stats backend_get_stats(VALUE self) {
   return backend_base_stats(&backend->base);
 }
 
+static inline struct io_uring_sqe *io_uring_backend_get_sqe(Backend_t *backend) {
+  struct io_uring_sqe *sqe;
+  sqe = io_uring_get_sqe(&backend->ring);
+  if (sqe) goto done;
+
+  if (backend->pending_sqes)
+    io_uring_backend_immediate_submit(backend);
+  else {
+    VALUE resume_value = backend_snooze(&backend->base);
+    RAISE_IF_EXCEPTION(resume_value);
+  }
+done:
+  return sqe;
+}
+
 VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -269,7 +284,7 @@ VALUE Backend_wakeup(VALUE self) {
   if (backend->base.currently_polling) {
     // Since we're currently blocking while waiting for a completion, we add a
     // NOP which would cause the io_uring_enter syscall to return
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_nop(sqe);
     io_uring_backend_immediate_submit(backend);
 
@@ -302,7 +317,7 @@ int io_uring_backend_defer_submit_and_await(
 
     // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
-    sqe = io_uring_get_sqe(&backend->ring);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_cancel(sqe, (__u64)ctx, 0);
     io_uring_backend_immediate_submit(backend);
   }
@@ -317,7 +332,7 @@ VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
   op_context_t *ctx = context_store_acquire(&backend->store, OP_POLL);
   VALUE resumed_value = Qnil;
 
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_poll_add(sqe, fd, write ? POLLOUT : POLLIN);
 
   io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resumed_value);
@@ -368,7 +383,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
     if (string_cap < expected_read_length + buf_pos) {
       shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
-      buffer.ptr = RSTRING_PTR(str) + buf_pos;
+      buffer.ptr = (unsigned char *)RSTRING_PTR(str) + buf_pos;
       buffer.len = expected_read_length;
     }
     else {
@@ -385,7 +400,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
     
@@ -415,7 +430,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
         rb_str_resize(str, total + buf_pos);
         rb_str_modify_expand(str, rb_str_capacity(str));
         shrinkable_string = 0;
-        buffer.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.ptr = (unsigned char *)RSTRING_PTR(str) + total + buf_pos;
         buffer.len = rb_str_capacity(str) - total - buf_pos;
       }
       else {
@@ -453,7 +468,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     ssize_t result;
     int completed;
 
@@ -502,7 +517,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     ssize_t result;
     int completed;
 
@@ -546,7 +561,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   while (left > 0) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITE);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -597,7 +612,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITEV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -672,7 +687,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
 
     if (string_cap < expected_read_length + buf_pos) {
       shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
-      buffer.ptr = RSTRING_PTR(str) + buf_pos;
+      buffer.ptr = (unsigned char *)RSTRING_PTR(str) + buf_pos;
       buffer.len = expected_read_length;
     }
     else {
@@ -689,7 +704,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -739,7 +754,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -787,7 +802,7 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -831,7 +846,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   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_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -869,7 +884,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_ACCEPT);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int fd;
     int completed;
 
@@ -935,7 +950,7 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
 
   while (1) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -984,7 +999,7 @@ VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   while (1) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -1021,7 +1036,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   GetBackend(self, backend);
   fd = fd_from_io(sock, &fptr, 1, 0);
   ctx = context_store_acquire(&backend->store, OP_CONNECT);
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_connect(sqe, fd, ai_addr, ai_addrlen);
   result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
   completed = context_store_release(&backend->store, ctx);
@@ -1063,7 +1078,7 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
 //   io_unset_nonblock(fptr, io);
 
 //   ctx = context_store_acquire(&backend->store, OP_CLOSE);
-//   sqe = io_uring_get_sqe(&backend->ring);
+//   sqe = io_uring_backend_get_sqe(backend);
 //   io_uring_prep_close(sqe, fd);
 //   result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
 //   completed = context_store_release(&backend->store, ctx);
@@ -1094,7 +1109,7 @@ inline struct __kernel_timespec duration_to_timespec(VALUE duration) {
 // returns true if completed, 0 otherwise
 int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
   struct __kernel_timespec ts = double_to_timespec(duration);
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
   op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -1183,7 +1198,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   GetBackend(self, backend);
   timeout = rb_funcall(cTimeoutException, ID_new, 0);
 
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -1259,7 +1274,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
     struct io_uring_sqe *sqe;
 
     backend->event_fd_ctx = context_store_acquire(&backend->store, OP_POLL);
-    sqe = io_uring_get_sqe(&backend->ring);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_poll_add(sqe, backend->event_fd, POLLIN);
     backend->base.op_count++;
     io_uring_sqe_set_data(sqe, backend->event_fd_ctx);
@@ -1275,7 +1290,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
 
     // last fiber to use the eventfd, so we cancel the ongoing poll
     struct io_uring_sqe *sqe;
-    sqe = io_uring_get_sqe(&backend->ring);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_cancel(sqe, (__u64)backend->event_fd_ctx, 0);
     io_uring_backend_immediate_submit(backend);
     backend->event_fd_ctx = NULL;
@@ -1296,7 +1311,7 @@ struct io_uring_sqe *Backend_chain_prepare_write(Backend_t *backend, VALUE io, V
   struct io_uring_sqe *sqe;
 
   fd = fd_from_io(io, &fptr, 1, 0);
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_write(sqe, fd, StringValuePtr(str), RSTRING_LEN(str), 0);
   return sqe;
 }
@@ -1308,7 +1323,7 @@ struct io_uring_sqe *Backend_chain_prepare_send(Backend_t *backend, VALUE io, VA
 
   fd = fd_from_io(io, &fptr, 1, 0);
 
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_send(sqe, fd, StringValuePtr(str), RSTRING_LEN(str), NUM2INT(flags));
   return sqe;
 }
@@ -1322,7 +1337,7 @@ struct io_uring_sqe *Backend_chain_prepare_splice(Backend_t *backend, VALUE src,
 
   src_fd = fd_from_io(src, &src_fptr, 0, 0);
   dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, NUM2INT(maxlen), 0);
   return sqe;
 }
@@ -1381,7 +1396,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
 
         ctx->ref_count = sqe_count;
         ctx->result = -ECANCELED;
-        sqe = io_uring_get_sqe(&backend->ring);
+        sqe = io_uring_backend_get_sqe(backend);
         io_uring_prep_cancel(sqe, (__u64)ctx, 0);
         io_uring_backend_immediate_submit(backend);
       }
@@ -1411,7 +1426,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
 
     // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
-    sqe = io_uring_get_sqe(&backend->ring);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_cancel(sqe, (__u64)ctx, 0);
     io_uring_backend_immediate_submit(backend);
     RAISE_IF_EXCEPTION(resume_value);
@@ -1470,14 +1485,14 @@ static inline void splice_chunks_get_sqe(
   }
   else
     *ctx = context_store_acquire(&backend->store, type);
-  (*sqe) = io_uring_get_sqe(&backend->ring);
+  (*sqe) = io_uring_backend_get_sqe(backend);
 }
 
 static inline void splice_chunks_cancel(Backend_t *backend, op_context_t *ctx) {
   struct io_uring_sqe *sqe;
   
   ctx->result = -ECANCELED;
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_cancel(sqe, (__u64)ctx, 0);
   io_uring_backend_immediate_submit(backend);
 }

data/ext/polyphony/backend_libev.c

@@ -311,7 +311,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
     if (string_cap < expected_read_length + buf_pos) {
       shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
-      buffer.ptr = RSTRING_PTR(str) + buf_pos;
+      buffer.ptr = (unsigned char *)RSTRING_PTR(str) + buf_pos;
       buffer.len = expected_read_length;
     }
     else {
@@ -353,7 +353,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
         rb_str_resize(str, total + buf_pos);
         rb_str_modify_expand(str, rb_str_capacity(str));
         shrinkable_string = 0;
-        buffer.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.ptr = (unsigned char *)RSTRING_PTR(str) + total + buf_pos;
         buffer.len = rb_str_capacity(str) - total - buf_pos;
       }
       else {
@@ -1645,6 +1645,9 @@ void Init_Backend() {
 
   rb_define_method(cBackend, "splice", Backend_splice, 3);
   rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
+  #ifdef POLYPHONY_LINUX
+  rb_define_method(cBackend, "tee", Backend_tee, 3);
+  #endif
 
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);

data/ext/polyphony/extconf.rb

@@ -47,6 +47,7 @@ end
 $defs << '-DPOLYPHONY_USE_PIDFD_OPEN' if config[:pidfd_open]
 if config[:io_uring]
   $defs << "-DPOLYPHONY_BACKEND_LIBURING"
+  $defs << "-DPOLYPHONY_LINUX"
   $defs << "-DPOLYPHONY_UNSET_NONBLOCK" if RUBY_VERSION =~ /^3/
   $CFLAGS << " -Wno-pointer-arith"
 else
@@ -70,7 +71,8 @@ $defs << '-DPOLYPHONY_PLAYGROUND' if ENV['POLYPHONY_PLAYGROUND']
 
 CONFIG['optflags'] << ' -fno-strict-aliasing' unless RUBY_PLATFORM =~ /mswin/
 
-have_func('rb_fiber_transfer', 'ruby.h')
-
+if RUBY_VERSION >= '3.1'
+  have_func('rb_fiber_transfer', 'ruby.h')
+end
 
 create_makefile 'polyphony_ext'

data/ext/polyphony/io_extensions.c

@@ -10,6 +10,7 @@
 #include "polyphony.h"
 #include "zlib.h"
 #include "assert.h"
+#include "ruby/thread.h"
 
 ID ID_at;
 ID ID_read_method;
@@ -29,6 +30,7 @@ VALUE SYM_orig_name;
 VALUE SYM_readpartial;
 
 enum read_method {
+  RM_STRING,
   RM_BACKEND_READ,
   RM_BACKEND_RECV,
   RM_READPARTIAL,
@@ -36,13 +38,15 @@ enum read_method {
 };
 
 enum write_method {
+  WM_STRING,
   WM_BACKEND_WRITE,
   WM_BACKEND_SEND,
   WM_WRITE,
   WM_CALL
 };
 
-static enum read_method detect_read_method(VALUE io) {
+static inline enum read_method detect_read_method(VALUE io) {
+  if (TYPE(io) == T_STRING) return RM_STRING;
   if (rb_respond_to(io, ID_read_method)) {
     VALUE method = rb_funcall(io, ID_read_method, 0);
     if (method == SYM_readpartial)  return RM_READPARTIAL;
@@ -58,7 +62,8 @@ static enum read_method detect_read_method(VALUE io) {
     rb_raise(rb_eRuntimeError, "Given io instance should be a callable or respond to #__read_method__");
 }
 
-static enum write_method detect_write_method(VALUE io) {
+static inline enum write_method detect_write_method(VALUE io) {
+  if (TYPE(io) == T_STRING) return WM_STRING;
   if (rb_respond_to(io, ID_write_method)) {
     VALUE method = rb_funcall(io, ID_write_method, 0);
     if (method == SYM_readpartial)    return WM_WRITE;
@@ -136,11 +141,18 @@ static inline int read_to_raw_buffer(VALUE backend, VALUE io, enum read_method m
       RB_GC_GUARD(str);
       return len;
     }
+    default: {
+      rb_raise(rb_eRuntimeError, "Invalid read method");
+    }
   }
 }
 
 static inline int write_from_raw_buffer(VALUE backend, VALUE io, enum write_method method, struct raw_buffer *buffer) {
   switch (method) {
+    case WM_STRING: {
+      rb_str_buf_cat(io, (char *)buffer->ptr, buffer->len);
+      return buffer->len;
+    }
     case WM_BACKEND_WRITE: {
       VALUE len = Backend_write(backend, io, PTR2FIX(buffer));
       return FIX2INT(len);
@@ -165,6 +177,9 @@ static inline int write_from_raw_buffer(VALUE backend, VALUE io, enum write_meth
       RB_GC_GUARD(str);
       return buffer->len;
     }
+    default: {
+      rb_raise(rb_eRuntimeError, "Invalid write method");
+    }
   }
 }
 
@@ -228,7 +243,7 @@ static inline time_t time_from_object(VALUE o) {
   return FIX2INT(rb_funcall(o, rb_intern("to_i"), 0));
 }
 
-int gzip_prepare_header(struct gzip_header_ctx *ctx, char *buffer, int maxlen) {
+int gzip_prepare_header(struct gzip_header_ctx *ctx, unsigned char *buffer, int maxlen) {
   int len = 0;
   unsigned char flags = 0, extraflags = 0;
 
@@ -259,7 +274,7 @@ int gzip_prepare_header(struct gzip_header_ctx *ctx, char *buffer, int maxlen) {
   return len;
 }
 
-int gzip_prepare_footer(unsigned long crc32, unsigned long total_in, char *buffer, int maxlen) {
+static inline int gzip_prepare_footer(unsigned long crc32, unsigned long total_in, unsigned char *buffer, int maxlen) {
   assert(maxlen >= GZIP_FOOTER_LEN);
 
   gzfile_set32(crc32, buffer);
@@ -287,8 +302,8 @@ struct z_stream_ctx {
 
   unsigned char in[CHUNK];
   unsigned char out[CHUNK];
-  int in_pos;
-  int out_pos;
+  unsigned int in_pos;
+  unsigned int out_pos;
   unsigned long in_total;
   unsigned long out_total;
 
@@ -297,8 +312,8 @@ struct z_stream_ctx {
 
 typedef int (*zlib_func)(z_streamp, int);
 
-void read_gzip_header_str(struct raw_buffer *buffer, VALUE *str, int *in_pos, unsigned long *total_read) {
-  int null_pos;
+void read_gzip_header_str(struct raw_buffer *buffer, VALUE *str, unsigned int *in_pos, unsigned long *total_read) {
+  unsigned long null_pos;
   // find null terminator
   for (null_pos = *in_pos; null_pos < *total_read; null_pos++) {
     if (!buffer->ptr[null_pos]) break;
@@ -306,28 +321,37 @@ void read_gzip_header_str(struct raw_buffer *buffer, VALUE *str, int *in_pos, un
   if (null_pos == *total_read)
     rb_raise(rb_eRuntimeError, "Invalid gzip header");
   
-  *str = rb_str_new_cstr(buffer->ptr + *in_pos);
+  *str = rb_str_new_cstr((char *)buffer->ptr + *in_pos);
   *in_pos = null_pos + 1;
 }
 
 void gzip_read_header(struct z_stream_ctx *ctx, struct gzip_header_ctx *header_ctx) {
-  struct raw_buffer in_buffer = { ctx->in, CHUNK };
+  struct raw_buffer in_buffer;
   int flags;
 
-  while (ctx->in_total < 10) {
-    int read = read_to_raw_buffer(ctx->backend, ctx->src, ctx->src_read_method, &in_buffer);
-    if (read == 0) goto error;
-    ctx->in_total += read;
+  if (ctx->src_read_method == RM_STRING) {
+    in_buffer.ptr = (unsigned char *)RSTRING_PTR(ctx->src);
+    in_buffer.len = RSTRING_LEN(ctx->src);
+    ctx->in_total = in_buffer.len;
   }
+  else {
+    in_buffer.ptr = ctx->in;
+    in_buffer.len = CHUNK;
+    while (ctx->in_total < 10) {
+      int read = read_to_raw_buffer(ctx->backend, ctx->src, ctx->src_read_method, &in_buffer);
+      if (read == 0) goto error;
+      ctx->in_total += read;
+    }
+  }
+
   // PRINT_BUFFER("read gzip header", ctx->in, ctx->in_total);
-  if (ctx->in[0] != GZ_MAGIC1) goto error;
-  if (ctx->in[1] != GZ_MAGIC2) goto error;
-  if (ctx->in[2] != GZ_METHOD_DEFLATE) goto error;
-  flags = ctx->in[3];
+  if (in_buffer.ptr[0] != GZ_MAGIC1) goto error;
+  if (in_buffer.ptr[1] != GZ_MAGIC2) goto error;
+  if (in_buffer.ptr[2] != GZ_METHOD_DEFLATE) goto error;
+  flags = in_buffer.ptr[3];
 
-  unsigned long mtime = gzfile_get32(ctx->in + 4);
+  unsigned long mtime = gzfile_get32(in_buffer.ptr + 4);
   header_ctx->mtime = INT2FIX(mtime);
-
   ctx->in_pos = 10;
 
   if (flags & GZ_FLAG_ORIG_NAME)
@@ -344,6 +368,26 @@ error:
   rb_raise(rb_eRuntimeError, "Invalid gzip header");
 }
 
+struct process_z_stream_ctx {
+  z_stream *strm;
+  int flags;
+  zlib_func fun;
+  int ret;
+};
+
+void *do_process_z_stream_without_gvl(void *ptr) {
+  struct process_z_stream_ctx *ctx = (struct process_z_stream_ctx *)ptr;
+
+  ctx->ret = (ctx->fun)(ctx->strm, ctx->flags);
+  return NULL;
+}
+
+static inline int process_without_gvl(zlib_func fun, z_stream *strm, int flags) {
+  struct process_z_stream_ctx ctx = { strm, flags, fun, 0 };
+  rb_thread_call_without_gvl2(do_process_z_stream_without_gvl, (void *)&ctx, RUBY_UBF_IO, 0);
+  return ctx.ret;
+}
+
 static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, int eof) {
   int ret;
   int written;
@@ -351,7 +395,7 @@ static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, in
 
   int avail_out_pre = ctx->strm.avail_out = CHUNK - ctx->out_pos;
   ctx->strm.next_out = ctx->out + ctx->out_pos;
-  ret = fun(&ctx->strm, eof ? Z_FINISH : Z_NO_FLUSH);
+  ret = process_without_gvl(fun, &ctx->strm, eof ? Z_FINISH : Z_NO_FLUSH);
   assert(ret != Z_STREAM_ERROR);
   written = avail_out_pre - ctx->strm.avail_out;
   out_buffer.ptr = ctx->out;
@@ -372,12 +416,13 @@ static inline int z_stream_write_out(struct z_stream_ctx *ctx, zlib_func fun, in
   return ctx->strm.avail_out;
 }
 
-void z_stream_io_loop(struct z_stream_ctx *ctx) {
+VALUE z_stream_io_loop(struct z_stream_ctx *ctx) {
   zlib_func fun = (ctx->mode == SM_DEFLATE) ? deflate : inflate;
 
-  if (ctx->in_total > ctx->in_pos) {
+  if ((ctx->src_read_method != RM_STRING) && (ctx->in_total > ctx->in_pos)) {
     // In bytes already read for parsing gzip header, so we need to process the
     // rest.
+
     ctx->strm.next_in = ctx->in + ctx->in_pos;
     ctx->strm.avail_in = ctx->in_total -= ctx->in_pos;
 
@@ -389,14 +434,27 @@ void z_stream_io_loop(struct z_stream_ctx *ctx) {
   }
 
   while (1) {
-    struct raw_buffer in_buffer = {ctx->in, CHUNK};
-    ctx->strm.next_in = ctx->in;
-    int read_len = ctx->strm.avail_in = read_to_raw_buffer(ctx->backend, ctx->src, ctx->src_read_method, &in_buffer);
-    if (!read_len) break;
-    int eof = read_len < CHUNK;
-
-    if (ctx->mode == SM_DEFLATE)
-      ctx->crc32 = crc32(ctx->crc32, ctx->in, read_len);
+    int eof;
+    int read_len;
+    if (ctx->src_read_method == RM_STRING) {
+      struct raw_buffer in_buffer = {
+        (unsigned char *)RSTRING_PTR(ctx->src) + ctx->in_pos,
+        RSTRING_LEN(ctx->src) - ctx->in_pos
+      };
+      ctx->strm.next_in = in_buffer.ptr;
+      read_len = ctx->strm.avail_in = in_buffer.len;
+      eof = 1;
+      if (ctx->mode == SM_DEFLATE) ctx->crc32 = crc32(ctx->crc32, in_buffer.ptr, read_len);
+    }
+    else {
+      struct raw_buffer in_buffer = {ctx->in, CHUNK};
+      ctx->strm.next_in = ctx->in;
+      read_len = ctx->strm.avail_in = read_to_raw_buffer(ctx->backend, ctx->src, ctx->src_read_method, &in_buffer);
+      if (!read_len) break;
+      eof = read_len < CHUNK;
+      if (ctx->mode == SM_DEFLATE) ctx->crc32 = crc32(ctx->crc32, ctx->in, read_len);
+    }
+
     ctx->in_total += read_len;
 
     // PRINT_BUFFER("read stream", ctx->in, read_len);
@@ -407,13 +465,15 @@ void z_stream_io_loop(struct z_stream_ctx *ctx) {
       if (z_stream_write_out(ctx, fun, eof)) break;
     }
 
-    if (eof) return;
+    if (eof) goto done;
   }
 
   //flush
   ctx->strm.avail_in = 0;
   ctx->strm.next_in = ctx->in;
   z_stream_write_out(ctx, fun, 1);
+done:
+  return Qnil;
 }
 
 static inline void setup_ctx(struct z_stream_ctx *ctx, enum stream_mode mode, VALUE src, VALUE dest) {
@@ -434,6 +494,18 @@ static inline void setup_ctx(struct z_stream_ctx *ctx, enum stream_mode mode, VA
   ctx->crc32 = 0;
 }
 
+static inline VALUE z_stream_cleanup(struct z_stream_ctx *ctx) {
+  if (ctx->mode == SM_DEFLATE)
+    deflateEnd(&ctx->strm);
+  else
+    inflateEnd(&ctx->strm);
+  return Qnil;
+}
+
+#define SAFE(f) (VALUE (*)(VALUE))(f)
+#define Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx) \
+  rb_ensure(SAFE(z_stream_io_loop), (VALUE)&ctx, SAFE(z_stream_cleanup), (VALUE)&ctx)
+
 VALUE IO_gzip(int argc, VALUE *argv, VALUE self) {
   VALUE src;
   VALUE dest;
@@ -450,18 +522,16 @@ VALUE IO_gzip(int argc, VALUE *argv, VALUE self) {
   };
 
   struct z_stream_ctx ctx;
-  int level = DEFAULT_LEVEL;
   int ret;
 
   setup_ctx(&ctx, SM_DEFLATE, src, dest);
   ctx.f_gzip_footer = 1; // write gzip footer
-  ctx.out_pos = gzip_prepare_header(&header_ctx, ctx.out, sizeof(ctx.out));
+  ctx.out_total = ctx.out_pos = gzip_prepare_header(&header_ctx, ctx.out, sizeof(ctx.out));
 
-  ret = deflateInit2(&ctx.strm, level, Z_DEFLATED, -MAX_WBITS, DEFAULT_MEM_LEVEL, Z_DEFAULT_STRATEGY);
-  if (ret != Z_OK) return INT2FIX(ret);
-  z_stream_io_loop(&ctx);
-  deflateEnd(&ctx.strm);
- 
+  ret = deflateInit2(&ctx.strm, DEFAULT_LEVEL, Z_DEFLATED, -MAX_WBITS, DEFAULT_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx); 
   return INT2FIX(ctx.out_total);
 }
 
@@ -482,21 +552,25 @@ VALUE IO_gunzip(int argc, VALUE *argv, VALUE self) {
   setup_ctx(&ctx, SM_INFLATE, src, dest);
   gzip_read_header(&ctx, &header_ctx);
 
+  ret = inflateInit2(&ctx.strm, -MAX_WBITS);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx);
+
+  // gzip_read_footer(&ctx, &footer_ctx);
+  // TODO: verify crc32
+  // TODO: verify total length
+
   if (info != Qnil) {
     rb_hash_aset(info, SYM_mtime, FIX2TIME(header_ctx.mtime));
     rb_hash_aset(info, SYM_orig_name, header_ctx.orig_name);
     rb_hash_aset(info, SYM_comment, header_ctx.comment);
   }
+  RB_GC_GUARD(header_ctx.orig_name);
+  RB_GC_GUARD(header_ctx.comment);
 
-  ret = inflateInit2(&ctx.strm, -MAX_WBITS);
-  if (ret != Z_OK) return INT2FIX(ret);
-  z_stream_io_loop(&ctx);
-  inflateEnd(&ctx.strm);
-
-  // gzip_read_footer(&ctx, &footer_ctx);
-  // TODO: verify crc32
-  // TODO: verify total length
-  return self;
+  return INT2FIX(ctx.out_total);
 }
 
 VALUE IO_deflate(VALUE self, VALUE src, VALUE dest) {
@@ -506,9 +580,10 @@ VALUE IO_deflate(VALUE self, VALUE src, VALUE dest) {
 
   setup_ctx(&ctx, SM_DEFLATE, src, dest);
   ret = deflateInit(&ctx.strm, level);
-  if (ret != Z_OK) return INT2FIX(ret);
-  z_stream_io_loop(&ctx);
-  deflateEnd(&ctx.strm);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx);
  
   return INT2FIX(ctx.out_total);
 }
@@ -519,19 +594,52 @@ VALUE IO_inflate(VALUE self, VALUE src, VALUE dest) {
 
   setup_ctx(&ctx, SM_INFLATE, src, dest);
   ret = inflateInit(&ctx.strm);
-  if (ret != Z_OK) return INT2FIX(ret);
-  z_stream_io_loop(&ctx);
-  inflateEnd(&ctx.strm);
+  if (ret != Z_OK)
+    rb_raise(rb_eRuntimeError, "zlib error: %s\n", ctx.strm.msg);
+
+  Z_STREAM_SAFE_IO_LOOP_WITH_CLEANUP(ctx);
  
   return INT2FIX(ctx.out_total);
 }
 
+VALUE IO_http1_splice_chunked(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  enum write_method method = detect_write_method(dest);
+  VALUE backend = BACKEND();
+  VALUE pipe = rb_funcall(cPipe, ID_new, 0);
+  unsigned char out[128];
+  struct raw_buffer buffer = { out, 0 };
+
+  while (1) {
+    int len = FIX2INT(Backend_splice(backend, src, pipe, maxlen));
+    if (!len) break;
+
+    // write chunk header
+    buffer.len += sprintf((char *)buffer.ptr + buffer.len, "%x\r\n", len);
+    write_from_raw_buffer(backend, dest, method, &buffer);
+    buffer.len = 0;
+    while (len) {
+      int spliced = FIX2INT(Backend_splice(backend, pipe, dest, INT2FIX(len)));
+      len -= spliced;
+    }
+    buffer.len += sprintf((char *)buffer.ptr + buffer.len, "\r\n");
+  }
+  buffer.len += sprintf((char *)buffer.ptr + buffer.len, "0\r\n\r\n");
+  write_from_raw_buffer(backend, dest, method, &buffer);
+
+  Pipe_close(pipe);
+  RB_GC_GUARD(pipe);
+
+  return self;
+}
+
 void Init_IOExtensions() {
   rb_define_singleton_method(rb_cIO, "gzip", IO_gzip, -1);
   rb_define_singleton_method(rb_cIO, "gunzip", IO_gunzip, -1);
   rb_define_singleton_method(rb_cIO, "deflate", IO_deflate, 2);
   rb_define_singleton_method(rb_cIO, "inflate", IO_inflate, 2);
 
+  rb_define_singleton_method(rb_cIO, "http1_splice_chunked", IO_http1_splice_chunked, 3);
+
   ID_at           = rb_intern("at");
   ID_read_method  = rb_intern("__read_method__");
   ID_readpartial  = rb_intern("readpartial");

data/ext/polyphony/polyphony.c

@@ -94,9 +94,11 @@ VALUE Polyphony_backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE c
   return Backend_splice_to_eof(BACKEND(), src, dest, chunksize);
 }
 
+#ifdef POLYPHONY_LINUX
 VALUE Polyphony_backend_tee(VALUE self, VALUE src, VALUE dest, VALUE chunksize) {
   return Backend_tee(BACKEND(), src, dest, chunksize);
 }
+#endif
 
 VALUE Polyphony_backend_timeout(int argc,VALUE *argv, VALUE self) {
   return Backend_timeout(argc, argv, BACKEND());
@@ -143,7 +145,7 @@ VALUE Polyphony_raw_buffer_get(int argc, VALUE *argv, VALUE self) {
   int length = (len == Qnil) ? buffer->len : FIX2INT(len);
   
   if (length > buffer->len) length = buffer->len;
-  return rb_utf8_str_new(buffer->ptr, length);
+  return rb_utf8_str_new((char *)buffer->ptr, length);
 }
 
 VALUE Polyphony_raw_buffer_set(VALUE self, VALUE buf, VALUE str) {
@@ -162,12 +164,6 @@ VALUE Polyphony_raw_buffer_size(VALUE self, VALUE buf) {
   return INT2FIX(buffer->len);
 }
 
-VALUE Polyphony_backend_test(VALUE self, VALUE io, VALUE str) {
-  struct raw_buffer buffer = { RSTRING_PTR(str), RSTRING_LEN(str) };
-  VALUE args[2] = { io, PTR2FIX(&buffer) };
-  return Polyphony_backend_write(2, args, self);
-}
-
 // VALUE Polyphony_backend_close(VALUE self, VALUE io) {
 //   return Backend_close(BACKEND(), io);
 // }
@@ -190,7 +186,11 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "backend_sleep", Polyphony_backend_sleep, 1);
   rb_define_singleton_method(mPolyphony, "backend_splice", Polyphony_backend_splice, 3);
   rb_define_singleton_method(mPolyphony, "backend_splice_to_eof", Polyphony_backend_splice_to_eof, 3);
+ 
+  #ifdef POLYPHONY_LINUX
   rb_define_singleton_method(mPolyphony, "backend_tee", Polyphony_backend_tee, 3);
+  #endif
+  
   rb_define_singleton_method(mPolyphony, "backend_timeout", Polyphony_backend_timeout, -1);
   rb_define_singleton_method(mPolyphony, "backend_timer_loop", Polyphony_backend_timer_loop, 1);
   rb_define_singleton_method(mPolyphony, "backend_wait_event", Polyphony_backend_wait_event, 1);
@@ -204,7 +204,6 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "__raw_buffer_get__", Polyphony_raw_buffer_get, -1);
   rb_define_singleton_method(mPolyphony, "__raw_buffer_set__", Polyphony_raw_buffer_set, 2);
   rb_define_singleton_method(mPolyphony, "__raw_buffer_size__", Polyphony_raw_buffer_size, 1);
-  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

@@ -90,6 +90,7 @@ int Runqueue_should_poll_nonblocking(VALUE self);
 
 void Pipe_verify_blocking_mode(VALUE self, VALUE blocking);
 int Pipe_get_fd(VALUE self, int write_mode);
+VALUE Pipe_close(VALUE self);
 
 #ifdef POLYPHONY_BACKEND_LIBEV
 #define Backend_recv_loop Backend_read_loop
@@ -112,7 +113,11 @@ 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);
 VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize);
+
+#ifdef POLYPHONY_LINUX
 VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen);
+#endif
+
 VALUE Backend_timeout(int argc,VALUE *argv, VALUE self);
 VALUE Backend_timer_loop(VALUE self, VALUE interval);
 VALUE Backend_wait_event(VALUE self, VALUE raise);

data/lib/polyphony/version.rb

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

data/test/test_io.rb

@@ -656,19 +656,75 @@ class IOExtensionsTest < MiniTest::Test
     i, o = IO.pipe
     r, w = IO.pipe
 
-    spin {
-      IO.deflate(i, w)
+    ret = nil
+    f = spin {
+      ret = IO.deflate(i, w)
       w.close
     }
 
     o << 'foobar' * 20
     o.close
 
+    f.await
+    assert_equal 17, ret
+
     data = r.read
     msg = Zlib::Inflate.inflate(data)
     assert_equal 'foobar' * 20, msg
   end
 
+  def test_deflate_to_string
+    i, o = IO.pipe
+    r, w = IO.pipe
+    str = +''
+
+    ret = nil
+    f = spin {
+      ret = IO.deflate(i, str)
+      w << str
+      w.close
+    }
+
+    o << 'foobar' * 20
+    o.close
+
+    f.await
+    assert_equal 17, ret
+
+    data = r.read
+    msg = Zlib::Inflate.inflate(data)
+    assert_equal 'foobar' * 20, msg
+  end
+
+  def test_deflate_to_frozen_string
+    i, o = IO.pipe
+    str = '' # frozen
+
+    f = spin {
+      o << 'foobar' * 20
+      o.close
+    }
+
+    assert_raises(FrozenError) { IO.deflate(i, str) }
+  end
+
+  def test_deflate_from_string
+    r, w = IO.pipe
+    str = 'foobar' * 10000
+    ret = nil
+    
+    f = spin {
+      ret = IO.deflate(str, w)
+      w.close
+    }
+    f.await
+    assert_equal 118, ret
+
+    data = r.read
+    msg = Zlib::Inflate.inflate(data)
+    assert_equal str, msg
+  end
+
   def test_inflate
     i, o = IO.pipe
     r, w = IO.pipe
@@ -679,7 +735,35 @@ class IOExtensionsTest < MiniTest::Test
       o.close
     }
 
-    IO.inflate(i, w)
+    ret = IO.inflate(i, w)
+    assert_equal 6, ret
+    w.close
+    msg = r.read
+    assert_equal 'foobar', msg
+  end
+
+  def test_inflate_to_string
+    i, o = IO.pipe
+    str = +''
+
+    spin {
+      data = Zlib::Deflate.deflate('foobar', 9)
+      o << data
+      o.close
+    }
+
+    ret = IO.inflate(i, str)
+    assert_equal 6, ret
+    assert_equal 6, str.bytesize
+    assert_equal 'foobar', str
+  end
+
+  def test_inflate_from_string
+    r, w = IO.pipe
+    str = Zlib::Deflate.deflate('foobar', 9)
+
+    ret = IO.inflate(str, w)
+    assert_equal 6, ret
     w.close
     msg = r.read
     assert_equal 'foobar', msg
@@ -690,7 +774,7 @@ class IOExtensionsTest < MiniTest::Test
     dest = Polyphony.pipe
     now = nil
 
-    spin {
+    f = spin {
       now = Time.now
       IO.gzip(src, dest)
       dest.close
@@ -698,6 +782,32 @@ class IOExtensionsTest < MiniTest::Test
 
     src << IO.read(__FILE__)
     src.close
+    f.await
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+    assert_in_range (now-2)..(now+1), gz.mtime
+    assert_nil gz.orig_name
+    assert_nil gz.comment
+  end
+
+  def test_gzip_to_string
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+    str = +''
+    now = nil
+
+    f = spin {
+      now = Time.now
+      IO.gzip(src, str)
+      dest << str
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+    f.await
 
     gz = Zlib::GzipReader.new(dest)
     data = gz.read
@@ -707,6 +817,39 @@ class IOExtensionsTest < MiniTest::Test
     assert_nil gz.comment
   end
 
+  def test_gzip_from_string
+    str = IO.read(__FILE__)
+    dest = Polyphony.pipe
+    now = nil
+
+    IO.gzip(str, dest)
+    dest.close
+
+    gz = Zlib::GzipReader.new(dest)
+    data = gz.read
+    assert_equal IO.read(__FILE__), data
+  end
+
+  def test_gzip_return_value
+    src = Polyphony.pipe
+    dest = Polyphony.pipe
+    now = nil
+    ret = nil
+
+    f = spin {
+      now = Time.now
+      ret = IO.gzip(src, dest)
+      dest.close
+    }
+
+    src << IO.read(__FILE__)
+    src.close
+    f.await
+
+    gzipped = dest.read
+    assert_equal gzipped.bytesize, ret
+  end
+
   def test_gzip_with_mtime_int
     src = Polyphony.pipe
     dest = Polyphony.pipe
@@ -801,19 +944,51 @@ class IOExtensionsTest < MiniTest::Test
   def test_gunzip
     src = Polyphony.pipe
     dest = Polyphony.pipe
+    ret = nil
 
-    spin {
-      IO.gunzip(src, dest)
+    f = spin {
+      ret = IO.gunzip(src, dest)
       dest.close
     }
 
     gz = Zlib::GzipWriter.new(src, 9)
-    gz << 'foobar'#IO.read(__FILE__)
+    gz << IO.read(__FILE__)
     gz.close
+    f.await
 
     data = dest.read
-    # assert_equal IO.read(__FILE__), data
-    assert_equal 'foobar', data
+    assert_equal IO.read(__FILE__).bytesize, ret
+    assert_equal IO.read(__FILE__), data
+  end
+
+  def test_gunzip_to_string
+    src = Polyphony.pipe
+    str = +''
+    ret = nil
+
+    f = spin {
+      ret = IO.gunzip(src, str)
+    }
+
+    gz = Zlib::GzipWriter.new(src, 9)
+    gz << IO.read(__FILE__)
+    gz.close
+    f.await
+
+    assert_equal IO.read(__FILE__).bytesize, ret
+    assert_equal IO.read(__FILE__), str
+  end
+
+  def test_gunzip_from_string
+    src_data = 'foobar' * 1000
+    str = Zlib.gzip(src_data, level: 9)
+    dest = Polyphony.pipe
+    ret = IO.gunzip(str, dest)
+    dest.close
+
+    dest_data = dest.read
+    assert_equal src_data.bytesize, ret
+    assert_equal src_data, dest_data
   end
 
   def test_gunzip_multi
@@ -893,4 +1068,24 @@ class IOExtensionsTest < MiniTest::Test
     assert_equal 'foo.bar', dest_info[:orig_name]
     assert_equal 'hello!', dest_info[:comment]
   end
+
+  def test_deflate_inflate_strings
+    src_data = IO.read(__FILE__)
+    deflated = +''
+    IO.deflate(src_data, deflated)
+    inflated = +''
+    IO.inflate(deflated, inflated)
+
+    assert_equal src_data, inflated
+  end
+
+  def test_gzip_gunzip_strings
+    src_data = IO.read(__FILE__)
+    gzipped = +''
+    IO.gzip(src_data, gzipped)
+    gunzipped = +''
+    IO.gunzip(gzipped, gunzipped)
+
+    assert_equal src_data, gunzipped
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.86'
+  version: '0.90'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-14 00:00:00.000000000 Z
+date: 2022-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -262,6 +262,7 @@ files:
 - examples/io/echo_stdin.rb
 - examples/io/gzip.rb
 - examples/io/happy-eyeballs.rb
+- examples/io/http1_splice_chunked.rb
 - examples/io/httparty.rb
 - examples/io/https_server.rb
 - examples/io/irb.rb
@@ -274,6 +275,7 @@ files:
 - examples/io/reline.rb
 - examples/io/splice_chunks.rb
 - examples/io/splice_echo_server.rb
+- examples/io/static_web_server.rb
 - examples/io/stdio.rb
 - examples/io/system.rb
 - examples/io/tcp_proxy.rb