rev 0.1.4 → 0.2.0

data/CHANGES

@@ -0,0 +1,102 @@
+0.2.0:
+
+* Initial Ruby 1.8.6 support
+
+* Omit Rev::LIBEV_VERSION constant
+
+* Catch Errno::ECONNRESET when writing to sockets
+
+* SSL support via Rev::SSL, with a small C extension subclassing Ruby's
+  OpenSSL::SSL::SSLSocket allowing for non-blocking SSL handshakes
+
+* Initial Rev::Utils implementation with #ncpus and methods to query and
+  change the maximum number of file descriptors for the current process.
+
+* Initial Rev::AsyncWatcher implementation for cross-thread signaling
+
+* Handle unspecified Content-Length when encoding is identity in HttpClient
+
+* Fix bug in HttpClient processing zero Content-Length
+
+* Get rid of method_missing stuff in Rev::HttpClient
+
+* Have Rev::HttpClient close the connection on error
+
+* Allow Rev::TCPSocket#on_connect to be private when accepting connections
+  from a Rev::TCPServer
+
+0.1.4:
+
+* Calibrate Rev::TimerWatchers against ev_time() and ev_now() when the watcher
+  is attached to the loop to ensure that the timeout interval is correct.
+
+* Add check to ensure that a Rev::Loop cannot be run from within a callback
+
+* Store Rev::Loop.default in a Thread-specific instance variable
+
+* Upgrade libev to 0.3.0
+
+* Rename BufferedIO to IO
+
+* Fixed bug in BufferedIO#write_output_buffer causing it to spin endlessly on
+  an empty buffer.
+
+* Added has_active_watchers? to Rev::Loop to check for active watchers
+
+0.1.3:
+
+* Fixed bug in Rev::Buffer read_from and write_to: now rb_sys_fail on failed
+  reads/writes.
+
+* Change Rev::Buffer memory pools to purge on a periodic interval, rather than
+  whenever the GC marks the object.
+
+* Fix bug in tracking the active watcher count.  Factor shared watcher behavior
+  from rev_watcher.h to rev_watcher.c.
+
+0.1.2:
+
+* Commit initial specs
+
+* Improve RDoc for the library
+
+* Eliminate "zero copy" writes as they bypass the event loop
+
+* Added Rev::Buffer C extension to provide high speed buffered writes
+
+* Implement Rev::TCPSocket#peeraddr to improve compatibility with Ruby sockets
+
+* Added Rev::Listener.close for clean shutdown of a listener
+
+* Rev::Loop.default used to call ev_loop_default() (in C).  However, this
+  registers signal handlers which conflict with Ruby's own.  Now the behavior
+  has been changed to return a thread-local singleton of Rev::Loop.
+
+* Creating a new Rev::TCPListener will disable reverse lookups in BasicSocket
+
+* Made backlog for Rev::TCPListener user-definable
+
+* Rev::TCPSocket now implements an on_resolve_failed callback for failed DNS
+  resolution.  By default it's aliased to on_connect_failed.
+
+* Changed event_callbacks to use instance_exec rather than passing the
+  watcher object as an argument.  Documented use of defining an event
+  callback as a block
+
+* Subsecond precision for Rev::TimerWatchers
+
+0.1.1:
+
+* Added Rev::HttpClient, an asynchronous HTTP/1.1 client written on top of
+  the Rev::TCPSocket class
+
+* Imported HTTP response parser from the RFuzz project
+
+* Added exception handling for Errno::ECONNRESET and Errno::EAGAIN
+
+* Fixed bugs in buffered writer which resulted in exceptions if all data
+  couldn't be written with a nonblocking write.
+
+0.1.0:
+
+* Initial public release

data/README

@@ -1,9 +1,9 @@
 = Rev
 
-Rev is a high performance event library for Ruby 1.9.  It uses the libev C
-library to handle support for underlying system calls.  This includes the
-epoll system call for Linux, the kqueue system call for BSDs and OS X, and the
-completion ports interface for Solaris.
+Rev is an event library for Ruby, built on the libev event library which 
+provides a cross-platform interface to high performance system calls .  This 
+includes the epoll system call for Linux, the kqueue system call for BSDs and 
+OS X, and the completion ports interface for Solaris.
 
 Rev also binds asynchronous wrappers to Ruby's core socket classes so you can
 use them in conjunction with Rev to build asynchronous event-driven 
@@ -120,7 +120,7 @@ haven't overridden them in a subclass).  This is especially useful for small
 one off programs or just experimenting with the API.
 
 Any callback (methods prefixed with on_*) can be set on the fly by passing it
