arachni-reactor 0.1.0.beta5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7671f97abb22c56a6488378023cd84ad92a8f30
-  data.tar.gz: ffd8c0513e0c41d4483249faaeeea3d9eea5aa21
+  metadata.gz: d8f90922fd68d3df405cf0aa7537924db3f3c118
+  data.tar.gz: 5bd9e5042618276a83909b43879651d60f8e0538
 SHA512:
-  metadata.gz: 5678c3dd7c6e90aa2061f06c892a4889538baee925550db1f5a46fc3ff232a5c66849ae1fef8c24fe6ae06d1e066dc8bfc2570b6f996dfe89ce33effd6d8e86c
-  data.tar.gz: 8c5ebfd3235211408111216a1dbf942266354f085e14cd629ae56eda7ddb91126b9b4ccbf3705aa2732cf28a45d45598a2aaeea7eabad9af08c1486abd5b26f5
+  metadata.gz: ff7c11326a30b31030b95ac93cd7ee3e5c37ab6f7097bb6f9a4829354b13bc683d484e8243bb9d14e88b8248bd69481a9a43ac01d475a708e61199595ec4632b
+  data.tar.gz: f1563d0bafe856937029267327fa8c049b05a56122e8fa8dd5c1fd0b45bb7e9784f250eb8dfd4d6438d8b866cd402de4340b9382d5a304c204fd54552c4a389c

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # ChangeLog
 
+## Version 0.1.0
+
+- Cleaned up connection handling structure for JRuby support.
+- `Connection`
+    - `PeerInfo` now not included by default and only available for servers.
+
 ## Version 0.1.0.beta5 _(September 4, 2014)_
 
 - `Tasks::OneOff#call`: Ensure that the task is marked as done even if an

data/README.md

@@ -3,7 +3,7 @@
 <table>
     <tr>
         <th>Version</th>
-        <td>0.1.0.beta5</td>
+        <td>0.1.0</td>
     </tr>
     <tr>
         <th>Github page</th>
@@ -51,7 +51,7 @@ on network connections -- and less so on generic tasks.
  - Rubies:
     - MRI >= 1.9
     - Rubinius
-    - JRuby (Without OpenSSL support)
+    - JRuby
  - Operating Systems:
     - Linux
     - OSX
@@ -63,7 +63,7 @@ For examples please see the `examples/` directory.
 
 ## Installation
 
-    gem install arachni-reactor --pre
+    gem install arachni-reactor
 
 ## Running the Specs
 

data/lib/arachni/reactor.rb

@@ -199,10 +199,9 @@ class Reactor
         begin
             Connection::Error.translate do
                 socket = options[:unix_socket] ?
-                    connect_unix( options[:unix_socket] ) :
-                    connect_tcp( options[:host], options[:port] )
+                    connect_unix( options[:unix_socket] ) : connect_tcp
 
-                connection.configure socket, :client
+                connection.configure options.merge( socket: socket, role: :client )
                 attach connection
             end
         rescue Connection::Error => e
@@ -266,7 +265,7 @@ class Reactor
                     listen_unix( options[:unix_socket] ) :
                     listen_tcp( options[:host], options[:port] )
 
-                server.configure socket, :server, server_handler
+                server.configure options.merge( socket: socket, role: :server, server_handler: server_handler )
                 attach server
             end
         rescue Connection::Error => e
@@ -500,7 +499,7 @@ class Reactor
 
         schedule do
             connection.reactor = self
-            @connections[connection.socket] = connection
+            @connections[connection.to_io] = connection
             connection.on_attach
         end
     end
@@ -517,7 +516,7 @@ class Reactor
 
         schedule do
             connection.on_detach
-            @connections.delete connection.socket
+            @connections.delete connection.to_io
             connection.reactor = nil
         end
     end
@@ -525,7 +524,7 @@ class Reactor
     # @return   [Bool]
     #   `true` if the connection is attached, `false` otherwise.
     def attached?( connection )
-        @connections.include? connection.socket
+        @connections.include? connection.to_io
     end
 
     private
@@ -558,6 +557,13 @@ class Reactor
             return
         end
 
+        # Required for OSX as it connects immediately and then #select returns
+        # nothing as there's no activity, given that, OpenSSL doesn't get a chance
+        # to do its handshake so explicitly connect pending sockets, bypassing #select.
+        @connections.each do |_, connection|
+            connection._connect if !connection.connected?
+        end
+
         # Get connections with available events - :read, :write, :error.
         selected = select_connections
 
