cuboid 0.0.5 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b01651b87b7bf659764002cbb1aaa3b8293caf047f9675874b7393dd36c54ced
-  data.tar.gz: 0b831b738a29e23eecdb949e17079294eb75b57cc902395ec54021cd2d923bee
+  metadata.gz: d9533dcacaf536c3e740993765c95acabe9ef309f47d0ee9abb17057ba20248b
+  data.tar.gz: 0557ca182b8e7589dca448e75062bb87444716b6d36a7fc257d678efa7090fd3
 SHA512:
-  metadata.gz: 4aaca66ce49f16888f68e39d84c4d2d9e3f81b7cc8551b31ee6f74505d0c379a6aa92443e698724da65babd8d32c3f9cc5695c272cca4d5d0c2e4d9637d50f6a
-  data.tar.gz: 258a9295ef9d4765ef9f8cc9ff60ec53e2ee2b11cb342069db7574853ce7db8c1bceb242c80012170a52bba8b9e8f1a489d7969b150e0be15135aa70a0ba15b6
+  metadata.gz: 1ceff653d44e2821fc770c6913fdb9de57922bbfd809f20a043746c2c0f2ddb0103f1e77156bdb103047fd6770bf2968ad9183db5ad6bf623a73965848082be1
+  data.tar.gz: 96d5ef822e102d7200068b192ef9f4817d0dba02e4d01a8f83c6aaafa7d2d997947d170bee8a344d61f7657ad29d54e0d7b30042c874e5f53dade035a20f15c2

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# 0.1.3
+
+* `Agent`
+  * `#preferred`, `#spawn`: Replaced `load_balance` override with `direct` `strategy`.
+
+# 0.1.0
+
+* `Dispatcher` => `Agent`
+* `Dispatcher#dispatch` => `Agent#spawn`
+* `neighbour` => `peer`

data/README.md

@@ -10,8 +10,8 @@ _Cloud_ within a _Cloud_.
 
 It offers:
 
-* Load-balancing of _**Instances**_ via a software mesh network (_**Grid**_) of _**Dispatchers**_.
-  * No need to setup a topology manually, _**Dispatchers**_ will reach
+* Load-balancing of _**Instances**_ via a network (_**Grid**_) of _**Agents**_.
+  * No need to setup a topology manually, _**Agents**_ will reach
     convergence on their own, just point them to an existing _**Grid**_ member.
   * Scaling up and down can be easily achieved by _plugging_ or _unplugging_ nodes.
   * Horizontal (`default`) and vertical workload distribution strategies available.
@@ -58,7 +58,7 @@ framework:
     * `:restore`
   * `instance_service_for( Symbol, Class )` -- Adds a custom _**Instance**_ RPC API.
   * `rest_service_for( Symbol, Module )` -- Hooks-up to the _**REST**_ service to provide a custom REST API.
-  * `dispatcher_service_for( Symbol, Class )` -- Hooks-up to the _**Dispatcher**_ to provide a custom RPC API.
+  * `agent_service_for( Symbol, Class )` -- Hooks-up to the _**Agent**_ to provide a custom RPC API.
   * `serialize_with( Module )` -- A serializer to be used for:
     * `#options`
     * `Report#data`
@@ -84,10 +84,10 @@ This is in order to enforce isolation (_state_, _data_, _fault_) between
 _**Applications**_, take advantage of _OS_ task management and generally keep
 things simple.
 
-### Dispatcher
+### Agent
 
-A _**Dispatcher**_ is a server which awaits for _**Instance**_ spawn requests
-(`dispatch` calls) upon which it spawns and passes the _**Instance**_'s
+A _**Agent**_ is a server which awaits for _**Instance**_ spawn requests
+(`spawn` calls) upon which it spawns and passes the _**Instance**_'s
 connection info to the client.
 
 The client can then proceed to use the _**Instance**_ to run and generally manage
@@ -95,7 +95,7 @@ the contained _**Application**_.
 
 #### Grid
 
-A _**Dispatcher**_ _**Grid**_ is a software mesh network of _**Dispatcher**_
+A _**Agent**_ _**Grid**_ is a software mesh network of _**Agent**_
 servers, aimed towards providing automated _load-balancing_ based on available
 system resources and each _**Application**_'s provisioning configuration.
 
