terraform-wrapper 0.0.2 → 0.1.0

data/lib/terraform-wrapper/shared/latest.rb

@@ -21,6 +21,10 @@ module TerraformWrapper
 
       include Singleton
 
+###############################################################################
+
+      include TerraformWrapper::Shared::Logging
+
 ###############################################################################
 
       @version
@@ -40,22 +44,22 @@ module TerraformWrapper
 ###############################################################################
 
       def refresh
-        $logger.info("Finding latest available Terraform release...")
+        logger.info("Finding latest available Terraform release...")
 
         response = Net::HTTP.get_response(URI("https://checkpoint-api.hashicorp.com/v1/check/terraform"))
 
-        raise "Hashicorp Checkpoint did not return status 200 for latest version check!" if response.code != "200"
-        raise "Response body from Hashicorp Checkpoint is not permitted!"                if not response.class.body_permitted?
-        raise "Response body from Hashicorp Checkpoint is empty!"                        if response.body.nil?
+        logger.fatal("Hashicorp Checkpoint did not return status 200 for latest version check!") if response.code != "200"
+        logger.fatal("Response body from Hashicorp Checkpoint is not permitted!")                if not response.class.body_permitted?
+        logger.fatal("Response body from Hashicorp Checkpoint is empty!")                        if response.body.nil?
 
         body = JSON.parse(response.body)
 
-        raise "Hashicorp Checkpoint JSON response did not include latest available Terraform version!" if not body.key?("current_version")
-        raise "Hashicorp Checkpoint indicated latest available version of Terraform is blank!"         if body["current_version"].empty?
+        logger.fatal("Hashicorp Checkpoint JSON response did not include latest available Terraform version!") if not body.key?("current_version")
+        logger.fatal("Hashicorp Checkpoint indicated latest available version of Terraform is blank!")         if body["current_version"].empty?
 
         version = body["current_version"]
 
-        $logger.info("Latest available Terraform release found: #{version}")
+        logger.success("Latest available Terraform release found: #{version}")
 
         return version
       end

data/lib/terraform-wrapper/shared/logger.rb

@@ -0,0 +1,80 @@
+###############################################################################
+
+require 'logger'
+
+###############################################################################
+
+module TerraformWrapper
+
+###############################################################################
+
+  module Shared
+
+###############################################################################
+
+    class Logger < ::Logger
+
+###############################################################################
+
+      @colour = false
+
+###############################################################################
+
+      def colour()
+        @colour
+      end
+
+###############################################################################
+
+      def colour=(enabled)
+        @colour = [ true, false ].include?(enabled) ? enabled : false
+      end
+
+###############################################################################
+
+      def success(message)
+        info(format(colour: 32, message: message))
+      end
+
+###############################################################################
+
+      def warn(message)
+        warn(format(colour: 33, message: message))
+      end
+
+###############################################################################
+
+      def error(message)
+        error(format(colour: 31, message: message))
+      end
+
+###############################################################################
+
+      def fatal(message)
+        fatal(format(colour: 31, message: message))
+        exit(1)
+      end
+
+###############################################################################
+
+      private
+
+###############################################################################
+
+      def format(colour: 32, message:)
+        return @colour ? "\e[" + colour.to_s + "m" + message + "\e[0m" : message
+      end
+
+###############################################################################
+
+    end
+
+###############################################################################
+
+  end
+
+###############################################################################
+
+end
+
+###############################################################################

data/lib/terraform-wrapper/shared/logging.rb

@@ -0,0 +1,77 @@
+###############################################################################
+
+require 'logger'
+
+###############################################################################
+
+module TerraformWrapper
+
+###############################################################################
+
+  module Shared
+
+###############################################################################
+
+    module Logging
+
+###############################################################################
+
+      private
+
+###############################################################################
+
+      def logger
+        @logger ||= Logging.logger_for(self.class.name)
+      end
+
+###############################################################################
+
+      @loggers = {}
+
+###############################################################################
+
+      class << self
+
+###############################################################################
+
+        def logger_for(classname)
+          @loggers[classname] ||= configure_logger_for(classname)
+        end
+
+###############################################################################
+
+        def configure_logger_for(classname)
+          colour = ENV["TERRAFORM_WRAPPER_LOG_COLOUR"] || "true"
+          level  = ENV["TERRAFORM_WRAPPER_LOG_LEVEL"]  || "INFO"
+
+          logger = ::TerraformWrapper::Shared::Logger.new(STDOUT)
+
+          logger.colour   = colour.downcase == "true"
+          logger.level    = level.upcase
+          logger.progname = classname
+
+          logger.formatter = proc do |severity, datetime, progname, msg|
+            sevId = severity.chars.first.upcase
+            "[#{sevId}] [#{progname}] #{msg}\n"
+          end
+
+          logger
+        end
+
+###############################################################################
+
+      end
+
+###############################################################################
+
+    end
+
+###############################################################################
+
+  end
+
+###############################################################################
+
+end
+
+###############################################################################