-a block.
+a block. (NOTE: Ruby 1.9 only)
 
 Below is an example of using this syntax.  It implements an echo server
 identical to the one above:

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'fileutils'
+include FileUtils
+
+# Load Rev Gemspec
+load 'rev.gemspec'
+
+# Default Rake task is compile
+task :default => :compile
+
+# RDoc
+Rake::RDocTask.new(:rdoc) do |task|
+  task.rdoc_dir = 'doc'
+  task.title    = 'Rev'
+  task.options = %w(--title Revactor --main README --line-numbers)
+  task.rdoc_files.include(['ext/rev/*.c', 'lib/**/*.rb'])
+  task.rdoc_files.include(['README', 'LICENSE'])
+end
+
+# Gem
+Rake::GemPackageTask.new(GEMSPEC) do |pkg|
+  pkg.need_tar = true
+end
+
+def make(makedir)
+  Dir.chdir(makedir) { sh 'make' }
+end
+
+def extconf(dir)
+  Dir.chdir(dir) { ruby "extconf.rb" }
+end
+
+def setup_extension(dir, extension)
+  ext = "ext/#{dir}"
+  ext_so = "#{ext}/#{extension}.#{Config::CONFIG['DLEXT']}"
+  ext_files = FileList[
+    "#{ext}/*.c",
+    "#{ext}/*.h",
+    "#{ext}/extconf.rb",
+    "#{ext}/Makefile",
+    "lib"
+  ] 
+  
+  task "lib" do
+    directory "lib"
+  end
+
+  desc "Builds just the #{extension} extension"
+  task extension.to_sym => ["#{ext}/Makefile", ext_so ]
+
+  file "#{ext}/Makefile" => ["#{ext}/extconf.rb"] do
+    extconf "#{ext}"
+  end
+
+  file ext_so => ext_files do
+    make "#{ext}"
+    cp ext_so, "lib"
+  end
+end
+
+setup_extension("rev", "rev_ext")
+setup_extension("http11_client", "http11_client")
+
+task :compile => [:rev_ext, :http11_client]
+
+CLEAN.include ['build/*', '**/*.o', '**/*.so', '**/*.a', '**/*.log', 'pkg']
+CLEAN.include ['ext/rev/Makefile', 'lib/rev_ext.*', 'lib/http11_client.*']

data/examples/echo_server.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../lib/rev'
+
+ADDR = '127.0.0.1'
+PORT = 4321
+
+class EchoServerConnection < Rev::TCPSocket
+  def on_connect
+    puts "#{remote_addr}:#{remote_port} connected"
+  end
+
+  def on_close
+    puts "#{remote_addr}:#{remote_port} disconnected"
+  end
+
+  def on_read(data)
+    write data
+  end
+end
+
+event_loop = Rev::Loop.default
+Rev::TCPServer.new(ADDR, PORT, EchoServerConnection).attach(event_loop)
+
+puts "Echo server listening on #{ADDR}:#{PORT}"
+event_loop.run

data/ext/http11_client/http11_parser.rl

