io_splice 4.2.0 → 4.3.0

data/.gitignore

@@ -2,6 +2,7 @@
 *.so
 *.log
 *.rbc
+.rbx
 Makefile
 /GIT-VERSION-FILE
 /local.mk

data/GIT-VERSION-GEN

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

data/GNUmakefile

@@ -6,7 +6,6 @@ rfpackage := io_splice
 include pkg.mk
 ifneq ($(VERSION),)
 release::
-	$(RAKE) raa_update VERSION=$(VERSION)
 	$(RAKE) publish_news VERSION=$(VERSION)
 endif
 rcov: build

data/README

@@ -14,11 +14,9 @@ buffer.
   arbitrary file descriptors (assuming kernel support), not just
   file-to-socket (or file-to-anything in newer Linux).
 
-* Thread-safe blocking operations under Ruby 1.9, releases GVL
+* Thread-safe blocking operations under Ruby 1.9+, releases GVL
   if blocking operations are used.
 
-* Almost drop-in replacement for IO.copy_stream: IO::Splice.copy_stream
-
 * Safely usable with non-blocking I/O frameworks (unlike IO.copy_stream)
   when combined with the IO::Splice::F_NONBLOCK flag.
 

data/Rakefile

@@ -31,40 +31,3 @@ task :publish_news do
   rf.login
   rf.post_news('qrp', subject, body)
 end
-
-desc "post to RAA"
-task :raa_update do
-  require 'net/http'
-  require 'net/netrc'
-  rc = Net::Netrc.locate('io_splice-raa') or abort "~/.netrc not found"
-  password = rc.password
-
-  s = Gem::Specification.load('io_splice.gemspec')
-  desc = [ s.description.strip ]
-  desc << ""
-  desc << "* #{s.email}"
-  desc << "* #{git_url}"
-  desc << "* #{cgit_url}"
-  desc = desc.join("\n")
-  uri = URI.parse('http://raa.ruby-lang.org/regist.rhtml')
-  form = {
-    :name => s.name,
-    :short_description => s.summary,
-    :version => s.version.to_s,
-    :status => 'stable',
-    :owner => s.authors.first,
-    :email => s.email,
-    :category_major => 'Library',
-    :category_minor => 'System',
-    :url => s.homepage,
-    :download => 'http://rubyforge.org/frs/?group_id=5626',
-    :license => "LGPL",
-    :description_style => 'Plain',
-    :description => desc,
-    :pass => password,
-    :submit => 'Update',
-  }
-  res = Net::HTTP.post_form(uri, form)
-  p res
-  puts res.body
-end

data/examples/splice-cp.rb

@@ -1,13 +1,5 @@
 #!/usr/bin/env ruby
 # -*- encoding: binary -*-
-
-# Example of using IO.splice to copy a file
-# This can be significantly faster than IO.copy_stream as data
-# is never copied into userspace.
-
-require 'io/splice'
-
-usage = "#$0 SOURCE DEST"
-source = ARGV.shift or abort usage
-dest = ARGV.shift or abort usage
-IO::Splice.copy_stream(source, dest)
+# This example is no longer valid, IO.copy_stream is faster in Ruby 2.2+
+# since it uses sendfile directly, which now allows direct file-to-file
+# copying (on Linux only) with fewer syscalls than splice.

data/ext/io_splice/extconf.rb

@@ -3,7 +3,9 @@ $CPPFLAGS << ' -D_GNU_SOURCE=1'
 
 have_func('splice', %w(fcntl.h)) or abort 'splice(2) not defined'
 have_func('tee', %w(fcntl.h)) or abort 'tee(2) not defined'
+have_func('pipe2', %w(fcntl.h unistd.h))
 have_func('rb_thread_blocking_region')
+have_func('rb_thread_call_without_gvl')
 have_macro('F_GETPIPE_SZ', %w(fcntl.h))
 have_macro('F_SETPIPE_SZ', %w(fcntl.h))
 

data/ext/io_splice/io_splice_ext.c

