cuboid 0.0.0 → 0.0.1alpha

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

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

@@ -0,0 +1,317 @@
+require 'spec_helper'
+require 'fileutils'
+
+require "#{Cuboid::Options.paths.lib}/rpc/server/dispatcher"
+
+describe Cuboid::RPC::Server::Dispatcher do
+    before( :each ) do
+        Cuboid::Options.system.max_slots = slots
+    end
+
+    let(:instance_info_keys) { %w(token application pid url owner birthdate helpers now age) }
+    let(:slots) { 3 }
+    let(:subject) { dispatcher_spawn( application: "#{fixtures_path}/mock_app.rb" ) }
+
+    describe '#alive?' do
+        it 'returns true' do
+            expect(subject.alive?).to eq(true)
+        end
+    end
+
+    describe '#preferred' do
+        context 'when the dispatcher is a grid member' do
+            it 'returns the URL of least burdened Dispatcher' do
+                dispatcher_spawn( neighbour: subject.url ).dispatch( load_balance: false )
+                dispatcher_spawn( neighbour: subject.url ).dispatch( load_balance: false )
+
+                expect(subject.preferred).to eq(subject.url)
+            end
+
+            context 'and all Dispatchers are at max utilization' do
+                before :each do
+                    subject.dispatch( load_balance: false )
+                end
+
+                let(:slots) { 1 }
+
+                it 'returns nil' do
+                    dispatcher_spawn( neighbour: subject.url ).dispatch( load_balance: false )
+                    dispatcher_spawn( neighbour: subject.url ).dispatch( load_balance: false )
+
+                    expect(subject.preferred).to be_nil
+                end
+            end
+        end
+
+        context 'when the dispatcher is not a grid member' do
+            it 'returns the URL of the Dispatcher' do
+                expect(subject.preferred).to eq(subject.url)
+            end
+
+            context 'and it is at max utilization' do
+                before :each do
+                    subject.dispatch( load_balance: false )
+                end
+
+                let(:slots) { 1 }
+
+                it 'returns nil' do
+                    expect(subject.preferred).to be_nil
+                end
+            end
+        end
+    end
+
+    describe '#handlers' do
+        it 'returns an array of loaded handlers' do
+            expect(subject.services.include?( 'test_service' )).to be_truthy
+        end
+    end
+
+    describe '#dispatch' do
+        it 'does not leak Instances' do
+            slots.times do
+                subject.dispatch
+            end
+
+            expect(subject.instances.size).to eq(slots)
+        end
+
+        it 'sets OptionGroups::Dispatcher#url' do
+            info = subject.dispatch
+            instance = instance_connect( info['url'], info['token'] )
+
+            expect(instance.dispatcher_url).to eq subject.url
+        end
+
+        context "when #{Cuboid::OptionGroups::RPC}#server_external_address has been set" do
+            before :each do
+                Cuboid::Options.rpc.server_external_address = address
+            end
+
+            let(:address) { '127.0.0.2' }
+
+            it 'advertises that address' do
+                expect(subject.dispatch['url']).to start_with "#{address}:"
+            end
+        end
+
+        context 'when not a Grid member' do
+            it 'returns Instance info' do
+                info = subject.dispatch( owner: 'rspec' )
+
+                %w(token application pid url owner birthdate helpers).each do |k|
+                    expect(info[k]).to be_truthy
+                end
+
+                instance = instance_connect( info['url'], info['token'] )
+                expect(instance.alive?).to be_truthy
+            end
+
+            it 'assigns an optional owner' do
+                owner = 'blah'
+                expect(subject.dispatch( owner: owner )['owner']).to eq(owner)
+            end
+
+            context 'when the there are no available slots' do
+                let(:slots) { 5 }
+                before :each do
+                    slots.times do
+                        subject.dispatch
+                    end
+                end
+
+                it 'returns nil' do
+                    expect(subject.dispatch).to be nil
+                end
+
+                context 'and slots are freed' do
+                    let(:free) { slots - 1 }
+
+                    it 'returns Instance info' do
+                        subject.instances[0...free].each do |info|
+                            service = instance_connect( info['url'], info['token'] )
+                            service.shutdown
+
+                            while sleep 0.1
+                                service.alive? rescue break
+                            end
+                        end
+
+                        instances = []
+                        free.times do
+                            instances << subject.dispatch
+                        end
+                        instances.compact!
+
+                        expect(instances.size).to eq free
+                        expect(subject.dispatch).to be nil
+                    end
+                end
+            end
+        end
+
+        context 'when a Grid member' do
+            let(:slots) { 4 }
+
+            it 'returns Instance info from the least burdened Dispatcher' do
+                d1 = dispatcher_spawn(
+                    address: '127.0.0.1',
+                    application: "#{fixtures_path}/mock_app.rb"
+                )
+
+                3.times do
+                    d1.dispatch( load_balance: false )
+                end
+
+                d2 = dispatcher_spawn(
+                    address:   '127.0.0.2',
+                    neighbour: d1.url,
+                    application: "#{fixtures_path}/mock_app.rb"
+                )
+
+                2.times do
+                    d2.dispatch( load_balance: false )
+                end
+
+                d3 = dispatcher_spawn(
+                    address:   '127.0.0.3',
+                    neighbour: d1.url,
+                    application: "#{fixtures_path}/mock_app.rb"
+                )
+                d3.dispatch( load_balance: false )
+                preferred = d3.url.split( ':' ).first
+
+                expect(d3.dispatch['url'].split( ':' ).first).to eq(preferred)
+                expect(%W{127.0.0.3 127.0.0.2}).to include d1.dispatch['url'].split( ':' ).first
+                expect(d2.dispatch['url'].split( ':' ).first).to eq(preferred)
+                expect(%W{127.0.0.1 127.0.0.3}).to include d3.dispatch['url'].split( ':' ).first
+                expect(%W{127.0.0.2 127.0.0.3}).to include d3.dispatch['url'].split( ':' ).first
+                expect(%W{127.0.0.2 127.0.0.3}).to include d1.dispatch['url'].split( ':' ).first
+            end
+
+            context 'when the load-balance option is set to false' do
+                it 'returns an Instance from the requested Dispatcher' do
+                    d1 = dispatcher_spawn(
+                        address: '127.0.0.1',
+                        application: "#{fixtures_path}/mock_app.rb"
+                    )
+
+                    d1.dispatch( load_balance: false )
+
+                    d2 = dispatcher_spawn(
+                        address:   '127.0.0.2',
+                        neighbour: d1.url,
+                        application: "#{fixtures_path}/mock_app.rb"
+                    )
+                    d2.dispatch( load_balance: false )
+
+                    d3 = dispatcher_spawn(
+                        address:   '127.0.0.3',
+                        neighbour: d1.url,
+                        application: "#{fixtures_path}/mock_app.rb"
+                    )
+                    2.times do
+                        d3.dispatch( load_balance: false )
+                    end
+
+                    expect(d3.dispatch( load_balance: false )['url'].
+                        split( ':' ).first).to eq('127.0.0.3')
+                end
+            end
+        end
+    end
+
+    describe '#instance' do
+        it 'returns proc info by PID' do
+            instance = subject.dispatch( owner: 'rspec' )
+            info = subject.instance( instance['pid'] )
+            instance_info_keys.each do |k|
+                expect(info[k]).to be_truthy
+            end
+        end
+    end
+
+    describe '#instances' do
+        it 'returns proc info by PID for all instances' do
+            slots.times { subject.dispatch( owner: 'rspec' ) }
+
+            subject.instances.each do |instance|
+                instance_info_keys.each do |k|
+                    expect(instance[k]).to be_truthy
+                end
+            end
+        end
+    end
+
+    describe '#running_instances' do
+        it 'returns proc info for running instances' do
+            slots.times { subject.dispatch }
+
+            expect(subject.running_instances.size).to eq(slots)
+        end
+    end
+
+    describe '#finished_instances' do
+        it 'returns proc info for finished instances' do
+            3.times { Cuboid::Processes::Manager.kill subject.dispatch['pid'] }
+
+            expect(subject.finished_instances.size).to eq(3)
+        end
+    end
+
+    describe '#utilization' do
+        it 'returns a float signifying the amount of workload' do
+            3.times do
+                subject.dispatch
+            end
+
+            expect(subject.utilization).to eq(3 / Float(slots))
+        end
+    end
+
+    describe '#statistics' do
+        it 'returns general statistics' do
+            subject.dispatch
+            instances = subject.instances
+            Cuboid::Processes::Manager.kill( instances.first['pid'] )
+
+            stats = subject.statistics
+
+            %w(utilization running_instances finished_instances node
+                consumed_pids snapshots).each do |k|
+                expect(stats[k]).to be_truthy
+            end
+
+            finished = stats['finished_instances']
+            expect(finished.size).to eq(1)
+
+            expect(stats['node']).to eq(subject.node.info)
+        end
+
+        context 'when there are snapshots' do
+            it 'lists them' do
+                info = subject.dispatch
+
+                instance = Cuboid::RPC::Client::Instance.new(
+                    info['url'], info['token']
+                )
+
+                instance.run
+                instance.suspend!
+                sleep 1 while !instance.suspended?
+                snapshot_path = instance.snapshot_path
+                instance.shutdown
+
+                expect(subject.statistics['snapshots']).to include snapshot_path
+            end
+        end
+    end
+
+    describe '#log' do
+        it 'returns the contents of the log file' do
+            expect(subject.log).to be_truthy
+        end
+    end
+
+end

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

