terraspace 0.1.2 → 0.2.0

data/lib/terraspace/cli/list.rb

@@ -0,0 +1,13 @@
+class Terraspace::CLI
+  class List
+    def initialize(options={})
+      @options = options
+    end
+
+    def run
+      Dir.glob("{app,vendor}/{modules,stacks}/*").sort.each do |path|
+        puts path
+      end
+    end
+  end
+end

data/lib/terraspace/cli/new.rb

@@ -1,5 +1,13 @@
 class Terraspace::CLI
   class New < Terraspace::Command
+    long_desc Help.text(:git_hook)
+    GitHook.cli_options.each { |args| option(*args) }
+    register(GitHook, "git_hook", "git_hook", "Generates new git hook")
+
+    long_desc Help.text(:shim)
+    Shim.cli_options.each { |args| option(*args) }
+    register(Shim, "shim", "shim", "Generates terraspace shim")
+
     long_desc Help.text(:module)
     Module.base_options.each { |args| option(*args) }
     Module.component_options.each { |args| option(*args) }

data/lib/terraspace/cli/new/git_hook.rb

@@ -0,0 +1,33 @@
+class Terraspace::CLI::New
+  class GitHook < Thor::Group
+    include Thor::Actions
+
+    def self.cli_options
+      [
+        [:envs, type: :array, default: %w[dev prod], desc: "envs to build"],
+        [:type, aliases: %w[t], default: "pre-push", desc: "git hook type"],
+      ]
+    end
+    cli_options.each { |args| class_option(*args) }
+
+    def self.source_root
+      File.expand_path("../../../templates/base/git_hook", __dir__)
+    end
+
+    def create
+      return unless File.exist?(".git")
+      dest = ".git/hooks/#{options[:type]}"
+      template "hook.sh", dest
+      chmod dest, 0755
+    end
+
+  private
+    def terraspace_build_commands
+      code = []
+      @options[:envs].each do |env|
+        code << %Q|TS_ENV=#{env} terraspace build placeholder|
+      end
+      code.join("\n")
+    end
+  end
+end

data/lib/terraspace/cli/new/shim.rb

@@ -0,0 +1,58 @@
+class Terraspace::CLI::New
+  class Shim < Thor::Group
+    include Thor::Actions
+
+    def self.cli_options
+      [
+        [:path, aliases: %w[p], default: "/usr/local/bin/terraspace", desc: "path to save the shim script"],
+      ]
+    end
+    cli_options.each { |args| class_option(*args) }
+
+    def self.source_root
+      File.expand_path("../../../templates/base/shim", __dir__)
+    end
+
+    def set_vars
+      @path = @options[:path]
+    end
+
+    def create
+      return unless File.exist?(".git")
+      dest = @path
+      template "terraspace", dest
+      chmod dest, 0755
+    end
+
+    def message
+      dir = File.dirname(@path)
+      puts <<~EOL
+        A terraspace shim as been generated at #{@path}
+        Please make sure that it is found in the $PATH.
+
+        You can double check with:
+
+            which terraspace
+
+        You should see
+
+            $ which terraspace
+            #{@path}
+
+        If you do not, please add #{dir} to your PATH.
+        You can usually do so by adding this line to ~/.bash_profile and opening a new terminal to check.
+
+            export PATH=#{dir}:/$PATH
+
+      EOL
+    end
+
+  private
+    def switch_ruby_version_line
+      rbenv_installed = system("type rbenv 2>&1 > /dev/null")
+      if rbenv_installed
+        'eval "$(rbenv init -)"'
+      end
+    end
+  end
+end

data/lib/terraspace/cli/summary.rb

@@ -11,26 +11,19 @@ class Terraspace::CLI
     end
 
     def run
+      Terraspace.check_project!
       build
       puts "Summary of resources based on backend storage statefiles"
       backend_expr = '.terraspace-cache/**/backend.*'
-      backends = Dir.glob(backend_expr)
-      backends.each do |backend|
-        process(backend)
-      end
+      # Currently summary assumes backend are within the same bucket and key prefix
+      backend = Dir.glob(backend_expr).first
+      process(backend) if backend
     end
 
     # Grab the last module and build that.
     # Assume the backend key has the same prefix
     def build
-      return if ENV['TS_SUMMARY_BUILD'] == '0'
-
-      mod = @options[:mod]
-      unless mod
-        mod_path = Dir.glob("{app,vendor}/{modules,stacks}/*").last
-        mod = File.basename(mod_path)
-      end
-      Build.new(@options.merge(mod: mod)).run # generate and init
+      Build::Placeholder.new(@options).build
     end
 
     def process(path)