@@ -79,23 +79,32 @@ static int check_fileno(VALUE io)
 	errno = saved_errno;
 	return fd;
 }
-#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && defined(HAVE_RUBY_THREAD_H)
+/* Ruby 2.0+ */
+#  include <ruby/thread.h>
+#  define WITHOUT_GVL(fn,a,ubf,b) \
+        rb_thread_call_without_gvl((fn),(a),(ubf),(b))
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+typedef VALUE (*my_blocking_fn_t)(void*);
+#  define WITHOUT_GVL(fn,a,ubf,b) \
+	rb_thread_blocking_region((my_blocking_fn_t)(fn),(a),(ubf),(b))
+
+#else /* Ruby 1.8 */
 /* 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)
 typedef void rb_unblock_function_t(void *);
-typedef VALUE rb_blocking_function_t(void *);
-static VALUE
-rb_thread_blocking_region(
-	rb_blocking_function_t *fn, void *data1,
-	rb_unblock_function_t *ubf, void *data2)
+typedef void * rb_blocking_function_t(void *);
+static void * WITHOUT_GVL(rb_blocking_function_t *func, void *data1,
+			rb_unblock_function_t *ubf, void *data2)
 {
-	VALUE rv;
+	void *rv;
 
 	assert(RUBY_UBF_IO == ubf && "RUBY_UBF_IO required for emulation");
 
 	TRAP_BEG;
-	rv = fn(data1);
+	rv = func(data1);
 	TRAP_END;
 
 	return rv;
@@ -108,17 +117,11 @@ rb_thread_blocking_region(
 #ifndef RSTRING_LEN
 #  define RSTRING_LEN(s) (RSTRING(s)->len)
 #endif
-#ifndef RARRAY_PTR
-#  define RARRAY_PTR(s) (RARRAY(s)->ptr)
-#endif
 #ifndef RARRAY_LEN
 #  define RARRAY_LEN(s) (RARRAY(s)->len)
 #endif
 
-static VALUE io_run(rb_blocking_function_t *fn, void *data)
-{
-	return rb_thread_blocking_region(fn, data, RUBY_UBF_IO, 0);
-}
+#define io_run(fn,data) WITHOUT_GVL((fn),(data),RUBY_UBF_IO,0)
 
 struct splice_args {
 	int fd_in;
@@ -129,14 +132,14 @@ struct splice_args {
 	unsigned flags;
 };
 
-static VALUE nogvl_splice(void *ptr)
+static void * nogvl_splice(void *ptr)
 {
 	struct splice_args *a = ptr;
 
 	if (a->len > MAX_AT_ONCE)
 		a->len = MAX_AT_ONCE;
 
-	return (VALUE)splice(a->fd_in, a->off_in, a->fd_out, a->off_out,
+	return (void *)splice(a->fd_in, a->off_in, a->fd_out, a->off_out,
 	                     a->len, a->flags);
 }
 
@@ -210,7 +213,6 @@ static ssize_t do_splice(int argc, VALUE *argv, unsigned dflags)
  * * IO::Splice::F_MOVE
  * * IO::Splice::F_NONBLOCK
  * * IO::Splice::F_MORE
- * * IO::Splice::WAITALL
  *
  * Returns the number of bytes spliced.
  * Raises EOFError when +io_in+ has reached end of file.
@@ -278,14 +280,14 @@ struct tee_args {
 };
 
 /* runs without GVL */
-static VALUE nogvl_tee(void *ptr)
+static void * nogvl_tee(void *ptr)
 {
 	struct tee_args *a = ptr;
 
 	if (a->len > MAX_AT_ONCE)
 		a->len = MAX_AT_ONCE;
 
-	return (VALUE)tee(a->fd_in, a->fd_out, a->len, a->flags);
+	return (void *)tee(a->fd_in, a->fd_out, a->len, a->flags);
 }
 
 static ssize_t do_tee(int argc, VALUE *argv, unsigned dflags)
