cuboid 0.0.5 → 0.1.3

data/lib/cuboid/rpc/server/scheduler.rb

@@ -6,7 +6,7 @@ require lib + 'processes/manager'
 require lib + 'processes/instances'
 
 require lib + 'rpc/client/instance'
-require lib + 'rpc/client/dispatcher'
+require lib + 'rpc/client/agent'
 
 require lib + 'rpc/server/base'
 require lib + 'rpc/server/output'
@@ -33,9 +33,9 @@ class Server
 # * {#attach Attached} to the queue monitor and transfer the management
 #   responsibility to the queue.
 #
-# If a {Dispatcher} has been provided, {Instance instances} will be
-# {Dispatcher#dispatch provided} by it.
-# If no {Dispatcher} has been given, {Instance instances} will be spawned on the
+# If a {Agent} has been provided, {Instance instances} will be
+# {Agent#spawn provided} by it.
+# If no {Agent} has been given, {Instance instances} will be spawned on the
 # Scheduler machine.
 #
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
@@ -379,7 +379,7 @@ class Scheduler
         end
     end
 
-    # Starts the dispatcher's server
+    # Starts the agent's server
     def run
         reactor.on_error do |_, e|
             print_error "Reactor: #{e}"
@@ -415,16 +415,16 @@ class Scheduler
         )
     end
 
-    def dispatcher
-        return if !Options.dispatcher.url
-        @dispatcher ||= RPC::Client::Dispatcher.new( Options.dispatcher.url )
+    def agent
+        return if !Options.agent.url
+        @agent ||= RPC::Client::Agent.new( Options.agent.url )
     end
 
     def spawn_instance( &block )