@@ -599,26 +605,13 @@ class Reactor
 
     # @return   [Socket]
     #   Connected socket.
-    def connect_tcp( host, port )
+    def connect_tcp
         socket = Socket.new(
             Socket::Constants::AF_INET,
             Socket::Constants::SOCK_STREAM,
             Socket::Constants::IPPROTO_IP
         )
         socket.do_not_reverse_lookup = true
-
-        # JRuby throws java.nio.channels.NotYetConnectedException even after
-        # it returns the socket from Kernel.select, so wait for it to connect
-        # before moving on.
-        if self.class.jruby?
-            socket.connect( Socket.sockaddr_in( port, host ) )
-        else
-            begin
-                socket.connect_nonblock( Socket.sockaddr_in( port, host ) )
-            rescue IO::WaitReadable, IO::WaitWritable, Errno::EINPROGRESS
-            end
-        end
-
         socket
     end
 
@@ -650,43 +643,70 @@ class Reactor
     #       {Connection#has_outgoing_data? outgoing buffer).
     #   * `:error`
     def select_connections
-        grouped_sockets =
+        readables = read_sockets
+
+        selected_sockets =
             begin
                 Connection::Error.translate do
                     select(
-                        read_sockets,
+                        readables,
                         write_sockets,
-                        read_sockets, # Read sockets are actually all sockets.
+                        all_sockets,
                         @select_timeout
                     )
                 end
-            rescue Connection::Error
+            rescue Connection::Error => e
+                nil
             end
 
-        return {} if !grouped_sockets
+        selected_sockets ||= [[],[],[]]
+
+        # SSL sockets maintain their own buffer whose state can't be checked by
+        # Kernel.select, leading to cases where the SSL buffer isn't empty,
+        # even though Kernel.select says that there's nothing to read.
+        #
+        # So force a read for SSL sockets to cover all our bases.
+        #
+        # This is apparent especially on JRuby.
+        (readables - selected_sockets[0]).each do |socket|
+            next if !socket.is_a?( OpenSSL::SSL::SSLSocket )
+            selected_sockets[0] << socket
+        end
+
+        if selected_sockets[0].empty? && selected_sockets[1].empty? &&
+            selected_sockets[2].empty?
+            return {}
+        end
 
         {
             # Since these will be processed in order, it's better have the write
             # ones first to flush the buffers ASAP.
-            write: connections_from_sockets( grouped_sockets[1] ),
-            read:  connections_from_sockets( grouped_sockets[0] ),
-            error: connections_from_sockets( grouped_sockets[2] )
+            write:   connections_from_sockets( selected_sockets[1] ),
+            read:    connections_from_sockets( selected_sockets[0] ),
+            error:   connections_from_sockets( selected_sockets[2] )
         }
     end
 
     # @return   [Array<Socket>]
     #   Sockets of all connections, we want to be ready to read at any time.
     def read_sockets
-        @connections.keys
+        @connections.map do |_, connection|
+            next if !connection.listener? && !connection.connected?
+            connection.socket
+        end.compact
+    end
+
+    def all_sockets
+        @connections.values.map(&:socket)
     end
 
     # @return   [Array<Socket>]
     #   Sockets of connections with
     #   {Connection#has_outgoing_data? outgoing data}.
     def write_sockets
-        @connections.map do |socket, connection|
-            next if !connection.has_outgoing_data?
-            socket
+        @connections.map do |_, connection|
+            next if connection.connected? && !connection.has_outgoing_data?
+            connection.socket
         end.compact
     end
 
@@ -695,7 +715,7 @@ class Reactor
     end
 
     def connection_from_socket( socket )
-        @connections[socket]
+        @connections[socket.to_io]
     end
 
 end

data/lib/arachni/reactor/connection.rb

@@ -7,8 +7,8 @@
 =end
 
 require_relative 'connection/error'
-require_relative 'connection/peer_info'
 require_relative 'connection/callbacks'
+require_relative 'connection/peer_info'
 require_relative 'connection/tls'
 
 module Arachni
@@ -16,7 +16,6 @@ class Reactor
 
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 class Connection
-    include PeerInfo
     include Callbacks
 
     # Maximum amount of data to be written or read at a time.
@@ -176,6 +175,92 @@ class Connection
         nil
     end
 
