inspec-core 3.7.1 → 3.7.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7442d912c4bfc6a39ee598dc8a15da983d73e368a33219870849147466e0da1
-  data.tar.gz: 3d7dee5115625ed08a8af8a8ba883324862232cb728e50b4d0ce34beb6d80fde
+  metadata.gz: cc2e24a1d0645cf7af9be7f62ba7552950180e2691f40202035a9829d4281f0d
+  data.tar.gz: 97c73d5944fc426dc72ba45db473dbd4bf0688b8da2119f64aced481a4b64989
 SHA512:
-  metadata.gz: 6b92f9ef32f1a79171a4d28fd4a1de61822489a22500e6578abbde8f475b574441730fbfd8bc02f6a2545a65773132e698a21ec7c65122340ad83400ab7b3c95
-  data.tar.gz: 4e9daea0b2fb3a75c3c9d50058b1b797dbae40cae81a8aee4d196f21b036d72603552f8bb888044f1fd47a1ce50deb7977221805ac0a7d86d8839a2a3d590e9b
+  metadata.gz: 4ac5832d0b35aead187e3c262a4febfcf4133d32296ac0ebf4a2532e816415410530d4d9ec146e516b66332708f926c035a530b4fbeec4b3bbfffaecb6b4c263
+  data.tar.gz: e6db3be4591461e56cc43f0c1258e43bf7fd625d2e7c24497b22c89c4b7be02272d327aa04ea143252ba5046911da3f12a8e04b71a9c0eb3c6c850bff7489530

data/lib/inspec/config.rb

@@ -30,6 +30,17 @@ module Inspec
       Inspec::Config.new({ backend: :mock }.merge(opts), StringIO.new('{}'))
     end
 
+    # Use this to get a cached version of the config.  This prevents you from
+    # being required to pass it around everywhere.
+    def self.cached
+      @cached_config
+    end
+
+    def self.cached=(cfg)
+      @cached_config ||= cfg
+    end
+
+    # This gets called when the first config is created.
     def initialize(cli_opts = {}, cfg_io = nil, command_name = nil)
       @command_name = command_name || (ARGV.empty? ? nil : ARGV[0].to_sym)
       @defaults = Defaults.for_command(@command_name)
@@ -40,6 +51,7 @@ module Inspec
 
       @merged_options = merge_options
       @final_options = finalize_options
+      self.class.cached = self
     end
 
     def diagnose

data/lib/inspec/shell.rb

@@ -80,19 +80,6 @@ module Inspec
       "\e[1m\e[39m#{x}\e[0m"
     end
 
