cem_acpt 0.7.3 → 0.8.1

data/lib/cem_acpt/image_builder.rb

@@ -2,11 +2,11 @@
 
 require 'fileutils'
 require 'json'
-require 'ruby-terraform'
 require_relative 'logging'
 require_relative 'platform'
 require_relative 'utils'
 require_relative 'version'
+require_relative 'provision/terraform/terraform_cmd'
 require_relative 'image_builder/exec'
 require_relative 'image_builder/provision_commands'
 
@@ -18,11 +18,11 @@ module CemAcpt
 
       builder = TerraformBuilder.new(config)
       builder.run
-      logger.info('ImageBuilder') { "Image builder finished after #{builder.duration} seconds" }
+      logger.info('CemAcpt::ImageBuilder') { "Image builder finished after #{builder.duration} seconds" }
       if builder.exit_code.zero?
-        logger.info('ImageBuilder') { 'Image builder finished successfully' }
+        logger.info('CemAcpt::ImageBuilder') { 'Image builder finished successfully' }
       else
-        logger.error('ImageBuilder') { "Image builder finished with exit code #{builder.exit_code}" }
+        logger.error('CemAcpt::ImageBuilder') { "Image builder finished with exit code #{builder.exit_code}" }
       end
       exit builder.exit_code
     end
@@ -55,42 +55,41 @@ module CemAcpt
 
       def run
         @start_time = Time.now
-        logger.with_ci_group("CemAcptImage v#{CemAcpt::VERSION} run started at #{@start_time}") do
-          @all_tfvars = new_tfvars(@config)
-          @linux_tfvars, @windows_tfvars = divide_tfvars_by_os(@all_tfvars)
-          image_types = []
-          image_types << [@linux_tfvars, 'linux'] unless no_linux?
-          image_types << [@windows_tfvars, 'windows'] unless no_windows?
-          return dry_run(image_types) if @config.get('dry_run')
-
-          @working_dir = new_working_dir
-          logger.info('CemAcptImage') { "Using working directory: #{@working_dir}..." }
-          keep_terminal_alive
-          save_vars_to_file!('linux', @linux_tfvars)
-          save_vars_to_file!('windows', @windows_tfvars)
-          terraform_init
-          image_types.each do |tfvars, os_str|
-            terraform_plan(os_str, tfvars, DEFAULT_PLAN_NAME)
-            begin
-              terraform_apply(os_str, DEFAULT_PLAN_NAME)
-              output = JSON.parse(terraform_output(os_str, 'node-data', json: true))
-              output.each do |instance_name, data|
-                logger.info('CemAcptImage') { "Stopping instance #{instance_name}..." }
-                @exec.run('compute', 'instances', 'stop', instance_name)
-                unless @config.get('no_build_images')
-                  deprecate_old_images_in_family(data['image_family'])
-                  create_image_from_disk(data['disk_link'], image_name_from_image_family(data['image_family']), data['image_family'])
-                end
-                @exit_code = 0
+        logger.start_ci_group("CemAcptImage v#{CemAcpt::VERSION} run started at #{@start_time}")
+        @all_tfvars = new_tfvars(@config)
+        @linux_tfvars, @windows_tfvars = divide_tfvars_by_os(@all_tfvars)
+        image_types = []
+        image_types << [@linux_tfvars, 'linux'] unless no_linux?
+        image_types << [@windows_tfvars, 'windows'] unless no_windows?
+        return dry_run(image_types) if @config.get('dry_run')
+
+        @working_dir = new_working_dir
+        logger.info('CemAcpt::ImageBuilder') { "Using working directory: #{@working_dir}..." }
+        keep_terminal_alive
+        save_vars_to_file!('linux', @linux_tfvars)
+        save_vars_to_file!('windows', @windows_tfvars)
+        terraform_init
+        image_types.each do |tfvars, os_str|
+          terraform_plan(os_str, tfvars, DEFAULT_PLAN_NAME)
+          begin
+            terraform_apply(os_str, DEFAULT_PLAN_NAME)
+            output = JSON.parse(terraform_output(os_str, 'node-data', json: true))
+            output.each do |instance_name, data|
+              logger.info('CemAcpt::ImageBuilder') { "Stopping instance #{instance_name}..." }
+              @exec.run('compute', 'instances', 'stop', instance_name)
+              unless @config.get('no_build_images')
+                deprecate_old_images_in_family(data['image_family'])
+                create_image_from_disk(data['disk_link'], image_name_from_image_family(data['image_family']), data['image_family'])
               end