+    # Accepts a new client connection.
+    #
+    # @return   [Connection, nil]
+    #   New connection or `nil` if the socket isn't ready to accept new
+    #   connections yet.
+    #
+    # @private
+    def accept
+        return if !(accepted = socket_accept)
+
+        connection = @server_handler.call
+        connection.configure socket: accepted, role: :server
+        @reactor.attach connection
+        connection
+    end
+
+    # @param    [Socket]    socket
+    #   Ruby `Socket` associated with this connection.
+    # @param    [Symbol]    role
+    #   `:server` or `:client`.
+    # @param    [Block]    server_handler
+    #   Block that generates a handler as specified in {Reactor#listen}.
+    #
+    # @private
+    def configure( options = {} )
+        @socket         = options[:socket]
+        @role           = options[:role]
+        @host           = options[:host]
+        @port           = options[:port]
+        @server_handler = options[:server_handler]
+
+        # If we're a server without a handler then we're an accepted connection.
+        if unix? || role == :server
+            @connected = true
+            on_connect
+        end
+
+        nil
+    end
+
+    def connected?
+        !!@connected
+    end
+
+    # @private
+    def _connect
+        return true if unix? || connected?
+
+        begin
+            Error.translate do
+                socket.connect_nonblock( Socket.sockaddr_in( @port, @host ) )
+            end
+        # Already connected. :)
+        rescue Errno::EISCONN
+        end
+
+        @connected = true
+        on_connect
+
+        true
+    rescue IO::WaitReadable, IO::WaitWritable, Errno::EINPROGRESS
+    rescue Error => e
+        close e
+    end
+
+    # @note If this is a server {#listener?} it will delegate to {#accept}.
+    # @note If this is a normal socket it will read {BLOCK_SIZE} amount of data.
+    #   and pass it to {#on_read}.
+    #
+    # Processes a `read` event for this connection.
+    #
+    # @private
+    def _read
+        return _connect if !listener? && !connected?
+        return accept   if listener?
+
+        Error.translate do
+            on_read @socket.read_nonblock( BLOCK_SIZE )
+        end
+
+    # Not ready to read or write yet, we'll catch it on future Reactor ticks.
+    rescue IO::WaitReadable, IO::WaitWritable
+    rescue Error => e
+        close e
+    end
+
     # @note Will call {#on_write} every time any of the buffer is consumed,
     #   can be multiple times when performing partial writes.
     # @note Will call {#on_flush} once all of the buffer has been consumed.
@@ -190,12 +275,14 @@ class Connection
     #
     # @private
     def _write
+        return _connect if !connected?
+
         chunk = write_buffer.slice( 0, BLOCK_SIZE )
         total_written = 0
 
         begin
             Error.translate do
-                # Send out the buffer, **all** of it, or at least try to.
+                # Send out the chunk, **all** of it, or at least try to.
                 loop do
                     total_written += written = @socket.write_nonblock( chunk )
                     write_buffer.slice!( 0, written )
@@ -222,60 +309,6 @@ class Connection
         close e
     end
 
-    # @note If this is a server {#listener?} it will delegate to {#accept}.
-    # @note If this is a normal socket it will read {BLOCK_SIZE} amount of data.
-    #   and pass it to {#on_read}.
-    #
-    # Processes a `read` event for this connection.
-    #
-    # @private
-    def _read
-        return accept if listener?
-
-        Error.translate do
-            on_read @socket.read_nonblock( BLOCK_SIZE )
-        end
-
-    # Not ready to read or write yet, we'll catch it on future Reactor ticks.
-    rescue IO::WaitReadable, IO::WaitWritable
-    rescue Error => e
-        close e
-    end
-
-    # Accepts a new client connection.
-    #
-    # @return   [Connection, nil]
-    #   New connection or `nil` if the socket isn't ready to accept new
-    #   connections yet.
-    #
-    # @private
-    def accept
-        return if !(accepted = socket_accept)
-
-        connection = @server_handler.call
-        connection.configure accepted, :server
-        @reactor.attach connection
-        connection
-    end
-
-    # @param    [Socket]    socket
-    #   Ruby `Socket` associated with this connection.
-    # @param    [Symbol]    role
-    #   `:server` or `:client`.
-    # @param    [Block]    server_handler
-    #   Block that generates a handler as specified in {Reactor#listen}.
-    #
-    # @private
-    def configure( socket, role, server_handler = nil )
-        @socket         = socket
-        @role           = role
-        @server_handler = server_handler
-
-        on_connect
-
-        nil
-    end
-
     private
 
     def write_buffer

