terraspace 0.0.0 → 0.2.1

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

@@ -0,0 +1,47 @@
+module Terraspace::Terraform::Args
+  class Custom
+    extend Memoist
+    include Dsl
+    include DslEvaluator
+
+    attr_accessor :name
+    def initialize(mod, name)
+      @mod, @name = mod, name
+      @file = "#{Terraspace.root}/config/cli/args.rb"
+      @commands = {}
+    end
+
+    def build
+      return @commands unless File.exist?(@file)
+      evaluate_file(@file)
+      @commands.deep_stringify_keys!
+    end
+    memoize :build
+
+    def args
+      build
+      args = dig("args")
+      args.compact.flatten
+    end
+
+    def var_files
+      build
+      var_files = dig("var_files")
+      var_files.select! { |f| var_file_exist?(f) }
+      var_files.map { |f| "-var-file=#{f}" }
+    end
+
+    def env_vars
+      build
+      dig("env", {})
+    end
+
+    def var_file_exist?(var_file)
+      File.exist?("#{@mod.cache_dir}/#{var_file}")
+    end
+
+    def dig(prop, default=[])
+      @commands.dig(@name, prop) || default
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require "tempfile"
+
+module Terraspace::Terraform::Args
+  class Default
+    def initialize(mod, name, options={})
+      @mod, @name, @options = mod, name, options
+      @quiet = @options[:quiet].nil? ? true : @options[:quiet]
+    end
+
+    def args
+      # https://terraspace.cloud/docs/ci-automation/
+      ENV['TF_IN_AUTOMATION'] = '1' if @options[:auto]
+
+      if %w[apply destroy init output plan].include?(@name)
+        meth = "#{@name}_args"
+        send(meth)
+      else
+        []
+      end
+    end
+
+    def apply_args
+      args = auto_approve_arg
+      var_files = @options[:var_files]
+      if var_files
+        args << var_files.map { |f| "-var-file #{Dir.pwd}/#{f}" }.join(' ')
+      end
+
+      if @options[:auto] && @options[:input].nil?
+        args << " -input=false"
+      end
+      unless @options[:input].nil?
+        input = @options[:input] ? "true" : "false"
+        args << " -input=#{input}" # = sign required for apply when there's a plan at the end. so input=false works input false doesnt
+      end
+
+      # must be at the end
+      plan = @options[:plan]
+      if plan
+        if plan.starts_with?('/')
+          src  = plan
+          dest = src
+        else
+          src = "#{Dir.pwd}/#{plan}"
+          dest = "#{@mod.cache_dir}/#{File.basename(src)}"
+        end
+        FileUtils.cp(src, dest)
+        args << " #{dest}"
+      end
+      args
+    end
+
+    def init_args
+      args = "-get"
+      if @options[:auto] && @options[:input].nil?
+        args << " -input=false"
+      end
+      unless @options[:input].nil?
+        input = @options[:input] ? "true" : "false"
+        args << " -input=#{input}"
+      end
+
+      args << " -reconfigure" if @options[:reconfigure]
+
+      # must be at the end
+      if @quiet && !ENV['TS_INIT_LOUD']
+        out_path = self.class.terraform_init_log
+        FileUtils.mkdir_p(File.dirname(out_path))
+        args << " > #{out_path}"
+      end
+      [args]
+    end
+
+    def plan_args
+      args = []
+      args << "-out #{expanded_out}" if @options[:out]
+      args
+    end
+
+    def output_args
+      args = []
+      args << "-json" if @options[:format] == "json"
+      args << "> #{expanded_out}" if @options[:out]
+      args
+    end
+
+    def expanded_out
+      out = @options[:out]
+      out.starts_with?('/') ? out : "#{Dir.pwd}/#{out}"
+    end
+
+    def destroy_args
+      auto_approve_arg
+    end
+
+    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/args/dsl.rb

@@ -0,0 +1,30 @@
+module Terraspace::Terraform::Args
+  module Dsl
+    include Shorthands
+
+    def command(*commands, **props)
+      commands.each do |name|
+        if shorthand?(name)
+          shorthand_commands(name, props)
+        else
+          each_command(name, props)
+        end
+      end
+    end
+    alias_method :commands, :command
+
+    def shorthand?(name)
+      shorthands.key?(name.to_sym)
+    end
+
+    def shorthand_commands(name, props)
+      shorthands[name].each do |n|
+        each_command(n, props)
+      end
+    end
+
+    def each_command(name, props={})
+      @commands[name] = props
+    end
+  end
+end