data/lib/terraform-wrapper/shared/runner.rb

@@ -10,6 +10,10 @@ module TerraformWrapper
 
     class Runner
 
+###############################################################################
+
+      include TerraformWrapper::Shared::Logging
+
 ###############################################################################
 
       attr_reader :binary
@@ -30,75 +34,90 @@ module TerraformWrapper
 
 ###############################################################################
 
-      def download
-        parameters = [ "-backend=false" ]
+      def download(upgrade: true)
+        parameters = Array.new
+        parameters.append("-backend=false")
+        parameters.append("-upgrade") if upgrade
+
         @downloaded = run(action: "init", parameters: parameters)
-        raise("Failed to download Terraform modules.") unless @downloaded
+        logger.fatal("Failed to download Terraform modules.") unless @downloaded
       end
 
 ###############################################################################
 
-      def init(config:)
-        parameters = [ "-reconfigure" ]
+      def init(config:, upgrade: true)
+        parameters = Array.new
+        parameters.append("-reconfigure")
+        parameters.append("-upgrade") if upgrade
+
         config.backend.hash.each do |key, value|
           parameters.append("-backend-config=\"#{key}=#{value}\"")
         end
 
+        config.auths.map(&:auth)
+
         @config = config
         @initialised = run(action: "init", parameters: parameters)
-        raise("Failed to initialise Terraform with backend.") unless @initialised
+        logger.fatal("Failed to initialise Terraform with backend.") unless @initialised
       end
 
 ###############################################################################
 
       def plan(destroy: false, file: nil)
-        raise("Cannot Terraform plan before initialising backend!") unless initialised
+        logger.fatal("Cannot Terraform plan before initialising backend!") unless initialised
 
-        parameters = variable_files
+        parameters = Array.new
+        parameters.concat(variable_files)
+        parameters.concat(variable_strings)
 
         if not file.nil? and file.kind_of?(String) and not file.strip.empty? then
-          raise "Failed to create plan directory: #{directory}" unless create_directory(directory: File.dirname(file), purpose: "plan")
+          logger.fatal("Failed to create plan directory: #{directory}") unless ::TerraformWrapper.create_directory(directory: File.dirname(file), purpose: "plan")
           parameters.append("-out=\"#{file}\"")
         end
 
         parameters.append("-destroy") if destroy
 
-        raise("Terraform plan failed!") unless run(action: "plan", parameters: parameters)
+        logger.fatal("Terraform plan failed!") unless run(action: "plan", parameters: parameters)
       end
 
 ###############################################################################
 
       def apply(file: nil)
-        raise("Cannot Terraform apply before initialising backend!") unless initialised
+        logger.fatal("Cannot Terraform apply before initialising backend!") unless initialised
 
-        parameters = [ "-auto-approve" ]
+        parameters = Array.new
+        parameters.concat(variable_files)
+        parameters.concat(variable_strings)
+        parameters.append("-auto-approve")
 
         if not file.nil? and file.kind_of?(String) and not file.strip.empty? then
-          raise "Plan file: #{file} does not exist!" unless File.file?(file)
+          logger.fatal("Plan file: #{file} does not exist!") unless File.file?(file)
           parameters.append("\"#{file}\"")
         else
           parameters.concat(variable_files)
         end
 
-        raise("Terraform apply failed!") unless run(action: "apply", parameters: parameters)
+        logger.fatal("Terraform apply failed!") unless run(action: "apply", parameters: parameters)
       end
 
 ###############################################################################
 
       def destroy
-        raise("Cannot Terraform destroy before initialising backend!") unless initialised
+        logger.fatal("Cannot Terraform destroy before initialising backend!") unless initialised
 
-        parameters = [ "-auto-approve" ]
+        parameters = Array.new
         parameters.concat(variable_files)
+        parameters.concat(variable_strings)
+        parameters.append("-auto-approve")
 
-        raise("Terraform destroy failed!") unless run(action: "destroy", parameters: parameters)
+        logger.fatal("Terraform destroy failed!") unless run(action: "destroy", parameters: parameters)
       end
 
 ###############################################################################
 
       def validate
-        raise("Cannot Terraform validate before downloading modules!") unless downloaded
-        raise("Terraform validation failed!") unless run(action: "validate")
+        logger.fatal("Cannot Terraform validate before downloading modules!") unless downloaded
+        logger.fatal("Terraform validation failed!") unless run(action: "validate")
       end
 
 ###############################################################################
@@ -108,7 +127,7 @@ module TerraformWrapper
 ###############################################################################
 
       def variable_files
-        raise("Cannot generate variable files until Terraform has been initialised!") unless @initialised
+        logger.fatal("Cannot generate variable files until Terraform has been initialised!") unless @initialised
 
         result = Array.new
 
