terraspace 0.1.0 → 0.2.2

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

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

@@ -0,0 +1,38 @@
+class Terraspace::Terraform::Api
+  class Vars
+    extend Memoist
+    include Client
+
+    def initialize(mod, workspace)
+      @mod, @workspace = mod, workspace
+    end
+
+    def run
+      return unless exist?
+
+      vars = vars_class.new(@mod, vars_path).vars
+      vars.each do |attrs|
+        Var.new(@workspace, attrs).sync
+      end
+    end
+
+    # Return value examples:
+    #
+    #     Terraspace::Terraform::Api::Vars::Json
+    #     Terraspace::Terraform::Api::Vars::Rb
+    #
+    def vars_class
+      ext = File.extname(vars_path).sub('.','')
+      "Terraspace::Terraform::Api::Vars::#{ext.camelize}".constantize
+    end
+
+    def exist?
+      !!vars_path
+    end
+
+    def vars_path
+      # .rb takes higher precedence
+      Dir.glob("#{Terraspace.root}/config/terraform/cloud/vars.{rb,json}").first
+    end
+  end
+end

data/lib/terraspace/terraform/api/vars/base.rb

@@ -0,0 +1,7 @@
+class Terraspace::Terraform::Api::Vars
+  class Base
+    def initialize(mod, vars_path)
+      @mod, @vars_path = mod, vars_path
+    end
+  end
+end

data/lib/terraspace/terraform/api/vars/json.rb

@@ -0,0 +1,14 @@
+class Terraspace::Terraform::Api::Vars
+  class Json < Base
+    def vars
+      context = Terraspace::Compiler::Erb::Context.new(@mod)
+      result = RenderMePretty.result(@vars_path, context: context)
+
+      data = JSON.load(result)
+      items = data.select do |item|
+        item['data']['type'] == 'vars'
+      end
+      items.map { |i| i['data']['attributes'] }
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+class Terraspace::Terraform::Api::Vars
+  class Rb < Base
+    include DslEvaluator
+
+    def initialize(*)
+      super
+      @vars = [] # holds results
+    end
+
+    def vars
+      evaluate_file(@vars_path)
+      @vars
+    end
+
+    def var(attrs={})
+      default = { category: "terraform" } # required field
+      var = default.deep_merge(attrs).deep_stringify_keys!
+      @vars << var
+    end
+  end
+end

data/lib/terraspace/terraform/args/custom.rb

@@ -37,7 +37,7 @@ module Terraspace::Terraform::Args
     end
 
     def var_file_exist?(var_file)
-      File.exist?("#{@mod.cache_build_dir}/#{var_file}")
+      File.exist?("#{@mod.cache_dir}/#{var_file}")
     end
 
     def dig(prop, default=[])

data/lib/terraspace/terraform/args/default.rb

@@ -1,3 +1,5 @@
+require "tempfile"
+
 module Terraspace::Terraform::Args
   class Default
     def initialize(mod, name, options={})
@@ -40,7 +42,7 @@ module Terraspace::Terraform::Args
           dest = src
         else
           src = "#{Dir.pwd}/#{plan}"
-          dest = "#{@mod.cache_build_dir}/#{File.basename(src)}"
+          dest = "#{@mod.cache_dir}/#{File.basename(src)}"
         end
         FileUtils.cp(src, dest)
         args << " #{dest}"
@@ -58,9 +60,11 @@ module Terraspace::Terraform::Args
         args << " -input=#{input}"
       end
 
+      args << " -reconfigure" if @options[:reconfigure]
+
       # must be at the end
       if @quiet && !ENV['TS_INIT_LOUD']
-        out_path = "#{Terraspace.tmp_root}/out/terraform-init.out"
+        out_path = self.class.terraform_init_log
         FileUtils.mkdir_p(File.dirname(out_path))
         args << " > #{out_path}"
       end
@@ -92,5 +96,15 @@ module Terraspace::Terraform::Args
     def auto_approve_arg
       @options[:yes] || @options[:auto] ? ["-auto-approve"] : []
     end
