kgio-sendfile 1.2.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72978ae5f2835c3a37bd201aa17c4d18259fb9a7
+  data.tar.gz: 756d41104b237627b23b90e5f598096f2a036615
+SHA512:
+  metadata.gz: bf9c72e3a21c2e0bdd542ff3780f7d5a2c8f2e5721ddd1e1870db3e5e8744d6b7f0ca0b77f07554271066bdcf472b9f2a3ab0e954d21f73b01992305c35d70c3
+  data.tar.gz: 6a682a3e4719b10421fadb891d552186a608791461840a68cd9e29170ad7c0eb0199096e2538bed75b9f520964ee5854c75f27be6db841fe2ab8ef17e8a2d665

data/ChangeLog

@@ -0,0 +1,21 @@
+* sendfile 0.9.3 - 2008.11.30 <toby@cbcg.net>
+
+  - Included sys/stat.h regardless of platform to fix compilation on 
+    OS X 10.5 (credit: Damon Morda <dmorda@andrew.cmu.edu>)
+  - Source formatting clean-up
+
+* sendfile 0.9.2 - 2006.03.27 <toby@cbcg.net>
+
+  - Fixed typo: s/rv_sys_fail/rb_sys_fail
+
+* sendfile 0.9.1 - 2006.03.24 <toby@cbcg.net>
+
+  - Improved interface with non-blocking sockets
+  - Added unit tests for blocking sends
+  - Added unit tests for nonblocking sends
+  - Added README
+  - Packaged in a RubyGem
+
+* sendfile 0.0.1 - 2005.11.16 <toby@cbcg.net>
+
+  - Initial release

data/FILES

@@ -0,0 +1,10 @@
+FILES
+README.textile
+LICENSE
+ChangeLog
+ext/extconf.rb
+ext/sendfile.c
+test/test_sendfile.rb
+test/large.gz
+test/small
+sendfile.gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+
+Copyright (c) 2005,2008 Tobias DiPasquale
+
+Permission is hereby granted, free of charge, to any person obtaining a 
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included 
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.
+ 

data/README.textile

@@ -0,0 +1,35 @@
+kgio-sendfile is a (hopefully temporary) fork of the original "sendfile"
+gem for Ruby 2.2.0dev compatibility.   Only Linux (and maybe FreeBSD)
+are supported in this version.
+
+Send plain-text email to our mailing list at kgio@librelist.org for
+anything related to this.
+
+
+h1. Ruby sendfile(2) Interface
+
+This module allows Ruby programs to access their OS's native <code>sendfile(2)</code> system call from any IO object. Your kernel must export a recognized signature for the <code>sendfile(2)</code> system call to use this module. Currently, that includes Linux, Solaris and FreeBSD.
+
+h2. Installation
+
+Download and install the latest package from the rubyforge.org RubyGems repository.
+
+<code>
+  $ gem install sendfile 
+</code>
+
+If the tests all pass, you're ready to start using sendfile!
+
+h2. Usage
+
+Here's a small example of a use of <code>IO#sendfile</code>.
+
+bc.. require 'socket'
+require 'rubygems'
+require 'sendfile'
+s = TCPSocket.new 'yourdomain.com', 5000
+File.open 'somefile.txt' { |f| s.sendfile f }
+s.close
+
+p. See the test scripts for more examples on how to use this module.
+

data/ext/extconf.rb

@@ -0,0 +1,58 @@
+#
+# Copyright (c) 2005 Tobias DiPasquale
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+#
+
+#
+# $Id: extconf.rb,v 1.1 2006/03/25 01:42:02 codeslinger Exp $
+#
+require 'mkmf'
+
+$config_h = ""
+case RUBY_PLATFORM
+when /solaris/
+  have_header( "sys/sendfile.h")
+  have_library( "sendfile", "sendfile")
+  $config_h << "#define RUBY_PLATFORM_SOLARIS"
+when /linux/
+  have_header( "sys/sendfile.h")
+  have_library( "c", "sendfile")
+  $config_h << "#define RUBY_PLATFORM_LINUX"
+when /freebsd/
+  have_library( "c", "sendfile")
+  $config_h << "#define RUBY_PLATFORM_FREEBSD"
+when /darwin/
+  have_library( "c", "sendfile")
+  $config_h << "#define RUBY_PLATFORM_DARWIN"
+end
+
+File.open( "config.h", "w") do |f|
+f.print <<EOF
+#ifndef CONFIG_H
+#define CONFIG_H
+#{$config_h}
+#endif /* CONFIG_H */
+EOF
+end
+
+unless have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+  have_func('rb_thread_blocking_region')
+end
+create_makefile( "sendfile")