@@ -119,6 +138,24 @@ module TerraformWrapper
         return result
       end
 
+###############################################################################
+
+      def variable_strings
+        logger.fatal("Cannot generate variable strings until Terraform has been initialised!") unless @initialised
+
+        result = Array.new
+
+        result.append("-var=\"component=#{@code.name}\"")
+        result.append("-var=\"config=#{@config.name}\"")
+        result.append("-var=\"service=#{@config.service}\"")
+
+        @config.variables.values.each do |key, value|
+          result.append("-var=\"#{key.to_s}=#{value}\"")
+        end
+
+        return result
+      end
+
 ###############################################################################
 
       def run(action:, parameters: Array.new)
@@ -128,14 +165,14 @@ module TerraformWrapper
 
         cmdline = [ "\"#{@binary.path}\"", action ].concat(parameters).join(" ")
 
-        $logger.info("Starting Terraform, action: #{action}")
+        logger.info("Starting Terraform, action: #{action}")
 
         puts("\n" + ('#' * 80) + "\n\n")
 
         Dir.chdir(@code.path)
         result = system(cmdline) || false
 
-        puts("\n")
+        puts("\n" + ('#' * 80) + "\n\n")
 
         return result
       end

data/lib/terraform-wrapper/shared/variables.rb

@@ -0,0 +1,66 @@
+###############################################################################
+
+module TerraformWrapper
+
+###############################################################################
+
+  module Shared
+
+###############################################################################
+
+    class Variables
+
+###############################################################################
+
+      include TerraformWrapper::Shared::Logging
+
+###############################################################################
+
+      @@reserved = [ "component", "config", "service" ]
+
+###############################################################################
+
+      attr_reader :values
+
+###############################################################################
+
+      def initialize(values: Hash.new, sort: true)
+        cleansed = cleanse(values: values)
+        @values = sort ? cleansed.sort.to_h : cleansed
+      end
+
+###############################################################################
+
+      private
+
+###############################################################################
+
+      def cleanse(values:)
+        result = Hash.new
+
+        values.keys.each do |key|
+          logger.fatal("Could not clean variables hash. All keys MUST be strings!") unless key.kind_of?(String)
+          logger.fatal("Could not clean variables hash, key: #{key.downcase} is reserved and cannot be used!") if @@reserved.include?(key.downcase)
+          logger.fatal("Could not clean variables hash, duplicate key found: #{key.downcase}!") if result.key?(key.downcase.to_sym)
+          logger.fatal("Could not clean variables hash, value for: #{key.downcase} is not a string!") unless values[key].kind_of?(String)
+          logger.fatal("Could not clean variables hash, value for: #{key.downcase} is empty!") if values[key].strip.empty?
+
+          result[key.downcase.to_sym] = values[key].strip
+        end
+
+        return result
+      end
+
+###############################################################################
+
+    end
+
+###############################################################################
+
+  end
+
+###############################################################################
+
+end
+
+###############################################################################

data/lib/terraform-wrapper/tasks/apply.rb

@@ -16,22 +16,20 @@ module TerraformWrapper
 
 ###############################################################################
 
-      @backend
+      include TerraformWrapper::Shared::Logging
+
+###############################################################################
+
       @binary
       @code
-      @configs
-      @overrides
-      @service
+      @options
 
 ###############################################################################
 
-      def initialize(backend:, binary:, code:, configs:, overrides:, service:)
-        @backend   = backend
-        @binary    = binary
-        @code      = code
-        @configs   = configs
-        @overrides = overrides
-        @service   = service
+      def initialize(binary:, code:, options:)
+        @binary  = binary
+        @code    = code
+        @options = options
 
         yield self if block_given?
 
@@ -41,13 +39,17 @@ module TerraformWrapper
 ###############################################################################
 
       def apply_task
-        desc "Applies infrastructure with Terraform for a given configuration on a workspace."
+        desc "Applies infrastructure with Terraform for a given configuration on an infrastructure component."
         task :apply, [:config, :plan] => :binary do |t, args|
-          $logger.info("Running Terraform apply for service: #{@service}, component: #{@code.name}...")
+          options = @options.merge({"name" => args[:config]})
 
-          config = TerraformWrapper::Shared::Config.new(backend: @backend, base: @configs, code: @code, name: args[:config], overrides: @overrides, service: @service)
+          logger.info("Processing configuration for Terraform apply...")
+
+          config = TerraformWrapper::Shared::Config.new(code: @code, options: options)
           runner = TerraformWrapper::Shared::Runner.new(binary: @binary, code: @code)
 
+          logger.info("Running Terraform apply for service: #{config.service}, component: #{@code.name}...")
+
           runner.init(config: config)
           runner.apply(file: args[:plan])
         end