polyphony 1.3 → 1.5

data/ext/polyphony/backend_libev.c

@@ -42,21 +42,24 @@ thread.
 #define _GNU_SOURCE 1
 #endif
 
-#include <netdb.h>
-#include <sys/socket.h>
-#include <sys/uio.h>
 #include <unistd.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
 #include <stdnoreturn.h>
 #include <sys/types.h>
+
+#ifdef POLYPHONY_USE_PIDFD_OPEN
 #include <sys/wait.h>
+#endif
+
 #include <fcntl.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
 #include "ruby/io.h"
 
+#ifndef POLYPHONY_WINDOWS
+#include <sys/uio.h>
+#endif
+
 #include "../libev/ev.h"
 #include "backend_common.h"
 
@@ -267,21 +270,25 @@ VALUE libev_wait_fd(Backend_t *backend, int fd, int events, int raise_exception)
 }
 
 static inline int fd_from_io(VALUE io, rb_io_t **fptr, int write_mode, int rectify_file_pos) {
+  if (TYPE(io) == T_FIXNUM) {
+    *fptr = NULL;
+    return FIX2INT(io);
+  }
+  
   if (rb_obj_class(io) == cPipe) {
     *fptr = NULL;
     Pipe_verify_blocking_mode(io, Qfalse);
     return Pipe_get_fd(io, write_mode);
   }
-  else {
-    VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
-    if (underlying_io != Qnil) io = underlying_io;
-
-    GetOpenFile(io, *fptr);
-    int fd = rb_io_descriptor(io);
-    io_verify_blocking_mode(io, fd, Qfalse);
-    if (rectify_file_pos) rectify_io_file_pos(*fptr);
-    return fd;
-  }
+
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+
+  GetOpenFile(io, *fptr);
+  int fd = rb_io_descriptor(io);
+  io_verify_blocking_mode(io, fd, Qfalse);
+  if (rectify_file_pos) rectify_io_file_pos(*fptr);
+  return fd;
 }
 
 VALUE Backend_read(VALUE self, VALUE io, VALUE buffer, VALUE length, VALUE to_eof, VALUE pos) {
@@ -558,6 +565,7 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+#ifndef POLYPHONY_WINDOWS
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   Backend_t *backend;
   struct libev_io watcher;
@@ -629,15 +637,23 @@ error:
   free(iov);
   return RAISE_EXCEPTION(switchpoint_result);
 }
+#endif
 
 VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
   if (argc < 2)
     // TODO: raise ArgumentError
     rb_raise(rb_eRuntimeError, "(wrong number of arguments (expected 2 or more))");
 
+#ifdef POLYPHONY_WINDOWS
+  int total = 0;
+  for (int i = 1; i < argc; i++)
+    total += FIX2INT(Backend_write(self, argv[0], argv[i]));
+  return INT2FIX(total);
+#else
   return (argc == 2) ?
     Backend_write(self, argv[0], argv[1]) :
     Backend_writev(self, argv[0], argc - 1, argv + 1);
+#endif
 }
 
 VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
@@ -1135,6 +1151,31 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   return libev_wait_fd(backend, fd, events, 1);
 }
 
+VALUE Backend_close(VALUE self, VALUE io) {
+  Backend_t *backend;
+  rb_io_t *fptr;
+  VALUE resume_value = Qnil;
+  int result;
+  int fd = fd_from_io(io, &fptr, 0, 0);
+  if (fd < 0) return Qnil;
+
+  GetBackend(self, backend);
+
+  result = close(fd);
+  if (result == -1) {
+    int err = errno;
+    rb_syserr_fail(err, strerror(err));
+  }
+
+  resume_value = backend_snooze(&backend->base);
+  RAISE_IF_EXCEPTION(resume_value);
+  RB_GC_GUARD(resume_value);
+
+  if (fptr) fptr_finalize(fptr);
+  // fd = -1;
+  return io;
+}
+
 struct libev_timer {
   struct ev_timer timer;
   VALUE fiber;
@@ -1292,6 +1333,7 @@ struct libev_child {
   VALUE fiber;
 };
 
+#ifndef POLYPHONY_WINDOWS
 void Backend_child_callback(EV_P_ ev_child *w, int revents) {
   struct libev_child *watcher = (struct libev_child *)w;
   int exit_status = WEXITSTATUS(w->rstatus);
@@ -1300,8 +1342,12 @@ void Backend_child_callback(EV_P_ ev_child *w, int revents) {
   status = rb_ary_new_from_args(2, INT2FIX(w->rpid), INT2FIX(exit_status));
   Fiber_make_runnable(watcher->fiber, status);
 }
+#endif
 
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
+#ifdef POLYPHONY_WINDOWS
+  rb_raise(rb_eStandardError, "Not implemented");
+#else
   Backend_t *backend;
   struct libev_child watcher;
   VALUE switchpoint_result = Qnil;
@@ -1319,6 +1365,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
+#endif
 }
 #endif
 
@@ -1472,6 +1519,7 @@ done:
 #endif
 }
 