data/ext/sendfile.c

@@ -0,0 +1,371 @@
+/*
+ * ------------------------------------------------------------------------
+ *
+ * Copyright (c) 2005,2008 Tobias DiPasquale
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * ------------------------------------------------------------------------
+ *
+ * Ruby binding for the UNIX sendfile(2) facility. Should work on FreeBSD,
+ * Linux and Solaris systems that support sendfile(2).
+ *
+ * Original Author: Toby DiPasquale <toby@cbcg.net>
+ * Current Maintainer: Toby DiPasquale <toby@cbcg.net>
+ *
+ * $Id: sendfile.c,v 1.4 2006/03/27 19:14:53 codeslinger Exp $
+ */
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <limits.h>
+#include "ruby.h"
+#ifdef HAVE_RUBY_IO_H
+#  include "ruby/io.h"
+#else
+#  include "rubyio.h"
+#endif
+#include <unistd.h>
+#include <fcntl.h>
+#include "config.h"
+static VALUE sym_wait_writable;
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && defined(HAVE_RUBY_THREAD_H)
+/* Ruby 2.0+ */
+#  include <ruby/thread.h>
+typedef void * (*my_blocking_fn_t)(void*);
+#  define WITHOUT_GVL(fn,a) \
+	rb_thread_call_without_gvl((my_blocking_fn_t)(fn),(a),RUBY_UBF_IO,0)
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION) /* Ruby 1.9 */
+typedef VALUE (*my_blocking_fn_t)(void*);
+#  define WITHOUT_GVL(fn,a) \
+	rb_thread_blocking_region((my_blocking_fn_t)(fn),(a),RUBY_UBF_IO,0)
+#else /* MRI 1.8 threads */
+/*
+ * For non-natively threaded interpreters, do not monopolize the
+ * process and send in smaller chunks.  64K was chosen as it is
+ * half the typical max readahead size in Linux 2.6, giving the
+ * kernel some time to populate the page cache in between
+ * subsequent sendfile() calls.
+ */
+#  define MAX_SEND_SIZE ((off_t)(0x10000))
+
+/* (very) partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
+#  include <rubysig.h>
+typedef VALUE rb_blocking_function_t(void *);
+static VALUE
+WITHOUT_GVL(rb_blocking_function_t *fn, void *data1)
+{
+	VALUE rv;
+
+	TRAP_BEG;
+	rv = fn(data1);
+	TRAP_END;
+
+	return rv;
+}
+#endif /* WITHOUT_GVL definitions */
+
+#ifndef MAX_SEND_SIZE
+/*
+ * We can release the GVL and block as long as we need to.
+ * Limit this to the maximum ssize_t anyways, since 32-bit machines with
+ * Large File Support can't send more than this number of bytes
+ * in one shot.
+ */
+#  define MAX_SEND_SIZE ((off_t)LONG_MAX)
+#endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
+
+#if defined(RUBY_PLATFORM_FREEBSD)
+# include <sys/socket.h>
+# include <sys/uio.h>
+#elif defined(RUBY_PLATFORM_LINUX)
+# include <sys/sendfile.h>
+# include <unistd.h>
+#elif defined(RUBY_PLATFORM_SOLARIS)
+# include <sys/sendfile.h>
+#elif defined(RUBY_PLATFORM_DARWIN)
+# include <sys/types.h>
+# include <sys/socket.h>
+# include <sys/uio.h>
+#endif
+
+static size_t count_max(off_t count)
+{
+	return (size_t)(count > MAX_SEND_SIZE ? MAX_SEND_SIZE : count);
+}
+
+struct sendfile_args {
+	int out;
+	int in;
+	off_t off;
+	off_t count;
+	int eof;
+};
+
+#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_rb_fileno(VALUE io)
+{
+	rb_io_t *fptr;
+
+	GetOpenFile(io, fptr);
+
+	return FPTR_TO_FD(fptr);
+}
+
+#if defined(RUBY_PLATFORM_FREEBSD)
+static VALUE nogvl_sendfile(void *data)
+{
+	struct sendfile_args *args = data;
+	int rv;
+	off_t written = 0;
+	size_t w = count_max(args->count);
+
+	rv = sendfile(args->in, args->out, args->off, w, NULL, &written, 0);
+	if (written == 0 && rv == 0) {
+		args->eof = 1;
+	} else if (written > 0) {
+		args->off += written;
+		args->count -= written;
+		rv = 0; /* anything written is a success */
+	}
+
+	return (VALUE)rv;
+}
+#elif defined(RUBY_PLATFORM_DARWIN)
+static VALUE nogvl_sendfile(void *data)
+{
+	struct sendfile_args *args = data;
+	int rv;
+	off_t written = args->count;
+
+	rv = sendfile(args->in, args->out, args->off, &written,
+				  NULL, 0);
+	if (written == 0 && rv == 0) {
+		args->eof = 1;
+	} else {
+		args->off += written;
+		args->count -= written;
+	}
+
+	return (VALUE)rv;
+}
+#else
+static VALUE nogvl_sendfile(void *data)
+{
+	ssize_t rv;
+	struct sendfile_args *args = data;
+	size_t w = count_max(args->count);
+
+	rv = sendfile(args->out, args->in, &args->off, w);
+	if (rv == 0)
+		args->eof = 1;
+	if (rv > 0)
+		args->count -= rv;
+
+	return (VALUE)rv;
+}
+#endif
+
+static off_t sendfile_full(struct sendfile_args *args)
+{
+	ssize_t rv;
+	off_t all = args->count;
+
+	while (1) {
+		rv = (ssize_t)WITHOUT_GVL(nogvl_sendfile, args);
+		if (!args->count)
+			break;
+		if (args->eof) {
+			if (all != args->count)
+				break;
+			rb_eof_error();
+		}
+		if (rv < 0 && ! rb_io_wait_writable(args->out))
+			rb_sys_fail("sendfile");
+	}
+	return all - args->count;
+}
+
+static VALUE sendfile_nonblock(struct sendfile_args *args, int try)
+{
+	ssize_t rv;
+	off_t before = args->count;
+	int flags;
+
+	flags = fcntl(args->out, F_GETFL);
+	if (flags == -1)
+		rb_sys_fail("fcntl");
+	if ((flags & O_NONBLOCK) == 0) {
+		if (fcntl(args->out, F_SETFL, flags | O_NONBLOCK) == -1)
+			rb_sys_fail("fcntl");
+	}
+
+	rv = (ssize_t)WITHOUT_GVL(nogvl_sendfile, args);
+	if (rv < 0) {
+		if (try && errno == EAGAIN)
+			return sym_wait_writable;
+		rb_sys_fail("sendfile");
+	}
+	if (args->eof) {
+		if (try)
+			return Qnil;
+		rb_eof_error();
+	}
+
+	return OFFT2NUM(before - args->count);
+}
+
+static void convert_args(int argc, VALUE *argv, VALUE self,
+						 struct sendfile_args *args)
+{
+	VALUE in, offset, count;
+
+	/* get fds for files involved to pass to sendfile(2) */
+	rb_scan_args(argc, argv, "12", &in, &offset, &count);
+	in = rb_convert_type(in, T_FILE, "IO", "to_io");
+	args->out = my_rb_fileno(self);
+	args->in = my_rb_fileno(in);
+	args->eof = 0;
+
+	/* determine offset and count parameters */
+	args->off = (NIL_P(offset)) ? 0 : NUM2OFFT(offset);
+	if (NIL_P(count)) {
+		/* FreeBSD's sendfile() can take 0 as an indication to send
+		 * until end of file, but Linux and Solaris can't, and anyway
+		 * we need the file size to ensure we send it all in the case
+		 * of a non-blocking fd */
+		struct stat s;
+		if (fstat(args->in, &s) == -1)
+			rb_sys_fail("sendfile");
+		args->count = s.st_size;
+		args->count -= args->off;
+	} else {
+		args->count = NUM2OFFT(count);
+	}
+}
+
+/* call-seq:
+ *	writeIO.sendfile( readIO, offset=0, count=nil) => integer
+ *
+ * Transfers count bytes starting at offset from readIO directly to writeIO
+ * without copying (i.e. invoking the kernel to do it for you).
+ *
+ * If offset is omitted, transfer starts at the beginning of the file.
+ *
+ * If count is omitted, the full length of the file will be sent.
+ *
+ * Returns the number of bytes sent on success. Will throw system error
+ * exception on error. (check man sendfile(2) on your platform for
+ * information on what errors could result and how to handle them)
+ */
+static VALUE rb_io_sendfile(int argc, VALUE *argv, VALUE self)
+{
+	struct sendfile_args args;
+
+	convert_args(argc, argv, self, &args);
+
+	/* now send the file */
+	return OFFT2NUM(sendfile_full(&args));
+}
+
+/* call-seq:
+ *	writeIO.sendfile_nonblock(readIO, offset=0, count=nil) => integer
+ *
+ * Transfers count bytes starting at offset from readIO directly to writeIO
+ * without copying (i.e. invoking the kernel to do it for you).
+ *
+ * Unlike IO#sendfile, this will set the O_NONBLOCK flag on writeIO
+ * before calling sendfile(2) and will raise Errno::EAGAIN instead
+ * of blocking.  This method is intended for use with non-blocking
+ * event frameworks, including those that rely on Fibers.
+ *
+ * If offset is omitted, transfer starts at the beginning of the file.
+ *
+ * If count is omitted, the full length of the file will be sent.
+ *
+ * Returns the number of bytes sent on success. Will throw system error
+ * exception on error. (check man sendfile(2) on your platform for
+ * information on what errors could result and how to handle them)
+ */
+static VALUE rb_io_sendfile_nonblock(int argc, VALUE *argv, VALUE self)
+{
+	struct sendfile_args args;
+
+	convert_args(argc, argv, self, &args);
+
+	return sendfile_nonblock(&args, 0);
+}
+
+/* call-seq:
+ *	writeIO.trysendfile(readIO, offset=0, count=nil) => integer, nil, or
+ *														:wait_writable
+ *
+ * Transfers count bytes starting at offset from readIO directly to writeIO
+ * without copying (i.e. invoking the kernel to do it for you).
+ *
+ * Unlike IO#sendfile, this will set the O_NONBLOCK flag on writeIO
+ * before calling sendfile(2) and will return :wait_writable instead
+ * of blocking.  This method is intended for use with non-blocking
+ * event frameworks, including those that rely on Fibers.
+ *
+ * If offset is omitted, transfer starts at the beginning of the file.
+ *
+ * If count is omitted, the full length of the file will be sent.
+ *
+ * Returns the number of bytes sent on success, nil on EOF, and
+ * :wait_writable on EAGAIN.  Will throw system error exception on error.
+ * (check man sendfile(2) on your platform for
+ * information on what errors could result and how to handle them)
+ *
+ * This method is a faster alternative to sendfile_nonblock as it does
+ * not raise exceptions on common EAGAIN errors.
+ */
+static VALUE rb_io_trysendfile(int argc, VALUE *argv, VALUE self)
+{
+	struct sendfile_args args;
+
+	convert_args(argc, argv, self, &args);
+
+	return sendfile_nonblock(&args, 1);
+}
+
+/* Interface to the UNIX sendfile(2) system call. Should work on FreeBSD,
+ * Linux and Solaris systems that support the sendfile(2) system call.
+ */
+void Init_sendfile(void)
+{
+	sym_wait_writable = ID2SYM(rb_intern("wait_writable"));
+	rb_define_method(rb_cIO, "sendfile", rb_io_sendfile, -1);
+	rb_define_method(rb_cIO, "sendfile_nonblock",
+					 rb_io_sendfile_nonblock, -1);
+	rb_define_method(rb_cIO, "trysendfile", rb_io_trysendfile, -1);
+}

