terradactyl 0.13.0

data/lib/terradactyl/commands.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Terradactyl
+  module Commands
+    class << self
+      def extend_by_revision(tf_version, object)
+        anon_module = revision_module
+
+        anon_module.include(self)
+        anon_module.prepend(revision_constant(tf_version))
+
+        object.extend(anon_module)
+      end
+
+      private
+
+      def revision_module
+        Module.new do
+          class << self
+            def extended(base)
+              terraform_methods.each { |method| decorate(base, method) }
+            end
+
+            def decorate(base, method)
+              base.define_singleton_method(method) do |*args, &block|
+                setup_terraform
+                pushd(stack_path)
+                super(*args, &block)
+              ensure
+                popd
+              end
+            end
+
+            private
+
+            def terraform_methods
+              public_instance_methods.reject { |m| m == :terraform_methods }
+            end
+          end
+        end
+      end
+
+      def revision_constant(tf_version)
+        revision_name = ['Rev', *tf_version.split('.').take(2)].join
+        const_get(revision_name)
+      end
+    end
+
+    include Terraform::Commands
+
+    def init
+      Init.execute(dir_or_plan: nil, options: command_options)
+    end
+
+    def plan
+      options = command_options.tap do |dat|
+        dat.state    = state_file
+        dat.out      = plan_file
+        dat.no_color = true
+      end
+
+      captured = Plan.execute(dir_or_plan: nil,
+                              options: options,
+                              capture: true)
+
+      output = case captured.exitstatus
+               when 0
+                 'No changes. Infrastructure is up-to-date.'
+               when 1
+                 captured.stderr
+               when 2
+                 captured.stdout
+               end
+
+      @plan_file_obj             = load_plan_file
+      @plan_file_obj.plan_output = output
+      @plan_file_obj.save
+
+      captured.exitstatus
+    end
+
+    def apply
+      Apply.execute(dir_or_plan: plan_file, options: command_options)
+    end
+
+    def refresh
+      options = command_options.tap { |dat| dat.state = state_file }
+      Refresh.execute(dir_or_plan: nil, options: options)
+    end
+
+    def destroy
+      options = command_options.tap { |dat| dat.state = state_file }
+      Destroy.execute(dir_or_plan: nil, options: options)
+    end
+
+    def lint
+      options = command_options.tap { |dat| dat.check = true }
+      Fmt.execute(dir_or_plan: nil, options: options)
+    end
+
+    def fmt
+      Fmt.execute(dir_or_plan: nil, options: command_options)
+    end
+
+    def validate
+      Validate.execute(dir_or_plan: nil, options: command_options)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def clean
+      removals = config.cleanup.match.map { |p| Dir.glob("**/#{p}") }
+      removals << `find . -type d -empty`.split if config.cleanup.empty
+      removals = removals.flatten.sort.uniq.each do |trash|
+        print_dot("Removing: #{trash}", :light_yellow)
+        FileUtils.rm_rf(trash)
+      end
+      puts unless removals.empty?
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    def load_plan_file
+      Terraform::PlanFile.new(plan_path: plan_file, parser: parser)
+    end
+
+    module Rev011
+      include Terraform::Commands
+
+      def checklist
+        Checklist.execute(dir_or_plan: nil, options: command_options)
+      end
+
+      private
+
+      def parser
+        Terraform::Rev011::PlanFileParser
+      end
+    end
+
+    module Rev012
+      include Terraform::Commands
+
+      private
+
+      def parser
+        Terraform::Rev012::PlanFileParser
+      end
+    end
+
+    module Rev013
+      include Terraform::Commands
+
+      private
+
+      def parser
+        Terraform::Rev012::PlanFileParser
+      end
+    end
+  end
+end

