cuboid 0.0.0 → 0.0.3

data/spec/cuboid/rpc/client/base_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require "#{Cuboid::Options.paths.lib}/rpc/server/base"
+
+class Server
+    def initialize( opts, token = nil, &block )
+        @server = Cuboid::RPC::Server::Base.new( opts, token )
+        @server.add_handler( "foo", self )
+
+        if block_given?
+            start
+            block.call self
+            process_kill_reactor
+        end
+    end
+
+    def url
+        @server.url
+    end
+
+    def start
+        Arachni::Reactor.global.run_in_thread if !Arachni::Reactor.global.running?
+        @server.start
+        sleep( 0.1 ) while !@server.ready?
+    end
+
+    def bar
+        true
+    end
+end
+
+describe Cuboid::RPC::Client::Base do
+    let(:empty_options) do
+        {}
+    end
+
+    let(:options) do
+        {
+            host: Cuboid::Options.rpc.server_address,
+            port: available_port
+        }
+    end
+
+    let(:server_ssl_options) do
+        options.merge(
+            ssl_ca:   support_path + 'pems/cacert.pem',
+            ssl_pkey: support_path + 'pems/server/key.pem',
+            ssl_cert: support_path + 'pems/server/cert.pem'
+        )
+    end
+
+    let(:client_ssl_options) do
+        {
+            ssl_ca:   support_path + 'pems/cacert.pem',
+            ssl_pkey: support_path + 'pems/client/key.pem',
+            ssl_cert: support_path + 'pems/client/cert.pem'
+        }
+    end
+
+    describe '.new' do
+        context 'without SSL options' do
+            it 'connects to a server' do
+                Server.new( options ) do |server|
+                    client = described_class.new( server.url, nil, options )
+                    expect(client.call( "foo.bar" )).to eq(true)
+                end
+            end
+        end
+
+        context 'when trying to connect to an SSL-enabled server' do
+            context 'with valid SSL options' do
+                it 'connects successfully' do
+                    Server.new( server_ssl_options ) do |server|
+                        client = described_class.new( server.url, nil, client_ssl_options )
+                        expect(client.call( "foo.bar" )).to be_truthy
+                    end
+                end
+            end
+
+            context 'with invalid SSL options' do
+                it 'throws an exception' do
+                    client_ssl_options.delete :ssl_pkey
+                    client_ssl_options.delete :ssl_cert
+
+                    Server.new( server_ssl_options ) do |server|
+                        raised = false
+                        begin
+                            client = described_class.new( server.url, nil, client_ssl_options )
+                            client.call( "foo.bar" )
+                        rescue Arachni::RPC::Exceptions::ConnectionError
+                            raised = true
+                        end
+
+                        expect(raised).to be_truthy
+                    end
+                end
+            end
+
+            context 'with no SSL options' do
+                it 'throws an exception' do
+                    Server.new( server_ssl_options ) do |server|
+                        raised = false
+                        begin
+                            client = described_class.new( server.url, nil, empty_options )
+                            client.call( "foo.bar" )
+                        rescue Arachni::RPC::Exceptions::ConnectionError
+                            raised = true
+                        end
+
+                        expect(raised).to be_truthy
+                    end
+                end
+            end
+        end
+
+        context 'when a server requires a token' do
+            context 'with a valid token' do
+                it 'connects successfully' do
+                    opts = options.dup
+                    opts[:port] = available_port
+                    token = 'secret!'
+
+                    Server.new( opts, token ) do |server|
+                        client = described_class.new( server.url, token, opts )
+                        expect(client.call( "foo.bar" )).to be_truthy
+                    end
+                end
+            end
+
+            context 'with invalid token' do
+                it 'throws an exception' do
+                    opts = options.dup
+                    opts[:port] = available_port
+                    token = 'secret!'
+
+                    Server.new( opts, token ) do |server|
+                        raised = false
+                        begin
+                            client = described_class.new( server.url, nil, empty_options )
+                            client.call( "foo.bar" )
+                        rescue Arachni::RPC::Exceptions::InvalidToken
+                            raised = true
+                        end
+
+                        expect(raised).to be_truthy
+                    end
+                end
+            end
+        end
+    end
+
+end

data/spec/cuboid/rpc/client/dispatcher_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe Cuboid::RPC::Client::Dispatcher do
+    subject { dispatcher_spawn application: "#{fixtures_path}/mock_app.rb" }
+
+    describe '#node' do
+        it 'provides access to the node data' do
+            expect(subject.node.info.is_a?( Hash )).to be_truthy
+        end
+    end
+
+end

