rev 0.2.0 → 0.2.1

data/lib/rev/ssl.rb

@@ -6,22 +6,15 @@
 
 require 'openssl'
 
-# --
-# Rev implements SSL by subclassing OpenSSL::SSL::SSLSocket in C
-# and adding implementations for non-blocking versions of the
-# methods it provides.  Unfortunately, this relies on hacks specific
-# to Ruby 1.9.  If you'd like to find a workaround which is compatible
-# with Ruby 1.8, have a look at rev_ssl.c and find out if you can
-# properly initialize an OpenSSL::SSL::SSLSocket.
-# ++
-if RUBY_VERSION.gsub('.', '').to_i < 190
-  raise LoadError, "Rev::SSL not supported in this Ruby version, sorry"
-end
-
 module Rev
-  # Monkeypatch Rev::IO to include SSL support.  This can be accomplished
-  # by extending any Rev:IO (or subclass) object with Rev::SSL after the
-  # connection has completed, e.g.
+  # The easiest way to add SSL support to your Rev applications is to use
+  # the SSLSocket class.  However, the SSL module is provided for cases where
+  # you've already subclassed TCPSocket and want to optionally provide
+  # SSL support in that class.
+  #
+  # This module monkeypatches Rev::IO to include SSL support.  This can be 
+  # accomplished by extending any Rev:IO (or subclass) object with Rev::SSL 
+  # after the connection has completed, e.g.
   #
   #   class MySocket < Rev::TCPSocket
   #     def on_connect
@@ -29,19 +22,18 @@ module Rev
   #       ssl_client_start
   #     end
   #   end
-  #
-  # Please be aware that SSL is only supported on Ruby 1.9 at the present time.
   # 
   module SSL
     # Start SSL explicitly in client mode.  After calling this, callbacks
     # will fire for checking the peer certificate (ssl_peer_cert) and
     # its validity (ssl_verify_result)
     def ssl_client_start
-      raise "ssl already started" if @ssl_socket
+      raise "ssl already started" if @_ssl_socket
       
       context = respond_to?(:ssl_context) ? ssl_context : OpenSSL::SSL::SSLContext.new
-      @ssl_socket = SSL::IO.new(@io, context)
-      @ssl_init = proc { @ssl_socket.connect_nonblock }
+      
+      @_ssl_socket = SSL::IO.new(@_io, context)
+      @_ssl_init = proc { @_ssl_socket.connect_nonblock }
       
       ssl_init
     end
@@ -50,10 +42,10 @@ module Rev
     # will fire for checking the peer certificate (ssl_peer_cert) and
     # its validity (ssl_verify_result)
     def ssl_server_start
-      raise "ssl already started" if @ssl_socket
+      raise "ssl already started" if @_ssl_socket
       
-      @ssl_socket = SSL::IO.new(@io, ssl_context)
-      @ssl_init = proc { @ssl_socket.accept_nonblock }
+      @_ssl_socket = SSL::IO.new(@_io, ssl_context)
+      @_ssl_init = proc { @_ssl_socket.accept_nonblock }
       
       ssl_init
     end
@@ -64,13 +56,13 @@ module Rev
     
     def ssl_init
       begin
-        @ssl_init.call
+        @_ssl_init.call
         ssl_init_complete
       rescue SSL::IO::ReadAgain
         enable unless enabled?
       rescue SSL::IO::WriteAgain
         enable_write_watcher
-      rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET
+      rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET, Errno::EPIPE
         close
       rescue => ex
         if respond_to? :on_ssl_error
@@ -81,24 +73,25 @@ module Rev
     end
     
     def ssl_init_complete
-      @ssl_init = nil
+      @_ssl_init = nil
       enable unless enabled?
       
-      on_peer_cert(@ssl_socket.peer_cert) if respond_to? :on_peer_cert
-      on_ssl_result(@ssl_socket.verify_result) if respond_to? :on_ssl_result
+      on_peer_cert(@_ssl_socket.peer_cert) if respond_to? :on_peer_cert
+      # FIXME Rev::SSL::IO#verify_result needs to be adapted to non-blocking
+      #on_ssl_result(@_ssl_socket.verify_result) if respond_to? :on_ssl_result
       on_ssl_connect if respond_to? :on_ssl_connect
     end
     
     def on_readable
