io_splice 0.1.0 → 1.0.0

data/GNUmakefile

@@ -3,6 +3,7 @@ all::
 RUBY = ruby
 RAKE = rake
 GIT_URL = git://git.bogomips.org/ruby_io_splice.git
+RSYNC = rsync
 
 GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
 	@./GIT-VERSION-GEN
@@ -40,7 +41,7 @@ manifest: $(pkg_extra)
 
 .manifest:
 	(git ls-files && \
-         for i in $@ $(pkg_extra) $(man1_paths); \
+         for i in $@ $(pkg_extra); \
 	 do echo $$i; done) | LC_ALL=C sort > $@+
 	cmp $@+ $@ || mv $@+ $@
 	$(RM) $@+
@@ -67,10 +68,10 @@ cgit_atom := http://git.bogomips.org/cgit/ruby_io_splice.git/atom/?h=master
 atom = <link rel="alternate" title="Atom feed" href="$(1)" \
              type="application/atom+xml"/>
 
-# using rdoc 2.4.1+
+# using rdoc 2.5.x + workaround patch here:
+# rubyforge.org/tracker/index.php?func=detail&aid=28230&group_id=627&atid=2472
 doc: .document NEWS ChangeLog
-	for i in $(man1_bins); do > $$i; done
-	rdoc -Na -t "$(shell sed -ne '1s/^= //p' README)"
+	rdoc -a -t "$(shell sed -ne '1s/^= //p' README)"
 	install -m644 COPYING doc/COPYING
 	install -m644 $(shell grep '^[A-Z]' .document) doc/
 	cd doc && for i in $(base_bins); do \
@@ -85,7 +86,31 @@ doc: .document NEWS ChangeLog
 	  doc/NEWS.html doc/README.html
 	$(RAKE) -s news_atom > doc/NEWS.atom.xml
 	cd doc && ln README.html tmp && mv tmp index.html
-	$(RM) $(man1_bins)
+
+latest: NEWS
+	@awk 'BEGIN{RS="=== ";ORS=""}NR==2{sub(/\n$$/,"");print RS""$$0 }' $<
+
+# publishes docs to http://bogomips.org/ruby_io_splice/,
+publish_doc:
+	-git set-file-times
+	$(RM) -r doc ChangeLog NEWS
+	$(MAKE) doc LOG_VERSION=$(shell git tag -l | tail -1)
+	awk 'BEGIN{RS="=== ";ORS=""}NR==2{sub(/\n$$/,"");print RS""$$0 }' \
+	  NEWS > doc/LATEST
+	find doc/images doc/js -type f | \
+		TZ=UTC xargs touch -d '1970-01-01 00:00:01' doc/rdoc.css
+	$(MAKE) doc_gz
+	chmod 644 $$(find doc -type f)
+	$(RSYNC) -av doc/ bogomips.org:/srv/bogomips/ruby_io_splice/
+	git ls-files | xargs touch
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
+doc_gz:
+	touch doc/NEWS.atom.xml -d "$$(awk 'NR==1{print $$4,$$5,$$6}' NEWS)"
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
 
 ifneq ($(VERSION),)
 rfproject := qrp

data/LICENSE

@@ -1,16 +1,16 @@
 io_splice is copyrighted Free Software by all contributors, see logs in
 revision control for names and email addresses of all of them.
 
-You can redistribute it and/or modify it under either the terms of the GNU
+You can redistribute it and/or modify it under the terms of the GNU
 Lesser General Public License as published by the Free Software Foundation,
 version 3.0 {LGPLv3}[http://www.gnu.org/licenses/lgpl-3.0.txt] (see
 link:COPYING).
 
-posix_mq is distributed in the hope that it will be useful, but WITHOUT
+io_splice is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 License for more details.
 
 You should have received a copy of the GNU Lesser General Public License
-along with the GNU C Library; if not, write to the Free Software
+along with this library; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301

data/README