+#ifdef POLYPHONY_LINUX
 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);
@@ -1561,6 +1609,7 @@ error:
   if (pipefd[1] != -1) close(pipefd[1]);
   return RAISE_EXCEPTION(result);
 }
+#endif
 
 VALUE Backend_trace(int argc, VALUE *argv, VALUE self) {
   Backend_t *backend;
@@ -1626,7 +1675,10 @@ void Init_Backend(void) {
   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, "idle_proc=", Backend_idle_proc_set, 1);
+  
+  #ifdef POLYPHONY_LINUX
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
+  #endif
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
@@ -1654,6 +1706,7 @@ void Init_Backend(void) {
   rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "write", Backend_write_m, -1);
+  rb_define_method(cBackend, "close", Backend_close, 1);
 
   SYM_libev = ID2SYM(rb_intern("libev"));
 

data/ext/polyphony/extconf.rb

@@ -2,12 +2,14 @@
 
 require 'rubygems'
 require 'mkmf'
+require 'rbconfig'
 
 dir_config 'polyphony_ext'
 
 KERNEL_INFO_RE = /Linux (\d)\.(\d+)(?:\.)?((?:\d+\.?)*)(?:\-)?([\w\-]+)?/
 def get_config
   config = { linux: !!(RUBY_PLATFORM =~ /linux/) }
+  config[:windows] = !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
   return config if !config[:linux]
 
   kernel_info = `uname -sr`
@@ -17,7 +19,8 @@ def get_config
   version, major_revision, distribution = m[1].to_i, m[2].to_i, m[4]
 
   combined_version = version.to_i * 100 + major_revision.to_i
-
+  
+  config[:kernel_version]     = combined_version
   config[:pidfd_open]         = combined_version > 503
   config[:multishot_recv]     = combined_version >= 600
   config[:multishot_recvmsg]  = combined_version >= 600
@@ -31,7 +34,7 @@ def get_config
 end
 
 config = get_config
-puts "Building Polyphony... (#{config.inspect})"
+puts "Building Polyphony (\n#{config.map { |(k, v)| "  #{k}: #{v}\n"}.join})"
 
 require_relative 'zlib_conf'
 
@@ -71,6 +74,7 @@ if config[:io_uring]
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
   $defs << "-DPOLYPHONY_LINUX" if config[:linux]
+  $defs << "-DPOLYPHONY_WINDOWS" if config[:windows]
 
   $defs << "-DEV_STANDALONE" # prevent libev from assuming "config.h" exists
 

data/ext/polyphony/pipe.c

@@ -97,8 +97,8 @@ VALUE Pipe_close(VALUE self) {
   if (pipe->w_closed)
     rb_raise(rb_eRuntimeError, "Pipe is already closed for writing");
 
+  Backend_close(BACKEND(), INT2FIX(pipe->fds[1]));
   pipe->w_closed = 1;
-  close(pipe->fds[1]);
   return self;
 }
 

data/ext/polyphony/polyphony.c

@@ -80,20 +80,6 @@ VALUE Polyphony_backend_accept_loop(VALUE self, VALUE server_socket, VALUE socke
   return Backend_accept_loop(BACKEND(), server_socket, socket_class);
 }
 
-#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-/* Starts a multishot accept operation on the given server socket. This API is
- * available only for the io_uring backend.
- *
- * @param server_socket [Socket] socket to accept on
- * @return [any] block return value
- */
-
-VALUE Polyphony_backend_multishot_accept(VALUE self, VALUE server_socket) {
-  return Backend_multishot_accept(BACKEND(), server_socket);
-}
-#endif
-
-
 /* Connects the given socket to the given address and port.
  *
  * @param io [Socket] socket to connect
@@ -404,9 +390,26 @@ VALUE Polyphony_raw_buffer_size(VALUE self, VALUE buffer) {
   return INT2FIX(buffer_spec->len);
 }
 
-// VALUE Polyphony_backend_close(VALUE self, VALUE io) {
-//   return Backend_close(BACKEND(), io);
-// }
+/* Closes the given IO.
+ *
+ * @param io [IO, Polyphony::Pipe] IO instance
+ * @return [IO, Polyphony::Pipe] given IO
+ */
+
+VALUE Polyphony_backend_close(VALUE self, VALUE io) {
+  return Backend_close(BACKEND(), io);
+}
+
+/* Ensures the given IO is in blocking/non-blocking mode.
+ *
+ * @param io [IO, Polyphony::Pipe] IO instance
+ * @param blocking [boolean] true for blocking, false for non-blocking mode
+ * @return [IO, Polyphony::Pipe] given IO
+ */
+
+VALUE Polyphony_backend_verify_blocking_mode(VALUE self, VALUE io, VALUE blocking) {
+  return Backend_verify_blocking_mode(BACKEND(), io, blocking);
+}
 
 void Init_Polyphony(void) {
   mPolyphony = rb_define_module("Polyphony");
@@ -416,12 +419,6 @@ void Init_Polyphony(void) {
   rb_define_singleton_method(mPolyphony, "backend_accept_loop", Polyphony_backend_accept_loop, 2);
   rb_define_singleton_method(mPolyphony, "backend_connect", Polyphony_backend_connect, 3);
   rb_define_singleton_method(mPolyphony, "backend_feed_loop", Polyphony_backend_feed_loop, 3);
-
-  #ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-  rb_define_singleton_method(mPolyphony, "backend_multishot_accept", Polyphony_backend_multishot_accept, 1);
-  #endif
-
-
   rb_define_singleton_method(mPolyphony, "backend_read", Polyphony_backend_read, 5);
   rb_define_singleton_method(mPolyphony, "backend_read_loop", Polyphony_backend_read_loop, 2);
   rb_define_singleton_method(mPolyphony, "backend_recv", Polyphony_backend_recv, 4);
@@ -448,8 +445,8 @@ void Init_Polyphony(void) {
   rb_define_singleton_method(mPolyphony, "backend_wait_io", Polyphony_backend_wait_io, 2);
   rb_define_singleton_method(mPolyphony, "backend_waitpid", Polyphony_backend_waitpid, 1);
   rb_define_singleton_method(mPolyphony, "backend_write", Polyphony_backend_write, -1);
-  // rb_define_singleton_method(mPolyphony, "backend_close", Polyphony_backend_close, 1);
-  rb_define_singleton_method(mPolyphony, "backend_verify_blocking_mode", Backend_verify_blocking_mode, 2);
+  rb_define_singleton_method(mPolyphony, "backend_close", Polyphony_backend_close, 1);
+  rb_define_singleton_method(mPolyphony, "backend_verify_blocking_mode", Polyphony_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);

data/ext/polyphony/polyphony.h

@@ -101,11 +101,6 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class);
 VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class);
 VALUE Backend_connect(VALUE self, VALUE io, VALUE addr, VALUE port);
 VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method);
-
-#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-VALUE Backend_multishot_accept(VALUE self, VALUE io);
-#endif
-
 VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos);
 VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen);
 VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos);
