polyphony 0.56.0 → 0.57.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6c9247de0e5049128fffb31879fd0a79ba6fe304e3802a5b7fa69baa4445ecf
-  data.tar.gz: f2e432fb0f9d6362b7d38834a0e37c7907328c6a27d6544e1dad5363ba4f715c
+  metadata.gz: e350937221c476548465a2881e64689042137eab59571a0940f63236a249563f
+  data.tar.gz: 14870d9e38e7aa9f300d09cdfa0693929edb59756e0d17e7b3e7ae2d4a9dab0d
 SHA512:
-  metadata.gz: 3d69bdb3f12cb65cf580cc243ea0a4f479b5306cf087bcfc5e9d8def1fee49b998528f881844649bc01b501ea22371632fd1f4f08d1f8118692bdf2331f698e6
-  data.tar.gz: d49152bd9c9be94835a020f829c7ddc7f3766fcac9fca8e652bd8df43daab7a6eda90c94b40e57b3cef064d1ff2a957f42030aedefae1b2d1ad6a6587cf6fa86
+  metadata.gz: 8087b84c7a583c8f3905c20d06aa4ad119fd2901be2594e66f56b577c1fa141f9e203971aedd27ad7c57b9c184adad1b97d0fbe4024702bfe3ef6bdaa861ac92
+  data.tar.gz: 6943231ef2b29dac3e33cfee865dbc6b3b35549c62e04dd1ed08d40fbd90a5c179417baf3b27b965e80c3ee7e137cbe167be9e8187dff46d89892978beb8a40d

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.57.0 2021-06-23
+
+- Implement `Backend#splice_chunks` method for both libev and io_uring backends
+- Improve waiting for readiness in libev `Backend#splice`, `#splice_to_eof`
+- Enable splice op in libev `Backend#chain` for non-Linux OS
+
 ## 0.56.0 2021-06-22
 
 - Implement fake `Backend#splice`, `Backend#splice_to_eof` methods for non-Linux

data/Gemfile.lock

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

data/examples/io/splice_chunks.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+i, o = IO.pipe
+
+f = spin do
+  i.read_loop { |data| STDOUT << data }
+end
+
+result = nil
+# File.open(__FILE__, 'r') do |f|
+File.open('../tipi/log', 'r') do |f|
+  result = Thread.current.backend.splice_chunks(
+    f,
+    o,
+    "Content-Type: ruby\n\n",
+    "0\r\n\r\n",
+    ->(len) { "#{len.to_s(16)}\r\n" },
+    "\r\n",
+    16384
+  )
+end
+
+
+o.close
+f.await
+p result: result

data/ext/polyphony/backend_io_uring.c

@@ -239,8 +239,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);
+  if (sqe) {
+    io_uring_sqe_set_data(sqe, ctx);
+    io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  }
   io_uring_backend_defer_submit(backend);
 
   switchpoint_result = backend_await((struct Backend_base *)backend);
