simplygenius-atmos 0.7.1 → 0.8.0

data/lib/atmos/terraform_executor.rb

@@ -1,267 +0,0 @@
-require_relative '../atmos'
-require_relative '../atmos/ipc'
-require_relative '../atmos/ui'
-require 'open3'
-require 'fileutils'
-require 'find'
-require 'climate_control'
-
-module Atmos
-
-  class TerraformExecutor
-    include GemLogger::LoggerSupport
-    include FileUtils
-    include Atmos::UI
-
-    class ProcessFailed < RuntimeError; end
-
-    def initialize(process_env: ENV, working_group: 'default')
-      @process_env = process_env
-      @working_group = working_group
-      @working_dir = Atmos.config.tf_working_dir(@working_group)
-      @recipes = Atmos.config["recipes.#{@working_group}"]
-    end
-
-    def run(*terraform_args, skip_backend: false, skip_secrets: false, get_modules: false, output_io: nil)
-      setup_working_dir(skip_backend: skip_backend)
-
-      if get_modules
-        logger.debug("Getting modules")
-        get_modules_io = StringIO.new
-        begin
-          execute("get", output_io: get_modules_io)
-        rescue Atmos::TerraformExecutor::ProcessFailed => e
-          logger.info(get_modules_io.string)
-          raise
-        end
-      end
-
-      return execute(*terraform_args, skip_secrets: skip_secrets, output_io: output_io)
-    end
-
-    private
-
-    def tf_cmd(*args)
-      ['terraform'] + args
-    end
-
-    def execute(*terraform_args, skip_secrets: false, output_io: nil)
-      cmd = tf_cmd(*terraform_args)
-      logger.debug("Running terraform: #{cmd.join(' ')}")
-
-      env = Hash[@process_env]
-      if ! skip_secrets
-        begin
-          env = env.merge(secrets_env)
-        rescue => e
-          logger.debug("Secrets not available: #{e}")
-        end
-      end
-
-      # lets tempfiles create by subprocesses be easily found by users
-      env['TMPDIR'] = Atmos.config.tmp_dir
-
-      # Lets terraform communicate back to atmos, e.g. for UI notifications
-      ipc = Atmos::Ipc.new(Atmos.config.tmp_dir)
-
-      IO.pipe do |stdout, stdout_writer|
-        IO.pipe do |stderr, stderr_writer|
-
-          stdout_writer.sync = stderr_writer.sync = true
-          # TODO: more filtering on terraform output?
-          stdout_thr = pipe_stream(stdout, output_io.nil? ? $stdout : output_io) do |data|
-            if data =~ /^[\e\[\dm\s]*Enter a value:[\e\[\dm\s]*$/
-              notify(message: "Terraform is waiting for user input")
-            end
-            data
-          end
-          stderr_thr = pipe_stream(stderr, output_io.nil? ? $stderr : output_io)
-
-          ipc.listen do |sock_path|
-
-            if Atmos.config['ipc.disable']
-              # Using : as the command makes execution of ipc from the
-              # terraform side a no-op in both cases of how we call it.  This
-              # way, terraform execution continues to work when IPC is disabled
-              # command = "$ATMOS_IPC_CLIENT <json_string>"
-              # program = ["sh", "-c", "$ATMOS_IPC_CLIENT"]
-              env['ATMOS_IPC_CLIENT'] = ":"
-            else
-              env['ATMOS_IPC_SOCK'] = sock_path
-              env['ATMOS_IPC_CLIENT'] = ipc.generate_client_script
-            end
-
-            # Was unable to get piping to work with stdin for some reason.  It
-            # worked in simple case, but started to fail when terraform config
-            # got more extensive.  Thus, using spawn to redirect stdin from the
-            # terminal direct to terraform, with IO.pipe to copy the outher
-            # streams.  Maybe in the future we can completely disconnect stdin
-            # and have atmos do the output parsing and stdin prompting
-            pid = spawn(env, *cmd,
-                        chdir: tf_recipes_dir,
-                        :out=>stdout_writer, :err=> stderr_writer, :in => :in)
-
-            logger.debug("Terraform started with pid #{pid}")
-            Process.wait(pid)
-          end
-
-          stdout_writer.close
-          stderr_writer.close
-          stdout_thr.join
-          stderr_thr.join
-
-          status = $?.exitstatus
-          logger.debug("Terraform exited: #{status}")
-          if status != 0
-            raise ProcessFailed.new "Terraform exited with non-zero exit code: #{status}"
-          end
-
-        end
-      end
-
-    end
-
-    def setup_working_dir(skip_backend: false)
-      clean_links
-      link_shared_plugin_dir
-      link_support_dirs
-      link_recipes
-      write_atmos_vars
-      setup_backend(skip_backend)
-    end
-
-    def setup_backend(skip_backend=false)
-      backend_file = File.join(tf_recipes_dir, 'atmos-backend.tf.json')
-      backend_config = (Atmos.config["backend"] || {}).clone
-
-      if backend_config.present? && ! skip_backend
-        logger.debug("Writing out terraform state backend config")
-
-        # Use a different state file per group
-        if @working_group
-          backend_config['key'] = "#{@working_group}-#{backend_config['key']}"
-        end
-
-        backend_type = backend_config.delete("type")
-
-        backend = {
-            "terraform" => {
-                "backend" => {
-                    backend_type => backend_config
-                }
-            }
-        }
-
-        File.write(backend_file, JSON.pretty_generate(backend))
-      else
-        logger.debug("Clearing terraform state backend config")
-        File.delete(backend_file) if File.exist?(backend_file)
-      end
-    end
-
-    # terraform currently (v0.11.3) doesn't handle maps with nested maps or
-    # lists well, so flatten them - nested maps get expanded into the top level
-    # one, with their keys being appended with underscores, and lists get
-    # joined with "," so we end up with a single hash with homogenous types
-    def homogenize_for_terraform(h, root={}, prefix="")
-      h.each do |k, v|
-        if v.is_a? Hash
-          homogenize_for_terraform(v, root, "#{k}_")
-        else
-          v = v.join(",") if v.is_a? Array
-          root["#{prefix}#{k}"] = v
-        end
-      end
-      return root
-    end
-
-    def tf_recipes_dir
-      @tf_recipes_dir ||= begin
-        dir = File.join(@working_dir, 'recipes')
-        logger.debug("Tf recipes dir: #{dir}")
-        mkdir_p(dir)
-        dir
-      end
-    end
-
-    def write_atmos_vars
-      File.open(File.join(tf_recipes_dir, 'atmos.auto.tfvars.json'), 'w') do |f|
-        atmos_var_config = atmos_config = homogenize_for_terraform(Atmos.config.to_h)
-
-        var_prefix = Atmos.config['var_prefix']
-        if var_prefix
-          atmos_var_config = Hash[atmos_var_config.collect {|k, v| ["#{var_prefix}#{k}", v]}]
-        end
-
-        var_hash = {
-            atmos_env: Atmos.config.atmos_env,
-            all_env_names: Atmos.config.all_env_names,
-            account_ids: Atmos.config.account_hash,
-            atmos_config: atmos_config
-        }
-        var_hash = var_hash.merge(atmos_var_config)
-        f.puts(JSON.pretty_generate(var_hash))
-      end
-    end
-
-    def secrets_env
-      # NOTE use an auto-deleting temp file if passing secrets through env ends
-      # up being problematic
-      # TODO fix the need for CC - TE calls for secrets which needs auth in
-      # ENV, so kinda clunk to have to do both CC and pass the env in
-      ClimateControl.modify(@process_env) do
-        secrets = Atmos.config.provider.secret_manager.to_h
-        env_secrets = Hash[secrets.collect { |k, v| ["TF_VAR_#{k}", v] }]
-        return env_secrets
-      end
-    end
-
-    def clean_links
-      Find.find(@working_dir) do |f|
-        Find.prune if f =~ /\/.terraform\/modules\//
-        File.delete(f) if File.symlink?(f)
-      end
-    end
-
-    def link_support_dirs
-      ['modules', 'templates'].each do |subdir|
-        ln_sf(File.join(Atmos.config.root_dir, subdir), @working_dir)
-      end
-    end
-
-    def link_shared_plugin_dir
-      if ! Atmos.config["terraform.disable_shared_plugins"]
-        shared_plugins_dir = File.join(Atmos.config.tmp_root, "terraform_plugins")
-        mkdir_p(shared_plugins_dir)
-        terraform_state_dir = File.join(tf_recipes_dir, '.terraform')
-        mkdir_p(terraform_state_dir)
-        terraform_plugins_dir = File.join(terraform_state_dir, 'plugins')
-        ln_sf(shared_plugins_dir, terraform_plugins_dir)
-      end
-    end
-
-    def link_recipes
-      @recipes.each do |recipe|
-        ln_sf(File.join(Atmos.config.root_dir, 'recipes', "#{recipe}.tf"), tf_recipes_dir)
-      end
-    end
-
-    def pipe_stream(src, dest)
-       Thread.new do
-         block_size = 1024
-         begin
-           while data = src.readpartial(block_size)
-             data = yield data if block_given?
-             dest.write(data)
-           end
-         rescue EOFError
-           nil
-         rescue Exception => e
-           logger.log_exception(e, "Stream failure")
-         end
-       end
-    end
-
-  end
-
-end

data/lib/atmos/ui.rb

@@ -1,159 +0,0 @@
-require_relative '../atmos'
-require 'highline'
-require 'rainbow'
-require 'yaml'
-require 'open3'
-require 'os'
-require 'hashie'
-
-module OSDockerDetection
-  refine OS.singleton_class do
-    def docker?
-      @docker ||= File.exist?('/.dockerenv')
-    end
-  end
-end
-
-module Atmos
-  module UI
-    extend ActiveSupport::Concern
-    include GemLogger::LoggerSupport
-    using OSDockerDetection
-
-    def self.color_enabled=(val)
-      Rainbow.enabled = val
-    end
-
-    def self.color_enabled
-      Rainbow.enabled
-    end
-
-    class Markup
-
-      def initialize(color = nil)
-        @color = color
-        @atmos_ui = HighLine.new
-      end
-
-      def say(statement)
-        statement = @color ? Rainbow(statement).send(@color) : statement
-        @atmos_ui.say(statement)
-      end
-
-      def ask(question, answer_type=nil, &details)
-        s = @color ? Rainbow(question).send(@color) : question
-        @atmos_ui.ask(question, answer_type, &details)
-      end
-
-      def agree(question, character=nil, &details)
-        s = @color ? Rainbow(question).send(@color) : question
-        @atmos_ui.agree(question, character, &details)
-      end
-
-    end
-
-    def warn
-      return Markup.new(:yellow)
-    end
-
-    def error
-      return Markup.new(:red)
-    end
-
-    def say(statement)
-      return Markup.new().say(statement)
-    end
-
-    def ask(question, answer_type=nil, &details)
-      return Markup.new().ask(question, answer_type, &details)
-    end
-
-    def agree(question, character=nil, &details)
-      return Markup.new().agree(question, character, &details)
-    end
-
-    # Pretty display of hashes
-    def display(data)
-      data = Hashie.stringify_keys(data)
-      display = YAML.dump(data).sub(/\A---\n/, "").gsub(/^/, "  ")
-    end
-
-    def notify(message:nil, title: nil, modal: false, **opts)
-
-      result = {
-          'stdout' => '',
-          'success' => ''
-      }
-
-      message = message.to_s
-      title = title.present? ? title.to_s : "Atmos Notification"
-      modal = ["true", "1"].include?(modal.to_s)
-      modal = false if Atmos.config["ui.notify.disable_modal"]
-
-      return result if Atmos.config["ui.notify.disable"].to_s == "true"
-
-      force_inline = Atmos.config["ui.notify.force_inline"].to_s == "true"
-      command = Atmos.config["ui.notify.command"]
-
-      if command.present? && ! force_inline
-
-        raise ArgumentError.new("notify command must be a list") if ! command.is_a?(Array)
-
-        command = command.collect do |c|
-          c = c.gsub("{{title}}", title)
-          c = c.gsub("{{message}}", message)
-          c = c.gsub("{{modal}}", modal.to_s)
-        end
-        result.merge! run_ui_process(*command)
-
-      elsif OS.mac? && ! force_inline
-        display_method = modal ? "displayDialog" : "displayNotification"
-
-        dialogScript = <<~EOF
-          var app = Application.currentApplication();
-          app.includeStandardAdditions = true;
-          app.#{display_method}(
-            #{JSON.generate(message)}, {
-              withTitle: #{JSON.generate(title)},
-              buttons: ['OK'],
-              defaultButton: 1
-          })
-        EOF
-
-        result.merge! run_ui_process("osascript", "-l", "JavaScript", "-e", dialogScript)
-
-      elsif OS.linux? && ! OS.docker? && ! force_inline
-        # TODO: add a modal option
-        result.merge! run_ui_process("notify-send", title, message)
-
-      # TODO windows notifications?
-      # elseif OS.windows? && ! force_inline
-
-      else
-
-        logger.debug("Notifications are unsupported on this OS")
-        logger.info(Rainbow("\n***** #{title} *****\n#{message}\n").orange)
-        if modal
-          logger.info(Rainbow("Hit enter to continue\n").orange)
-          $stdin.gets
-        end
-
-      end
-
-      return result
-    end
-
-    private
-
-    def run_ui_process(*args)
-      stdout, status = Open3.capture2e(*args)
-      result = {'stdout' => stdout, 'success' => status.success?.to_s}
-      if ! status.success?
-        result['error'] = "Notification process failed"
-        logger.debug("Failed to run notification utility: #{stdout}")
-      end
-      return result
-    end
-
-  end
-end

data/lib/atmos/utils.rb

@@ -1,50 +0,0 @@
-require_relative '../atmos'
-
-module Atmos
-  module Utils
-
-    extend ActiveSupport::Concern
-    include GemLogger::LoggerSupport
-
-    class SymbolizedMash < ::Hashie::Mash
-      include Hashie::Extensions::Mash::SymbolizeKeys
-    end
-
-    # remove leading whitespace using first non-empty line to determine how
-    # much space to remove from the rest. Skips empty lines
-    def clean_indent(str)
-      first = true
-      first_size = 0
-      str.lines.collect do |line|
-        if line =~ /^(\s*)\S/ # line has at least one non-whitespace character
-          if first
-            first_size = Regexp.last_match(0).size
-            first = false
-          end
-          line[(first_size - 1)..-1]
-        else
-          line
-        end
-      end.join()
-    end
-
-    # wraps to an 80 character limit by adding newlines
-    def wrap(str)
-      result = ""
-      count = 0
-      str.each do |c|
-        result << c
-        if count >= 78
-          result << "\n"
-          count = 0
-        else
-          count += 1
-        end
-      end
-      return result
-    end
-
-    extend self
-
-  end
-end