cuboid 0.0.0 → 0.0.1alpha

data/lib/cuboid/option_groups/report.rb

@@ -0,0 +1,39 @@
+module Cuboid::OptionGroups
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Report < Cuboid::OptionGroup
+
+    # @return    [String]
+    #   Directory or file path where to store the scan report.
+    attr_accessor :path
+
+    def initialize
+        @default_path = self.path = default_path
+    end
+
+    def path=( path )
+        return @path = @default_path if !path
+
+        if path.end_with?( '/' ) && !File.exist?( path )
+            raise ArgumentError,
+                  "Snapshot location does not exist: #{path}"
+        end
+
+        path = File.expand_path( path )
+        if File.directory? path
+            path += '/' if !path.end_with? '/'
+        end
+
+        @path = path
+    end
+
+    def default_path
+        Paths.config['reports']
+    end
+
+    def defaults
+        { path: default_path }
+    end
+
+end
+end

data/lib/cuboid/option_groups/rpc.rb

@@ -0,0 +1,105 @@
+module Cuboid::OptionGroups
+
+# Holds {Engine::RPC::Client} and {Engine::RPC::Server} options.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class RPC < Cuboid::OptionGroup
+
+    # @return   [String]
+    #   Path to the UNIX socket to use for RPC communication.
+    #
+    # @see RPC::Server::Base
+    attr_accessor :server_socket
+
+    # @return   [String]
+    #   Hostname or IP address for the RPC server.
+    #
+    # @see RPC::Server::Base
+    attr_accessor :server_address
+
+    # @return   [String]
+    #   External (hostname or IP) address for the RPC server to advertise.
+    attr_accessor :server_external_address
+
+    # @return   [Integer]
+    #   RPC server port.
+    #
+    # @see RPC::Server::Base
+    attr_accessor :server_port
+
+    # @return   [String]
+    #   Path to an SSL certificate authority file in PEM format.
+    #
+    # @see RPC::Server::Base
+    # @see RPC::Client::Base
+    attr_accessor :ssl_ca
+
+    # @return   [String]
+    #   Path to a server SSL private key in PEM format.
+    #
+    # @see RPC::Server::Base
+    attr_accessor :server_ssl_private_key
+
+    # @return   [String]
+    #   Path to server SSL certificate in PEM format.
+    #
+    # @see RPC::Server::Base
+    attr_accessor :server_ssl_certificate
+
+    # @return   [String]
+    #   Path to a client SSL private key in PEM format.
+    #
+    # @see RPC::Client::Base
+    attr_accessor :client_ssl_private_key
+
+    # @return   [String]
+    #   Path to client SSL certificate in PEM format.
+    #
+    # @see RPC::Client::Base
+    attr_accessor :client_ssl_certificate
+
+    # @return [Integer]
+    #   Maximum retries for failed RPC calls.
+    #
+    # @see RPC::Client::Base
+    attr_accessor :client_max_retries
+
+    # @note This should be permanently set to `1`, otherwise it will cause issues
+    #   with the scheduling of the workload distribution of multi-Instance scans.
+    #
+    # @return [Integer]
+    #   Amount of concurrently open connections for each RPC client.
+    #
+    # @see RPC::Client::Base
+    attr_accessor :connection_pool_size
+
+    set_defaults(
+        connection_pool_size: 1,
+        server_address:       '127.0.0.1',
+        server_port:          7331
+    )
+
+    def to_client_options
+        {
+            connection_pool_size: connection_pool_size,
+            max_retries:          client_max_retries,
+            ssl_ca:               ssl_ca,
+            ssl_pkey:             client_ssl_private_key,
+            ssl_cert:             client_ssl_certificate
+        }
+    end
+
+    def to_server_options
+        {
+            host:             server_address,
+            external_address: server_external_address,
+            port:             server_port,
+            socket:           server_socket,
+            ssl_ca:           ssl_ca,
+            ssl_pkey:         server_ssl_private_key,
+            ssl_cert:         server_ssl_certificate
+        }
+    end
+
+end
+end

