terraspace 0.0.0 → 0.1.0

data/lib/terraspace/plugin/meta.rb

@@ -0,0 +1,29 @@
+module Terraspace::Plugin
+  class Meta
+    # raw: {"aws" => {root: "/path", backend: "s3"}
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def name
+      name = @raw.keys.first
+      unless name
+        raise "No plugin found. Are you sure you have the terraspace_plugin_XXX configured in your Gemfile?"
+      end
+      name.camelize
+    end
+    alias_method :plugin, :name
+
+    def data
+      @raw.values.first
+    end
+
+    def backend
+      data[:backend]
+    end
+
+    def root
+      data[:root]
+    end
+  end
+end

data/lib/terraspace/plugin/summary/interface.rb

@@ -0,0 +1,129 @@
+# Should implement methods:
+#
+#   key_field: if need to override default key
+#   bucket_field: if need to override default bucket
+#   download
+#   statefile_expr: needed for azurerm
+#
+# If need more customization, then override and implement the call method.
+#
+module Terraspace::Plugin::Summary
+  module Interface
+    def initialize(info)
+      @info = info
+    end
+
+    # 1. download state files to temp area
+    # 2. show resources for each
+    def call
+      # Note: will not change any of these instance variables unless we note breaking changes
+      @bucket = @info[bucket_field]
+      @key = @info[key_field] # key_field is INTERFACE METHOD IE: aws: key , google: prefix
+      @folder = folder(@key)
+      @dest = dest(@bucket)
+      # May change any of these instance variables that follow
+      @dest_folder = "#{@dest}/#{@folder}"
+
+      download_statefiles
+      show_resources
+    end
+
+    # default because aws and azurerm uses it.
+    # google uses prefix
+    # interface method
+    def key_field
+      'key'
+    end
+
+    # default because aws and google uses it.
+    # azure uses storage_account_name and other attributes
+    # interface method
+    def bucket_field
+      'bucket'
+    end
+
+    # Allow override by plugin implementation class. Generally, all files in these folders are tfstate files.
+    def statefile_expr
+      "#{@dest_folder}**/*"
+    end
+
+    def download_statefiles
+      return unless download?
+      FileUtils.rm_rf(@dest_folder)
+      logger.info("Downloading statefiles to #{@dest_folder}")
+      download # INTERFACE METHOD
+    end
+
+    def show_resources
+      Dir.glob(statefile_expr).sort.each do |path|
+        next unless File.file?(path)
+        next if path.include?(".tflock")
+        show_each(path)
+      end
+      logger.info("No resources found in statefiles") unless @has_shown_resources
+    end
+
+    def show_each(path)
+      data = JSON.load(IO.read(path))
+      resources = data['resources']
+      remove_statefile(path) if resources && resources.size == 0 && !ENV['TS_KEEP_EMPTY_STATEFILES']
+      return unless resources && resources.size > 0
+
+      pretty_path = path.sub(Regexp.new(".*#{@bucket}/#{@folder}"), '')
+      logger.info pretty_path.color(:green)
+      resources.each do |r|
+        identifier = r['instances'].map do |i|
+          i['attributes']['name'] || i['attributes']['id']
+        end.join(',')
+        logger.info "    #{r['type']} #{r['name']}: #{identifier}"
+        @has_shown_resources = true # flag to note some resources there were shown
+      end
+    end
+
+    # Clean up empty statefiles because over time the extra network calls to download them
+    # slow down the summary command
+    def remove_statefile(path)
+      key = path.sub("#{statefiles_root}/#{@bucket}/",'')
+      delete_empty_statefile(key)
+    end
+
+    # interface method
+    def delete_empty_statefile(key)
+    end
+
+  private
+    def folder(path)
+      index = locate_env_index(path)
+      path[0..index] # Example folder: us-central1/dev/
+    end
+
+    # Assume that the state files are within a env folder.
+    # IE: us-central1/dev/stacks/vm
+    def locate_env_index(path)
+      regexp = Regexp.new("/#{Terraspace.env}/")
+      index = path.index(regexp)
+      unless index
+        logger.error "ERROR: Unable to find the #{Terraspace.env} position in the prefix"
+        exit 1
+      end
+      env_chars = Terraspace.env.size + 1
+      index + env_chars
+    end
+
+    def dest(bucket)
+      "#{statefiles_root}/#{bucket}"
+    end
+
+    def statefiles_root
+      "#{Terraspace.tmp_root}/statefiles"
+    end
+
+    def logger
+      Terraspace.logger
+    end
+
+    def download?
+      ENV['TS_SUMMARY_DOWNLOAD'] != '0'
+    end
+  end
+end

data/lib/terraspace/seeder.rb