@@ -446,7 +448,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     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);
-    io_uring_prep_write(sqe, fptr->fd, buf, left, -1);
+    io_uring_prep_write(sqe, fptr->fd, buf, left, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     int completed = context_store_release(&backend->store, ctx);
@@ -1065,7 +1067,7 @@ struct io_uring_sqe *Backend_chain_prepare_write(Backend_t *backend, VALUE io, V
   long len = RSTRING_LEN(str);
 
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
-  io_uring_prep_write(sqe, fptr->fd, buf, len, -1);
+  io_uring_prep_write(sqe, fptr->fd, buf, len, 0);
   return sqe;
 }
 
@@ -1190,6 +1192,160 @@ inline VALUE Backend_run_idle_tasks(VALUE self) {
   return self;
 }
 
+static inline void splice_chunks_prep_write(op_context_t *ctx, struct io_uring_sqe *sqe, int fd, VALUE str) {
+  char *buf = RSTRING_PTR(str);
+  int len = RSTRING_LEN(str);
+  io_uring_prep_write(sqe, fd, buf, len, 0);
+  // io_uring_prep_send(sqe, fd, buf, len, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+}
+
+static inline void splice_chunks_prep_splice(op_context_t *ctx, struct io_uring_sqe *sqe, int src, int dest, int maxlen) {
+  io_uring_prep_splice(sqe, src, -1, dest, -1, maxlen, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+}
+
+static inline void splice_chunks_get_sqe(
+  Backend_t *backend,
+  op_context_t **ctx,
+  struct io_uring_sqe **sqe,
+  enum op_type type
+)
+{
+  if (*ctx) {
+    if (*sqe) (*sqe)->flags |= IOSQE_IO_LINK;
+    (*ctx)->ref_count++;
+  }
+  else
+    *ctx = context_store_acquire(&backend->store, type);
+  (*sqe) = io_uring_get_sqe(&backend->ring);
+}
+
+static inline void splice_chunks_cancel(Backend_t *backend, op_context_t *ctx) {
+  ctx->result = -ECANCELED;
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_cancel(sqe, ctx, 0);
+  backend->pending_sqes = 0;
+  io_uring_submit(&backend->ring);
+}
+
+static inline int splice_chunks_await_ops(
+  Backend_t *backend,
+  op_context_t **ctx,
+  int *result,
+  VALUE *switchpoint_result
+)
+{
+  int res = io_uring_backend_defer_submit_and_await(backend, 0, *ctx, switchpoint_result);
+  if (result) (*result) = res;
+  int completed = context_store_release(&backend->store, *ctx);
+  if (!completed) {
+    splice_chunks_cancel(backend, *ctx);
+    if (TEST_EXCEPTION(*switchpoint_result)) return 1;
+  }
+  *ctx = 0;
+  return 0;
+}
+
+#define SPLICE_CHUNKS_AWAIT_OPS(backend, ctx, result, switchpoint_result) \
+  if (splice_chunks_await_ops(backend, ctx, result, switchpoint_result)) goto error;
+
+VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VALUE postfix, VALUE chunk_prefix, VALUE chunk_postfix, VALUE chunk_size) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  int total = 0;
+  int err = 0;
+  VALUE switchpoint_result = Qnil;
+  op_context_t *ctx = 0;
+  struct io_uring_sqe *sqe = 0;
+
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+
+  VALUE underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_verify_blocking_mode(src_fptr, src, Qtrue);
+
+  underlying_io = rb_ivar_get(dest, ID_ivar_io);
+  if (underlying_io != Qnil) dest = underlying_io;
+  dest = rb_io_get_write_io(dest);
+  GetOpenFile(dest, dest_fptr);
+  io_verify_blocking_mode(dest_fptr, dest, Qtrue);
+
+  int maxlen = NUM2INT(chunk_size);
+  VALUE str = Qnil;
+  VALUE chunk_len_value = Qnil;
+
+  int pipefd[2] = { -1, -1 };
+  if (pipe(pipefd) == -1) {
+    err = errno;
+    goto syscallerror;
+  }
+
+  if (prefix != Qnil) {
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+    splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, prefix);
+  }
+
+  while (1) {
+    int chunk_len;
+    VALUE chunk_prefix_str = Qnil;
+    VALUE chunk_postfix_str = Qnil;
+
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
+    splice_chunks_prep_splice(ctx, sqe, src_fptr->fd, pipefd[1], maxlen);
+    
+    SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, &chunk_len, &switchpoint_result);
+    if (chunk_len == 0) break;
+    
+    total += chunk_len;
+    chunk_len_value = INT2NUM(chunk_len);
+
+
+    if (chunk_prefix != Qnil) {
+      chunk_prefix_str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
+      splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+      splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_prefix_str);
+    }
+
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
+    splice_chunks_prep_splice(ctx, sqe, pipefd[0], dest_fptr->fd, chunk_len);
+
+    if (chunk_postfix != Qnil) {
+      chunk_postfix_str = (TYPE(chunk_postfix) == T_STRING) ? chunk_postfix : rb_funcall(chunk_postfix, ID_call, 1, chunk_len_value);
+      splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+      splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_postfix_str);
+    }
+
+    RB_GC_GUARD(chunk_prefix_str);
+    RB_GC_GUARD(chunk_postfix_str);
+  }
+
+  if (postfix != Qnil) {
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+    splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, postfix);
+  }
+  if (ctx) {
+    SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, 0, &switchpoint_result);
+  }
+
+  RB_GC_GUARD(str);
+  RB_GC_GUARD(chunk_len_value);
+  RB_GC_GUARD(switchpoint_result);
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  return INT2NUM(total);
+syscallerror:
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  rb_syserr_fail(err, strerror(err));
+error:
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 void Init_Backend() {
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);
@@ -1203,6 +1359,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "kind", Backend_kind, 0);
   rb_define_method(cBackend, "chain", Backend_chain, -1);
   rb_define_method(cBackend, "idle_gc_period=", Backend_idle_gc_period_set, 1);