@@ -0,0 +1,307 @@
+require 'json'
+require 'spec_helper'
+require "#{fixtures_path}/mock_app"
+
+describe 'Cuboid::RPC::Server::Instance' do
+    let(:subject) { instance_spawn( application: "#{fixtures_path}/mock_app.rb" ) }
+
+    it 'supports UNIX sockets', if: Arachni::Reactor.supports_unix_sockets? do
+        socket = "#{Dir.tmpdir}/cuboid-instance-#{Cuboid::Utilities.generate_token}"
+        subject = instance_spawn(
+          socket:      socket,
+          application: "#{fixtures_path}/mock_app.rb"
+        )
+
+        expect(subject.url).to eq(socket)
+        expect(subject.alive?).to be_truthy
+    end
+
+    describe '#application' do
+        it 'returns the application name' do
+            expect(subject.application).to eq 'MockApp'
+        end
+    end
+
+    describe '#snapshot_path' do
+        it 'returns the path to the future/current snapshot' do
+            subject.run
+
+            Timeout.timeout 5 do
+                sleep 1 while !subject.running?
+            end
+
+            expect(subject.snapshot_path).to end_with '.csf'
+        end
+    end
+
+    describe '#suspend!' do
+        it 'suspends the Instance to disk' do
+            subject.run
+
+            Timeout.timeout 5 do
+                sleep 1 while !subject.running?
+            end
+
+            subject.suspend!
+
+            Timeout.timeout 5 do
+                sleep 1 while !subject.suspended?
+            end
+
+            expect(File.exists?( subject.snapshot_path )).to be_truthy
+        end
+    end
+
+    describe '#suspended?' do
+        context 'when the Instance has not been suspended' do
+            it 'returns false' do
+                expect(subject.suspended?).to be_falsey
+            end
+        end
+
+        context 'when the Instance has been suspended' do
+            it 'returns true' do
+                subject.run
+
+                Timeout.timeout 5 do
+                    sleep 1 while !subject.running?
+                end
+
+                subject.suspend!
+
+                Timeout.timeout 5 do
+                    sleep 1 while !subject.suspended?
+                end
+
+                expect(subject.suspended?).to be_truthy
+            end
+        end
+    end
+
+    describe '#busy?' do
+        context 'when the Instance is not running' do
+            it 'returns false' do
+                expect(subject.busy?).to be_falsey
+            end
+        end
+
+        context 'when the Instance is running' do
+            it 'returns true' do
+                subject.run
+                expect(subject.busy?).to be_truthy
+            end
+        end
+    end
+
+    describe '#restore!' do
+        it 'suspends the Instance to disk' do
+            subject.run
+
+            options = subject.generate_report.options
+
+            subject.suspend!
+
+            Timeout.timeout 5 do
+                sleep 1 while subject.status != :suspended
+            end
+
+            snapshot_path = subject.snapshot_path
+            subject.shutdown
+
+            subject = instance_spawn
+            subject.restore! snapshot_path
+
+            File.delete snapshot_path
+
+            sleep 1 while subject.status != :done
+
+            expect(subject.generate_report.options).to eq(options)
+        end
+    end
+
+    describe '#errors' do
+        before(:each) do
+            subject.error_test error
+        end
+        let(:error) { "My error #{rand(9999)}" }
+
+        context 'when no argument has been provided' do
+            it 'returns all logged errors' do
+                expect(subject.errors.last).to end_with error
+            end
+        end
+
+        context 'when a start line-range has been provided' do
+            it 'returns all logged errors after that line' do
+                initial_errors = subject.errors
+                errors = subject.errors( 10 )
+
+                expect(initial_errors[10..-1]).to eq(errors)
+            end
+        end
+    end
+
+    describe '#error_logfile' do
+        before(:each) do
+            subject.error_test error
+        end
+        let(:error) { "My error #{rand(9999)}" }
+
+        it 'returns the path to the error logfile' do
+            errors = IO.read( subject.error_logfile )
+
+            subject.errors.each do |error|
+                expect(errors).to include error
+            end
+        end
+    end
+
+    describe '#alive?' do
+        it 'returns true' do
+            expect(subject.alive?).to eq(true)
+        end
+    end
+
+    describe '#paused?' do
+        context 'when not paused' do
+            it 'returns false' do
+                expect(subject.paused?).to be_falsey
+            end
+        end
+        context 'when paused' do
+            it 'returns true' do
+                subject.run
+
+                subject.pause!
+                Timeout.timeout 5 do
+                    sleep 1 while !subject.paused?
+                end
+
+                expect(subject.paused?).to be_truthy
+            end
+        end
+    end
+
+    describe '#resume!' do
+        it 'resumes the Instance' do
+            subject.run
+
+            subject.pause!
+            Timeout.timeout 5 do
+                sleep 1 while !subject.paused?
+            end
+
+            expect(subject.paused?).to be_truthy
+            expect(subject.resume!).to be_truthy
+
+            Timeout.timeout 5 do
+                sleep 1 while subject.paused?
+            end
+
+            expect(subject.paused?).to be_falsey
+        end
+    end
+
+    describe '#abort_and_generate_report' do
+        it "cleans-up and returns the report as #{Cuboid::Report}" do
+            expect(subject.abort_and_generate_report).to be_kind_of Cuboid::Report
+        end
+    end
+
+    describe '#status' do
+        context 'after initialization' do
+            it 'returns :ready' do
+                expect(subject.status).to eq(:ready)
+            end
+        end
+
+        context 'after #run has been called' do
+            it 'returns :running' do
+                subject.run
+
+                sleep 2
+                expect(subject.status).to eq(:running)
+            end
+        end
+
+        context 'once the Instance has completed' do
+            it 'returns :done' do
+                subject.run
+
+                sleep 1 while subject.busy?
+                expect(subject.status).to eq(:done)
+            end
+        end
+    end
+
+    describe '#run' do
+        context 'on invalid options' do
+            it 'raises ArgumentError' do
+                expect do
+                    subject.run invalid: :stuff
+                end.to raise_error Arachni::RPC::Exceptions::RemoteException
+            end
+        end
+
+        it 'configures and starts a job' do
+            expect(subject.busy?).to  be false
+            expect(subject.status).to be :ready
+
+            subject.run
+
+            # if a run in already running it should just bail out early
+            expect(subject.run).to be_falsey
+
+            sleep 1 while subject.busy?
+
+            expect(subject.busy?).to  be false
+            expect(subject.status).to be :done
+        end
+    end
+
+    describe '#progress' do
+        before( :each ) do
+            subject.run
+            sleep 1 while subject.busy?
+        end
+
+        it 'returns progress information' do
+            p = subject.progress
+            expect(p[:busy]).to   be false
+            expect(p[:status]).to be :done
+            expect(p[:statistics]).to  be_any
+
+            expect(p[:seed]).not_to be_empty
+        end
+
+        describe ':without' do
+            describe ':statistics' do
+                it 'includes statistics' do
+                    expect(subject.progress(
+                        without: :statistics
+                    )).not_to include :statistics
+                end
+            end
+
+            context 'with an array of things to be excluded'  do
+                it 'excludes those things'
+            end
+        end
+
+        describe ':with' do
+            context 'with an array of things to be included'  do
+                it 'includes those things'
+            end
+        end
+    end
+
+    describe '#shutdown' do
+        it 'shuts-down the instance' do
+            expect(subject.shutdown).to be_truthy
+            sleep 4
+
+            expect { subject.alive? }.to raise_error Arachni::RPC::Exceptions::ConnectionError
+        end
+    end
+
+end