@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) 2005 Zed A. Shaw
+ * You can redistribute it and/or modify it under the same terms as Ruby.
+ */
+
+#include "http11_parser.h"
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#define LEN(AT, FPC) (FPC - buffer - parser->AT)
+#define MARK(M,FPC) (parser->M = (FPC) - buffer)
+#define PTR_TO(F) (buffer + parser->F)
+#define L(M) fprintf(stderr, "" # M "\n");
+
+
+/** machine **/
+%%{
+  machine httpclient_parser;
+
+  action mark {MARK(mark, fpc); }
+
+  action start_field { MARK(field_start, fpc); }
+
+  action write_field { 
+    parser->field_len = LEN(field_start, fpc);
+  }
+
+  action start_value { MARK(mark, fpc); }
+
+  action write_value { 
+    parser->http_field(parser->data, PTR_TO(field_start), parser->field_len, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action reason_phrase { 
+    parser->reason_phrase(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action status_code { 
+    parser->status_code(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action http_version {	
+    parser->http_version(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action chunk_size {
+    parser->chunk_size(parser->data, PTR_TO(mark), LEN(mark, fpc));
+  }
+
+  action last_chunk {
+    parser->last_chunk(parser->data, NULL, 0);
+  }
+
+  action done { 
+    parser->body_start = fpc - buffer + 1; 
+    if(parser->header_done != NULL)
+      parser->header_done(parser->data, fpc + 1, pe - fpc - 1);
+    fbreak;
+  }
+
+# line endings
+  CRLF = "\r\n";
+
+# character types
+  CTL = (cntrl | 127);
+  tspecials = ("(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\\" | "\"" | "/" | "[" | "]" | "?" | "=" | "{" | "}" | " " | "\t");
+
+# elements
+  token = (ascii -- (CTL | tspecials));
+
+  Reason_Phrase = (any -- CRLF)+ >mark %reason_phrase;
+  Status_Code = digit+ >mark %status_code;
+  http_number = (digit+ "." digit+) ;
+  HTTP_Version = ("HTTP/" http_number) >mark %http_version ;
+  Status_Line = HTTP_Version " " Status_Code " " Reason_Phrase :> CRLF;
+
+  field_name = token+ >start_field %write_field;
+  field_value = any* >start_value %write_value;
+  message_header = field_name ":" " "* field_value :> CRLF;
+
+  Response = 	Status_Line (message_header)* (CRLF @done);
+
+  chunk_ext_val = token+;
+  chunk_ext_name = token+;
+  chunk_extension = (";" chunk_ext_name >start_field %write_field %start_value ("=" chunk_ext_val >start_value)? %write_value )*;
+  last_chunk = "0"? chunk_extension :> (CRLF @last_chunk @done);
+  chunk_size = xdigit+;
+  chunk = chunk_size >mark %chunk_size chunk_extension :> (CRLF @done);
+  Chunked_Header = (chunk | last_chunk);
+
+  main := Response | Chunked_Header;
+}%%
+
+/** Data **/
+%% write data;
+
+int httpclient_parser_init(httpclient_parser *parser)  {
+  int cs = 0;
+  %% write init;
+  parser->cs = cs;
+  parser->body_start = 0;
+  parser->content_len = 0;
+  parser->mark = 0;
+  parser->nread = 0;
+  parser->field_len = 0;
+  parser->field_start = 0;    
+
+  return(1);
+}
+
+
+/** exec **/
+size_t httpclient_parser_execute(httpclient_parser *parser, const char *buffer, size_t len, size_t off)  {
+  const char *p, *pe;
+  int cs = parser->cs;
+
+  assert(off <= len && "offset past end of buffer");
+
+  p = buffer+off;
+  pe = buffer+len;
+
+  assert(*pe == '\0' && "pointer does not end on NUL");
+  assert(pe - p == len - off && "pointers aren't same distance");
+
+
+  %% write exec;
+
+  parser->cs = cs;
+  parser->nread += p - (buffer + off);
+
+  assert(p <= pe && "buffer overflow after parsing execute");
+  assert(parser->nread <= len && "nread longer than length");
+  assert(parser->body_start <= len && "body starts after buffer end");
+  assert(parser->mark < len && "mark is after buffer end");
+  assert(parser->field_len <= len && "field has length longer than whole buffer");
+  assert(parser->field_start < len && "field starts after buffer end");
+
+  if(parser->body_start) {
+    /* final \r\n combo encountered so stop right here */
+    %%write eof;
+    parser->nread++;
+  }
+
+  return(parser->nread);
+}
+
+int httpclient_parser_finish(httpclient_parser *parser)
+{
+  int cs = parser->cs;
+
+  %%write eof;
+
+  parser->cs = cs;
+
+  if (httpclient_parser_has_error(parser) ) {
+    return -1;
+  } else if (httpclient_parser_is_finished(parser) ) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int httpclient_parser_has_error(httpclient_parser *parser) {
+  return parser->cs == httpclient_parser_error;
+}
+
+int httpclient_parser_is_finished(httpclient_parser *parser) {
+  return parser->cs == httpclient_parser_first_final;
+}

data/ext/libev/Changes

@@ -0,0 +1,40 @@
+Revision history for libev, a high-performance and full-featured event loop
+
+3.0  Mon Jan 28 13:14:47 CET 2008
+	- API/ABI bump to version 3.0.
+	- ev++.h includes "ev.h" by default now, not <ev.h>.
+	- slightly improved documentation.
+	- speed up signal detection after a fork.
+        - only optionally return trace status changed in ev_child
+          watchers.
+        - experimental (and undocumented) loop wrappers for ev++.h.
+
+2.01 Tue Dec 25 08:04:41 CET 2007
+	- separate Changes file.
+	- fix ev_path_set => ev_stat_set typo.
+        - remove event_compat.h from the libev tarball.
+        - change how include files are found.
+        - doc updates.
+        - update licenses, explicitly allow for GPL relicensing.
+
+2.0  Sat Dec 22 17:47:03 CET 2007
+        - new ev_sleep, ev_set_(io|timeout)_collect_interval.
+        - removed epoll from embeddable fd set.
+        - fix embed watchers.
+	- renamed ev_embed.loop to other.
+	- added exported Symbol tables.
+        - undefine member wrapper macros at the end of ev.c.
+        - respect EV_H in ev++.h.
+
+1.86 Tue Dec 18 02:36:57 CET 2007
+	- fix memleak on loop destroy (not relevant for perl).
+
+1.85 Fri Dec 14 20:32:40 CET 2007
+        - fix some aliasing issues w.r.t. timers and periodics
+          (not relevant for perl).
+
+(for historic versions refer to EV/Changes, found in the Perl interface)
+
+0.1  Wed Oct 31 21:31:48 CET 2007
+	- original version; hacked together in <24h.
+

data/ext/libev/LICENSE

@@ -0,0 +1,25 @@
+All files in libev are Copyright (C)2007 Marc Alexander Lehmann.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.