yle_tf 0.4.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fef8984348903ca788037c6d3562009f2499d513375aca7b8a6e93d14e9cf7cb
-  data.tar.gz: adf1e1f5a27f03c420cde1d49496956a224a88a5fa434cbd0eb4dcf90fa00810
+  metadata.gz: 7811f980206094727502839932ba9a800a4e37694ae26bc71d9c4935de38d3c3
+  data.tar.gz: 95e2c481a30b3caffb65c08407f9e222210fe01514f59ff88ca38a00915ea31b
 SHA512:
-  metadata.gz: 834703a380e72cd8ccd7c8c3dd4f5013042f6fa39f230da61fa3859a860d02102415a48a1cd7065021439b5b506a13c6a184f39241aef7f4e719b2af9a42164e
-  data.tar.gz: c432b0981046afd428eb2110dd45becfa810952c2d4e4d7263b117da82d5dd3da8c0a01713c8fff01ff5abe29c269dcfb99927d80a3941e8114dd6f573e9dc60
+  metadata.gz: 84010f77dfa1d2786f0c9b4a3783073ad15bbf6146bac16f4a49401b8b378e28f0747f82a6880eb01dda175fccbd1465f3e25391586e10c11d424e304fe8e74b
+  data.tar.gz: 95c19822da06edb58e250215fb0c5e2154da99e8881a2b8a8ce4fb9fe7c124772e81d7a2774595fdedb97cec3166e0b34e7c098ac20d8133ad97bfcb1196534e

data/bin/tf

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 # Catch Ctrl+C to avoid stack traces
 Signal.trap('INT') { abort }
 
-require 'bundler/setup' if File.exist?(File.expand_path('../../Gemfile', __FILE__))
+require 'bundler/setup' if File.exist?(File.expand_path('../Gemfile', __dir__))
 require 'yle_tf/cli'
 
 cli = YleTf::CLI.new(ARGV)

data/lib/yle_tf.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require 'yle_tf/logger'
 require 'yle_tf/version'
 
 class YleTf
+  TERRAFORM_VERSION_REQUIREMENT = '>= 0.9'
+
   autoload :Action,  'yle_tf/action'
   autoload :Error,   'yle_tf/error'
   autoload :Plugin,  'yle_tf/plugin'

data/lib/yle_tf/action.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class YleTf
   module Action
     autoload :Builder, 'yle_tf/action/builder'
@@ -10,11 +12,13 @@ class YleTf
     autoload :TmpDir, 'yle_tf/action/tmpdir'
     autoload :VerifyTerraformVersion, 'yle_tf/action/verify_terraform_version'
     autoload :VerifyTfEnv, 'yle_tf/action/verify_tf_env'
+    autoload :VerifyYleTfVersion, 'yle_tf/action/verify_yle_tf_version'
     autoload :WriteTerraformrcDefaults, 'yle_tf/action/write_terraformrc_defaults'
 
     def self.default_action_stack(command_class = nil)
       Builder.new do
         use LoadConfig
+        use VerifyYleTfVersion
         use VerifyTfEnv
         use TmpDir
         use WriteTerraformrcDefaults

data/lib/yle_tf/action/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../vendor/middleware/builder'
 
 class YleTf

data/lib/yle_tf/action/command.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yle_tf/logger'
 
 class YleTf
@@ -12,9 +14,9 @@ class YleTf
 
       def call(env)
         if env[:tf_options][:only_hooks]
-          Logger.debug "Skipping command #{command.class} due to `--only-hooks`"
+          Logger.debug "Skipping command #{command} due to `--only-hooks`"
         else
-          Logger.debug "Executing command #{command.class} with env: #{env.inspect}"
+          Logger.debug "Executing command #{command} with env: #{env.inspect}"
           command.new.execute(env)
         end
 

data/lib/yle_tf/action/copy_root_module.rb

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

data/lib/yle_tf/action/generate_vars_file.rb

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

data/lib/yle_tf/action/load_config.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'yle_tf/config'
+require 'yle_tf/logger'
 
 class YleTf
   module Action
@@ -8,10 +11,15 @@ class YleTf
       end
 
       def call(env)
-        env[:config] ||= Config.new(env[:tf_env])
+        env[:config] ||= load_config(env[:tf_env])
 
         @app.call(env)
       end