-            ensure
-              terraform_destroy(os_str, tfvars) unless @config.get('no_destroy_nodes')
+              @exit_code = 0
             end
+          ensure
+            terraform_destroy(os_str, tfvars) unless @config.get('no_destroy_nodes')
           end
         end
       rescue StandardError => e
-        logger.error('CemAcptImage') { "Image builder failed with error: #{e}" }
-        logger.verbose('CemAcptImage') { e.backtrace.join("\n") }
+        logger.error('CemAcpt::ImageBuilder') { "Image builder failed with error: #{e}" }
+        logger.verbose('CemAcpt::ImageBuilder') { e.backtrace.join("\n") }
         @exit_code = 1
       ensure
         if @start_time
@@ -98,6 +97,7 @@ module CemAcpt
         else
           @duration = 0
         end
+        logger.end_ci_group
       end
 
       private
@@ -109,21 +109,21 @@ module CemAcpt
       end
 
       def deprecate_old_images_in_family(image_family)
-        logger.info('CemAcptImage') { "Deprecating old images in family #{image_family}..." }
+        logger.info('CemAcpt::ImageBuilder') { "Deprecating old images in family #{image_family}..." }
         images = @exec.run('compute', 'images', 'list', '--project', @config.get('platform.project'), '--filter', "family:#{image_family}")
         images.each do |image|
           next unless image['status'] == 'READY'
 
-          logger.info('CemAcptImage') { "Deprecating image #{image['name']}..." }
+          logger.info('CemAcpt::ImageBuilder') { "Deprecating image #{image['name']}..." }
           @exec.run('compute', 'images', 'deprecate', image['name'], '--state', 'DEPRECATED', '--delete-in', '1d', '--project', @config.get('platform.project'))
         end
       end
 
       def create_image_from_disk(disk_link, image_name, image_family)
-        logger.info('CemAcptImage') { "Creating image from disk #{disk_link}..." }
+        logger.info('CemAcpt::ImageBuilder') { "Creating image from disk #{disk_link}..." }
         @exec.run('compute', 'images', 'create', image_name, '--family', image_family,
                   '--source-disk', disk_link, '--project', @config.get('platform.project'))
-        logger.info('CemAcptImage') { "Image #{image_name} created for family #{image_family}"}
+        logger.info('CemAcpt::ImageBuilder') { "Image #{image_name} created for family #{image_family}"}
       end
 
       def no_windows?
@@ -135,30 +135,22 @@ module CemAcpt
       end
 
       def dry_run(image_types)
-        logger.info('CemAcptImage') { 'Dry run mode enabled. No images will be built.' }
+        logger.info('CemAcpt::ImageBuilder') { 'Dry run mode enabled. No images will be built.' }
         image_types.each do |tfvars, os_str|
-          logger.info('CemAcptImage') { "Dry run for #{os_str}..." }
-          logger.info('CemAcptImage') { "Terraform vars:\n#{JSON.pretty_generate(tfvars)}" }
+          logger.info('CemAcpt::ImageBuilder') { "Dry run for #{os_str}..." }
+          logger.info('CemAcpt::ImageBuilder') { "Terraform vars:\n#{JSON.pretty_generate(tfvars)}" }
         end
         @exit_code = 0
       end
 
       def terraform
-        return @terraform if defined?(@terraform)
-
-        RubyTerraform.configure do |c|
-          c.logger = logger
-          c.stdout = logger
-          c.stderr = logger
-        end
-        @terraform = RubyTerraform
-        @terraform
+        @terraform ||= CemAcpt::Provision::TerraformCmd.new(@image_terraform_dir, @environment)
       end
 
       def new_environment(config)
         env = (config.get('terraform.environment') || {})
         env['CLOUDSDK_PYTHON_SITEPACKAGES'] = '1' # This is needed for gcloud to use numpy
-        logger.verbose('ImageBuilder') { "Using environment:\n#{JSON.pretty_generate(env)}" }
+        logger.verbose('CemAcpt::ImageBuilder') { "Using environment:\n#{JSON.pretty_generate(env)}" }
         env
       end
 