@@ -85,3 +85,13 @@ don't email the git mailing list or maintainer with io_splice patches.
 
 All feedback (bug reports, user/development discussion, patches, pull
 requests) go to the mailing list: mailto:ruby.io.splice@librelist.com
+
+== Mailing List Archives
+
+In addition to the rsync-able archives provided by http://librelist.com/, we
+are also mirrored to
+{Gmane}[http://gmane.org/info.php?group=gmane.comp.lang.ruby.io-splice.general]
+and maintain our own mbox mirrors downloadable via HTTP.
+
+* nntp://news.gmane.org/gmane.comp.lang.ruby.io-splice.general
+* http://bogomips.org/ruby_io_splice/archives/

data/ext/io_splice/io_splice_ext.c

@@ -10,10 +10,38 @@
 #include <limits.h>
 #include <alloca.h>
 
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
-#  define RUBY_1_8_TRAP_BEG for(;0;)
-#  define RUBY_1_8_TRAP_END for(;0;)
+#if ! HAVE_RB_IO_T
+#  define rb_io_t OpenFile
+#endif
+
+#ifdef GetReadFile
+#  define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
 #else
+#  if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
+#    define FPTR_TO_FD(fptr) fileno(fptr->f)
+#  else
+#    define FPTR_TO_FD(fptr) fptr->fd
+#  endif
+#endif
+
+static int my_fileno(VALUE io)
+{
+	rb_io_t *fptr;
+
+	for (;;) {
+		switch (TYPE(io)) {
+		case T_FIXNUM: return NUM2INT(io);
+		case T_FILE: {
+			GetOpenFile(io, fptr);
+			return FPTR_TO_FD(fptr);
+		}
+		default:
+			io = rb_convert_type(io, T_FILE, "IO", "to_io");
+			/* retry */
+		}
+	}
+}
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
 /* partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
 #  include <rubysig.h>
 #  define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
@@ -34,8 +62,6 @@ rb_thread_blocking_region(
 
 	return rv;
 }
-#  define RUBY_1_8_TRAP_BEG TRAP_BEG
-#  define RUBY_1_8_TRAP_END TRAP_END
 #endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
 
 #ifndef RSTRING_PTR
@@ -77,21 +103,9 @@ struct splice_args {
 static VALUE nogvl_splice(void *ptr)
 {
 	struct splice_args *a = ptr;
-	long n;
 
-	/*
-	 * it's still possible to block because the SPLICE_F_NONBLOCK flag
-	 * only affects the pipe descriptor, not the non-pipe descriptor.
-	 * So use TRAP_BEG/TRAP_END (only) to make Ruby 1.8 happy.  We also
-	 * don't want the TRAP_BEG/TRAP_END compatibility layer in 1.9,
-	 * so we use the 1.8-only versions
-	 */
-	RUBY_1_8_TRAP_BEG;
-	n = splice(a->fd_in, a->off_in, a->fd_out, a->off_out,
-	           a->len, a->flags);
-	RUBY_1_8_TRAP_END;
-
-	return (VALUE)n;
+	return (VALUE)splice(a->fd_in, a->off_in, a->fd_out, a->off_out,
+	                     a->len, a->flags);
 }
 
 /*
@@ -140,13 +154,13 @@ static VALUE my_splice(VALUE self,
 	struct splice_args a = {
 		.off_in = NIL_P(off_in) ? NULL : (i = NUM2OFFT(off_in), &i),
 		.off_out = NIL_P(off_out) ? NULL : (o = NUM2OFFT(off_out), &o),
-		.fd_in = NUM2INT(fd_in),
-		.fd_out = NUM2INT(fd_out),
+		.fd_in = my_fileno(fd_in),
+		.fd_out = my_fileno(fd_out),
 		.len = (size_t)NUM2ULONG(len),
 		.flags = NUM2UINT(flags),
 	};
 
-	n = (long)nb_io_run(nogvl_splice, &a, a.flags);
+	n = (long)rb_thread_blocking_region(nogvl_splice, &a, RUBY_UBF_IO, 0);
 	if (n == 0)
 		rb_eof_error();
 	if (n < 0)
@@ -194,8 +208,8 @@ static VALUE my_tee(VALUE self,
 {
 	long n;
 	struct tee_args a = {
-		.fd_in = NUM2INT(fd_in),
-		.fd_out = NUM2INT(fd_out),
+		.fd_in = my_fileno(fd_in),
+		.fd_out = my_fileno(fd_out),
 		.len = (size_t)NUM2ULONG(len),
 		.flags = NUM2UINT(flags),
 	};
@@ -223,6 +237,58 @@ static VALUE nogvl_vmsplice(void *ptr)
 	return (VALUE)vmsplice(a->fd, a->iov, a->nr_segs, a->flags);
 }
 
+/* this can't be a function since we use alloca() */
+#define ARY2IOVEC(iov,iovcnt,expect,ary) \
+do { \
+	VALUE *cur; \
+	struct iovec *tmp; \
+	long n; \
+	Check_Type(ary, T_ARRAY); \
+	cur = RARRAY_PTR(ary); \
+	n = RARRAY_LEN(ary); \
+	if (n > IOV_MAX) \
+		rb_raise(rb_eArgError, "array is larger than IOV_MAX"); \
+	iov = tmp = alloca(sizeof(struct iovec) * n); \
+	expect = 0; \
+	iovcnt = n; \
+	for (; --n >= 0; tmp++, cur++) { \
+		Check_Type(*cur, T_STRING); \
+		tmp->iov_base = RSTRING_PTR(*cur); \
+		tmp->iov_len = RSTRING_LEN(*cur); \
+		expect += tmp->iov_len; \
+	} \
+} while (0)
+
+static void advance_vmsplice_args(struct vmsplice_args *a, long n)
+{
+	struct iovec *new_iov = a->iov;
+	int i;
+
+	/* skip over iovecs we've already written completely */
+	for (i = 0; i < a->nr_segs; i++, new_iov++) {
+		if (n == 0)
+			break;
+		/*
+		 * partially written iov,
+		 * modify and retry with current iovec in
+		 * front
+		 */
+		if (new_iov->iov_len > (size_t)n) {
+			VALUE base = (VALUE)new_iov->iov_base;
+
+			new_iov->iov_len -= n;
+			new_iov->iov_base = (void *)(base + n);
+			break;
+		}
+
+		n -= new_iov->iov_len;
+	}
+
+	/* setup to retry without the already-written iovecs */
+	a->nr_segs -= i;
+	a->iov = new_iov;
+}
+
 /*
  * call-seq:
  *   IO.vmsplice(fd, string_array, flags) => integer
@@ -238,46 +304,48 @@ static VALUE nogvl_vmsplice(void *ptr)
  */
 static VALUE my_vmsplice(VALUE self, VALUE fd, VALUE data, VALUE flags)
 {
-	long n;
+	long rv = 0;
+	ssize_t left;
 	struct vmsplice_args a;
-	struct iovec *tmp;
-	VALUE *ary;
-
-	switch (TYPE(data)) {
-	case T_ARRAY:
-		ary = RARRAY_PTR(data);
-		a.nr_segs = RARRAY_LEN(data);
-
-		if (a.nr_segs > IOV_MAX)
-			rb_raise(rb_eArgError, "array larger than IOV_MAX");
 
-		a.iov = tmp = alloca(sizeof(struct iovec) * a.nr_segs);
+	ARY2IOVEC(a.iov, a.nr_segs, left, data);
+	a.fd = my_fileno(fd);
+	a.flags = NUM2UINT(flags);
 
-		for (n = (long)a.nr_segs; --n >= 0; tmp++, ary++) {
-			if (TYPE(*ary) != T_STRING)
-				rb_raise(rb_eArgError,
-				         "must be an array of strings");
-			tmp->iov_base = RSTRING_PTR(*ary);
-			tmp->iov_len = RSTRING_LEN(*ary);
+	for (;;) {
+		long n = (long)nb_io_run(nogvl_vmsplice, &a, a.flags);
+
+		if (n < 0) {
+			if (errno == EAGAIN) {
+				if (a.flags & SPLICE_F_NONBLOCK)
+					rb_sys_fail("vmsplice");
+				else if (rb_io_wait_writable(a.fd))
+					continue;
+				/* fall through on error */
+			}
+			/*
+			 * unlikely to hit this case, return the
+			 * already written bytes, we'll let the next
+			 * write (or close) fail instead
+			 */
+			if (rv > 0)
+				break;
+			rb_sys_fail("vmsplice");
 		}
-		break;
-	default:
-		rb_raise(rb_eArgError, "must be an array of strings");
-	}
-
-	a.fd = NUM2INT(fd);
-	a.flags = NUM2UINT(flags);
 
-	n = (long)nb_io_run(nogvl_vmsplice, &a, a.flags);
-	if (n < 0)
-		rb_sys_fail("vmsplice");
+		rv += n;
+		left -= n;
+		if (left == 0)
+			break;
+		advance_vmsplice_args(&a, n);
+	}
 
-	return LONG2NUM(n);
+	return LONG2NUM(rv);
 }
 
 void Init_io_splice_ext(void)
 {
-	VALUE cSplice = rb_define_class_under(rb_cIO, "Splice", rb_cObject);
+	VALUE mSplice = rb_define_module_under(rb_cIO, "Splice");
 
 	rb_define_singleton_method(rb_cIO, "splice", my_splice, 6);
 	rb_define_singleton_method(rb_cIO, "tee", my_tee, 4);
@@ -288,32 +356,38 @@ void Init_io_splice_ext(void)
 	 * and support for it was removed in Linux 2.6.21 and has not been
 	 * readded as of 2.6.30.
 	 */
-	rb_define_const(cSplice, "F_MOVE", UINT2NUM(SPLICE_F_MOVE));
+	rb_define_const(mSplice, "F_MOVE", UINT2NUM(SPLICE_F_MOVE));
 
 	/*
-	 * Do not block on I/O.  This flag only affects the pipe(s) being
-	 * spliced from/to and has no effect on the non-pipe descriptor
-	 * (which requires non-blocking operation to be set explicitly).
+	 * Do not block on pipe I/O.  This flag only affects the pipe(s)
+	 * being spliced from/to and has no effect on the non-pipe
+	 * descriptor (which requires non-blocking operation to be set
+	 * explicitly).
+	 *
+	 * The non-blocking flag (O_NONBLOCK) on the pipe descriptors
+	 * themselves are ignored by this family of functions, and
+	 * using this flag is the only way to get non-blocking operation
+	 * out of them.
 	 */
-	rb_define_const(cSplice, "F_NONBLOCK", UINT2NUM(SPLICE_F_NONBLOCK));
+	rb_define_const(mSplice, "F_NONBLOCK", UINT2NUM(SPLICE_F_NONBLOCK));
 
 	/*
 	 * Indicate that there may be more data coming into the outbound
 	 * descriptor.  This can allow the kernel to avoid sending partial
 	 * frames from sockets.  Currently only used with splice.
 	 */
-	rb_define_const(cSplice, "F_MORE", UINT2NUM(SPLICE_F_MORE));
+	rb_define_const(mSplice, "F_MORE", UINT2NUM(SPLICE_F_MORE));
 
 	/*
 	 * Only usable by vmsplice.  This flag probably not useful in the
 	 * context of Ruby applications which cannot control alignment.
 	 */
-	rb_define_const(cSplice, "F_GIFT", UINT2NUM(SPLICE_F_GIFT));
+	rb_define_const(mSplice, "F_GIFT", UINT2NUM(SPLICE_F_GIFT));
 
 	/*
 	 * The maximum size of an atomic write to a pipe
 	 * POSIX requires this to be at least 512 bytes.
 	 * Under Linux, this is 4096 bytes.
 	 */
-	rb_define_const(cSplice, "PIPE_BUF", UINT2NUM(PIPE_BUF));
+	rb_define_const(mSplice, "PIPE_BUF", UINT2NUM(PIPE_BUF));
 }

data/lib/io/splice.rb

@@ -3,10 +3,10 @@ require 'io_splice_ext'
 
 class IO
 
-  class Splice
+  module Splice
 
     # the version of IO::Splice, currently 0.1.0
-    VERSION = '0.1.0'
+    VERSION = '1.0.0'
 
     # The maximum capacity of the pipe in bytes.
     # Under stock Linux, this is 65536 bytes as of 2.6.11, and 4096 before

data/local.mk.sample

@@ -1,64 +1,15 @@
-# this is a sample local.mk file, feel free to modify it for your needs
-# GNUmakefile will source local.mk in the top-level source tree
-# if it is present.
-#
-# This is depends on a bunch of GNU-isms from bash, touch.
-
-RSYNC = rsync
 DLEXT := so
-gems :=
 
 # Avoid loading rubygems to speed up tests because gmake is
 # fork+exec heavy with Ruby.
 prefix = $(HOME)
+
 ifeq ($(r19),)
   RUBY := $(prefix)/bin/ruby
-  gem_paths := $(addprefix $(prefix)/lib/ruby/gems/1.8/gems/,$(gems))
+  RAKE := $(prefix)/bin/rake
 else
   prefix := $(prefix)/ruby-1.9
   export PATH := $(prefix)/bin:$(PATH)
   RUBY := $(prefix)/bin/ruby --disable-gems
-  gem_paths := $(addprefix $(prefix)/lib/ruby/gems/1.9.1/gems/,$(gems))
+  RAKE := $(prefix)/bin/rake
 endif
-
-ifdef gem_paths
-  sp :=
-  sp +=
-  export RUBYLIB := $(subst $(sp),:,$(addsuffix /lib,$(gem_paths)))
-endif
-
-# pipefail is THE reason to use bash (v3+) or never revisions of ksh93
-# SHELL := /bin/bash -e -o pipefail
-SHELL := /bin/ksh93 -e -o pipefail
-
-# trace execution of tests
-# TRACER = strace -f -o $(t_pfx).strace -s 100000
-TRACER = /usr/bin/time -v -o $(t_pfx).time
-
-latest: NEWS
-	@awk 'BEGIN{RS="=== ";ORS=""}NR==2{sub(/\n$$/,"");print RS""$$0 }' $<
-
-# publishes docs to http://bogomips.org/ruby_io_splice/
-publish_doc:
-	-git set-file-times
-	$(RM) -r doc ChangeLog NEWS
-	$(MAKE) doc LOG_VERSION=$(shell git tag -l | tail -1)
-	$(MAKE) -s latest > doc/LATEST
-	find doc/images doc/js -type f | \
-		TZ=UTC xargs touch -d '1970-01-01 00:00:00' doc/rdoc.css
-	$(MAKE) doc_gz
-	chmod 644 $$(find doc -type f)
-	$(RSYNC) -av doc/ dcvr:/srv/bogomips/ruby_io_splice/
-	git ls-files | xargs touch
-
-# Create gzip variants of the same timestamp as the original so nginx
-# "gzip_static on" can serve the gzipped versions directly.
-doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
-doc_gz:
-	touch doc/NEWS.atom.xml -d "$$(awk 'NR==1{print $$4,$$5,$$6}' NEWS)"
-	for i in $(docs); do \
-	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
-
-# launches any of the following shells with RUBYLIB set
-irb sh bash ksh:
-	$@

data/test/test_io_splice.rb

@@ -1,15 +1,60 @@
 # -*- encoding: binary -*-
 require 'test/unit'
 require 'tempfile'
+require 'socket'
+require 'io/nonblock'
+$-w = true
 require 'io/splice'
 
+# unused_port provides an unused port on +addr+ usable for TCP that is
+# guaranteed to be unused across all unicorn builds on that system.  It
+# prevents race conditions by using a lock file other unicorn builds
+# will see.  This is required if you perform several builds in parallel
+# with a continuous integration system or run tests in parallel via
+# gmake.  This is NOT guaranteed to be race-free if you run other
+# processes that bind to random ports for testing (but the window
+# for a race condition is very small).
+def unused_port(addr = '127.0.0.1')
+  retries = 100
+  base = 5000
+  port = sock = nil
+  begin
+    begin
+      port = base + rand(32768 - base)
+      while port == 8080
+        port = base + rand(32768 - base)
+      end
+
+      sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      sock.bind(Socket.pack_sockaddr_in(port, addr))
+      sock.listen(5)
+    rescue Errno::EADDRINUSE, Errno::EACCES
+      sock.close rescue nil
+      retry if (retries -= 1) >= 0
+    end
+
+    # since we'll end up closing the random port we just got, there's a race
+    # condition could allow the random port we just chose to reselect itself
+    # when running tests in parallel with gmake.  Create a lock file while
+    # we have the port here to ensure that does not happen .
+    lock_path = "#{Dir::tmpdir}/unicorn_test.#{addr}:#{port}.lock"
+    lock = File.open(lock_path, File::WRONLY|File::CREAT|File::EXCL, 0600)
+    at_exit { File.unlink(lock_path) rescue nil }
+  rescue Errno::EEXIST
+    sock.close rescue nil
+    retry
+  end
+  sock.close rescue nil
+  port
+end
+
 class Test_IO_Splice < Test::Unit::TestCase
 
   def test_splice
     str = 'abcde'
     size = 5
     rd, wr = IO.pipe
-    tmp = Tempfile.new(nil)
+    tmp = Tempfile.new('ruby_io_splice')
 
     assert_nothing_raised {
       tmp.syswrite(str)
@@ -21,12 +66,48 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_equal str, rd.sysread(size)
   end
 
+  def test_splice_io
+    str = 'abcde'
+    size = 5
+    rd, wr = IO.pipe
+    tmp = Tempfile.new('ruby_io_splice')
+
+    assert_nothing_raised {
+      tmp.syswrite(str)
+      tmp.sysseek(0)
+    }
+
+    nr = IO.splice(tmp, nil, wr, nil, size, 0)
+    assert_equal size, nr
+    assert_equal str, rd.sysread(size)
+  end
+
+  def test_splice_io_ish
+    str = 'abcde'
+    size = 5
+    rd, wr = IO.pipe
+    tmp = Tempfile.new('ruby_io_splice')
+    io_ish = [ tmp ]
+    def io_ish.to_io
+      first.to_io
+    end
+
+    assert_nothing_raised {
+      tmp.syswrite(str)
+      tmp.sysseek(0)
+    }
+
+    nr = IO.splice(io_ish, nil, wr, nil, size, 0)
+    assert_equal size, nr
+    assert_equal str, rd.sysread(size)
+  end
+
   def test_splice_in_offset
     str = 'abcde'
     off = 3
     len = 2
     rd, wr = IO.pipe
-    tmp = Tempfile.new(nil)
+    tmp = Tempfile.new('ruby_io_splice')
 
     assert_nothing_raised {
       tmp.syswrite(str)
@@ -41,7 +122,7 @@ class Test_IO_Splice < Test::Unit::TestCase
   def test_splice_out_offset
     str = 'abcde'
     rd, wr = IO.pipe
-    tmp = Tempfile.new(nil)
+    tmp = Tempfile.new('ruby_io_splice')
 
     assert_nothing_raised { wr.syswrite(str) }
     nr = IO.splice(rd.fileno, nil, tmp.fileno, 3, str.size, 0)
@@ -52,7 +133,7 @@ class Test_IO_Splice < Test::Unit::TestCase
 
   def test_splice_nonblock
     rd, wr = IO.pipe
-    tmp = Tempfile.new(nil)
+    tmp = Tempfile.new('ruby_io_splice')
 
     assert_raises(Errno::EAGAIN) {
       IO.splice(rd.fileno, nil, tmp.fileno, 0, 5, IO::Splice::F_NONBLOCK)
@@ -61,7 +142,7 @@ class Test_IO_Splice < Test::Unit::TestCase
 
   def test_splice_eof
     rd, wr = IO.pipe
-    tmp = Tempfile.new(nil)
+    tmp = Tempfile.new('ruby_io_splice')
     wr.syswrite 'abc'
     wr.close
 
@@ -72,6 +153,17 @@ class Test_IO_Splice < Test::Unit::TestCase
     }
   end
 
+  def test_splice_nonblock_socket
+    port = unused_port
+    server = TCPServer.new('127.0.0.1', port)
+    rp, wp = IO.pipe
+    rs = TCPSocket.new('127.0.0.1', port)
+    rs.nonblock = true
+    assert_raises(Errno::EAGAIN) { IO.splice(rs, nil, wp, nil, 1024, 0) }
+    rs.close
+    server.close
+  end
+
   def test_tee
     str = 'abcde'
     size = 5
@@ -100,6 +192,19 @@ class Test_IO_Splice < Test::Unit::TestCase
     }
   end
 
+  def test_tee_io
+    str = 'abcde'
+    size = 5
+    rda, wra = IO.pipe
+    rdb, wrb = IO.pipe
+
+    assert_nothing_raised { wra.syswrite(str) }
+    nr = IO.tee(rda, wrb, size, 0)
+    assert_equal 5, nr
+    assert_equal str, rdb.sysread(5)
+    assert_equal str, rda.sysread(5)
+  end
+
   def test_vmsplice_array
     data = %w(hello world how are you today)
     r, w = IO.pipe
@@ -108,6 +213,14 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_equal data.join(''), r.readpartial(16384)
   end
 
+  def test_vmsplice_array_io
+    data = %w(hello world how are you today)
+    r, w = IO.pipe
+    n = IO.vmsplice(w, data, 0)
+    assert_equal data.join('').size, n
+    assert_equal data.join(''), r.readpartial(16384)
+  end
+
   def test_vmsplice_nonblock
     data = %w(hello world how are you today)
     r, w = IO.pipe
@@ -117,6 +230,40 @@ class Test_IO_Splice < Test::Unit::TestCase
     }
   end
 
+  def test_vmsplice_in_full
+    empty = ""
+
+    # bs * count should be > PIPE_BUF
+    [ [ 512, 512 ], [ 131073, 3 ], [ 4098, 64 ] ].each do |(bs,count)|
+      rd, wr = IO.pipe
+      buf = File.open('/dev/urandom', 'rb') { |fp| fp.sysread(bs) }
+
+      vec = (1..count).map { buf }
+      pid = fork do
+        wr.close
+        tmp = []
+        begin
+          sleep 0.005
+          tmp << rd.readpartial(8192, buf)
+        rescue EOFError
+          break
+        end while true
+        ok = (vec.join(empty) == tmp.join(empty))
+        exit! ok
+      end
+      assert_nothing_raised { rd.close }
+      assert_equal(bs * count, IO.vmsplice(wr.fileno, vec, 0))
+      assert_nothing_raised { wr.close }
+      _, status = Process.waitpid2(pid)
+      assert status.success?
+    end
+  end
+
+  def test_vmsplice_nil
+    data = %w(hello world how are you today)
+    assert_raises(TypeError) { IO.vmsplice(nil, data, 0) }
+  end
+
   def test_constants
     assert IO::Splice::PIPE_BUF > 0
     %w(move nonblock more gift).each { |x|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: io_splice
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - io_splice hackers
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-15 00:00:00 +00:00
+date: 2010-05-27 00:00:00 +00:00
 default_executable: 
 dependencies: []