Class: Inspec::InspecCLI

Inherits:

BaseCLI

• Object
• Thor
• BaseCLI
• Inspec::InspecCLI

Defined in:

lib/inspec/cli.rb

Instance Method Summary

• #archive(path) ⇒ Object
• #check(path) ⇒ Object

  rubocop:disable Metrics/AbcSize.

• #detect ⇒ Object
• #env(shell = nil) ⇒ Object
• #exec(*targets) ⇒ Object
• #json(target) ⇒ Object
• #schema(name) ⇒ Object
• #shell_func ⇒ Object
• #vendor(path = nil) ⇒ Object
• #version ⇒ Object

Methods inherited from BaseCLI

exec_options, exit_on_failure?, format_platform_info, profile_options, target_options

Instance Method Details

#archive(path) ⇒ Object

# File 'lib/inspec/cli.rb', line 157

def archive(path)
  o = config
  diagnose(o)

  o[:logger] = Logger.new(STDOUT)
  o[:logger].level = get_log_level(o[:log_level])
  o[:backend] = Inspec::Backend.create(Inspec::Config.mock)

  # Force vendoring with overwrite when archiving
  vendor_options = o.dup
  vendor_options[:overwrite] = true
  vendor_deps(path, vendor_options)

  profile = Inspec::Profile.for_target(path, o)
  result = profile.check

  if result && !o[:ignore_errors] == false
    o[:logger].info 'Profile check failed. Please fix the profile before generating an archive.'
    return exit 1
  end

  # generate archive
  exit 1 unless profile.archive(o)
rescue StandardError => e
  pretty_handle_exception(e)
end

#check(path) ⇒ Object

rubocop:disable Metrics/AbcSize

# File 'lib/inspec/cli.rb', line 84

def check(path) # rubocop:disable Metrics/AbcSize
  o = config
  diagnose(o)
  o[:backend] = Inspec::Backend.create(Inspec::Config.mock)
  o[:check_mode] = true
  o[:vendor_cache] = Inspec::Cache.new(o[:vendor_cache])

  # run check
  profile = Inspec::Profile.for_target(path, o)
  result = profile.check

  if o['format'] == 'json'
    puts JSON.generate(result)
  else
    %w{location profile controls timestamp valid}.each do |item|
      puts format('%-12s %s', item.to_s.capitalize + ':',
                  mark_text(result[:summary][item.to_sym]))
    end
    puts

    if result[:errors].empty? and result[:warnings].empty?
      puts 'No errors or warnings'
    else
      red    = "\033[31m"
      yellow = "\033[33m"
      rst    = "\033[0m"

      item_msg = lambda { |item|
        pos = [item[:file], item[:line], item[:column]].compact.join(':')
        pos.empty? ? item[:msg] : pos + ': ' + item[:msg]
      }
      result[:errors].each do |item|
        puts "#{red}  ✖  #{item_msg.call(item)}#{rst}"
      end
      result[:warnings].each do |item|
        puts "#{yellow}  !  #{item_msg.call(item)}#{rst}"
      end

      puts
      puts format('Summary:     %s%d errors%s, %s%d warnings%s',
                  red, result[:errors].length, rst,
                  yellow, result[:warnings].length, rst)
    end
  end
  exit 1 unless result[:summary][:valid]
rescue StandardError => e
  pretty_handle_exception(e)
end

#detect ⇒ Object

# File 'lib/inspec/cli.rb', line 276

def detect
  o = config
  o[:command] = 'platform.params'
  (_, res) = run_command(o)
  if o['format'] == 'json'
    puts res.to_json
  else
    headline('Platform Details')
    puts Inspec::BaseCLI.format_platform_info(params: res, indent: 0, color: 36)
  end
rescue ArgumentError, RuntimeError, Train::UserError => e
  $stderr.puts e.message
  exit 1
rescue StandardError => e
  pretty_handle_exception(e)
end

#env(shell = nil) ⇒ Object

# File 'lib/inspec/cli.rb', line 332

def env(shell = nil)
  p = Inspec::EnvPrinter.new(self.class, shell)
  p.print_and_exit!
rescue StandardError => e
  pretty_handle_exception(e)
end

#exec(*targets) ⇒ Object

# File 'lib/inspec/cli.rb', line 257

def exec(*targets)
  o = config
  diagnose(o)
  configure_logger(o)

  runner = Inspec::Runner.new(o)
  targets.each { |target| runner.add_target(target) }

  exit runner.run
rescue ArgumentError, RuntimeError, Train::UserError => e
  $stderr.puts e.message
  exit 1
rescue StandardError => e
  pretty_handle_exception(e)
end

#json(target) ⇒ Object

# File 'lib/inspec/cli.rb', line 48

def json(target)
  o = config
  diagnose(o)
  o['log_location'] = STDERR
  configure_logger(o)

  o[:backend] = Inspec::Backend.create(Inspec::Config.mock)
  o[:check_mode] = true
  o[:vendor_cache] = Inspec::Cache.new(o[:vendor_cache])

  profile = Inspec::Profile.for_target(target, o)
  info = profile.info
  # add in inspec version
  info[:generator] = {
    name: 'inspec',
    version: Inspec::VERSION,
  }
  dst = o[:output].to_s
  if dst.empty?
    puts JSON.dump(info)
  else
    if File.exist? dst
      puts "----> updating #{dst}"
    else
      puts "----> creating #{dst}"
    end
    fdst = File.expand_path(dst)
    File.write(fdst, JSON.dump(info))
  end
rescue StandardError => e
  pretty_handle_exception(e)
end

#schema(name) ⇒ Object

# File 'lib/inspec/cli.rb', line 340

def schema(name)
  puts Inspec::Schema.json(name)
rescue StandardError => e
  puts e
  puts "Valid schemas are #{Inspec::Schema.names.join(', ')}"
end

#shell_func ⇒ Object

# File 'lib/inspec/cli.rb', line 304

def shell_func
  o = config
  diagnose(o)
  o[:debug_shell] = true

  log_device = suppress_log_output?(o) ? nil : STDOUT
  o[:logger] = Logger.new(log_device)
  o[:logger].level = get_log_level(o[:log_level])

  if o[:command].nil?
    runner = Inspec::Runner.new(o)
    return Inspec::Shell.new(runner).start
  end

  run_type, res = run_command(o)
  exit res unless run_type == :ruby_eval

  # No InSpec tests - just print evaluation output.
  res = (res.respond_to?(:to_json) ? res.to_json : JSON.dump(res)) if o['reporter']&.keys&.include?('json')
  puts res
  exit 0
rescue RuntimeError, Train::UserError => e
  $stderr.puts e.message
rescue StandardError => e
  pretty_handle_exception(e)
end

#vendor(path = nil) ⇒ Object

# File 'lib/inspec/cli.rb', line 136

def vendor(path = nil)
  o = config
  configure_logger(o)
  o[:logger] = Logger.new(STDOUT)
  o[:logger].level = get_log_level(o[:log_level])

  vendor_deps(path, o)
end

#version ⇒ Object

# File 'lib/inspec/cli.rb', line 349

def version
  if config['format'] == 'json'
    v = { version: Inspec::VERSION }
    puts v.to_json
  else
    puts Inspec::VERSION
    # display outdated version
    latest = LatestInSpecVersion.new.latest
    if Gem::Version.new(Inspec::VERSION) < Gem::Version.new(latest)
      puts "\nYour version of InSpec is out of date! The latest version is #{latest}."
    end
  end
end