mux_tf 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 72d1bbf43fcbb38f0d1a8c4bba72321f582a4ff10ce75a49c87cef89e21647ac
+  data.tar.gz: 2be9f70c1ce5a58df894866e02cd8efcfa04aa500ac394218368ef2bb88ee6fc
+SHA512:
+  metadata.gz: e64d359f26aafe4d2fd88f00d6294132ee1ed917a5bd02eda45500d55700327e7c70fad0a053b2007db2e350c822509288e1900ad30601571bce097795d70ae4
+  data.tar.gz: 1c3b1ac826bace9b8191ce9ae55b392956ddb24e3d89d4aef86080799f408fd545d9efe4254e309a48515a9896e9f757ac20dc7938f42ee12d9f09a3a1a4cc8e

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mux_tf.gemspec
+gemspec
+
+gem 'rake', '~> 12.0'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Piotr Banasik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# MuxTf
+
+Terraform Module Multiplexer
+
+## Installation
+
+```shell
+gem install mux_tf
+```
+
+## Usage
+
+At the root folder of your terraform modules eg:
+
+```text
+ROOT/
+     production/ << == HERE
+                group1/
+                       cluster1/
+                                main.tf
+                       cluster2/
+                                main.tf
+                group2/
+                       cluster3/
+                                main.tf
+                       cluster4/
+                                main.tf
+     sandbox/ << == OR HERE
+             {SIMILLAR STRUCTURE}
+```
+
+## Development
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotrb/mux_tf.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+# task :default => :spec

data/exe/tf_current

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(File.join(__dir__, '..', 'lib'))
+
+require 'mux_tf'
+
+MuxTf::Cli.run(:current, ARGV)

data/exe/tf_mux

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(File.join(__dir__, '..', 'lib'))
+
+require 'mux_tf'
+
+MuxTf::Cli.run(:mux, ARGV)

data/exe/tf_plan_summary

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path(File.join(__dir__, '..', 'lib'))
+
+require 'mux_tf'
+
+MuxTf::Cli.run(:plan_summary, ARGV)

data/lib/mux_tf.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'English'
+
+require 'shellwords'
+require 'optparse'
+require 'json'
+require 'open3'
+
+require 'piotrb_cli_utils'
+require 'stateful_parser'
+
+require 'active_support/core_ext'
+
+require 'paint'
+require 'pastel'
+require 'tty-prompt'
+require 'tty-table'
+require 'dotenv'
+
+require_relative './mux_tf/version'
+require_relative './mux_tf/cli'
+require_relative './mux_tf/tmux'
+require_relative './mux_tf/terraform_helpers'
+require_relative './mux_tf/plan_formatter'
+
+module MuxTf
+end

data/lib/mux_tf/cli.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Cli
+    def self.run(mode, args)
+      case mode
+      when :mux
+        require_relative "./cli/mux"
+        MuxTf::Cli::Mux.run(args)
+      when :current
+        require_relative "./cli/current"
+        MuxTf::Cli::Current.run(args)
+      when :plan_summary
+        require_relative "./cli/plan_summary"
+        MuxTf::Cli::PlanSummary.run(args)
+      else
+        fail_with "unhandled mode: #{mode.inspect}"
+      end
+    end
+  end
+end