@@ -104,11 +104,11 @@ providing any existing _**Grid**_ member upon start-up and the rest will be
 sorted out automatically.
 
 The network is _self-healing_ and will monitor _node_ connectivity, taking steps
-to ensure that neither server nor network conditions will disrupt dispatching.
+to ensure that neither server nor network conditions will disrupt spawning.
 
 ##### Scalability
 
-_**Dispatchers**_ can be easily _plugged_ to or _unplugged_ from the _**Grid**_
+_**Agents**_ can be easily _plugged_ to or _unplugged_ from the _**Grid**_
 to scale up or down as necessary.
 
 _Plugging_ happens at boot-time and _unplugging_ can take place via the available
@@ -125,12 +125,12 @@ The _**Scheduler**_ is a server which:
   5. Upon _**Application**_ completion stores report to disk.
   6. Shuts down the _**Instance**_.
 
-#### Dispatcher
+#### Agent
 
-The _**Scheduler**_ can be configured with a _**Dispatcher**_, upon which case,
+The _**Scheduler**_ can be configured with a _**Agent**_, upon which case,
 it will use it to spawn _**Instances**_.
 
-If the _**Dispatcher**_ is a _**Grid**_ member then the _**Scheduler**_ will
+If the _**Agent**_ is a _**Grid**_ member then the _**Scheduler**_ will
 also enjoy _load-balancing_ features. 
 
 ## APIs
@@ -154,7 +154,7 @@ RPC interface.
 A REST API is also available, taking advantage of HTTP sessions to make progress
 tracking easier.
 
-The REST interface is basically a web _**Dispatcher**_ and centralised point of
+The REST interface is basically a web _**Agent**_ and centralised point of
 management for the rest of the entities.
 
 Each _**Application**_ can extend upon this and expose an API via its _**REST**_ 

data/cuboid.gemspec

@@ -42,12 +42,8 @@ Gem::Specification.new do |s|
     # RPC serialization.
     s.add_dependency 'msgpack',             '1.1.0'
 
-    # Optimized JSON.
-    s.add_dependency 'oj',                  '3.11.5'
-    s.add_dependency 'oj_mimic_json',       '1.0.1'
-
     # Web server
-    s.add_dependency 'puma',                '5.5.2'
+    s.add_dependency 'puma',                '5.6.2'
 
     s.add_dependency 'rack',                '2.2.3'
     s.add_dependency 'rack-test'

data/lib/cuboid/application.rb

@@ -103,15 +103,15 @@ class Application
             @max_memory ||= 0
         end
 
-        def provision_disk( ram )
-            @max_disk = ram
+        def provision_disk( disk )
+            @max_disk = disk
         end
 
         def max_disk
-            @max_memory ||= 0
+            @max_disk ||= 0
         end
 
-        def instance_service_for(name, service )
+        def instance_service_for( name, service )
             instance_services[name] = service
         end
 
@@ -127,12 +127,12 @@ class Application
             @rest_services ||= {}
         end
 
-        def dispatcher_service_for( name, service )
-            dispatcher_services[name] = service
+        def agent_service_for( name, service )
+            agent_services[name] = service
         end
 
-        def dispatcher_services
-            @dispatcher_services ||= {}
+        def agent_services
+            @agent_services ||= {}
         end
 
         def handler_for( signal, handler )
@@ -183,8 +183,8 @@ class Application
             case type
             when :instance
                 const = :Instances
-            when :dispatcher
-                const = :Dispatchers
+            when :agent
+                const = :Agents
             when :scheduler
                 const = :Schedulers
             when :rest

data/lib/cuboid/option_groups/{dispatcher.rb → agent.rb}

@@ -1,14 +1,14 @@
 module Cuboid::OptionGroups
 
-# Holds options for {RPC::Server::Dispatcher} servers.
+# Holds options for {RPC::Server::Agent} servers.
 #
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
-class Dispatcher < Cuboid::OptionGroup
+class Agent < Cuboid::OptionGroup
 
-    STRATEGIES = Set.new([:horizontal, :vertical])
+    STRATEGIES = Set.new([:horizontal, :vertical, :direct])
 
     # @return   [String]
-    #   URL of a {RPC::Server::Dispatcher}.
+    #   URL of a {RPC::Server::Agent}.
     attr_accessor :url
 
     # @return   [Array<Integer>]
