cuboid 0.0.3alpha → 0.1.0

data/lib/cuboid/rest/server/routes/dispatcher.rb

@@ -3,32 +3,32 @@ module Rest
 class Server
 module Routes
 
-module Dispatcher
+module Agent
 
     def self.registered( app )
 
-        app.get '/dispatcher/url' do
-            ensure_dispatcher!
+        app.get '/agent/url' do
+            ensure_agent!
 
-            json Options.dispatcher.url
+            json Options.agent.url
         end
 
-        app.put '/dispatcher/url' do
+        app.put '/agent/url' do
             url = ::JSON.load( request.body.read ) || {}
 
             handle_error do
-                connect_to_dispatcher( url ).alive?
+                connect_to_agent( url ).alive?
 
-                @dispatcher = nil
-                Options.dispatcher.url = url
+                @agent = nil
+                Options.agent.url = url
                 json nil
             end
         end
 
-        app.delete '/dispatcher/url' do
-            ensure_dispatcher!
+        app.delete '/agent/url' do
+            ensure_agent!
 
-            json @dispatcher = Options.dispatcher.url = nil
+            json @agent = Options.agent.url = nil
         end
 
     end

data/lib/cuboid/rest/server/routes/grid.rb

@@ -8,24 +8,24 @@ module Grid
     def self.registered( app )
 
         app.get '/grid' do
-            ensure_dispatcher!
+            ensure_agent!
 
             handle_error do
-                json [Options.dispatcher.url] + dispatcher.statistics['node']['neighbours']
+                json [Options.agent.url] + agent.statistics['node']['peers']
             end
         end
 
-        app.get '/grid/:dispatcher' do |url|
-            ensure_dispatcher!
+        app.get '/grid/:agent' do |url|
+            ensure_agent!
 
-            handle_error { json connect_to_dispatcher( url ).statistics }
+            handle_error { json connect_to_agent( url ).statistics }
         end
 
-        app.delete '/grid/:dispatcher' do |url|
-            ensure_dispatcher!
+        app.delete '/grid/:agent' do |url|
+            ensure_agent!
 
             handle_error do
-                unplug_dispatcher( url )
+                unplug_agent( url )
             end
 
             json nil

data/lib/cuboid/rest/server/routes/instances.rb

@@ -16,7 +16,7 @@ module Instances
 
         # Create
         app.post '/instances' do
-            max_utilization! if !dispatcher && System.max_utilization?
+            max_utilization! if !agent && System.max_utilization?
 
             options = ::JSON.load( request.body.read ) || {}
 

data/lib/cuboid/rest/server.rb

@@ -23,7 +23,7 @@ class Server < Sinatra::Base
     end
 
     register Routes::Instances
-    register Routes::Dispatcher
+    register Routes::Agent
     register Routes::Grid
     register Routes::Scheduler
 
@@ -81,9 +81,9 @@ class Server < Sinatra::Base
             halt 404, json( "Scan not found for id: #{h id}." )
         end
 
-        def ensure_dispatcher!
-            return if dispatcher
-            halt 501, json( 'No Dispatcher has been set.' )
+        def ensure_agent!
+            return if agent
+            halt 501, json( 'No Agent has been set.' )
         end
 
         def ensure_scheduler!
@@ -114,7 +114,7 @@ class Server < Sinatra::Base
 
         def reset
             @@instances.clear
-            @@dispatchers.clear
+            @@agents.clear
         end
 
         def run!( options )

data/lib/cuboid/rpc/client/{dispatcher.rb → agent.rb}

@@ -5,10 +5,10 @@ require Options.paths.lib + 'rpc/client/base'
 module RPC
 class Client
 
-# RPC Dispatcher client
+# RPC Agent client
 #
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
-class Dispatcher
+class Agent
     # Not always available, set by the parent.
     attr_accessor :pid
 
@@ -18,7 +18,7 @@ class Dispatcher
         @client = Base.new( url, nil, options )
         @node   = Arachni::RPC::Proxy.new( @client, 'node' )
 