+  rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);

data/ext/polyphony/backend_libev.c

@@ -737,10 +737,63 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+struct libev_rw_ctx {
+  int ref_count;
+  VALUE fiber;
+};
+
+struct libev_ref_count_io {
+  struct ev_io io;
+  struct libev_rw_ctx *ctx;
+};
+
+struct libev_rw_io {
+  struct libev_ref_count_io r;
+  struct libev_ref_count_io w;
+  struct libev_rw_ctx ctx;
+};
+
+void Backend_rw_io_callback(EV_P_ ev_io *w, int revents)
+{
+  struct libev_ref_count_io *watcher = (struct libev_ref_count_io *)w;
+  int ref_count = watcher->ctx->ref_count--;
+  if (!ref_count)
+    Fiber_make_runnable(watcher->ctx->fiber, Qnil);
+}
+
+VALUE libev_wait_rw_fd_with_watcher(Backend_t *backend, int r_fd, int w_fd, struct libev_rw_io *watcher) {
+  VALUE switchpoint_result = Qnil;
+
+  if (watcher->ctx.fiber == Qnil) watcher->ctx.fiber = rb_fiber_current();
+  watcher->ctx.ref_count = 0;
+  if (r_fd != -1) {
+    ev_io_init(&watcher->r.io, Backend_rw_io_callback, r_fd, EV_READ);
+    ev_io_start(backend->ev_loop, &watcher->r.io);
+    watcher->r.ctx = &watcher->ctx;
+    watcher->ctx.ref_count++;
+  }
+  if (w_fd != -1) {
+    ev_io_init(&watcher->w.io, Backend_rw_io_callback, w_fd, EV_WRITE);
+    ev_io_start(backend->ev_loop, &watcher->w.io);
+    watcher->w.ctx = &watcher->ctx;
+    watcher->ctx.ref_count++;
+  }
+
+  switchpoint_result = backend_await((struct Backend_base *)backend);
+
+  if (r_fd != -1) ev_io_stop(backend->ev_loop, &watcher->r.io);
+  if (w_fd != -1) ev_io_stop(backend->ev_loop, &watcher->w.io);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
+}
+
+
+
+
 #ifdef POLYPHONY_LINUX
 VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
-  struct libev_io watcher;
+  struct libev_rw_io watcher;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_io;
   rb_io_t *src_fptr;
@@ -760,17 +813,14 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   GetOpenFile(dest, dest_fptr);
   io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
-  watcher.fiber = Qnil;
+  watcher.ctx.fiber = Qnil;
   while (1) {
     len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
-      if (TEST_EXCEPTION(switchpoint_result)) goto error;
-
-      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, dest_fptr->fd, &watcher);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -778,12 +828,12 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
     }
   }
 
