terradactyl 0.13.0

data/Rakefile

@@ -0,0 +1,61 @@
+require 'bundler'
+require 'open3'
+require 'uri'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new(:doc) do |t|
+  t.rspec_opts = "--format doc"
+end
+
+task :default => :spec
+
+BUILD_DIR = 'pkg'
+
+def bundler
+  @bundler ||= Bundler::GemHelper.new
+end
+
+def execute(cmd)
+  Open3.popen2e(ENV, cmd) do |stdin, stdout_err, wait_thru|
+    puts $_ while stdout_err.gets
+    wait_thru.value.exitstatus
+  end
+end
+
+def name
+  bundler.gemspec.name
+end
+
+def version
+  bundler.gemspec.version
+end
+
+def allowed_push_host
+  bundler.gemspec.metadata['allowed_push_host'] || String.new
+end
+
+def gem_server
+  URI.parse(allowed_push_host).host
+end
+
+def resultant_gem
+  "#{BUILD_DIR}/#{name}-#{version}.gem"
+end
+
+desc "Lint gem"
+task :lint do
+  exit(execute('bundle exec rubocop lib'))
+end
+
+desc "Build gem"
+task :build do
+  bundler.build_gem
+end
+
+desc "Clean all builds"
+task :clean do
+  FileUtils.rm_rf BUILD_DIR if File.exist? BUILD_DIR
+end

data/examples/multi-tf-version/stacks/tfv11/example.tf

@@ -0,0 +1 @@
+resource "null_resource" "foo" {}

data/examples/multi-tf-version/stacks/tfv11/terradactyl.yaml

@@ -0,0 +1,3 @@
+terradactyl:
+  terraform:
+    version: '0.11.14' # an explicit version

data/examples/multi-tf-version/stacks/tfv12/example.tf

@@ -0,0 +1 @@
+resource "null_resource" "bar" {}

data/examples/multi-tf-version/stacks/tfv12/terradactyl.yaml

@@ -0,0 +1,3 @@
+terradactyl:
+  terraform:
+    version: 0.12.29

data/examples/multi-tf-version/stacks/tfv13/example.tf

@@ -0,0 +1 @@
+resource "null_resource" "baz" {}

data/examples/multi-tf-version/stacks/tfv13/terradactyl.yaml

@@ -0,0 +1,3 @@
+terradactyl:
+  terraform:
+    version: '~> 0.13.5' # >= 0.13.5 && < 0.14.0

data/examples/multi-tf-version/terradactyl.yaml

@@ -0,0 +1,3 @@
+terradactyl:
+  terraform:
+    version: 0.12.29

data/examples/simple/stacks/demo/example.tf

@@ -0,0 +1 @@
+resource "null_resource" "demo" {}

data/examples/simple/terradactyl.yaml

@@ -0,0 +1 @@
+terradactyl:

data/exe/td

@@ -0,0 +1 @@
+exe/terradactyl

data/exe/terradactyl

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'terradactyl'
+
+trap 'SIGINT' do
+  puts
+  puts 'Caught Interrupt. Exiting ...'
+  exit 1
+end
+
+Terradactyl::CLI.start

data/lib/terradactyl.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'rake'
+require 'open3'
+require 'yaml'
+require 'json'
+require 'ostruct'
+require 'digest'
+require 'singleton'
+require 'colorize'
+require 'deepsort'
+require 'deep_merge'
+require 'terradactyl/terraform'
+
+require_relative 'terradactyl/version'
+require_relative 'terradactyl/config'
+require_relative 'terradactyl/commands'
+require_relative 'terradactyl/common'
+require_relative 'terradactyl/stack'
+require_relative 'terradactyl/stacks'
+require_relative 'terradactyl/filters'
+require_relative 'terradactyl/cli'

