cem_acpt 0.7.2 → 0.8.0

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'
 
@@ -14,7 +14,17 @@ module CemAcpt
   # This module contains the classes and methods for building test node images
   module ImageBuilder
     def self.build_images(config)
-      TerraformBuilder.new(config).run
+      include CemAcpt::Logging
+
+      builder = TerraformBuilder.new(config)
+      builder.run
+      logger.info('CemAcpt::ImageBuilder') { "Image builder finished after #{builder.duration} seconds" }
+      if builder.exit_code.zero?
+        logger.info('CemAcpt::ImageBuilder') { 'Image builder finished successfully' }
+      else
+        logger.error('CemAcpt::ImageBuilder') { "Image builder finished with exit code #{builder.exit_code}" }
+      end
+      exit builder.exit_code
     end
 
     # This class builds test node images using Terraform
@@ -27,6 +37,8 @@ module CemAcpt
       DEFAULT_VARS_FILE = 'imagevars.json'
       include CemAcpt::Logging
 
+      attr_reader :exit_code, :duration
+
       def initialize(config)
         @config = config
         @image_terraform_dir = File.join(config.get('terraform.dir'), 'image', config.get('platform.name'))
@@ -36,43 +48,56 @@ module CemAcpt
         @linux_tfvars = { node_data: {} }
         @windows_tfvars = { node_data: {} }
         @duration = 0
-        @exit_code = 0
+        @exit_code = 1
         @private_key = nil
         @public_key = nil
       end
 
       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)
+        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)
+              @exit_code = 0
             end
+          ensure
+            terraform_destroy(os_str, tfvars) unless @config.get('no_destroy_nodes')
           end
         end
+      rescue StandardError => e
+        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
+          @duration = Time.now - @start_time
+        else
+          @duration = 0
+        end
+        logger.end_ci_group
       end
 
       private
@@ -84,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?
@@ -110,29 +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
 
@@ -177,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
 
@@ -190,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
@@ -201,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
@@ -262,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
 
@@ -273,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
 
@@ -283,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
 
@@ -294,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

@@ -40,7 +40,23 @@ module CemAcpt
             commands << "sudo systemctl start #{file} && sudo systemctl enable #{file}"
           end
         end
-        commands << "sudo #{puppet_bin_path} apply #{destination_provision_directory}/#{puppet_manifest_file}"
+        commands << apply_command
+      end
+
+      private
+
+      def apply_command
+        cmd = [
+          'sudo',
+          puppet_bin_path,
+          'apply',
+          '--logdest',
+          'console,/opt/cem_acpt/provision_apply.log',
+        ]
+        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
     end
   end