-  if (watcher.fiber == Qnil) {
+  if (watcher.ctx.fiber == Qnil) {
     switchpoint_result = backend_snooze();
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
-  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(watcher.ctx.fiber);
   RB_GC_GUARD(switchpoint_result);
 
   return INT2NUM(len);
@@ -793,7 +843,7 @@ error:
 
 VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
-  struct libev_io watcher;
+  struct libev_rw_io watcher;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_io;
   rb_io_t *src_fptr;
@@ -814,17 +864,14 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   GetOpenFile(dest, dest_fptr);
   io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
-  watcher.fiber = Qnil;
+  watcher.ctx.fiber = Qnil;
   while (1) {
     len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
-      if (TEST_EXCEPTION(switchpoint_result)) goto error;
-
-      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, dest_fptr->fd, &watcher);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else if (len == 0) {
@@ -835,12 +882,12 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
     }
   }
 
-  if (watcher.fiber == Qnil) {
+  if (watcher.ctx.fiber == Qnil) {
     switchpoint_result = backend_snooze();
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
-  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(watcher.ctx.fiber);
   RB_GC_GUARD(switchpoint_result);
 
   return INT2NUM(total);
@@ -1225,10 +1272,8 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
       result = Backend_write(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2));
     else if (op_type == SYM_send && op_len == 4)
       result = Backend_send(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
-    #ifdef POLYPHONY_LINUX
     else if (op_type == SYM_splice && op_len == 4)
       result = Backend_splice(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
-    #endif
     else
       rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
   }
@@ -1252,6 +1297,142 @@ inline VALUE Backend_run_idle_tasks(VALUE self) {
   return self;
 }
 
+inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct libev_rw_io *watcher, VALUE *result) {
+  char *buf = RSTRING_PTR(str);
+  int len = RSTRING_LEN(str);
+  int left = len;
+  while (left > 0) {
+    ssize_t n = write(fd, buf, left);
+    if (n < 0) {
+      int err = errno;
+      if ((err != EWOULDBLOCK && err != EAGAIN)) return err;
+
+      *result = libev_wait_rw_fd_with_watcher(backend, -1, fd, watcher);
+      if (TEST_EXCEPTION(*result)) return -1;
+    }
+    else {
+      buf += n;
+      left -= n;
+    }
+  }
+  return 0;
+}
+
+VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VALUE postfix, VALUE chunk_prefix, VALUE chunk_postfix, VALUE chunk_size) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  int total = 0;
+  int err = 0;
+  VALUE result = Qnil;
+
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+
+  VALUE underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_verify_blocking_mode(src_fptr, src, Qfalse);
+
+  underlying_io = rb_ivar_get(dest, ID_ivar_io);
+  if (underlying_io != Qnil) dest = underlying_io;
+  dest = rb_io_get_write_io(dest);
+  GetOpenFile(dest, dest_fptr);
+  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
+
+  struct libev_rw_io watcher;
+  watcher.ctx.fiber = Qnil;
+  int maxlen = NUM2INT(chunk_size);
+  VALUE str = Qnil;
+  VALUE chunk_len_value = Qnil;
+
+  int pipefd[2] = { -1, -1 };
+  if (pipe(pipefd) == -1) {
+    err = errno;
+    goto syscallerror;
+  }
+
+  fcntl(pipefd[0], F_SETFL, O_NONBLOCK);
+  fcntl(pipefd[1], F_SETFL, O_NONBLOCK);
+
+  if (prefix != Qnil) {
+    int err = splice_chunks_write(backend, dest_fptr->fd, prefix, &watcher, &result);
+    if (err == -1) goto error; else if (err) goto syscallerror;
+  }
+  while (1) {
+    int chunk_len;
+    // splice to pipe
+    while (1) {
+      chunk_len = splice(src_fptr->fd, 0, pipefd[1], 0, maxlen, 0);
+      if (chunk_len < 0) {
+        err = errno;
+        if (err != EWOULDBLOCK && err != EAGAIN) goto syscallerror;
+
+        result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, pipefd[1], &watcher);
+        if (TEST_EXCEPTION(result)) goto error;
+      }
+      else {
+        break;
+      }
+    }
+    if (chunk_len == 0) break;
+    
+    total += chunk_len;
+    chunk_len_value = INT2NUM(chunk_len);
+
+    if (chunk_prefix != Qnil) {
+      VALUE str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
+      int err = splice_chunks_write(backend, dest_fptr->fd, str, &watcher, &result);
+      if (err == -1) goto error; else if (err) goto syscallerror;
+    }
+
+    int left = chunk_len;
+    while (1) {
+      int n = splice(pipefd[0], 0, dest_fptr->fd, 0, left, 0);
+      if (n < 0) {
+        err = errno;
+        if (err != EWOULDBLOCK && err != EAGAIN) goto syscallerror;
+
+        result = libev_wait_rw_fd_with_watcher(backend, pipefd[0], dest_fptr->fd, &watcher);
+        if (TEST_EXCEPTION(result)) goto error;
+      }
+      else {
+        left -= n;
+        if (left == 0) break;
+      }
+    }
+
+    if (chunk_postfix != Qnil) {
+      VALUE str = (TYPE(chunk_postfix) == T_STRING) ? chunk_postfix : rb_funcall(chunk_postfix, ID_call, 1, chunk_len_value);
+      int err = splice_chunks_write(backend, dest_fptr->fd, str, &watcher, &result);
+      if (err == -1) goto error; else if (err) goto syscallerror;
+    }
+  }
+
+  if (postfix != Qnil) {
+    int err = splice_chunks_write(backend, dest_fptr->fd, postfix, &watcher, &result);
+    if (err == -1) goto error; else if (err) goto syscallerror;
+  }
+
+  if (watcher.ctx.fiber == Qnil) {
+    result = backend_snooze();
+    if (TEST_EXCEPTION(result)) goto error;
+  }
+  RB_GC_GUARD(str);
+  RB_GC_GUARD(chunk_len_value);
+  RB_GC_GUARD(result);
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  return INT2NUM(total);
+syscallerror:
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  rb_syserr_fail(err, strerror(err));
+error:
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  return RAISE_EXCEPTION(result);
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
@@ -1267,6 +1448,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "kind", Backend_kind, 0);
   rb_define_method(cBackend, "chain", Backend_chain, -1);
   rb_define_method(cBackend, "idle_gc_period=", Backend_idle_gc_period_set, 1);
