yle_tf 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/tf

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup' if File.exist? File.expand_path('../../Gemfile', __FILE__)
+require 'yle_tf/cli'
+
+cli = YleTf::CLI.new(ARGV)
+cli.execute

data/examples/envs/prod.tfvars

@@ -0,0 +1,5 @@
+aws_access_key = "PRODUCTION_ACCOUNT_ACCESS_KEY_HERE"
+aws_secret_key = "PRODUCTION_ACCOUNT_SECRET_KEY_HERE"
+
+# let's use a bigger instance type in prod
+instance_type = "t2.medium"

data/examples/envs/test.tfvars

@@ -0,0 +1,2 @@
+aws_access_key = "TEST_ACCOUNT_ACCESS_KEY_HERE"
+aws_secret_key = "TEST_ACCOUNT_SECRET_KEY_HERE"

data/examples/main.tf

@@ -0,0 +1,10 @@
+provider "aws" {
+  access_key = "${var.aws_access_key}"
+  secret_key = "${var.aws_secret_key}"
+  region     = "${var.region}"
+}
+
+resource "aws_instance" "example" {
+  ami           = "ami-d7b9a2b1"
+  instance_type = "${var.instance_type}"
+}

data/examples/tf.yaml

@@ -0,0 +1,4 @@
+backend:
+  type: file
+terraform:
+  version_requirement: "~> 0.9.11"

data/examples/tf_hooks/pre/get_current_hash.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+set -eu
+
+current_hash() {
+  CURRENT_GIT_HASH="$(git rev-parse HEAD)"
+
+  cat <<EOF > current_git_hash.tf.json
+{
+  "variable": {
+    "current_git_hash": {
+      "value": "$CURRENT_GIT_HASH"
+    }
+  }
+}
+EOF
+}
+
+# Execute only for commands `plan` and `apply`
+case "$TF_COMMAND" in
+  plan|apply)
+    current_hash
+    ;;
+  *)
+    ;;
+esac

data/examples/variables.tf

@@ -0,0 +1,22 @@
+variable "region" {
+  description = "The AWS region for the resources"
+  default     = "eu-west-1"
+}
+
+variable "env" {
+  # passed by `tf`
+  description = "The environment"
+}
+
+variable "aws_access_key" {
+  description = "Your AWS access key id"
+}
+
+variable "aws_secret_key" {
+  description = "Your AWS secret key"
+}
+
+variable "instance_type" {
+  description = "Instance type to use"
+  default     = "t2.micro"
+}

data/lib/yle_tf.rb

@@ -0,0 +1,70 @@
+require 'yle_tf/logger'
+require 'yle_tf/version'
+
+class YleTf
+  autoload :Action,  'yle_tf/action'
+  autoload :Error,   'yle_tf/error'
+  autoload :Plugin,  'yle_tf/plugin'
+
+  attr_reader :tf_env, :tf_command, :tf_command_args, :tf_options
+  attr_writer :actions
+
+  def initialize(tf_options, tf_env, tf_command, tf_command_args = [])
+    Logger.debug("YleTf version: #{VERSION}")
+    Logger.debug("Ruby version: #{RUBY_VERSION}")
+    Logger.debug("tf_options: #{tf_options.inspect}")
+    Logger.debug("tf_env: #{tf_env.inspect}")
+    Logger.debug("tf_command: #{tf_command.inspect}")
+    Logger.debug("tf_command_args: #{tf_command_args.inspect}")
+
+    @tf_options      = tf_options
+    @tf_env          = tf_env
+    @tf_command      = tf_command
+    @tf_command_args = tf_command_args
+
+    Plugin::Loader.load_plugins
+  end
+
+  def run(env = {})
+    Logger.debug('Building and running the stack')
+    apply_action_hooks
+    Logger.debug("actions: #{actions.inspect}")
+    env.merge!(action_env)
+    Logger.debug("env: #{env.inspect}")
+    actions.call(env)
+  end
+
+  def actions
+    @actions ||= build_action_stack
+  end
+
+  def build_action_stack
+    command_data = Plugin.manager.commands[tf_command]
+    command_proc = command_data[:proc]
+    command_proc.call
+  end
+
+  def apply_action_hooks
+    hooks = Plugin.manager.action_hooks
+    Logger.debug("Applying #{hooks.length} action hooks")
+    Plugin::ActionHook.new(actions).tap do |h|
+      hooks.each { |hook_proc| hook_proc.call(h) }
+    end
+  end
+
+  def action_env
+    {
+      tf_options:      tf_options,
+      tf_env:          tf_env,
+      tf_command:      tf_command,
+      tf_command_args: tf_command_args,
+      tfvars:          default_tfvars,
+    }
+  end
+
+  def default_tfvars
+    {
+      'env' => tf_env,
+    }
+  end
+end

