terraspace 0.1.2 → 0.2.0

data/lib/terraspace/core.rb

@@ -18,7 +18,7 @@ module Terraspace
     end
 
     def cache_root
-      ENV['TS_CACHE_ROOT'] || "#{root}/.terraspace-cache"
+      ENV['TS_CACHE_ROOT'] || config.build.cache_root || "#{root}/.terraspace-cache"
     end
     memoize :cache_root
 
@@ -42,5 +42,11 @@ module Terraspace
       config.logger
     end
     memoize :logger
+
+    def check_project!
+      return if File.exist?("#{Terraspace.root}/config/app.rb")
+      logger.error "ERROR: It doesnt look like this is a terraspace project. Are you sure you are in a terraspace project?".color(:red)
+      ENV['TS_TEST'] ? raise : exit(1)
+    end
   end
 end

data/lib/terraspace/mod.rb

@@ -11,18 +11,26 @@ module Terraspace
 
     attr_reader :name, :consider_stacks, :instance, :options
     def initialize(name, options={})
-      @name, @options = name, options
+      @name, @options = placeholder(name), options
       @consider_stacks = options[:consider_stacks].nil? ? true : options[:consider_stacks]
       @instance = options[:instance]
     end
 
+    def placeholder(name)
+      if name == "placeholder"
+        Terraspace::CLI::Build::Placeholder.new(@options).find_mod
+      else
+        name
+      end
+    end
+
     attr_accessor :root_module
     def root_module?
       @root_module
     end
 
     def check_exist!
-      check_terraspace_project!
+      Terraspace.check_project!
       return if root
 
       pretty_paths = paths.map { |p| Terraspace::Util.pretty_path(p) }
@@ -30,16 +38,10 @@ module Terraspace
       ENV['TS_TEST'] ? raise : exit(1)
     end
 