data/lib/terradactyl/cli.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Terradactyl
+  # rubocop:disable Metrics/ClassLength
+  class CLI < Thor
+    include Common
+    def self.exit_on_failure?
+      true
+    end
+
+    def initialize(*args)
+      # Hook ensures abort on stack errors
+      at_exit { abort if Stacks.error? }
+      super
+    end
+
+    no_commands do
+      # Monkey-patch Thor internal method to break out of nested calls
+      def invoke_command(command, *args)
+        catch(:error) { super }
+      end
+
+      def validate_smartplan(stacks)
+        if stacks.empty?
+          print_message 'No Stacks Modified ...'
+          print_line 'Did you forget to `git add` your selected changes?'
+        end
+        stacks
+      end
+
+      def validate_planpr(stacks)
+        if stacks.empty?
+          print_message 'No Stacks Modified ...'
+          print_line 'Skipping plan ...'
+        end
+        stacks
+      end
+
+      def generate_report(report)
+        data_file = "#{config.base_folder}.audit.json"
+        print_warning "Writing Report: #{data_file} ..."
+        report[:error] = Stacks.error.map { |s| "#{config.base_folder}/#{s.name}" }.sort
+        File.write data_file, JSON.pretty_generate(report)
+        print_ok 'Done!'
+      end
+    end
+
+    #################################################################
+    # GENERIC TASKS
+    # * These tasks are used regularly against stacks, by name.
+    #################################################################
+
+    desc 'defaults', 'Print the compiled configuration'
+    def defaults
+      puts config.to_h.to_yaml
+    end
+
+    desc 'stacks', 'List the stacks'
+    def stacks
+      print_ok 'Stacks:'
+      Stacks.load.each do |name|
+        print_dot name.to_s
+      end
+    end
+
+    desc 'version', 'Print version'
+    def version
+      print_message format('version: %<semver>s', semver: Terradactyl::VERSION)
+    end
+
+    #################################################################
+    # SPECIAL TASKS
+    # * These tasks are related to Git state and PR planning ops.
+    # * Some are useful only in pipelines. These are hidden.
+    #################################################################
+
+    desc 'planpr', 'Plan stacks against origin/HEAD (used for PRs)', hide: true
+    def planpr
+      print_header 'SmartPlanning PR ...'
+      stacks = Stacks.load(filter: StacksPlanFilterGitDiffOriginBranch.new)
+      validate_planpr(stacks).each do |name|
+        clean(name)
+        init(name)
+        plan(name)
+        @stack = nil
+      end
+    end
+
+    desc 'smartplan', 'Plan any stacks that differ from Git HEAD'
+    def smartplan
+      print_header 'SmartPlanning Stacks ...'
+      stacks = Stacks.load(filter: StacksPlanFilterGitDiffHead.new)
+      validate_smartplan(stacks).each do |name|
+        clean(name)
+        init(name)
+        plan(name)
+        @stack = nil
+      end
+    end
+
+    desc 'smartapply', 'Apply any stacks that contain plan files', hide: true
+    def smartapply
+      print_header 'SmartApplying Stacks ...'
+      stacks = Stacks.load(filter: StacksApplyFilterPrePlanned.new)
+      print_warning 'No stacks contain plan files ...' unless stacks.any?
+      stacks.each do |name|
+        apply(name)
+        @stack = nil
+      end
+      print_message "Total Stacks Modified: #{stacks.size}"
+    end
+
+    desc 'smartrefresh', 'Refresh any stacks that contain plan files', hide: true
+    def smartrefresh
+      print_header 'SmartRefreshing Stacks ...'
+      stacks = Stacks.load(filter: StacksApplyFilterPrePlanned.new)
+      print_warning 'No stacks contain plan files ...' unless stacks.any?
+      stacks.each do |name|
+        refresh(name)
+        @stack = nil
+      end
+      print_message "Total Stacks Refreshed: #{stacks.size}"
+    end
+
+    #################################################################
+    # META-STACK TASKS
+    # * These tasks are used regularly against groups of stacks, but
+    # the `quickplan` task is an exception to this rule.
+    #################################################################
+
+    desc 'quickplan NAME', 'Clean, init and plan a stack, by name'
+    def quickplan(name)
+      print_header "Quick planning #{name} ..."
+      clean(name)
+      init(name)
+      plan(name)
+    end
+
+    desc 'clean-all', 'Clean all stacks'
+    def clean_all
+      print_header 'Cleaning ALL Stacks ...'
+      Stacks.load.each do |name|
+        clean(name)
+        @stack = nil
+      end
+    end
+
+    desc 'plan-all', 'Plan all stacks'
+    def plan_all
+      print_header 'Planning ALL Stacks ...'
+      Stacks.load.each do |name|
+        catch(:error) do
+          clean(name)
+          init(name)
+          plan(name)
+        end
+        @stack = nil
+      end
+    end
+
+    desc 'audit-all', 'Audit all stacks'
+    options report: :optional
+    method_option :report, type: :boolean
+    # rubocop:disable Metrics/AbcSize
+    def audit_all
+      report = { start: Time.now.to_json }
+      print_header 'Auditing ALL Stacks ...'
+      Stacks.load.each do |name|
+        catch(:error) do
+          clean(name)
+          init(name)
+          audit(name)
+        end
+        @stack = nil
+      end
+      report[:finish] = Time.now.to_json
+      if options[:report]
+        print_header 'Audit Report ...'
+        generate_report(report)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    desc 'validate-all', 'Validate all stacks'
+    def validate_all
+      print_header 'Validating ALL Stacks ...'
+      Stacks.load.each do |name|
+        catch(:error) do
+          clean(name)
+          init(name)
+          validate(name)
+        end
+        @stack = nil
+      end
+    end
+
+    #################################################################
+    # TARGETED STACK TASKS
+    # * These tasks are used regularly against stacks, by name.
+    #################################################################
+
+    desc 'lint NAME', 'Lint an individual stack, by name'
+    def lint(name)
+      @stack ||= Stack.new(name)
+      print_ok "Linting: #{@stack.name}"
+      if @stack.lint.zero?
+        print_ok "Formatting OK: #{@stack.name}"
+      else
+        Stacks.error!(@stack)
+        print_warning "Bad Formatting: #{@stack.name}"
+      end
+    end
+
+    desc 'fmt NAME', 'Format an individual stack, by name'
+    def fmt(name)
+      @stack ||= Stack.new(name)
+      print_warning "Formatting: #{@stack.name}"
+      if @stack.fmt.zero?
+        print_ok "Formatted: #{@stack.name}"
+      else
+        Stacks.error!(@stack)
+        print_crit "Formatting failed: #{@stack.name}"
+      end
+    end
+
+    desc 'init NAME', 'Init an individual stack, by name'
+    def init(name)
+      @stack ||= Stack.new(name)
+      print_ok "Initializing: #{@stack.name}"
+      if @stack.init.zero?
+        print_ok "Initialized: #{@stack.name}"
+      else
+        Stacks.error!(@stack)
+        print_crit "Initialization failed: #{@stack.name}"
+        throw :error
+      end
+    end
+
+    desc 'plan NAME', 'Plan an individual stack, by name'
+    # rubocop:disable Metrics/AbcSize
+    def plan(name)
+      @stack ||= Stack.new(name)
+      print_ok "Planning: #{@stack.name}"
+      case @stack.plan
+      when 0
+        print_ok "No changes: #{@stack.name}"
+      when 1
+        Stacks.error!(@stack)
+        print_crit "Plan failed: #{@stack.name}"
+        @stack.print_plan
+        throw :error
+      when 2
+        Stacks.dirty!(@stack)
+        print_warning "Changes detected: #{@stack.name}"
+        @stack.print_plan
+      else
+        raise
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    desc 'audit NAME', 'Audit an individual stack, by name'
+    def audit(name)
+      plan(name)
+      if (@stack = Stacks.dirty?(name))
+        Stacks.error!(@stack)
+        print_crit "Dirty stack: #{@stack.name}"
+      end
+    end
+
+    desc 'validate NAME', 'Validate an individual stack, by name'
+    def validate(name)
+      @stack ||= Stack.new(name)
+      print_ok "Validating: #{@stack.name}"
+      if @stack.validate.zero?
+        print_ok "Validated: #{@stack.name}"
+      else
+        Stacks.error!(@stack)
+        print_crit "Validation failed: #{@stack.name}"
+        throw :error
+      end
+    end
+
+    desc 'clean NAME', 'Clean an individual stack, by name'
+    def clean(name)
+      @stack ||= Stack.new(name)
+      print_warning "Cleaning: #{@stack.name}"
+      @stack.clean
+      print_ok "Cleaned: #{@stack.name}"
+    end
+
+    #################################################################
+    # HIDDEN TARGETED STACK TASKS
+    # * These tasks are destructive in nature and do not require
+    # regular use.
+    #################################################################
+
+    desc 'apply NAME', 'Apply an individual stack, by name', hide: true
+    def apply(name)
+      @stack ||= Stack.new(name)
+      print_warning "Applying: #{@stack.name}"
+      if @stack.apply.zero?
+        print_ok "Applied: #{@stack.name}"
+      else
+        Stacks.error!(@stack)
+        print_crit "Failed to apply changes: #{@stack.name}"
+      end
+    end
+
+    desc 'refresh NAME', 'Refresh state on an individual stack, by name', hide: true
+    def refresh(name)
+      @stack ||= Stack.new(name)
+      print_crit "Refreshing: #{@stack.name}"
+      if @stack.refresh.zero?
+        print_warning "Refreshed: #{@stack.name}"
+      else
+        Stacks.error!(@stack)
+        print_crit "Failed to refresh stack: #{@stack.name}"
+      end
+    end
+
+    desc 'destroy NAME', 'Destroy an individual stack, by name', hide: true
+    def destroy(name)
+      @stack ||= Stack.new(name)
+      print_crit "Destroying: #{@stack.name}"
+      if @stack.destroy.zero?
+        print_warning "Destroyed: #{@stack.name}"
+      else
+        Stacks.error!(@stack)
+        print_crit "Failed to apply changes: #{@stack.name}"
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end