@@ -344,7 +346,6 @@ static ssize_t do_tee(int argc, VALUE *argv, unsigned dflags)
  *
  * +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.
  *
@@ -406,30 +407,28 @@ struct vmsplice_args {
 	unsigned flags;
 };
 
-static VALUE nogvl_vmsplice(void *ptr)
+static void * nogvl_vmsplice(void *ptr)
 {
 	struct vmsplice_args *a = ptr;
 
-	return (VALUE)vmsplice(a->fd, a->iov, a->nr_segs, a->flags);
+	return (void *)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; \
-	cur = RARRAY_PTR(ary); \
-	n = RARRAY_LEN(ary); \
-	if (n > IOV_MAX) \
+	unsigned long i; \
+	iovcnt = (unsigned long)RARRAY_LEN(ary); \
+	if (iovcnt > IOV_MAX) \
 		rb_raise(rb_eArgError, "array is larger than IOV_MAX"); \
-	iov = tmp = alloca(sizeof(struct iovec) * n); \
+	iov = tmp = alloca(sizeof(struct iovec) * iovcnt); \
 	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); \
+	for (i = 0; i < iovcnt; tmp++, i++) { \
+		VALUE cur = rb_ary_entry(ary, (long)i); \
+		Check_Type(cur, T_STRING); \
+		tmp->iov_base = RSTRING_PTR(cur); \
+		tmp->iov_len = RSTRING_LEN(cur); \
 		expect += tmp->iov_len; \
 	} \
 } while (0)
@@ -619,8 +618,14 @@ static VALUE set_pipe_size(VALUE self, VALUE size)
 
 static int can_mod_pipe_size(void)
 {
+	/*
+	 * pipe2 appeared in Linux 2.6.27, F_*PIPE_SZ appeared in 2.6.35,
+	 * thus not having pipe2 automatically disqualifies us from having
+	 * F_*PIPE_SZ support
+	 */
+#ifdef HAVE_PIPE2
 	int fds[2];
-	int rc = pipe(fds);
+	int rc = pipe2(fds, O_CLOEXEC);
 
 	if (rc == 0) {
 		rc = fcntl(fds[0], F_GETPIPE_SZ);
@@ -629,13 +634,22 @@ static int can_mod_pipe_size(void)
 		(void)close(fds[0]);
 		(void)close(fds[1]);
 	} else {
-		/* weird error, but don't raise during init */
+		/*
+		 * weird error, but don't raise during init, this could be
+		 * ENOSYS, even..
+		 */
 		rc = 0;
 	}
 	errno = 0;
 	return rc;
+#else  /* ! HAVE_PIPE2 */
+	return 0;
+#endif /* ! HAVE_PIPE2 */
 }
 