@@ -203,7 +195,7 @@ module CemAcpt
         return unless block_given?
 
         if no_os_str?(os_str)
-          logger.debug('ImageBuilder') { "Skipping #{os_str} because no_#{os_str} is true" }
+          logger.debug('CemAcpt::ImageBuilder') { "Skipping #{os_str} because no_#{os_str} is true" }
           return
         end
 
@@ -216,7 +208,7 @@ module CemAcpt
       def terraform_init
         raise 'Cannot initialize Terraform, both no_linux and no_windows are true' if no_linux? && no_windows?
 
-        logger.debug('ImageBuilder') { 'Initializing Terraform' }
+        logger.debug('CemAcpt::ImageBuilder') { 'Initializing Terraform' }
         in_os_dir('linux') do
           terraform.init({ input: false, no_color: true })
         end
@@ -227,37 +219,37 @@ module CemAcpt
 
       def terraform_plan(os_dir, tfvars, plan_name)
         in_os_dir(os_dir) do
-          logger.debug('ImageBuilder') { "Creating Terraform plan #{plan_name} for #{os_dir}" }
-          logger.verbose('ImageBuilder') { "Using vars:\n#{JSON.pretty_generate(tfvars)}" }
+          logger.debug('CemAcpt::ImageBuilder') { "Creating Terraform plan #{plan_name} for #{os_dir}" }
+          logger.verbose('CemAcpt::ImageBuilder') { "Using vars:\n#{JSON.pretty_generate(tfvars)}" }
           terraform.plan({ input: false, no_color: true, plan: plan_name, vars: tfvars }, { environment: environment })
         end
       end
 
       def terraform_apply(os_dir, plan_name)
         in_os_dir(os_dir) do
-          logger.debug('ImageBuilder') { "Applying Terraform plan #{plan_name} for #{os_dir}" }
+          logger.debug('CemAcpt::ImageBuilder') { "Applying Terraform plan #{plan_name} for #{os_dir}" }
           terraform.apply({ input: false, no_color: true, plan: plan_name }, { environment: environment })
         end
       end
 
       def terraform_output(os_dir, output_name, json: true)
         in_os_dir(os_dir) do
-          logger.debug('ImageBuilder') { "Getting Terraform output #{output_name} for #{os_dir}" }
+          logger.debug('CemAcpt::ImageBuilder') { "Getting Terraform output #{output_name} for #{os_dir}" }
           terraform.output({ no_color: true, json: json, name: output_name }, { environment: environment })
         end
       end
 
       def terraform_destroy(os_dir, tfvars)
         in_os_dir(os_dir) do
-          logger.debug('ImageBuilder') { "Destroying Terraform resources for #{os_dir}" }
-          logger.verbose('ImageBuilder') { "Using vars:\n#{JSON.pretty_generate(tfvars)}" }
+          logger.debug('CemAcpt::ImageBuilder') { "Destroying Terraform resources for #{os_dir}" }
+          logger.verbose('CemAcpt::ImageBuilder') { "Using vars:\n#{JSON.pretty_generate(tfvars)}" }
           terraform.destroy({ auto_approve: true, input: false, no_color: true, vars: tfvars }, { environment: environment })
         end
       end
 
       def terraform_show(os_dir)
         in_os_dir(os_dir) do
-          logger.debug('ImageBuilder') { "Showing Terraform state for #{os_dir}" }
+          logger.debug('CemAcpt::ImageBuilder') { "Showing Terraform state for #{os_dir}" }
           terraform.show({ no_color: true }, { environment: environment })
         end
       end
@@ -288,7 +280,7 @@ module CemAcpt
             windows_image: windows_image?(image[:os]),
           )
         end
-        logger.verbose('ImageBuilder') { "All Terraform variables:\n#{JSON.pretty_generate(tfvars)}" }
+        logger.verbose('CemAcpt::ImageBuilder') { "All Terraform variables:\n#{JSON.pretty_generate(tfvars)}" }
         tfvars
       end
 
@@ -299,8 +291,8 @@ module CemAcpt
         linux_tfvars[:node_data] = linux_node_data
         windows_tfvars = tfvars.dup
         windows_tfvars[:node_data] = windows_node_data