data/lib/cuboid/option_groups/scheduler.rb

@@ -0,0 +1,27 @@
+module Cuboid::OptionGroups
+
+# Holds options for {RPC::Server::Scheduler} servers.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Scheduler < Cuboid::OptionGroup
+
+    # @return   [String]
+    #   URL of a {RPC::Server::Scheduler}.
+    attr_accessor :url
+
+    # @return   [Array<Integer>]
+    #   Range of ports to use when spawning instances, first entry should be
+    #   the lowest port number, last the max port number.
+    attr_accessor :instance_port_range
+
+    # @return   [Float]
+    #   How regularly to check for scan statuses.
+    attr_accessor :ping_interval
+
+    set_defaults(
+        ping_interval:       5.0,
+        instance_port_range: [1025, 65535]
+    )
+
+end
+end

data/lib/cuboid/option_groups/snapshot.rb

@@ -0,0 +1,13 @@
+require_relative 'report'
+
+module Cuboid::OptionGroups
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Snapshot < Report
+
+    def default_path
+        Paths.config['snapshots']
+    end
+
+end
+end

data/lib/cuboid/option_groups/system.rb

@@ -0,0 +1,10 @@
+module Cuboid::OptionGroups
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class System < Cuboid::OptionGroup
+
+    # @return    [Integer]
+    attr_accessor :max_slots
+
+end
+end

data/lib/cuboid/options.rb