+
+      def load_config(tf_env)
+        Logger.debug("Initializing configuration for the #{tf_env.inspect} environment")
+        Config.load(tf_env).tap { |config| Logger.debug(config.inspect) }
+      end
     end
   end
 end

data/lib/yle_tf/action/terraform_init.rb

@@ -1,8 +1,10 @@
-require 'yle_tf/error'
+# frozen_string_literal: true
+
+require 'pathname'
+
 require 'yle_tf/logger'
 require 'yle_tf/plugin'
 require 'yle_tf/system'
-require 'yle_tf/version_requirement'
 
 class YleTf
   module Action
@@ -10,62 +12,58 @@ class YleTf
       TF_CMD_ARGS = %w[-input=false -no-color].freeze
 
       TF_CMD_OPTS = {
-        env: { 'TF_IN_AUTOMATION' => 'true' }, # Reduces some output
-        stdout: :debug                         # Hide the output to the debug level
+        env:    { 'TF_IN_AUTOMATION' => 'true' }, # Reduces some output
+        stdout: :debug                            # Hide the output to the debug level
       }.freeze
 
+      attr_reader :config
+
       def initialize(app)
         @app = app
       end
 
       def call(env)
-        config = env[:config]
-        backend = backend_config(config)
+        @config = env[:config]
 
         Logger.info('Initializing Terraform')
         Logger.debug("Backend configuration: #{backend}")
 
-        if VersionRequirement.pre_0_9?(env[:terraform_version])
-          init_pre_0_9(backend)
-        else
-          init(backend)
-        end
+        init(backend)
 
         @app.call(env)
       end
 
-      def init_pre_0_9(backend)
-        cli_args = backend.cli_args
-        if cli_args
-          YleTf::System.cmd('terraform', 'remote', 'config', *TF_CMD_ARGS, *cli_args, TF_CMD_OPTS)
-        end
+      def init(backend)
+        Logger.debug('Configuring the backend')
+        backend.configure
+
+        Logger.debug('Symlinking errored.tfstate')
+        symlink_errored_tfstate
 
-        Logger.debug('Fetching Terraform modules')
-        YleTf::System.cmd('terraform', 'get', *TF_CMD_ARGS, TF_CMD_OPTS)
+        Logger.debug('Initializing Terraform')
+        YleTf::System.cmd('terraform', 'init', *TF_CMD_ARGS, **TF_CMD_OPTS)
       end
 
-      def init(backend)
-        Logger.debug('Generating the backend configuration')
-        backend.generate_config do
-          Logger.debug('Initializing Terraform')
-          YleTf::System.cmd('terraform', 'init', *TF_CMD_ARGS, TF_CMD_OPTS)
-        end
+      def backend
+        @backend ||= find_backend
       end
 
-      def backend_config(config)
+      def find_backend
         backend_type = config.fetch('backend', 'type').downcase
-        backend_proc = backend_proc(backend_type)
+        backend_proc = Plugin.manager.backends[backend_type]
 
         klass = backend_proc.call
-        klass.new.backend_config(config)
+        klass.new(config)
       end
 
-      def backend_proc(backend_type)
-        backends = Plugin.manager.backends
-        backends.fetch(backend_type.to_sym) do
-          raise Error, "Unknown backend type '#{backend_type}'. " \
-            "Supported backends: #{backends.keys.join(', ')}"
-        end
+      def symlink_errored_tfstate
+        local_path = Pathname.pwd.join('errored.tfstate')
+        remote_path = config.module_dir.join('errored.tfstate')
+
+        # Remove the possibly copied old file
+        local_path.unlink if local_path.exist?
+
+        local_path.make_symlink(remote_path)
       end
     end
   end

data/lib/yle_tf/action/tf_hooks.rb

@@ -1,5 +1,4 @@
-require 'yle_tf/logger'
-require 'yle_tf/tf_hook/runner'
+# frozen_string_literal: true
 
 require 'yle_tf/logger'
 require 'yle_tf/tf_hook/runner'
@@ -21,7 +20,7 @@ class YleTf
 
       def hook_runner
         if run_hooks?
-          TfHook::Runner.new(@env[:config], hook_env)
+          TfHook::Runner.new(config, hook_env)
         else
           NoRunner
         end