-      if @ssl_init
+      if @_ssl_init
         disable
         ssl_init
         return
       end
       
       begin
-        on_read @ssl_socket.read_nonblock(Rev::IO::INPUT_SIZE)
-      rescue Errno::AGAIN, SSL::IO::ReadAgain
+        on_read @_ssl_socket.read_nonblock(Rev::IO::INPUT_SIZE)
+      rescue Errno::EAGAIN, SSL::IO::ReadAgain
         return
       rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET, EOFError
         close
@@ -106,14 +99,14 @@ module Rev
     end
     
     def on_writable
-      if @ssl_init
+      if @_ssl_init
         disable_write_watcher
         ssl_init
         return
       end
       
       begin
-        nbytes = @ssl_socket.write_nonblock @write_buffer.to_str
+        nbytes = @_ssl_socket.write_nonblock @_write_buffer.to_str
       rescue Errno::EAGAIN, SSL::IO::WriteAgain
         return
       rescue OpenSSL::SSL::SSLError, Errno::EPIPE, Errno::ECONNRESET
@@ -121,29 +114,30 @@ module Rev
         return
       end
       
-      @write_buffer.read(nbytes)
+      @_write_buffer.read(nbytes)
       
-      if @write_buffer.empty?
+      if @_write_buffer.empty?
         disable_write_watcher
         on_write_complete
       end
     end
   end
   
-  # A socket class for outgoing and incoming SSL connections.  Please be aware
-  # that SSL is only supported on Ruby 1.9 at the present time.
+  # A socket class for SSL connections
   class SSLSocket < TCPSocket
     # Perform a non-blocking connect to the given host and port
     def self.connect(addr, port, *args)
-      super.instance_eval { @connecting = true; self }
+      sock = super
+      sock.instance_variable_set(:@_connecting, true)
+      sock
     end
     
     # Returns the OpenSSL::SSL::SSLContext for to use for the session.
     # By default no certificates will be checked.  If you would like 
     # any certificate checking to be performed, please override this 
-    # class and return a context loaded with the appropriate certificates.
+    # method and return a context loaded with the appropriate certificates.
     def ssl_context
-      @ssl_context ||= OpenSSL::SSL::SSLContext.new
+      @_ssl_context ||= OpenSSL::SSL::SSLContext.new
     end
     
     # Called when SSL handshaking has successfully completed
@@ -170,15 +164,7 @@ module Rev
     
     def on_connect
       extend SSL
-      @connecting ? ssl_client_start : ssl_server_start
-    end
-  end
-  
-  # A class for implementing SSL servers.  Please be aware that SSL is only
-  # supported on Ruby 1.9 at the present time.
-  class SSLServer < TCPServer
-    def initialize(host, port, klass = SSLSocket, *args, &block)
-      super
+      @_connecting ? ssl_client_start : ssl_server_start
     end
   end
 end

data/lib/rev/timer_watcher.rb

@@ -11,6 +11,7 @@ module Rev
     # These can take a block and store it to be called when the event
     # is actually fired.
     
+    extend Meta
     event_callback :timer_watcher
   end
 end

data/rev.gemspec

@@ -2,10 +2,10 @@ require 'rubygems'
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "rev"
-  s.version = "0.2.0"
+  s.version = "0.2.1"
   s.authors = "Tony Arcieri"
   s.email = "tony@medioh.com"
-  s.date = "2008-2-16"
+  s.date = "2008-4-19"
   s.summary = "Rev is a Ruby binding to the libev high performance event library"
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>= 1.8.6'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rev
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Tony Arcieri
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-16 00:00:00 -07:00
+date: 2008-04-19 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -33,11 +33,11 @@ files:
 - lib/rev/io_watcher.rb
 - lib/rev/listener.rb
 - lib/rev/loop.rb
+- lib/rev/meta.rb
 - lib/rev/server.rb
 - lib/rev/socket.rb
 - lib/rev/ssl.rb
 - lib/rev/timer_watcher.rb
-- lib/rev/watcher.rb
 - lib/rev.rb
 - ext/http11_client
 - ext/http11_client/ext_help.h