yle_tf 1.0.0 → 1.4.0

data/lib/yle_tf/backend.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'json'
+
+class YleTf
+  class Backend
+    BACKEND_CONFIG_FILE = '_backend.tf.json'
+
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def type
+      @type ||= config.fetch('backend', 'type')
+    end
+
+    def backend_specific_config
+      config.fetch('backend', type)
+    end
+
+    # Generate backend configuration file for Terraform
+    def configure
+      data = {
+        terraform: [{
+          backend: [to_h]
+        }]
+      }
+      File.write(BACKEND_CONFIG_FILE, JSON.pretty_generate(data))
+    end
+
+    # Tear down the backend
+    def tear_down
+      # Nothing to do by default
+    end
+
+    # Returns the backend configuration as a `Hash` for Terraform
+    def to_h
+      { type => backend_specific_config }
+    end
+
+    def to_s
+      to_h.to_s
+    end
+  end
+end

data/lib/yle_tf/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yle_tf'
 
 class YleTf
@@ -48,7 +50,7 @@ class YleTf
           if TF_OPTIONS.include?(arg)
             @tf_options[key(arg)] = true
           else
-            STDERR.puts "Unknown option '#{arg}'"
+            warn "Unknown option '#{arg}'"
             @tf_command = 'help'
             @tf_env = 'error'
             break

data/lib/yle_tf/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'yaml'
 
@@ -10,16 +12,23 @@ class YleTf
   class Config
     NotFoundError = Class.new(Error)
 
-    attr_reader :config, :tf_env, :module_dir
+    # Loads the configuration based on the environment
+    def self.load(tf_env)
+      opts = {
+        tf_env:     tf_env,
+        module_dir: Pathname.pwd
+      }
 
-    def initialize(tf_env)
-      Logger.debug("Initializing configuration for the #{tf_env.inspect} environment")
+      config = Loader.new(opts).load
+      new(config, **opts)
+    end
 
-      @tf_env = tf_env
-      @module_dir = Pathname.pwd
-      @config = Loader.new(tf_env: tf_env, module_dir: module_dir).load
+    attr_reader :config, :tf_env, :module_dir
 
-      Logger.debug(inspect)
+    def initialize(config, **opts)
+      @config = config
+      @tf_env = opts[:tf_env]
+      @module_dir = opts[:module_dir]
     end
 
     def to_s
@@ -33,8 +42,15 @@ class YleTf
       block ||= DEFAULT_NOT_FOUND_BLOCK
 
       keys.inject(config) do |conf, key|
-        break block.call(keys) if !conf || !conf.key?(key)
-        conf[key]
+        next conf[key] if conf.is_a?(Hash) && conf.key?(key)
+
+        if !conf.nil? && !conf.is_a?(Hash)
+          Logger.warn(
+            "Configuration [#{keys.join(' > ')}] includes non-hash element #{conf.inspect}"
+          )
+        end
+
+        break block.call(keys)
       end
     end
 

data/lib/yle_tf/config/defaults.rb