+#define NODOC_CONST(klass,name,value) \
+  rb_define_const((klass),(name),(value))
+
 void Init_io_splice_ext(void)
 {
 	VALUE mSplice = rb_define_module_under(rb_cIO, "Splice");
@@ -696,7 +710,7 @@ void Init_io_splice_ext(void)
 	 *
 	 * IO.vmsplice always defaults to this behavior.
 	 */
-	rb_define_const(mSplice, "WAITALL", UINT2NUM(WAITALL));
+	NODOC_CONST(mSplice, "WAITALL", UINT2NUM(WAITALL));
 
 	/*
 	 * The maximum size of an atomic write to a pipe

data/io_splice.gemspec

@@ -21,7 +21,6 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{qrp}
   s.test_files = Dir['test/test_*.rb']
   s.add_development_dependency('wrongdoc', '~> 1.5')
-  s.add_development_dependency('rack', '~> 1.2')
 
   # s.licenses = %w(LGPL) # accessor not compatible with older RubyGems
 end

data/lib/io/splice.rb

@@ -3,6 +3,14 @@ require 'io_splice_ext'
 require 'io/wait'
 
 module IO::Splice
+  @warned = false
+
+  def self.__deprecated
+    return if @warned
+    warn("IO::Splice.{copy_stream,full} are deprecated " \
+         "and to be removed in io_splice 5.x")
+    @warned = true
+  end
 
   # The maximum default capacity of the pipe in bytes.
   # Under stock Linux, this is 65536 bytes as of 2.6.11, and 4096 before
@@ -36,10 +44,19 @@ module IO::Splice
   # Otherwise the copy will be until EOF is reached on the +src+.
   # +src+ and +dst+ must be IO objects or respond to +to_io+
   #
-  # This is nearly a drop-in replacement for IO.copy_stream (in Ruby 1.9)
-  # but does not take into account userspace I/O buffers nor IO-like
-  # objects with no underlying file descriptor (e.g. StringIO).
+  # Unlike IO.copy_stream, this does not take into account
+  # userspace I/O buffers nor IO-like objects with no underlying
+  # file descriptor (e.g. StringIO).
+  #
+  # This is unsafe for socket-to-socket copies unless there is an
+  # active (blocking) reader on the other end.
+  #
+  # This method is deprecated and will be removed in a future, as it is
+  # potentially unsafe for socket-to-socket operations and difficult-to-use.
+  # IO.copy_stream on Linux 2.6.33 and later allows using sendfile for
+  # file-to-file copies, so this offers no advantage.
   def self.copy_stream(src, dst, len = nil, src_offset = nil)
+    __deprecated
     close = []
     need_open?(src) and close << (src = File.open(src))
     need_open?(dst) and close << (dst = File.open(dst, "w"))
@@ -90,6 +107,7 @@ module IO::Splice
   #
   # This method is safe for splicing a pipe +src+ into any type of +dst+ IO.
   def self.full(src, dst, len, src_offset)
+    __deprecated
     IO.splice(src, src_offset, dst, nil, len, F_MOVE | WAITALL)
   end
 

data/test/test_io_splice.rb

@@ -332,130 +332,6 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert IO::Splice::PIPE_CAPA >= IO::Splice::PIPE_BUF
   end
 
-  def test_splice_copy_stream_file_to_file_small
-    a, b = Tempfile.new('a'), Tempfile.new('b')
-    a.syswrite 'hello world'
-    a.sysseek(0)
-    IO::Splice.copy_stream(a, b)
-    b.rewind
-    assert_equal 'hello world', b.read
-  end
-
-  def test_splice_copy_stream_file_to_file_big
-    buf = ('ab' * IO::Splice::PIPE_CAPA) + 'hi'
-    a, b = Tempfile.new('a'), Tempfile.new('b')
-    a.syswrite buf
-    a.sysseek(0)
-    IO::Splice.copy_stream(a, b)
-    b.rewind
-    assert_equal buf, b.read
-  end
-
-  def test_splice_copy_stream_file_to_file_big_partial
-    nr = IO::Splice::PIPE_CAPA
-    buf = ('ab' * nr) + 'hi'
-    a, b = Tempfile.new('a'), Tempfile.new('b')
-    a.syswrite buf
-    a.sysseek(0)
-    assert_equal nr, IO::Splice.copy_stream(a, b, nr)
-    b.rewind
-    assert_equal('ab' * (nr/2), b.read)
-  end
-
-  def test_splice_copy_stream_file_to_file_len
-    a, b = Tempfile.new('a'), Tempfile.new('b')
-    a.syswrite 'hello world'
-    a.sysseek(0)
-    IO::Splice.copy_stream(a, b, 5)
-    b.rewind
-    assert_equal 'hello', b.read
-  end
-
-  def test_splice_copy_stream_pipe_to_file_len
-    a = Tempfile.new('a')
-    r, w = IO.pipe
-    w.syswrite 'hello world'
-    IO::Splice.copy_stream(r, a, 5)
-    a.rewind
-    assert_equal 'hello', a.read
-  end
-
-  def test_splice_copy_stream_paths
-    a = Tempfile.new('a')
-    b = Tempfile.new('a')
-    a.syswrite('hello world')
-    IO::Splice.copy_stream(a.path, b.path, 5)
-    assert_equal 'hello', b.read
-  end
-
-  def test_splice_copy_stream_src_offset
-    a = Tempfile.new('a')
-    b = Tempfile.new('a')
-    a.syswrite('hello world')
-    IO::Splice.copy_stream(a.path, b.path, 5, 6)
-    assert_equal 'world', b.read
-  end
-
-  def test_splice_copy_stream_src_offset_unchanged
-    a = Tempfile.new('a')
-    b = Tempfile.new('a')
-    a.syswrite('hello world')
-    assert_equal 0, a.sysseek(0, IO::SEEK_SET)
-    IO::Splice.copy_stream(a, b.path, 5, 6)
-    assert_equal 'world', b.read
-    assert_equal 0, a.sysseek(0, IO::SEEK_CUR)
-  end
-
-  def test_copy_stream_nonblock_src
-    server = TCPServer.new('127.0.0.1', 0)
-    port = server.addr[1]
-    rp, wp = IO.pipe
-    rs = TCPSocket.new('127.0.0.1', port)
-    rs.nonblock = true
-    nr = 0
-    assert_raises(Timeout::Error) do
-      timeout(0.05) { nr += IO::Splice.copy_stream(rs, wp, 5) }
-    end
-    assert_equal 0, nr
-    rs.close
-    server.close
-  end if mri?
-
-  def test_copy_stream_nonblock_dst
-    server = TCPServer.new('127.0.0.1', 0)
-    port = server.addr[1]
-    rp, wp = IO.pipe
-    rs = TCPSocket.new('127.0.0.1', port)
-    rs.nonblock = true
-    client = server.accept
-    buf = ' ' * IO::Splice::PIPE_CAPA
-    nr = 0
-    assert_raises(Timeout::Error) do
-      loop do
-        begin
-          wp.write_nonblock(buf)
-        rescue Errno::EAGAIN
-        end
-        timeout(0.05) do
-          nr += IO::Splice.copy_stream(rp, rs, IO::Splice::PIPE_CAPA)
-        end
-      end
-    end
-    assert_equal nr, client.read(nr).size
-    rs.close
-    server.close
-  end if mri?
-
-  def test_copy_stream_eof
-    r, w = IO.pipe
-    w.syswrite 'hello world'
-    w.close
-    a = Tempfile.new('a')
-    assert_equal 11, IO::Splice.copy_stream(r, a)
-    a.rewind
-    assert_equal 'hello world', a.read
-  end
-
   def test_pipe_size
     r, w = IO.pipe
     assert_kind_of Integer, r.pipe_size

metadata

@@ -2,7 +2,7 @@
 name: !binary |-
   aW9fc3BsaWNl
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-19 00:00:00.000000000 Z
+date: 2014-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: !binary |-
@@ -34,27 +34,6 @@ dependencies:
       - !ruby/object:Gem::Version
         version: !binary |-
           MS41
-- !ruby/object:Gem::Dependency
-  name: !binary |-
-    cmFjaw==
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - !binary |-
-        fj4=
-      - !ruby/object:Gem::Version
-        version: !binary |-
-          MS4y
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - !binary |-
-        fj4=
-      - !ruby/object:Gem::Version
-        version: !binary |-
-          MS4y
 description: ! 'The splice family of Linux system calls can transfer data between
   file
 
@@ -103,12 +82,9 @@ files:
 - 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
-- test/test_rack_file_compat.rb
-- test/test_tcp_splice.rb
 homepage: http://bogomips.org/ruby_io_splice/
 licenses: []
 post_install_message: 
@@ -139,15 +115,9 @@ signing_key:
 specification_version: 3
 summary: zero-copy pipe I/O for Linux and Ruby
 test_files:
-- !binary |-
-  dGVzdC90ZXN0X3JhY2tfZmlsZV9jb21wYXQucmI=
 - !binary |-
   dGVzdC90ZXN0X2lvX3NwbGljZV9pbl9mdWxsLnJi
-- !binary |-
-  dGVzdC90ZXN0X3RjcF9zcGxpY2UucmI=
 - !binary |-
   dGVzdC90ZXN0X2lvX3NwbGljZS5yYg==
-- !binary |-
-  dGVzdC90ZXN0X2NvcHlfc3RyZWFtLnJi
 - !binary |-
   dGVzdC90ZXN0X2lvX3NwbGljZV9laW50ci5yYg==

data/test/test_copy_stream.rb

@@ -1,340 +0,0 @@
-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_rack_file_compat.rb

@@ -1,31 +0,0 @@
-# -*- encoding: binary -*-
-require "rack"
-require "test/unit"
-require "socket"
-require "io/splice"
-
-class TestRackFileCompat < Test::Unit::TestCase
-  def setup
-    @app = Rack::File.new(File.dirname(__FILE__))
-    @req = Rack::MockRequest.new(@app)
-    @base_file = File.basename(__FILE__)
-    @r, @w = UNIXSocket.pair
-  end
-
-  def teardown
-    [ @r, @w ].each { |io| io.closed? or io.close }
-  end
-
-  def test_get_rack_file
-    env = Rack::MockRequest.env_for "http://example.com/#@base_file"
-    status, headers, body = @app.call(env)
-    assert_equal 200, status.to_i
-    headers.each { |k,v|
-      assert_instance_of String, k.to_str
-      assert_instance_of String, v.to_str
-    }
-    thr = Thread.new { @r.read(File.size(__FILE__)) }
-    assert_equal File.size(__FILE__), IO::Splice.copy_stream(body, @w)
-    assert_equal File.read(__FILE__), thr.value
-  end
-end if IO.respond_to?(:copy_stream)

data/test/test_tcp_splice.rb

@@ -1,66 +0,0 @@
-require 'socket'
-require 'io/wait'
-require 'io/splice'
-require 'io/nonblock'
-require "test/unit"
-
-class TestTCPCopyStream < Test::Unit::TestCase
-  def setup
-    host = ENV["TEST_HOST"] || "127.0.0.1"
-    @srv = TCPServer.new(host, 0)
-    @port = @srv.addr[1]
-    @client = TCPSocket.new(host, @port)
-    @client.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-    @accept = @srv.accept
-    @accept.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
-    @client.sync = @accept.sync = true
-    @r, @w = IO.pipe
-  end
-
-  def teardown
-    @srv.close
-    [ @client, @accept, @r, @w ].each { |io| io.close unless io.closed? }
-  end
-
-  def test_client_to_server_eof
-    nr = 2000
-    buf = '0123456789abcdef' * 1024
-    expect = buf.size * nr
-    thr = Thread.new do
-      nr.times { @client.write(buf) }
-      @client.close
-    end
-    sleep 1 # wait for rcvbuf to fill up
-    bytes = IO::Splice.copy_stream(@accept, "/dev/null")
-    assert_equal expect, bytes
-  end
-
-  def test_client_to_server_expect
-    nr = 2000
-    buf = '0123456789abcdef' * 1024
-    expect = buf.size * nr
-    thr = Thread.new do
-      nr.times { @client.write(buf) }
-    end
-    sleep 1 # wait for rcvbuf to fill up
-    bytes = IO::Splice.copy_stream(@accept, "/dev/null", expect)
-    assert_equal expect, bytes
-  end
-
-  def test_mega_splice
-    nr = 2000
-    buf = '0123456789abcdef' * 1024
-    expect = buf.size * nr
-    thr = Thread.new do
-      nr.times { @client.write(buf) }
-      @client.close
-    end
-    size_t_max = if (1 << 30).kind_of?(Bignum)
-      0xffffffff
-    else
-      0xffffffffffffffff
-    end
-    bytes = IO::Splice.copy_stream(@accept, "/dev/null", size_t_max)
-    assert_equal expect, bytes
-  end
-end