cem_acpt 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52762f33465c435a0c6009002d7915dd249c145210493cd503936e7e816177a2
-  data.tar.gz: 6b7f8cb35ed65f914269ae0a5179a89f7ca3cc4d0f0d940bfd9a913b0c2cabf2
+  metadata.gz: f2539a6c12df56b28e4ede4dce5da549496fd1a8ebe7076da780b410bf7d5c58
+  data.tar.gz: 5fe4e01b0c307583fbe204dd893f05dce4361ab60c8d84ea9c5b5f11e806621f
 SHA512:
-  metadata.gz: e6e1a5986dda72b212bb344c8b62ddceb5ca8277be3fc392ff6f5dea61981a1666ace99f205a43d7ba63013d4fce0e509ec48819e4a96e9577fa5dbae52c180f
-  data.tar.gz: 529dbb05eabffe98ee9c7feaa1635858245d4ac20d681451a43d377c04a42f77516371c986c1a5add2c719631e8625dd454471b99fbb1e5270c8ee1d49ce4127
+  metadata.gz: 71d1fe8bf2935bded271ddf40fbb274d7c9748598dff84ff2ca5dd356c8ceb79137093ebefc33c8ee9270400b3afe2c4736578962af180a273dd9127600f542a
+  data.tar.gz: 1d09872c69652ac64e262c06474cc3fb08d0b37b6c548127fea91cd81f3b8e7fa3a79211adac934ae087f40113e5388f328cef17809c04e47f82d0d5fda0918f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cem_acpt (0.6.4)
+    cem_acpt (0.7.0)
       async-http (>= 0.60, < 0.70)
       bcrypt_pbkdf (>= 1.0, < 2.0)
       deep_merge (>= 1.2, < 2.0)

data/README.md

@@ -2,7 +2,7 @@
 
 CemAcpt is an acceptance testing library / command line application for running acceptance tests for the CEM modules.
 