+  rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);

data/lib/polyphony/version.rb

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

data/test/test_backend.rb

@@ -282,6 +282,41 @@ class BackendTest < MiniTest::Test
     end
   end
 
+
+  def test_splice_chunks
+    body = 'abcd' * 250
+    chunk_size = 750
+
+    buf = +''
+    r, w = IO.pipe
+    reader = spin do
+      r.read_loop { |data| buf << data }
+    end
+
+    i, o = IO.pipe
+    writer = spin do
+      o << body
+      o.close
+    end
+    Thread.current.backend.splice_chunks(
+      i,
+      w,
+      "Content-Type: foo\r\n\r\n",
+      "0\r\n\r\n",
+      ->(len) { "#{len.to_s(16)}\r\n" },
+      "\r\n",
+      chunk_size
+    )
+    w.close
+    reader.await
+
+    expected = "Content-Type: foo\r\n\r\n#{750.to_s(16)}\r\n#{body[0..749]}\r\n#{250.to_s(16)}\r\n#{body[750..999]}\r\n0\r\n\r\n"
+    assert_equal expected, buf
+  ensure
+    o.close
+    w.close
+  end
+
   def test_idle_gc
     GC.disable
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: 0.56.0
+  version: 0.57.0
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-22 00:00:00.000000000 Z
+date: 2021-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -361,6 +361,7 @@ files:
 - examples/io/rack_server.rb
 - examples/io/raw.rb
 - examples/io/reline.rb
+- examples/io/splice_chunks.rb
 - examples/io/stdio.rb
 - examples/io/system.rb
 - examples/io/tcp_proxy.rb