-        Cuboid::Application.application.dispatcher_services.keys.each do |name|
+        Cuboid::Application.application.agent_services.keys.each do |name|
             self.class.send( :attr_reader, name.to_sym )
 
             instance_variable_set(
@@ -48,7 +48,7 @@ class Dispatcher
 
     # Used to provide the illusion of locality for remote methods
     def method_missing( sym, *args, &block )
-        @client.call( "dispatcher.#{sym.to_s}", *args, &block )
+        @client.call( "agent.#{sym.to_s}", *args, &block )
     end
 
 end

data/lib/cuboid/rpc/client/instance.rb

@@ -5,7 +5,7 @@ require Options.paths.lib + 'rpc/client/base'
 module RPC
 class Client
 
-# RPC client for remote instances spawned by a remote dispatcher
+# RPC client for remote instances spawned by a remote agent
 #
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 class Instance
@@ -47,7 +47,7 @@ class Instance
         @instance = Proxy.new( @client )
         @options  = Arachni::RPC::Proxy.new( @client, 'options' )
 
-        # map Dispatcher handlers
+        # map Agent handlers
         Cuboid::Application.application.instance_services.keys.each do |name|
             self.class.send( :attr_reader, name.to_sym )
 

data/lib/cuboid/rpc/client.rb

@@ -1,3 +1,3 @@
 require_relative 'client/instance'
-require_relative 'client/dispatcher'
+require_relative 'client/agent'
 require_relative 'client/scheduler'

data/lib/cuboid/rpc/server/agent/node.rb

@@ -0,0 +1,247 @@
+module Cuboid
+
+require Options.paths.lib + 'rpc/server/output'
+
+module RPC
+
+# Agent node class, helps maintain a list of all available Agents in
+# the grid and announce itself to peering Agents.
+#
+# As soon as a new Node is fired up it checks-in with its peer and grabs
+# a list of all available peers.
+#
+# As soon as it receives the peer list it then announces itself to them.
+#
+# Upon convergence there will be a grid of Agents each one with its own
+# copy of all available Agent URLs.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Server::Agent::Node
+    include UI::Output
+
+    # Initializes the node by:
+    #
+    #   * Adding the peer (if the user has supplied one) to the peer list.
+    #   * Getting the peer's peer list and appending them to its own.
+    #   * Announces itself to the peer and instructs it to propagate our URL
+    #     to the others.
+    #
+    # @param    [Cuboid::Options]    options
+    # @param    [Server::Base]    server
+    #   Agent's RPC server.
+    # @param    [String]              logfile
+    #   Where to send the output.
+    def initialize( options, server, logfile = nil )
+        @options = options
+        @server  = server
+        @url     = @server.url
+
+        reroute_to_file( logfile ) if logfile
+
+        print_status 'Initializing grid node...'
+
+        @dead_nodes = Set.new
+        @peers = Set.new
+        @nodes_info_cache = []
+
+        if (peer = @options.agent.peer)
+            # Grab the peer's peers.
+            connect_to_peer( peer ).peers do |urls|
+                if urls.rpc_exception?
+                    add_dead_peer( peer )
+                    print_info "Neighbour seems dead: #{peer}"
+                    add_dead_peer( peer )
+                    next
+                end
+
+                # Add peer and announce it to everyone.
+                add_peer( peer, true )
+
+                urls.each { |url| @peers << url if url != @url }
+            end
+        end
+
+        print_status 'Node ready.'
+
+        log_updated_peers
+
+        Arachni::Reactor.global.at_interval( @options.agent.ping_interval ) do
+            ping
+            check_for_comebacks
+        end
+    end
+
+    # @return   [Boolean]
+    #   `true` if grid member, `false` otherwise.
+    def grid_member?
+        @peers.any?
+    end
+
+    def unplug
+        @peers.each do |peer|
+            connect_to_peer( peer ).remove_peer( @url ) {}
+        end
+
+        @peers.clear
+        @dead_nodes.clear
+
+        nil
+    end
+
+    # Adds a peer to the peer list.
+    #
+    # @param    [String]    node_url
+    #   URL of a peering node.
+    # @param    [Boolean]   propagate
+    #   Whether or not to announce the new node to the peers.
+    def add_peer( node_url, propagate = false )
+        # we don't want ourselves in the Set
+        return false if node_url == @url
+        return false if @peers.include?( node_url )
+
+        print_status "Adding peer: #{node_url}"
+
+        @peers << node_url
+        log_updated_peers
+        announce( node_url ) if propagate
+
+        connect_to_peer( node_url ).add_peer( @url, propagate ) do |res|
+            next if !res.rpc_exception?
+            add_dead_peer( node_url )
+            print_status "Neighbour seems dead: #{node_url}"
+        end
+        true
+    end
+
+    def remove_peer( url )
+        @peers.delete url
+        @dead_nodes.delete url
+        nil
+    end
+
+    # @return   [Array]
+    #   Neighbour/node/peer URLs.
+    def peers
+        @peers.to_a
+    end
+
+    def peers_with_info( &block )
+        fail 'This method requires a block!' if !block_given?
+
+        @peers_cmp = ''
+
+        if @nodes_info_cache.empty? || @peers_cmp != peers.to_s
+            @peers_cmp = peers.to_s
+
+            each = proc do |peer, iter|
+                connect_to_peer( peer ).info do |info|
+                    if info.rpc_exception?
+                        print_info "Neighbour seems dead: #{peer}"
+                        add_dead_peer( peer )
+                        log_updated_peers
+
+                        iter.return( nil )
+                    else
+                        iter.return( info )
+                    end
+                end
+            end
+
+            after = proc do |nodes|
+                @nodes_info_cache = nodes.compact
+                block.call( @nodes_info_cache )
+            end
+
+            Arachni::Reactor.global.create_iterator( peers ).map( each, after )
+        else
+            block.call( @nodes_info_cache )
+        end
+    end
+
+    # @return    [Hash]
+    #
+    #   * `url` -- This node's URL.
+    #   * `name` -- Nickname
+    #   * `peers` -- Array of peers.
+    def info
+        {
+            'url'                    => @url,
+            'name'                   => @options.agent.name,
+            'peers'             => @peers.to_a,
+            'unreachable_peers' => @dead_nodes.to_a
+        }
+    end
+
+    def alive?
+        true
+    end
+
+    private
+
+    def add_dead_peer( url )
+        remove_peer( url )
+        @dead_nodes << url
+    end
+
+    def log_updated_peers
+        print_info 'Updated peers:'
+
+        if !peers.empty?
+            peers.each { |node| print_info( '---- ' + node ) }
+        else
+            print_info '<empty>'
+        end
+    end
+
+    def ping
+        peers.each do |peer|
+            connect_to_peer( peer ).alive? do |res|
+                next if !res.rpc_exception?
+                add_dead_peer( peer )
+                print_status "Found dead peer: #{peer} "
+            end
+        end
+    end
+
+    def check_for_comebacks
+        @dead_nodes.dup.each do |url|
+            peer = connect_to_peer( url )
+            peer.alive? do |res|
+                next if res.rpc_exception?
+
+                print_status "Agent came back to life: #{url}"
+                ([@url] | peers).each do |node|
+                    peer.add_peer( node ){}
+                end
+
+                add_peer( url )
+                @dead_nodes.delete url
+            end
+        end
+    end
+
+    # Announces the node to the ones in the peer list
+    #
+    # @param    [String]    node
+    #   URL
+    def announce( node )
+        print_status "Advertising: #{node}"
+
+        peers.each do |peer|
+            next if peer == node
+
+            print_info '---- to: ' + peer
+            connect_to_peer( peer ).add_peer( node ) do |res|
+                add_dead_peer( peer ) if res.rpc_exception?
+            end
+        end
+    end
+
+    def connect_to_peer( url )
+        @rpc_clients ||= {}
+        @rpc_clients[url] ||= Client::Agent.new( url ).node
+    end
+
+end
+end
+end

data/lib/cuboid/rpc/server/{dispatcher → agent}/service.rb

@@ -1,7 +1,7 @@
 module Cuboid
 module RPC
 
-# Base class and namespace for all Dispatcher services.
+# Base class and namespace for all Agent services.
 #
 # # RPC accessibility
 #
@@ -26,20 +26,20 @@ module RPC
 # results to that block instead of returning a value.
 #
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
-class Server::Dispatcher::Service
+class Server::Agent::Service
 
     attr_reader :options
-    attr_reader :dispatcher
+    attr_reader :agent
 
-    def initialize( options, dispatcher )
+    def initialize( options, agent )
         @options    = options
-        @dispatcher = dispatcher
+        @agent = agent
     end
 
-    # @return   [Server::Dispatcher::Node]
+    # @return   [Server::Agent::Node]
     #   Local node.
     def node
-        dispatcher.instance_eval { @node }
+        agent.instance_eval { @node }
     end
 
     # Performs an asynchronous map operation over all running instances.
@@ -102,17 +102,17 @@ class Server::Dispatcher::Service
     # @return   [Array<Hash>]
     #   Alive instances.
     def instances
-        dispatcher.running_instances
+        agent.running_instances
     end
 
-    # Connects to a Dispatcher by `url`
+    # Connects to a Agent by `url`
     #
     # @param    [String]    url
     #
-    # @return   [Client::Dispatcher]
-    def connect_to_dispatcher( url )
-        @dispatcher_connections ||= {}
-        @dispatcher_connections[url] ||= Client::Dispatcher.new( url )
+    # @return   [Client::Agent]
+    def connect_to_agent( url )
+        @agent_connections ||= {}
+        @agent_connections[url] ||= Client::Agent.new( url )
     end
 
     # Connects to an Instance by `url`.