polyphony 0.80 → 0.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf3658689c8bb7614624ad75492b16fc31401c5c8ee37cd510bb4aab1c9d1449
-  data.tar.gz: 5e2520d758db10e9dfe8022d6a85df61e1702f2e1e6560a95968e37b6f4f6e82
+  metadata.gz: 8f80cdfe71dec5b03bd98ffb4150beec84fd6e35b70b6e099fb223a1c78706bc
+  data.tar.gz: 8a245a57849a917814d5b8dbb563315e42291c0063f5fc353578af16002209bb
 SHA512:
-  metadata.gz: 7bd42d8fed28064941281c0e010f86a7ff7fff56e28c8e8190c8bc5c68eebd26a8d568e03ce20120db64684a036afb8d9b8586668c59f39fadebdaba2624ba75
-  data.tar.gz: cd91d0394a0642fbb43d59cc3ba6a3100377be955f1cabeebc051f8f6159d6fb0e78fa7deedabc6bc4fabc20b12453c963b85ed9ce76002211d3423b05f51542
+  metadata.gz: 0450fcbbe868c731f2e0b41bb196522f33487700eaf2636bb65d65def95af81d341057c071271aa726934008e19969a36a4e8e97e4775d9bb2660f5750708dc3
+  data.tar.gz: b789f4ad289136b91a24c3f68ddfc4864dbc2ede4989d7dafec09393527f6f93e44362843a406599a8d38f6f6f8e99626cffb88eb7395fdc99c1cbeafead87dc

data/.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ${{matrix.os}}
 
     env:
-      POLYPHONY_USE_LIBEV: "1"
+      POLYPHONY_LIBEV: "1"
 
     steps:
     - name: Setup machine

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.82 2022-03-04
+
+- Use `POLYPHONY_LIBEV` instead of `POLYPHONY_USE_LIBEV` environment variable
+- Add support for working with raw buffers (#78)
+
+## 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`

data/Gemfile.lock

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

data/bin/test

@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 set -e
-clear && POLYPHONY_USE_LIBEV=1 rake recompile && ruby test/run.rb
+clear && POLYPHONY_LIBEV=1 rake recompile && ruby test/run.rb
 clear && rake recompile && ruby test/run.rb

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

@@ -10,6 +10,7 @@ writer = Zlib::GzipWriter.new(w)
 writer << 'chunk'
 writer.flush
 p pos: writer.pos
-w.close
+# w.close
+writer.close
 
 p r.read

data/ext/polyphony/backend_common.c

@@ -470,3 +470,21 @@ int backend_getaddrinfo(VALUE host, VALUE port, struct sockaddr **ai_addr) {
   *ai_addr = addrinfo_result->ai_addr;
   return addrinfo_result->ai_addrlen;
 }
+
+struct io_buffer get_io_buffer(VALUE in) {
+  if (FIXNUM_P(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 };
+}
+
+VALUE coerce_io_string_or_buffer(VALUE buf) {
+  switch (TYPE(buf)) {
+    case T_STRING:
+    case T_FIXNUM:
+      return buf;
+    default:
+      return StringValue(buf);
+  }
+}

data/ext/polyphony/backend_common.h

@@ -55,7 +55,24 @@ struct backend_stats backend_base_stats(struct Backend_base *base);
 }
 #define COND_TRACE(base, ...) if (SHOULD_TRACE(base)) { TRACE(base, __VA_ARGS__); }
 
+// raw buffers
 
+struct raw_buffer {
+  char *ptr;
+  int len;
+};
+
+struct io_buffer {
+  char *ptr;
+  int len;
+  int raw;
+};
+
+#define FIX2PTR(v) ((void *)(FIX2LONG(v)))
+#define PTR2FIX(p) LONG2FIX((long)p)
+
+struct io_buffer get_io_buffer(VALUE in);
+VALUE coerce_io_string_or_buffer(VALUE buf);
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 int pidfd_open(pid_t pid, unsigned int flags);

data/ext/polyphony/backend_io_uring.c

@@ -332,23 +332,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.len) buf_pos = buffer.len;
+    buffer.ptr += buf_pos;
+    buffer.len -= 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.len) buf_pos = buffer.len;
+
+    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.len = expected_read_length;
+    }
+    else {
+      buffer.ptr += buf_pos;
+      buffer.len = string_cap - buf_pos;
+      if (buffer.len > expected_read_length)
+        buffer.len = 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 +378,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.ptr, buffer.len, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -383,26 +397,31 @@ 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.len) {
+        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.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.len = rb_str_capacity(str) - total - buf_pos;
+      }
+      else {
+        buffer.ptr += result;
+        buffer.len -= result;
+        if (!buffer.len) 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 +533,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.len;
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -532,7 +551,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.ptr, left, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -546,12 +565,12 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buf += result;
+      buffer.ptr += result;
       left -= result;
     }
   }
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 }
 
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
@@ -638,21 +657,36 @@ VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
 VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   Backend_t *backend;
   rb_io_t *fptr;