data/lib/arachni/reactor/connection/error.rb

@@ -51,7 +51,7 @@ class Error < Arachni::Reactor::Error
         # aren't any specific exceptions for these.
         #
         # Why make things easy and clean, right?
-        rescue OpenSSL::OpenSSLError => e
+        rescue OpenSSL::SSL::SSLError, OpenSSL::OpenSSLError => e
             raise_with_proper_backtrace( e, SSL )
         end
 

data/lib/arachni/reactor/connection/tls.rb

@@ -62,17 +62,78 @@ module TLS
             @socket = OpenSSL::SSL::SSLSocket.new( @socket, @ssl_context )
             @socket.sync_close = true
 
-            begin
-                @socket.connect_nonblock
-            rescue IO::WaitReadable, IO::WaitWritable
-            end
+            # We've switched to SSL, a connection needs to be re-established
+            # via the SSL handshake.
+            @connected         = false
+
+            _connect if unix?
         end
 
         @socket
     end
 
+    # Performs an SSL handshake in addition to a plaintext connect operation.
+    #
+    # @private
+    def _connect
+        return if @ssl_connected
+
+        Error.translate do
+            @plaintext_connected ||= super
+            return if !@plaintext_connected
+
+            # Mark the connection as not connected due to the pending SSL handshake.
+            @connected = false
+
+            @socket.connect_nonblock
+            @ssl_connected = @connected = true
+        end
+    rescue IO::WaitReadable, IO::WaitWritable, Errno::EINPROGRESS
+    rescue Error => e
+        close e
+    end
+
+    # First checks if there's a pending SSL #accept operation when this
+    # connection is a server handler which has been passed an accepted
+    # plaintext connection.
+    #
+    # @private
+    def _write( *args )
+        return ssl_accept if accept?
+
+        super( *args )
+    end
+
+    # First checks if there's a pending SSL #accept operation when this
+    # connection is a server handler which has been passed an accepted
+    # plaintext connection.
+    #
+    # @private
+    def _read
+        return ssl_accept if accept?
+
+        super
+    end
+
     private
 
+    def ssl_accept
+        Error.translate do
+            @accepted = !!@socket.accept_nonblock
+        end
+    rescue IO::WaitReadable, IO::WaitWritable
+    rescue Error => e
+        close e
+        false
+    end
+
+    def accept?
+        return false if @accepted
+        return false if role != :server || !@socket.is_a?( OpenSSL::SSL::SSLSocket )
+
+        true
+    end
+
     # Accepts a new SSL client connection.
     #
     # @return   [OpenSSL::SSL::SSLSocket, nil]
@@ -81,26 +142,19 @@ module TLS
     #
     # @private
     def socket_accept
-        socket = nil
-        begin
+        Error.translate do
             socket = to_io.accept_nonblock
-        rescue IO::WaitReadable, IO::WaitWritable
-            return
-        end
-
-        socket = OpenSSL::SSL::SSLSocket.new(
-            socket,
-            @ssl_context
-        )
-        socket.sync_close = true
 
-        begin
-            socket.accept_nonblock
-        rescue IO::WaitReadable, IO::WaitWritable
+            ssl_socket = OpenSSL::SSL::SSLSocket.new(
+                socket,
+                @ssl_context
+            )
+            ssl_socket.sync_close = true
+            ssl_socket
         end
-
-        socket
-    rescue OpenSSL::SSL::SSLError
+    rescue IO::WaitReadable, IO::WaitWritable
+    rescue Error => e
+        close e
     end
 
 end

data/lib/arachni/reactor/version.rb

@@ -9,7 +9,7 @@
 module Arachni
 class Reactor
 
-    VERSION = '0.1.0.beta5'
+    VERSION = '0.1.0'
 
 end
 end

data/spec/arachni/reactor/connection/tls_spec.rb

@@ -43,16 +43,32 @@ describe Arachni::Reactor::Connection::TLS do
         end
     end
 
+    before :each do
+        @accept_q = Queue.new
+        @accepted = nil
+    end
+
     let(:unix_socket) { unix_connect( @unix_socket ) }
     let(:unix_server_socket) { unix_server( port_to_socket( Servers.available_port ) ) }
 
