terraspace 0.0.0 → 0.2.1

data/lib/terraspace/plugin/infer_provider.rb

@@ -0,0 +1,15 @@
+module Terraspace::Plugin
+  module InferProvider
+    # Examples:
+    #    TerraspacePluginAws     => aws
+    #    TerraspacePluginAzurerm => azurerm
+    #    TerraspacePluginGoogle  => google
+    #
+    # If multiple clouds used in a single Terraspace project. The TS_PROVIDER_EXPANSION env var provides a way to
+    # change it. Can possibly use config hooks to set different values based on the module being deployed:
+    # https://terraspace.cloud/docs/config/hooks/
+    def provider
+      ENV['TS_PROVIDER'] || self.class.to_s.split('::').first.sub('TerraspacePlugin','').underscore
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Terraspace::Plugin::Layer
+  module Interface
+    include Terraspace::Plugin::InferProvider
+  end
+end

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,130 @@
+# Should implement methods:
+#
+#   key_field: if need to override default key
+#   bucket_field: if need to override default bucket
+#   download
+#
+# If need more customization, then override and implement the call method.
+#
+module Terraspace::Plugin::Summary
+  module Interface
+    def initialize(info, options={})
+      @info, @options = info, options
+    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|
+        @has_shown_resources = true # flag to note some resources there were shown
+        identifier = r['instances'].map do |i|
+          i['attributes']['name'] || i['attributes']['id']
+        end.join(',')
+        return if @options[:short]
+        logger.info "    #{r['type']} #{r['name']}: #{identifier}"
+      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"
+        logger.error "path used: #{path}"
+        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_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_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_dir}/#{file}"
+      File.exist?(path)
+    end
+
+    def read(file)
+      path = "#{@mod.cache_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/api.rb

@@ -0,0 +1,53 @@
+module Terraspace::Terraform
+  class Api
+    extend Memoist
+    include Client
+    include Terraspace::Util::Logging
+
+    def initialize(mod, remote)
+      @mod = mod
+      @organization = remote['organization']
+      @workspace_name = remote['workspaces']['name']
+    end
+
+    # Docs: https://www.terraform.io/docs/cloud/api/workspaces.html
+    def set_working_dir
+      working_directory = @mod.cache_dir.sub("#{Terraspace.root}/", '')
+      return if working_directory == workspace['attributes']['working-directory']
+
+      payload = {
+        data: {
+          attributes: {
+            "working-directory": working_directory
+          },
+          type: "workspaces"
+        }
+      }
+      http.patch("organizations/#{@organization}/workspaces/#{@workspace_name}", payload)
+    end
+
+    def set_env_vars
+      Vars.new(@mod, workspace).run
+    end
+
+    def workspace(options={})
+      payload = http.get("organizations/#{@organization}/workspaces/#{@workspace_name}")
+      # Note only way to get here is to bypass init. Example:
+      #
+      #     terraspace up demo --no-init
+      #
+      unless payload || options[:exit_on_fail] == false
+        logger.error "ERROR: Unable to find the workspace. The workspace may not exist. Or the Terraform token may be invalid. Please double check your Terraform token.".color(:red)
+        exit 1
+      end
+      return unless payload
+      payload['data']
+    end
+    memoize :workspace
+
+    def destroy_workspace
+      # resp payload from delete operation is nil
+      http.delete("/organizations/#{@organization}/workspaces/#{@workspace_name}")
+    end
+  end
+end