yle_tf 0.1.0

data/lib/yle_tf/action/verify_terraform_version.rb

@@ -0,0 +1,41 @@
+require 'yle_tf/error'
+require 'yle_tf/logger'
+require 'yle_tf/version_requirement'
+
+class YleTf
+  module Action
+    class VerifyTerraformVersion
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Logger.debug('Verifying Terraform version')
+
+        version = env[:terraform_version] = terraform_version
+        raise(Error, 'Terraform not found') if !version
+
+        Logger.debug("Terraform version: #{version}")
+        verify_version(env)
+
+        @app.call(env)
+      end
+
+      def terraform_version
+        # TODO: move `command` to YleTf::System
+        Regexp.last_match(1) if `terraform version` =~ /^Terraform v([^\s]+)/
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def verify_version(env)
+        version = env[:terraform_version]
+        requirement = env[:config].fetch('terraform', 'version_requirement') { nil }
+
+        if !VersionRequirement.new(requirement).satisfied_by?(version)
+          raise Error, "Terraform version '#{requirement}' required, '#{version}' found"
+        end
+      end
+    end
+  end
+end

data/lib/yle_tf/action/verify_tf_env.rb

@@ -0,0 +1,24 @@
+require 'yle_tf/error'
+require 'yle_tf/vars_file'
+
+class YleTf
+  module Action
+    class VerifyTfEnv
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        config = env[:config]
+        all_envs = VarsFile.list_all_envs(config)
+
+        if !all_envs.include?(config.tf_env)
+          raise Error, "Terraform vars file not found for the '#{config.tf_env}' " \
+            " environment. Existing envs: #{all_envs.join(', ')}"
+        end
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/yle_tf/backend_config.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+class YleTf
+  class BackendConfig
+    BACKEND_CONFIG_FILE = '_backend.tf.json'.freeze
+
+    attr_reader :type, :config
+
+    def initialize(type, config)
+      @type = type
+      @config = config
+    end
+
+    # Returns an `Array` of CLI args for Terraform pre 0.9 `init` command
+    def cli_args
+      args = ["-backend=#{type}"]
+      config.each do |key, value|
+        args << "-backend-config=#{key}=#{value}"
+      end
+      args
+    end
+
+    # Generate backend configuration file for Terraform v0.9+
+    def generate_config
+      data = {
+        terraform: [{
+          backend: [to_h]
+        }]
+      }
+      File.write(BACKEND_CONFIG_FILE, JSON.pretty_generate(data))
+      yield if block_given?
+    end
+
+    # Returns the backend configuration as a `Hash` for Terraform v0.9+
+    def to_h
+      { type => config }
+    end
+
+    alias to_s to_h
+  end
+end

data/lib/yle_tf/cli.rb

@@ -0,0 +1,88 @@
+require 'yle_tf'
+
+class YleTf
+  class CLI
+    attr_reader :tf_options, :tf_command, :tf_command_args, :tf_env
+
+    # YleTf option arguments
+    TF_OPTIONS = %w[--debug --no-hooks --only-hooks].freeze
+
+    HELP_ARGS = %w[-h --help help].freeze
+    VERSION_ARGS = %w[-v --version version].freeze
+
+    def initialize(argv)
+      @tf_options = {}
+      @tf_command_args = []
+      split_args(argv)
+    end
+
+    def execute
+      tf = YleTf.new(tf_options, tf_env, tf_command, tf_command_args)
+      tf.run
+    rescue YleTf::Error => e
+      raise e if debug?
+
+      Logger.fatal e
+      exit 1
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def split_args(argv)
+      argv.each do |arg|
+        if @tf_env && @tf_command
+          if TF_OPTIONS.include?(arg)
+            @tf_options[key(arg)] = true
+          else
+            @tf_command_args << arg
+          end
+        elsif HELP_ARGS.include?(arg)
+          @tf_command = 'help'
+          @tf_env = '_'
+          break
+        elsif VERSION_ARGS.include?(arg)
+          @tf_command = 'version'
+          @tf_env = '_'
+          break
+        elsif arg.start_with?('-')
+          if TF_OPTIONS.include?(arg)
+            @tf_options[key(arg)] = true
+          else
+            STDERR.puts "Unknown option '#{arg}'"
+            @tf_command = 'help'
+            @tf_env = 'error'
+            break
+          end
+        elsif !@tf_env
+          @tf_env = arg
+        else
+          @tf_command = arg
+        end
+      end
+
+      if !@tf_command || !@tf_env
+        @tf_command = 'help'
+        @tf_env = 'error'
+      end
+
+      self.debug = true if @tf_options.include?(:debug)
+    end
+
+    # Returns `Symbol` for the arg, e.g. `"--foo-bar"` -> `:foo_bar`
+    def key(arg)
+      arg.sub(/\A--?/, '').tr('-', '_').to_sym
+    end
+
+    def debug=(value)
+      if value
+        ENV['TF_DEBUG'] = '1'
+      else
+        ENV.delete('TF_DEBUG')
+      end
+    end
+
+    def debug?
+      ENV.key?('TF_DEBUG')
+    end
+  end
+end

data/lib/yle_tf/config.rb