-        if dispatcher
+        if agent
             options = {
               owner:    self.class.to_s,
-              strategy: Cuboid::Options.dispatcher.strategy,
+              strategy: Cuboid::Options.agent.strategy,
               helpers: {
                     owner: {
                         url: @url
@@ -432,9 +432,9 @@ class Scheduler
                 }
             }
 
-            dispatcher.dispatch options do |info|
+            agent.spawn options do |info|
                 if info.rpc_exception?
-                    print_error "Failed to contact Dispatcher at: #{dispatcher.url}"
+                    print_error "Failed to contact Agent at: #{agent.url}"
                     print_error "[#{info.class}] #{info.to_s}"
                     block.call :error
                     next

data/lib/cuboid.rb

@@ -2,9 +2,6 @@ require 'rubygems'
 require 'bundler/setup'
 require 'tmpdir'
 
-require 'oj'
-require 'oj_mimic_json'
-
 require_relative 'cuboid/version'
 
 require 'concurrent'

data/lib/version

@@ -1 +1 @@
-0.0.5
+0.1.3

data/spec/cuboid/option_groups/dispatcher_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Cuboid::OptionGroups::Dispatcher do
+describe Cuboid::OptionGroups::Agent do
     include_examples 'option_group'
     subject { described_class.new }
 
-    %w(url instance_port_range neighbour ping_interval name).each do |method|
+    %w(url instance_port_range peer ping_interval name).each do |method|
         it { is_expected.to respond_to method }
         it { is_expected.to respond_to "#{method}=" }
     end

data/spec/cuboid/rest/server_spec.rb

@@ -15,7 +15,7 @@ describe Cuboid::Rest::Server do
     let(:id) { @id }
     let(:non_existent_id) { 'stuff' }
 
-    let(:dispatcher) { Cuboid::Processes::Dispatchers.spawn }
+    let(:agent) { Cuboid::Processes::Agents.spawn }
     let(:scheduler) { Cuboid::Processes::Schedulers.spawn }
 
     def create_instance
@@ -182,7 +182,7 @@ describe Cuboid::Rest::Server do
             context 'when a running instance completes' do
                 it 'is removed' do
                     scheduler.push( options )
-                    sleep 0.1 while scheduler.completed.empty?
+                    sleep 0.1 while !scheduler.completed.empty?
 
                     get url
                     expect(response_data).to be_empty
@@ -235,17 +235,17 @@ describe Cuboid::Rest::Server do
             end
         end
 
-        context 'when a Dispatcher has been set' do
+        context 'when a Agent has been set' do
 
             it 'uses it' do
-                put '/dispatcher/url', dispatcher.url
+                put '/agent/url', agent.url
 
-                get "/grid/#{dispatcher.url}"
+                get "/grid/#{agent.url}"
                 expect(response_data['running_instances']).to be_empty
 
                 create_instance
 
-                get "/grid/#{dispatcher.url}"
+                get "/grid/#{agent.url}"
                 expect(response_data['running_instances'].size).to eq 1
             end
         end
@@ -623,32 +623,32 @@ describe Cuboid::Rest::Server do
         end
     end
 
-    describe 'GET /dispatcher/url' do
-        let(:tpl_url) { '/dispatcher/url' }
+    describe 'GET /agent/url' do
+        let(:tpl_url) { '/agent/url' }
 
-        it 'returns the Dispatcher' do
-            put url, dispatcher.url
+        it 'returns the Agent' do
+            put url, agent.url
             expect(response_code).to eq 200
 
             get url
             expect(response_code).to eq 200
-            expect(response_data).to eq dispatcher.url
+            expect(response_data).to eq agent.url
         end
 
-        context 'when no Dispatcher has been set' do
+        context 'when no Agent has been set' do
             it 'returns 501' do
                 get url
                 expect(response_code).to eq 501
-                expect(response_data).to eq 'No Dispatcher has been set.'
+                expect(response_data).to eq 'No Agent has been set.'
             end
         end
     end
 
-    describe 'PUT /dispatcher/url' do
-        let(:tpl_url) { '/dispatcher/url' }
+    describe 'PUT /agent/url' do
+        let(:tpl_url) { '/agent/url' }
 
-        it 'sets the Dispatcher' do
-            put url, dispatcher.url
+        it 'sets the Agent' do
+            put url, agent.url
             expect(response_code).to eq 200
         end
 
@@ -663,101 +663,101 @@ describe Cuboid::Rest::Server do
         end
     end
 
-    describe 'DELETE /dispatcher/url' do
-        let(:tpl_url) { '/dispatcher/url' }
+    describe 'DELETE /agent/url' do
+        let(:tpl_url) { '/agent/url' }
 
-        it 'removes the the Dispatcher' do
-            put url, dispatcher.url
+        it 'removes the the Agent' do
+            put url, agent.url
             expect(response_code).to eq 200
 
             delete url
             expect(response_code).to eq 200
 
-            get url, dispatcher.url
+            get url, agent.url
             expect(response_code).to eq 501
         end
 
-        context 'when no Dispatcher has been set' do
+        context 'when no Agent has been set' do
             it 'returns 501' do
                 delete url
                 expect(response_code).to eq 501
-                expect(response_data).to eq 'No Dispatcher has been set.'
+                expect(response_data).to eq 'No Agent has been set.'
             end
         end
     end
 
     describe 'GET /grid' do
-        let(:dispatcher) { Cuboid::Processes::Dispatchers.grid_spawn }
+        let(:agent) { Cuboid::Processes::Agents.grid_spawn }
         let(:tpl_url) { '/grid' }
 
         it 'returns Grid info' do
-            put '/dispatcher/url', dispatcher.url
+            put '/agent/url', agent.url
             expect(response_code).to eq 200
 
             get url
             expect(response_code).to eq 200
-            expect(response_data.sort).to eq ([dispatcher.url] + dispatcher.node.neighbours).sort
+            expect(response_data.sort).to eq ([agent.url] + agent.node.peers).sort
         end
 
-        context 'when no Dispatcher has been set' do
+        context 'when no Agent has been set' do
             it 'returns 501' do
                 get url
                 expect(response_code).to eq 501
-                expect(response_data).to eq 'No Dispatcher has been set.'
+                expect(response_data).to eq 'No Agent has been set.'
             end
         end
     end
 
-    describe 'GET /grid/:dispatcher' do
-        let(:dispatcher) { Cuboid::Processes::Dispatchers.grid_spawn }
+    describe 'GET /grid/:agent' do
+        let(:agent) { Cuboid::Processes::Agents.grid_spawn }
         let(:tpl_url) { '/grid/%s' }
 
-        it 'returns Dispatcher info' do
-            put '/dispatcher/url', dispatcher.url
+        it 'returns Agent info' do
+            put '/agent/url', agent.url
             expect(response_code).to eq 200
 
-            @id = dispatcher.url
+            @id = agent.url
 
             get url
             expect(response_code).to eq 200
-            expect(response_data).to eq dispatcher.statistics
+            expect(response_data).to eq agent.statistics
         end
 
-        context 'when no Dispatcher has been set' do
+        context 'when no Agent has been set' do
             it 'returns 501' do
                 @id = 'localhost:2222'
 
                 get url
                 expect(response_code).to eq 501
-                expect(response_data).to eq 'No Dispatcher has been set.'
+                expect(response_data).to eq 'No Agent has been set.'
             end
         end
     end
 
-    describe 'DELETE /grid/:dispatcher' do
-        let(:dispatcher) { Cuboid::Processes::Dispatchers.grid_spawn }
+    describe 'DELETE /grid/:agent' do
+        let(:agent) { Cuboid::Processes::Agents.grid_spawn }
         let(:tpl_url) { '/grid/%s' }
 
-        it 'unplugs the Dispatcher from the Grid' do
-            put '/dispatcher/url', dispatcher.url
+        it 'unplugs the Agent from the Grid' do
+            put '/agent/url', agent.url
             expect(response_code).to eq 200
 
-            @id = dispatcher.url
+            @id = agent.url
 
-            expect(dispatcher.node.grid_member?).to be_truthy
+            expect(agent.node.grid_member?).to be_truthy
 
             delete url
             expect(response_code).to eq 200
-            expect(dispatcher.node.grid_member?).to be_falsey
+            expect(agent.node.grid_member?).to be_falsey
         end
 
-        context 'when no Dispatcher has been set' do
+        context 'when no Agent has been set' do
             it 'returns 501' do
                 @id = 'localhost:2222'
 
                 delete url
                 expect(response_code).to eq 501
-                expect(response_data).to eq 'No Dispatcher has been set.'
+                expect(response_data).to eq 'No Agent has been set.'
             end
         end
     end

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

@@ -1,8 +1,8 @@
 require 'spec_helper'
 require 'fileutils'
 
-describe Cuboid::RPC::Client::Dispatcher do
-    subject { dispatcher_spawn application: "#{fixtures_path}/mock_app.rb" }
+describe Cuboid::RPC::Client::Agent do
+    subject { agent_spawn application: "#{fixtures_path}/mock_app.rb" }
 
     describe '#node' do
         it 'provides access to the node data' do

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

@@ -0,0 +1,222 @@
+require 'spec_helper'
+require "#{Cuboid::Options.paths.lib}/rpc/server/agent"
+
+describe Cuboid::RPC::Server::Agent::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.agent.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 agent is a grid member' do
+            it 'should return true' do
+                options.agent.peer = subject.url
+
+                c = get_node
+                sleep 0.5
+
+                expect(c.grid_member?).to be_truthy
+            end
+        end
+
+        context 'when the agent 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 peer comes back to life' do
+        it 'gets re-added to the peers list' do
+            port = available_port
+            subject.add_peer( '127.0.0.1:' + port.to_s )
+
+            sleep 3
+            expect(subject.peers).to be_empty
+
+            c = get_node( port )
+
+            sleep 0.5
+            expect(subject.peers).to eq([c.url])
+            expect(c.peers).to eq([subject.url])
+        end
+    end
+
+    context 'when a peer becomes unreachable' do
+        it 'is removed' do
+            c = get_node
+
+            subject.add_peer( c.url )
+            sleep 0.5
+
+            expect(c.peers).to eq([subject.url])
+            expect(subject.peers).to eq([c.url])
+
+            subject.shutdown rescue break while sleep 0.1
+            sleep 0.5
+
+            expect(c.peers).to be_empty
+        end
+    end
+
+    context 'when initialised with a peer' do
+        it 'adds that peer and reach convergence' do
+            options.agent.peer = subject.url
+
+            c = get_node
+            sleep 0.5
+            expect(c.peers).to eq([subject.url])
+            expect(subject.peers).to eq([c.url])
+
+            d = get_node
+            sleep 0.5
+            expect(d.peers.sort).to eq([subject.url, c.url].sort)
+            expect(c.peers.sort).to eq([subject.url, d.url].sort)
+            expect(subject.peers.sort).to eq([c.url, d.url].sort)
+
+            options.agent.peer = d.url
+            e = get_node
+            sleep 0.5
+            expect(e.peers.sort).to eq([subject.url, c.url, d.url].sort)
+            expect(d.peers.sort).to eq([subject.url, c.url, e.url].sort)
+            expect(c.peers.sort).to eq([subject.url, d.url, e.url].sort)
+            expect(subject.peers.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_peer( c.url )
+            sleep 0.5
+            expect(c.peers).to eq([subject.url])
+
+            c.unplug
+
+            expect(c.peers).to be_empty
+            expect(c.grid_member?).to be_falsey
+        end
+    end
+
+    describe '#add_peer' do
+        before(:each) do
+            subject.add_peer( other.url )
+            sleep 0.5
+        end
+
+        let( :other ) { get_node }
+
+        it 'adds a peer' do
+            expect(subject.peers).to eq([other.url])
+            expect(other.peers).to eq([subject.url])
+        end
+
+        context 'when propagate is set to true' do
+            it 'announces the new peer to the existing peers' do
+                n = get_node
+                subject.add_peer( n.url, true )
+                sleep 0.5
+
+                expect(subject.peers.sort).to eq([other.url, n.url].sort)
+                expect(other.peers.sort).to eq([subject.url, n.url].sort)
+
+                c = get_node
+                n.add_peer( c.url, true )
+                sleep 0.5
+
+                expect(subject.peers.sort).to eq([other.url, n.url, c.url].sort)
+                expect(other.peers.sort).to eq([subject.url, n.url, c.url].sort)
+                expect(c.peers.sort).to eq([subject.url, n.url, other.url].sort)
+
+                d = get_node
+                d.add_peer( c.url, true )
+                sleep 0.5
+
+                expect(subject.peers.sort).to eq([d.url, other.url, n.url, c.url].sort)
+                expect(other.peers.sort).to eq([d.url, subject.url, n.url, c.url].sort)
+                expect(c.peers.sort).to eq([d.url, subject.url, n.url, other.url].sort)
+                expect(d.peers.sort).to eq([c.url, subject.url, n.url, other.url].sort)
+            end
+        end
+    end
+
+    describe '#peers' do
+        it 'returns an array of peers' do
+            expect(subject.peers.is_a?( Array )).to be_truthy
+        end
+    end
+
+    describe '#peers_with_info' do
+        it 'returns all peers accompanied by their node info' do
+            subject.add_peer( get_node.url )
+            sleep 0.5
+
+            expect(subject.peers).to be_any
+            expect(subject.peers_with_info.size).to eq (subject.peers.size)
+
+            keys = subject.info.keys.sort
+            subject.peers_with_info.each do |i|
+                expect(i.keys.sort).to eq(keys)
+            end
+        end
+    end
+
+    describe '#info' do
+        it 'returns node info' do
+            options.agent.name = 'blah'
+
+            c = get_node
+            subject.add_peer( c.url )
+            sleep 0.5
+
+            info = subject.info
+
+            expect(info['url']).to eq(subject.url)
+            expect(info['peers']).to eq(subject.peers)
+            expect(info['unreachable_peers']).to be_empty
+            expect(info['name']).to eq(options.agent.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 → agent}/service_spec.rb

@@ -1,36 +1,36 @@
 require 'spec_helper'
-require "#{Cuboid::Options.paths.lib}/rpc/server/dispatcher"
+require "#{Cuboid::Options.paths.lib}/rpc/server/agent"
 
-describe Cuboid::RPC::Server::Dispatcher::Service do
+describe Cuboid::RPC::Server::Agent::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 }
+    let(:agent) { agent_spawn application: "#{fixtures_path}/mock_app.rb" }
+    let(:subject) { agent.test_service }
 
-    describe '#dispatcher' do
-        it 'provides access to the parent Dispatcher' do
-            expect(subject.test_dispatcher).to be_truthy
+    describe '#agent' do
+        it 'provides access to the parent Agent' do
+            expect(subject.test_agent).to be_truthy
         end
     end
 
     describe '#opts' do
-        it 'provides access to the Dispatcher\'s options' do
+        it 'provides access to the Agent\'s options' do
             expect(subject.test_opts).to be_truthy
         end
     end
 
     describe '#node' do
-        it 'provides access to the Dispatcher\'s node' do
+        it 'provides access to the Agent\'s node' do
             expect(subject.test_node).to be_truthy
         end
     end
 
     describe '#instances' do
         before(:each) do
-            instance_count.times { dispatcher.dispatch }
+            instance_count.times { agent.spawn }
         end
 
         it 'provides access to the running instances' do
@@ -40,7 +40,7 @@ describe Cuboid::RPC::Server::Dispatcher::Service do
 
     describe '#map_instances' do
         before(:each) do
-            instance_count.times { dispatcher.dispatch }
+            instance_count.times { agent.spawn }
         end
 
         it 'asynchronously maps all running instances' do
@@ -52,7 +52,7 @@ describe Cuboid::RPC::Server::Dispatcher::Service do
 
     describe '#each_instance' do
         before(:each) do
-            instance_count.times { dispatcher.dispatch }
+            instance_count.times { agent.spawn }
         end
 
         it 'asynchronously iterates over all running instances' do
@@ -92,15 +92,15 @@ describe Cuboid::RPC::Server::Dispatcher::Service do
         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
+    describe '#connect_to_agent' do
+        it 'connects to the a agent by url' do
+            expect(subject.test_connect_to_agent( agent.url )).to be_truthy
         end
     end
 
     describe '#connect_to_instance' do
         it 'connects to an instance' do
-            dispatcher.dispatch
+            agent.spawn
             instance = subject.instances.first
 
             expect(subject.test_connect_to_instance( instance )).to be_falsey