-    def print_example(example)
-      # determine min whitespace that can be removed
-      min = nil
-      example.lines.each do |line|
-        if !line.strip.empty? # ignore empty lines
-          line_whitespace = line.length - line.lstrip.length
-          min = line_whitespace if min.nil? || line_whitespace < min
-        end
-      end
-      # remove whitespace from each line
-      example.gsub(/\n\s{#{min}}/, "\n")
-    end
-
     def intro
       puts 'Welcome to the interactive InSpec Shell'
       puts "To find out how to use it, type: #{mark 'help'}"
@@ -142,8 +129,8 @@ module Inspec
         end
 
         unless topic_info.example.nil?
-          info += "#{mark 'Example:'}\n"
-          info += "#{print_example(topic_info.example)}\n\n"
+          info += "#{mark 'Example:'}\n\n"
+          info += "#{topic_info.example}\n\n"
         end
 
         info += "#{mark 'Web Reference:'}\n\n"

data/lib/inspec/version.rb

@@ -4,5 +4,5 @@
 # author: Christoph Hartmann
 
 module Inspec
-  VERSION = '3.7.1'
+  VERSION = '3.7.11'
 end

data/lib/plugins/inspec-habitat/Berksfile

@@ -0,0 +1,5 @@
+source 'https://supermarket.chef.io'
+
+group :integration do
+  cookbook 'inspec_habitat_fixture', path: 'test/cookbooks/inspec_habitat_fixture/'
+end

data/lib/plugins/inspec-habitat/README.md

@@ -0,0 +1,150 @@
+# InSpec Habitat Plugin
+
+## Summary
+
+This plugin allows you to do the following:
+  1. Add Habitat configuration to a profile
+  2. Create/Upload a Habitat package from an InSpec profile
+
+Creating a [Habitat](https://www.habitat.sh/) package from an InSpec profile
+allows you to execute that profile as a service (via a Habitat Supervisor) on
+any Linux based platform.
+
+When running as a service, an InSpec report will be created in JSON format (by
+default at `/hab/svc/YOUR_SERVICE/logs/inspec_last_run.json`).  Additionally, a
+log of the last run will be located at
+`/hab/svc/YOUR_SERVICE/logs/inspec_log.txt` and CLI output is viewable in
+the Supervisor logs by default. You can also configure this service to report
+to [Chef Automate](https://www.chef.io/automate/).
+
+See below for usage instructions.
+
+## Plugin Usage
+
+### Adding Habitat Configuration to an InSpec Profile
+
+Run the following command:
+
+```
+inspec habitat profile setup PATH
+```
+
+This will create the following files:
+  - habitat/plan.sh (Provides build time instructions to Habitat)
+  - habitat/default.toml (Used to configure the running Habitat service)
+  - habitat/hooks/run (Shell script to execute this profile as a service)
+  - habitat/config/inspec_exec_config.json (JSON for `inspec exec` CLI options)
+
+### Creating a Habitat Package
+
+> This command requires Habitat to be installed and configured. For instructions
+on how to do that see [here](https://www.habitat.sh/docs/install-habitat/).
+
+Run the following command:
+
+```
+inspec habitat profile create PATH
+```
+
+This command will:
+  - Create a Habitat artifact (`.hart` file).
+
+> NOTE: If you are fetching packages from Chef Automate see
+[below](#Integrating-with-Chef-Automate).
+
+### Uploading a Habitat Package
+
+> This command requires Habitat to be installed and configured. For instructions
+on how to do that see [here](https://www.habitat.sh/docs/install-habitat/).
+
+Run the following command:
+
+```
+inspec habitat profile upload PATH
+```
+
+This command will:
+  - Create a Habitat artifact (`.hart` file).
+  - Upload the Habitat artifact to [bldr.habitat.sh](bldr.habitat.sh).
+
+> NOTE: If you are fetching packages from Chef Automate see
+[below](#Integrating-with-Chef-Automate).
+
+## Habitat Package Usage
+
+> This command requires Habitat to be installed and configured. For instructions
+on how to do that see [here](https://www.habitat.sh/docs/install-habitat/).
+
+General usage instructions for using Habitat packages can be found
+[here](https://www.habitat.sh/docs/using-habitat/#Using-Habitat-Packages).
+
+Installing the package from a HART file:
+
+```
+# See Habitat docs for more info. The below is for testing only.
+hab pkg install PATH_TO_CREATED_HART_FILE
+hab sup run YOUR_ORIGIN/inspec-profile-YOUR_PROFILE_NAME
+```
+
+Installing the package from the Public Builder Depot:
+
+```
+# See Habitat docs for more info. The below is for testing only.
+hab pkg install YOUR_ORIGIN/inspec-profile-YOUR_PROFILE_NAME
+hab sup run YOUR_ORIGIN/inspec-profile-YOUR_PROFILE_NAME
+```
+
+## Integrating with Chef Automate
+
+### Fetching Profiles from Chef Automate During Build
+
+Fetching profiles from Chef Automate requires authentication.
+
+Run the following commands prior to creating/uploading your Habitat package:
+
+```
+# Remove -k if you are not using a self-signed certificate
+inspec compliance login -k --user USER --token API_TOKEN https://AUTOMATE_FQDN
+export HAB_STUDIO_SECRET_COMPLIANCE_CREDS=$(cat ~/.inspec/compliance/config.json)
+```
+
+### Sending InSpec Reports to Chef Automate
+
+After running your Habitat package as a service you can configure it to report
+to Chef Automate via a
+[configuration update](https://www.habitat.sh/docs/using-habitat/#config-updates).
+
+For example, create a TOML file (config.toml) that matches the below:
+
+```
+[automate]
+url = 'https://chef-automate.test'
+token = 'TOKEN'
+user = 'admin'
+```
+
+Then apply it like so:
+
+```
+# The '1' here is the config version (increment this with each change)
+hab config apply inspec-profile-PROFILE_NAME.default 1 /path/to/config.toml
+```
+
+This will apply the configuration to all services in the service group. For
+more info on service groups see the
+[Habitat docs](https://www.habitat.sh/docs/using-habitat/#service-groups)
+
+## Testing
+
+Lint, unit, and functional tests are ran from the root of the InSpec source:
+
+```
+bundle exec rake test
+```
+
+To execute the integration tests (Test Kitchen + Vagrant + VirtualBox) run the
+following from the directory containing this README.md:
+
+```
+bundle exec kitchen test
+```

data/lib/plugins/inspec-habitat/kitchen.yml

@@ -0,0 +1,28 @@
+---
+driver:
+  name: vagrant
+
+provisioner:
+  name: chef_solo
+  sudo: true
+
+verifier:
+  name: inspec
+
+platforms:
+  - name: ubuntu-18.04
+
+lifecycle:
+  # Build the InSpec gem so it is available to install during `kitchen converge`
+  pre_create:
+    - cd ../../../ && gem build inspec.gemspec
+    - mv ../../../inspec-*.gem test/cookbooks/inspec_habitat_fixture/files/inspec-local.gem
+  post_converge:
+    - local: sleep 10 # Wait for Habitat to load/run hab service before `verify`
+
+suites:
+  - name: default
+    run_list:
+      - recipe[inspec_habitat_fixture]
+    attributes:
+

data/lib/plugins/inspec-habitat/lib/inspec-habitat/cli.rb

@@ -10,21 +10,21 @@ module InspecPlugins
         "#{basename} habitat profile #{command.usage}"
       end
 
-      desc 'create PATH', 'Create a one-time Habitat artifact for the profile found at PATH'
+      desc 'create PATH', 'Create a Habitat artifact for the profile found at PATH'
       option :output_dir, type: :string, required: false,
-        desc: 'Directory in which to save the generated Habitat artifact. Default: current directory'
-      def create(path)
-        InspecPlugins::Habitat::Profile.create(path, options)
+        desc: 'Output directory for the Habitat artifact. Default: current directory'
+      def create(path = '.')
+        InspecPlugins::Habitat::Profile.new(path, options).create
       end
 
       desc 'setup PATH', 'Configure the profile at PATH for Habitat, including a plan and hooks'
-      def setup(path)
-        InspecPlugins::Habitat::Profile.setup(path)
+      def setup(path = '.')
+        InspecPlugins::Habitat::Profile.new(path, options).setup
       end
 
-      desc 'upload PATH', 'Create a one-time Habitat artifact for the profile found at PATH, and upload it to a Habitat Depot'
-      def upload(path)
-        InspecPlugins::Habitat::Profile.upload(path, options)
+      desc 'upload PATH', 'Create then upload a Habitat artifact for the profile found at PATH to the Habitat Builder Depot'
+      def upload(path = '.')
+        InspecPlugins::Habitat::Profile.new(path, options).upload
       end
     end
 

data/lib/plugins/inspec-habitat/lib/inspec-habitat/profile.rb

@@ -1,238 +1,226 @@
 # encoding: utf-8
-# author: Adam Leff
 
 require 'inspec/profile_vendor'
 require 'mixlib/shellout'
 require 'tomlrb'
+require 'ostruct'
 
 module InspecPlugins
   module Habitat
     class Profile
-      attr_reader :options, :path, :profile
-
-      def self.create(path, options = {})
-        creator = new(path, options)
-        hart_file = creator.create
-        creator.copy(hart_file)
-      ensure
-        creator.delete_work_dir
-      end
-
-      def self.setup(path)
-        new(path).setup
-      end
-
-      def self.upload(path, options = {})
-        uploader = new(path, options)
-        uploader.upload
-      ensure
-        uploader.delete_work_dir
-      end
-
+      attr_reader :logger
       def initialize(path, options = {})
         @path    = path
         @options = options
-        @cli_config = nil
-
-        log_level = options.fetch('log_level', 'info')
-        @log = Inspec::Log
-        @log.level(log_level.to_sym)
+        @logger  = Inspec::Log
+        logger.level(options.fetch(:log_level, 'info').to_sym)
       end
 
       def create
-        @log.info("Creating a Habitat artifact for profile: #{path}")
-
-        validate_habitat_installed
-        validate_habitat_origin
-        create_profile_object
-        verify_profile
-        vendor_profile_dependencies
-        copy_profile_to_work_dir
-        create_habitat_directories(work_dir)
-        create_plan(work_dir)
-        create_run_hook(work_dir)
-        create_default_config(work_dir)
-
-        # returns the path to the .hart file in the work directory
-        build_hart
+        logger.info("Creating a Habitat artifact for '#{@path}'...")
+
+        # Need to create working directory first so `ensure` doesn't error
+        working_dir = create_working_dir
+
+        habitat_config = read_habitat_config
+        verify_habitat_setup(habitat_config)
+
+        output_dir = @options[:output_dir] || Dir.pwd
+        unless File.directory?(output_dir)
+          exit_with_error("Output directory #{output_dir} is not a directory " \
+                          'or does not exist.')
+        end
+
+        duplicated_profile = duplicate_profile(@path, working_dir)
+        prepare_profile!(duplicated_profile)
+
+        hart_file = build_hart(working_dir, habitat_config)
+
+        logger.debug("Copying artifact to #{output_dir}...")
+        destination = File.join(output_dir, File.basename(hart_file))
+        FileUtils.cp(hart_file, destination)
+
+        logger.info("Habitat artifact '#{@destination}' created.")
+        destination
       rescue => e
-        @log.debug(e.backtrace.join("\n"))
-        exit_with_error(
-          'Unable to generate Habitat artifact.',
-          "#{e.class} -- #{e.message}",
-        )
+        logger.debug(e.backtrace.join("\n"))
+        exit_with_error('Unable to create Habitat artifact.')
+      ensure
+        if Dir.exist?(working_dir)
+          logger.debug("Deleting working directory #{working_dir}")
+          FileUtils.rm_rf(working_dir)
+        end
       end
 
-      def copy(hart_file)
-        validate_output_dir
+      def setup(profile = profile_from_path(@path))
+        path = profile.root_path
+        logger.debug("Setting up #{path} for Habitat...")
+
+        plan_file = File.join(path, 'habitat', 'plan.sh')
+        logger.info("Generating Habitat plan at #{plan_file}...")
+        vars = {
+          profile: profile,
+          habitat_origin: read_habitat_config['origin'],
+        }
+        create_file_from_template(plan_file, 'plan.sh.erb', vars)
 
-        @log.info("Copying artifact to #{output_dir}...")
-        copy_hart(hart_file)
+        run_hook_file = File.join(path, 'habitat', 'hooks', 'run')
+        logger.info("Generating a Habitat run hook at #{run_hook_file}...")
+        create_file_from_template(run_hook_file, 'hooks/run.erb')
+
+        default_toml = File.join(path, 'habitat', 'default.toml')
+        logger.info("Generating a Habitat default.toml at #{default_toml}...")
+        create_file_from_template(default_toml, 'default.toml.erb')
+
+        config = File.join(path, 'habitat', 'config', 'inspec_exec_config.json')
+        logger.info("Generating #{config} for `inspec exec`...")
+        create_file_from_template(config, 'config/inspec_exec_config.json.erb')
       end
 
       def upload
-        validate_habitat_auth_token
-        hart_file = create
-        upload_hart(hart_file)
+        habitat_config = read_habitat_config
+
+        if habitat_config['auth_token'].nil?
+          exit_with_error(
+            'Unable to determine Habitat auth token for uploading.',
+            'Run `hab setup` or set the HAB_AUTH_TOKEN environment variable.',
+          )
+        end
+
+        # Run create command to create habitat artifact
+        hart = create
+
+        logger.info("Uploading Habitat artifact #{hart}...")
+        upload_hart(hart, habitat_config)
+        logger.info("Habitat artifact #{hart} uploaded.")
       rescue => e
-        @log.debug(e.backtrace.join("\n"))
-        exit_with_error(
-          'Unable to upload Habitat artifact.',
-          "#{e.class} -- #{e.message}",
-        )
+        logger.debug(e.backtrace.join("\n"))
+        exit_with_error('Unable to upload Habitat artifact.')
       end
 
-      def delete_work_dir
-        @log.debug("Deleting work directory #{work_dir}")
-        FileUtils.rm_rf(work_dir) if Dir.exist?(work_dir)
+      private
+
+      def create_working_dir
+        working_dir = Dir.mktmpdir
+        logger.debug("Generated working directory #{working_dir}")
+        working_dir
       end
 
-      def setup
-        @log.info("Setting up profile at #{path} for Habitat...")
-        create_profile_object
-        verify_profile
-        vendor_profile_dependencies
-        create_habitat_directories(path)
-        create_plan(path)
-        create_run_hook(path)
-        create_default_config(path)
+      def duplicate_profile(path, working_dir)
+        profile = profile_from_path(path)
+        copy_profile_to_working_dir(profile, working_dir)
+        profile_from_path(working_dir)
       end
 
-      private
+      def prepare_profile!(profile)
+        vendored_profile = vendor_profile_dependencies!(profile)
+        verify_profile(vendored_profile)
+        setup(vendored_profile)
+      end
 
-      def create_profile_object
-        @profile = Inspec::Profile.for_target(
+      def profile_from_path(path)
+        Inspec::Profile.for_target(
           path,
           backend: Inspec::Backend.create(Inspec::Config.mock),
         )
       end
 
-      def verify_profile
-        @log.info('Checking to see if the profile is valid...')
+      def copy_profile_to_working_dir(profile, working_dir)
+        logger.debug('Copying profile contents to the working directory...')
+        profile.files.each do |profile_file|
+          next if File.extname(profile_file) == '.hart'
+
+          src = File.join(profile.root_path, profile_file)
+          dst = File.join(working_dir, profile_file)
+          if File.directory?(profile_file)
+            logger.debug("Creating directory #{dst}")
+            FileUtils.mkdir_p(dst)
+          else
+            logger.debug("Copying file #{src} to #{dst}")
+            FileUtils.cp_r(src, dst)
+          end
+        end
+      end
+
+      def verify_profile(profile)
+        logger.debug('Checking to see if the profile is valid...')
 
         unless profile.check[:summary][:valid]
-          exit_with_error('Profile check failed. Please fix the profile before creating a Habitat artifact.')
+          exit_with_error('Profile check failed. Please fix the profile ' \
+                          'before creating a Habitat artifact.')
         end
 
-        @log.info('Profile is valid.')
+        logger.debug('Profile is valid.')
       end
 
-      def vendor_profile_dependencies
-        profile_vendor = Inspec::ProfileVendor.new(path)
+      def vendor_profile_dependencies!(profile)
+        profile_vendor = Inspec::ProfileVendor.new(profile.root_path)
         if profile_vendor.lockfile.exist? && profile_vendor.cache_path.exist?
-          @log.info("Profile's dependencies are already vendored, skipping vendor process.")
+          logger.debug("Profile's dependencies are already vendored, skipping " \
+                    'vendor process.')
         else
-          @log.info("Vendoring the profile's dependencies...")
+          logger.debug("Vendoring the profile's dependencies...")
           profile_vendor.vendor!
 
-          @log.info('Ensuring all vendored content has read permissions...')
+          logger.debug('Ensuring all vendored content has read permissions...')
           profile_vendor.make_readable
-
-          # refresh the profile object since the profile now has new files
-          create_profile_object
         end
+
+        # Return new profile since it has changed
+        Inspec::Profile.for_target(
+          profile.root_path,
+          backend: Inspec::Backend.create(Inspec::Config.mock),
+        )
       end
 
-      def validate_habitat_installed
-        @log.info('Checking to see if Habitat is installed...')
+      def verify_habitat_setup(habitat_config)
+        logger.debug('Checking to see if Habitat is installed...')
         cmd = Mixlib::ShellOut.new('hab --version')
         cmd.run_command
-        exit_with_error('Unable to run Habitat commands.', cmd.stderr) if cmd.error?
-      end
-
-      def validate_habitat_origin
-        exit_with_error(
-          'Unable to determine Habitat origin name.',
-          'Run `hab setup` or set the HAB_ORIGIN environment variable.',
-        ) if habitat_origin.nil?
-      end
-
-      def validate_habitat_auth_token
-        exit_with_error(
-          'Unable to determine Habitat auth token for publishing.',
-          'Run `hab setup` or set the HAB_AUTH_TOKEN environment variable.',
-        ) if habitat_auth_token.nil?
-      end
-
-      def validate_output_dir
-        exit_with_error("Output directory #{output_dir} is not a directory or does not exist.") unless
-          File.directory?(output_dir)
-      end
-
-      def work_dir
-        return @work_dir if @work_dir
-
-        @work_dir ||= Dir.mktmpdir('inspec-habitat-exporter')
-        @log.debug("Generated work directory #{@work_dir}")
-
-        @work_dir
-      end
-
-      def create_habitat_directories(parent_directory)
-        [
-          File.join(parent_directory, 'habitat'),
-          File.join(parent_directory, 'habitat', 'hooks'),
-        ].each do |dir|
-          Dir.mkdir(dir) unless Dir.exist?(dir)
+        if cmd.error?
+          exit_with_error('Unable to run Habitat commands.', cmd.stderr)
         end
-      end
 
-      def copy_profile_to_work_dir
-        @log.info('Copying profile contents to the work directory...')
-        profile.files.each do |f|
-          src = File.join(profile.root_path, f)
-          dst = File.join(work_dir, f)
-          if File.directory?(f)
-            @log.debug("Creating directory #{dst}")
-            FileUtils.mkdir_p(dst)
-          else
-            @log.debug("Copying file #{src} to #{dst}")
-            FileUtils.cp_r(src, dst)
-          end
+        if habitat_config['origin'].nil?
+          exit_with_error(
+            'Unable to determine Habitat origin name.',
+            'Run `hab setup` or set the HAB_ORIGIN environment variable.',
+          )
         end
       end
 
-      def create_plan(directory)
-        plan_file = File.join(directory, 'habitat', 'plan.sh')
-        @log.info("Generating Habitat plan at #{plan_file}...")
-        File.write(plan_file, plan_contents)
+      def create_file_from_template(file, template, vars = {})
+        FileUtils.mkdir_p(File.dirname(file))
+        template_path = File.join(__dir__, '../../templates/habitat', template)
+        contents = ERB.new(File.read(template_path))
+                      .result(OpenStruct.new(vars).instance_eval { binding })
+        File.write(file, contents)
       end
 
-      def create_run_hook(directory)
-        run_hook_file = File.join(directory, 'habitat', 'hooks', 'run')
-        @log.info("Generating a Habitat run hook at #{run_hook_file}...")
-        File.write(run_hook_file, run_hook_contents)
-      end
-
-      def create_default_config(directory)
-        default_toml = File.join(directory, 'habitat', 'default.toml')
-        @log.info("Generating Habitat's default.toml configuration...")
-        File.write(default_toml, 'sleep_time = 300')
-      end
-
-      def build_hart
-        @log.info('Building our Habitat artifact...')
+      def build_hart(working_dir, habitat_config)
+        logger.debug('Building our Habitat artifact...')
 
         env = {
           'TERM'               => 'vt100',
-          'HAB_ORIGIN'         => habitat_origin,
+          'HAB_ORIGIN'         => habitat_config['origin'],
           'HAB_NONINTERACTIVE' => 'true',
         }
 
-        env['RUST_LOG'] = 'debug' if @log.level == :debug
+        env['RUST_LOG'] = 'debug' if logger.level == :debug
 
         # TODO: Would love to use Mixlib::ShellOut here, but it doesn't
         # seem to preserve the STDIN tty, and docker gets angry.
-        Dir.chdir(work_dir) do
+        Dir.chdir(working_dir) do
           unless system(env, 'hab pkg build .')
             exit_with_error('Unable to build the Habitat artifact.')
           end
         end
 
-        hart_files = Dir.glob(File.join(work_dir, 'results', '*.hart'))
+        hart_files = Dir.glob(File.join(working_dir, 'results', '*.hart'))
 
         if hart_files.length > 1
-          exit_with_error('More than one Habitat artifact was created which was not expected.')
+          exit_with_error('More than one Habitat artifact was created which ' \
+                          'was not expected.')
         elsif hart_files.empty?
           exit_with_error('No Habitat artifact was created.')
         end
@@ -240,21 +228,16 @@ module InspecPlugins
         hart_files.first
       end
 
-      def copy_hart(working_dir_hart)
-        hart_basename = File.basename(working_dir_hart)
-        dst = File.join(output_dir, hart_basename)
-        FileUtils.cp(working_dir_hart, dst)
-
-        dst
-      end
+      def upload_hart(hart_file, habitat_config)
+        logger.debug("Uploading '#{hart_file}' to the Habitat Builder Depot...")
 
-      def upload_hart(hart_file)
-        @log.info('Uploading the Habitat artifact to our Depot...')
+        config = habitat_config
 
         env = {
-          'TERM'               => 'vt100',
-          'HAB_AUTH_TOKEN'     => habitat_auth_token,
+          'HAB_AUTH_TOKEN'     => config['auth_token'],
           'HAB_NONINTERACTIVE' => 'true',
+          'HAB_ORIGIN'         => config['origin'],
+          'TERM'               => 'vt100',
         }
 
         env['HAB_DEPOT_URL'] = ENV['HAB_DEPOT_URL'] if ENV['HAB_DEPOT_URL']
@@ -269,124 +252,25 @@ module InspecPlugins
           )
         end
 
-        @log.info('Upload complete!')
-      end
-
-      def habitat_origin
-        ENV['HAB_ORIGIN'] || habitat_cli_config['origin']
-      end
-
-      def habitat_auth_token
-        ENV['HAB_AUTH_TOKEN'] || habitat_cli_config['auth_token']
-      end
-
-      def habitat_cli_config
-        return @cli_config if @cli_config
-
-        config_file = File.join(ENV['HOME'], '.hab', 'etc', 'cli.toml')
-        return {} unless File.exist?(config_file)
-
-        @cli_config = Tomlrb.load_file(config_file)
+        logger.debug('Upload complete!')
       end
 
-      def output_dir
-        options[:output_dir] || Dir.pwd
+      def read_habitat_config
+        cli_toml = File.join(ENV['HOME'], '.hab', 'etc', 'cli.toml')
+        cli_toml = '/hab/etc/cli.toml' unless File.exist?(cli_toml)
+        cli_config = File.exist?(cli_toml) ? Tomlrb.load_file(cli_toml) : {}
+        cli_config['origin'] ||= ENV['HAB_ORIGIN']
+        cli_config['auth_token'] ||= ENV['HAB_AUTH_TOKEN']
+        cli_config
       end
 
       def exit_with_error(*errors)
         errors.each do |error_msg|
-          @log.error(error_msg)
+          logger.error(error_msg)
         end
 
         exit 1
       end
-
-      def package_name
-        "inspec-profile-#{profile.name}"
-      end
-
-      def plan_contents
-        plan = <<~EOL
-          pkg_name=#{package_name}
-          pkg_version=#{profile.version}
-          pkg_origin=#{habitat_origin}
-          pkg_deps=(chef/inspec)
-        EOL
-
-        plan += "pkg_license='#{profile.metadata.params[:license]}'\n\n" if profile.metadata.params[:license]
-
-        plan += <<~EOL
-          do_setup_environment() {
-            ARCHIVE_PATH="$HAB_CACHE_SRC_PATH/$pkg_dirname/$pkg_name-$pkg_version.tar.gz"
-          }
-
-          do_build() {
-            if [ ! -f $PLAN_CONTEXT/../inspec.yml ]; then
-              exit_with 'Cannot find inspec.yml. Please build from profile root.' 1
-            fi
-
-            local profile_files=($(ls $PLAN_CONTEXT/../ -I habitat -I results))
-            local profile_location="$HAB_CACHE_SRC_PATH/$pkg_dirname/build"
-            mkdir -p $profile_location
-
-            build_line "Copying profile files to $profile_location"
-            cp -R ${profile_files[@]} $profile_location
-
-            build_line "Archiving $ARCHIVE_PATH"
-            inspec archive "$HAB_CACHE_SRC_PATH/$pkg_dirname/build" \
-                           -o $ARCHIVE_PATH \
-                           --overwrite
-          }
-
-          do_install() {
-            mkdir -p $pkg_prefix/profiles
-            cp $ARCHIVE_PATH $pkg_prefix/profiles
-          }
-        EOL
-
-        plan
-      end
-
-      def run_hook_contents
-        <<~EOL
-          #!{{pkgPathFor "core/bash"}}/bin/bash
-
-          # Redirect stderr to stdout
-          # This will be captured by Habitat and viewable via `journalctl`
-          # NOTE: We might want log to "{{pkg.svc_path}}/logs" and handle rotation
-          exec 2>&1
-
-          # InSpec will try to create a .cache directory in the user's home directory
-          # so this needs to be someplace writeable by the hab user
-          export HOME={{pkg.svc_var_path}}
-
-          RESULTS_DIR="{{pkg.svc_var_path}}/inspec_results"
-          RESULTS_FILE="${RESULTS_DIR}/{{pkg.name}}.json"
-
-          # Create a directory for InSpec reporter output
-          mkdir -p $(dirname $RESULTS_FILE)
-
-          while true; do
-            echo "Executing InSpec for {{pkg.ident}}"
-            inspec exec "{{pkg.path}}/profiles/*" --reporter=json > ${RESULTS_FILE}
-
-            EXIT_STATUS=$?
-            if [ $EXIT_STATUS -eq 0 ]; then
-              echo "InSpec run completed successfully."
-            elif [ $EXIT_STATUS -eq 100 ]; then
-              echo "InSpec run completed successfully, with at least 1 failed test"
-            elif [ $EXIT_STATUS -eq 101 ]; then
-              echo "InSpec run completed successfully, with skipped tests and no failures"
-            else
-              echo "InSpec run did not complete successfully. Exited with status: $?"
-            fi
-            echo "Results located here: ${RESULTS_FILE}"
-
-            echo "Sleeping for {{cfg.sleep_time}} seconds"
-            sleep {{cfg.sleep_time}}
-          done
-        EOL
-      end
     end
   end
 end