@@ -0,0 +1,66 @@
+require "hcl_parser"
+
+module Terraspace
+  class Seeder
+    extend Memoist
+    include Terraspace::Util
+
+    def initialize(mod, options={})
+      @mod, @options = mod, options
+    end
+
+    def seed
+      parsed = parse # make @parsed available for rest of processing
+      content = Content.new(parsed).build
+      write(content)
+    end
+
+    def parse
+      if exist?("variables.tf")
+        load_hcl_variables
+      elsif exist?("variables.tf.json")
+        JSON.load(read("variables.tf.json"))
+      else
+        logger.warn "WARN: no variables.tf or variables.tf.json found in: #{@mod.cache_build_dir}"
+        ENV['TS_TEST'] ? raise : exit
+      end
+    end
+    memoize :parse
+
+    def load_hcl_variables
+      HclParser.load(read("variables.tf"))
+    rescue Racc::ParseError => e
+      logger.error "ERROR: Unable to parse the #{Util.pretty_path(@mod.cache_build_dir)}/variables.tf file".color(:red)
+      logger.error "and generate the starter tfvars file. This is probably due to a complex variable type."
+      logger.error "#{e.class}: #{e.message}"
+      puts
+      logger.error "You will have to create the tfvars file manually at: #{Util.pretty_path(dest_path)}"
+      exit 1
+    end
+
+    def write(content)
+      actions.create_file(dest_path, content)
+    end
+
+    def dest_path
+      Where.new(@mod, @options).dest_path
+    end
+    memoize :dest_path
+
+    def exist?(file)
+      path = "#{@mod.cache_build_dir}/#{file}"
+      File.exist?(path)
+    end
+
+    def read(file)
+      path = "#{@mod.cache_build_dir}/#{file}"
+      logger.info "Reading: #{Util.pretty_path(path)}"
+      IO.read(path)
+    end
+
+    def actions
+      Actions.new(@options)
+    end
+    memoize :actions
+  end
+end

data/lib/terraspace/seeder/actions.rb

@@ -0,0 +1,24 @@
+require "thor"
+
+# Usage:
+#
+#    @actions = Actions.new
+#    @actions.create_file("content", "/path/to/file.txt")
+#
+class Terraspace::Seeder
+  class Actions
+    # What's needed for a Thor::Group or "Sequence"
+    # Gives us Thor::Actions commands like create_file
+    include Thor::Actions
+    include Thor::Base
+
+    attr_reader :options # Thor requires options
+    # Override Thor::Base initialize to set destination_root
+    def initialize(options={})
+      # Thor::Base.initialize(args = [], local_options = {}, config = {}) <= original signature
+      options[:force] = options[:yes]
+      super([], options)
+      self.destination_root = Dir.pwd # Thor::Actions require destination_root to be set
+    end
+  end
+end

data/lib/terraspace/seeder/content.rb

@@ -0,0 +1,84 @@
+class Terraspace::Seeder
+  class Content
+    extend Memoist
+
+    def initialize(parsed)
+      @parsed = parsed
+    end
+
+    def build
+      lines = []
+      lines << "# Required variables:" unless required_vars.empty?
+      required_vars.each do |name, meta|
+        lines << build_line(name, meta)
+      end
+      lines << "" unless required_vars.empty?
+      lines << "# Optional variables:" unless optional_vars.empty?
+      optional_vars.each do |name, meta|
+        lines << build_line(name, meta)
+      end
+      lines.join("\n") + "\n"
+    end
+
+    def build_line(name, meta)
+      value = var_value(meta)
+      name = "# #{name}" if meta["default"] # optional so add as a comment
+      name = "%-#{rpad}s" % name # rpad to align = signs
+      "#{name} = #{value}"
+    end
+
+    def var_value(meta)
+      type, default = meta["type"], meta["default"]
+
+      if default
+        escape(type, default)
+      else
+        value = desc_example(meta["description"]) || type || "any"
+        escape(type, value)
+      end
+    end
+
+    def escape(type, value)
+      if type&.include?('(') # complex type
+        "[...] # #{type}"
+      elsif %w[null any true false].include?(value)
+        value # no quotes
+      else
+        %Q|"#{value}"| # add quotes
+      end
+    end
+
+    def rpad
+      all_vars.keys.map(&:size).max
+    end
+    memoize :rpad
+
+    def desc_example(desc)
+      return unless desc
+      md = desc.match(/([eE]xample|IE): (.*)/)
+      return unless md
+      md[2]
+    end
+
+    def required_vars
+      select_vars(@parsed) { |meta|  meta["default"].nil? }
+    end
+
+    def optional_vars
+      select_vars(@parsed) { |meta| !meta["default"].nil? }
+    end
+
+    def all_vars
+      select_vars(@parsed)
+    end
+
+    def select_vars(parsed)
+      vars = parsed.dig("variable")
+      return [] unless vars
+      vars.select do |name,meta|
+        block_given? ? yield(meta) : true
+      end
+    end
+
+  end
+end