-  long dynamic_len = length == Qnil;
-  long len = 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;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);;
+  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.len) buf_pos = buffer.len;
+    buffer.ptr += buf_pos;
+    buffer.len -= 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.len) buf_pos = buffer.len;
+
+    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.len = expected_read_length;
+    }
+    else {
+      buffer.ptr += buf_pos;
+      buffer.len = string_cap - buf_pos;
+      if (buffer.len > expected_read_length)
+        buffer.len = expected_read_length;
+    }
   }
-  else buf_pos = 0;
-  shrinkable = io_setstrbuf(&str, buf_pos + len);
-  buf = RSTRING_PTR(str) + buf_pos;
 
   GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
@@ -668,7 +702,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
     int result;
     int completed;
 
-    io_uring_prep_recv(sqe, fptr->fd, buf, len - total, 0);
+    io_uring_prep_recv(sqe, fptr->fd, buffer.ptr, buffer.len, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -687,12 +721,13 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
     }
   }
 
-  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_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
@@ -802,10 +837,10 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   Backend_t *backend;
   rb_io_t *fptr;
   VALUE underlying_io;
-  char *buf;
-  long len;
-  long left;
-  int flags_int;
+
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.len;
+  int flags_int = NUM2INT(flags);
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -814,11 +849,6 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   GetOpenFile(io, fptr);
   io_unset_nonblock(fptr, io);
 
-  buf = StringValuePtr(str);
-  len = RSTRING_LEN(str);
-  left = len;
-  flags_int = NUM2INT(flags);
-
   while (left > 0) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
@@ -826,7 +856,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     int result;
     int completed;
 
-    io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
+    io_uring_prep_send(sqe, fptr->fd, buffer.ptr, left, flags_int);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -840,12 +870,12 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buf += result;
+      buffer.ptr += result;
       left -= result;
     }
   }
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 }
 
 VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {

data/ext/polyphony/backend_libev.c

@@ -270,21 +270,40 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
-  long dynamic_len = length == Qnil;
-  long len = dynamic_len ? 4096 : NUM2INT(length);
+
+  struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
-  if (str != Qnil) {
-    int current_len = RSTRING_LEN(str);
-    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
-  }
-  else buf_pos = 0;
-  int shrinkable = io_setstrbuf(&str, buf_pos + len);
-  char *buf = RSTRING_PTR(str) + buf_pos;
+  int shrinkable_string = 0;
+  int expandable_buffer = 0;
   long total = 0;
   VALUE switchpoint_result = Qnil;
   int read_to_eof = RTEST(to_eof);
   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
+  if (buffer.raw) {
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+    buffer.ptr += buf_pos;
+    buffer.len -= 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.len) buf_pos = buffer.len;
+
+    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.len = expected_read_length;
+    }
+    else {
+      buffer.ptr += buf_pos;
+      buffer.len = string_cap - buf_pos;
+      if (buffer.len > expected_read_length)
+        buffer.len = expected_read_length;
+    }
+  }
+
   GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