data/lib/terradactyl/common.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Terradactyl
+  module Common
+    COLUMN_WIDTH = 80
+    BORDER_CHAR  = '#'
+
+    module_function
+
+    def config
+      @config ||= ConfigProject.instance
+    end
+
+    def terraform_binary
+      config.terraform.binary || %(terraform)
+    end
+
+    def tag
+      'Terradactyl'
+    end
+
+    def border
+      BORDER_CHAR * COLUMN_WIDTH
+    end
+
+    def centre
+      COLUMN_WIDTH / 2
+    end
+
+    def dot_icon
+      config.misc.utf8 ? '•' : '*'
+    end
+
+    def stack_icon
+      config.misc.utf8 ? '  𝓣  ' : '  |||  '
+    end
+
+    def print_crit(msg)
+      print_message(msg, :light_red)
+    end
+
+    def print_ok(msg)
+      print_message(msg, :light_green)
+    end
+
+    def print_warning(msg)
+      print_message(msg, :light_yellow)
+    end
+
+    def print_content(content)
+      content.split("\n").each do |line|
+        print_line line
+      end
+      puts
+    end
+
+    def print_dot(msg, color = :light_blue)
+      string = "     #{dot_icon} #{msg}"
+      cputs(string, color)
+    end
+
+    def print_line(msg, color = :light_blue)
+      string = "     #{msg}"
+      cputs(string, color)
+    end
+
+    def print_message(msg, color = :light_blue)
+      string = "#{stack_icon}[#{tag}] #{msg}"
+      cputs(string, color)
+      puts
+    end
+
+    def print_header(msg, color = :blue)
+      indent  = centre + msg.size / 2 - 1
+      content = format("#%#{indent}s", "#{tag} | #{msg}")
+      string  = [border, content, border].join("\n")
+      cputs(string, color)
+      puts
+    end
+
+    def cputs(msg, color)
+      puts config.misc.disable_color ? msg : msg.send(color.to_s)
+    end
+  end
+end

data/lib/terradactyl/config.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Terradactyl
+  class ConfigApplication
+    CONFIG_DEFAULTS = <<~CONFIG_DEFAULTS
+      ---
+      terradactyl:
+        base_folder: stacks
+        terraform:
+          binary:
+          version:
+          autoinstall: true
+          install_dir:
+          echo: false
+          quiet: true
+          init:
+            lock: false
+            force_copy: true
+          plan:
+            lock: false
+            parallelism: 5
+            detailed_exitcode: true
+          apply:
+            parallelism: 5
+          refresh:
+            input: false
+          destroy:
+            parallelism: 5
+            force: true
+        environment:
+          TF_PLUGIN_CACHE_DIR: ~/.terraform.d/plugins
+        misc:
+          utf8: true
+          disable_color: false
+        cleanup:
+          empty: true
+          match:
+            - "*.tfout"
+            - "*.tflock"
+            - "*.zip"
+            - ".terraform"
+    CONFIG_DEFAULTS
+
+    attr_reader :config_file, :terradactyl
+
+    def initialize(config_file = nil, defaults: nil)
+      @config_file = config_file
+      @defaults    = load_defaults(defaults)
+      @overlay     = load_overlay(config_file)
+      load_config
+    end
+
+    def reload
+      load_config
+    end
+
+    def to_h
+      @config
+    end
+    alias to_hash to_h
+
+    private
+
+    def load_config
+      @config = [
+        @defaults,
+        @overlay
+      ].inject({}) do |memo, obj|
+        memo.deep_merge!(obj, overwrite_arrays: true)
+        Marshal.load(Marshal.dump(memo))
+      end
+      @terradactyl = structify(@config).terradactyl
+      configure_colorization
+      @terradactyl
+    end
+
+    def load_defaults(defaults)
+      defaults || YAML.safe_load(CONFIG_DEFAULTS)
+    end
+
+    def load_overlay(config_file)
+      YAML.load_file(config_file.to_s)
+    rescue Errno::ENOENT
+      load_empty
+    end
+
+    def load_empty
+      { 'terradactyl' => {} }
+    end
+
+    def structify(hash)
+      OpenStruct.new(hash.each_with_object({}) do |(key, val), memo|
+        memo[key] = val.is_a?(Hash) ? structify(val) : val
+      end)
+    end
+
+    def configure_colorization
+      String.disable_colorization = terradactyl.misc.disable_color
+    end
+
+    def method_missing(sym, *args, &block)
+      terradactyl.send(sym.to_sym, *args, &block)
+    rescue NameError
+      super
+    end
+
+    def respond_to_missing?(sym, *args)
+      terradactyl.respond_to?(sym) || super
+    end
+  end
+
+  class ConfigProject < ConfigApplication
+    include Singleton
+
+    CONFIG_PROJECT_FILE = 'terradactyl.yaml'
+
+    def self.instance
+      @instance ||= new
+    end
+
+    private_class_method :new
+
+    def load_overlay(_overload)
+      YAML.load_file(config_file)
+    rescue Errno::ENOENT => e
+      abort "FATAL: Could not load project file: `#{config_file}`, #{e.message}"
+    end
+
+    def config_file
+      @config_file = CONFIG_PROJECT_FILE
+    end
+  end
+
+  class ConfigStack < ConfigApplication
+    attr_reader :stack_name, :stack_path, :base_folder
+
+    def initialize(stack_name)
+      @stack_name     = stack_name
+      @project_config = ConfigProject.instance
+      @base_folder    = @project_config.base_folder
+      @stack_path     = "#{@base_folder}/#{@stack_name}"
+      @config_file    = "#{@stack_path}/#{ConfigProject::CONFIG_PROJECT_FILE}"
+      @defaults       = load_defaults(@project_config.to_h)
+      @overlay        = load_overlay(@config_file)
+      load_config
+    end
+
+    alias name stack_name
+    alias path stack_path
+
+    def state_file
+      'terraform.tfstate'
+    end
+
+    def state_path
+      "#{stack_path}/terraform.tfstate"
+    end
+
+    def plan_file
+      "#{stack_name}.tfout"
+    end
+
+    def plan_path
+      "#{stack_path}/#{plan_file}"
+    end
+  end
+end

