sendfile 0.9.3 → 1.0.0

data/FILES

@@ -1,5 +1,5 @@
 FILES
-README
+README.textile
 LICENSE
 ChangeLog
 ext/extconf.rb

data/README.textile

@@ -0,0 +1,31 @@
+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.
+
+  $ sudo gem install sendfile 
+
+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>.
+
+  require 'socket'
+  require 'rubygems'
+  require 'sendfile'
+  s = TCPSocket.new 'yourdomain.com', 5000
+  File.open 'somefile.txt' { |f| s.sendfile f }
+  s.close
+
+See the test scripts for more examples on how to use this 
+module.
+

data/ext/extconf.rb

@@ -49,5 +49,6 @@ f.print <<EOF
 EOF
 end
 
+have_func('rb_thread_blocking_region')
 create_makefile( "sendfile")
 

data/ext/sendfile.c

@@ -33,11 +33,55 @@
  */
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <limits.h>
 #include "ruby.h"
-#include "rubyio.h"
-#include "rubysig.h"
+#ifdef HAVE_RUBY_IO_H
+#  include "ruby/io.h"
+#else
+#  include "rubyio.h"
+#endif
+#include <unistd.h>
+#include <fcntl.h>
 #include "config.h"
 
+#ifndef HAVE_RB_THREAD_BLOCKING_REGION
+/*
+ * 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>
+#  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)
+{
+	VALUE rv;
+
+	TRAP_BEG;
+	rv = fn(data1);
+	TRAP_END;
+
+	return rv;
+}
+#else
+/*
+ * 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>
@@ -48,103 +92,202 @@
 # include <sys/sendfile.h>
 #endif
 
-#define SENDFILE_PAUSE_SEC 	0
-#define SENDFILE_PAUSE_USEC	500
+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 off_t __sendfile(int out, int in, off_t off, size_t count, struct timeval *tv)
+static VALUE nogvl_sendfile(void *data)
 {
+	struct sendfile_args *args = data;
 	int rv;
-	off_t written, initial = off;
+	off_t written;
+	size_t w = count_max(args->count);
 
-	while (1) {
-		TRAP_BEG;
-		rv = sendfile(in, out, off, count, NULL, &written, 0);
-		TRAP_END;
-		off += written;
-		count -= written;
-		if (rv < 0 && errno != EAGAIN)
-			rb_sys_fail("sendfile");
-		if (!rv)
-			break;
-		rb_thread_select(0, NULL, NULL, NULL, tv);
+	rv = sendfile(args->in, args->out, args->off, args->count,
+	              NULL, &written, 0);
+	if (written == 0 && rv == 0) {
+		args->eof = 1;
+	} else {
+		args->off += written;
+		args->count -= written;
 	}
-	return off - initial;
+
+	return (VALUE)rv;
 }
 #else
-static size_t __sendfile(int out, int in, off_t off, size_t count, struct timeval *tv)
+static VALUE nogvl_sendfile(void *data)
 {
-	ssize_t rv, remaining = count;
-	
+	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) {
-		TRAP_BEG;
-		rv = sendfile(out, in, &off, remaining);
-		TRAP_END;
-		if (rv < 0 && errno != EAGAIN)
-			rb_sys_fail("sendfile");
-		if (rv > 0)
-			remaining -= rv;
-		if (!remaining)
+		rv = (ssize_t)rb_thread_blocking_region(nogvl_sendfile, args,
+		                                        RUBY_UBF_IO, NULL);
+		if (!args->count)
 			break;
-		rb_thread_select(0, NULL, NULL, NULL, tv);
+		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 count;
+	return all - args->count;
 }
-#endif
 
-/* 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)
+static off_t sendfile_nonblock(struct sendfile_args *args)
+{
+	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)rb_thread_blocking_region(nogvl_sendfile, args,
+	                                        RUBY_UBF_IO, NULL);
+	if (rv < 0)
+		rb_sys_fail("sendfile");
+	if (args->eof)
+		rb_eof_error();
+
+	return before - args->count;
+}
+
+static void convert_args(int argc, VALUE *argv, VALUE self,
+                         struct sendfile_args *args)
 {
-	int i, o;
-	size_t c;
-	off_t off;
-	OpenFile *iptr, *optr;
 	VALUE in, offset, count;
-	struct timeval _sendfile_sleep;
 
 	/* get fds for files involved to pass to sendfile(2) */
 	rb_scan_args(argc, argv, "12", &in, &offset, &count);
-	if (TYPE(in) != T_FILE)
-		rb_raise(rb_eArgError, "invalid first argument\n");
-	GetOpenFile(self, optr);
-	GetOpenFile(in, iptr);
-	o = fileno(optr->f);
-	i = fileno(iptr->f);
-
-	_sendfile_sleep.tv_sec = SENDFILE_PAUSE_SEC;
-	_sendfile_sleep.tv_usec = SENDFILE_PAUSE_USEC;
-	
+	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 */
-	off = (NIL_P(offset)) ? 0 : NUM2ULONG(offset);
+	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(i, &s) == -1)
+		if (fstat(args->in, &s) == -1)
 			rb_sys_fail("sendfile");