-        logger.verbose('ImageBuilder') { "Linux Terraform variables:\n#{JSON.pretty_generate(linux_tfvars)}" }
-        logger.verbose('ImageBuilder') { "Windows Terraform variables:\n#{JSON.pretty_generate(windows_tfvars)}" }
+        logger.verbose('CemAcpt::ImageBuilder') { "Linux Terraform variables:\n#{JSON.pretty_generate(linux_tfvars)}" }
+        logger.verbose('CemAcpt::ImageBuilder') { "Windows Terraform variables:\n#{JSON.pretty_generate(windows_tfvars)}" }
         [linux_tfvars, windows_tfvars]
       end
 
@@ -309,10 +301,10 @@ module CemAcpt
       end
 
       def save_vars_to_file!(prefix, vars)
-        logger.debug('ImageBuilder') { "Saving vars to file #{File.join(@working_dir, "#{prefix}_#{DEFAULT_VARS_FILE}")}" }
+        logger.debug('CemAcpt::ImageBuilder') { "Saving vars to file #{File.join(@working_dir, "#{prefix}_#{DEFAULT_VARS_FILE}")}" }
         File.write(File.join(@working_dir, "#{prefix}_#{DEFAULT_VARS_FILE}"), vars.to_json)
       rescue StandardError => e
-        logger.error('ImageBuilder') { 'Error saving vars to file' }
+        logger.error('CemAcpt::ImageBuilder') { 'Error saving vars to file' }
         raise e
       end
 
@@ -320,25 +312,25 @@ module CemAcpt
         unless Dir.exist?(@image_terraform_dir)
           raise "Image Terraform directory #{@image_terraform_dir} does not exist"
         end
-        logger.debug('ImageBuilder') { "Creating new working directory in #{@image_terraform_dir}" }
+        logger.debug('CemAcpt::ImageBuilder') { "Creating new working directory in #{@image_terraform_dir}" }
         working_dir = File.join(@image_terraform_dir, "image_builder_#{Time.now.to_i}")
         FileUtils.mkdir_p(working_dir)
-        logger.verbose('ImageBuilder') { "Created working directory #{working_dir}" }
+        logger.verbose('CemAcpt::ImageBuilder') { "Created working directory #{working_dir}" }
         FileUtils.cp_r(File.join(@image_terraform_dir, 'linux'), working_dir)
         FileUtils.cp_r(File.join(@image_terraform_dir, 'windows'), working_dir)
-        logger.verbose('ImageBuilder') { "Copied Terraform files from #{@image_terraform_dir}/(linux|windows) to #{working_dir}" }
+        logger.verbose('CemAcpt::ImageBuilder') { "Copied Terraform files from #{@image_terraform_dir}/(linux|windows) to #{working_dir}" }
         if File.exist?(@all_tfvars[:private_key])
           FileUtils.cp(@all_tfvars[:private_key], working_dir)
           @private_key = File.join(working_dir, File.basename(@all_tfvars[:private_key]))
-          logger.verbose('ImageBuilder') { "Copied private key #{@all_tfvars[:private_key]} to #{working_dir}" }
+          logger.verbose('CemAcpt::ImageBuilder') { "Copied private key #{@all_tfvars[:private_key]} to #{working_dir}" }
         end
         if File.exist?(@all_tfvars[:public_key])
           FileUtils.cp(@all_tfvars[:public_key], working_dir)
           @public_key = File.join(working_dir, File.basename(@all_tfvars[:public_key]))
-          logger.verbose('ImageBuilder') { "Copied public key #{@all_tfvars[:public_key]} to #{working_dir}" }
+          logger.verbose('CemAcpt::ImageBuilder') { "Copied public key #{@all_tfvars[:public_key]} to #{working_dir}" }
         end
 
-        logger.verbose('ImageBuilder') { "Content of #{working_dir}:\n#{Dir.glob(File.join(working_dir, '*')).join("\n")}" }
+        logger.verbose('CemAcpt::ImageBuilder') { "Content of #{working_dir}:\n#{Dir.glob(File.join(working_dir, '*')).join("\n")}" }
         working_dir
       end
     end

data/lib/cem_acpt/logging.rb

@@ -13,7 +13,7 @@ module CemAcpt
       'error' => ::Logger::ERROR,
       'fatal' => ::Logger::FATAL,
       'unknown' => ::Logger::UNKNOWN,
-    }
+    }.freeze
 
     # Delegator class for when you want to log to multiple devices
     # at the same time, such as STDOUT and a file.
