io_splice 3.1.0 → 4.0.0

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v3.1.0.GIT
+DEF_VER=v4.0.0.GIT
 
 LF='
 '

data/ext/io_splice/io_splice_ext.c

@@ -13,6 +13,7 @@
 #include <sys/utsname.h>
 
 static VALUE sym_EAGAIN;
+#define WAITALL 0x4000000
 
 #ifndef F_LINUX_SPECIFIC_BASE
 #  define F_LINUX_SPECIFIC_BASE 1024
@@ -37,13 +38,26 @@ static VALUE sym_EAGAIN;
 #  endif
 #endif
 
+#ifndef SSIZET2NUM
+#  define SSIZET2NUM(x) LONG2NUM(x)
+#endif
+#ifndef NUM2SSIZET
+#  define NUM2SSIZET(x) NUM2LONG(x)
+#endif
+#ifndef SIZET2NUM
+#  define SIZET2NUM(x) ULONG2NUM(x)
+#endif
+#ifndef NUM2SIZET
+#  define NUM2SIZET(x) NUM2ULONG(x)
+#endif
+
 static int my_fileno(VALUE io)
 {
 	rb_io_t *fptr;
 
 	for (;;) {
 		switch (TYPE(io)) {
-		case T_FIXNUM: return NUM2INT(io);
+		case T_FIXNUM: return FIX2INT(io);
 		case T_FILE: {
 			GetOpenFile(io, fptr);
 			return FPTR_TO_FD(fptr);
@@ -54,6 +68,14 @@ static int my_fileno(VALUE io)
 		}
 	}
 }
+
+static int check_fileno(VALUE io)
+{
+	int saved_errno = errno;
+	int fd = my_fileno(io);
+	errno = saved_errno;
+	return fd;
+}
 #ifndef HAVE_RB_THREAD_BLOCKING_REGION
 /* partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
 #  include <rubysig.h>
@@ -95,21 +117,6 @@ static VALUE io_run(rb_blocking_function_t *fn, void *data)
 	return rb_thread_blocking_region(fn, data, RUBY_UBF_IO, 0);
 }
 
-/*
- * Releases GVL only iff blocking I/O is used.
- * Only use this if all file descriptors in data are pipes.
- * We'll trust programmers who use non-blocking I/O explicitly to
- * want the fastest possible performance without resorting to threads,
- * so releasing and them immediately reacquiring the GVL would be
- * a waste of time.
- */
-static VALUE nb_io_run(rb_blocking_function_t *fn, void *data, unsigned flags)
-{
-	if (flags & SPLICE_F_NONBLOCK)
-		return fn(data);
-	return io_run(fn, data);
-}
-
 struct splice_args {
 	int fd_in;
 	off_t *off_in;
@@ -127,32 +134,65 @@ static VALUE nogvl_splice(void *ptr)
 	                     a->len, a->flags);
 }
 
-static long do_splice(int argc, VALUE *argv, unsigned dflags)
+static ssize_t do_splice(int argc, VALUE *argv, unsigned dflags)
 {
-	off_t i, o;
-	VALUE fd_in, off_in, fd_out, off_out, len, flags;
+	off_t i = 0, o = 0;
+	VALUE io_in, off_in, io_out, off_out, len, flags;
 	struct splice_args a;
+	ssize_t bytes;
+	ssize_t total = 0;
+	unsigned waitall;
 
 	rb_scan_args(argc, argv, "51",
-	             &fd_in, &off_in, &fd_out, &off_out, &len, &flags);
+	             &io_in, &off_in, &io_out, &off_out, &len, &flags);
 
 	a.off_in = NIL_P(off_in) ? NULL : (i = NUM2OFFT(off_in), &i);
 	a.off_out = NIL_P(off_out) ? NULL : (o = NUM2OFFT(off_out), &o);
-	a.fd_in = my_fileno(fd_in);
-	a.fd_out = my_fileno(fd_out);
-	a.len = (size_t)NUM2ULONG(len);
+	a.len = NUM2SIZET(len);
 	a.flags = NIL_P(flags) ? dflags : NUM2UINT(flags) | dflags;
+	waitall = a.flags & WAITALL;
+	if (waitall)
+		a.flags ^= WAITALL;
 