@@ -17,18 +17,18 @@ class Dispatcher < Cuboid::OptionGroup
     attr_accessor :instance_port_range
 
     # @return   [String]
-    #   The URL of a neighbouring {RPC::Server::Dispatcher}, applicable when
-    #   {RPC::Server::Dispatcher} are connected to each other to form a Grid.
+    #   The URL of a peering {RPC::Server::Agent}, applicable when
+    #   {RPC::Server::Agent} are connected to each other to form a Grid.
     #
-    # @see RPC::Server::Dispatcher::Node
-    attr_accessor :neighbour
+    # @see RPC::Server::Agent::Node
+    attr_accessor :peer
 
     # @return   [Float]
-    #   How regularly to check for neighbour statuses.
+    #   How regularly to check for peer statuses.
     attr_accessor :ping_interval
 
     # @return   [String]
-    #   Dispatcher name.
+    #   Agent name.
     attr_accessor :name
 
     attr_accessor :strategy

data/lib/cuboid/option_groups/paths.rb

@@ -70,7 +70,7 @@ class Paths < Cuboid::OptionGroup
 
     # @!attribute executables
     #   @return [String]
-    #       System processes (instance, dispatcher, browser, etc.).
+    #       System processes (instance, agent, browser, etc.).
 
     def initialize
         @root = self.root_path

data/lib/cuboid/options.rb

@@ -76,7 +76,7 @@ class Options
     require_relative 'option_groups'
 
     TO_RPC_IGNORE = Set.new([
-        :instance, :rpc, :dispatcher, :queue, :paths,
+        :instance, :rpc, :agent, :queue, :paths,
         :snapshot, :report, :output, :system
     ])
 

data/lib/cuboid/processes/{dispatchers.rb → agents.rb}

@@ -2,28 +2,28 @@ module Cuboid
 module Processes
 
 #
-# Helper for managing {RPC::Server::Dispatcher} processes.
+# Helper for managing {RPC::Server::Agent} processes.
 #
 # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
 #
-class Dispatchers
+class Agents
     include Singleton
     include Utilities
 
-    # @return   [Array<String>] URLs of all running Dispatchers.
+    # @return   [Array<String>] URLs of all running Agents.
     attr_reader :list
 
     def initialize
         @list = []
-        @dispatcher_connections = {}
+        @agent_connections = {}
     end
 
-    # Connects to a Dispatcher by URL.
+    # Connects to a Agent by URL.
     #
-    # @param    [String]    url URL of the Dispatcher.
+    # @param    [String]    url URL of the Agent.
     # @param    [Hash]    options Options for the RPC client.
     #
-    # @return   [RPC::Client::Dispatcher]
+    # @return   [RPC::Client::Agent]
     def connect( url, options = nil )
         Arachni::Reactor.global.run_in_thread if !Arachni::Reactor.global.running?
 
@@ -33,26 +33,26 @@ class Dispatchers
         end
 
         if fresh
-            @dispatcher_connections[url] = RPC::Client::Dispatcher.new( url, options )
+            @agent_connections[url] = RPC::Client::Agent.new( url, options )
         else
-            @dispatcher_connections[url] ||= RPC::Client::Dispatcher.new( url, options )
+            @agent_connections[url] ||= RPC::Client::Agent.new( url, options )
         end
     end
 
-    # @param    [Block] block   Block to pass an RPC client for each Dispatcher.
+    # @param    [Block] block   Block to pass an RPC client for each Agent.
     def each( &block )
         @list.each do |url|
             block.call connect( url )
         end
     end
 
-    # Spawns a {RPC::Server::Dispatcher} process.
+    # Spawns a {RPC::Server::Agent} process.
     #
     # @param    [Hash]  options
     #   To be passed to {Cuboid::Options#set}. Allows `address` instead of
     #   `rpc_server_address` and `port` instead of `rpc_port`.
     #
-    # @return   [RPC::Client::Dispatcher]
+    # @return   [RPC::Client::Agent]
     def spawn( options = {} )
         options = options.dup
         fork = options.delete(:fork)