data/lib/yle_tf/action.rb

@@ -0,0 +1,29 @@
+class YleTf
+  module Action
+    autoload :Builder, 'yle_tf/action/builder'
+    autoload :Command, 'yle_tf/action/command'
+    autoload :CopyRootModule, 'yle_tf/action/copy_root_module'
+    autoload :GenerateVarsFile, 'yle_tf/action/generate_vars_file'
+    autoload :LoadConfig, 'yle_tf/action/load_config'
+    autoload :TerraformInit, 'yle_tf/action/terraform_init'
+    autoload :TfHooks, 'yle_tf/action/tf_hooks'
+    autoload :TmpDir, 'yle_tf/action/tmpdir'
+    autoload :VerifyTfEnv, 'yle_tf/action/verify_tf_env'
+    autoload :VerifyTerraformVersion, 'yle_tf/action/verify_terraform_version'
+
+    def self.default_action_stack(command_class = nil)
+      Builder.new do
+        use LoadConfig
+        use VerifyTfEnv
+        use TmpDir
+        use VerifyTerraformVersion
+        use CopyRootModule
+        use GenerateVarsFile
+        use TfHooks
+        use TerraformInit
+
+        use(Command, command_class) if command_class
+      end
+    end
+  end
+end

data/lib/yle_tf/action/builder.rb

@@ -0,0 +1,9 @@
+require_relative '../../../vendor/middleware/builder'
+
+class YleTf
+  module Action
+    # Middleware builder for the actions
+    class Builder < Middleware::Builder
+    end
+  end
+end

data/lib/yle_tf/action/command.rb

@@ -0,0 +1,25 @@
+require 'yle_tf/logger'
+
+class YleTf
+  module Action
+    class Command
+      attr_reader :command
+
+      def initialize(app, command)
+        @app = app
+        @command = command
+      end
+
+      def call(env)
+        if env[:tf_options][:only_hooks]
+          Logger.debug "Skipping command #{command.class} due to `--only-hooks`"
+        else
+          Logger.debug "Executing command #{command.class} with env: #{env.inspect}"
+          command.new.execute(env)
+        end
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/yle_tf/action/copy_root_module.rb

@@ -0,0 +1,22 @@
+require 'fileutils'
+
+require 'yle_tf/logger'
+
+class YleTf
+  module Action
+    class CopyRootModule
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        config = env[:config]
+
+        Logger.debug("Copying the Terraform module from '#{config.module_dir}' to '#{Dir.pwd}'")
+        FileUtils.cp_r("#{config.module_dir}/.", '.')
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/yle_tf/action/generate_vars_file.rb

@@ -0,0 +1,27 @@
+require 'yle_tf/logger'
+require 'yle_tf/vars_file'
+
+class YleTf
+  module Action
+    class GenerateVarsFile
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        config = env[:config]
+
+        Logger.debug("Generating 'terraform.tfvars'")
+        vars_file = VarsFile.new('terraform.tfvars')
+        vars_file.append_vars(tfvars(env))
+        vars_file.append_file(VarsFile.find_env_vars_file(config))
+
+        @app.call(env)
+      end
+
+      def tfvars(env)
+        env[:tfvars].merge(env[:config].fetch('tfvars'))
+      end
+    end
+  end
+end