+
+    class << self
+      # Use different tmp log file in case uses run terraspace up in 2 terminals at the same time
+      @@terraform_init_log = nil
+      def terraform_init_log
+        return @@terraform_init_log if @@terraform_init_log
+        basename = File.basename(Tempfile.new('terraform-init').path)
+        @@terraform_init_log = "#{Terraspace.tmp_root}/out/#{basename}.out"
+      end
+    end
   end
 end

data/lib/terraspace/terraform/cloud.rb

@@ -0,0 +1,25 @@
+module Terraspace::Terraform
+  class Cloud < Terraspace::CLI::Base
+    extend Memoist
+
+    def run
+      return unless workspaces?
+      api = Api.new(@mod, remote)
+      api.set_working_dir
+      api.set_env_vars
+    end
+
+    def workspaces?
+      remote && remote['workspaces']
+    end
+
+    def remote
+      backend["remote"]
+    end
+
+    def backend
+      Terraspace::Compiler::Backend::Parser.new(@mod).result
+    end
+    memoize :backend
+  end
+end

data/lib/terraspace/terraform/cloud/workspace.rb

@@ -0,0 +1,95 @@
+class Terraspace::Terraform::Cloud
+  class Workspace < Terraspace::CLI::Base
+    extend Memoist
+    include Terraspace::Util::Logging
+    include Terraspace::Terraform::Api::Client
+
+    # List will not have @mod set.
+    def list
+      @mod = Terraspace::CLI::Build::Placeholder.new(@options).build
+      unless remote && remote['organization']
+        logger.info "ERROR: There was no organization found. Are you sure you configured backend.tf with it?".color(:red)
+        exit 1
+      end
+
+      org = remote['organization']
+      payload = http.get("/organizations/#{org}/workspaces") # list using api client directly
+      names = payload['data'].map { |i| i['attributes']['name'] }.sort
+      logger.info "Workspaces for #{org}:"
+      logger.info names.join("\n")
+    end
+
+    def setup
+      build
+      unless backend.dig('remote','workspaces') # in case called by terraspace down demo -y --destroy-workspace with a non-remote backend
+        logger.info "ERROR: Workspace not configured in backend.tf"
+        exit 1
+      end
+      init
+    end
+
+    def init
+      Terraspace::CLI::Init.new(@options.merge(calling_command: "cloud-setup")).run
+    end
+
+    def destroy
+      build
+      return unless backend.dig('remote','workspaces') # in case called by terraspace down demo -y --destroy-workspace with a non-remote backend
+      api = Terraspace::Terraform::Api.new(@mod, remote)
+      workspace = api.workspace(exit_on_fail: false)
+      unless workspace
+        logger.info "Workspace #{workspace_name} not found for #{@mod.type}: #{@mod.name}"
+        exit 0
+      end
+      sure?
+      logger.info "Destroying workspace #{workspace_name}"
+      api.destroy_workspace
+    end
+
+    def build
+      Terraspace::Builder.new(@options).run
+    end
+
+    def workspace_name
+      remote['workspaces']['name']
+    end
+
+    def remote
+      backend["remote"]
+    end
+
+    def backend
+      Terraspace::Compiler::Backend::Parser.new(@mod).result
+    end
+    memoize :backend
+
+    def sure?
+      message = <<~EOL.chop + " " # chop to remove newline
+        You are about to delete the workspace: #{workspace_name}
+        All variables, settings, run history, and state history will be removed.
+        This cannot be undone.
+
+        This will NOT remove any infrastructure managed by this workspace.
+        If needed, destroy the infrastructure prior to deleting the workspace with:
+
+            terraspace down #{@mod.name}
+
+        This will delete the workspace: #{workspace_name}.
+        Are you sure? (y/N)
+      EOL
+
+      if @options[:yes]
+        sure = 'y'
+      else
+        print message
+        sure = $stdin.gets
+      end
+
+      unless sure =~ /^y/
+        puts "Whew! Exiting."
+        exit 0
+      end
+    end
+  end
+end
+