data/spec/cuboid/rpc/client/instance_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Cuboid::RPC::Client::Instance do
+
+    let(:subject) { instance_spawn application: "#{fixtures_path}/mock_app.rb" }
+
+    context 'when connecting to an instance' do
+        context 'which requires a token' do
+            context 'with a valid token' do
+                it 'connects successfully' do
+                    expect(subject.alive?).to be_truthy
+                end
+            end
+
+            context 'with an invalid token' do
+                it 'should fail to connect' do
+                    expect do
+                        described_class.new( subject.url, 'blah' ).alive?
+                    end.to raise_error Arachni::RPC::Exceptions::InvalidToken
+                end
+            end
+        end
+    end
+
+    describe '#options' do
+        let(:options) { subject.options }
+
+        describe '#set' do
+            let(:authorized_by) { 'tasos.laskos@gmail.com' }
+
+            it 'allows batch assigning using a hash' do
+                expect(options.set( authorized_by: authorized_by )).to be_truthy
+                expect(options.authorized_by).to eq(authorized_by)
+            end
+        end
+    end
+
+end

data/spec/cuboid/rpc/server/active_options_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+require Cuboid::Options.paths.lib + 'rpc/client/instance'
+require Cuboid::Options.paths.lib + 'rpc/server/instance'
+
+describe Cuboid::RPC::Server::ActiveOptions do
+    let(:instance) { instance_spawn application: "#{fixtures_path}/mock_app.rb" }
+    
+    describe '#set' do
+        it 'sets options by hash' do
+            opts = {
+                'datastore' => { 'key' => 'val' },
+            }
+
+            instance.options.set( opts )
+            h = instance.options.to_h
+
+            expect(h['datastore']['key']).to eq(opts['datastore']['key'])
+        end
+    end
+end

data/spec/cuboid/rpc/server/base_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require "#{Cuboid::Options.paths.lib}/rpc/server/base"
+
+describe Cuboid::RPC::Server::Base do
+    before( :each ) do
+        Arachni::Reactor.global.run_in_thread
+    end
+
+    let(:subject) { Cuboid::RPC::Server::Base.new(
+        host: 'localhost', port: port
+    ) }
+    let(:port) { available_port }
+
+    it 'supports UNIX sockets', if: Arachni::Reactor.supports_unix_sockets? do
+        server = Cuboid::RPC::Server::Base.new(
+            socket: "#{Dir.tmpdir}/cuboid-base-#{Cuboid::Utilities.generate_token}"
+        )
+
+        server.start
+
+        raised = false
+        begin
+            Timeout.timeout( 20 ){
+                sleep 0.1 while !server.ready?
+            }
+        rescue Exception => e
+            raised = true
+        end
+
+        expect(server.ready?).to be_truthy
+        expect(raised).to be_falsey
+    end
+
+    describe '#ready?' do
+        context 'when the server is not ready' do
+            it 'returns false' do
+                expect(subject.ready?).to be_falsey
+            end
+        end
+
+        context 'when the server is ready' do
+            it 'returns true' do
+                subject.start
+
+                raised = false
+                begin
+                    Timeout.timeout( 20 ){
+                        sleep 0.1 while !subject.ready?
+                    }
+                rescue Exception => e
+                    raised = true
+                end
+
+                expect(subject.ready?).to be_truthy
+                expect(raised).to be_falsey
+            end
+        end
+    end
+
+end

