inspec 0.9.0

data/lib/inspec/log.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+# Copyright 2015 Dominik Richter. All rights reserved.
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'rainbow/ext/string'
+
+module Inspec
+  class Log
+    def initialize(opts = {})
+      @quiet = opts[:quiet] || false
+    end
+
+    def show(msg)
+      puts msg unless @quiet
+    end
+
+    def info(msg)
+      show '  .  '.color(:white) + msg
+    end
+
+    def error(msg)
+      show '  ✖  '.color(:red).bright + msg
+    end
+
+    def warn(msg)
+      show '  !  '.color(:yellow).bright + msg
+    end
+
+    def ok(msg)
+      show '  ✔  '.color(:green).bright + msg
+    end
+  end
+end

data/lib/inspec/metadata.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# Copyright 2015 Dominik Richter. All rights reserved.
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'logger'
+
+module Inspec
+  # Extract metadata.rb information
+  class Metadata
+    attr_reader :params
+    def initialize(logger = nil)
+      @logger = logger || Logger.new(nil)
+      @params = {}
+      @missing_methods = []
+    end
+
+    %w{
+      name
+      title
+      maintainer
+      maintainer_email
+      copyright
+      copyright_email
+      license
+      summary
+      description
+      version
+    }.each do |name|
+      define_method name.to_sym do |arg|
+        params[name.to_sym] = arg
+      end
+    end
+
+    def supports(sth, version = nil)
+      params[:supports] ||= []
+      params[:supports].push(
+        {
+          os:      sth,
+          version: version,
+        },
+      )
+    end
+
+    def valid?
+      is_valid = true
+      %w{ name title version summary }.each do |field|
+        next unless params[field.to_sym].nil?
+        @logger.error("Missing profile #{field} in metadata.rb")
+        is_valid = false
+      end
+      %w{ maintainer copyright }.each do |field|
+        next unless params[field.to_sym].nil?
+        @logger.warn("Missing profile #{field} in metadata.rb")
+        is_valid = false
+      end
+      is_valid && @missing_methods.empty?
+    end
+
+    def method_missing(sth, *args)
+      @logger.warn "metadata.rb doesn't support: #{sth} #{args}"
+      @missing_methods.push(sth)
+    end
+
+    def self.from_file(path, profile_id, logger = nil)
+      logger ||= Logger.new(nil)
+
+      unless File.file?(path)
+        logger.error "Can't find metadata file #{path}"
+        return nil
+      end
+
+      res = Metadata.new(logger)
+      res.instance_eval(File.read(path), path, 1)
+      res.params[:name] = profile_id.to_s unless profile_id.to_s.empty?
+      res
+    end
+  end
+end

data/lib/inspec/plugins.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+module Inspec
+  module Plugins
+    autoload :Resource, 'inspec/plugins/resource'
+  end
+end

data/lib/inspec/plugins/resource.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+module Inspec
+  module Plugins
+    class Resource
+      def self.name(name = nil)
+        return if name.nil?
+        Inspec::Plugins::Resource.__register(name, self)
+      end
+
+      def self.__register(name, obj)
+        # rubocop:disable Lint/NestedMethodDefinition
+        cl = Class.new(obj) do
+          # add some common methods
+          include Inspec::Plugins::ResourceCommon
+          def initialize(backend, name, *args)
+            # attach the backend to this instance
+            @__backend_runner__ = backend
+            @__resource_name__ = name
+            # call the resource initializer
+            super(*args)
+          end
+
+          def inspec
+            @__backend_runner__
+          end
+        end
+        # rubocop:enable Lint/NestedMethodDefinition
+
+        # add the resource to the registry by name
+        Inspec::Resource.registry[name] = cl
+      end
+
+      # Define methods which are available to all resources
+      # and may be overwritten.
+
+      # Print the name of the resource
+      def to_s
+        @__resource_name__
+      end
+
+      # Overwrite inspect to provide better output to RSpec results.
+      #
+      # @return [String] full name of the resource
+      def inspect
+        to_s
+      end
+    end
+
+    module ResourceCommon
+      def resource_skipped
+        @resource_skipped
+      end
+
+      def skip_resource(message)
+        @resource_skipped = message
+      end
+    end
+  end
+end