@@ -28,34 +28,39 @@ module CemAcpt
       def self.from_logger_configs(configs)
         return if configs.nil? || configs.empty?
 
-        loggers = configs.map do |config|
+        logger_instances = configs.map do |config|
           CemAcpt::Logging::Logger.new(config[:logdev],
                                        config[:shift_age],
                                        config[:shift_size],
                                        **config.reject { |k, _| [:logdev, :shift_age, :shift_size].include?(k) })
         end
-        new(*loggers)
+        new(*logger_instances)
       end
 
-      def initialize(*loggers)
-        @loggers = loggers
+      def initialize(*logger_instances)
+        @loggers = logger_instances
       end
 
       def logger_configs
-        @loggers.map(&:config_hash)
+        loggers.map(&:config_hash)
       end
 
       def method_missing(m, *args, &block)
-        if @loggers.all? { |l| l.respond_to?(m) }
-          @loggers.map { |l| l.send(m, *args, &block) }
+        if loggers.all? { |l| l.respond_to?(m) }
+          loggers.map { |l| l.send(m, *args, &block) }
         else
           super
         end
       end
 
       def respond_to_missing?(m, include_private = false)
-        @loggers.all? { |l| l.respond_to?(m) } || super
+        loggers.all? { |l| l.respond_to?(m) } || super
       end
+
+      private
+
+      # Basically just for making testing easier
+      attr_reader :loggers
     end
 
     # Delagator class for the standard Ruby Logger class.
@@ -89,55 +94,63 @@ module CemAcpt
       end
 
       def debug(progname = nil, &block)
-        return if log_trap_context('debug', progname, &block)
-        return if log_ci_mode('debug', progname, &block)
+        severity = 'debug'
+        return log_trap_context(severity, progname, &block) if log_trap_context?(severity)
+        return log_ci_mode(severity, progname, &block) if log_ci_mode?(severity)
 
         super
       end
 
       def info(progname = nil, &block)
-        return if log_trap_context('info', progname, &block)
-        return if log_ci_mode('info', progname, &block)
+        severity = 'info'
+        return log_trap_context(severity, progname, &block) if log_trap_context?(severity)
+        return log_ci_mode(severity, progname, &block) if log_ci_mode?(severity)
 
         super
       end
 
       def warn(progname = nil, &block)
-        return if log_trap_context('warn', progname, &block)
-        return if log_ci_mode('warn', progname, &block)
+        severity = 'warn'
+        return log_trap_context(severity, progname, &block) if log_trap_context?(severity)
+        return log_ci_mode(severity, progname, &block) if log_ci_mode?(severity)
 
         super
       end
 
       def error(progname = nil, &block)
-        return if log_trap_context('error', progname, &block)
-        return if log_ci_mode('error', progname, &block)
+        severity = 'error'
+        return log_trap_context(severity, progname, &block) if log_trap_context?(severity)
+        return log_ci_mode(severity, progname, &block) if log_ci_mode?(severity)
 
         super
       end
 
       def fatal(progname = nil, &block)
-        return if log_trap_context('fatal', progname, &block)
-        return if log_ci_mode('fatal', progname, &block)
+        severity = 'fatal'
+        return log_trap_context(severity, progname, &block) if log_trap_context?(severity)
+        return log_ci_mode(severity, progname, &block) if log_ci_mode?(severity)
 
         super
       end
 
-      # Wraps the given block in a Github Actions group if in CI mode
-      # @param name [String] the name of the group
-      def with_ci_group(name)
+      def start_ci_group(name)
         if @ci_mode
           self.<< "::group::#{name}\n"
         else
           info(name)
         end
-        yield
-      ensure
+      end
+
+      def end_ci_group
         self.<< "::endgroup::\n" if @ci_mode
       end
 
       private
 
+      def log_trap_context?(severity)
+        @trap_context && level <= LEVEL_MAP[severity]
+      end
+
       # Can't use the standard Logger methods when in trap context
       # because they don't work. So we have to write directly to the
       # raw logdev. Unlike the standard Logger methods, there is no