data/spec/cuboid/rpc/server/dispatcher/node_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+require "#{Cuboid::Options.paths.lib}/rpc/server/dispatcher"
+
+describe Cuboid::RPC::Server::Dispatcher::Node do
+
+    def get_node( port = available_port )
+        Cuboid::Options.rpc.server_port = port
+
+        Cuboid::Processes::Manager.spawn( :node )
+
+        c = Cuboid::RPC::Client::Base.new(
+            "#{Cuboid::Options.rpc.server_address}:#{port}"
+        )
+        c = Arachni::RPC::Proxy.new( c, 'node' )
+
+        begin
+            c.alive?
+        rescue Arachni::RPC::Exceptions::ConnectionError
+            sleep 0.1
+            retry
+        end
+
+        c
+    end
+
+    before( :each ) do
+        options.paths.executables        = "#{fixtures_path}executables/"
+        options.dispatcher.ping_interval = 0.5
+    end
+    after( :each )  do
+        Cuboid::Processes::Manager.killall
+    end
+
+    let(:subject) { get_node }
+    let(:options) { Cuboid::Options }
+
+    describe '#grid_member?' do
+        context 'when the dispatcher is a grid member' do
+            it 'should return true' do
+                options.dispatcher.neighbour = subject.url
+
+                c = get_node
+                sleep 0.5
+
+                expect(c.grid_member?).to be_truthy
+            end
+        end
+
+        context 'when the dispatcher is not a grid member' do
+            it 'should return false' do
+                expect(subject.grid_member?).to be_falsey
+            end
+        end
+    end
+
+    context 'when a previously unreachable neighbour comes back to life' do
+        it 'gets re-added to the neighbours list' do
+            port = available_port
+            subject.add_neighbour( '127.0.0.1:' + port.to_s )
+
+            sleep 3
+            expect(subject.neighbours).to be_empty
+
+            c = get_node( port )
+
+            sleep 0.5
+            expect(subject.neighbours).to eq([c.url])
+            expect(c.neighbours).to eq([subject.url])
+        end
+    end
+
+    context 'when a neighbour becomes unreachable' do
+        it 'is removed' do
+            c = get_node
+
+            subject.add_neighbour( c.url )
+            sleep 0.5
+
+            expect(c.neighbours).to eq([subject.url])
+            expect(subject.neighbours).to eq([c.url])
+
+            subject.shutdown rescue break while sleep 0.1
+            sleep 0.5
+
+            expect(c.neighbours).to be_empty
+        end
+    end
+
+    context 'when initialised with a neighbour' do
+        it 'adds that neighbour and reach convergence' do
+            options.dispatcher.neighbour = subject.url
+
+            c = get_node
+            sleep 0.5
+            expect(c.neighbours).to eq([subject.url])
+            expect(subject.neighbours).to eq([c.url])
+
+            d = get_node
+            sleep 0.5
+            expect(d.neighbours.sort).to eq([subject.url, c.url].sort)
+            expect(c.neighbours.sort).to eq([subject.url, d.url].sort)
+            expect(subject.neighbours.sort).to eq([c.url, d.url].sort)
+
+            options.dispatcher.neighbour = d.url
+            e = get_node
+            sleep 0.5
+            expect(e.neighbours.sort).to eq([subject.url, c.url, d.url].sort)
+            expect(d.neighbours.sort).to eq([subject.url, c.url, e.url].sort)
+            expect(c.neighbours.sort).to eq([subject.url, d.url, e.url].sort)
+            expect(subject.neighbours.sort).to eq([c.url, d.url, e.url].sort)
+        end
+    end
+
+    describe '#unplug' do
+        it 'removes itself from the Grid' do
+            c = get_node
+
+            subject.add_neighbour( c.url )
+            sleep 0.5
+            expect(c.neighbours).to eq([subject.url])
+
+            c.unplug
+
+            expect(c.neighbours).to be_empty
+            expect(c.grid_member?).to be_falsey
+        end
+    end
+
+    describe '#add_neighbour' do
+        before(:each) do
+            subject.add_neighbour( other.url )
+            sleep 0.5
+        end
+
+        let( :other ) { get_node }
+
+        it 'adds a neighbour' do
+            expect(subject.neighbours).to eq([other.url])
+            expect(other.neighbours).to eq([subject.url])
+        end
+
+        context 'when propagate is set to true' do
+            it 'announces the new neighbour to the existing neighbours' do
+                n = get_node
+                subject.add_neighbour( n.url, true )
+                sleep 0.5
+
+                expect(subject.neighbours.sort).to eq([other.url, n.url].sort)
+                expect(other.neighbours.sort).to eq([subject.url, n.url].sort)
+
+                c = get_node
+                n.add_neighbour( c.url, true )
+                sleep 0.5
+
+                expect(subject.neighbours.sort).to eq([other.url, n.url, c.url].sort)
+                expect(other.neighbours.sort).to eq([subject.url, n.url, c.url].sort)
+                expect(c.neighbours.sort).to eq([subject.url, n.url, other.url].sort)
+
+                d = get_node
+                d.add_neighbour( c.url, true )
+                sleep 0.5
+
+                expect(subject.neighbours.sort).to eq([d.url, other.url, n.url, c.url].sort)
+                expect(other.neighbours.sort).to eq([d.url, subject.url, n.url, c.url].sort)
+                expect(c.neighbours.sort).to eq([d.url, subject.url, n.url, other.url].sort)
+                expect(d.neighbours.sort).to eq([c.url, subject.url, n.url, other.url].sort)
+            end
+        end
+    end
+
+    describe '#neighbours' do
+        it 'returns an array of neighbours' do
+            expect(subject.neighbours.is_a?( Array )).to be_truthy
+        end
+    end
+
+    describe '#neighbours_with_info' do
+        it 'returns all neighbours accompanied by their node info' do
+            subject.add_neighbour( get_node.url )
+            sleep 0.5
+
+            expect(subject.neighbours).to be_any
+            expect(subject.neighbours_with_info.size).to eq (subject.neighbours.size)
+
+            keys = subject.info.keys.sort
+            subject.neighbours_with_info.each do |i|
+                expect(i.keys.sort).to eq(keys)
+            end
+        end
+    end
+
+    describe '#info' do
+        it 'returns node info' do
+            options.dispatcher.name = 'blah'
+
+            c = get_node
+            subject.add_neighbour( c.url )
+            sleep 0.5
+
+            info = subject.info
+
+            expect(info['url']).to eq(subject.url)
+            expect(info['neighbours']).to eq(subject.neighbours)
+            expect(info['unreachable_neighbours']).to be_empty
+            expect(info['name']).to eq(options.dispatcher.name)
+        end
+
+        context 'when OptionGroups::RPC#server_external_address has been set' do
+            it 'advertises that address' do
+                options.rpc.server_external_address = '9.9.9.9'
+
+                expect(subject.info['url']).to start_with options.rpc.server_external_address
+            end
+        end
+    end
+
+    describe '#alive?' do
+        it 'returns true' do
+            expect(subject.alive?).to be_truthy
+        end
+    end
+end