@@ -295,8 +314,8 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
   while (1) {
     backend->base.op_count++;
-    ssize_t n = read(fptr->fd, buf, len - total);
-    if (n < 0) {
+    ssize_t result = read(fptr->fd, buffer.ptr, buffer.len);
+    if (result < 0) {
       int e = errno;
       if (e != EWOULDBLOCK && e != EAGAIN) rb_syserr_fail(e, strerror(e));
 
@@ -308,32 +327,39 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       switchpoint_result = backend_snooze(&backend->base);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
-      if (n == 0) break; // EOF
-      total = total + n;
+      if (!result) break; // EOF
+
+      total += result;
       if (!read_to_eof) break;
 
-      if (total == len) {
-        if (!dynamic_len) break;
+      if (result == buffer.len) {
+        if (!expandable_buffer) break;
 
-        rb_str_resize(str, buf_pos + total);
-        rb_str_modify_expand(str, len);
-        buf = RSTRING_PTR(str) + buf_pos + total;
-        shrinkable = 0;
-        len += len;
+        // 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.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.len = rb_str_capacity(str) - total - buf_pos;
+      }
+      else {
+        buffer.ptr += result;
+        buffer.len -= result;
+        if (!buffer.len) break;
       }
-      else buf += n;
     }
   }
 
-  io_set_read_length(str, buf_pos + total, shrinkable);
-  io_enc_str(str, fptr);
-
-  if (total == 0) return Qnil;
+  if (!buffer.raw) {
+    io_set_read_length(str, buf_pos + total, shrinkable_string);
+    io_enc_str(str, fptr);
+  }
+  if (!total) return Qnil;
 
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return str;
+  return buffer.raw ? INT2FIX(total) : str;
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -453,9 +479,9 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
   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.len;
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
@@ -467,8 +493,8 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
 
   while (left > 0) {
     backend->base.op_count++;
-    ssize_t n = write(fptr->fd, buf, left);
-    if (n < 0) {
+    ssize_t result = write(fptr->fd, buffer.ptr, left);
+    if (result < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
@@ -477,8 +503,8 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      buf += n;
-      left -= n;
+      buffer.ptr += result;
+      left -= result;
     }
   }
 
@@ -491,7 +517,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -743,9 +769,9 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
   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.len;
   int flags_int = NUM2INT(flags);
 
   underlying_io = rb_ivar_get(io, ID_ivar_io);
@@ -758,8 +784,8 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
 
   while (left > 0) {
     backend->base.op_count++;
-    ssize_t n = send(fptr->fd, buf, left, flags_int);
-    if (n < 0) {
+    ssize_t result = send(fptr->fd, buffer.ptr, left, flags_int);
+    if (result < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
@@ -768,8 +794,8 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      buf += n;
-      left -= n;
+      buffer.ptr += result;
+      left -= result;
     }
   }
 
@@ -782,7 +808,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }

data/ext/polyphony/extconf.rb

@@ -16,7 +16,7 @@ def get_config
   version, major_revision, distribution = m[1].to_i, m[2].to_i, m[3]
   config[:pidfd_open] = (version == 5) && (major_revision >= 3)
 
-  force_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
+  force_libev = ENV['POLYPHONY_LIBEV'] != nil
   config[:io_uring] = !force_libev &&
     (version == 5) && (major_revision >= 6) && (distribution != 'linuxkit')
   config

data/ext/polyphony/polyphony.c

@@ -118,6 +118,52 @@ VALUE Polyphony_backend_write(int argc, VALUE *argv, VALUE self) {
   return Backend_write_m(argc, argv, BACKEND());
 }
 
+VALUE Polyphony_with_raw_buffer(VALUE self, VALUE size) {
+  struct raw_buffer buffer;
+  buffer.len = NUM2INT(size);
+  buffer.ptr = malloc(buffer.len);
+  if (!buffer.ptr)
+    rb_raise(rb_eRuntimeError, "Failed to allocate buffer");
+
+  VALUE return_value = rb_yield(PTR2FIX(&buffer));
+  free(buffer.ptr);
+  return return_value;
+}
+
+VALUE Polyphony_raw_buffer_get(int argc, VALUE *argv, VALUE self) {
+  VALUE buf = Qnil;
+  VALUE len = Qnil;
+  rb_scan_args(argc, argv, "11", &buf, &len);
+
+  struct raw_buffer *buffer = FIX2PTR(buf);
+  int length = (len == Qnil) ? buffer->len : FIX2INT(len);
+  
+  if (length > buffer->len) length = buffer->len;
+  return rb_utf8_str_new(buffer->ptr, length);
+}
+
+VALUE Polyphony_raw_buffer_set(VALUE self, VALUE buf, VALUE str) {
+  struct raw_buffer *buffer = FIX2PTR(buf);
+  int len = RSTRING_LEN(str);
+  if (len > buffer->len)
+    rb_raise(rb_eRuntimeError, "Given string does not fit in given buffer");
+  
+  memcpy(buffer->ptr, RSTRING_PTR(str), len);
+  buffer->len = len;
+  return self;
+}
+
+VALUE Polyphony_raw_buffer_size(VALUE self, VALUE buf) {
+  struct raw_buffer *buffer = FIX2PTR(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);
 // }
@@ -149,6 +195,12 @@ 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, "__with_raw_buffer__", Polyphony_with_raw_buffer, 1);
+  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/lib/polyphony/adapters/process.rb

@@ -24,8 +24,6 @@ module Polyphony
         kill_process(pid) unless terminated || pid.nil?
       end
 
-      private
-
       def kill_process(pid)
         cancel_after(5) do
           kill_and_await('TERM', pid)
@@ -34,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/net.rb

@@ -53,6 +53,21 @@ module Polyphony
         end
       end
 
+      # Sets up ALPN negotiation for the given context. The ALPN handler for the
+      # context will select the first protocol from the list given by the client
+      # that appears in the list of given protocols, according to the specified
+      # order.
+      # 
+      # @param context [SSLContext] SSL context
+      # @param protocols [Array] array of supported protocols
+      # @return [void]
+      def setup_alpn(context, protocols)
+        context.alpn_protocols = protocols
+        context.alpn_select_cb = lambda do |peer_protocols|
+          (protocols & peer_protocols).first
+        end
+      end
+
       private
 
       # Creates a listening `Socket` instance.
@@ -114,21 +129,6 @@ module Polyphony
         setup_alpn(context, opts[:alpn_protocols]) if opts[:alpn_protocols]
         OpenSSL::SSL::SSLServer.new(socket, context)
       end
-
-      # Sets up ALPN negotiation for the given context. The ALPN handler for the
-      # context will select the first protocol from the list given by the client
-      # that appears in the list of given protocols, according to the specified
-      # order.
-      # 
-      # @param context [SSLContext] SSL context
-      # @param protocols [Array] array of supported protocols
-      # @return [void]
-      def setup_alpn(context, protocols)
-        context.alpn_protocols = protocols
-        context.alpn_select_cb = lambda do |peer_protocols|
-          (protocols & peer_protocols).first
-        end
-      end
     end
   end
 end

data/lib/polyphony/version.rb

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

data/test/test_io.rb

@@ -281,6 +281,41 @@ class IOTest < MiniTest::Test
   end
 end
 
+class IOWithRawBufferTest < MiniTest::Test
+  def setup
+    super
+    @i, @o = IO.pipe
+  end
+
+  def test_write_with_raw_buffer
+    Polyphony.__with_raw_buffer__(64) do |b|
+      Polyphony.__raw_buffer_set__(b, 'foobar')
+      @o << b
+      @o.close
+    end
+
+    str = @i.read
+    assert_equal 'foobar', str
+  end
+
+  def test_read_with_raw_buffer
+    @o << '*' * 65
+    @o.close
+    chunks = []
+    Polyphony.__with_raw_buffer__(64) do |b|
+      res = @i.read(64, b)
+      assert_equal 64, res
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+
+      res = @i.read(64, b)
+      assert_equal 1, res
+      assert_equal 64, Polyphony.__raw_buffer_size__(b)
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+    end
+    assert_equal ['*' * 64, '*'], chunks
+  end
+end
+
 class IOClassMethodsTest < MiniTest::Test
   def test_binread
     s = IO.binread(__FILE__)

data/test/test_raw_buffer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'msgpack'
+
+class RawBufferTest < MiniTest::Test
+  def test_with_raw_buffer
+    result = Polyphony.__with_raw_buffer__(64) do |b|
+      assert_kind_of Integer, b
+      assert_equal 64, Polyphony.__raw_buffer_size__(b)
+      :foo
+    end
+    assert_equal :foo, result
+  end
+
+  def test_raw_buffer_get_set
+    Polyphony.__with_raw_buffer__(64) do |b|
+      # should raise if buffer not big enough
+      assert_raises { Polyphony.__raw_buffer_set__(b, '*' * 65) }
+
+      Polyphony.__raw_buffer_set__(b, 'foobar')
+      assert_equal 6, Polyphony.__raw_buffer_size__(b)
+
+      str = Polyphony.__raw_buffer_get__(b)
+      assert_equal 'foobar', str
+
+      str = Polyphony.__raw_buffer_get__(b, 3)
+      assert_equal 'foo', str
+
+      Polyphony.__raw_buffer_set__(b, '')
+      assert_equal 0, Polyphony.__raw_buffer_size__(b)
+
+      str = Polyphony.__raw_buffer_get__(b)
+      assert_equal '', str
+    end
+  end
+end

data/test/test_socket.rb

@@ -193,6 +193,55 @@ class SocketTest < MiniTest::Test
   end
 end
 
+class SocketWithRawBufferTest < MiniTest::Test
+  def start_tcp_server_on_random_port(host = '127.0.0.1')
+    port = rand(1100..60000)
+    server = TCPServer.new(host, port)
+    [port, server]
+  rescue Errno::EADDRINUSE
+    retry
+  end  
+
+  def setup
+    super
+
+    port, server = start_tcp_server_on_random_port
+    connector = spin { @o = TCPSocket.new('127.0.0.1', port) }
+    @i = server.accept
+  end
+
+  def test_send_with_raw_buffer
+    Polyphony.__with_raw_buffer__(64) do |b|
+      Polyphony.__raw_buffer_set__(b, 'foobar')
+      @o << b
+      @o.close
+    end
+
+    str = @i.read
+    assert_equal 'foobar', str
+  end
+
+  def test_recv_with_raw_buffer
+    @o << '*' * 65
+    @o.close
+    chunks = []
+    Polyphony.__with_raw_buffer__(64) do |b|
+      res = @i.recv(64, 0, b)
+      assert_equal 64, res
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+
+      res = @i.recv(64, 0, b)
+      assert_equal 1, res
+      assert_equal 64, Polyphony.__raw_buffer_size__(b)
+      chunks << Polyphony.__raw_buffer_get__(b, res)
+
+      res = @i.recv(64, 0, b)
+      assert_nil res
+    end
+    assert_equal ['*' * 64, '*'], chunks
+  end
+end
+
 if IS_LINUX
   class HTTPClientTest < MiniTest::Test
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.80'
+  version: '0.82'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-28 00:00:00.000000000 Z
+date: 2022-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -232,6 +232,7 @@ files:
 - examples/core/nested.rb
 - examples/core/pingpong.rb
 - examples/core/queue.rb
+- examples/core/raw_buffer_test.rb
 - examples/core/recurrent-timer.rb
 - examples/core/resource_delegate.rb
 - examples/core/ring.rb
@@ -398,6 +399,7 @@ files:
 - test/test_kernel.rb
 - test/test_process_supervision.rb
 - test/test_queue.rb
+- test/test_raw_buffer.rb
 - test/test_resource_pool.rb
 - test/test_signal.rb
 - test/test_socket.rb