rev 0.2.2 → 0.2.3

data/lib/revem.rb

@@ -0,0 +1,210 @@
+#--
+# Copyright (C)2007 Tony Arcieri, Roger Pack
+# You can redistribute this under the terms of the Ruby license
+# See file LICENSE for details
+#++
+
+require File.dirname(__FILE__) + '/rev'
+
+module EventMachine
+  
+  class << self
+    # Start the Reactor loop
+    def run
+      yield if block_given?
+      Rev::Loop.default.run
+    end
+
+    # Stop the Reactor loop
+    def stop_event_loop
+      Rev::Loop.default.stop
+    end
+
+    class OneShotEMTimer < Rev::TimerWatcher
+      def setup(proc)
+        @proc = proc
+      end
+
+      def on_timer
+       @proc.call
+      end
+    end
+
+    # ltodo: use Rev's PeriodicTimer to wrap EM's two similar to it
+    # todo: close all connections on 'stop', I believe
+
+    def add_timer interval, proc = nil, &block
+      block ||= proc
+      t = OneShotEMTimer.new(interval, false) # non repeating
+      t.setup(block) 
+      t.attach(Rev::Loop.default) # fire 'er off ltodo: do we keep track of these timers in memory?
+      t
+    end
+
+    def cancel_timer t
+     t.detach if t.attached? # guess there's a case where EM you can say 'cancel' but it's already fired? kind of odd but it happens
+    end
+
+    def set_comm_inactivity_timeout *args; end # TODO
+
+    # Make an outgoing connection
+    def connect(addr, port, handler = Connection, *args, &block)
+	block = args.pop if Proc === args[-1]
+
+       # make sure we're a 'real' class here
+       klass = if (handler and handler.is_a?(Class))
+         handler
+       else
+         Class.new( Connection ) {handler and include handler}
+       end
+
+      wrapped_child = CallsBackToEM.connect(addr, port, *args) # ltodo: args? what? they're used? also TODOC TODO FIX
+      conn = klass.new(wrapped_child) # ltodo [?] addr, port, *args)
+      wrapped_child.attach(Rev::Loop.default) # necessary
+      conn.heres_your_socket(wrapped_child)
+      wrapped_child.call_back_to_this(conn) # calls post_init for us
+      yield conn if block_given?
+    end
+    
+    # Start a TCP server on the given address and port
+    def start_server(addr, port, handler = Connection, *args, &block)
+
+       # make sure we're a 'real' class here
+       klass = if (handler and handler.is_a?(Class))
+         handler
+       else
+         Class.new( Connection ) {handler and include handler}
+       end
+      server = Rev::TCPServer.new(addr, port, CallsBackToEM, *args) { |wrapped_child| 
+	conn = klass.new(wrapped_child)
+	conn.heres_your_socket(wrapped_child) # ideally NOT have this :)
+	wrapped_child.call_back_to_this(conn) 
+	block.call(conn) if block
+      }
+
+      server.attach(Rev::Loop.default)
+    end
+
+    def stop_server server
+	server.close
+    end
+
+    # Set the maximum number of descriptors available to this process
+    def set_descriptor_table_size(nfds)
+      Rev::Utils.maxfds = nfds
+    end
+
+    # Compatibility noop.  Handled automatically by libev
+    def epoll; end
+
+    # Compatibility noop.  Handled automatically by libev
+    def kqueue; end
+  end
+
+  class CallsBackToEM < Rev::TCPSocket
+    class ConnectTimer < Rev::TimerWatcher
+      attr_accessor :parent
+      def on_timer
+       @parent.connection_has_timed_out
+      end
+    
+    end
+
+    def call_back_to_this parent
+      @call_back_to_this = parent
+      parent.post_init
+    end
+
+    def on_connect
+      # @connection_timer.detach if @connection_timer # won't need that anymore :) -- with server connecteds we don't have it, anyway
+      @call_back_to_this.connection_completed if @call_back_to_this # TODO should server accepted's call this? They don't currently [and can't, since on_connect gets called basically in the initializer--needs some code love for that to happen :)
+    end
+
+    def connection_has_timed_out
+      return if closed?
+      close unless closed? # wonder if this works when you're within a half-connected phase.  I think it does.  What about TCP state?
+      @call_back_to_this.unbind
+    end
+
+    def on_write_complete; close if @should_close_after_writing; end
+
+    def should_close_after_writing
+      @should_close_after_writing = true;
+    end
+
+    def on_close
+      @call_back_to_this.unbind # about the same ltodo check if they ARE the same here
+    end
+
+    def on_resolve_failed
+      fail
+    end
+
+    def on_connect_failed
+      fail
+    end
+
+    def on_read(data)
+      @call_back_to_this.receive_data data
+    end
+
+    def fail
+      #@connection_timer.detch if @connection_timer
+      @call_back_to_this.unbind
+    end
+
+    def self.connect *args
+      a = super *args
+      # the connect timer currently kills TCPServer classes.  I'm not sure why.
+      #@connection_timer = ConnectTimer.new(14) # needs to be at least higher than 12 :)
+      #@connection_timer.parent = a
+      #@connection_timer.attach(Rev::Loop.default)
+      a
+    end
+  
+  end
+
+  class Connection
+    def self.new *args
+      allocate#.instance_eval do
+      #  initialize *args
+      #end
+    end
+    # we will need to call 'their functions' appropriately -- the commented out ones, here
+    # 
+    # Callback fired when connection is created
+    def post_init; end # I thought we were 'overriding' EM's existing methods, here.  Huh? Why do we have to define these then?
+
+    # Callback fired when connection is closed
+    def unbind; end
+    
+    # Callback fired when data is received
+    # def receive_data(data); end
+    def heres_your_socket instantiated_rev_socket
+      instantiated_rev_socket.call_back_to_this self
+      @wrapped_rev = instantiated_rev_socket
+    end
+
+    # Send data to the current connection -- called by them
+    def send_data(data)
+      @wrapped_rev.write data
+    end
+    
+    # Close the connection, optionally after writing
+    def close_connection(after_writing = false)
+      return close_connection_after_writing if after_writing
+      @wrapped_rev.close
+    end
+    
+    # Close the connection after all data has been written
+    def close_connection_after_writing
+      @wrapped_rev.output_buffer_size.zero? ? @wrapped_rev.close : @wrapped_rev.should_close_after_writing
+    end
+
+    def get_peername
+        family, port, host_name, host_ip = @wrapped_rev.peeraddr
+	Socket.pack_sockaddr_in( port, host_ip) # pack it up :)
+    end
+    
+  end
+end