-    let(:echo_client) { tcp_connect( @host, @port ) }
+    let(:echo_client) { tcp_socket }
     let(:echo_client_handler) { EchoClientTLS.new }
 
     let(:peer_client_socket) { tcp_ssl_connect( host, port ) }
-    let(:peer_server_socket) { tcp_ssl_server( host, port ) }
+    let(:peer_server_socket) do
+        s = tcp_ssl_server( host, port )
+        Thread.new do
+            begin
+                @accept_q << s.accept
+            rescue => e
+                ap e
+            end
+        end
+        s
+    end
+    let(:accepted) { @accepted ||= @accept_q.pop }
 
-    let(:client_socket) { tcp_connect( host, port ) }
+    let(:client_socket) { tcp_socket }
     let(:server_socket) { tcp_server( host, port ) }
 
     let(:connection) { TLSHandler.new }
@@ -244,7 +260,15 @@ describe Arachni::Reactor::Connection::TLS do
 
         context 'when connecting to a server' do
             let(:server) do
-                tcp_ssl_server( host, port, server_ssl_options )
+                s = tcp_ssl_server( host, port, server_ssl_options )
+                Thread.new do
+                    begin
+                        @accept_q << s.accept
+                    rescue => e
+                        # ap e
+                    end
+                end
+                s
             end
 
             before :each do
@@ -258,9 +282,7 @@ describe Arachni::Reactor::Connection::TLS do
                     it 'connects successfully' do
                         received = nil
                         Thread.new do
-                            s = server.accept
-                            received = s.gets
-
+                            received = accepted.gets
                             reactor.stop
                         end
 
@@ -279,10 +301,6 @@ describe Arachni::Reactor::Connection::TLS do
 
                 context 'and no options have been provided' do
                     it "passes #{Arachni::Reactor::Connection::Error} to #on_error" do
-                        Thread.new do
-                            server.accept
-                        end
-
                         connection = nil
                         reactor.run do
                             connection = reactor.connect( host, port, TLSHandler )
@@ -297,8 +315,7 @@ describe Arachni::Reactor::Connection::TLS do
                         it 'connects successfully' do
                             received = nil
                             t = Thread.new do
-                                s = server.accept
-                                received = s.gets
+                                received = accepted.gets
                                 reactor.stop
                             end
 
@@ -313,10 +330,6 @@ describe Arachni::Reactor::Connection::TLS do
 
                     context 'and are invalid' do
                         it "passes #{Arachni::Reactor::Connection::Error} to #on_error" do
-                            Thread.new do
-                                server.accept
-                            end
-
                             connection = nil
                             reactor.run do
                                 connection = reactor.connect( host, port, TLSHandler, client_invalid_ssl_options )

data/spec/arachni/reactor/connection_spec.rb

@@ -39,16 +39,32 @@ describe Arachni::Reactor::Connection do
         end
     end
 
+    before :each do
+        @accept_q = Queue.new
+        @accepted = nil
+    end
+
     let(:unix_socket) { unix_connect( @unix_socket ) }
     let(:unix_server_socket) { unix_server( port_to_socket( Servers.available_port ) ) }
 
-    let(:echo_client) { tcp_connect( @host, @port ) }
+    let(:echo_client) { tcp_socket }
     let(:echo_client_handler) { EchoClient.new }
 
     let(:peer_client_socket) { tcp_connect( host, port ) }
-    let(:peer_server_socket) { tcp_server( host, port ) }
+    let(:peer_server_socket) do
+        s = tcp_server( host, port )
+        Thread.new do
+            begin
+                @accept_q << s.accept
+            rescue => e
+                ap e
+            end
+        end
+        s
+    end
+    let(:accepted) { @accepted ||= @accept_q.pop }
 
-    let(:client_socket) { tcp_connect( host, port ) }
+    let(:client_socket) { tcp_socket }
     let(:server_socket) { tcp_server( host, port ) }
 
     let(:connection) { Handler.new }

data/spec/support/helpers/utilities.rb

@@ -17,6 +17,16 @@ def tcp_connect( host, port )
     TCPSocket.new( host, port )
 end
 
+def tcp_socket
+    socket = Socket.new(
+        Socket::Constants::AF_INET,
+        Socket::Constants::SOCK_STREAM,
+        Socket::Constants::IPPROTO_IP
+    )
+    socket.do_not_reverse_lookup = true
+    socket
+end
+
 def tcp_write( host, port, data )
     s = tcp_connect( host, port )
     s.write data