@@ -145,8 +158,6 @@ module CemAcpt
       # This is necessary in the trap context because using a Mutex
       # lock in a trap context will cause a deadlock.
       def log_trap_context(severity, progname = nil, &block)
-        return false unless @trap_context && level <= LEVEL_MAP[severity]
-
         if @raw_logdev.respond_to?(:puts)
           @raw_logdev.puts(ci_format(severity, false, progname, &block))
         elsif @raw_logdev.respond_to?(:write)
@@ -155,7 +166,10 @@ module CemAcpt
           # Default to logging to STDERR
           $stderr.puts(ci_format(severity, false, progname, &block))
         end
-        true
+      end
+
+      def log_ci_mode?(severity)
+        @ci_mode && level <= LEVEL_MAP[severity]
       end
 
       # CI mode uses << instead of the standard Logger methods
@@ -164,10 +178,7 @@ module CemAcpt
       # with a standard Logger, the CI mode messages are still
       # formatted correctly.
       def log_ci_mode(severity, progname = nil, &block)
-        return false unless @ci_mode && level <= LEVEL_MAP[severity]
-
         self.<<(ci_format(severity, true, progname, &block))
-        true
       end
 
       # Formats the log message for CI mode, translating the severity

data/lib/cem_acpt/platform.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'concurrent-ruby'
 require_relative 'logging'
 
 # CemAcpt::Platform manages creating and configring platform specific objects
@@ -25,7 +24,7 @@ module CemAcpt::Platform
       raise Error, 'run_data must include a :test_data key' unless run_data.key?(:test_data)
       raise Error, 'run_data[:test_data] must be an Array' unless run_data[:test_data].is_a?(Array)
 
-      logger.info "Using #{platform} for #{run_data[:test_data].length} tests..."
+      logger.info('CemAcpt::Platform') { "Using #{platform} for #{run_data[:test_data].length} tests..." }
       run_data[:test_data].dup.each_with_object([]) do |single_test_data, ary|
         ary << new_test_platform_object(platform, config, single_test_data, **run_data.reject { |k, _| k == :test_data })
       end
@@ -53,7 +52,7 @@ module CemAcpt::Platform
         File.basename(file, '.rb') unless file.end_with?('base.rb')
       end
       @platforms.compact!
-      logger.debug "Discovered platform(s): #{@platforms}"
+      logger.debug('CemAcpt::Platform') { "Discovered platform(s): #{@platforms}" }
       @platforms
     end
 
@@ -83,7 +82,7 @@ module CemAcpt::Platform
       require_relative 'platform/base'
       # If the class has already been defined, we can just use it.
       if Object.const_defined?(class_name)
-        logger.debug "Using existing platform class #{class_name}"
+        logger.debug('CemAcpt::Platform') { "Using existing platform class #{class_name}" }
         klass = Object.const_get(class_name)
       else
         # Otherwise, we need to create the class. We do this by setting
@@ -110,7 +109,7 @@ module CemAcpt::Platform
           end,
         )
       end
-      logger.debug "Using platform class: #{klass.inspect}"
+      logger.debug('CemAcpt::Platform') { "Using platform class: #{klass.inspect}" }
       klass
     end
   end

data/lib/cem_acpt/provision/terraform/linux.rb

@@ -53,8 +53,8 @@ module CemAcpt
           '--logdest',
           'console,/opt/cem_acpt/provision_apply.log',
         ]
-        cmd << '--debug' if @config.debug?
-        cmd << '--verbose' if @config.verbose?
+        cmd << '--debug' if @config.debug? && !@config.get('puppet.no_debug')
+        cmd << '--verbose' if @config.verbose? && !@config.get('puppet.no_verbose')
         cmd << "#{destination_provision_directory}/#{puppet_manifest_file}"
         cmd.join(' ')
       end