data/lib/yle_tf/action/load_config.rb

@@ -0,0 +1,17 @@
+require 'yle_tf/config'
+
+class YleTf
+  module Action
+    class LoadConfig
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env[:config] ||= Config.new(env[:tf_env])
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/yle_tf/action/terraform_init.rb

@@ -0,0 +1,63 @@
+require 'yle_tf/error'
+require 'yle_tf/logger'
+require 'yle_tf/plugin'
+require 'yle_tf/system'
+require 'yle_tf/version_requirement'
+
+class YleTf
+  module Action
+    class TerraformInit
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        config = env[:config]
+        backend = backend_config(config)
+
+        Logger.debug('Initializing Terraform with backend configuration:')
+        Logger.debug(backend.to_s)
+
+        if VersionRequirement.pre_0_9?(env[:terraform_version])
+          init_pre_0_9(backend)
+        else
+          init(backend)
+        end
+
+        @app.call(env)
+      end
+
+      def init_pre_0_9(backend)
+        cli_args = backend.cli_args
+        YleTf::System.cmd('terraform', 'remote', 'config', *cli_args) if cli_args
+
+        Logger.debug('Fetching Terraform modules')
+        YleTf::System.cmd('terraform', 'get')
+      end
+
+      def init(backend)
+        Logger.debug('Generating the backend configuration')
+        backend.generate_config do
+          Logger.debug('Initializing Terraform')
+          YleTf::System.cmd('terraform', 'init', '-no-color')
+        end
+      end
+
+      def backend_config(config)
+        backend_type = config.fetch('backend', 'type').downcase
+        backend_proc = backend_proc(backend_type)
+
+        klass = backend_proc.call
+        klass.new.backend_config(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
+      end
+    end
+  end
+end

data/lib/yle_tf/action/tf_hooks.rb

@@ -0,0 +1,48 @@
+require 'yle_tf/logger'
+require 'yle_tf/tf_hook/runner'
+
+require 'yle_tf/logger'
+require 'yle_tf/tf_hook/runner'
+
+class YleTf
+  module Action
+    class TfHooks
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @env = env
+
+        hook_runner.run('pre')
+        @app.call(env)
+        hook_runner.run('post')
+      end
+
+      def hook_runner
+        if run_hooks?
+          TfHook::Runner.new(@env[:config], hook_env)
+        else
+          NoRunner
+        end
+      end
+
+      def hook_env
+        {
+          'TF_COMMAND' => @env[:tf_command],
+          'TF_ENV'     => @env[:tf_env],
+        }
+      end
+
+      def run_hooks?
+        !@env[:tf_options][:no_hooks]
+      end
+
+      class NoRunner
+        def self.run(hook_type)
+          Logger.debug("Skipping #{hook_type} hooks due to `--no-hooks`")
+        end
+      end
+    end
+  end
+end

data/lib/yle_tf/action/tmpdir.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+require 'tmpdir'
+
+require 'yle_tf/logger'
+
+class YleTf
+  module Action
+    class TmpDir
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        config = env[:config]
+
+        tmpdir = Dir.mktmpdir(tmpdir_prefix(config))
+        Logger.debug("Temporary Terraform directory: #{tmpdir}")
+
+        Dir.chdir(tmpdir) do
+          @app.call(env)
+        end
+      ensure
+        FileUtils.rm_r(tmpdir) if tmpdir
+      end
+
+      def tmpdir_prefix(config)
+        if config
+          "tf_#{config.module_dir.basename}_#{config.tf_env}_"
+        else
+          'tf_'
+        end
+      end
+    end
+  end
+end