@@ -45,6 +55,10 @@ def tcp_server( host, port )
     TCPServer.new( host, port )
 end
 
+def tcp_ssl_socket( host, port, options = {}  )
+    convert_client_to_ssl( tcp_socket, options )
+end
+
 def tcp_ssl_connect( host, port, options = {}  )
     convert_client_to_ssl( tcp_connect( host, port ), options )
 end

data/spec/support/lib/servers.rb

@@ -26,7 +26,7 @@ class Servers
         return [host_for(name), port_for(name)] if server_info[:pid] && up?( name )
 
         server_info[:pid] = Process.spawn(
-            'ruby', RUNNER, server_info[:path], '-p', server_info[:port].to_s,
+            RbConfig.ruby, RUNNER, server_info[:path], '-p', server_info[:port].to_s,
             '-o', host_for( name )
         )
 
@@ -77,7 +77,7 @@ class Servers
         return if !server_info[:pid]
 
         begin
-            Process.kill( 'KILL', server_info[:pid] ) while sleep 0.1
+            Process.kill( Gem.win_platform? ? 'QUIT' : 'KILL', server_info[:pid] ) while sleep 0.1
         rescue Errno::ESRCH
             server_info.delete(:pid)
 

data/spec/support/servers/echo.rb

@@ -4,10 +4,10 @@ loop do
     Thread.new server.accept do |socket|
         begin
             loop do
-                next if !(line = socket.gets)
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
-        rescue EOFError, Errno::EPIPE
+        rescue EOFError, Errno::EPIPE, Errno::ECONNRESET
             socket.close
         end
     end

data/spec/support/servers/echo_tls.rb

@@ -12,8 +12,8 @@ loop do
     Thread.new do
         begin
             loop do
-                next if (line = socket.gets).to_s.empty?
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
         rescue EOFError, Errno::EPIPE
             socket.close

data/spec/support/servers/echo_unix.rb

@@ -4,8 +4,8 @@ loop do
     Thread.new server.accept do |socket|
         begin
             loop do
-                next if !(line = socket.gets)
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
         rescue EOFError, Errno::EPIPE
             socket.close

data/spec/support/servers/echo_unix_tls.rb

@@ -12,8 +12,8 @@ loop do
     Thread.new do
         begin
             loop do
-                next if (line = socket.gets).to_s.empty?
-                socket.write( line )
+                next if (data = socket.gets).to_s.empty?
+                socket.write( data )
             end
         rescue EOFError, Errno::EPIPE
             socket.close

data/spec/support/shared/connection.rb

@@ -16,117 +16,28 @@ shared_examples_for 'Arachni::Reactor::Connection' do
     let(:data) { 'b' * 5 * block_size }
     let(:configured) do
         connection.reactor = reactor
-        connection.configure socket, role, server_handler
-        connection
-    end
-
-    # This needs to be put in a file of its own.
-    describe '::PeerInfo' do
-        describe '#peer_address_info' do
-            context 'when using an IP socket' do
-                let(:connection) { echo_client_handler }
-                let(:role) { :client }
-                let(:socket) { client_socket }
-
-                it 'returns IP address information' do
-                    s = peer_server_socket
-                    configured
-
-                    Thread.new do
-                        s = s.accept
-                    end
-
-                    IO.select( nil, [configured.socket] )
-
-                    info = {}
-                    info[:protocol], info[:port], info[:hostname], info[:ip_address] = s.to_io.addr
-                    configured.peer_address_info.should == info
-
-                    info = {}
-                    info[:protocol], info[:port], info[:hostname], info[:ip_address] = s.to_io.addr(false)
-                    configured.peer_address_info(false).should == info
-
-                    info = {}
-                    info[:protocol], info[:port], info[:hostname], info[:ip_address] = s.to_io.addr(true)
-                    configured.peer_address_info(true).should == info
-                end
-            end
-
-            context 'when using UNIX-domain socket',
-                    if: Arachni::Reactor.supports_unix_sockets? do
-
-                let(:connection) { echo_client_handler }
-                let(:role) { :client }
-                let(:socket) { unix_socket }
-
-                it 'returns socket information' do
-                    configured
-
-                    IO.select( nil, [configured.socket] )
-
-                    info = {}
-                    info[:protocol], info[:path] = 'AF_UNIX', socket.path
-                    configured.peer_address_info.should == info
-                end
-            end
-        end
-
-        describe '#peer_hostname' do
-            let(:connection) { echo_client_handler }
-            let(:role) { :client }
-            let(:socket) { client_socket }
-
-            it 'returns the peer hostname' do
-                s = peer_server_socket
-                configured
-
-                Thread.new do
-                    s = s.accept
-                end
-
-                IO.select( nil, [configured.socket] )
-
-                configured.peer_hostname.should == s.to_io.addr(true)[2]
-            end
-        end
-
-        describe '#peer_ip_address' do
-            let(:connection) { echo_client_handler }
-            let(:role) { :client }
-            let(:socket) { client_socket }
-
-            it 'returns the peer IP address' do
-                s = peer_server_socket
-                configured
-
-                Thread.new do
-                    s = s.accept
+        connection.configure(
+            host:           host,
+            port:           port,
+            socket:         socket,
+            role:           role,
+            server_handler: server_handler
+        )
+
+        if role == :client
+            while !connection.connected?
+                begin
+                    IO.select( [connection.socket], [connection.socket], nil, 0.1 )
+                rescue => e
+                    ap e
+                    break
                 end
 