data/lib/mux_tf/cli/current.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+module MuxTf
+  module Cli
+    module Current
+      extend TerraformHelpers
+      extend PiotrbCliUtils::Util
+      extend PiotrbCliUtils::CriCommandSupport
+      extend PiotrbCliUtils::CmdLoop
+
+      PLAN_FILENAME = 'foo.tfplan'
+
+      class << self
+        def run(args)
+          if args[0] == 'cli'
+            cmd_loop
+            return
+          end
+
+          folder_name = File.basename(Dir.getwd)
+          log "Processing #{Paint[folder_name, :cyan]} ..."
+
+          ENV['TF_IN_AUTOMATION'] = '1'
+          ENV['TF_INPUT'] = '0'
+
+          return launch_cmd_loop(:error) unless run_validate
+
+          if ENV['TF_UPGRADE']
+            upgrade_status, upgrade_meta = run_upgrade
+            return launch_cmd_loop(:error) unless upgrade_status == :ok
+          end
+
+          plan_status, @plan_meta = create_plan(PLAN_FILENAME)
+
+          case plan_status
+          when :ok
+            log 'no changes, exiting', depth: 1
+          when :error
+            log 'something went wrong', depth: 1
+            launch_cmd_loop(plan_status)
+          when :changes
+            log 'Printing Plan Summary ...', depth: 1
+            pretty_plan_summary(PLAN_FILENAME)
+            launch_cmd_loop(plan_status)
+          when :unknown
+            launch_cmd_loop(plan_status)
+          end
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          puts Paint['Unhandled Exception!', :red]
+          puts '=' * 20
+          puts e.full_message
+          puts
+          puts '< press enter to continue >'
+          gets
+          exit 1
+        end
+
+      private
+
+        def run_validate
+          remedies = PlanFormatter.process_validation(validate)
+          process_remedies(remedies)
+        end
+
+        def process_remedies(remedies)
+          if remedies.delete? :init
+            log 'Running terraform init ...', depth: 2
+            tf_init
+            remedies = PlanFormatter.process_validation(validate)
+            process_remedies(remedies)
+          end
+          unless remedies.empty?
+            log "unprocessed remedies: #{remedies.to_a}", depth: 1
+            return false
+          end
+          true
+        end
+
+        def validate
+          log 'Validating module ...', depth: 1
+          tf_validate.parsed_output
+        end
+
+        def create_plan(filename)
+          log 'Preparing Plan ...', depth: 1
+          exit_code, meta = PlanFormatter.pretty_plan(filename)
+          case exit_code
+          when 0
+            [:ok, meta]
+          when 1
+            [:error, meta]
+          when 2
+            [:changes, meta]
+          else
+            log Paint["terraform plan exited with an unknown exit code: #{exit_code}", :yellow]
+            [:unknown, meta]
+          end
+        end
+
+        def launch_cmd_loop(status)
+          return if ENV['NO_CMD']
+
+          case status
+          when :error, :unknown
+            log Paint['Dropping to command line so you can fix the issue!', :red]
+          when :changes
+            log Paint['Dropping to command line so you can review the changes.', :yellow]
+          end
+          cmd_loop(status)
+        end
+
+        def cmd_loop(status = nil)
+          root_cmd = build_root_cmd
+
+          folder_name = File.basename(Dir.getwd)
+
+          puts root_cmd.help
+
+          prompt = "#{folder_name} => "
+          case status
+          when :error, :unknown
+            prompt = "[#{Paint[status.to_s, :red]}] #{prompt}"
+          when :changes
+            prompt = "[#{Paint[status.to_s, :yellow]}] #{prompt}"
+          end
+
+          run_cmd_loop(prompt) do |cmd|
+            throw(:stop, :no_input) if cmd == ''
+            args = Shellwords.split(cmd)
+            root_cmd.run(args, {}, hard_exit: false)
+          end
+        end
+
+        def build_root_cmd
+          root_cmd = define_cmd(nil)
+
+          root_cmd.add_command(plan_cmd)
+          root_cmd.add_command(apply_cmd)
+          root_cmd.add_command(shell_cmd)
+          root_cmd.add_command(force_unlock_cmd)
+          root_cmd.add_command(upgrade_cmd)
+          root_cmd.add_command(interactive_cmd)
+
+          root_cmd.add_command(exit_cmd)
+          root_cmd
+        end
+
+        def plan_cmd
+          define_cmd('plan', summary: 'Re-run plan') do |_opts, _args, _cmd|
+            run_validate && run_plan
+          end
+        end
+
+        def apply_cmd
+          define_cmd('apply', summary: 'Apply the current plan') do |_opts, _args, _cmd|
+            status = tf_apply(filename: PLAN_FILENAME)
+            if status.success?
+              throw :stop, :done
+            else
+              log 'Apply Failed!'
+            end
+          end
+        end
+
+        def shell_cmd
+          define_cmd('shell', summary: 'Open your default terminal in the current folder') do |_opts, _args, _cmd|
+            log Paint['Launching shell ...', :yellow]
+            log Paint['When it exits you will be back at this prompt.', :yellow]
+            system ENV['SHELL']
+          end
+        end
+
+        def force_unlock_cmd
+          define_cmd('force-unlock', summary: 'Force unlock state after encountering a lock error!') do
+            prompt = TTY::Prompt.new(interrupt: :noop)
+
+            table = TTY::Table.new(header: %w[Field Value])
+            table << ['Lock ID', @plan_meta['ID']]
+            table << ['Operation', @plan_meta['Operation']]
+            table << ['Who', @plan_meta['Who']]
+            table << ['Created', @plan_meta['Created']]
+
+            puts table.render(:unicode, padding: [0, 1])
+
+            if @plan_meta && @plan_meta['error'] == 'lock'
+              done = catch(:abort) do
+                if @plan_meta['Operation'] != 'OperationTypePlan'
+                  throw :abort unless prompt.yes?(
+                    "Are you sure you want to force unlock a lock for operation: #{@plan_meta['Operation']}",
+                    default: false
+                  )
+                end
+
+                throw :abort unless prompt.yes?(
+                  'Are you sure you want to force unlock this lock?',
+                  default: false
+                )
+
+                status = tf_force_unlock(id: @plan_meta['ID'])
+                if status.success?
+                  log 'Done!'
+                else
+                  log Paint["Failed with status: #{status}", :red]
+                end
+
+                true
+              end
+
+              log Paint['Aborted', :yellow] unless done
+            else
+              log Paint['No lock error or no plan ran!', :red]
+            end
+          end
+        end
+
+        def upgrade_cmd
+          define_cmd('upgrade', summary: 'Upgrade modules/plguins') do |_opts, _args, _cmd|
+            status, meta = run_upgrade
+            if status != :ok
+              log meta.inspect unless meta.empty?
+              log 'Upgrade Failed!'
+            end
+          end
+        end
+
+        def interactive_cmd
+          define_cmd('interactive', summary: 'Apply interactively') do |_opts, _args, _cmd|
+            status = run_shell(['tf-plan-summary', PLAN_FILENAME, '-i'], return_status: true)
+            if status != 0
+              log 'Interactive Apply Failed!'
+            else
+              run_plan
+            end
+          end
+        end
+
+        def run_plan
+          plan_status, @plan_meta = create_plan(PLAN_FILENAME)
+
+          case plan_status
+          when :ok
+            log 'no changes', depth: 1
+          when :error
+            log 'something went wrong', depth: 1
+          when :changes
+            log 'Printing Plan Summary ...', depth: 1
+            pretty_plan_summary(PLAN_FILENAME)
+          when :unknown
+            # nothing
+          end
+        end
+
+        def run_upgrade
+          exit_code, meta = PlanFormatter.process_upgrade
+          case exit_code
+          when 0
+            [:ok, meta]
+          when 1
+            [:error, meta]
+          # when 2
+          #   [:changes, meta]
+          else
+            log Paint["terraform init upgrade exited with an unknown exit code: #{exit_code}", :yellow]
+            [:unknown, meta]
+          end
+        end
+
+        def tf_plan_summrary_cmd
+          @tf_plan_summrary_cmd ||= File.expand_path(File.join(__dir__, '..', '..', '..', 'exe', 'tf_plan_summary'))
+        end
+
+        def pretty_plan_summary(filename)
+          run_with_each_line([tf_plan_summrary_cmd, filename]) do |raw_line|
+            log raw_line.rstrip, depth: 2
+          end
+        end
+    end
+  end
+  end
+end