-	return (long)io_run(nogvl_splice, &a);
+	for (;;) {
+		a.fd_in = check_fileno(io_in);
+		a.fd_out = check_fileno(io_out);
+		bytes = (ssize_t)io_run(nogvl_splice, &a);
+		if (bytes == -1) {
+			if (errno == EINTR)
+				continue;
+			if (waitall && errno == EAGAIN) {
+				rb_io_wait_readable(check_fileno(io_in));
+				errno = EAGAIN;
+				rb_io_wait_writable(check_fileno(io_out));
+				continue;
+			}
+			if (total > 0)
+				return total;
+			return bytes;
+		} else if (bytes == 0) {
+			break;
+		} else if (waitall) {
+			total += bytes;
+			if ((a.len -= bytes) == 0)
+				return total;
+			i += bytes;
+			o += bytes;
+		} else {
+			return bytes;
+		}
+	}
+
+	return total;
 }
 
 /*
  * call-seq:
- *    IO.splice(fd_in, off_in, fd_out, off_out, len) => integer
- *    IO.splice(fd_in, off_in, fd_out, off_out, len, flags) => integer
+ *    IO.splice(io_in, off_in, io_out, off_out, len) => integer
+ *    IO.splice(io_in, off_in, io_out, off_out, len, flags) => integer
  *
- * Splice +len+ bytes from/to a pipe.  Either +fd_in+ or +fd_out+
- * MUST be a pipe.  +fd_in+ and +fd_out+ may BOTH be pipes as of
+ * Splice +len+ bytes from/to a pipe.  Either +io_in+ or +io_out+
+ * MUST be a pipe.  +io_in+ and +io_out+ may BOTH be pipes as of
  * Linux 2.6.31 or later.
  *
  * +off_in+ and +off_out+ if non-nil may be used to
@@ -161,22 +201,18 @@ static long do_splice(int argc, VALUE *argv, unsigned dflags)
  * +flags+ defaults to zero if unspecified.
  * +flags+ may be a bitmask of the following flags:
  *
- * IO::Splice::F_MOVE, IO::Splice::F_NONBLOCK, IO::Splice::F_MORE
+ * * IO::Splice::F_MOVE
+ * * IO::Splice::F_NONBLOCK
+ * * IO::Splice::F_MORE
+ * * IO::Splice::WAITALL
  *
  * Returns the number of bytes spliced.
- * Raises EOFError when +fd_in+ has reached end of file.
+ * Raises EOFError when +io_in+ has reached end of file.
  * Raises Errno::EAGAIN if the IO::Splice::F_NONBLOCK flag is set
  * and the pipe has no data to read from or space to write to.  May
  * also raise Errno::EAGAIN if the non-pipe descriptor has no data
  * to read from or space to write to.
  *
- *     rd, wr = (pipe = IO.pipe).map { |io| io.fileno }
- *     src_io, dst_io = File.open("/path/to/src"), File.open("/path/to/dst")
- *     src, dst = src_io.fileno, dst_io.fileno
- *
- *     nr = IO.splice(src, nil, wr, nil, IO::Splice::PIPE_CAPA, 0)
- *     IO.splice(rd, nil, dst, nil, nr, 0)
- *
  * As splice never exposes buffers to userspace, it will not take
  * into account userspace buffering done by Ruby or stdio.  It is
  * also not subject to encoding/decoding filters under Ruby 1.9.
@@ -190,19 +226,19 @@ static long do_splice(int argc, VALUE *argv, unsigned dflags)
  */
 static VALUE my_splice(int argc, VALUE *argv, VALUE self)
 {
-	long n = do_splice(argc, argv, 0);
+	ssize_t n = do_splice(argc, argv, 0);
 
 	if (n == 0)
 		rb_eof_error();
-	if (n < 0)
+	if (n == -1)
 		rb_sys_fail("splice");
-	return LONG2NUM(n);
+	return SSIZET2NUM(n);
 }
 
 /*
  * call-seq:
- *    IO.trysplice(fd_in, off_in, fd_out, off_out, len) => integer
- *    IO.trysplice(fd_in, off_in, fd_out, off_out, len, flags) => integer
+ *    IO.trysplice(io_in, off_in, io_out, off_out, len) => integer
+ *    IO.trysplice(io_in, off_in, io_out, off_out, len, flags) => integer
  *
  * Exactly like IO.splice, except +:EAGAIN+ is returned when either
  * the read or write end would block instead of raising Errno::EAGAIN.
@@ -214,16 +250,16 @@ static VALUE my_splice(int argc, VALUE *argv, VALUE self)
  */
 static VALUE trysplice(int argc, VALUE *argv, VALUE self)
 {
-	long n = do_splice(argc, argv, SPLICE_F_NONBLOCK);
+	ssize_t n = do_splice(argc, argv, SPLICE_F_NONBLOCK);
 
 	if (n == 0)
 		return Qnil;
-	if (n < 0) {
+	if (n == -1) {
 		if (errno == EAGAIN)
 			return sym_EAGAIN;
 		rb_sys_fail("splice");
 	}
-	return LONG2NUM(n);
+	return SSIZET2NUM(n);
 }
 
 struct tee_args {
@@ -241,35 +277,69 @@ static VALUE nogvl_tee(void *ptr)
 	return (VALUE)tee(a->fd_in, a->fd_out, a->len, a->flags);
 }
 
-static long do_tee(int argc, VALUE *argv, unsigned dflags)
+static ssize_t do_tee(int argc, VALUE *argv, unsigned dflags)
 {
-	VALUE fd_in, fd_out, len, flags;
+	VALUE io_in, io_out, len, flags;
 	struct tee_args a;
+	ssize_t bytes;
+	ssize_t total = 0;
+	unsigned waitall;
 
-	rb_scan_args(argc, argv, "31", &fd_in, &fd_out, &len, &flags);
-	a.fd_in = my_fileno(fd_in);
-	a.fd_out = my_fileno(fd_out);
-	a.len = (size_t)NUM2ULONG(len);
+	rb_scan_args(argc, argv, "31", &io_in, &io_out, &len, &flags);
+	a.len = (size_t)NUM2SIZET(len);
 	a.flags = NIL_P(flags) ? dflags : NUM2UINT(flags) | dflags;
+	waitall = a.flags & WAITALL;
+	if (waitall)
+		a.flags ^= WAITALL;
+
+	for (;;) {
+		a.fd_in = check_fileno(io_in);
+		a.fd_out = check_fileno(io_out);
+		bytes = (ssize_t)io_run(nogvl_tee, &a);
+		if (bytes == -1) {
+			if (errno == EINTR)
+				continue;
+			if (waitall && errno == EAGAIN) {
+				rb_io_wait_readable(check_fileno(io_in));
+				errno = EAGAIN;
+				rb_io_wait_writable(check_fileno(io_out));
+				continue;
+			}
+			if (total > 0)
+				return total;
+			return bytes;
+		} else if (bytes == 0) {
+			break;
+		} else if (waitall) {
+			total += bytes;
+			if ((a.len -= bytes) == 0)
+				return total;
+		} else {
+			return bytes;
+		}
+	}
 
-	return (long)nb_io_run(nogvl_tee, &a, a.flags);
+	return total;
 }
 
 /*
  * call-seq:
- *   IO.tee(fd_in, fd_out, len) => integer
- *   IO.tee(fd_in, fd_out, len, flags) => integer
+ *   IO.tee(io_in, io_out, len) => integer
+ *   IO.tee(io_in, io_out, len, flags) => integer
  *
- * Copies up to +len+ bytes of data from +fd_in+ to +fd_out+.  +fd_in+
- * and +fd_out+ must both refer to pipe descriptors.  +fd_in+ and +fd_out+
+ * Copies up to +len+ bytes of data from +io_in+ to +io_out+.  +io_in+
+ * and +io_out+ must both refer to pipe descriptors.  +io_in+ and +io_out+
  * may not be endpoints of the same pipe.
  *
- * +flags+ may be zero (the default) or IO::Splice::F_NONBLOCK
+ * +flags+ may be zero (the default) or a combination of:
+ * * IO::Splice::F_NONBLOCK
+ * * IO::Splice::WAITALL
+ *
  * Other IO::Splice flags are currently unimplemented or have no effect.
  *
  * Returns the number of bytes duplicated if successful.
- * Raises EOFError when +fd_in+ is closed and emptied.
- * Raises Errno::EAGAIN when +fd_in+ is empty and/or +fd_out+ is full
+ * Raises EOFError when +io_in+ is closed and emptied.
+ * Raises Errno::EAGAIN when +io_in+ is empty and/or +io_out+ is full
  * and +flags+ contains IO::Splice::F_NONBLOCK
  *
  * Consider using IO.trytee if you are using IO::Splice::F_NONBLOCK
@@ -280,20 +350,20 @@ static long do_tee(int argc, VALUE *argv, unsigned dflags)
  */
 static VALUE my_tee(int argc, VALUE *argv, VALUE self)
 {
-	long n = do_tee(argc, argv, 0);
+	ssize_t n = do_tee(argc, argv, 0);
 
 	if (n == 0)
 		rb_eof_error();
-	if (n < 0)
+	if (n == -1)
 		rb_sys_fail("tee");
 
-	return LONG2NUM(n);
+	return SSIZET2NUM(n);
 }
 
 /*
  * call-seq:
- *    IO.trytee(fd_in, fd_out, len) => integer
- *    IO.trytee(fd_in, fd_out, len, flags) => integer
+ *    IO.trytee(io_in, io_out, len) => integer
+ *    IO.trytee(io_in, io_out, len, flags) => integer
  *
  * Exactly like IO.tee, except +:EAGAIN+ is returned when either
  * the read or write end would block instead of raising Errno::EAGAIN.
@@ -305,17 +375,17 @@ static VALUE my_tee(int argc, VALUE *argv, VALUE self)
  */
 static VALUE trytee(int argc, VALUE *argv, VALUE self)
 {
-	long n = do_tee(argc, argv, SPLICE_F_NONBLOCK);
+	ssize_t n = do_tee(argc, argv, SPLICE_F_NONBLOCK);
 
 	if (n == 0)
 		return Qnil;
-	if (n < 0) {
+	if (n == -1) {
 		if (errno == EAGAIN)
 			return sym_EAGAIN;
 		rb_sys_fail("tee");
 	}
 
-	return LONG2NUM(n);
+	return SSIZET2NUM(n);
 }
 
 struct vmsplice_args {
@@ -385,13 +455,13 @@ static void advance_vmsplice_args(struct vmsplice_args *a, long n)
 
 /*
  * call-seq:
- *   IO.vmsplice(fd, string_array) => integer
- *   IO.vmsplice(fd, string_array, flags) => integer
- *   IO.vmsplice(fd, string) => integer
- *   IO.vmsplice(fd, string, flags) => integer
+ *   IO.vmsplice(io, string_array) => integer
+ *   IO.vmsplice(io, string_array, flags) => integer
+ *   IO.vmsplice(io, string) => integer
+ *   IO.vmsplice(io, string, flags) => integer
  *
- * Transfers an array of strings into the pipe descriptor given by fd.
- * +fd+ must be the writable end of a pipe.
+ * Transfers an array of strings into the pipe descriptor given by io.
+ * +io+ must be the writable end of a pipe.
  *
  * This may allow the kernel to avoid data copies in some cases.
  * but is (probably) of limited usefulness in Ruby.  If you have
@@ -408,12 +478,12 @@ static void advance_vmsplice_args(struct vmsplice_args *a, long n)
  */
 static VALUE my_vmsplice(int argc, VALUE * argv, VALUE self)
 {
-	long rv = 0;
+	ssize_t rv = 0;
 	ssize_t left;
 	struct vmsplice_args a;
-	VALUE fd, data, flags;
+	VALUE io, data, flags;
 
-	rb_scan_args(argc, argv, "21", &fd, &data, &flags);
+	rb_scan_args(argc, argv, "21", &io, &data, &flags);
 
 	switch (TYPE(data)) {
 	case T_STRING: {
@@ -433,18 +503,21 @@ static VALUE my_vmsplice(int argc, VALUE * argv, VALUE self)
 		         "(expected a String or Array of strings)",
 		         rb_obj_classname(data));
 	}
-	a.fd = my_fileno(fd);
+	a.fd = my_fileno(io);
 	a.flags = NIL_P(flags) ? 0 : NUM2UINT(flags);
 
 	for (;;) {
-		long n = (long)nb_io_run(nogvl_vmsplice, &a, a.flags);
+		ssize_t n = (ssize_t)io_run(nogvl_vmsplice, &a);
 
-		if (n < 0) {
+		if (n == -1) {
 			if (errno == EAGAIN) {
-				if (a.flags & SPLICE_F_NONBLOCK)
+				if (a.flags & SPLICE_F_NONBLOCK) {
 					rb_sys_fail("vmsplice");
-				else if (rb_io_wait_writable(a.fd))
-					continue;
+				} else {
+					a.fd = check_fileno(io);
+					if (rb_io_wait_writable(a.fd))
+						continue;
+				}
 				/* fall through on error */
 			}
 			/*
@@ -454,6 +527,10 @@ static VALUE my_vmsplice(int argc, VALUE * argv, VALUE self)
 			 */
 			if (rv > 0)
 				break;
+			if (errno == EINTR) {
+				a.fd = check_fileno(io);
+				continue;
+			}
 			rb_sys_fail("vmsplice");
 		}
 
@@ -464,7 +541,7 @@ static VALUE my_vmsplice(int argc, VALUE * argv, VALUE self)
 		advance_vmsplice_args(&a, n);
 	}
 
-	return LONG2NUM(rv);
+	return SSIZET2NUM(rv);
 }
 
 /*
@@ -550,6 +627,7 @@ void Init_io_splice_ext(void)
          * re-added for FUSE filesystems only in Linux 2.6.35.
 	 */
 	rb_define_const(mSplice, "F_MOVE", UINT2NUM(SPLICE_F_MOVE));
+	assert(WAITALL != SPLICE_F_MOVE && "WAITALL == F_MOVE");
 
 	/*
 	 * Do not block on pipe I/O.  This flag only affects the pipe(s)
@@ -563,6 +641,7 @@ void Init_io_splice_ext(void)
 	 * out of them.
 	 */
 	rb_define_const(mSplice, "F_NONBLOCK", UINT2NUM(SPLICE_F_NONBLOCK));
+	assert(WAITALL != SPLICE_F_NONBLOCK && "WAITALL == F_NONBLOCK");
 
 	/*
 	 * Indicate that there may be more data coming into the outbound
@@ -570,12 +649,23 @@ void Init_io_splice_ext(void)
 	 * frames from sockets.  Currently only used with splice.
 	 */
 	rb_define_const(mSplice, "F_MORE", UINT2NUM(SPLICE_F_MORE));
+	assert(WAITALL != SPLICE_F_MORE && "WAITALL == F_MORE");
 
 	/*
 	 * Only usable by vmsplice.  This flag probably not useful in the
 	 * context of Ruby applications which cannot control alignment.
 	 */
 	rb_define_const(mSplice, "F_GIFT", UINT2NUM(SPLICE_F_GIFT));
+	assert(WAITALL != SPLICE_F_GIFT && "WAITALL == F_GIFT");
+
+	/*
+	 * Retry until the requested transfer is complete, this will
+	 * cause IO.splice/IO.tee to never return less than the requested
+	 * transfer size unless an error occored.
+	 *
+	 * IO.vmsplice always defaults to this behavior.
+	 */
+	rb_define_const(mSplice, "WAITALL", UINT2NUM(WAITALL));
 
 	/*
 	 * The maximum size of an atomic write to a pipe

data/lib/io/splice.rb

@@ -1,5 +1,6 @@
 # -*- encoding: binary -*-
 require 'io_splice_ext'
+require 'io/wait'
 
 module IO::Splice
 
@@ -39,28 +40,30 @@ module IO::Splice
     dst.kind_of?(String) and close << (dst = File.open(dst, "w"))
     src, dst = src.to_io, dst.to_io
     rv = len
-    select_args = selectable(src, dst)
 
     if src.stat.pipe? || dst.stat.pipe?
       if len
-        len -= full(src, dst, len, src_offset, select_args) until len == 0
+        len -= full(src, dst, len, src_offset) until len == 0
       else
         rv = 0
-        while n = partial(src, dst, PIPE_CAPA, src_offset, select_args)
+        while n = partial(src, dst, PIPE_CAPA, src_offset)
           rv += n
+          src_offset += n if src_offset
         end
       end
     else
       r, w = tmp = IO.pipe
       close.concat(tmp)
       if len
-        while len != 0 && n = partial(src, w, len, src_offset, select_args)
-          len -= full(r, dst, n, nil, select_args)
+        while len != 0 && n = partial(src, w, len, src_offset)
+          src_offset += n if src_offset
+          len -= full(r, dst, n, nil)
         end
       else
         rv = 0
-        while n = partial(src, w, PIPE_CAPA, src_offset, select_args)
-          rv += full(r, dst, n, nil, select_args)
+        while n = partial(src, w, PIPE_CAPA, src_offset)
+          src_offset += n if src_offset
+          rv += full(r, dst, n, nil)
         end
       end
     end
@@ -76,17 +79,8 @@ module IO::Splice
   # This will block and wait for IO completion of +len+
   # Raises +EOFError+ if end of file is reached.
   # bytes.  Returns the number of bytes actually spliced (always +len+)
-  # The +_select_args+ parameter is reserved for internal use and
-  # may be removed in future versions.  Do not write code that
-  # depends on +_select_args+.
-  def self.full(src, dst, len, src_offset, _select_args = selectable(src, dst))
-    nr = len
-    while nr > 0
-      n = partial(src, dst, nr, src_offset, _select_args) or
-                                     raise EOFError, "end of file reached"
-      nr -= n
-    end
-    len
+  def self.full(src, dst, len, src_offset)
+    IO.splice(src, src_offset, dst, nil, len, F_MOVE | WAITALL)
   end
 
   # splice up to +len+ bytes from +src+ to +dst+.
@@ -94,22 +88,20 @@ module IO::Splice
   # may BOTH be pipes in Linux 2.6.31 or later.
   # Returns the number of bytes actually spliced.
   # Like IO#readpartial, this never returns Errno::EAGAIN
-  # The +_select_args+ parameter is reserved for internal use and
-  # may be removed in future versions.  Do not write code that
-  # depends on +_select_args+.
-  def self.partial(src, dst, len, src_offset,
-                   _select_args = selectable(src, dst))
-    begin
-      rv = IO.trysplice(src, src_offset, dst, nil, len, F_MOVE)
-    end while rv == :EAGAIN and IO.select(*_select_args)
-    rv
-  end
-
-  # returns an array suitable for splat-ing to IO.select for blocking I/O
-  def self.selectable(src, dst) # :nodoc:
-    rv = []
-    src.stat.pipe? or rv[0] = [ src ]
-    dst.stat.pipe? or rv[1] = [ dst ]
-    rv
+  def self.partial(src, dst, len, src_offset)
+    IO.splice(src, src_offset, dst, nil, len, F_MOVE)
+    rescue EOFError
+      nil
+    rescue Errno::EAGAIN
+      begin
+        src.to_io.wait
+        IO.select(nil, [dst])
+        rv = IO.trysplice(src, src_offset, dst, nil, len, F_MOVE)
+      end while rv == :EAGAIN
+      rv
   end
 end
+if (! defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby") &&
+   RUBY_VERSION.to_f <= 1.8
+  require "io/splice/mri_18"
+end

data/lib/io/splice/mri_18.rb

@@ -0,0 +1,34 @@
+# :enddoc:
+require "io/nonblock"
+module IO::Splice
+  class << self
+    remove_method :full
+    remove_method :partial
+  end
+  def self.full(src, dst, len, src_offset)
+    dst.to_io.nonblock = src.to_io.nonblock = true
+    spliced = 0
+    case n = IO.trysplice(src, src_offset, dst, nil, len, IO::Splice::F_MOVE)
+    when :EAGAIN
+      src.to_io.wait
+      IO.select(nil, [dst])
+    when Integer
+      spliced += n
+      len -= n
+      src_offset += n if src_offset
+    when nil
+      break
+    end while len > 0
+    spliced
+  end
+
+  def self.partial(src, dst, len, src_offset)
+    dst.to_io.nonblock = src.to_io.nonblock = true
+    begin
+      src.to_io.wait
+      IO.select(nil, [dst])
+      rv = IO.trysplice(src, src_offset, dst, nil, len, IO::Splice::F_MOVE)
+    end while rv == :EAGAIN
+    rv
+  end
+end

data/test/test_copy_stream.rb

@@ -0,0 +1,340 @@
+require 'test/unit'
+require 'tmpdir'
+require "fcntl"
+require 'io/nonblock'
+require 'socket'
+require 'timeout'
+require 'tempfile'
+require 'io/splice'
+
+class TestIOCopyStreamCompat < Test::Unit::TestCase
+  def have_nonblock?
+    IO.method_defined?("nonblock=")
+  end
+
+  def pipe(wp, rp)
+    re, we = nil, nil
+    r, w = IO.pipe
+    rt = Thread.new do
+      begin
+        rp.call(r)
+      rescue Exception
+        r.close
+        re = $!
+      end
+    end
+    wt = Thread.new do
+      begin
+        wp.call(w)
+      rescue Exception
+        w.close
+        we = $!
+      end
+    end
+    flunk("timeout") unless wt.join(10) && rt.join(10)
+  ensure
+    w.close unless !w || w.closed?
+    r.close unless !r || r.closed?
+    (wt.kill; wt.join) if wt
+    (rt.kill; rt.join) if rt
+    raise we if we
+    raise re if re
+  end
+
+  def with_pipe
+    r, w = IO.pipe
+    begin
+      yield r, w
+    ensure
+      r.close unless r.closed?
+      w.close unless w.closed?
+    end
+  end
+
+  def with_read_pipe(content)
+    pipe(proc do |w|
+      w << content
+      w.close
+    end, proc do |r|
+      yield r
+    end)
+  end
+
+  def mkcdtmpdir
+    Dir.mktmpdir {|d|
+      Dir.chdir(d) {
+        yield
+      }
+    }
+  end
+
+  def trapping_usr1
+    @usr1_rcvd  = 0
+    trap(:USR1) { @usr1_rcvd += 1 }
+    yield
+    ensure
+      trap(:USR1, "DEFAULT")
+  end
+
+  def test_copy_stream
+    mkcdtmpdir {
+      content = "foobar"
+      File.open("src", "w") {|f| f << content }
+      ret = IO::Splice.copy_stream("src", "dst")
+      assert_equal(content.bytesize, ret)
+      assert_equal(content, File.read("dst"))
+
+      # overwrite by smaller file.
+      content = "baz"
+      File.open("src", "w") {|f| f << content }
+      ret = IO::Splice.copy_stream("src", "dst")
+      assert_equal(content.bytesize, ret)
+      assert_equal(content, File.read("dst"))
+
+      ret = IO::Splice.copy_stream("src", "dst", 2)
+      assert_equal(2, ret)
+      assert_equal(content[0,2], File.read("dst"))
+
+      ret = IO::Splice.copy_stream("src", "dst", 0)
+      assert_equal(0, ret)
+      assert_equal("", File.read("dst"))
+
+      ret = IO::Splice.copy_stream("src", "dst", nil, 1)
+      assert_equal(content.bytesize-1, ret)
+      assert_equal(content[1..-1], File.read("dst"))
+
+      assert_raise(Errno::ENOENT) {
+        IO::Splice.copy_stream("nodir/foo", "dst")
+      }
+
+      assert_raise(Errno::ENOENT) {
+        IO::Splice.copy_stream("src", "nodir/bar")
+      }
+
+      pipe(proc do |w|
+        ret = IO::Splice.copy_stream("src", w)
+        assert_equal(content.bytesize, ret)
+        w.close
+      end, proc do |r|
+        assert_equal(content, r.read)
+      end)
+
+      with_pipe {|r, w|
+        w.close
+        assert_raise(IOError) { IO::Splice.copy_stream("src", w) }
+      }
+
+      pipe_content = "abc"
+      with_read_pipe(pipe_content) {|r|
+        ret = IO::Splice.copy_stream(r, "dst")
+        assert_equal(pipe_content.bytesize, ret)
+        assert_equal(pipe_content, File.read("dst"))
+      }
+
+      pipe(proc do |w|
+        ret = IO::Splice.copy_stream("src", w, 1, 1)
+        assert_equal(1, ret)
+        w.close
+      end, proc do |r|
+        assert_equal(content[1,1], r.read)
+      end)
+
+      bigcontent = "abc" * 123456
+      File.open("bigsrc", "w") {|f| f << bigcontent }
+      ret = IO::Splice.copy_stream("bigsrc", "bigdst")
+      assert_equal(bigcontent.bytesize, ret)
+      assert_equal(bigcontent, File.read("bigdst"))
+
+      File.unlink("bigdst")
+      ret = IO::Splice.copy_stream("bigsrc", "bigdst", nil, 100)
+      assert_equal(bigcontent.bytesize-100, ret)
+      assert_equal(bigcontent[100..-1], File.read("bigdst"))
+
+      File.unlink("bigdst")
+      ret = IO::Splice.copy_stream("bigsrc", "bigdst", 30000, 100)
+      assert_equal(30000, ret)
+      assert_equal(bigcontent[100, 30000], File.read("bigdst"))
+
+      File.open("bigsrc") {|f|
+        begin
+          assert_equal(0, f.pos)
+          ret = IO::Splice.copy_stream(f, "bigdst", nil, 10)
+          assert_equal(bigcontent.bytesize-10, ret)
+          assert_equal(bigcontent[10..-1], File.read("bigdst"))
+          assert_equal(0, f.pos)
+          ret = IO::Splice.copy_stream(f, "bigdst", 40, 30)
+          assert_equal(40, ret)
+          assert_equal(bigcontent[30, 40], File.read("bigdst"))
+          assert_equal(0, f.pos)
+        rescue NotImplementedError
+          #skip "pread(2) is not implemtented."
+        end
+      }
+
+      with_pipe {|r, w|
+        w.close
+        assert_raise(IOError) { IO::Splice.copy_stream("src", w) }
+      }
+
+      megacontent = "abc" * 1234567
+      File.open("megasrc", "w") {|f| f << megacontent }
+
+      if have_nonblock?
+        with_pipe {|r1, w1|
+          with_pipe {|r2, w2|
+            begin
+              r1.nonblock = true
+              w2.nonblock = true
+            rescue Errno::EBADF
+              skip "nonblocking IO for pipe is not implemented"
+            end
+            t1 = Thread.new { w1 << megacontent; w1.close }
+            t2 = Thread.new { r2.read }
+            ret = IO::Splice.copy_stream(r1, w2)
+            assert_equal(megacontent.bytesize, ret)
+            w2.close
+            t1.join
+            assert_equal(megacontent, t2.value)
+          }
+        }
+      end
+
+      with_pipe {|r1, w1|
+        with_pipe {|r2, w2|
+          t1 = Thread.new { w1 << megacontent; w1.close }
+          t2 = Thread.new { r2.read }
+          ret = IO::Splice.copy_stream(r1, w2)
+          assert_equal(megacontent.bytesize, ret)
+          w2.close
+          t1.join
+          assert_equal(megacontent, t2.value)
+        }
+      }
+
+      with_pipe {|r, w|
+        t = Thread.new { r.read }
+        ret = IO::Splice.copy_stream("megasrc", w)
+        assert_equal(megacontent.bytesize, ret)
+        w.close
+        assert_equal(megacontent, t.value)
+      }
+    }
+  end
+
+  def with_socketpair
+    s1, s2 = UNIXSocket.pair
+    begin
+      yield s1, s2
+    ensure
+      s1.close unless s1.closed?
+      s2.close unless s2.closed?
+    end
+  end
+
+  def test_copy_stream_socket
+    mkcdtmpdir {
+
+      content = "foobar"
+      File.open("src", "w") {|f| f << content }
+
+      with_socketpair {|s1, s2|
+        ret = IO::Splice.copy_stream("src", s1)
+        assert_equal(content.bytesize, ret)
+        s1.close
+        assert_equal(content, s2.read)
+      }
+
+      bigcontent = "abc" * 123456
+      File.open("bigsrc", "w") {|f| f << bigcontent }
+
+      with_socketpair {|s1, s2|
+        t = Thread.new { s2.read }
+        ret = IO::Splice.copy_stream("bigsrc", s1)
+        assert_equal(bigcontent.bytesize, ret)
+        s1.close
+        result = t.value
+        assert_equal(bigcontent, result)
+      }
+
+      with_socketpair {|s1, s2|
+        t = Thread.new { s2.read }
+        ret = IO::Splice.copy_stream("bigsrc", s1, 10000)
+        assert_equal(10000, ret)
+        s1.close
+        result = t.value
+        assert_equal(bigcontent[0,10000], result)
+      }
+
+      File.open("bigsrc") {|f|
+        assert_equal(0, f.pos)
+        with_socketpair {|s1, s2|
+          t = Thread.new { s2.read }
+          ret = IO::Splice.copy_stream(f, s1, nil, 100)
+          assert_equal(bigcontent.bytesize-100, ret)
+          assert_equal(0, f.pos)
+          s1.close
+          result = t.value
+          assert_equal(bigcontent[100..-1], result)
+        }
+      }
+
+      File.open("bigsrc") {|f|
+        assert_equal(bigcontent[0,100], f.sysread(100))
+        assert_equal(100, f.pos)
+        with_socketpair {|s1, s2|
+          t = Thread.new { s2.read }
+          ret = IO::Splice.copy_stream(f, s1)
+          assert_equal(bigcontent.bytesize-100, ret)
+          assert_equal(bigcontent.length, f.sysseek(0, IO::SEEK_CUR))
+          s1.close
+          result = t.value
+          assert_equal(bigcontent[100..-1], result)
+        }
+      }
+
+      megacontent = "abc" * 1234567
+      File.open("megasrc", "w") {|f| f << megacontent }
+
+      if have_nonblock?
+        with_socketpair {|s1, s2|
+          begin
+            s1.nonblock = true
+          rescue Errno::EBADF
+            skip "nonblocking IO for pipe is not implemented"
+          end
+          t = Thread.new { s2.read }
+          ret = IO::Splice.copy_stream("megasrc", s1)
+          assert_equal(megacontent.bytesize, ret)
+          s1.close
+          result = t.value
+          assert_equal(megacontent, result)
+        }
+        with_socketpair {|s1, s2|
+          begin
+            s1.nonblock = true
+          rescue Errno::EBADF
+            skip "nonblocking IO for pipe is not implemented"
+          end
+          trapping_usr1 do
+            nr = 10
+            pid = fork do
+              s1.close
+              IO.select([s2])
+              Process.kill(:USR1, Process.ppid)
+              s2.read
+            end
+            s2.close
+            nr.times do
+              assert_equal megacontent.bytesize,
+                          IO::Splice.copy_stream("megasrc", s1)
+            end
+            assert_equal(1, @usr1_rcvd)
+            s1.close
+            _, status = Process.waitpid2(pid)
+            assert status.success?, status.inspect
+          end
+        }
+      end
+    }
+  end
+end

data/test/test_io_splice.rb

@@ -9,6 +9,10 @@ require 'io/splice'
 
 class Test_IO_Splice < Test::Unit::TestCase
 
+  def self.mri?
+    (defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby") || !defined?(RUBY_ENGINE)
+  end
+
   def test_splice
     str = 'abcde'
     size = 5
@@ -415,7 +419,7 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_equal 0, nr
     rs.close
     server.close
-  end
+  end if mri?
 
   def test_copy_stream_nonblock_dst
     server = TCPServer.new('127.0.0.1', 0)
@@ -440,7 +444,7 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_equal nr, client.read(nr).size
     rs.close
     server.close
-  end
+  end if mri?
 
   def test_copy_stream_eof
     r, w = IO.pipe
@@ -466,5 +470,4 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_nothing_raised { r.pipe_size = pipe_max_size }
     assert_raises(Errno::EPERM) { r.pipe_size = pipe_max_size * 2 }
   end if IO.method_defined?(:pipe_size)
-
 end

data/test/test_io_splice_eintr.rb

@@ -0,0 +1,35 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'tempfile'
+require 'socket'
+require 'io/nonblock'
+require 'timeout'
+$-w = true
+require 'io/splice'
+Thread.abort_on_exception = true
+
+class Test_IO_Splice_EINTR < Test::Unit::TestCase
+  def setup
+    @usr1 = 0
+    trap(:USR1) { @usr1 += 1 }
+  end
+
+  def teardown
+    trap(:USR1, "DEFAULT")
+  end
+
+  def test_EINTR_splice_read
+    rd, wr = IO.pipe
+    tmp = Tempfile.new 'splice-read'
+    main = Thread.current
+    Thread.new do
+      sleep 0.01
+      Process.kill(:USR1, $$)
+      sleep 0.01
+      wr.write "HI"
+    end
+    nr = IO.splice rd, nil, tmp, nil, 666
+    assert_equal 2, nr
+    assert_equal 1, @usr1
+  end
+end if defined?(RUBY_ENGINE)

data/test/test_io_splice_in_full.rb

@@ -0,0 +1,39 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'tempfile'
+$-w = true
+require 'io/splice'
+Thread.abort_on_exception = true
+
+class Test_IO_Splice_In_Full < Test::Unit::TestCase
+  def test_splice_in_full
+    rd, wr = IO.pipe
+    tmp = Tempfile.new 'splice-read'
+    Thread.new do
+      111.times do
+        sleep 0.002
+        wr.write "HIHIHI"
+      end
+    end
+    nr = IO.splice rd, nil, tmp, nil, 666, IO::Splice::WAITALL
+    assert_equal 666, nr
+    tmp.rewind
+    assert_equal "HIHIHI" * 111, tmp.read
+  end
+
+  def test_tee_in_full
+    rd, wr = IO.pipe
+    a, b = IO.pipe
+    thr = Thread.new { a.read(666) }
+    Thread.new do
+      111.times do
+        sleep 0.001
+        wr.syswrite "HIHIHI"
+      end
+    end
+    nr = IO.tee rd, b, 666, IO::Splice::WAITALL
+    assert_equal 666, nr
+    thr.join
+    assert_equal "HIHIHI" * 111, thr.value
+  end
+end if defined?(RUBY_ENGINE)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: io_splice
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 63
   prerelease: 
   segments: 
-  - 3
-  - 1
+  - 4
   - 0
-  version: 3.1.0
+  - 0
+  version: 4.0.0
 platform: ruby
 authors: 
 - Ruby io_splice hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-01 00:00:00 Z
+date: 2011-05-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: wrongdoc
@@ -48,6 +48,7 @@ extra_rdoc_files:
 - NEWS
 - ChangeLog
 - lib/io/splice.rb
+- lib/io/splice/mri_18.rb
 - ext/io_splice/io_splice_ext.c
 - LATEST
 files: 
@@ -71,10 +72,14 @@ files:
 - ext/io_splice/io_splice_ext.c
 - io_splice.gemspec
 - lib/io/splice.rb
+- lib/io/splice/mri_18.rb
 - local.mk.sample
 - pkg.mk
 - setup.rb
+- test/test_copy_stream.rb
 - test/test_io_splice.rb
+- test/test_io_splice_eintr.rb
+- test/test_io_splice_in_full.rb
 homepage: http://bogomips.org/ruby_io_splice/
 licenses: []
 
@@ -107,9 +112,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: qrp
-rubygems_version: 1.7.2
+rubygems_version: 1.8.1
 signing_key: 
 specification_version: 3
 summary: zero-copy pipe I/O for Linux and Ruby
 test_files: 
+- test/test_io_splice_in_full.rb
 - test/test_io_splice.rb
+- test/test_copy_stream.rb
+- test/test_io_splice_eintr.rb