-                IO.select( nil, [configured.socket] )
-
-                configured.peer_ip_address.should == s.to_io.addr[3]
+                connection._connect
             end
         end
 
-        describe '#peer_port' do
-            let(:connection) { echo_client_handler }
-            let(:role) { :client }
-            let(:socket) { client_socket }
-
-            it 'returns the peer IP address' do
-                s = peer_server_socket
-                configured
-
-                Thread.new do
-                    s = s.accept
-                end
-
-                IO.select( nil, [configured.socket] )
-
-                configured.peer_port.should == s.to_io.addr[1]
-            end
-        end
+        connection
     end
 
     describe '#configure' do
@@ -157,12 +68,12 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             end
         end
 
-        it 'calls #on_connect' do
-            peer_server_socket
-            connection.should receive(:on_connect)
-            connection.reactor = reactor
-            connection.configure socket, role
-        end
+        # it 'calls #on_connect' do
+        #     peer_server_socket
+        #     connection.should receive(:on_connect)
+        #     connection.reactor = reactor
+        #     connection.configure socket: socket, role: role
+        # end
     end
 
     describe '#unix?' do
@@ -172,7 +83,7 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             let(:socket) { client_socket }
 
             it 'returns false' do
-                s = peer_server_socket
+                peer_server_socket
                 configured
                 configured.should_not be_unix
             end
@@ -186,7 +97,7 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             let(:socket) { unix_socket }
 
             it 'returns true' do
-                s = peer_server_socket
+                peer_server_socket
                 configured
                 configured.should be_unix
             end
@@ -200,7 +111,7 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             let(:socket) { client_socket }
 
             it 'returns false' do
-                s = peer_server_socket
+                peer_server_socket
                 configured
                 configured.should be_inet
             end
@@ -214,7 +125,7 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             let(:socket) { unix_socket }
 
             it 'returns false' do
-                s = peer_server_socket
+                peer_server_socket
                 configured
                 configured.should_not be_inet
             end
@@ -240,7 +151,6 @@ shared_examples_for 'Arachni::Reactor::Connection' do
                     if: Arachni::Reactor.supports_unix_sockets? do
 
                 let(:connection) { echo_client_handler }
-                let(:role) { :client }
                 let(:socket) { unix_server_socket }
 
                 it 'returns UNIXServer' do
@@ -278,7 +188,7 @@ shared_examples_for 'Arachni::Reactor::Connection' do
 
                 it 'returns TCPSocket' do
                     peer_server_socket
-                    configured.to_io.should be_instance_of TCPSocket
+                    configured.to_io.should be_instance_of Socket
                 end
             end
 
@@ -315,7 +225,6 @@ shared_examples_for 'Arachni::Reactor::Connection' do
                     if: Arachni::Reactor.supports_unix_sockets? do
 
                 let(:connection) { echo_client_handler }
-                let(:role) { :client }
                 let(:socket) { unix_server_socket }
 
                 it 'returns true' do
@@ -479,7 +388,7 @@ shared_examples_for 'Arachni::Reactor::Connection' do
         let(:socket) { client_socket }
 
         it 'appends the given data to the send-buffer' do