-    def check_terraspace_project!
-      return if File.exist?("#{Terraspace.root}/config/app.rb")
-      logger.error "ERROR: It doesnt look like this is a terraspace project. Are you sure you are in a terraspace project?".color(:red)
-      ENV['TS_TEST'] ? raise : exit(1)
-    end
-
     def to_info
       {
         build_dir: build_dir,
-        cache_build_dir: Terraspace::Util.pretty_path(cache_build_dir),
+        cache_dir: Terraspace::Util.pretty_path(cache_dir),
         name: name,
         root: Terraspace::Util.pretty_path(root),
         type: type,
@@ -48,10 +50,30 @@ module Terraspace
     end
 
     def root
-      paths.find { |p| File.exist?(p) }
+      root = paths.find { |p| File.exist?(p) }
+      if root.nil?
+        possible_fake_root
+      else
+        root
+      end
     end
     memoize :root
 
+    # If the app/stacks/NAME has been removed in source code but stack still exist in the cloud.
+    # allow user to delete by materializing an empty stack with the backend.tf
+    # Note this does not seem to work for Terraform Cloud as terraform init doesnt seem to download the plugins
+    # required. SIt only works for s3, azurerm, and gcs backends. On TFC, you can delete the stack via the GUI though.
+    #
+    #   down - so user can delete stacks w/o needing to create an empty app/stacks/demo folder
+    #   null - for the terraspace summary command when there are zero stacks.
+    #          Also useful for terraspace cloud list_workspaces
+    #
+    def possible_fake_root
+      if @options[:command] == "down"
+        "#{Terraspace.root}/app/stacks/#{@name}" # fake stack root
+      end
+    end
+
     # Relative folder path without app or vendor. For example, the actual location can be found in a couple of places
     #
     #     app/modules/vpc
@@ -74,9 +96,12 @@ module Terraspace
     end
 
     # Full path with build_dir
-    def cache_build_dir
-      "#{Terraspace.cache_root}/#{Terraspace.env}/#{build_dir}"
+    def cache_dir
+      pattern = Terraspace.config.build.cache_dir # IE: :CACHE_ROOT/:REGION/:ENV/:BUILD_DIR
+      expander = Terraspace::Compiler::Expander.autodetect(self)
+      expander.expansion(pattern)
     end
+    memoize :cache_dir
 
     def type
       root.include?("/stacks/") ? "stack" : "module"

data/lib/terraspace/mod/remote.rb

@@ -8,7 +8,7 @@ class Terraspace::Mod
     end
 
     def root
-      "#{@parent.cache_build_dir}/#{@meta['Dir']}"
+      "#{@parent.cache_dir}/#{@meta['Dir']}"
     end
 
     def type

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

@@ -6,34 +6,64 @@
 #
 module Terraspace::Plugin::Expander
   module Interface
-    delegate :build_dir, :type_dir, to: :mod
+    include Terraspace::Plugin::InferProvider
+
+    delegate :build_dir, :type_dir, :type, to: :mod
 
     attr_reader :mod
     def initialize(mod)
       @mod = mod
     end
 
+    # Handles list of objects. Calls expansion to handle each string expansion.
     def expand(props={})
       props.each do |key, value|
-        props[key] = expand_string(value)
+        props[key] = expansion(value)
       end
       props
     end
 
+    # Handles single string
+    #
     # Replaces variables denoted by colon in front with actual values. Example:
     #
     #     :REGION/:ENV/:BUILD_DIR/terraform.tfstate
     # =>
     #     us-west-2/dev/stacks/wordpress/terraform.tfstate
     #
-    def expand_string(string)
+    def expansion(string)
       return string unless string.is_a?(String) # in case of nil
 
+      string = string.dup
       vars = string.scan(/:\w+/) # => [":ENV", ":BUILD_DIR"]
       vars.each do |var|
         string.gsub!(var, var_value(var))
       end
-      string
+      strip(string)
+    end
+
+    # remove leading and trailing common separators.
+    #
+    # This is useful for when INSTANCE is not set.
+    # Note: BUILD_DIR includes INSTANCE
+    #
+    # Examples:
+    #
+    # cache_dir:
+    #
+    #    :CACHE_ROOT/:REGION/:ENV/:BUILD_DIR/
+    #
+    # s3 backend key:
+    #
+    #    :REGION/:ENV/:BUILD_DIR/terraform.tfstate
+    #
+    # workspace:
+    #
+    #    :MOD_NAME-:ENV-:REGION-:INSTANCE
+    #
+    def strip(string)
+      string.sub(/^-+/,'').sub(/-+$/,'') # remove leading and trailing -
+            .sub(%r{/+$},'') # only remove trailing / or else /home/ec2-user => home/ec2-user
     end
 
     def var_value(name)
@@ -48,5 +78,18 @@ module Terraspace::Plugin::Expander
     def env
       Terraspace.env
     end
+
+    def type_instance
+      [type, instance].reject { |s| s.blank? }.join('-')
+    end
+
+    def instance
+      @mod.options[:instance] || ''
+    end
+    alias_method :instance_option, :instance
+
+    def cache_root
+      Terraspace.cache_root
+    end
   end
-end
+end

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/seeder.rb

@@ -21,7 +21,7 @@ module Terraspace
       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}"
+        logger.warn "WARN: no variables.tf or variables.tf.json found in: #{@mod.cache_dir}"
         ENV['TS_TEST'] ? raise : exit
       end
     end
@@ -30,7 +30,7 @@ module Terraspace
     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 "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
@@ -48,12 +48,12 @@ module Terraspace
     memoize :dest_path
 
     def exist?(file)
-      path = "#{@mod.cache_build_dir}/#{file}"
+      path = "#{@mod.cache_dir}/#{file}"
       File.exist?(path)
     end
 
     def read(file)
-      path = "#{@mod.cache_build_dir}/#{file}"
+      path = "#{@mod.cache_dir}/#{file}"
       logger.info "Reading: #{Util.pretty_path(path)}"
       IO.read(path)
     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

data/lib/terraspace/terraform/api/client.rb

@@ -0,0 +1,10 @@
+class Terraspace::Terraform::Api
+  module Client
+    extend Memoist
+
+    def http
+      Http.new
+    end
+    memoize :http
+  end
+end

data/lib/terraspace/terraform/api/http.rb