@@ -43,6 +36,10 @@ class Terraspace::CLI
 
       info = backend.values.first # structure within the s3 or gcs key
       klass = summary_class(name)
+      unless klass
+        logger.info "Summary is unavailable for this backend: #{name}"
+        exit
+      end
       summary = klass.new(info, @options)
       summary.call
     end

data/lib/terraspace/compiler/backend.rb

@@ -1,5 +1,3 @@
-require "hcl_parser"
-
 module Terraspace::Compiler
   class Backend
     extend Memoist
@@ -9,53 +7,27 @@ module Terraspace::Compiler
     end
 
     def create
-      klass = backend_class(backend_name)
+      klass = backend_interface(backend_name)
       return unless klass # in case auto-creation is not supported for specific backend
 
-      backend = klass.new(backend_info)
-      backend.call
+      interface = klass.new(backend_info)
+      interface.call
     end
 
     def backend_name
-      backend_raw.keys.first # IE: s3, gcs, etc
+      backend.keys.first # IE: s3, gcs, etc
     end
 
     def backend_info
-      backend_raw.values.first # structure within the s3 or gcs key
-    end
-
-    def backend_raw
-      return {} unless exist?(backend_path)
-      if backend_path.include?('.json')
-        json_backend
-      else
-        hcl_backend
-      end
-    end
-
-    def json_backend
-      data = JSON.load(IO.read(backend_path))
-      data.dig("terraform", "backend") || {}
-    end
-
-    def hcl_backend
-      return {} unless File.exist?(backend_path)
-      backend_raw = HclParser.load(IO.read(backend_path))
-      return {} unless backend_raw
-      backend_raw.dig("terraform", "backend") || {}
-    end
-
-    def exist?(path)
-      path && File.exist?(path)
+      backend.values.first # structure within the s3 or gcs key
     end
 
-    def backend_path
-      expr = "#{@mod.cache_build_dir}/backend.tf*"
-      Dir.glob(expr).first
+    def backend
+      Parser.new(@mod).result
     end
-    memoize :backend_path
+    memoize :backend
 
-    def backend_class(name)
+    def backend_interface(name)
       return unless name
       # IE: TerraspacePluginAws::Interfaces::Backend
       klass_name = Terraspace::Plugin.klass("Backend", backend: name)

data/lib/terraspace/compiler/backend/parser.rb

@@ -0,0 +1,42 @@
+require "hcl_parser"
+
+class Terraspace::Compiler::Backend
+  class Parser
+    extend Memoist
+
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def result
+      return {} unless exist?(backend_path)
+      if backend_path.include?('.json')
+        json_backend
+      else
+        hcl_backend
+      end
+    end
+
+    def json_backend
+      data = JSON.load(IO.read(backend_path))
+      data.dig("terraform", "backend") || {}
+    end
+
+    def hcl_backend
+      return {} unless File.exist?(backend_path)
+      backend_raw = HclParser.load(IO.read(backend_path))
+      return {} unless backend_raw
+      backend_raw.dig("terraform", "backend") || {}
+    end
+
+    def exist?(path)
+      path && File.exist?(path)
+    end
+
+    def backend_path
+      expr = "#{@mod.cache_dir}/backend.tf*"
+      Dir.glob(expr).first
+    end
+    memoize :backend_path
+  end
+end

data/lib/terraspace/compiler/builder.rb

@@ -14,7 +14,7 @@ module Terraspace::Compiler
 
     # build common config files: provider and backend for the root module
     def build_config
-      return unless @mod.root_module?
+      return unless build?
       build_config_templates
     end
 
@@ -25,11 +25,15 @@ module Terraspace::Compiler
     end
 
     def build_tfvars
-      return unless @mod.root_module?
+      return unless build?
       Strategy::Tfvar.new(@mod).run # writer within Strategy to control file ordering
     end
 
   private
+    def build?
+      @mod.type == "stack" || @mod.root_module?
+    end
+
     def build_config_templates
       expr = "#{Terraspace.root}/config/terraform/**/*"
       Dir.glob(expr).each do |path|

data/lib/terraspace/compiler/cleaner.rb

@@ -19,6 +19,7 @@ module Terraspace::Compiler
     # only remove .tf* files. leaving cache .terraform and terraform.state files
     def remove_materialized_artifacts
       Dir.glob("#{Terraspace.cache_root}/**/*").each do |path|
+        next unless within_env?(path)
         next if path.include?(".tfstate")
         FileUtils.rm_f(path) if File.file?(path)
       end
@@ -31,7 +32,7 @@ module Terraspace::Compiler
     # the file again. With verbose logging, it shows it twice so that's a little bit confusing though.
     #
     # def remove_materialized_artifacts_dot_terraform