@@ -133,7 +128,7 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write);
 VALUE Backend_waitpid(VALUE self, VALUE pid);
 VALUE Backend_write(VALUE self, VALUE io, VALUE str);
 VALUE Backend_write_m(int argc, VALUE *argv, VALUE self);
-// VALUE Backend_close(VALUE self, VALUE io);
+VALUE Backend_close(VALUE self, VALUE io);
 
 VALUE Backend_poll(VALUE self, VALUE blocking);
 VALUE Backend_wait_event(VALUE self, VALUE raise_on_exception);

data/ext/polyphony/win_uio.h

@@ -0,0 +1,18 @@
+// source: https://stackoverflow.com/questions/57897314/fatal-error-when-compiling-include-sys-uio-h-on-project-windows
+
+#ifndef SYS_UIO_H
+#define SYS_UIO_H
+
+#include <inttypes.h>
+#include <unistd.h>
+
+struct iovec
+{
+    void    *iov_base;  /* Base address of a memory region for input or output */
+    size_t   iov_len;   /* The size of the memory pointed to by iov_base */
+};
+
+ ssize_t readv(int fildes, const struct iovec *iov, int iovcnt);
+ssize_t writev(int fildes, const struct iovec *iov, int iovcnt);
+
+#endif /* SYS_UIO_H */

data/lib/polyphony/core/debug.rb

@@ -52,7 +52,7 @@ module Polyphony
 
       # Converts an event (expressed as an array) to a hash.
       #