data/spec/cuboid/rpc/server/dispatcher/service_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require "#{Cuboid::Options.paths.lib}/rpc/server/dispatcher"
+
+describe Cuboid::RPC::Server::Dispatcher::Service do
+    before( :each ) do
+        Cuboid::Options.paths.services   = "#{fixtures_path}services/"
+        Cuboid::Options.system.max_slots = 10
+    end
+    let(:instance_count) { 3 }
+    let(:dispatcher) { dispatcher_spawn application: "#{fixtures_path}/mock_app.rb" }
+    let(:subject) { dispatcher.test_service }
+
+    describe '#dispatcher' do
+        it 'provides access to the parent Dispatcher' do
+            expect(subject.test_dispatcher).to be_truthy
+        end
+    end
+
+    describe '#opts' do
+        it 'provides access to the Dispatcher\'s options' do
+            expect(subject.test_opts).to be_truthy
+        end
+    end
+
+    describe '#node' do
+        it 'provides access to the Dispatcher\'s node' do
+            expect(subject.test_node).to be_truthy
+        end
+    end
+
+    describe '#instances' do
+        before(:each) do
+            instance_count.times { dispatcher.dispatch }
+        end
+
+        it 'provides access to the running instances' do
+            expect(subject.instances.map{ |i| i['pid'] }).to eq(subject.instances.map{ |j| j['pid'] })
+        end
+    end
+
+    describe '#map_instances' do
+        before(:each) do
+            instance_count.times { dispatcher.dispatch }
+        end
+
+        it 'asynchronously maps all running instances' do
+            expect(subject.test_map_instances).to eq(
+                Hash[subject.instances.map { |j| [j['url'], j['token']] }]
+            )
+        end
+    end
+
+    describe '#each_instance' do
+        before(:each) do
+            instance_count.times { dispatcher.dispatch }
+        end
+
+        it 'asynchronously iterates over all running instances' do
+            subject.test_each_instance
+            auths = subject.instances.map do |j|
+                Cuboid::RPC::Client::Instance.new(
+                    j['url'], j['token']
+                ).options.authorized_by
+            end
+
+            expect(auths.size).to eq(instance_count)
+            auths.sort!
+
+            1.upto( instance_count ).each do |i|
+                expect(auths[i-1]).to eq "test_#{i}@test.com"
+            end
+        end
+    end
+
+    describe '#defer' do
+        it 'defers execution of the given block' do
+            args = [1, 'stuff']
+            expect(subject.test_defer( *args )).to eq(args)
+        end
+    end
+
+    describe '#run_asap' do
+        it 'runs the given block as soon as possible' do
+            args = [1, 'stuff']
+            expect(subject.test_run_asap( *args )).to eq(args)
+        end
+    end
+
+    describe '#iterator_for' do
+        it 'provides an asynchronous iterator' do
+            expect(subject.test_iterator_for).to be_truthy
+        end
+    end
+
+    describe '#connect_to_dispatcher' do
+        it 'connects to the a dispatcher by url' do
+            expect(subject.test_connect_to_dispatcher( dispatcher.url )).to be_truthy
+        end
+    end
+
+    describe '#connect_to_instance' do
+        it 'connects to an instance' do
+            dispatcher.dispatch
+            instance = subject.instances.first
+
+            expect(subject.test_connect_to_instance( instance )).to be_falsey
+            expect(subject.test_connect_to_instance( instance['url'], instance['token'] )).to be_falsey
+            expect(subject.test_connect_to_instance( url: instance['url'], token: instance['token'] )).to be_falsey
+        end
+    end
+
+end