data/lib/inspec/profile.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+# Copyright 2015 Dominik Richter. All rights reserved.
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'inspec/metadata'
+
+module Inspec
+  class Profile # rubocop:disable Metrics/ClassLength
+    def self.from_path(path, options = nil)
+      opt = {}
+      options.each { |k, v| opt[k.to_sym] = v } unless options.nil?
+      opt[:path] = path
+      Profile.new(opt)
+    end
+
+    attr_reader :params
+    attr_reader :metadata
+
+    def initialize(options = nil)
+      @options = options || {}
+      @profile_id = options[:id] || nil
+      @params = {}
+      @logger = options[:logger] || Logger.new(nil)
+
+      @path = @options[:path]
+      fail 'Cannot read an empty path.' if @path.nil? || @path.empty?
+      fail "Cannot find directory #{@path}" unless File.directory?(@path)
+
+      @metadata = read_metadata
+      @params = @metadata.params unless @metadata.nil?
+
+      @params[:rules] = rules = {}
+      @runner = Runner.new(
+        id: @profile_id,
+        backend: :mock,
+      )
+      @runner.add_tests([@path])
+      @runner.rules.each do |id, rule|
+        file = rule.instance_variable_get(:@__file)
+        rules[file] ||= {}
+        rules[file][id] = {
+          title: rule.title,
+          desc: rule.desc,
+          impact: rule.impact,
+          checks: rule.instance_variable_get(:@checks),
+          code: rule.instance_variable_get(:@__code),
+          group_title: rule.instance_variable_get(:@__group_title),
+        }
+      end
+    end
+
+    def info
+      res = @params.dup
+      rules = {}
+      res[:rules].each do |gid, group|
+        next if gid.to_s.empty?
+        path = gid.sub(File.join(@path, ''), '')
+        rules[path] = { title: path, rules: {} }
+        group.each do |id, rule|
+          next if id.to_s.empty?
+          data = rule.dup
+          data.delete(:checks)
+          data[:impact] ||= 0.5
+          data[:impact] = 1.0 if data[:impact] > 1.0
+          data[:impact] = 0.0 if data[:impact] < 0.0
+          rules[path][:rules][id] = data
+          # TODO: temporarily flatten the group down; replace this with
+          # proper hierarchy later on
+          rules[path][:title] = data[:group_title]
+        end
+      end
+      res[:rules] = rules
+      res
+    end
+
+    # Check if the profile is internall well-structured. The logger will be
+    # used to print information on errors and warnings which are found.
+    #
+    # @return [Boolean] true if no errors were found, false otherwise
+    def check # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      no_errors = true
+      no_warnings = true
+      warn = lambda { |msg|
+        @logger.warn(msg)
+        no_warnings = false
+      }
+      error = lambda { |msg|
+        @logger.error(msg)
+        no_warnings = no_errors = false
+      }
+
+      @logger.info "Checking profile in #{@path}"
+
+      if @params[:name].to_s.empty?
+        error.call('No profile name defined')
+      elsif !(@params[:name].to_s =~ %r{^\S+\/\S+$})
+        error.call('Profile name must be defined as: OWNER/ID')
+      end
+
+      warn.call('No version defined') if @params[:name].to_s.empty?
+      warn.call('No title defined') if @params[:name].to_s.empty?
+      warn.call('No maintainer defined') if @params[:name].to_s.empty?
+      warn.call('No supports defined') if @params[:name].empty?
+      @logger.info 'Metadata OK.' if no_warnings
+
+      no_warnings = true
+      if @params[:name].empty?
+        warn.call('No rules were found.')
+      else
+        @logger.debug "Found #{@params[:name].length} rules."
+      end
+
+      # iterate over hash of groups
+      @params[:rules].each do |group, rules_array|
+        @logger.debug "Verify all rules in  #{group}"
+        rules_array.each do |id, rule|
+          error.call('Avoid rules with empty IDs') if id.nil? or id.empty?
+          warn.call("Rule #{id} has no title") if rule[:title].to_s.empty?
+          warn.call("Rule #{id} has no description") if rule[:desc].to_s.empty?
+          warn.call("Rule #{id} has impact > 1.0") if rule[:impact].to_f > 1.0
+          warn.call("Rule #{id} has impact < 0.0") if rule[:impact].to_f < 0.0
+          warn.call("Rule #{id} has no tests defined") if rule[:checks].nil? or rule[:checks].empty?
+        end
+      end
+
+      @logger.info 'Rule definitions OK.' if no_warnings
+      no_errors
+    end
+
+    private
+
+    def read_metadata
+      mpath = File.join(@path, 'metadata.rb')
+      @metadata = Metadata.from_file(mpath, @profile_id, @logger)
+    end
+  end
+end

