raktr 0.0.1

data/spec/raktr/connection/tls_spec.rb

@@ -0,0 +1,348 @@
+require 'spec_helper'
+
+class TLSHandler < Raktr::Connection
+    include TLS
+
+    attr_reader :received_data
+    attr_reader :error
+
+    def initialize( options = {} )
+        @options = options
+    end
+
+    def on_close( error )
+        @error = error
+
+        if @options[:on_error]
+            @options[:on_error].call error
+        end
+
+        @raktr.stop
+    end
+
+    def on_read( data )
+        (@received_data ||= '' ) << data
+
+        return if !@options[:on_read]
+        @options[:on_read].call data
+    end
+
+    def on_connect
+        start_tls @options
+    end
+
+end
+
+describe Raktr::Connection::TLS do
+    before :all do
+        @host, @port = Servers.start( :echo_tls )
+
+        if Raktr.supports_unix_sockets?
+            _, port = Servers.start( :echo_unix_tls )
+            @unix_socket = port_to_socket( port )
+        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_socket }
+    let(:echo_client_handler) { EchoClientTLS.new }
+
+    let(:peer_client_socket) { tcp_ssl_connect( host, port ) }
+    let(:peer_server_socket) do
+        s = tcp_ssl_server( host, port )
+        Thread.new do
+            begin
+                @accept_q << s.accept
+            rescue => e
+                p e
+            end
+        end
+        s
+    end
+    let(:accepted) { @accepted ||= @accept_q.pop }
+
+    let(:client_socket) { tcp_socket }
+    let(:server_socket) { tcp_server( host, port ) }
+
+    let(:connection) { TLSHandler.new }
+    let(:server_handler) { proc { TLSHandler.new } }
+    let(:raktr) { Raktr.new }
+
+    let(:client_valid_ssl_options) do
+        {
+            ca:          pems_path + '/cacert.pem',
+            private_key: pems_path + '/client/key.pem',
+            certificate: pems_path + '/client/cert.pem'
+        }
+    end
+    let(:client_invalid_ssl_options) do
+        {
+            ca:          pems_path + '/cacert.pem',
+            private_key: pems_path + '/client/foo-key.pem',
+            certificate: pems_path + '/client/foo-cert.pem'
+        }
+    end
+
+    let(:server_valid_ssl_options) do
+        {
+            ca:          pems_path + '/cacert.pem',
+            private_key: pems_path + '/server/key.pem',
+            certificate: pems_path + '/server/cert.pem'
+        }
+    end
+
+    it_should_behave_like 'Raktr::Connection'
+
+    context '#start_tls' do
+        let(:host) { '127.0.0.1' }
+        let(:port) { Servers.available_port }
+        let(:data) { "stuff\n" }
+
+        context 'when listening for a client' do
+            let(:client) do
+                tcp_ssl_connect( host, port, client_ssl_options )
+            end
+
+            context 'without requiring SSL authentication' do
+                let(:server_ssl_options) { {} }
+
+                context 'and no options have been provided' do
+                    let(:client_ssl_options) { {} }
+
+                    it 'connects successfully' do
+                        received_data = nil
+                        options = server_ssl_options.merge(
+                            on_read: proc do |received|
+                                received_data = received
+                            end
+                        )
+
+                        raktr.run_in_thread
+
+                        raktr.listen( host, port, TLSHandler, options )
+
+                        client.write data
+                        sleep 1
+
+                        raktr.stop
+                        raktr.wait rescue Raktr::Error::NotRunning
+
+                        expect(received_data).to eq data
+                    end
+                end
+
+                context 'and options have been provided' do
+                    let(:client_ssl_options) { client_valid_ssl_options }
+
+                    it "passes #{Raktr::Connection::Error::SSL} to #on_error" do
+                        error = nil
+
+                        options = server_ssl_options.merge(
+                            on_error: proc do |e|
+                                error ||= e
+                            end
+                        )
+
+                        raktr.run_in_thread
+
+                        raktr.listen( host, port, TLSHandler, options )
+
+                        client_error = nil
+                        begin
+                            client
+                        rescue => e
+                            client_error = e
+                        end
+
+                        [OpenSSL::SSL::SSLError, Errno::ECONNRESET].should include client_error.class
+
+                        raktr.wait rescue Raktr::Error::NotRunning
+
+                        error.should be_kind_of Raktr::Connection::Error::SSL
+                    end
+                end
+            end
+
+            context 'while requiring SSL authentication' do
+                let(:server_ssl_options) { server_valid_ssl_options }
+
+                context 'and options have been provided' do
+                    context 'and are valid' do
+                        let(:client_ssl_options) { client_valid_ssl_options }
+
+                        it 'connects successfully' do
+                            received_data = nil
+                            options = server_ssl_options.merge(
+                                on_read: proc do |received|
+                                    received_data = received
+                                end
+                            )
+
+                            raktr.run_in_thread
+
+                            raktr.listen( host, port, TLSHandler, options )
+
+                            client.write data
+
+                            sleep 0.1 while !received_data
+                            received_data.should == data
+                        end
+                    end
+
+                    context 'and are invalid' do
+                        let(:client_ssl_options) { client_invalid_ssl_options }
+
+                        it "passes #{Raktr::Connection::Error::SSL} to #on_error" do
+                            error = nil
+
+                            options = server_ssl_options.merge(
+                                on_error: proc do |e|
+                                    error ||= e
+                                end
+                            )
+
+                            raktr.run_in_thread
+                            raktr.listen( host, port, TLSHandler, options )
+
+                            client_error = nil
+                            begin
+                                client
+                            rescue => e
+                                client_error = e
+                            end
+
+                            [OpenSSL::SSL::SSLError, Errno::ECONNRESET].should include client_error.class
+
+                            raktr.wait rescue Raktr::Error::NotRunning
+
+                            error.should be_kind_of Raktr::Connection::Error::SSL
+                        end
+                    end
+                end
+
+                context 'and no options have been provided' do
+                    let(:client_ssl_options) { {} }
+
+                    it "passes #{Raktr::Connection::Error::SSL} to #on_error" do
+                        error = nil
+
+                        options = server_ssl_options.merge(
+                            on_error: proc do |e|
+                                error ||= e
+                            end
+                        )
+
+                        raktr.run_in_thread
+
+                        raktr.listen( host, port, TLSHandler, options )
+
+                        client_error = nil
+                        begin
+                            client
+                        rescue => e
+                            client_error = e
+                        end
+
+                        [OpenSSL::SSL::SSLError, Errno::ECONNRESET].should include client_error.class
+
+                        raktr.wait rescue Raktr::Error::NotRunning
+
+                        error.should be_kind_of Raktr::Connection::Error::SSL
+                    end
+                end
+            end
+        end
+
+        context 'when connecting to a server' do
+            let(:server) do
+                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
+                server
+            end
+
+            context 'that does not require SSL authentication' do
+                let(:server_ssl_options) { {} }
+
+                context 'and no options have been provided' do
+                    it 'connects successfully' do
+                        received = nil
+                        Thread.new do
+                            received = accepted.gets
+                            raktr.stop
+                        end
+
+                        raktr.run do
+                            connection = raktr.connect( host, port, TLSHandler )
+                            connection.write data
+                        end
+
+                        received.should == data
+                    end
+                end
+            end
+
+            context 'that requires SSL authentication' do
+                let(:server_ssl_options) { server_valid_ssl_options }
+
+                context 'and no options have been provided' do
+                    it "passes #{Raktr::Connection::Error} to #on_error" do
+                        connection = nil
+                        raktr.run do
+                            connection = raktr.connect( host, port, TLSHandler )
+                        end
+
+                        connection.error.should be_kind_of Raktr::Connection::Error
+                    end
+                end
+
+                context 'and options have been provided' do
+                    context 'and are valid' do
+                        it 'connects successfully' do
+                            received = nil
+                            t = Thread.new do
+                                received = accepted.gets
+                                raktr.stop
+                            end
+
+                            raktr.run do
+                                connection = raktr.connect( host, port, TLSHandler, client_valid_ssl_options )
+                                connection.write data
+                            end
+
+                            sleep 1
+                            expect(received).to eq data
+                        end
+                    end
+
+                    context 'and are invalid' do
+                        it "passes #{Raktr::Connection::Error} to #on_error" do
+                            connection = nil
+                            raktr.run do
+                                connection = raktr.connect( host, port, TLSHandler, client_invalid_ssl_options )
+                            end
+
+                            connection.error.should be_kind_of Raktr::Connection::Error
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/spec/raktr/connection_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+require 'spec_helper'
+
+class Handler < Raktr::Connection
+    attr_reader :received_data
+    attr_reader :error
+
+    def initialize( options = {} )
+        @options = options
+    end
+
+    def on_close( error )
+        @error = error
+
+        if @options[:on_error]
+            @options[:on_error].call error
+        end
+
+        @raktr.stop
+    end
+
+    def on_read( data )
+        (@received_data ||= '' ) << data
+
+        return if !@options[:on_read]
+        @options[:on_read].call data
+    end
+
+end
+
+describe Raktr::Connection do
+    before :all do
+        @host, @port = Servers.start( :echo )
+
+        if Raktr.supports_unix_sockets?
+            _, port = Servers.start( :echo_unix )
+            @unix_socket = port_to_socket( port )
+        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_socket }
+    let(:echo_client_handler) { EchoClient.new }
+
+    let(:peer_client_socket) { tcp_connect( 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_socket }
+    let(:server_socket) { tcp_server( host, port ) }
+
+    let(:connection) { Handler.new }
+    let(:server_handler) { proc { Handler.new } }
+
+    it_should_behave_like 'Raktr::Connection'
+end

data/spec/raktr/iterator_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe Raktr::Iterator do
+
+    def get_iterator
+        described_class.new raktr, list, concurrency
+    end
+
+    def get_raktr
+        Raktr.new
+    end
+
+    let(:raktr) { get_raktr }
+    let(:list) { %w(one two three four) }
+    let(:concurrency) { list.size }
+    subject { get_iterator }
+
+    describe '#initialize' do
+        context 'when the list does not respond to #to_a' do
+            let(:list) { 'stuff' }
+
+            it "raises #{ArgumentError}" do
+                expect { subject }.to raise_error ArgumentError
+            end
+        end
+
+        context 'when the concurrency is' do
+            context '0' do
+                let(:concurrency) { 0 }
+
+                it "raises #{ArgumentError}" do
+                    expect { subject }.to raise_error ArgumentError
+                end
+            end
+
+            context 'less than 0' do
+                let(:concurrency) { -1 }
+
+                it "raises #{ArgumentError}" do
+                    expect { subject }.to raise_error ArgumentError
+                end
+            end
+        end
+    end
+
+    describe '#raktr' do
+        it 'returns the associated Reactor' do
+            subject.raktr.should == raktr
+        end
+    end
+
+    describe '#concurrency' do
+        let(:concurrency){ 3 }
+        it 'returns the configured Reactor' do
+            subject.concurrency.should == concurrency
+        end
+    end
+
+    describe '#concurrency=' do
+        it 'sets the iterator concurrency' do
+            runner = proc do |concurrency|
+                start  = nil
+                finish = nil
+
+                iter = described_class.new( get_raktr, list, concurrency )
+                iter.concurrency = concurrency
+
+                iter.raktr.run do
+                    iter.each do |item, iterator|
+                        start ||= Time.now
+
+                        iter.raktr.delay 1 do
+                            if item == list.last
+                                finish = Time.now
+                                iter.raktr.stop
+                            end
+
+                            iterator.next
+                        end
+                    end
+                end
+
+                finish - start
+            end
+
+            high_concurrency = list.size
+            low_concurrency  = 1
+
+            high_concurrency_time, low_concurrency_time =
+                runner.call( high_concurrency ), runner.call( low_concurrency )
+
+            low_concurrency_time.should > high_concurrency_time
+
+            (low_concurrency_time - high_concurrency_time).to_i.should ==
+                high_concurrency - low_concurrency
+        end
+
+        context 'when it is larger than the list size' do
+            let(:concurrency){ 30 }
+
+            it 'does stuff' do
+                iterated = []
+
+                raktr.run do
+                    subject.each do |item, iterator|
+                        iterated << item
+
+                        raktr.delay 1 do
+                            raktr.stop if item == list.last
+                            iterator.next
+                        end
+                    end
+                end
+
+                list.should == iterated
+            end
+        end
+    end
+
+    describe '#each' do
+        it 'iterates over the list' do
+            iterated = []
+
+            raktr.run do
+                subject.each do |item, iterator|
+                    iterated << item
+
+                    raktr.stop if item == list.last
+                    raktr.delay 1 do
+                        iterator.next
+                    end
+                end
+            end
+
+            list.should == iterated
+        end
+
+        context 'when an \'after\' proc has been provided' do
+            it 'is called when the iteration is complete' do
+                iterated = []
+
+                raktr.run do
+                    subject.each(
+                        proc do |item, iterator|
+                            iterated << item
+                            raktr.delay 1 do
+                                iterator.next
+                            end
+                        end,
+                        proc do
+                            raktr.stop
+                        end
+                    )
+                end
+
+                list.should == iterated
+            end
+        end
+    end
+
+    describe '#map' do
+        it 'collects the results of each iteration' do
+            results = nil
+
+            raktr.run do
+                subject.map(
+                    proc do |string, iterator|
+                        raktr.delay 1 do
+                            iterator.return( string.size )
+                        end
+                    end,
+                    proc do |res|
+                        results = res
+                        raktr.stop
+                    end
+                )
+            end
+
+            results.should == list.map(&:size)
+        end
+    end
+
+    describe '#inject' do
+        it 'injects the results of the iteration into the given object' do
+            results = nil
+
+            raktr.run do
+                subject.inject( {},
+                    proc do |hash, string, iterator|
+                        hash.merge!( string => string.size )
+                        iterator.return( hash )
+                    end,
+                    proc do |res|
+                        results = res
+                        raktr.stop
+                    end
+                )
+            end
+
+            results.should == list.inject({}) { |h, string| h.merge( string => string.size ) }
+        end
+    end
+end

data/spec/raktr/queue_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Raktr::Queue do
+    let(:raktr) { Raktr.new }
+    subject { described_class.new raktr }
+
+    describe '#initialize' do
+        it 'sets the associated raktr' do
+            subject.raktr.should == raktr
+        end
+    end
+
+    describe '#pop' do
+        context 'when the queue is not empty' do
+            it 'passes the next item to the block' do
+                passed_item = nil
+
+                raktr.run do
+                    subject << :my_item
+                    subject.pop do |item|
+                        passed_item = item
+                        raktr.stop
+                    end
+                end
+
+                passed_item.should == :my_item
+            end
+        end
+
+        context 'when the queue is empty' do
+            it 'assigns a block to handle new items' do
+                passed_item = nil
+
+                raktr.run do
+                    subject.pop do |item|
+                        passed_item = item
+                        raktr.stop
+                    end
+
+                    subject << :my_item
+                end
+
+                passed_item.should == :my_item
+            end
+        end
+    end
+
+    describe '#empty?' do
+        context 'when the queue is empty' do
+            it 'returns true' do
+                subject.should be_empty
+            end
+        end
+
+        context 'when the queue is not empty' do
+            it 'returns false' do
+                raktr.run_block do
+                    subject << nil
+                    subject.should_not be_empty
+                end
+            end
+        end
+    end
+
+    describe '#size' do
+        it 'returns the queue size' do
+            raktr.run_block do
+                2.times { |i| subject << i }
+                subject.size.should == 2
+            end
+        end
+    end
+
+    describe '#num_waiting' do
+        context 'when no jobs are available to handle new items' do
+            it 'returns 0' do
+                subject.num_waiting.should == 0
+            end
+        end
+
+        context 'when there are jobs waiting to handle new items' do
+            it 'returns a count' do
+                raktr.run_block do
+                    3.times { subject.pop{} }
+                    subject.num_waiting.should == 3
+                end
+            end
+        end
+    end
+
+end