-    #   expr = "#{@mod.cache_build_dir}/.terraform/**/*"
+    #   expr = "#{@mod.cache_dir}/.terraform/**/*"
     #
     #   Dir.glob(expr).each do |path|
     #     logger.info "path #{path}"
@@ -40,7 +41,23 @@ module Terraspace::Compiler
 
     def remove_empty_directories
       return unless File.exist?(Terraspace.cache_root)
-      Dir["#{Terraspace.cache_root}/**/"].reverse_each { |d| Dir.rmdir d if Dir.entries(d).size == 2 }
+      Dir["#{Terraspace.cache_root}/**/"].reverse_each do |d|
+        next unless within_env?(d)
+        Dir.rmdir(d) if Dir.entries(d).size == 2
+      end
+    end
+
+    # Only remove files within an env for the TFC VCS-Workflow.
+    # We dont want to run:
+    #
+    #      TS_ENV=prod terraspace up demo
+    #
+    # And that to delete the .terraspace-cache/us-west-2/dev files
+    #
+    # May need to allow further customization to this if user project has a stack named the same as the env.
+    #
+    def within_env?(path)
+      path.include?("/#{Terraspace.env}/")
     end
   end
 end

data/lib/terraspace/compiler/cleaner/backend_change.rb

@@ -27,7 +27,7 @@ class Terraspace::Compiler::Cleaner
     end
 
     def current_backend
-      materialized_path = find_src_path("#{@mod.cache_build_dir}/backend*")
+      materialized_path = find_src_path("#{@mod.cache_dir}/backend*")
       IO.read(materialized_path) if materialized_path
     end
 

data/lib/terraspace/compiler/dsl/syntax/mod.rb

@@ -1,5 +1,6 @@
 module Terraspace::Compiler::Dsl::Syntax
   module Mod
+    include Terraspace::Util::Logging
     include_dir("mod")
     include_dir("helpers")
   end

data/lib/terraspace/compiler/dsl/syntax/mod/backend.rb

@@ -3,16 +3,29 @@ module Terraspace::Compiler::Dsl::Syntax::Mod
     def backend(name, props={})
       terraform = @structure[:terraform] ||= {}
       backend = terraform[:backend] ||= {}
-      backend_expand_all!(name, props)
+      expansion_all!(name, props)
       backend[name] = props
     end
 
-    def backend_expand_all!(backend_name, props={})
+    def expansion_all!(backend_name, props={})
       Terraspace::Compiler::Expander.new(@mod, backend_name).expand(props)
     end
 
+    # Can set opts to explicitly use an specfic backend. Example:
+    #
+    #    opts = {backend: s3}
+    #
+    # Else Terraspace autodetects the backend installed.
+    #
+    def expansion(string, opts={})
+      expander = Terraspace::Compiler::Expander.autodetect(@mod, opts)
+      expander.expansion(string)
+    end
+
+    # DEPRECATED: Will be removed in future release
     def backend_expand(backend_name, string)
-      Terraspace::Compiler::Expander.new(@mod, backend_name).expand_string(string)
+      logger.info "DEPRECATED backend_expand: instead use expansion(string)"
+      Terraspace::Compiler::Expander.new(@mod, backend_name).expansion(string)
     end
   end
 end

data/lib/terraspace/compiler/expander.rb

@@ -1,6 +1,6 @@
 module Terraspace::Compiler
   class Expander
-    delegate :expand, :expand_string, to: :expander
+    delegate :expand, :expansion, to: :expander
 
     attr_reader :expander
     def initialize(mod, name)
@@ -15,5 +15,32 @@ module Terraspace::Compiler
     rescue NameError
       Terraspace::Plugin::Expander::Generic
     end
+
+    class << self
+      extend Memoist
+
+      def autodetect(mod, opts={})
+        backend = opts[:backend]
+        unless backend
+          plugin = find_plugin
+          backend = plugin[:backend]
+        end
+        new(mod, backend)
+      end
+      memoize :autodetect
+
+      def find_plugin
+        plugins = Terraspace::Plugin.meta
+        if plugins.size == 1
+          plugins.first[1]
+        else
+          precedence = %w[aws azurerm google]
+          plugin = precedence.find do |provider|
+            plugins[provider]
+          end
+          plugins[plugin]
+        end
+      end
+    end
   end
 end

data/lib/terraspace/compiler/writer.rb

@@ -19,7 +19,7 @@ module Terraspace::Compiler
       if @mod.is_a?(Terraspace::Mod::Remote)
         File.dirname(@src_path) # for Mod::Remote src is dest
       else
-        @mod.cache_build_dir
+        @mod.cache_dir
       end
     end