terraspace 0.1.2 → 0.2.4

data/lib/terraspace/cli/check_setup.rb

@@ -23,15 +23,21 @@ class Terraspace::CLI
     end
 
     def check_required_version!
-      puts "Terraspace requires Terraform v#{REQUIRED_TERRAFORM_VERSION}.x"
+      puts "Terraspace requires Terraform v#{REQUIRED_TERRAFORM_VERSION}.x and above"
       if ok?
         puts "You're all set!"
       else
-        puts "The installed version of terraform may not work with terraspace. Recommend using terraform v#{REQUIRED_TERRAFORM_VERSION}.x"
-        exit 1
+        puts "The installed version of terraform may not work with terraspace."
+        puts "Recommend using at least terraform v#{REQUIRED_TERRAFORM_VERSION}.x"
+        puts "If you would like to bypass this check. Use TS_VERSION_CHECK=0" unless check_command?
+        exit 1 unless ENV['TS_VERSION_CHECK'] == '0'
       end
     end
 
+    def check_command?
+      ARGV[0] == "check_setup"
+    end
+
     def ok?
       version = terraform_version_message.sub(/.*v/,'') # => 0.12.24
       major, minor, _ = version.split('.')
@@ -47,7 +53,8 @@ class Terraspace::CLI
     end
     memoize :terraform_bin
 
-    # First line contains the Terraform version info:
+    # Sometimes Terraform shows the version info on the first line and sometimes on the bottom line.
+    # Account for that by finding the line.
     #
     #     $ terraform --version
     #     Terraform v0.12.24
@@ -56,7 +63,7 @@ class Terraspace::CLI
     #     is 0.12.26. You can update by downloading from https://www.terraform.io/downloads.html
     #
     def terraform_version_message
-      `terraform --version`.split("\n").first.strip
+      `terraform --version`.split("\n").find { |l| l =~ /^Terraform / }.strip
     end
     memoize :terraform_version_message
 

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|