-CemAcpt uses [Terraform](#terraform) for provisioning test nodes, and [Goss](#goss) to execute acceptance tests.
+CemAcpt uses [Terraform](#terraform) for provisioning test nodes, and [Goss](#goss) to execute acceptance tests. For provisioning nodes in GCP, CemAcpt also uses the [gcloud CLI](https://cloud.google.com/cli).
 
 ## Installation
 
@@ -16,7 +16,7 @@ gem install cem_acpt
 
 ### Quickstart
 
-Make sure Terraform is installed and in your PATH. Instructions for installing Terraform can be found [here](https://learn.hashicorp.com/tutorials/terraform/install-cli).Then, navigate to the root of the `cem_linux` module and run the following command:
+Make sure Terraform and the gcloud CLI are installed and in your PATH. Instructions for installing Terraform can be found [here](https://learn.hashicorp.com/tutorials/terraform/install-cli) and instructions for installing the gcloud CLI can be found [here](https://cloud.google.com/sdk/docs/install).Then, navigate to the root of the `cem_linux` module and run the following command:
 
 ```bash
 cem_acpt --config ./cem_acpt_config.yaml
@@ -26,6 +26,7 @@ cem_acpt --config ./cem_acpt_config.yaml
 
 ```bash
 cem_acpt -h | --help
+cem_acpt_image -h | --help
 ```
 
 > If you do not delete Gemfile.lock before running `bundle install`, you may encounter dependency version errors. Just delete Gemfile.lock and run `bundle install` again to get past these.
@@ -209,3 +210,41 @@ Much like `name_pattern_vars`, specifying the `image_name_builder` top-level key
 - Once node is provisioned, make HTTP get requests to the Goss server endpoints to run the tests
 - Destroy the test nodes
 - Report the results of the tests
+
+## Generating acceptance test node images
+
+CemAcpt provides the command `cem_acpt_image` that allows you to generate new acceptance test node images that are then used with the `cem_acpt` command. This is useful for when you want to test a new version of Puppet or a new OS.
+
+### Configuring the image builder
+
+Images are built according to the entries in the `images` config key. Each entry in the `images` hash should follow the following format:
+
+```yaml
+images:
+  <image family name>:
+    os: <os key string (rhel, alma, etc.)>
+    os_major_version: <os major version integer>
+    puppet_version: <puppet major version integer>
+    base_image: <base image name / family string>
+    provision_commands: <array of commands to run on the image>
+```
+
+For example, the following config would build an image for Puppet 7 on RHEL 8:
+
+```yaml
+images:
+  cem-acpt-rhel-8-puppet7-firewalld:
+    os: rhel
+    os_major_version: 8
+    puppet_version: 7
+    base_image: 'rhel-cloud/rhel-8'
+    provision_commands:
+      - 'systemctl enable firewalld'
+      - 'systemctl start firewalld'
+      - 'firewall-cmd --permanent --add-service=ssh'
+      - 'firewall-cmd --reload'
+      - 'useradd testuser1'
+      - "echo 'testuser1:P@s5W-rd$' | chpasswd"
+```
+
+See [sample_config.yaml](sample_config.yaml) for a more complete example.

data/exe/cem_acpt

@@ -1,118 +1,15 @@
-#!/usr/bin/env jruby
+#!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'deep_merge'
-require 'json'
-require 'optparse'
-require 'yaml'
 require 'cem_acpt'
+require 'cem_acpt/cli'
 
-options = {}
-parser = OptionParser.new do |opts|
-  opts.banner = 'Usage: cem_acpt [options]'
-
-  opts.on('-h', '--help', 'Show this help message') do
-    puts opts
-    exit 0
-  end
-
-  opts.on('-a', '--only-actions ACTIONS', 'Set actions. Example: -a "acpt,noop"') do |a|
-    options[:actions] ||= {}
-    options[:actions][:only] = a.split(',')
-  end
-
-  opts.on('-A', '--except-actions ACTIONS', 'Set excluded actions. Example: -A "noop,idempotent"') do |a|
-    options[:actions] ||= {}
-    options[:actions][:except] = a.split(',')
-  end
-
-  opts.on('-t', '--tests TESTS', 'Set tests. Example: -t "test1,test2"') do |t|
-    options[:tests] = t.split(',')
-  end
-
-  opts.on('-D', '--debug', 'Enable debug logging') do
-    options[:log_level] = 'debug'
-  end
-
-  opts.on('-L', '--log-file FILE', 'Log to FILE') do |file|
-    options[:log_file] = file
-  end
-
-  opts.on('-O', '--options OPTS', 'Set options. Example: -P "param1=value1,param2=value2"') do |o|
-    params = o.split(',').map { |s| s.split('=') }.to_h
-    params.transform_keys(&:to_sym).each do |k, v|
-      options[k] = v
-    end
-  end
-
-  opts.on('-p', '--platform PLATFORM', 'Set platform. Example: -p "gcp"') do |p|
-    options[:platform] = p
-  end
-
-  opts.on('-m', '--module-dir DIR', 'Set module directory. Example: -m "/tmp/module"') do |m|
-    options[:module_dir] = m
-  end
-
-  opts.on('-c', '--config-file FILE', 'Set config file. Example: -c "/tmp/config.yaml"') do |c|
-    options[:config_file] = c
-  end
-
-  opts.on('-I', '--CI', 'Run in CI mode') do
-    options[:ci_mode] = true
-    options[:log_format] = 'github_action'
-  end
-
-  opts.on('-E', '--no-destroy-nodes', 'Do not destroy nodes') do
-    options[:no_destroy_nodes] = true
-  end
-
-  opts.on('-q', '--quiet', 'Do not log to stdout') do
-    options[:quiet] = true
-  end
-
-  opts.on('-v', '--verbose', 'Enables verbose logging mode') do
-    options[:verbose] = true
-  end
-
-  opts.on('-S', '--no-epehemeral-ssh-key', 'Do not generate an ephemeral SSH key for test suites') do
-    options[:no_ephemeral_ssh_key] = true
-  end
-
-  opts.on('-V', '--version', 'Show the cem_acpt version') do
-    puts CemAcpt.version(as_str: true)
-    exit 0
-  end
-
-  opts.on('-Y', '--print-yaml-config', 'Loads and prints the config as YAML. Other specified options will be added to the config.') do
-    options[:print_yaml_config] = true
-  end
-
-  opts.on('-X', '--explain-config', 'Loads and prints the config explanation. Other specified options will be added to the config.') do
-    options[:explain_config] = true
-  end
-
-  # NOT IMPLEMENTED
-  # opts.on('-R', '--reuse-nodes', 'Reuses test nodes if compatible node inventory exists') do
-  #   options[:reuse_nodes] = true
-  # end
-end
-
-parser.parse!
-if options[:print_yaml_config]
-  options.delete(:print_yaml_config)
-  puts CemAcpt.print_config(options, format: :yaml)
-  exit 0
-end
-if options[:explain_config]
-  options.delete(:explain_config)
-  puts CemAcpt.print_config(options, format: :explain)
-  exit 0
-end
+command, options = CemAcpt::CLI.parse_opts_for(:cem_acpt)
 # Set CLI defaults
 options[:module_dir] = Dir.pwd unless options[:module_dir]
 if (options[:log_level] == 'debug' || options[:verbose]) && !options[:quiet]
-  puts '#################### RUNNING ACCEPTANCE TEST SUITE ####################'
-  puts "Using options from command line: #{options}"
+  puts '############################### RUNNING ###############################'
+  puts "Command #{File.basename(__FILE__)}:#{command} using options from command line: #{options}"
   puts '#######################################################################'
 end
-CemAcpt.run(options)
+CemAcpt.run(command, File.basename(__FILE__).to_sym, options)

data/exe/cem_acpt_image

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'cem_acpt'
+require 'cem_acpt/cli'
+
+command, options = CemAcpt::Cli.parse_opts_for(:cem_acpt_image)
+# Set CLI defaults
+options[:module_dir] = Dir.pwd unless options[:module_dir]
+if (options[:log_level] == 'debug' || options[:verbose]) && !options[:quiet]
+  puts '############################### RUNNING ###############################'
+  puts "Command #{File.basename(__FILE__)}:#{command} using options from command line: #{options}"
+  puts '#######################################################################'
+end
+CemAcpt.run(command, File.basename(__FILE__).to_sym, options)

data/lib/cem_acpt/cli.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module CemAcpt
+  module Cli
+    def self.parse_opts_for(command)
+      cmd = command
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{command} [options]"
+      
+        opts.on('-h', '--help', 'Show this help message') do
+          puts opts
+          exit 0
+        end
+
+        # Command specific options
+        case command
+        when :cem_acpt
+          opts.on('-m', '--module-dir DIR', 'Set module directory. Example: -m "/tmp/module"') do |m|
+            options[:module_dir] = m
+          end
+  
+          opts.on('-a', '--only-actions ACTIONS', 'Set actions. Example: -a "acpt,noop"') do |a|
+            options[:actions] ||= {}
+            options[:actions][:only] = a.split(',')
+          end
+        
+          opts.on('-A', '--except-actions ACTIONS', 'Set excluded actions. Example: -A "noop,idempotent"') do |a|
+            options[:actions] ||= {}
+            options[:actions][:except] = a.split(',')
+          end
+        
+          opts.on('-t', '--tests TESTS', 'Set tests. Example: -t "test1,test2"') do |t|
+            options[:tests] = t.split(',')
+          end
+        when :cem_acpt_image
+          opts.on('-U', '--no-linux', 'Do not build Linux images') do
+            options[:cem_acpt_image] ||= {}
+            options[:cem_acpt_image][:no_linux] = true
+          end
+
+          opts.on('-W', '--no-windows', 'Do not build Windows images') do
+            options[:cem_acpt_image] ||= {}
+            options[:cem_acpt_image][:no_windows] = true
+          end
+        end
+      
+        opts.on('-D', '--debug', 'Enable debug logging') do
+          options[:log_level] = 'debug'
+        end
+      
+        opts.on('-L', '--log-file FILE', 'Log to FILE') do |file|
+          options[:log_file] = file
+        end
+      
+        opts.on('-O', '--options OPTS', 'Set options. Example: -P "param1=value1,param2=value2"') do |o|
+          params = o.split(',').map { |s| s.split('=') }.to_h
+          params.transform_keys(&:to_sym).each do |k, v|
+            options[k] = v
+          end
+        end
+      
+        opts.on('-p', '--platform PLATFORM', 'Set platform. Example: -p "gcp"') do |p|
+          options[:platform] = p
+        end
+      
+        opts.on('-c', '--config-file FILE', 'Set config file. Example: -c "/tmp/config.yaml"') do |c|
+          options[:config_file] = c
+        end
+      
+        opts.on('-I', '--CI', 'Run in CI mode (modifies logging for Github Actions output)') do
+          options[:ci_mode] = true
+          options[:log_format] = 'github_action'
+        end
+      
+        opts.on('-E', '--no-destroy-nodes', 'Do not destroy nodes') do
+          options[:no_destroy_nodes] = true
+        end
+      
+        opts.on('-q', '--quiet', 'Do not log to stdout') do
+          options[:quiet] = true
+        end
+      
+        opts.on('-v', '--verbose', 'Enables verbose logging mode') do
+          options[:verbose] = true
+        end
+      
+        opts.on('-S', '--no-epehemeral-ssh-key', 'Do not generate an ephemeral SSH key for test suites') do
+          options[:no_ephemeral_ssh_key] = true
+        end
+      
+        opts.on('-V', '--version', 'Show the cem_acpt version') do
+          cmd = :version
+        end
+      
+        opts.on('-Y', '--print-yaml-config', 'Loads and prints the config as YAML. Other specified options will be added to the config.') do
+          cmd = :print_yaml_config
+        end
+      
+        opts.on('-X', '--explain-config', 'Loads and prints the config explanation. Other specified options will be added to the config.') do
+          cmd = :print_explain_config
+        end
+      
+        # NOT IMPLEMENTED
+        # opts.on('-R', '--reuse-nodes', 'Reuses test nodes if compatible node inventory exists') do
+        #   options[:reuse_nodes] = true
+        # end
+      end
+      parser.parse!
+      [cmd, options]
+    end
+  end
+end

data/lib/cem_acpt/config/base.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'yaml'
+require_relative '../core_ext'
+require_relative '../version'
+
+# Module contains the CemAcptConfig::Base class which serves as a base class for different configs.
+module CemAcpt
+  module Config
+    using CemAcpt::CoreExt::ExtendedHash
+
+    # Base class for other config classes
+    # Child classes should implement the following methods:
+    #   - valid_keys - provide an array of valid top-level keys for the config as symbols
+    #   - defaults - provide a hash of default values for the config
+    #   - env_var_prefix - provide a string to prefix environment variables with (defaults to 'CEM_ACPT').
+    #                      This will be converted to uppercase, have all non-alphanumeric characters replaced with
+    #                      underscores, and be joined with the key name with an underscore to form the environment
+    #                      variable name.
+    # However, they can override any of the methods in this class.
+    class Base
+      attr_reader :config, :env_vars
+
+      def initialize(opts: {}, config_file: nil, load_user_config: true)
+        @load_user_config = load_user_config
+        load(opts: opts, config_file: config_file)
+      end
+
+      # @return [String] The prefix for environment variables
+      def env_var_prefix
+        'CEM_ACPT'
+      end
+
+      # @return [Array<Symbol>] Valid top-level keys for the config
+      def valid_keys
+        []
+      end
+
+      # @return [Hash] The default configuration
+      def defaults
+        {}
+      end
+
+      # Load the configuration from the environment variables, config file, and opts
+      # The order of precedence is:
+      #   1. environment variables
+      #   2. user config file (config.yaml in user_config_dir)
+      #   3. specified config file (if it exists)
+      #   4. opts
+      #   5. static options (set in this class)
+      # @param opts [Hash] The options to load
+      # @param config_file [String] The config file to load
+      # @return [self] This object with the config loaded
+      def load(opts: {}, config_file: nil)
+        create_config_dirs!
+        init_config!(opts: opts, config_file: config_file)
+        add_env_vars!(@config)
+        @config.merge!(user_config) if user_config && @load_user_config
+        @config.merge!(config_from_file) if config_from_file
+        @config.merge!(@options) if @options
+        add_static_options!(@config)
+        @config.format! # Symbolize keys of all hashes
+        validate_config!
+        # Freeze the config so it can't be modified
+        # This helps with thread safety and deterministic behavior
+        @config.freeze
+        self
+      end
+      alias to_h config
+
+      # Returns a string representation of how the config was loaded
+      def explain
+        explanation = {}
+        %i[defaults env_vars user_config config_from_file options].each do |source|
+          source_vals = send(source).dup
+          next if source_vals.nil? || source_vals.empty?
+
+          # The loop below will overwrite the value of explanation[key] if the same key is found in multiple sources
+          # This is intentional, as the last source to set the value is the one that should be used
+          source_vals.each do |key, value|
+            explanation[key] = source if @config.dget(key.to_s) == value
+          end
+        end
+        explained = explanation.each_with_object([]) do |(key, value), ary|
+          ary << "Key '#{key}' from source '#{value}'"
+        end
+        explained.join("\n")
+      end
+
+      def [](key)
+        if key.is_a?(Symbol)
+          @config[key].dup
+        elsif key.is_a?(String)
+          @config.dget(key).dup
+        else
+          raise ArgumentError, "Invalid key type '#{key.class}'"
+        end
+      end
+
+      def get(dot_key)
+        @config.dget(dot_key).dup
+      end
+      alias dget get
+
+      def has?(dot_key)
+        !!get(dot_key)
+      end
+
+      def empty?
+        @config.empty?
+      end
+
+      def ci_mode?
+        !!get('ci_mode') || !!(ENV['GITHUB_ACTIONS'] || ENV['CI'])
+      end
+      alias ci? ci_mode?
+
+      def debug_mode?
+        get('log_level') == 'debug'
+      end
+      alias debug? debug_mode?
+
+      def verbose_mode?
+        !!get('verbose')
+      end
+      alias verbose? verbose_mode?
+
+      def quiet_mode?
+        !!get('quiet')
+      end
+      alias quiet? quiet_mode?
+
+      def to_yaml
+        @config.to_yaml
+      end
+
+      def to_json(*args)
+        @config.to_json(*args)
+      end
+
+      private
+
+      attr_reader :options
+
+      def user_config_dir
+        @user_config_dir ||= File.join(Dir.home, '.cem_acpt')
+      end
+
+      def user_config_file
+        @user_config_file ||= File.join(user_config_dir, 'config.yaml')
+      end
+
+      def terraform_dir
+        @terraform_dir ||= File.join(user_config_dir, 'terraform')
+      end
+
+      def module_terraform_checksum_file
+        @module_terraform_checksum_file ||= File.join(user_config_dir, 'terraform_checksum.txt')
+      end
+
+      def module_terraform_checksum
+        @module_terraform_checksum ||= new_module_terraform_checksum
+      end
+
+      def valid_env_var?(env_var)
+        env_var.start_with?('CEM_ACPT_') && ENV[env_var]
+      end
+
+      def env_var_to_dot_key(env_var)
+        env_var.sub('CEM_ACPT_', '').gsub(%r{__}, '.').downcase
+      end
+
+      def add_static_options!(config)
+        config.dset('user_config.dir', user_config_dir)
+        config.dset('user_config.file', user_config_file)
+        config.dset('provisioner', 'terraform')
+        config.dset('terraform.dir', terraform_dir)
+        set_third_party_env_vars!(config)
+      end
+
+      # Certain environment variables are used by other tools like GitHub Actions
+      # This method sets the relative config values for those environment variables.
+      # This is the last step in composing the config, so it will override any
+      # values set by the user.
+      def set_third_party_env_vars!(config)
+        if ENV['RUNNER_DEBUG'] == '1'
+          config.dset('log_level', 'debug')
+          config.dset('verbose', true)
+        end
+        if ENV['GITHUB_ACTIONS'] == 'true' || ENV['CI'] == 'true'
+          config.dset('ci_mode', true)
+        end
+      end
+
+      # Used to source the config during loading of config files.
+      # Because config may not be fully loaded yet, this method
+      # checks the options hash first, then the current config,
+      # then the environment variables for the given key
+      # @param key [String] The key to find in dot notation
+      # @return [Any] The value of the key
+      def find_option(key)
+        return @options.dget(key) if @options.dget(key)
+        return @config.dget(key) if @config.dget(key)
+        ENV.each do |k, v|
+          next unless valid_env_var?(k)
+
+          return v if env_var_to_dot_key(k) == key
+        end
+        nil
+      end
+
+      def init_config!(opts: {}, config_file: nil)
+        # Blank out the config
+        @user_config = {}
+        @config_from_file = {}
+        @options = {}
+        @config = defaults.dup
+        # Set the parameterized defaults
+        config_file = ENV["#{env_var_prefix}_CONFIG_FILE"] if config_file.nil?
+        @config.dset('config_file', config_file) if config_file
+        @options = opts || {}
+      end
+
+      def add_env_vars!(config)
+        @env_vars = {}
+        # First load known environment variables into their respective config keys
+        # Then load any environment variables that start with CEM_ACPT_<known key> into their respective config keys
+        ENV.each do |env_var, value|
+          next unless valid_env_var?(env_var)
+
+          key = env_var_to_dot_key(env_var) # Convert CEM_ACPT_<key> to <dotkey>
+          next unless valid_keys.include?(key.split('.').first.to_sym) # Skip if the key is not a known config key
+          @env_vars[key] = value
+          config.dset(key, value)
+        end
+      end
+
+      def user_config
+        return @user_config unless @user_config.nil? || @user_config.empty?
+
+        @user_config = if user_config_file && File.exist?(user_config_file)
+                        load_config_file(user_config_file)
+                      else
+                        {}
+                      end
+
+        @user_config
+      end
+
+      # def config_from_file
+      #   {}
+      # end
+
+      def load_config_file(config_file)
+        return {} if config_file.nil? || config_file.empty? || !File.exist?(File.expand_path(config_file))
+
+        loaded = load_yaml(config_file)
+        loaded.format!
+        loaded
+      end
+
+      def config_from_file
+        return @config_from_file unless @config_from_file.nil? || @config_from_file.empty?
+
+        conf_file = find_option('config_file')
+        return {} if conf_file.nil? || conf_file.empty?
+
+        unless conf_file
+          warn "Invalid config_file type '#{conf_file.class}'. Must be a String."
+          return {}
+        end
+
+        mod_dir = find_option('module_dir')
+        if mod_dir && File.exist?(File.join(mod_dir, conf_file))
+          @config_from_file = load_config_file(File.join(mod_dir, conf_file))
+        elsif File.exist?(File.expand_path(conf_file))
+          @config_from_file = load_config_file(File.expand_path(conf_file))
+        else
+          err_msg = [
+            "Config file '#{File.expand_path(conf_file)}' does not exist.",
+          ]
+          err_msg << "Config file '#{File.join(mod_dir, conf_file)}' does not exist." if mod_dir
+          raise err_msg.join("\n")
+        end
+
+        @config_from_file
+      end
+
+      def load_yaml(config_file)
+        if YAML.respond_to?(:safe_load_file) # Ruby 3.0+
+          YAML.safe_load_file(File.expand_path(config_file), permitted_classes: [Regexp])
+        else
+          YAML.safe_load(File.read(File.expand_path(config_file)), permitted_classes: [Regexp])
+        end
+      end
+
+      def validate_config!
+        return unless @config && !valid_keys.empty?
+
+        @config.each do |key, _value|
+          warn "Config key '#{key}' is not usable with this command" unless valid_keys.include?(key.to_sym)
+        end
+      end
+
+      def create_config_dirs!
+        FileUtils.mkdir_p(user_config_dir)
+        create_terraform_dir!
+      end
+
+      def create_terraform_dir!
+        raise 'Cannot create terraform dir without a user config dir' unless Dir.exist? user_config_dir
+
+        if File.exist?(module_terraform_checksum_file)
+          checksum = File.read(module_terraform_checksum_file).strip
+          return if checksum == module_terraform_checksum
+        end
+        module_terraform_dir = File.expand_path(File.join(__dir__, '..', '..', 'terraform'))
+        FileUtils.rm_rf(File.join(user_config_dir, 'terraform'))
+        FileUtils.cp_r(module_terraform_dir, user_config_dir)
+        raise 'Failed to copy terraform dir to local config dir' unless Dir.exist?(File.join(user_config_dir, 'terraform'))
+
+        @module_terraform_checksum = new_module_terraform_checksum
+        File.write(module_terraform_checksum_file, module_terraform_checksum)
+      end
+
+      def new_module_terraform_checksum
+        sha256 = Digest::SHA256.new
+        sha256 << ::CemAcpt::VERSION # This ensures the checksum changes when the gem version changes
+        path = File.join(File.expand_path(File.join(__dir__, '..', '..', 'terraform')), '**', '*')
+        files_and_dirs = Dir.glob(path)
+        raise "Failed to find terraform files at path #{path}" if files_and_dirs.empty?
+
+        files_and_dirs.each do |file|
+          sha256 << if File.directory?(file)
+                      File.basename(file)
+                    else
+                      File.read(file)
+                    end
+        end
+        sha256.hexdigest
+      end
+    end
+  end
+end