@@ -0,0 +1,106 @@
+require 'net/http'
+
+class Terraspace::Terraform::Api
+  class Http
+    include Terraspace::Util::Logging
+
+    API = ENV['TERRAFORM_API'] || 'https://app.terraform.io/api/v2'
+    extend Memoist
+
+    def get(path)
+      request(Net::HTTP::Get, path)
+    end
+
+    def post(path, data={})
+      request(Net::HTTP::Post, path, data)
+    end
+
+    def patch(path, data={})
+      request(Net::HTTP::Patch, path, data)
+    end
+
+    def delete(path, data={})
+      request(Net::HTTP::Delete, path, data)
+    end
+
+    # Always translate raw json response to ruby Hash
+    def request(klass, path, data={})
+      url = url(path)
+      http = http(url)
+      req = build_request(klass, url, data)
+      resp = http.request(req) # send request
+      load_json(resp)
+    end
+
+    def build_request(klass, url, data={})
+      req = klass.new(url) # url includes query string and uri.path does not, must used url
+      set_headers!(req)
+      if [Net::HTTP::Delete, Net::HTTP::Patch, Net::HTTP::Post, Net::HTTP::Put].include?(klass)
+        text = JSON.dump(data)
+        req.body = text
+        req.content_length = text.bytesize
+      end
+      req
+    end
+
+    def set_headers!(req)
+      req['Authorization'] = "Bearer #{token}"
+      req['Content-Type'] = "application/vnd.api+json"
+    end
+
+    def http(url)
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = http.read_timeout = 30
+      http.use_ssl = true if uri.scheme == 'https'
+      http
+    end
+    memoize :http
+
+    # API does not include the /. IE: https://app.terraform.io/api/v2
+    def url(path)
+      "#{API}/#{path}"
+    end
+
+    def load_json(res)
+      if res.code == "200"
+        JSON.load(res.body)
+      else
+        if ENV['TERRASPACE_DEBUG_API']
+          puts "Error: Non-successful http response status code: #{res.code}"
+          puts "headers: #{res.each_header.to_h.inspect}"
+        end
+        nil
+      end
+    end
+
+    def token
+      token ||= ENV['TERRAFORM_TOKEN']
+      return token if token
+
+      creds_path = "#{ENV['HOME']}/.terraform.d/credentials.tfrc.json"
+      if File.exist?(creds_path)
+        data = JSON.load(IO.read(creds_path))
+        token = data.dig('credentials', 'app.terraform.io', 'token')
+      end
+
+      # Note only way to get here is to bypass init. Example:
+      #
+      #     terraspace up demo --no-init
+      #
+      unless token
+        logger.error "ERROR: Unable to not find a Terraform token. A Terraform token is needed for Terraspace to call the Terraform API.".color(:red)
+        logger.error <<~EOL
+          Here are some ways to provide the Terraform token:
+
+              1. By running: terraform login
+              2. With an env variable: export TERRAFORM_TOKEN=xxx
+
+          Please configure a Terraform token and try again.
+        EOL
+        exit 1
+      end
+      token
+    end
+  end
+end

data/lib/terraspace/terraform/api/var.rb

@@ -0,0 +1,72 @@
+class Terraspace::Terraform::Api
+  class Var
+    extend Memoist
+    include Client
+    include Terraspace::Util::Logging
+
+    def initialize(workspace, attrs={})
+      @workspace, @attrs = workspace, attrs
+      @workspace_id = @workspace['id']
+    end
+
+    def sync
+      exist? ? update : create
+    end
+
+    def update
+      return unless overwrite?
+      logger.debug "Updating Terraform Cloud #{category} variable: #{@attrs['key']}"
+      variable_id = variable_id(@attrs['key'])
+      payload = payload(variable_id)
+      http.patch("workspaces/#{@workspace_id}/vars/#{variable_id}", payload)
+    end
+
+    def overwrite?
+      cloud = Terraspace.config.cloud
+      if @attrs['sensitive']
+        cloud.overwrite_sensitive
+      else
+        cloud.overwrite
+      end
+    end
+
+    def variable_id(key)
+      current_var_resp['id']
+    end
+
+    def create
+      logger.info "Creating Terraform Cloud #{category} variable: #{@attrs['key']}"
+      http.post("workspaces/#{@workspace_id}/vars", payload)
+    end
+
+    def payload(id=nil)
+      data = {
+        type: "vars",
+        attributes: @attrs
+      }
+      data[:id] = id if id
+      { data: data }
+    end
+
+    def exist?
+      !!current_var_resp
+    end
+
+    def current_var_resp
+      current_vars_resp['data'].find do |item|
+        attributes = item['attributes']
+        attributes['key'] == @attrs['key'] &&
+        attributes['category'] == category
+      end
+    end
+
+    def category
+      @attrs['category'] || 'terraform' # default category when not set is terraform
+    end
+
+    @@current_vars_resp = nil
+    def current_vars_resp
+      @@current_vars_resp ||= http.get("workspaces/#{@workspace_id}/vars")
+    end
+  end
+end