cuboid 0.0.5 → 0.1.3

data/spec/cuboid/rpc/server/{dispatcher_spec.rb → agent_spec.rb}

@@ -1,16 +1,16 @@
 require 'spec_helper'
 require 'fileutils'
 
-require "#{Cuboid::Options.paths.lib}/rpc/server/dispatcher"
+require "#{Cuboid::Options.paths.lib}/rpc/server/agent"
 
-describe Cuboid::RPC::Server::Dispatcher do
+describe Cuboid::RPC::Server::Agent 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" ) }
+    let(:subject) { agent_spawn( application: "#{fixtures_path}/mock_app.rb" ) }
 
     describe '#alive?' do
         it 'returns true' do
@@ -19,32 +19,36 @@ describe Cuboid::RPC::Server::Dispatcher do
     end
 
     describe '#preferred' do
-        context 'when the dispatcher is a grid member' do
+        context 'when the agent is a grid member' do
             context 'and strategy is' do
                 context :horizontal 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 )
+                    it 'returns the URL of least burdened Agent' do
+                        agent_spawn( peer: subject.url ).spawn( strategy: :direct )
+                        agent_spawn( peer: subject.url ).spawn( strategy: :direct )
 
                         expect(subject.preferred( :horizontal )).to eq(subject.url)
                     end
                 end
 
                 context :vertical do
-                    it 'returns the URL of most burdened Dispatcher' do
-                        dispatcher_spawn( neighbour: subject.url ).dispatch( load_balance: false )
-                        d = dispatcher_spawn( neighbour: subject.url )
-                        d.dispatch( load_balance: false )
-                        d.dispatch( load_balance: false )
+                    it 'returns the URL of most burdened Agent' do
+                        agent_spawn( peer: subject.url ).spawn( strategy: :direct )
+                        d = agent_spawn( peer: subject.url )
+                        d.spawn( strategy: :direct )
+                        d.spawn( strategy: :direct )
 
                         expect(subject.preferred( :vertical )).to eq(d.url)
                     end
                 end
 
+                context :direct do
+                    it 'returns the URL of this Agent'
+                end
+
                 context 'default' 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 )
+                    it 'returns the URL of least burdened Agent' do
+                        agent_spawn( peer: subject.url ).spawn( strategy: :direct )
+                        agent_spawn( peer: subject.url ).spawn( strategy: :direct )
 
                         expect(subject.preferred).to eq(subject.url)
                     end
@@ -52,38 +56,38 @@ describe Cuboid::RPC::Server::Dispatcher do
 
                 context 'other' do
                     it 'returns :error_unknown_strategy' do
-                        dispatcher_spawn( neighbour: subject.url ).dispatch( load_balance: false )
-                        dispatcher_spawn( neighbour: subject.url ).dispatch( load_balance: false )
+                        agent_spawn( peer: subject.url ).spawn( strategy: :direct )
+                        agent_spawn( peer: subject.url ).spawn( strategy: :direct )
 
                         expect(subject.preferred( :blah )).to eq('error_unknown_strategy')
                     end
                 end
             end
 
-            context 'and all Dispatchers are at max utilization' do
+            context 'and all Agents are at max utilization' do
                 before :each do
-                    subject.dispatch( load_balance: false )
+                    subject.spawn( strategy: :direct )
                 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 )
+                    agent_spawn( peer: subject.url ).spawn( strategy: :direct )
+                    agent_spawn( peer: subject.url ).spawn( strategy: :direct )
 
                     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
+        context 'when the agent is not a grid member' do
+            it 'returns the URL of the Agent' 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 )
+                    subject.spawn( strategy: :direct )
                 end
 
                 let(:slots) { 1 }
@@ -101,20 +105,20 @@ describe Cuboid::RPC::Server::Dispatcher do
         end
     end
 
-    describe '#dispatch' do
+    describe '#spawn' do
         it 'does not leak Instances' do
             slots.times do
-                subject.dispatch
+                subject.spawn
             end
 
             expect(subject.instances.size).to eq(slots)
         end
 