-		c = s.st_size;
-		c -= off;
+		args->count = s.st_size;
+		args->count -= args->off;
 	} else {
-		c = NUM2ULONG(count);
+		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 INT2FIX(__sendfile(o, i, off, c, &_sendfile_sleep));
+	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 OFFT2NUM(sendfile_nonblock(&args));
 }
 
 /* Interface to the UNIX sendfile(2) system call. Should work on FreeBSD,
@@ -153,5 +296,7 @@ static VALUE rb_io_sendfile(int argc, VALUE *argv, VALUE self)
 void Init_sendfile(void)
 {
 	rb_define_method(rb_cIO, "sendfile", rb_io_sendfile, -1);
+	rb_define_method(rb_cIO, "sendfile_nonblock",
+	                 rb_io_sendfile_nonblock, -1);
 }
 

data/sendfile.gemspec

@@ -2,7 +2,7 @@
 
 spec = Gem::Specification.new do |gs|
 	gs.name = 'sendfile'
-	gs.version = '0.9.3'
+	gs.version = '1.0.0'
 	gs.summary = 'Ruby interface to sendfile(2) system call'
 	gs.description = <<-EOF
 Allows Ruby programs to access sendfile(2) functionality on 
@@ -19,7 +19,7 @@ EOF
 	gs.extensions << 'ext/extconf.rb'
 
 	gs.has_rdoc = true
-	gs.extra_rdoc_files = %w(README)
+	gs.extra_rdoc_files = %w(README.textile)
 	gs.required_ruby_version = '>= 1.8.0'
 end
 

data/test/test_sendfile.rb

@@ -170,5 +170,58 @@ class TestSendfile < Test::Unit::TestCase
 		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_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
 end		# class TestSendfile
 

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sendfile
 version: !ruby/object:Gem::Version 
-  version: 0.9.3
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Toby DiPasquale
@@ -9,21 +15,25 @@ autorequire: sendfile
 bindir: bin
 cert_chain: []
 
-date: 2008-11-30 00:00:00 -05:00
+date: 2010-06-26 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
-description: Allows Ruby programs to access sendfile(2) functionality on  any IO object. Works on Linux, Solaris and FreeBSD with  blocking and non-blocking sockets.
+description: |
+  Allows Ruby programs to access sendfile(2) functionality on 
+  any IO object. Works on Linux, Solaris and FreeBSD with 
+  blocking and non-blocking sockets.
+
 email: toby@cbcg.net
 executables: []
 
 extensions: 
 - ext/extconf.rb
 extra_rdoc_files: 
-- README
+- README.textile
 files: 
 - FILES
-- README
+- README.textile
 - LICENSE
 - ChangeLog
 - ext/extconf.rb
@@ -34,29 +44,39 @@ files:
 - sendfile.gemspec
 has_rdoc: true
 homepage: 
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 55
+      segments: 
+      - 1
+      - 8
+      - 0
       version: 1.8.0
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: ruby-sendfile
-rubygems_version: 1.3.0
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Ruby interface to sendfile(2) system call
 test_files: 
 - test/test_sendfile.rb

data/README

@@ -1,57 +0,0 @@
-= Ruby sendfile(2) Interface
-
-This module allows Ruby programs to access their OS's native
-sendfile(2) system call from any IO object. Your kernel must
-export a recognized signature for the sendfile(2) system call
-to use this module. Currently, that includes Linux, Solaris
-and FreeBSD.
-
-== Installation
-
-Download and install the latest package from the rubyforge.org
-RubyGems repository.
-
-  gem install sendfile --remote
-  gem check sendfile --test
-
-If the tests all pass, you're ready to start using sendfile.
-
-Or, if you don't have rubygems installed, you can install by
-hand by downloading the tarball:
-
-  tar xzvf ruby-sendfile-<latest>.tar.gz
-  cd ruby-sendfile-<latest>/ext
-  ruby extconf.rb
-  make
-  sudo make install
-
-You can then run the tests with:
-
-  ruby test/test_*.rb
-
-== Usage
-
-Here's a small example of a use of IO#sendfile.
-
-  require 'socket'
-  require 'rubygems'
-  require 'sendfile'
-
-  s = TCPSocket.new 'yourdomain.com', 5000
-  File.open 'somefile.txt' { |f| s.sendfile f }
-  s.close
-
-See the test scripts for more examples on how to use this 
-module.
-
-== Contact Information
-
-This project's homepage is:
-
-  http://rubyforge.org/projects/ruby-sendfile
-
-Thereupon are additional resources, such as news and forums
-can be found for working out any issues you may have with this
-module. In the last case, you can email questions or patches
-to toby@cbcg.net.
-