-      # @param e [Array] event as emitted by the backend
+      # @param event [Array] event as emitted by the backend
       # @return [Hash] event hash
       def trace_event_info(event)
         {
@@ -65,7 +65,7 @@ module Polyphony
 
       # Returns an event hash for a `:block` event.
       #
-      # @param e [Array] event array
+      # @param event [Array] event array
       # @return [Hash] event hash
       def event_props_block(event)
         {
@@ -76,7 +76,7 @@ module Polyphony
 
       # Returns an event hash for a `:enter_poll` event.
       #
-      # @param e [Array] event array
+      # @param _event [Array] event array
       # @return [Hash] event hash
       def event_props_enter_poll(_event)
         {}
@@ -84,7 +84,7 @@ module Polyphony
 
       # Returns an event hash for a `:leave_poll` event.
       #
-      # @param e [Array] event array
+      # @param _event [Array] event array
       # @return [Hash] event hash
       def event_props_leave_poll(_event)
         {}
@@ -92,7 +92,7 @@ module Polyphony
 
       # Returns an event hash for a `:schedule` event.
       #
-      # @param e [Array] event array
+      # @param event [Array] event array
       # @return [Hash] event hash
       def event_props_schedule(event)
         {
@@ -105,7 +105,7 @@ module Polyphony
 
       # Returns an event hash for a `:spin` event.
       #
-      # @param e [Array] event array
+      # @param event [Array] event array
       # @return [Hash] event hash
       def event_props_spin(event)
         {
@@ -117,7 +117,7 @@ module Polyphony
 
       # Returns an event hash for a `:terminate` event.
       #
-      # @param e [Array] event array
+      # @param event [Array] event array
       # @return [Hash] event hash
       def event_props_terminate(event)
         {
@@ -128,7 +128,7 @@ module Polyphony
 
       # Returns an event hash for a `:unblock` event.
       #
-      # @param e [Array] event array
+      # @param event [Array] event array
       # @return [Hash] event hash
       def event_props_unblock(event)
         {

data/lib/polyphony/extensions/io.rb

@@ -197,7 +197,7 @@ class ::IO
   alias_method :orig_read, :read
 
   # @!visibility private
-  def read(len = nil, buf = nil, buffer_pos: 0)
+  def read(len = nil, buf = nil, buffer_pos = 0)
     return '' if len == 0
     return Polyphony.backend_read(self, buf, len, true, buffer_pos) if buf
 
@@ -214,7 +214,7 @@ class ::IO
   alias_method :orig_readpartial, :read
 
   # @!visibility private
-  def readpartial(len, str = +'', buffer_pos: 0, raise_on_eof: true)
+  def readpartial(len, str = +'', buffer_pos = 0, raise_on_eof = true)
     result = Polyphony.backend_read(self, str, len, false, buffer_pos)
     raise EOFError if !result && raise_on_eof
 
@@ -255,7 +255,7 @@ class ::IO
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      result = readpartial(8192, @read_buffer, buffer_pos: -1)
+      result = readpartial(8192, @read_buffer, -1)
       return nil unless result
     end
   rescue EOFError
@@ -280,7 +280,7 @@ class ::IO
         yield line
       end
 
-      result = readpartial(8192, @read_buffer, buffer_pos: -1)
+      result = readpartial(8192, @read_buffer, -1)
       return self if !result
     end
   rescue EOFError
@@ -427,6 +427,19 @@ class ::IO
     Polyphony.backend_splice(src, self, maxlen)
   end
 
+  # @!visibility private
+  alias_method :orig_close, :close
+
+  # Closes the IO instance
+  #
+  # @return [void]
+  def close
+    return if closed?
+
+    Polyphony.backend_close(self)
+    nil
+  end
+
   if RUBY_PLATFORM =~ /linux/
     # Tees data from the given IO.
     #

data/lib/polyphony/extensions/kernel.rb

@@ -5,6 +5,22 @@ require 'open3'
 module Polyphony
   # Intercepts calls to #trap
   module TrapInterceptor
+    # Installs a signal handler. If a block is given (or the command parameter
+    # is a Proc or a callable), it is executed inside an out-of-band,
+    # prioritized fiber.
+    #
+    # If the command is the string “IGNORE” or “SIG_IGN”, the signal will be
+    # ignored. If the command is “DEFAULT” or “SIG_DFL”, the Ruby’s default
+    # handler will be invoked. If the command is “EXIT”, the script will be
+    # terminated by the signal. If the command is “SYSTEM_DEFAULT”, the
+    # operating system’s default handler will be invoked. Otherwise, the given
+    # command or block will be run. The special signal name “EXIT” or signal
+    # number zero will be invoked just prior to program termination.
+    #
+    # trap returns the previous handler for the given signal.
+    #
+    # @param sig [String, Symbol, Integer] signal name or number
+    # @param command [String, Proc] command to perform
     def trap(sig, command = nil, &block)
       return super(sig, command) if command.is_a? String
 

data/lib/polyphony/extensions/openssl.rb

@@ -90,7 +90,7 @@ class ::OpenSSL::SSL::SSLSocket
 
   # Reads from the socket. If `maxlen` is given, reads up to `maxlen` bytes from
   # the socket, otherwise reads to `EOF`. If `buf` is given, it is used as the
-  # buffer to read into, otherwise a new string is allocated. If `buf_pos` is
+  # buffer to read into, otherwise a new string is allocated. If `buffer_pos` is
   # given, reads into the given offset (in bytes) in the given buffer. If the
   # given buffer offset is negative, it is calculated from the current end of
   # the buffer (`-1` means the read data will be appended to the end of the
@@ -101,21 +101,21 @@ class ::OpenSSL::SSL::SSLSocket
   #
   # @param maxlen [Integer, nil] maximum bytes to read from socket
   # @param buf [String, nil] buffer to read into
-  # @param buf_pos [Number] buffer position to read into
+  # @param buffer_pos [Number] buffer position to read into
   # @return [String] buffer used for reading
-  def read(maxlen = nil, buf = nil, buffer_pos: 0)
-    return readpartial(maxlen, buf, buffer_pos:) if buf
+  def read(maxlen = nil, buf = nil, buffer_pos = 0)
+    return readpartial(maxlen, buf, buffer_pos) if buf
 
     buf = +''
     return readpartial(maxlen, buf) if maxlen
 
-    readpartial(4096, buf, buffer_pos: -1) while true
+    readpartial(4096, buf, -1) while true
   rescue EOFError
     buf
   end
 
   # Reads up to `maxlen` from the socket. If `buf` is given, it is used as the
-  # buffer to read into, otherwise a new string is allocated. If `buf_pos` is
+  # buffer to read into, otherwise a new string is allocated. If `buffer_pos` is
   # given, reads into the given offset (in bytes) in the given buffer. If the
   # given buffer offset is negative, it is calculated from the current end of
   # the buffer (`-1` means the read data will be appended to the end of the
@@ -127,16 +127,16 @@ class ::OpenSSL::SSL::SSLSocket
   #
   # @param maxlen [Integer, nil] maximum bytes to read from socket
   # @param buf [String, nil] buffer to read into
-  # @param buf_pos [Number] buffer position to read into
+  # @param buffer_pos [Number] buffer position to read into
   # @param raise_on_eof [bool] whether to raise an exception on `EOF`
   # @return [String, nil] buffer used for reading or nil on `EOF`
-  def readpartial(maxlen, buf = +'', buffer_pos: 0, raise_on_eof: true)
-    if buf_pos != 0
+  def readpartial(maxlen, buf = +'', buffer_pos = 0, raise_on_eof = true)
+    if buffer_pos != 0
       if (result = sysread(maxlen, +''))
-        if buf_pos == -1
+        if buffer_pos == -1
           result = buf + result
         else
-          result = buf[0...buf_pos] + result
+          result = buf[0...buffer_pos] + result
         end
       end
     else

data/lib/polyphony/extensions/pipe.rb

@@ -41,9 +41,9 @@ class Polyphony::Pipe
   #
   # @param len [Integer, nil] maximum bytes to read
   # @param buf [String, nil] buffer to read into
-  # @param buf_pos [Integer] buffer position to read into
+  # @param buffer_pos [Integer] buffer position to read into
   # @return [String] read data
-  def read(len = nil, buf = nil, buffer_pos: 0)
+  def read(len = nil, buf = nil, buffer_pos = 0)
     return Polyphony.backend_read(self, buf, len, true, buffer_pos) if buf
 
     @read_buffer ||= +''
@@ -59,10 +59,10 @@ class Polyphony::Pipe
   #
   # @param len [Integer, nil] maximum bytes to read
   # @param buf [String, nil] buffer to read into
-  # @param buf_pos [Integer] buffer position to read into
+  # @param buffer_pos [Integer] buffer position to read into
   # @param raise_on_eof [boolean] whether to raise an error if EOF is detected
   # @return [String] read data
-  def readpartial(len, buf = +'', buffer_pos: 0, raise_on_eof: true)
+  def readpartial(len, buf = +'', buffer_pos = 0, raise_on_eof = true)
     result = Polyphony.backend_read(self, buf, len, false, buffer_pos)
     raise EOFError if !result && raise_on_eof
 
@@ -104,7 +104,7 @@ class Polyphony::Pipe
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      result = readpartial(8192, @read_buffer, buffer_pos: -1)
+      result = readpartial(8192, @read_buffer, -1)
       return nil unless result
     end
   rescue EOFError