data/sendfile.gemspec

@@ -0,0 +1,26 @@
+# vim:set ts=4 sw=4 ai syntax=ruby:
+
+spec = Gem::Specification.new do |gs|
+	gs.name = 'kgio-sendfile'
+	gs.version = '1.2.1.1'
+	gs.summary = 'Ruby interface to sendfile(2) system call'
+	gs.description = <<-EOF
+This is a (hopefully temporary) fork of the original "sendfile" gem for
+Ruby 2.2.0dev compatibility.   Only Linux (and maybe FreeBSD) are
+supported in this version.
+
+Allows Ruby programs to access sendfile(2) functionality on 
+any IO object. Works on Linux, Solaris, FreeBSD and Darwin with
+blocking and non-blocking sockets.
+EOF
+	gs.authors = [ 'Eric Wong', 'Toby DiPasquale' ]
+	gs.email = 'kgio@librelist.org'
+	gs.homepage = 'http://bogomips.org/ruby-sendfile.git'
+	gs.files = File.read('FILES').split($/)
+	gs.test_files = Dir.glob 'test/test_*.rb'
+	gs.extensions << 'ext/extconf.rb'
+	gs.has_rdoc = true
+	gs.extra_rdoc_files = %w(README.textile)
+	gs.required_ruby_version = '>= 1.8.0'
+end
+