@@ -0,0 +1,45 @@
+require 'pathname'
+require 'yaml'
+
+require 'yle_tf/config/loader'
+require 'yle_tf/error'
+require 'yle_tf/logger'
+
+class YleTf
+  # Configuration object to be used especially by the middleware stack
+  class Config
+    NotFoundError = Class.new(Error)
+
+    attr_reader :config, :tf_env, :module_dir
+
+    def initialize(tf_env)
+      Logger.debug("Initializing configuration for the #{tf_env.inspect} environment")
+
+      @tf_env = tf_env
+      @module_dir = Pathname.pwd
+      @config = Loader.new(tf_env: tf_env, module_dir: module_dir).load
+
+      Logger.debug(inspect)
+    end
+
+    def to_s
+      YAML.dump(config)
+    end
+
+    # Returns a value from the configuration hierarchy specified by a list of
+    # keys. If the key is not specified, return result of a specied block, or
+    # raise `NotFoundError` if none specified.
+    def fetch(*keys, &block)
+      block ||= DEFAULT_NOT_FOUND_BLOCK
+
+      keys.inject(config) do |conf, key|
+        break block.call(keys) if !conf || !conf.key?(key)
+        conf[key]
+      end
+    end
+
+    DEFAULT_NOT_FOUND_BLOCK = lambda do |keys|
+      raise NotFoundError, "Configuration key not found: #{keys.join(' > ')}"
+    end.freeze
+  end
+end

data/lib/yle_tf/config/defaults.rb

@@ -0,0 +1,35 @@
+class YleTf
+  class Config
+    module Defaults
+      DEFAULT_CONFIG = {
+        'hooks' => {
+          'pre' => [],
+          'post' => []
+        },
+        'backend' => {
+          'type' => 'file',
+          'bucket'  => nil,
+          'file'    => '<%= @module %>_<%= @env %>.tfstate',
+          'region'  => nil,
+          'encrypt' => false,
+        },
+        'tfvars' => {
+        },
+        'terraform' => {
+          'version_requirement' => nil
+        }
+      }.freeze
+
+      def default_config
+        DEFAULT_CONFIG.dup
+      end
+
+      def default_config_context
+        {
+          env: tf_env,
+          module: module_dir.basename.to_s,
+        }
+      end
+    end
+  end
+end

data/lib/yle_tf/config/erb.rb

@@ -0,0 +1,22 @@
+require 'erb'
+
+class YleTf
+  class Config
+    module ERB
+      class Context
+        def initialize(vars)
+          vars.each { |key, value| instance_variable_set(:"@#{key}", value) }
+        end
+
+        def binding
+          super
+        end
+      end
+
+      def self.evaluate(string, vars = {})
+        b = Context.new(vars).binding
+        ::ERB.new(string).result(b)
+      end
+    end
+  end
+end

data/lib/yle_tf/config/file.rb

@@ -0,0 +1,26 @@
+require 'yaml'
+
+require 'yle_tf/logger'
+
+class YleTf
+  class Config
+    class File
+      attr_reader :name
+
+      def initialize(name)
+        @name = name.to_s
+      end
+
+      def read
+        YAML.load_file(name) || {}
+      rescue StandardError => e
+        Logger.fatal("Failed to load or parse configuration from '#{name}'")
+        raise e
+      end
+
+      def to_s
+        name
+      end
+    end
+  end
+end

data/lib/yle_tf/config/loader.rb

@@ -0,0 +1,108 @@
+require 'yle_tf/config/defaults'
+require 'yle_tf/config/erb'
+require 'yle_tf/config/file'
+require 'yle_tf/logger'
+require 'yle_tf/plugin'
+
+require_relative '../../../vendor/hash_deep_merge'
+
+class YleTf
+  class Config
+    class Loader
+      include Config::Defaults
+
+      attr_reader :tf_env, :module_dir
+
+      def initialize(opts)
+        @tf_env = opts.fetch(:tf_env)
+        @module_dir = opts.fetch(:module_dir)
+      end
+
+      def load
+        Logger.debug('Loading default config')
+        config = default_config
+        Logger.debug(config.inspect)
+
+        Logger.debug('Merging default configurations from plugins')
+        merge_plugin_configurations(config)
+        Logger.debug(config.inspect)
+
+        Logger.debug('Merging configurations from files')
+        merge_config_files(config)
+        Logger.debug(config.inspect)
+
+        Logger.debug('Evaluating the configuration strings')
+        eval_config(config)
+      end
+
+      def config_context
+        @config_context ||= load_config_context
+      end
+
+      def load_config_context
+        Logger.debug('Loading config context')
+        default_config_context.tap do |context|
+          Logger.debug('Merging configuration contexts from plugins')
+          merge_plugin_config_contexts(context)
+          Logger.debug("config_context: #{context.inspect}")
+        end
+      end
+
+      def merge_plugin_config_contexts(context)
+        Plugin.manager.config_contexts.each do |plugin_context|
+          context.merge!(plugin_context)
+        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
+
+      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
+        end
+      end
+    end
+  end
+end

data/lib/yle_tf/error.rb

@@ -0,0 +1,4 @@
+class YleTf
+  # Base class for yle_tf errors
+  Error = Class.new(StandardError)
+end