@@ -0,0 +1,254 @@
+require 'yaml'
+require 'singleton'
+
+require_relative 'error'
+require_relative 'utilities'
+
+module Cuboid
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+# @see OptionGroups
+class Options
+    include Singleton
+
+    def self.attr_accessor(*vars)
+        @attr_accessors ||= []
+        @attr_accessors |= vars
+        super( *vars )
+    end
+
+    def self.attr_accessors
+        @attr_accessors
+    end
+
+    def attr_accessors
+        self.class.attr_accessors
+    end
+
+    # {Options} error namespace.
+    #
+    # All {Options} errors inherit from and live under it.
+    #
+    # @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+    class Error < Cuboid::Error
+    end
+
+    class <<self
+
+        def method_missing( sym, *args, &block )
+            if instance.respond_to?( sym )
+                instance.send( sym, *args, &block )
+            else
+                super( sym, *args, &block )
+            end
+        end
+
+        def respond_to?( *args )
+            super || instance.respond_to?( *args )
+        end
+
+        # Ruby 2.0 doesn't like my class-level method_missing for some reason.
+        # @private
+        public :allocate
+
+        # @return   [Hash<Symbol,OptionGroup>]
+        #   {OptionGroups Option group} classes by name.
+        def group_classes
+            @group_classes ||= {}
+        end
+
+        # Should be called by {OptionGroup.inherited}.
+        # @private
+        def register_group( group )
+            name = Utilities.caller_name
+
+            # Prepare an attribute reader for this group...
+            attr_reader name
+
+            # ... and initialize it.
+            instance_variable_set "@#{name}".to_sym, group.new
+
+            group_classes[name.to_sym] = group
+        end
+    end
+
+    # Load all {OptionGroups}.
+    require_relative 'option_groups'
+
+    TO_RPC_IGNORE = Set.new([
+        :instance, :rpc, :dispatcher, :queue, :paths,
+        :snapshot, :report, :output, :system
+    ])
+
+    TO_HASH_IGNORE = Set.new([ :instance ])
+
+
+    # @return    [String]
+    #   E-mail address of the person that authorized the run.
+    #
+    # @see HTTP::Client#headers
+    attr_accessor :authorized_by
+
+    attr_accessor :application
+
+    def initialize
+        reset
+    end
+
+    # Restores everything to their default values.
+    #
+    # @return [Options] `self`
+    def reset
+        # nil everything out.
+        instance_variables.each { |var| instance_variable_set( var.to_s, nil ) }
+
+        # Set fresh option groups.
+        group_classes.each do |name, klass|
+            instance_variable_set "@#{name}".to_sym, klass.new
+        end
+
+        @authorized_by  = nil
+
+        self
+    end
+
+
+    # Configures options via a Hash object.
+    #
+    # @param    [Hash]  options
+    #   If the key refers to a class attribute, the attribute will be assigned
+    #   the given value, if it refers to one of the {OptionGroups} the value
+    #   should be a hash with data to update that {OptionGroup group} using
+    #   {OptionGroup#update}.
+    #
+    # @return   [Options]
+    #
+    # @see OptionGroups
+    def update( options )
+        options.each do |k, v|
+            k = k.to_sym
+            if group_classes.include? k
+                send( k ).update v
+            else
+                send( "#{k.to_s}=", v )
+            end
+        end
+
+        self
+    end
+    alias :set :update
+
+    # @return   [Hash]
+    #   Hash of errors with the name of the invalid options/groups as the keys.
+    def validate
+        errors = {}
+        group_classes.keys.each do |name|
+            next if (group_errors = send(name).validate).empty?
+            errors[name] = group_errors
+        end
+        errors
+    end
+
+    # @param    [String]    file
+    #   Saves `self` to `file` using YAML.
+    def save( file )
+        File.open( file, 'w' ) do |f|
+            f.write to_save_data
+            f.path
+        end
+    end
+
+    def to_save_data
+        to_rpc_data.to_yaml
+    end
+
+    def to_save_data_without_defaults
+        to_rpc_data_without_defaults.to_yaml
+    end
+
+    # Loads a file created by {#save}.
+    #
+    # @param    [String]    filepath
+    #   Path to the file created by {#save}.
+    #
+    # @return   [Cuboid::Options]
+    def load( filepath )
+        update( YAML.load_file( filepath ) )
+    end
+
+    # @return    [Hash]
+    #   `self` converted to a Hash suitable for RPC transmission.
+    def to_rpc_data
+        hash = {}
+        instance_variables.each do |var|
+            val = instance_variable_get( var )
+            var = normalize_name( var )
+
+            next if TO_RPC_IGNORE.include?( var )
+
+            hash[var.to_s] = (val.is_a? OptionGroup) ? val.to_rpc_data : val
+        end
+        hash.deep_clone
+    end
+
+    def to_rpc_data_without_defaults
+        defaults = self.class.allocate.reset.to_rpc_data
+        to_rpc_data.reject { |k, v| defaults[k] == v }
+    end
+
+    # @return    [Hash]
+    #   `self` converted to a Hash.
+    def to_hash
+        hash = {}
+        instance_variables.each do |var|
+            val = instance_variable_get( var )
+            var = normalize_name( var )
+
+            next if TO_HASH_IGNORE.include?( var )
+
+            hash[var] = (val.is_a? OptionGroup) ? val.to_h : val
+        end
+
+        hash.deep_clone
+    end
+    alias :to_h :to_hash
+
+    # @param    [Hash]  hash
+    #   Hash to convert into {#to_hash} format.
+    #
+    # @return   [Hash]
+    #   `hash` in {#to_hash} format.
+    def rpc_data_to_hash( hash )
+        self.class.allocate.reset.update( hash ).to_hash.
+            reject { |k| TO_RPC_IGNORE.include? k }
+    end
+
+    # @param    [Hash]  hash
+    #   Hash to convert into {#to_rpc_data} format.
+    #
+    # @return   [Hash]
+    #   `hash` in {#to_rpc_data} format.
+    def hash_to_rpc_data( hash )
+        self.class.allocate.reset.update( hash ).to_rpc_data
+    end
+
+    def hash_to_save_data( hash )
+        self.class.allocate.reset.update( hash ).to_save_data
+    end
+
+    def dup
+        self.class.allocate.reset.update( self.to_h )
+    end
+
+    private
+
+    def group_classes
+        self.class.group_classes
+    end
+
+    def normalize_name( name )
+        name.to_s.gsub( '@', '' ).to_sym
+    end
+
+end
+end