data/test/small

@@ -0,0 +1 @@
+I love Pocky!

data/test/test_sendfile.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+# vim:set ts=4 sw=4 ai:
+require 'io/nonblock'
+begin
+  require 'rubygems'
+rescue
+  nil
+end
+require 'sendfile'
+require 'socket'
+require 'tempfile'
+require "minitest/autorun"
+require 'minitest'
+require 'zlib'
+
+class TestSendfile < MiniTest::Test
+  def __fork_server
+    # open pipe for backchannel
+    @rd, @wr = IO.pipe
+    # fork server child
+    @pid = fork do
+      # close read end in child
+      @rd.close
+
+      # start listening and send port back to parent
+      ss = TCPServer.new @host, 0
+      @wr.write( [ ss.addr[1] ].pack( "S"))
+      @wr.flush
+
+      # read what they send and push it back up the pipe
+      while s = ss.accept
+        data = s.read
+        s.close
+        @wr.write( [data.length].pack( "N"))
+        @wr.write data
+        @wr.flush
+      end
+    end
+
+    # close write end in parent and get server port
+    @wr.close
+    @port = @rd.read( 2).unpack( "S")[0]
+  end
+
+  def setup
+    @dir = File.dirname __FILE__
+    @host = '127.0.0.1'
+    __fork_server
+
+    @smallfile = "#{@dir}/small"
+    @small = File.open @smallfile
+    @small_data = File.read @smallfile
+
+    File.open( "#{@dir}/large.gz") do |f|
+      gzipped = Zlib::GzipReader.new f
+      @large_data = gzipped.read
+    end
+    @largefile = "/tmp/sendfiletest"
+    @large = File.open @largefile, 'w+'
+    @large.write @large_data
+    @large.flush
+  end
+
+  def teardown
+    @small.close
+    @large.close
+    File.unlink @largefile
+
+    Process.kill 'KILL', @pid
+    Process.wait
+  end
+
+  def __do_sendfile file, off=nil, count=nil
+    s = TCPSocket.new @host, @port
+    yield s if block_given?
+    sent = s.sendfile file, off, count
+    s.close
+    len = @rd.read( 4).unpack( "N")[0]
+    read = @rd.read len
+    [ sent, read ]
+  end
+
+  def test_blocking_full_small
+    sent, read = __do_sendfile( @small)
+    assert_equal @small_data.size, sent
+    assert_equal @small_data.size, read.size
+    assert_equal @small_data, read
+  end
+
+  def test_nonblocking_full_small
+    sent, read = __do_sendfile( @small) { |s| s.nonblock = true }
+    assert_equal @small_data.size, sent
+    assert_equal @small_data.size, read.size
+    assert_equal @small_data, read
+  end
+
+  def test_blocking_full_large
+    sent, read = __do_sendfile( @large)
+    assert_equal @large_data.size, sent
+    assert_equal @large_data.size, read.size
+    assert_equal @large_data, read
+  end
+
+  def test_nonblocking_full_large
+    sent, read = __do_sendfile( @large) { |s| s.nonblock = true }
+    assert_equal @large_data.size, sent
+    assert_equal @large_data.size, read.size
+    assert_equal @large_data, read
+  end
+
+  def test_blocking_from_offset
+    data = @large_data[4096..-1]
+    sent, read = __do_sendfile( @large, 4096)
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_blocking_partial_from_beginning
+    data = @large_data[0, 1048576]
+    sent, read = __do_sendfile( @large, 0, 1048576)
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_blocking_partial_from_middle
+    data = @large_data[2048, 1048576]
+    sent, read = __do_sendfile( @large, 2048, 1048576)
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_blocking_partial_to_end
+    data = @large_data[-1048576, 1048576]
+    sent, read = __do_sendfile( @large, @large_data.size - 1048576, 1048576)
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_nonblocking_from_offset
+    data = @large_data[4096..-1]
+    sent, read = __do_sendfile( @large, 4096) { |s| s.nonblock = true }
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_nonblocking_partial_from_beginning
+    data = @large_data[0, 1048576]
+    sent, read = __do_sendfile( @large, 0, 1048576) { |s| s.nonblock = true }
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_nonblocking_partial_from_middle
+    data = @large_data[2048, 1048576]
+    sent, read = __do_sendfile( @large, 2048, 1048576) { |s| s.nonblock = true }
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_nonblocking_partial_to_end
+    data = @large_data[-1048576, 1048576]
+    sent, read = __do_sendfile( @large, @large_data.size - 1048576, 1048576) { |s| s.nonblock = true }
+    assert_equal data.size, sent
+    assert_equal data.size, read.size
+    assert_equal data, read
+  end
+
+  def test_sendfile_nonblock
+    c, s = UNIXSocket.pair
+    nr_sent = 0
+    assert_raises(Errno::EAGAIN) do
+      loop do
+        nr_sent += c.sendfile_nonblock @small
+      end
+    end
+    c.close
+    nr_read = s.read.size
+    s.close
+    assert_equal nr_read, nr_sent
+  end
+
+  def test_trysendfile
+    c, s = UNIXSocket.pair
+    nr_sent = 0
+    case rv = c.trysendfile(@small)
+    when :wait_writable
+      break
+    when Integer
+      nr_sent += rv
+    else
+      raise "Unexpected return: #{rv.inspect}"
+    end while true
+    assert nr_sent > 0, "nr_sent: #{nr_sent} <= 0"
+    c.close
+    nr_read = s.read.size
+    s.close
+    assert_equal nr_read, nr_sent
+  end
+
+  def test_tempfile
+    tmp = Tempfile.new ''
+    tmp.write @small_data
+    tmp.rewind
+    sent, read = __do_sendfile(tmp)
+    assert_equal @small_data.size, sent
+    assert_equal @small_data.size, read.size
+    assert_equal @small_data, read
+  end
+
+  def test_invalid_file
+    assert_raises(TypeError) { __do_sendfile(:hello) }
+  end
+
+  def test_sendfile_too_big_eof
+    sent = read = nil
+    count = @small_data.size * 2
+    s = TCPSocket.new @host, @port
+    sent = s.sendfile @small, nil, count
+    assert_raises(EOFError) do
+      s.sendfile @small, sent, 1
+    end
+    s.close
+    len = @rd.read( 4).unpack( "N")[0]
+    read = @rd.read len
+    assert_equal @small_data.size, sent
+    assert_equal @small_data.size, read.size
+    assert_equal @small_data, read
+  end
+
+  def test_sendfile_nonblock_eof
+    s = TCPSocket.new @host, @port
+    off = @small_data.size
+    assert_raises(EOFError) do
+      s.sendfile_nonblock @small, off, 1
+    end
+    s.close
+  end
+
+  def test_trysendfile_eof
+    s = TCPSocket.new @host, @port
+    off = @small_data.size
+    assert_nil s.trysendfile(@small, off, 1)
+    s.close
+  end
+end     # class TestSendfile

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: kgio-sendfile
+version: !ruby/object:Gem::Version
+  version: 1.2.1.1
+platform: ruby
+authors:
+- Eric Wong
+- Toby DiPasquale
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-13 00:00:00.000000000 Z
+dependencies: []
+description: "This is a (hopefully temporary) fork of the original \"sendfile\" gem
+  for\nRuby 2.2.0dev compatibility.   Only Linux (and maybe FreeBSD) are\nsupported
+  in this version.\n\nAllows Ruby programs to access sendfile(2) functionality on
+  \nany IO object. Works on Linux, Solaris, FreeBSD and Darwin with\nblocking and
+  non-blocking sockets.\n"
+email: kgio@librelist.org
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- README.textile
+files:
+- ChangeLog
+- FILES
+- LICENSE
+- README.textile
+- ext/extconf.rb
+- ext/sendfile.c
+- sendfile.gemspec
+- test/large.gz
+- test/small
+- test/test_sendfile.rb
+homepage: http://bogomips.org/ruby-sendfile.git
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby interface to sendfile(2) system call
+test_files:
+- test/test_sendfile.rb