-        it 'sets OptionGroups::Dispatcher#url' do
-            info = subject.dispatch
+        it 'sets OptionGroups::Agent#url' do
+            info = subject.spawn
             instance = instance_connect( info['url'], info['token'] )
 
-            expect(instance.dispatcher_url).to eq subject.url
+            expect(instance.agent_url).to eq subject.url
         end
 
         context "when #{Cuboid::OptionGroups::RPC}#server_external_address has been set" do
@@ -125,13 +129,13 @@ describe Cuboid::RPC::Server::Dispatcher do
             let(:address) { '127.0.0.2' }
 
             it 'advertises that address' do
-                expect(subject.dispatch['url']).to start_with "#{address}:"
+                expect(subject.spawn['url']).to start_with "#{address}:"
             end
         end
 
         context 'when not a Grid member' do
             it 'returns Instance info' do
-                info = subject.dispatch( owner: 'rspec' )
+                info = subject.spawn( owner: 'rspec' )
 
                 %w(token application pid url owner birthdate helpers).each do |k|
                     expect(info[k]).to be_truthy
@@ -143,19 +147,19 @@ describe Cuboid::RPC::Server::Dispatcher do
 
             it 'assigns an optional owner' do
                 owner = 'blah'
-                expect(subject.dispatch( owner: owner )['owner']).to eq(owner)
+                expect(subject.spawn( 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
+                        subject.spawn
                     end
                 end
 
                 it 'returns nil' do
-                    expect(subject.dispatch).to be nil
+                    expect(subject.spawn).to be nil
                 end
 
                 context 'and slots are freed' do
@@ -173,12 +177,12 @@ describe Cuboid::RPC::Server::Dispatcher do
 
                         instances = []
                         free.times do
-                            instances << subject.dispatch
+                            instances << subject.spawn
                         end
                         instances.compact!
 
                         expect(instances.size).to eq free
-                        expect(subject.dispatch).to be nil
+                        expect(subject.spawn).to be nil
                     end
                 end
             end
@@ -188,149 +192,153 @@ describe Cuboid::RPC::Server::Dispatcher do
             let(:slots) { 4 }
 
             context 'and strategy is' do
+                context :direct do
+                    it 'provides Instances from this Agent'
+                end
+
                 context :horizontal do
-                    it 'provides Instances from the least burdened Dispatcher' do
-                        d1 = dispatcher_spawn(
+                    it 'provides Instances from the least burdened Agent' do
+                        d1 = agent_spawn(
                           address: '127.0.0.1',
                           application: "#{fixtures_path}/mock_app.rb"
                         )
 
                         3.times do
-                            d1.dispatch( load_balance: false )
+                            d1.spawn( strategy: :direct )
                         end
 
-                        d2 = dispatcher_spawn(
+                        d2 = agent_spawn(
                           address:   '127.0.0.2',
-                          neighbour: d1.url,
+                          peer: d1.url,
                           application: "#{fixtures_path}/mock_app.rb"
                         )
 
                         2.times do
-                            d2.dispatch( load_balance: false )
+                            d2.spawn( strategy: :direct )
                         end
 
-                        d3 = dispatcher_spawn(
+                        d3 = agent_spawn(
                           address:   '127.0.0.3',
-                          neighbour: d1.url,
+                          peer: d1.url,
                           application: "#{fixtures_path}/mock_app.rb"
                         )
-                        d3.dispatch( load_balance: false )
+                        d3.spawn( strategy: :direct )
                         preferred = d3.url.split( ':' ).first
 
-                        expect(d3.dispatch(strategy: :horizontal )['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(strategy: :horizontal )['url'].split( ':' ).first).to eq(preferred)
-                        expect(%W{127.0.0.1 127.0.0.3}).to include d3.dispatch(strategy: :horizontal )['url'].split( ':' ).first
-                        expect(%W{127.0.0.2 127.0.0.3}).to include d3.dispatch(strategy: :horizontal )['url'].split( ':' ).first
-                        expect(%W{127.0.0.2 127.0.0.3}).to include d1.dispatch(strategy: :horizontal )['url'].split( ':' ).first
+                        expect(d3.spawn(strategy: :horizontal )['url'].split( ':' ).first).to eq(preferred)
+                        expect(%W{127.0.0.3 127.0.0.2}).to include d1.spawn['url'].split( ':' ).first
+                        expect(d2.spawn(strategy: :horizontal )['url'].split( ':' ).first).to eq(preferred)
+                        expect(%W{127.0.0.1 127.0.0.3}).to include d3.spawn(strategy: :horizontal )['url'].split( ':' ).first
+                        expect(%W{127.0.0.2 127.0.0.3}).to include d3.spawn(strategy: :horizontal )['url'].split( ':' ).first
+                        expect(%W{127.0.0.2 127.0.0.3}).to include d1.spawn(strategy: :horizontal )['url'].split( ':' ).first
                     end
                 end
 
                 context :vertical do
-                    it 'provides Instances from the most burdened Dispatcher' do
-                        d1 = dispatcher_spawn(
+                    it 'provides Instances from the most burdened Agent' do
+                        d1 = agent_spawn(
                           address: '127.0.0.1',
                           application: "#{fixtures_path}/mock_app.rb"
                         )
 
                         3.times do
-                            d1.dispatch( load_balance: false )
+                            d1.spawn( strategy: :direct )
                         end
 
-                        d2 = dispatcher_spawn(
+                        d2 = agent_spawn(
                           address:   '127.0.0.2',
-                          neighbour: d1.url,
+                          peer: d1.url,
                           application: "#{fixtures_path}/mock_app.rb"
                         )
 
                         2.times do
-                            d2.dispatch( load_balance: false )
+                            d2.spawn( strategy: :direct )
                         end
 
-                        d3 = dispatcher_spawn(
+                        d3 = agent_spawn(
                           address:   '127.0.0.3',
-                          neighbour: d1.url,
+                          peer: d1.url,
                           application: "#{fixtures_path}/mock_app.rb"
                         )
-                        d3.dispatch( load_balance: false )
+                        d3.spawn( strategy: :direct )
 
                         preferred = d1.url.split( ':' ).first
-                        expect(d3.dispatch( strategy: :vertical )['url'].split( ':' ).first).to eq(preferred)
+                        expect(d3.spawn( strategy: :vertical )['url'].split( ':' ).first).to eq(preferred)
                     end
                 end
 
                 context 'default' do
-                    it 'provides Instances from the least burdened Dispatcher' do
-                        d1 = dispatcher_spawn(
+                    it 'provides Instances from the least burdened Agent' do
+                        d1 = agent_spawn(
                           address: '127.0.0.1',
                           application: "#{fixtures_path}/mock_app.rb"
                         )
 
                         3.times do
-                            d1.dispatch( load_balance: false )
+                            d1.spawn( strategy: :direct )
                         end
 
-                        d2 = dispatcher_spawn(
+                        d2 = agent_spawn(
                           address:   '127.0.0.2',
-                          neighbour: d1.url,
+                          peer: d1.url,
                           application: "#{fixtures_path}/mock_app.rb"
                         )
 
                         2.times do
-                            d2.dispatch( load_balance: false )
+                            d2.spawn( strategy: :direct )
                         end
 
-                        d3 = dispatcher_spawn(
+                        d3 = agent_spawn(
                           address:   '127.0.0.3',
-                          neighbour: d1.url,
+                          peer: d1.url,
                           application: "#{fixtures_path}/mock_app.rb"
                         )
-                        d3.dispatch( load_balance: false )
+                        d3.spawn( strategy: :direct )
                         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
+                        expect(d3.spawn['url'].split( ':' ).first).to eq(preferred)
+                        expect(%W{127.0.0.3 127.0.0.2}).to include d1.spawn['url'].split( ':' ).first
+                        expect(d2.spawn['url'].split( ':' ).first).to eq(preferred)
+                        expect(%W{127.0.0.1 127.0.0.3}).to include d3.spawn['url'].split( ':' ).first
+                        expect(%W{127.0.0.2 127.0.0.3}).to include d3.spawn['url'].split( ':' ).first
+                        expect(%W{127.0.0.2 127.0.0.3}).to include d1.spawn['url'].split( ':' ).first
                     end
                 end
 
                 context 'other' do
                     it 'returns :error_unknown_strategy' do
-                        expect(dispatcher_spawn( neighbour: subject.url ).
-                          dispatch( strategy: 'blah' )).to eq('error_unknown_strategy')
+                        expect(agent_spawn( peer: subject.url ).
+                          spawn( strategy: 'blah' )).to eq('error_unknown_strategy')
                     end
                 end
             end
 
             context 'when the load-balance option is set to false' do
-                it 'returns an Instance from the requested Dispatcher' do
-                    d1 = dispatcher_spawn(
+                it 'returns an Instance from the requested Agent' do
+                    d1 = agent_spawn(
                         address: '127.0.0.1',
                         application: "#{fixtures_path}/mock_app.rb"
                     )
 
-                    d1.dispatch( load_balance: false )
+                    d1.spawn( strategy: :direct )
 
-                    d2 = dispatcher_spawn(
+                    d2 = agent_spawn(
                         address:   '127.0.0.2',
-                        neighbour: d1.url,
+                        peer: d1.url,
                         application: "#{fixtures_path}/mock_app.rb"
                     )
-                    d2.dispatch( load_balance: false )
+                    d2.spawn( strategy: :direct )
 
-                    d3 = dispatcher_spawn(
+                    d3 = agent_spawn(
                         address:   '127.0.0.3',
-                        neighbour: d1.url,
+                        peer: d1.url,
                         application: "#{fixtures_path}/mock_app.rb"
                     )
                     2.times do
-                        d3.dispatch( load_balance: false )
+                        d3.spawn( strategy: :direct )
                     end
 
-                    expect(d3.dispatch( load_balance: false )['url'].
+                    expect(d3.spawn( strategy: :direct )['url'].
                         split( ':' ).first).to eq('127.0.0.3')
                 end
             end
@@ -339,7 +347,7 @@ describe Cuboid::RPC::Server::Dispatcher do
 
     describe '#instance' do
         it 'returns proc info by PID' do
-            instance = subject.dispatch( owner: 'rspec' )
+            instance = subject.spawn( owner: 'rspec' )
             info = subject.instance( instance['pid'] )
             instance_info_keys.each do |k|
                 expect(info[k]).to be_truthy
@@ -349,7 +357,7 @@ describe Cuboid::RPC::Server::Dispatcher do
 
     describe '#instances' do
         it 'returns proc info by PID for all instances' do
-            slots.times { subject.dispatch( owner: 'rspec' ) }
+            slots.times { subject.spawn( owner: 'rspec' ) }
 
             subject.instances.each do |instance|
                 instance_info_keys.each do |k|
@@ -361,7 +369,7 @@ describe Cuboid::RPC::Server::Dispatcher do
 
     describe '#running_instances' do
         it 'returns proc info for running instances' do
-            slots.times { subject.dispatch }
+            slots.times { subject.spawn }
 
             expect(subject.running_instances.size).to eq(slots)
         end
@@ -369,7 +377,7 @@ describe Cuboid::RPC::Server::Dispatcher do
 
     describe '#finished_instances' do
         it 'returns proc info for finished instances' do
-            3.times { Cuboid::Processes::Manager.kill subject.dispatch['pid'] }
+            3.times { Cuboid::Processes::Manager.kill subject.spawn['pid'] }
 
             expect(subject.finished_instances.size).to eq(3)
         end
@@ -378,7 +386,7 @@ describe Cuboid::RPC::Server::Dispatcher do
     describe '#utilization' do
         it 'returns a float signifying the amount of workload' do
             3.times do
-                subject.dispatch
+                subject.spawn
             end
 
             expect(subject.utilization).to eq(3 / Float(slots))
@@ -387,7 +395,7 @@ describe Cuboid::RPC::Server::Dispatcher do
 
     describe '#statistics' do
         it 'returns general statistics' do
-            subject.dispatch
+            subject.spawn
             instances = subject.instances
             Cuboid::Processes::Manager.kill( instances.first['pid'] )
 
@@ -406,7 +414,7 @@ describe Cuboid::RPC::Server::Dispatcher do
 
         context 'when there are snapshots' do
             it 'lists them' do
-                info = subject.dispatch
+                info = subject.spawn
 
                 instance = Cuboid::RPC::Client::Instance.new(
                     info['url'], info['token']

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

@@ -52,20 +52,20 @@ describe Cuboid::RPC::Server::Scheduler do
         end
     end
 
-    context 'when a Dispatcher has been set' do
-        subject { Cuboid::Processes::Schedulers.spawn dispatcher: dispatcher.url }
-        let(:dispatcher) do
-            Cuboid::Processes::Dispatchers.spawn( application: "#{fixtures_path}/mock_app.rb" )
+    context 'when a Agent has been set' do
+        subject { Cuboid::Processes::Schedulers.spawn agent: agent.url }
+        let(:agent) do
+            Cuboid::Processes::Agents.spawn( application: "#{fixtures_path}/mock_app.rb" )
         end
 
         it 'gets Instances from it' do
-            expect(dispatcher.finished_instances).to be_empty
+            expect(agent.finished_instances).to be_empty
 
             subject.push( options )
             sleep 0.1 while subject.completed.empty?
             sleep 2
 
-            expect(dispatcher.finished_instances).to be_any
+            expect(agent.finished_instances).to be_any
         end
 
         it 'sets OptionGroups::Scheduler#url' do
@@ -80,7 +80,7 @@ describe Cuboid::RPC::Server::Scheduler do
             it 'does not consume the queue' do
                 subject
 
-                Cuboid::Processes::Dispatchers.killall
+                Cuboid::Processes::Agents.killall
                 sleep 3
 
                 expect(subject.size).to be 0
@@ -89,7 +89,7 @@ describe Cuboid::RPC::Server::Scheduler do
                 sleep 5
 
                 expect(subject.size).to be 1
-                expect(subject.errors.join("\n")).to include "Failed to contact Dispatcher at: #{dispatcher.url}"
+                expect(subject.errors.join("\n")).to include "Failed to contact Agent at: #{agent.url}"
             end
         end
     end

data/spec/support/fixtures/executables/node.rb

@@ -1,14 +1,14 @@
 require Options.paths.lib + 'ui/output'
-require Options.paths.lib + 'rpc/server/dispatcher'
+require Options.paths.lib + 'rpc/server/agent'
 require Options.paths.lib + 'processes/manager'
 
-class Node < Cuboid::RPC::Server::Dispatcher::Node
+class Node < Cuboid::RPC::Server::Agent::Node
 
     def initialize
         @options = Options.instance
 
         methods.each do |m|
-            next if method( m ).owner != Cuboid::RPC::Server::Dispatcher::Node
+            next if method( m ).owner != Cuboid::RPC::Server::Agent::Node
             self.class.send :private, m
             self.class.send :public, m
         end

data/spec/support/fixtures/mock_app/test_service.rb

@@ -1,20 +1,20 @@
-require 'cuboid/rpc/server/dispatcher'
+require 'cuboid/rpc/server/agent'
 
-class TestService < Cuboid::RPC::Server::Dispatcher::Service
+class TestService < Cuboid::RPC::Server::Agent::Service
 
     private :instances
     public  :instances
 
-    def test_dispatcher
-        dispatcher.class == Cuboid::RPC::Server::Dispatcher
+    def test_agent
+        agent.class == Cuboid::RPC::Server::Agent
     end
 
     def test_opts
-        dispatcher.instance_eval{ @options } == options
+        agent.instance_eval{ @options } == options
     end
 
     def test_node
-        node.class == Cuboid::RPC::Server::Dispatcher::Node
+        node.class == Cuboid::RPC::Server::Agent::Node
     end
 
     def test_map_instances( &block )
@@ -39,8 +39,8 @@ class TestService < Cuboid::RPC::Server::Dispatcher::Service
         iterator_for( instances ).class == Arachni::Reactor::Iterator
     end
 
-    def test_connect_to_dispatcher( url, &block )
-        connect_to_dispatcher( url ).alive? { |b| block.call b }
+    def test_connect_to_agent( url, &block )
+        connect_to_agent( url ).alive? { |b| block.call b }
     end
 
     def test_connect_to_instance( *args, &block )

data/spec/support/fixtures/mock_app.rb

@@ -21,7 +21,7 @@ class MockApp < Cuboid::Application
     # RPC, report and snapshot file.
     serialize_with Marshal
 
-    dispatcher_service_for :test_service, TestService
+    agent_service_for :test_service, TestService
 
     # Execution entry point.
     def run

data/spec/support/fixtures/services/echo.rb

@@ -1,15 +1,15 @@
-class Cuboid::RPC::Server::Dispatcher
+class Cuboid::RPC::Server::Agent
 class Service::Echo < Service
 
     private :instances
     public  :instances
 
-    def test_dispatcher
-        dispatcher.class == Cuboid::RPC::Server::Dispatcher
+    def test_agent
+        agent.class == Cuboid::RPC::Server::Agent
     end
 
     def test_opts
-        dispatcher.instance_eval{ @options } == options
+        agent.instance_eval{ @options } == options
     end
 
     def test_node
@@ -38,8 +38,8 @@ class Service::Echo < Service
         iterator_for( instances ).class == Arachni::Reactor::Iterator
     end
 
-    def test_connect_to_dispatcher( url, &block )
-        connect_to_dispatcher( url ).alive? { |b| block.call b }
+    def test_connect_to_agent( url, &block )
+        connect_to_agent( url ).alive? { |b| block.call b }
     end
 
     def test_connect_to_instance( *args, &block )

data/spec/support/helpers/resets.rb

@@ -40,7 +40,7 @@ end
 
 def processes_killall
     instance_killall
-    dispatcher_killall
+    agent_killall
     scheduler_killall
     process_killall
     process_kill_reactor

data/spec/support/lib/web_server_client.rb

@@ -2,9 +2,9 @@ require 'arachni/rpc'
 
 # @note Needs `ENV['WEB_SERVER_DISPATCHER']` in the format of `host:port`.
 #
-# {WebServerManager}-API-compatible client for the {WebServerDispatcher}.
+# {WebServerManager}-API-compatible client for the {WebServerAgent}.
 #
-# Delegates test webserver creation to the machine running {WebServerDispatcher},
+# Delegates test webserver creation to the machine running {WebServerAgent},
 # for hosts that lack support for fast servers (like Windows, which can't run
 # Thin, Puma etc.).
 #

data/spec/support/lib/web_server_dispatcher.rb

@@ -9,7 +9,7 @@ require 'arachni/rpc'
 # Exposes the {WebServerManager} over RPC.
 #
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
-class WebServerDispatcher
+class WebServerAgent
 
     def initialize( options = {} )
         host, port = ENV['WEB_SERVER_DISPATCHER'].split( ':' )

data/spec/support/logs/Agent - 1797289-46860.log

@@ -0,0 +1,6 @@
+[Sun Feb 20 02:46:52 2022] [status]  Starting the RPC Server...
+[Sun Feb 20 02:46:52 2022] [status]  Initializing grid node...
+[Sun Feb 20 02:46:52 2022] [status]  Node ready.
+[Sun Feb 20 02:46:52 2022] [info]  Updated peers:
+[Sun Feb 20 02:46:52 2022] [info]  <empty>
+[Sun Feb 20 02:46:52 2022] [status]  Ready