data/lib/cem_acpt/provision/terraform/terraform_cmd.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+require 'stringio'
+require_relative '../../logging'
+require_relative '../../utils/shell'
+
+module CemAcpt
+  module Provision
+    # Stand-in for ruby-terraform because ruby-terraform doesn't work with Ruby 3
+    class TerraformCmd
+      include CemAcpt::Logging
+
+      attr_accessor :working_dir
+      attr_reader :bin_path
+
+      def initialize(working_dir = nil, environment = {})
+        @working_dir = working_dir
+        @environment = environment
+        @bin_path = which_terraform
+      end
+
+      def inspect
+        to_s
+      end
+
+      def to_s
+        "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+      end
+
+      def environment=(env)
+        raise ArgumentError, 'environment must be a Hash' unless env.is_a?(Hash)
+
+        @environment = env
+      end
+
+      def environment(env = {})
+        raise ArgumentError, 'additional environment must be a Hash' unless env.is_a?(Hash)
+
+        if env.key?(:environment) && env[:environment].is_a?(Hash)
+          env = env[:environment]
+        end
+        @environment.merge(env)
+      end
+
+      def init(opts = {}, env = {})
+        run_cmd('init', opts, env)
+      end
+
+      def plan(opts = {}, env = {})
+        plan = extract_arg!(opts, :plan, required: true)
+        opts[:out] = plan
+        run_cmd('plan', opts, env)
+      end
+
+      def apply(opts = {}, env = {})
+        plan = extract_arg!(opts, :plan, required: true)
+        run_cmd('apply', opts, env, suffix: plan)
+      end
+
+      def destroy(opts = {}, env = {})
+        run_cmd('destroy', opts, env)
+      end
+
+      def show(opts = {}, env = {})
+        run_cmd('show', opts, env)
+      end
+
+      def output(opts = {}, env = {})
+        name = extract_arg!(opts, :name, required: true)
+        run_cmd('output', opts, env, suffix: name)
+      end
+
+      private
+
+      def extract_arg!(opts, key, required: false)
+        key = key.to_sym
+        raise ArgumentError, "option #{key} is required" if required && !opts.key?(key) && (opts[key].nil? || opts[key].empty?)
+
+        opts.delete(key)
+      end
+
+      def run_cmd(cmd, opts = {}, env = {}, suffix: '')
+        cmd = format_cmd(cmd, opts, suffix)
+        env = environment(env)
+        logger.debug('CemAcpt::Provision::TerraformCmd') { "Running command \"#{cmd}\" with environment \"#{env}\"" }
+        CemAcpt::Utils::Shell.run_cmd(cmd, env, output: logger)
+      end
+
+      def chdir(opts = {})
+        [extract_arg!(opts, :chdir), working_dir, Dir.pwd].each do |d|
+          next if d.nil? || d.empty?
+
+          d = File.expand_path(d)
+          return "-chdir=#{d}" if File.directory?(d)
+
+          logger.warn('CemAcpt::Provision::TerraformCmd') { "Directory #{d} does not exist, using next..." }
+        end
+      end
+
+      def which_terraform
+        path = CemAcpt::Utils::Shell.which('terraform')
+        raise 'terraform not found in PATH, make sure it is installed' if path.nil?
+
+        path
+      end
+
+      def format_cmd(cmd, opts = {}, suffix = '')
+        formatted = [bin_path, chdir(opts), cmd]
+        opts_s = opts_string(opts)
+        formatted << opts_s unless opts_s.empty?
+        formatted << suffix unless suffix.empty?
+        formatted.join(' ')
+      end
+
+      def opts_string(opts = {})
+        formatted = opts.map do |k, v|
+          next if k.nil? || k.empty?
+
+          k = k.to_s
+          k.tr!('_', '-')
+          if k == 'vars'
+            v.map { |vk, vv| "-var '#{vk}=#{vv}'" }.join(' ')
+          elsif %w[input lock refresh].include?(k) # These are boolean flags with values
+            "-#{k}=#{v}"
+          elsif v.nil? || (v.respond_to?(:empty) && v.empty?) || v.is_a?(TrueClass)
+            "-#{k}"
+          else
+            case v
+            when Array, Hash
+              "-#{k}='#{v.to_json}'"
+            else
+              "-#{k}=#{v}"
+            end
+          end
+        end
+        formatted.join(' ')
+      end
+    end
+  end
+
+  # IO monkey patch for non-blocking readline
+  class ::IO
+    def readline_nonblock
+      rlnb = []
+      while (ch = read_nonblock(1))
+        rlnb << ch
+        break if ch == "\n"
+      end
+      rlnb.join
+    end
+  end
+end