yle_tf 0.4.0 → 1.3.0

data/lib/yle_tf/config/defaults.rb

@@ -1,33 +1,44 @@
+# 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'
+          },
+          '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

data/lib/yle_tf/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class YleTf
   # Base class for yle_tf errors
   Error = Class.new(StandardError)

data/lib/yle_tf/helpers/hash.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../../../vendor/hash_deep_merge'
+
+class YleTf
+  module Helpers
+    module Hash
+      module_function
+
+      # Returns deep merged new Hash
+      def deep_merge(target, source)
+        target.deep_merge(source)
+      end
+
+      # Returns deep copy of a Hash.
+      # `dup` and `clone` only return shallow copies.
+      def deep_copy(hash)
+        Marshal.load(Marshal.dump(hash))
+      end
+    end
+  end
+end

data/lib/yle_tf/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require 'logger'
 require 'rubygems'
@@ -21,7 +23,6 @@ class YleTf
 
     def self.logger
       @logger ||= ::Logger.new(DEVICE).tap do |logger|
-        patch_for_old_ruby(logger)
         logger.level = log_level
         logger.formatter = log_formatter
       end
@@ -63,14 +64,5 @@ class YleTf
         :brown
       end
     end
-
-    # Patches the `::Logger` in older Ruby versions to
-    # accept log level as a `String`
-    def self.patch_for_old_ruby(logger)
-      if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
-        require_relative '../../vendor/logger_level_patch'
-        logger.extend(LoggerLevelPatch)
-      end
-    end
   end
 end

data/lib/yle_tf/logger/colorize.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class YleTf
   module Logger
     module Colorize

data/lib/yle_tf/plugin.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 class YleTf
   class Plugin
     autoload :ActionHook, 'yle_tf/plugin/action_hook'
     autoload :Loader, 'yle_tf/plugin/loader'
     autoload :Manager, 'yle_tf/plugin/manager'
 
+    DEFAULT_BACKEND = Object.new.freeze
     DEFAULT_COMMAND = Object.new.freeze
 
     def self.manager
@@ -30,7 +33,7 @@ class YleTf
       name = name.to_s if name.is_a?(Symbol)
       commands[name] = {
         synopsis: synopsis,
-        proc: block
+        proc:     block
       }
     end
 
@@ -49,7 +52,8 @@ class YleTf
     end
 
     def self.backend(type, &block)
-      backends[type.to_sym] = block
+      type = type.to_s if type.is_a?(Symbol)
+      backends[type] = block
     end
   end
 end