-            s = peer_server_socket
+            peer_server_socket
             reactor.run_in_thread
 
             configured
@@ -488,8 +397,8 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             received = ''
 
             t = Thread.new do
-                s = s.accept
-                received << s.read( data.size ) while received.size != data.size
+                sleep 0.1 while !accepted
+                received << accepted.read( data.size ) while received.size != data.size
                 all_read = true
             end
 
@@ -548,13 +457,13 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             let(:socket) { client_socket }
 
             it "reads a maximum of #{Arachni::Reactor::Connection::BLOCK_SIZE} bytes at a time" do
-                s = peer_server_socket
+                peer_server_socket
                 configured
 
                 Thread.new do
-                    s = s.accept
-                    s.write data
-                    s.flush
+                    sleep 0.1 while !accepted
+                    accepted.write data
+                    accepted.flush
                 end
 
                 while configured.received_data.to_s.size != data.size
@@ -567,15 +476,15 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             end
 
             it 'passes the data to #on_read' do
-                s = peer_server_socket
+                peer_server_socket
                 configured
 
                 data = "test\n"
 
                 Thread.new do
-                    s = s.accept
-                    s.write data
-                    s.flush
+                    sleep 0.1 while !accepted
+                    accepted.write data
+                    accepted.flush
                 end
 
                 configured._read while !configured.received_data
@@ -618,6 +527,8 @@ shared_examples_for 'Arachni::Reactor::Connection' do
             reactor.run_in_thread
         end
 
+        let(:port) { @port }
+        let(:host) { @host }
         let(:connection) { echo_client_handler }
         let(:role) { :client }
         let(:socket) { echo_client }
@@ -634,7 +545,7 @@ shared_examples_for 'Arachni::Reactor::Connection' do
                     next
                 end
 
-                written.should == block_size
+                written.should <= block_size
                 writes += 1
             end
 
@@ -647,17 +558,14 @@ shared_examples_for 'Arachni::Reactor::Connection' do
 
             writes = 0
             while configured.has_outgoing_data?
-
                 IO.select( nil, [configured.socket] )
-                if configured._write == 0
-                    IO.select( [configured.socket] )
-                    next
-                end
+
+                next if configured._write == 0
 
                 writes += 1
             end
 
-            configured.on_write_count.should == writes
+            configured.on_write_count.should >= writes
         end
 
         context 'when the buffer is entirely consumed' do
@@ -668,12 +576,10 @@ shared_examples_for 'Arachni::Reactor::Connection' do
                 while configured.has_outgoing_data?
                     IO.select( nil, [configured.socket] )
 
-                    if (written = configured._write) == 0
+                    if configured._write == 0
                         IO.select( [configured.socket] )
                         next
                     end
-
-                    written.should == block_size
                 end
 
                 configured.called_on_flush.should be_true
@@ -682,6 +588,9 @@ shared_examples_for 'Arachni::Reactor::Connection' do
     end
 
     describe '#has_outgoing_data?' do
+        let(:port) { @port }
+        let(:host) { @host }
+
         let(:role) { :client }
         let(:socket) { echo_client }
 
@@ -704,6 +613,9 @@ shared_examples_for 'Arachni::Reactor::Connection' do
     end
 
     describe '#closed?' do
+        let(:port) { @port }
+        let(:host) { @host }
+
         let(:role) { :client }
         let(:socket) { echo_client }
 
@@ -725,6 +637,9 @@ shared_examples_for 'Arachni::Reactor::Connection' do
     end
 
     describe '#close_without_callback' do
+        let(:port) { @port }
+        let(:host) { @host }
+
         let(:role) { :client }
         let(:socket) { echo_client }
 
@@ -753,6 +668,9 @@ shared_examples_for 'Arachni::Reactor::Connection' do
     end
 
     describe '#close' do
+        let(:port) { @port }
+        let(:host) { @host }
+
         let(:role) { :client }
         let(:socket) { echo_client }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arachni-reactor
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta5
+  version: 0.1.0
 platform: ruby
 authors:
 - Tasos Laskos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-04 00:00:00.000000000 Z
+date: 2015-03-21 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Arachni::Reactor is a simple, lightweight, pure-Ruby implementation of the Reactor
@@ -93,12 +93,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A pure-Ruby implementation of the Reactor pattern.