@@ -63,9 +63,9 @@ class Dispatchers
         }
 
         options = {
-            dispatcher: {
+            agent: {
                 name:      options[:name],
-                neighbour: options[:neighbour],
+                peer: options[:peer],
                 strategy:  options[:strategy],
             },
             rpc:        {
@@ -88,11 +88,11 @@ class Dispatchers
             options[:rpc].delete :server_external_address
         end
 
-        if options[:dispatcher][:neighbour].nil?
-            options[:dispatcher].delete :neighbour
+        if options[:agent][:peer].nil?
+            options[:agent].delete :peer
         end
 
-        pid = Manager.spawn( :dispatcher, options: options, fork: fork )
+        pid = Manager.spawn( :agent, options: options, fork: fork )
 
         url = "#{options[:rpc][:server_address]}:#{options[:rpc][:server_port]}"
         while sleep( 0.1 )
@@ -110,26 +110,26 @@ class Dispatchers
 
     def grid_spawn( options = {} )
         d = spawn( options )
-        spawn( options.merge neighbour: d.url )
+        spawn( options.merge peer: d.url )
     end
 
-    # @note Will also kill all Instances started by the Dispatcher.
+    # @note Will also kill all Instances started by the Agent.
     #
-    # @param    [String]    url URL of the Dispatcher to kill.
+    # @param    [String]    url URL of the Agent to kill.
     def kill( url )
-        dispatcher = connect( url )
-        Manager.kill_many dispatcher.statistics['consumed_pids']
-        Manager.kill dispatcher.pid
+        agent = connect( url )
+        Manager.kill_many agent.statistics['consumed_pids']
+        Manager.kill agent.pid
     rescue => e
         #ap e
         #ap e.backtrace
         nil
     ensure
         @list.delete( url )
-        @dispatcher_connections.delete( url )
+        @agent_connections.delete( url )
     end
 
-    # Kills all {Dispatchers #list}.
+    # Kills all {Agents #list}.
     def killall
         @list.dup.each do |url|
             kill url

data/lib/cuboid/processes/executables/agent.rb

@@ -0,0 +1,5 @@
+require Options.paths.lib  + 'rpc/server/agent'
+
+Arachni::Reactor.global.run do
+    RPC::Server::Agent.new
+end

data/lib/cuboid/processes/helpers/agents.rb

@@ -0,0 +1,23 @@
+# @param (see Cuboid::Processes::Agents#spawn)
+# @return (see Cuboid::Processes::Agents#spawn)
+def agent_spawn( *args )
+    Cuboid::Processes::Agents.spawn( *args )
+end
+
+# @param (see Cuboid::Processes::Agents#kill)
+# @return (see Cuboid::Processes::Agents#kill)
+def agent_kill( *args )
+    Cuboid::Processes::Agents.kill( *args )
+end
+
+# @param (see Cuboid::Processes::Agents#killall)
+# @return (see Cuboid::Processes::Agents#killall)
+def agent_killall
+    Cuboid::Processes::Agents.killall
+end
+
+# @param (see Cuboid::Processes::Agents#connect)
+# @return (see Cuboid::Processes::Agents#connect)
+def agent_connect( *args )
+    Cuboid::Processes::Agents.connect( *args )
+end

data/lib/cuboid/processes/helpers/instances.rb

@@ -10,10 +10,10 @@ def instance_grid_spawn( *args )
     Cuboid::Processes::Instances.grid_spawn( *args )
 end
 
-# @param (see Cuboid::Processes::Instances#dispatcher_spawn)
-# @return (see Cuboid::Processes::Instances#dispatcher_spawn)
-def instance_dispatcher_spawn( *args )
-    Cuboid::Processes::Instances.dispatcher.spawn( *args )
+# @param (see Cuboid::Processes::Instances#agent_spawn)
+# @return (see Cuboid::Processes::Instances#agent_spawn)
+def instance_agent_spawn( *args )
+    Cuboid::Processes::Instances.agent.spawn( *args )
 end
 
 def instance_kill( url )

data/lib/cuboid/processes/helpers.rb

@@ -1,4 +1,4 @@
 require_relative 'helpers/processes'
-require_relative 'helpers/dispatchers'
+require_relative 'helpers/agents'
 require_relative 'helpers/instances'
 require_relative 'helpers/schedulers'

data/lib/cuboid/processes/instances.rb

@@ -21,7 +21,7 @@ class Instances
     #
     # Connects to a Instance by URL.
     #
-    # @param    [String]    url URL of the Dispatcher.
+    # @param    [String]    url URL of the Agent.
     # @param    [String]    token
     #   Authentication token -- only need be provided once.
     #
@@ -125,10 +125,10 @@ class Instances
         end
     end
 
-    # Starts {RPC::Server::Dispatcher} grid and returns a high-performance Instance.
+    # Starts {RPC::Server::Agent} grid and returns a high-performance Instance.
     #
     # @param    [Hash]  options
-    # @option options [Integer] :grid_size (3)  Amount of Dispatchers to spawn.
+    # @option options [Integer] :grid_size (3)  Amount of Agents to spawn.
     #
     # @return   [RPC::Client::Instance]
     def grid_spawn(options = {} )
@@ -136,23 +136,23 @@ class Instances
 
         last_member = nil
         options[:grid_size].times do |i|
-            last_member = Dispatchers.spawn(
-                neighbour: last_member ? last_member.url : last_member,
+            last_member = Agents.spawn(
+                peer: last_member ? last_member.url : last_member,
                 pipe_id:   Utilities.available_port.to_s + Utilities.available_port.to_s
             )
         end
 
         info = nil
-        info = last_member.dispatch while !info && sleep( 0.1 )
+        info = last_member.spawn while !info && sleep( 0.1 )
 
         connect( info['url'], info['token'] )
     end
 
-    # Starts {RPC::Server::Dispatcher} and returns an Instance.
+    # Starts {RPC::Server::Agent} and returns an Instance.
     #
     # @return   [RPC::Client::Instance]
-    def dispatcher_spawn
-        info = Dispatchers.spawn.dispatch
+    def agent_spawn
+        info = Agents.spawn.spawn
         connect( info['url'], info['token'] )
     end
 

data/lib/cuboid/processes/schedulers.rb

@@ -61,8 +61,8 @@ class Schedulers
         }
 
         options = {
-            dispatcher: {
-                url:      options[:dispatcher],
+            agent: {
+                url:      options[:agent],
                 strategy: options[:strategy]
             },
             rpc:        {

data/lib/cuboid/processes.rb

@@ -3,11 +3,11 @@ require 'ostruct'
 
 lib = Cuboid::Options.paths.lib
 require lib + 'rpc/client/instance'
-require lib + 'rpc/client/dispatcher'
+require lib + 'rpc/client/agent'
 require lib + 'rpc/client/scheduler'
 
 lib = Cuboid::Options.paths.lib + 'processes/'
 require lib + 'manager'
-require lib + 'dispatchers'
+require lib + 'agents'
 require lib + 'instances'
 require lib + 'schedulers'

data/lib/cuboid/report.rb

@@ -1,4 +1,5 @@
 require_relative 'rpc/serializer'
+require 'time'
 
 module Cuboid
 

data/lib/cuboid/rest/server/instance_helpers.rb

@@ -5,10 +5,10 @@ class Server
 module InstanceHelpers
 
     @@instances   = {}
-    @@dispatchers = {}
+    @@agents = {}
 
     def get_instance
-        if dispatcher
+        if agent
             options = {
               owner:   self.class.to_s,
               helpers: {
@@ -18,7 +18,7 @@ module InstanceHelpers
                 }
             }
 
-            if (info = dispatcher.dispatch( options ))
+            if (info = agent.spawn( options ))
                 connect_to_instance( info['url'], info['token'] )
             end
         else
@@ -26,24 +26,24 @@ module InstanceHelpers
         end
     end
 
-    def dispatchers
-        @@dispatchers.keys
+    def agents
+        @@agents.keys
     end
 
-    def dispatcher
-        return if !Options.dispatcher.url
-        @dispatcher ||= connect_to_dispatcher( Options.dispatcher.url )
+    def agent
+        return if !Options.agent.url
+        @agent ||= connect_to_agent( Options.agent.url )
     end
 
-    def unplug_dispatcher( url )
-        connect_to_dispatcher( url ).node.unplug
+    def unplug_agent( url )
+        connect_to_agent( url ).node.unplug
 
-        c = @@dispatchers.delete( url )
+        c = @@agents.delete( url )
         c.close if c
     end
 
-    def connect_to_dispatcher( url )
-        @@dispatchers[url] ||= RPC::Client::Dispatcher.new( url )
+    def connect_to_agent( url )
+        @@agents[url] ||= RPC::Client::Agent.new( url )
     end
 
     def connect_to_instance( url, token )

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 ) || {}