@@ -29,11 +28,16 @@ class YleTf
 
       def hook_env
         {
-          'TF_COMMAND' => @env[:tf_command],
-          'TF_ENV'     => @env[:tf_env],
+          'TF_COMMAND'    => @env[:tf_command],
+          'TF_ENV'        => @env[:tf_env],
+          'TF_MODULE_DIR' => config.module_dir.to_s,
         }
       end
 
+      def config
+        @env[:config]
+      end
+
       def run_hooks?
         !@env[:tf_options][:no_hooks]
       end

data/lib/yle_tf/action/tmpdir.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'tmpdir'
 
@@ -20,7 +22,7 @@ class YleTf
           @app.call(env)
         end
       ensure
-        FileUtils.rm_r(tmpdir) if tmpdir && Dir.exist?(tmpdir)
+        FileUtils.rm_rf(tmpdir, secure: true) if tmpdir && Dir.exist?(tmpdir)
       end
 
       def tmpdir_prefix(config)

data/lib/yle_tf/action/verify_terraform_version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'yle_tf'
 require 'yle_tf/error'
 require 'yle_tf/logger'
 require 'yle_tf/system'
@@ -17,22 +20,32 @@ class YleTf
         raise(Error, 'Terraform not found') if !version
 
         Logger.debug("Terraform version: #{version}")
-        verify_version(env)
+
+        verify_version(version, requirement_by_yletf, required_by: 'YleTf')
+        verify_version(version, requirement_by_config(env), required_by: 'config')
 
         @app.call(env)
       end
 
       def terraform_version
         v = YleTf::System.read_cmd('terraform', 'version', error_handler: proc {})
-        Regexp.last_match(1) if v =~ /^Terraform v([^\s]+)/
+        m = /^Terraform v(?<version>[^\s]+)/.match(v)
+        m && m[:version]
       end
 
-      def verify_version(env)
-        version = env[:terraform_version]
+      def requirement_by_config(env)
         requirement = env[:config].fetch('terraform', 'version_requirement') { nil }
+        VersionRequirement.new(requirement)
+      end
+
+      def requirement_by_yletf
+        VersionRequirement.new(YleTf::TERRAFORM_VERSION_REQUIREMENT)
+      end
 
-        if !VersionRequirement.new(requirement).satisfied_by?(version)
-          raise Error, "Terraform version '#{requirement}' required, '#{version}' found"
+      def verify_version(version, requirement, **opts)
+        if !requirement.satisfied_by?(version)
+          raise Error, "Terraform version '#{requirement}' required by #{opts[:required_by]}, " \
+                       "'#{version}' found"
         end
       end
     end

data/lib/yle_tf/action/verify_tf_env.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yle_tf/error'
 require 'yle_tf/vars_file'
 

data/lib/yle_tf/action/verify_yle_tf_version.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'yle_tf/error'
+require 'yle_tf/logger'
+require 'yle_tf/version'
+require 'yle_tf/version_requirement'
+
+class YleTf
+  module Action
+    class VerifyYleTfVersion
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Logger.debug('Verifying YleTf version')
+
+        requirement = requirement(env[:config])
+        verify_version(requirement)
+
+        @app.call(env)
+      end
+
+      def requirement(config)
+        requirement = config.fetch('yle_tf', 'version_requirement') { nil }
+        VersionRequirement.new(requirement)
+      end
+
+      def verify_version(requirement)
+        return if requirement.satisfied_by?(YleTf::VERSION)
+
+        raise Error, "YleTf version '#{YleTf::VERSION}', '#{requirement}' required by config"
+      end
+    end
+  end
+end

data/lib/yle_tf/action/write_terraformrc_defaults.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'yle_tf/logger'
 
@@ -5,10 +7,10 @@ class YleTf
   module Action
     class WriteTerraformrcDefaults
       # Path of the Terraform CLI configuration file
-      RC_PATH = '~/.terraformrc'.freeze
+      RC_PATH = '~/.terraformrc'
 
       # Path of the plugin cache directory
-      DEFAULT_PLUGIN_CACHE_PATH = '~/.terraform.d/plugin-cache'.freeze
+      DEFAULT_PLUGIN_CACHE_PATH = '$HOME/.terraform.d/plugin-cache'
 
       def initialize(app)
         @app = app

data/lib/yle_tf/backend.rb

@@ -0,0 +1,42 @@
+# 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
+
+    # 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