data/lib/terradactyl/filters.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Terradactyl
+  class StacksPlanFilterDefault
+    include Common
+
+    def self.name
+      'default'
+    end
+
+    def self.desc
+      'A list of all stacks in the basedir'
+    end
+
+    def git_cmd
+      `git ls-files .`
+    end
+
+    def base_dir
+      config.base_folder
+    end
+
+    def stack_name(path)
+      path.split('/')[1]
+    end
+
+    def sift(stacks)
+      stacks
+    end
+  end
+
+  class StacksPlanFilterGitDiffHead < StacksPlanFilterDefault
+    def self.name
+      'diff-head'
+    end
+
+    def self.desc
+      'A list of all stacks that differ from Git HEAD'
+    end
+
+    def git_cmd
+      `git --no-pager diff --name-only HEAD .`
+    end
+
+    def sift(stacks)
+      modified = git_cmd.split.each_with_object([]) do |path, memo|
+        memo << stack_name(path) if path =~ /#{base_dir}/
+      end
+      stacks & modified
+    end
+  end
+
+  class StacksPlanFilterGitDiffFetchHead < StacksPlanFilterGitDiffHead
+    def self.name
+      'diff-fetch-head'
+    end
+
+    def self.desc
+      'A list of all stacks that differ from Git FETCH_HEAD'
+    end
+
+    def git_cmd
+      `git --no-pager diff --name-only FETCH_HEAD ORIG_HEAD .`
+    rescue StandardError
+      String.new
+    end
+  end
+
+  class StacksPlanFilterGitDiffOriginBranch < StacksPlanFilterGitDiffHead
+    def self.name
+      'diff-origin'
+    end
+
+    def self.desc
+      'A list of all stacks that differ from Git origin/HEAD'
+    end
+
+    def current_branch
+      `git symbolic-ref -q --short HEAD`
+    end
+
+    def git_cmd
+      `git --no-pager diff --name-only origin/#{current_branch} .`
+    rescue StandardError
+      String.new
+    end
+  end
+
+  class StacksApplyFilterDefault < StacksPlanFilterDefault
+  end
+
+  class StacksApplyFilterPrePlanned < StacksApplyFilterDefault
+    def sift(stacks)
+      targets = Dir.glob('**/*.tfout').each_with_object([]) do |path, memo|
+        memo << path.split('/')[1]
+      end
+      stacks & targets
+    end
+  end
+end