data/lib/inspec/profile_context.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'inspec/rule'
+require 'inspec/dsl'
+require 'rspec/core/dsl'
+
+module Inspec
+  class ProfileContext # rubocop:disable Metrics/ClassLength
+    attr_reader :rules, :only_ifs
+    def initialize(profile_id, backend, profile_registry = {}, only_ifs = [])
+      if backend.nil?
+        fail 'ProfileContext is initiated with a backend == nil. ' \
+             'This is a backend error which must be fixed upstream.'
+      end
+
+      @profile_id = profile_id
+      @rules = profile_registry
+      @only_ifs = only_ifs
+
+      dsl = create_inner_dsl(backend)
+      outer_dsl = create_outer_dsl(dsl)
+      ctx = create_context(outer_dsl)
+
+      @profile_context = ctx.new
+    end
+
+    def load(content, source = nil, line = nil)
+      @current_load = { file: source }
+      @profile_context.instance_eval(content, source || 'unknown', line || 1)
+    end
+
+    def unregister_rule(id)
+      full_id = Inspec::Rule.full_id(@profile_id, id)
+      @rules[full_id] = nil
+    end
+
+    def register_rule(r)
+      # get the full ID
+      r.instance_variable_set(:@__file, @current_load[:file])
+      r.instance_variable_set(:@__group_title, @current_load[:title])
+      full_id = Inspec::Rule.full_id(@profile_id, r)
+      if full_id.nil?
+        # TODO: error
+        return
+      end
+
+      # add the rule to the registry
+      existing = @rules[full_id]
+      if existing.nil?
+        @rules[full_id] = r
+      else
+        Inspec::Rule.merge(existing, r)
+      end
+    end
+
+    def set_header(field, val)
+      @current_load[field] = val
+    end
+
+    private
+
+    # Creates the inner DSL which includes all resources for
+    # creating tests. It is always connected to one target,
+    # which is specified via the backend argument.
+    #
+    # @param backend [BackendRunner] exposing the target to resources
+    # @return [InnerDSLModule]
+    def create_inner_dsl(backend)
+      Module.new do
+        Inspec::Resource.registry.each do |id, r|
+          define_method id.to_sym do |*args|
+            r.new(backend, id.to_s, *args)
+          end
+        end
+      end
+    end
+
+    # Creates the outer DSL which includes all methods for creating
+    # tests and control structures.
+    #
+    # @param dsl [InnerDSLModule] which contains all resources
+    # @return [OuterDSLClass]
+    def create_outer_dsl(dsl)
+      rule_class = Class.new(Inspec::Rule) do
+        include RSpec::Core::DSL
+        include dsl
+      end
+
+      # rubocop:disable Lint/NestedMethodDefinition
+      Class.new do
+        include dsl
+
+        define_method :control do |*args, &block|
+          id = args[0]
+          opts = args[1] || {}
+
+          # Skip the control if the resource triggered a skip;
+          # However: when this is run on a mock backend, do not skip it.
+          # This is e.g. relevant for JSON generation, where we need all
+          # controls.
+          return if @skip_profile && os[:family] != 'unknown'
+
+          __register_rule rule_class.new(id, opts, &block)
+        end
+
+        alias_method :rule, :control
+
+        define_method :describe do |*args, &block|
+          path = block.source_location[0]
+          line = block.source_location[1]
+          id = "#{File.basename(path)}:#{line}"
+          rule = rule_class.new(id, {}) do
+            describe(*args, &block)
+          end
+          __register_rule rule, &block
+        end
+
+        # TODO: mock method for attributes; import attribute handling
+        define_method :attributes do |_name, _options|
+          nil
+        end
+
+        def skip_rule(id)
+          __unregister_rule id
+        end
+
+        def only_if(&block)
+          return unless block_given?
+          @skip_profile = !block.call
+        end
+      end
+      # rubocop:enable all
+    end
+
+    # Creates the heart of the profile context:
+    # An instantiated object which has all resources registered to it
+    # and exposes them to the a test file. The profile context serves as a
+    # container for all profiles which are registered. Within the context
+    # profiles get access to all DSL calls for creating tests and controls.
+    #
+    # @param outer_dsl [OuterDSLClass]
+    # @return [ProfileContextClass]
+    def create_context(outer_dsl)
+      profile_context_owner = self
+
+      # rubocop:disable Lint/NestedMethodDefinition
+      Class.new(outer_dsl) do
+        include Inspec::DSL
+
+        define_method :title do |arg|
+          profile_context_owner.set_header(:title, arg)
+        end
+
+        define_method :__register_rule do |*args|
+          profile_context_owner.register_rule(*args)
+        end
+        define_method :__unregister_rule do |*args|
+          profile_context_owner.unregister_rule(*args)
+        end
+
+        def to_s
+          'Profile Context Run'
+        end
+      end
+      # rubocop:enable all
+    end
+  end
+end