@@ -1,33 +1,47 @@
+# frozen_string_literal: true
+
+require 'yle_tf/helpers/hash'
+
 class YleTf
   class Config
     module Defaults
       DEFAULT_CONFIG = {
-        'hooks' => {
-          'pre' => [],
+        'hooks'     => {
+          'pre'  => [],
           'post' => []
         },
-        'backend' => {
+        'backend'   => {
           'type' => 'file',
-          'bucket'  => nil,
-          'file'    => '<%= @module %>_<%= @env %>.tfstate',
-          'region'  => nil,
-          'encrypt' => false,
+          'file' => {
+            'path'            => '<%= @module %>_<%= @env %>.tfstate',
+            'encrypt'         => false,
+            'encrypt_command' => 'sops --encrypt --input-type binary --output-type binary --output "{{TO}}" "{{FROM}}"',
+            'decrypt_command' => 'sops --decrypt --input-type binary --output-type binary --output "{{TO}}" "{{FROM}}"'
+          },
+          's3'   => {
+            'key' => '<%= @module %>_<%= @env %>.tfstate'
+          }
         },
-        'tfvars' => {
+        'tfvars'    => {
         },
         'terraform' => {
           'version_requirement' => nil
+        },
+        'yle_tf'    => {
+          'version_requirement' => nil
         }
       }.freeze
 
+      # Returns deep copy of the default config Hash.
       def default_config
-        DEFAULT_CONFIG.dup
+        Helpers::Hash.deep_copy(DEFAULT_CONFIG)
       end
 
       def default_config_context
         {
-          env: tf_env,
-          module: module_dir.basename.to_s,
+          env:        tf_env,
+          module:     module_dir.basename.to_s,
+          module_dir: module_dir.to_s,
         }
       end
     end

data/lib/yle_tf/config/erb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'erb'
 
 class YleTf

data/lib/yle_tf/config/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 require 'yle_tf/logger'

data/lib/yle_tf/config/loader.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'yle_tf/config/defaults'
 require 'yle_tf/config/erb'
 require 'yle_tf/config/file'
+require 'yle_tf/config/migration'
+require 'yle_tf/helpers/hash'
 require 'yle_tf/logger'
 require 'yle_tf/plugin'
 
-require_relative '../../../vendor/hash_deep_merge'
-
 class YleTf
   class Config
     class Loader
@@ -19,20 +21,88 @@ class YleTf
       end
 
       def load
-        Logger.debug('Loading default config')
-        config = default_config
-        Logger.debug(config.inspect)
+        load_sequence = %i[
+          load_default_config
+          load_plugin_configurations
+          load_config_files
+          evaluate_configuration_strings
+        ]
+        load_sequence.inject({}) { |config, method| send(method, config) }
+      end
+
+      def load_default_config(_config)
+        task('Loading default config') { default_config }
+      end
+
+      def load_plugin_configurations(config)
+        Logger.debug('Loading configuration from plugins')
+
+        plugins.inject(config) do |prev_config, plugin|
+          migrate_and_merge_configuration(prev_config, plugin.default_config,
+                                          type: 'plugin', name: plugin.to_s)
+        end
+      end
+
+      def load_config_files(config)
+        Logger.debug('Loading configuration from files')
+
+        config_files.inject(config) do |prev_config, file|
+          migrate_and_merge_configuration(prev_config, file.read,
+                                          type: 'file', name: file.name)
+        end
+      end
+
+      def evaluate_configuration_strings(config)
+        task('Evaluating the configuration strings') { eval_config(config) }
+      end
+
+      def eval_config(config)
+        case config
+        when Hash
+          config.each_with_object({}) { |(key, value), h| h[key] = eval_config(value) }
+        when Array
+          config.map { |item| eval_config(item) }
+        when String
+          Config::ERB.evaluate(config, config_context)
+        else
+          config
+        end
+      end
 
-        Logger.debug('Merging default configurations from plugins')
-        merge_plugin_configurations(config)
-        Logger.debug(config.inspect)
+      def plugins
+        Plugin.manager.registered
+      end
+
+      def config_files
+        module_dir.descend.lazy
+                  .map { |dir| dir.join('tf.yaml') }
+                  .select(&:exist?)
+                  .map { |file| Config::File.new(file) }
+      end
 
-        Logger.debug('Merging configurations from files')
-        merge_config_files(config)
-        Logger.debug(config.inspect)
+      def migrate_and_merge_configuration(prev_config, config, **opts)
+        task("- #{opts[:name]}") { config }
+        return prev_config if config.empty?
 
-        Logger.debug('Evaluating the configuration strings')
-        eval_config(config)
+        source = "#{opts[:type]}: '#{opts[:name]}'"
+        config = migrate_old_config(config, source: source)
+        deep_merge(prev_config, config, source: source)
+      end
+
+      def migrate_old_config(config, **opts)
+        task('  -> Migrating') do
+          Config::Migration.migrate_old_config(config, **opts)
+        end
+      end
+
+      def deep_merge(prev_config, config, **opts)
+        task('  -> Merging') do
+          Helpers::Hash.deep_merge(prev_config, config)
+        end
+      rescue StandardError => e
+        Logger.fatal("Failed to merge configuration from #{opts[:source]}:\n" \
+                     "#{config.inspect}\ninto:\n#{prev_config.inspect}")
+        raise e
       end
 
       def config_context
@@ -54,53 +124,13 @@ class YleTf
         end
       end
 
-      def merge_plugin_configurations(config)
-        Plugin.manager.default_configs.each do |plugin_config|
-          deep_merge(
-            config, plugin_config,
-            error_msg:
-              "Failed to merge a plugin's default configuration:\n" \
-              "#{plugin_config.inspect}\ninto:\n#{config.inspect}"
-          )
-        end
-      end
-
-      def merge_config_files(config)
-        config_files do |file|
-          Logger.debug("  - #{file}")
-          deep_merge(
-            config, file.read,
-            error_msg:
-              "Failed to merge configuration from '#{file}' into:\n" \
-              "#{config.inspect}"
-          )
-        end
-      end
+      # Helper to print debug information about the task and configuration
+      # after it
+      def task(message = nil)
+        Logger.debug(message) if message
 
-      def deep_merge(config, new_config, opts = {})
-        config.deep_merge!(new_config)
-      rescue StandardError => e
-        Logger.fatal(opts[:error_msg]) if opts[:error_msg]
-        raise e
-      end
-
-      def config_files
-        module_dir.descend do |dir|
-          file = dir.join('tf.yaml')
-          yield(Config::File.new(file)) if file.exist?
-        end
-      end
-
-      def eval_config(config)
-        case config
-        when Hash
-          config.each_with_object({}) { |(key, value), h| h[key] = eval_config(value) }
-        when Array
-          config.map { |item| eval_config(item) }
-        when String
-          Config::ERB.evaluate(config, config_context)
-        else
-          config
+        yield.tap do |config|
+          Logger.debug("  #{config.inspect}")
         end
       end
     end

data/lib/yle_tf/config/migration.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'yle_tf/helpers/hash'
+require 'yle_tf/logger'
+
+class YleTf
+  class Config
+    class Migration
+      BACKEND_MIGRATIONS = {
+        'file'  => {
+          'file' => 'path'
+        },
+        's3'    => {
+          'region'  => 'region',
+          'bucket'  => 'bucket',
+          'file'    => 'key',
+          'encrypt' => 'encrypt'
+        },
+        'swift' => {
+          'region'            => 'region_name',
+          'container'         => 'container',
+          'archive_container' => 'archive_container'
+        }
+      }.freeze
+
+      include Helpers::Hash
+
+      def self.migrate_old_config(config, **opts)
+        new(config, **opts).migrated_config
+      end
+
+      attr_reader :config, :config_source
+
+      def initialize(config, **opts)
+        @config = config
+        @config_source = opts.fetch(:source)
+      end
+
+      def old_backend_config
+        config['backend']
+      end
+
+      def migrated_config
+        migrate_old_backend_config(&deprecation_warning)
+      end
+
+      # Returns a `Proc` to print deprecation warnings unless denied by an env var
+      def deprecation_warning
+        return nil if ENV['TF_OLD_CONFIG_WARNINGS'] == 'false'
+
+        lambda do |new_config|
+          Logger.warn("Old configuration found in #{config_source}")
+          Logger.warn("Please migrate to relevant parts of:\n" \
+                      "#{sanitize_config(new_config)}")
+          Logger.warn(
+            'See https://github.com/Yleisradio/yle_tf/wiki/Migrating-Configuration for more details'
+          )
+        end
+      end
+
+      # TODO: Remove support in v2.0
+      def migrate_old_backend_config
+        changed = false
+
+        new_config = BACKEND_MIGRATIONS.inject(config) do |prev_config, (type, keys)|
+          migrate_old_backend_config_keys(prev_config, type, keys) { changed = true }
+        end
+
+        yield(new_config) if changed && block_given?
+
+        new_config
+      end
+
+      def migrate_old_backend_config_keys(config, type, keys)
+        migrated_keys = find_old_backend_config_keys(keys)
+        return config if migrated_keys.empty?
+
+        defaults = {
+          'backend' => {
+            type => {}
+          }
+        }
+        copy_with_defaults(config, defaults).tap do |new_config|
+          migrated_keys.each do |old_key, new_key|
+            new_config['backend'][type][new_key] = old_backend_config[old_key]
+          end
+
+          yield new_config
+        end
+      end
+
+      def find_old_backend_config_keys(keys)
+        return {} if !old_backend_config.is_a?(Hash)
+
+        keys.select do |old_key, _new_key|
+          old_backend_config.key?(old_key) &&
+            # Special case for 'file' as it is now used for option Hash for the
+            # 'file' backend
+            !(old_key == 'file' && old_backend_config['file'].is_a?(Hash))
+        end
+      end
+
+      def copy_with_defaults(config, defaults)
+        deep_merge(deep_copy(config), defaults)
+      end
+
+      def sanitize_config(config)
+        backend_config = config['backend'].select do |key, value|
+          key == 'type' || value.is_a?(Hash)
+        end
+
+        YAML.dump('backend' => backend_config)
+      end
+    end
+  end
+end