data/lib/terraspace/seeder/where.rb

@@ -0,0 +1,30 @@
+class Terraspace::Seeder
+  class Where
+    def initialize(mod, options={})
+      @mod, @options = mod, options
+    end
+
+    def dest_path
+      case @options[:where]
+      when "app"
+        app_path
+      when "seed"
+        seed_path
+      else
+        infer_dest_path
+      end
+    end
+
+    def infer_dest_path
+      @mod.type == "stack" ? app_path : seed_path
+    end
+
+    def app_path
+      "#{Terraspace.root}/app/#{@mod.build_dir}/tfvars/#{Terraspace.env}.tfvars"
+    end
+
+    def seed_path
+      "#{Terraspace.root}/seed/tfvars/#{@mod.build_dir}/#{Terraspace.env}.tfvars"
+    end
+  end
+end

data/lib/terraspace/terraform/args/custom.rb

@@ -0,0 +1,47 @@
+module Terraspace::Terraform::Args
+  class Custom
+    extend Memoist
+    include Dsl
+    include DslEvaluator
+
+    attr_accessor :name
+    def initialize(mod, name)
+      @mod, @name = mod, name
+      @file = "#{Terraspace.root}/config/cli/args.rb"
+      @commands = {}
+    end
+
+    def build
+      return @commands unless File.exist?(@file)
+      evaluate_file(@file)
+      @commands.deep_stringify_keys!
+    end
+    memoize :build
+
+    def args
+      build
+      args = dig("args")
+      args.compact.flatten
+    end
+
+    def var_files
+      build
+      var_files = dig("var_files")
+      var_files.select! { |f| var_file_exist?(f) }
+      var_files.map { |f| "-var-file=#{f}" }
+    end
+
+    def env_vars
+      build
+      dig("env", {})
+    end
+
+    def var_file_exist?(var_file)
+      File.exist?("#{@mod.cache_build_dir}/#{var_file}")
+    end
+
+    def dig(prop, default=[])
+      @commands.dig(@name, prop) || default
+    end
+  end
+end

data/lib/terraspace/terraform/args/default.rb

@@ -0,0 +1,96 @@
+module Terraspace::Terraform::Args
+  class Default
+    def initialize(mod, name, options={})
+      @mod, @name, @options = mod, name, options
+      @quiet = @options[:quiet].nil? ? true : @options[:quiet]
+    end
+
+    def args
+      # https://terraspace.cloud/docs/ci-automation/
+      ENV['TF_IN_AUTOMATION'] = '1' if @options[:auto]
+
+      if %w[apply destroy init output plan].include?(@name)
+        meth = "#{@name}_args"
+        send(meth)
+      else
+        []
+      end
+    end
+
+    def apply_args
+      args = auto_approve_arg
+      var_files = @options[:var_files]
+      if var_files
+        args << var_files.map { |f| "-var-file #{Dir.pwd}/#{f}" }.join(' ')
+      end
+
+      if @options[:auto] && @options[:input].nil?
+        args << " -input=false"
+      end
+      unless @options[:input].nil?
+        input = @options[:input] ? "true" : "false"
+        args << " -input=#{input}" # = sign required for apply when there's a plan at the end. so input=false works input false doesnt
+      end
+
+      # must be at the end
+      plan = @options[:plan]
+      if plan
+        if plan.starts_with?('/')
+          src  = plan
+          dest = src
+        else
+          src = "#{Dir.pwd}/#{plan}"
+          dest = "#{@mod.cache_build_dir}/#{File.basename(src)}"
+        end
+        FileUtils.cp(src, dest)
+        args << " #{dest}"
+      end
+      args
+    end
+
+    def init_args
+      args = "-get"
+      if @options[:auto] && @options[:input].nil?
+        args << " -input=false"
+      end
+      unless @options[:input].nil?
+        input = @options[:input] ? "true" : "false"
+        args << " -input=#{input}"
+      end
+
+      # must be at the end
+      if @quiet && !ENV['TS_INIT_LOUD']
+        out_path = "#{Terraspace.tmp_root}/out/terraform-init.out"
+        FileUtils.mkdir_p(File.dirname(out_path))
+        args << " > #{out_path}"
+      end
+      [args]
+    end
+
+    def plan_args
+      args = []
+      args << "-out #{expanded_out}" if @options[:out]
+      args
+    end
+
+    def output_args
+      args = []
+      args << "-json" if @options[:format] == "json"
+      args << "> #{expanded_out}" if @options[:out]
+      args
+    end
+
+    def expanded_out
+      out = @options[:out]
+      out.starts_with?('/') ? out : "#{Dir.pwd}/#{out}"
+    end
+
+    def destroy_args
+      auto_approve_arg
+    end
+
+    def auto_approve_arg
+      @options[:yes] || @options[:auto] ? ["-auto-approve"] : []
+    end
+  end
+end