data/rev.gemspec

@@ -2,10 +2,10 @@ require 'rubygems'
 
 GEMSPEC = Gem::Specification.new do |s|
   s.name = "rev"
-  s.version = "0.2.2"
+  s.version = "0.2.3"
   s.authors = "Tony Arcieri"
   s.email = "tony@medioh.com"
-  s.date = "2008-4-19"
+  s.date = "2009-02-01"
   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.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - Tony Arcieri
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-19 00:00:00 -06:00
+date: 2009-02-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,6 +25,7 @@ extra_rdoc_files:
 - README
 - CHANGES
 files: 
+- lib/http11_client.bundle
 - lib/rev
 - lib/rev/async_watcher.rb
 - lib/rev/dns_resolver.rb
@@ -39,13 +40,20 @@ files:
 - lib/rev/ssl.rb
 - lib/rev/timer_watcher.rb
 - lib/rev.rb
+- lib/rev_ext.bundle
+- lib/revem.rb
 - ext/http11_client
 - ext/http11_client/ext_help.h
 - ext/http11_client/extconf.rb
+- ext/http11_client/http11_client.bundle
 - ext/http11_client/http11_client.c
+- ext/http11_client/http11_client.o
 - ext/http11_client/http11_parser.c
 - ext/http11_client/http11_parser.h
+- ext/http11_client/http11_parser.o
 - ext/http11_client/http11_parser.rl
+- ext/http11_client/Makefile
+- ext/http11_client/mkmf.log
 - ext/libev
 - ext/libev/Changes
 - ext/libev/ev.c
@@ -61,20 +69,38 @@ files:
 - ext/libev/LICENSE
 - ext/libev/README
 - ext/libev/README.embed
+- ext/libev/test_libev_win32.c
 - ext/libev/update_ev_wrap
 - ext/rev
+- ext/rev/ev_wrap.h
 - ext/rev/extconf.rb
+- ext/rev/libev.c
+- ext/rev/libev.o
+- ext/rev/Makefile
+- ext/rev/mkmf.log
 - ext/rev/rev.h
 - ext/rev/rev_buffer.c
+- ext/rev/rev_buffer.o
+- ext/rev/rev_ext.bundle
 - ext/rev/rev_ext.c
+- ext/rev/rev_ext.o
 - ext/rev/rev_io_watcher.c
+- ext/rev/rev_io_watcher.o
 - ext/rev/rev_loop.c
+- ext/rev/rev_loop.o
 - ext/rev/rev_ssl.c
+- ext/rev/rev_ssl.o
 - ext/rev/rev_timer_watcher.c
+- ext/rev/rev_timer_watcher.o
 - ext/rev/rev_utils.c
+- ext/rev/rev_utils.o
 - ext/rev/rev_watcher.c
 - ext/rev/rev_watcher.h
+- ext/rev/rev_watcher.o
+- examples/echo_client.rb
 - examples/echo_server.rb
+- examples/google.rb
+- examples/httpclient.rb
 - Rakefile
 - rev.gemspec
 - LICENSE
@@ -106,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rev
-rubygems_version: 1.0.1
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Rev is a Ruby binding to the libev high performance event library