terraspace 0.1.1 → 0.2.3

data/lib/terraspace/cli/cloud.rb

@@ -0,0 +1,24 @@
+class Terraspace::CLI
+  class Cloud < Terraspace::Command
+    Workspace = Terraspace::Terraform::Cloud::Workspace
+
+    desc "list", "List workspaces"
+    long_desc Help.text("cloud:list")
+    def list
+      Workspace.new(options).list
+    end
+
+    desc "destroy STACK", "Destroy workspace"
+    long_desc Help.text("cloud:destroy")
+    option :yes, aliases: :y, type: :boolean, desc: "bypass are you sure prompt"
+    def destroy(mod)
+      Workspace.new(options.merge(mod: mod)).destroy
+    end
+
+    desc "setup STACK", "Setup workspace"
+    long_desc Help.text("cloud:setup")
+    def setup(mod)
+      Workspace.new(options.merge(mod: mod)).setup
+    end
+  end
+end

data/lib/terraspace/cli/commander.rb

@@ -7,8 +7,15 @@ class Terraspace::CLI
 
     # Commander always runs Build#run
     def run
-      Build.new(@options).run # generate and init
+      Terraspace::Builder.new(@options).run # generate and init
+      auto_create_backend
+      Init.new(@options.merge(calling_command: @name)).run
       Terraspace::Terraform::Runner.new(@name, @options).run
     end
+
+    def auto_create_backend
+      return unless @name == "apply"
+      Terraspace::Compiler::Backend.new(@mod).create
+    end
   end
 end

data/lib/terraspace/cli/init.rb

@@ -0,0 +1,67 @@
+require 'timeout'
+
+class Terraspace::CLI
+  class Init < Base
+    def initialize(options={})
+      # Original calling command. Can be from Commander which is a terraform command. IE: terraform apply
+      # Or can be from terraspace cloud setup. Which will be cloud-setup.
+      @calling_command = options[:calling_command]
+      super(options)
+    end
+
+    def run
+      init if init?
+      build_remote_dependencies # runs after terraform init, which downloads remote modules
+      sync_cloud
+    end
+
+    # Note the init will always create the Terraform Cloud Workspace
+    def init
+      # default init timeout is pretty generous in case of slow internet to download the provider plugins
+      init_timeout = Integer(ENV['TS_INIT_TIMEOUT'] || 600)
+      Timeout::timeout(init_timeout) do
+        Terraspace::Terraform::Runner.new("init", @options).run if !auto? && @options[:init] != false # will run on @options[:init].nil?
+      end
+    rescue Timeout::Error
+      logger.error "ERROR: It took too long to run terraform init.  Here is the output logs of terraform init:".color(:red)
+      logger.error IO.read(Terraspace::Terraform::Args::Default.terraform_init_log)
+    end
+
+    def sync_cloud
+      Terraspace::Terraform::Cloud.new(@options).run if %w[apply plan destroy cloud-setup].include?(@calling_command)
+    end
+
+    # Currently only handles remote modules only one-level deep.
+    def build_remote_dependencies
+      modules_json_path = "#{@mod.cache_dir}/.terraform/modules/modules.json"
+      return unless File.exist?(modules_json_path)
+
+      initialized_modules = JSON.load(IO.read(modules_json_path))
+      # For example of structure see spec/fixtures/initialized/modules.json
+      initialized_modules["Modules"].each do |meta|
+        build_remote_mod(meta)
+      end
+    end
+
+    def build_remote_mod(meta)
+      return if local_source?(meta["Source"])
+      return if meta['Dir'] == '.' # root is already built
+
+      remote_mod = Mod::Remote.new(meta, @mod)
+      Compiler::Builder.new(remote_mod).build
+    end
+
+    def auto?
+      # command is only passed from CLI in the update specifically for this check
+      @options[:auto] && @calling_command == "apply"
+    end
+  private
+    def local_source?(s)
+       s =~ %r{^\.} || s =~ %r{^/}
+    end
+
+    def init?
+      %w[apply console destroy output plan providers refresh show validate cloud-setup].include?(@calling_command)
+    end
+  end
+end

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).find { |p| p.include?("/#{Terraspace.env}/") }
+      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