terraspace 1.1.7 → 2.0.0

data/lib/terraspace/cloud/api/http_methods.rb

@@ -0,0 +1,116 @@
+class Terraspace::Cloud::Api
+  module HttpMethods
+    extend Memoist
+    include Terraspace::Util
+
+    # Always translate raw json response to ruby Hash
+    def request(klass, path, data={})
+      url = url(path)
+      req = build_request(klass, url, data)
+      retries = 0
+      begin
+        resp = http.request(req) # send request
+      rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
+        delay = 2 ** retries
+        logger.info "Unable to connect to #{url}. Delay for #{delay}s and trying again."
+        sleep(delay)
+        retries += 1
+        # Final retry time: 2 * 4 = 16s
+        # Total retry time: 2 ** 4 + 2 ** 3 + 2 ** 2 + 2 ** 1 + 2 ** 0 = 31s
+        if retries < 5 # max_retries is 4
+          retry
+        else
+          logger.error "Error connecting to #{url}"
+          message = "#{$!.class}: #{$!.message}"
+          raise Terraspace::NetworkError.new(message)
+        end
+      end
+      result = load_json(url, resp)
+      Cani.new(result).handle if data[:cani]
+      result
+    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
+
+      logger.debug "API klass: #{klass}"
+      logger.debug "API url: #{url}"
+      logger.debug "API data: #{data}"
+
+      req
+    end
+
+    def set_headers!(req)
+      req['Authorization'] = "Bearer #{token}" if token
+      req['Content-Type'] = 'application/json'
+    end
+
+    def token
+      ENV['TS_TOKEN']
+    end
+
+    def load_json(url, resp)
+      uri = URI(url)
+
+      logger.debug "resp.code #{resp.code}"
+      logger.debug "resp.body #{resp.body}" # {"errors":[{"message":"403 Forbidden"}]}
+
+      if parseable?(resp.code)
+        JSON.load(resp.body)
+      else
+        logger.error "Error: #{url}"
+        logger.error "Error: Non-successful http response status code: #{resp.code}"
+        # logger.debug "Error: Non-successful http response body: #{resp.body}"
+        logger.error "headers: #{resp.each_header.to_h.inspect}"
+        logger.error "Terraspace Cloud API #{url}"
+        raise "Terraspace Cloud API called failed: #{uri.host}"
+      end
+    end
+
+    # Note: 422 is Unprocessable Entity. This means an invalid data payload was sent.
+    # We want that to error and raise
+    def parseable?(http_code)
+      http_code =~ /^20/ || http_code =~ /^40/
+    end
+
+    def http
+      uri = URI(endpoint)
+      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)
+      "#{endpoint}/#{path}"
+    end
+
+    def get(path)
+      request(Net::HTTP::Get, path)
+    end
+
+    def post(path, data={})
+      request(Net::HTTP::Post, path, data)
+    end
+
+    def put(path, data={})
+      request(Net::HTTP::Put, 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
+  end
+end

data/lib/terraspace/cloud/api/validate.rb

@@ -0,0 +1,24 @@
+class Terraspace::Cloud::Api
+  module Validate
+    def validate(name, value)
+      unless value =~ /^[\w-]*$/
+        message = "ERROR: #{name}: only allows letters, numbers, dashes, and underscores"
+      end
+      if value =~ /^[-_]/ || value =~ /[-_]$/
+        message = "ERROR: #{name}: no leading or trailing underscore or dash allowed"
+      end
+      if message
+        puts message.color(:red)
+        puts <<~EOL
+          Please fix the configuration
+
+          config/app.rb
+
+             config.cloud.#{name} = '...'
+
+        EOL
+        exit 1
+      end
+    end
+  end
+end

data/lib/terraspace/cloud/api.rb

@@ -0,0 +1,33 @@
+module Terraspace::Cloud
+  class Api
+    include Context
+    include HttpMethods
+
+    def initialize(options)
+      @options = options
+      setup_context(@options)
+    end
+
+    def endpoint
+      ENV['TS_API'].blank? ? 'https://api.terraspace.cloud/api/v1' : ENV['TS_API']
+    end
+
+    def stack_path
+      "orgs/#{@org}/projects/#{@project}/stacks/#{@stack}"
+    end
+
+    def create_upload
+      post("#{stack_path}/uploads", @options)
+    end
+
+    # record_attrs: {upload_id: "upload-nRPSpyWd65Ps6978", kind: "apply", stack_id: '...'}
+    def create_plan(data)
+      post("#{stack_path}/plans", data.merge(@options))
+    end
+
+    # data: {upload_id: "upload-nRPSpyWd65Ps6978", kind: "apply", stack_id: '...'}
+    def create_update(data)
+      post("#{stack_path}/updates", data.merge(@options))
+    end
+  end
+end

data/lib/terraspace/cloud/base.rb

@@ -0,0 +1,97 @@
+module Terraspace::Cloud
+  class Base < Terraspace::CLI::Base
+    extend Memoist
+    include Api::Concern
+    include Context
+    include Terraspace::Util
+
+    def initialize(options={})
+      super
+      @cani = options[:cani]
+      @kind = options[:kind]
+      @success = options[:success]
+      setup_context(options)
+    end
+
+    def stage_attrs
+      status = @success ? "success" : "fail"
+      attrs = {
+        status: status,
+        kind: @kind,
+        terraspace_version: check.terraspace_version,
+        terraform_version: check.terraform_version,
+      }
+      attrs.merge!(ci_vars) if ci_vars
+      attrs
+    end
+
+    def check
+      Terraspace::CLI::Setup::Check.new
+    end
+    memoize :check
+
+    def pr_comment(url)
+      ci.comment(url) if ci.respond_to?(:comment)
+    end
+
+    def ci_vars
+      return unless ci
+      if ci.vars[:host]
+        vcs = Ci::Vcs.new(ci.vars)
+        vcs.merged_vars
+      else
+        ci.vars
+      end
+    end
+
+    def ci
+      Terraspace::Cloud::Ci.detect
+    end
+    memoize :ci
+
+    def sh(command, exit_on_fail: true)
+      logger.debug "=> #{command}"
+      system command
+      if $?.exitstatus != 0 && exit_on_fail
+        logger.info "ERROR RUNNING: #{command}"
+        exit $?.exitstatus
+      end
+    end
+
+    def clean_cache2_stage
+      # terraform plan can be a kind of apply or destroy
+      # terraform apply can be a kind of apply or destroy
+      kind = self.class.name.to_s.split('::').last.underscore # IE: apply or destroy
+      dir = "#{@mod.cache_dir}/.terraspace-cache/_cache2/#{kind}"
+      FileUtils.rm_rf(dir)
+      FileUtils.mkdir_p(dir)
+    end
+
+    def record?
+      changes? && !cancelled? || Terraspace.config.cloud.record == "all"
+    end
+
+    def changes?
+      no_changes = Terraspace::Logger.buffer.detect do |line|
+        line.include?('No changes')
+      end
+      zero_destroyed = Terraspace::Logger.buffer.detect do |line|
+        line.include?('Destroy complete! Resources: 0 destroyed')
+      end
+      !no_changes && !zero_destroyed
+    end
+
+    def cancelled?
+      !!Terraspace::Logger.buffer.detect do |line|
+        line.include?(' cancelled')
+      end
+    end
+
+    def terraspace_cloud_info(result)
+      data = result['data']
+      url = data['attributes']['url']
+      logger.info "Terraspace Cloud #{url}"
+      url
+    end
+  end
+end

data/lib/terraspace/cloud/ci/generic.rb

@@ -0,0 +1,25 @@
+class Terraspace::Cloud::Ci
+  class Generic
+    def vars
+      {
+        build_system: "generic",
+        host: ENV['TS_CI_HOST'] || ENV['TS_VCS_HOST'],
+        full_repo: ENV['TS_CI_REPO'],
+        branch_name: ENV['TS_CI_BRANCH'],
+        # urls
+        commit_url: ENV['TS_CI_COMMIT_URL'],
+        branch_url: ENV['TS_CI_BRANCH_URL'],
+        pr_url: ENV['TS_CI_PR_URL'],
+        build_url: ENV['TS_CI_BUILD_URL'],
+        # additional properties
+        build_type: ENV['TS_CI_BUILD_TYPE'],
+        pr_number: ENV['TS_CI_PR_NUMBER'],
+        sha: ENV['TS_CI_SHA'],
+        # additional properties
+        commit_message: ENV['TS_CI_COMMIT_MESSAGE'],
+        build_id: ENV['TS_CI_BUILD_ID'],
+        build_number: ENV['TS_CI_BUILD_NUMBER'],
+      }
+    end
+  end
+end

data/lib/terraspace/cloud/ci/manual.rb

@@ -0,0 +1,81 @@
+class Terraspace::Cloud::Ci
+  class Manual
+    extend Memoist
+    include Terraspace::Util::Logging
+
+    def vars
+      if git_repo? && git_installed?
+        vars_data
+      else
+        { build_system: "manual" }
+      end
+    end
+
+    def vars_data
+      {
+        build_system: "manual",   # required
+        host: host,
+        full_repo: full_repo,
+        branch_name: branch_name,
+        sha: sha,
+        dirty: dirty?,
+        # commit_url: commit_url,  # provided by core
+        # branch_url: branch_url,  # provided by core
+      }
+    end
+
+    def host
+      return nil unless File.exist?('.git')
+      return nil if git_url.blank?
+      uri = URI(git_url)
+      "#{uri.scheme}://#{uri.host}"
+    end
+
+    def full_repo
+      uri = URI(git_url)
+      uri.path.sub(/^\//,'')
+    end
+
+    def dirty?
+      out = git "status --porcelain"
+      !out.blank?
+    end
+
+    # Works for
+    #   git@github.com:    => https://github.com/
+    #   git@bitbucket.org: => https://bitbucket.org/
+    #   git@gitlab.com:    => https://gitlab.com/
+    def git_url
+      out = git "config --get remote.origin.url"
+      out.sub(/\.git/,'').sub(/^git@/,'https://').sub(/\.(.*):/,'.\1/')
+    end
+
+    def branch_name
+      out = git "rev-parse --abbrev-ref HEAD"
+      out unless out == "HEAD" # edge case: when branch has never been pushed
+    end
+
+    def sha
+      out = git "rev-parse HEAD"
+      out unless out == "HEAD" # edge case: when branch has never been pushed
+    end
+
+    def git(command)
+      return unless git_installed?
+      out = `git #{command}`
+      unless $?.success?
+        logger.debug "WARN Command Failed: git #{command}".color(:yellow)
+      end
+      out.strip
+    end
+    memoize :git
+
+    def git_installed?
+      system "type git > /dev/null 2>&1"
+    end
+
+    def git_repo?
+      File.exist?('.git')
+    end
+  end
+end

data/lib/terraspace/cloud/ci/vcs/base.rb

@@ -0,0 +1,36 @@
+class Terraspace::Cloud::Ci::Vcs
+  class Base
+    extend Memoist
+
+    def initialize(vars)
+      @vars = vars
+    end
+
+    def vars
+      {
+        commit_url: commit_url,  # implemented by subclass
+        branch_url: branch_url,  # implemented by subclass
+      }
+    end
+
+    def merged_vars
+      @vars.merge(vars)
+    end
+
+    class << self
+      def vars_methods(*names)
+        names.each do |name|
+          vars_method(name)
+        end
+      end
+
+      def vars_method(name)
+        define_method name do
+          @vars[name]
+        end
+      end
+    end
+
+    vars_methods :host, :full_repo, :sha, :branch_name
+  end
+end

data/lib/terraspace/cloud/ci/vcs/bitbucket.rb

@@ -0,0 +1,11 @@
+class Terraspace::Cloud::Ci::Vcs
+  class Bitbucket < Base
+    def commit_url
+      "#{host}/#{full_repo}/commits/#{sha}" if sha
+    end
+
+    def branch_url
+      "#{host}/#{full_repo}/branch/#{branch_name}" if branch_name
+    end
+  end
+end

data/lib/terraspace/cloud/ci/vcs/github.rb

@@ -0,0 +1,11 @@
+class Terraspace::Cloud::Ci::Vcs
+  class Github < Base
+    def commit_url
+      "#{host}/#{full_repo}/commits/#{sha}" if sha
+    end
+
+    def branch_url
+      "#{host}/#{full_repo}/tree/#{branch_name}" if branch_name
+    end
+  end
+end

data/lib/terraspace/cloud/ci/vcs/gitlab.rb

@@ -0,0 +1,11 @@
+class Terraspace::Cloud::Ci::Vcs
+  class Gitlab < Base
+    def commit_url
+      "#{host}/#{full_repo}/-/commits/#{sha}" if sha
+    end
+
+    def branch_url
+      "#{host}/#{full_repo}/-/tree/#{branch_name}" if branch_name
+    end
+  end
+end

data/lib/terraspace/cloud/ci/vcs.rb

@@ -0,0 +1,18 @@
+class Terraspace::Cloud::Ci
+  class Vcs
+    extend Memoist
+
+    def initialize(vars)
+      @vars = vars
+    end
+
+    def merged_vars
+      vcs_class = case @vars[:host]
+                  when /github/ then Github
+                  when /gitlab/ then Gitlab
+                  when /bitbucket/ then Bitbucket
+                  end
+      vcs_class ? vcs_class.new(@vars).merged_vars : {}
+    end
+  end
+end

data/lib/terraspace/cloud/ci.rb

@@ -0,0 +1,56 @@
+module Terraspace::Cloud
+  class Ci
+    # Example meta:
+    #
+    # [
+    #   {name: "github", interface_class: TerrapaceCiGithub::Interface},
+    #   {name: "gitlab", interface_class: TerrapaceCiGitlab::Interface},
+    # ]
+    #
+    class_attribute :meta # not shared with child classes
+    self.meta = []
+
+    class << self
+      def register(data)
+        self.meta << data unless meta.find do |m|
+          m[:name] == data[:name]
+        end
+      end
+
+      def detect
+        return Generic if ENV['TS_CI_REPO']
+
+        detected = meta.find do |data|
+          env_key = data[:env_key] # IE: ENV['GITHUB_ACTIONS']
+          env_value = data[:env_value] # IE: "string" or /pattern/
+          if env_value
+            v = ENV[env_key]
+            v && match?(v, env_value)
+          else
+            ENV[env_key] # only env_key
+          end
+        end
+        klass = if detected
+          interface_class(detected)
+        else
+          Manual
+        end
+        klass.new
+      end
+
+      # IE: TerraspaceCiGithub::Interface
+      def interface_class(meta)
+        "terraspace_ci_#{meta[:name]}::Interface".classify.constantize
+      end
+
+      def match?(v, env_value)
+        case v
+        when String
+          v == env_value
+        when Regexp
+          v.match(env_value)
+        end
+      end
+    end
+  end
+end

data/lib/terraspace/cloud/context.rb

@@ -0,0 +1,14 @@
+module Terraspace::Cloud
+  module Context
+    include Terraspace::Cloud::Api::Validate
+
+    def setup_context(options)
+      cloud = Terraspace.config.cloud
+      @org = cloud.org
+      @project = cloud.project
+      @stack = options[:stack]
+      validate("org", @org)
+      validate("project", @project)
+    end
+  end
+end

data/lib/terraspace/cloud/folder/base.rb

@@ -0,0 +1,17 @@
+class Terraspace::Cloud::Folder
+  class Base < Terraspace::Cloud::Base
+    def initialize(options={})
+      super
+      @type = options[:type]
+    end
+
+    # final zip dest
+    def zip_path
+      "#{artifacts_path}.zip"
+    end
+
+    def artifacts_path
+      "#{@mod.cache_dir}/.terraspace-cache/_cache2/artifacts/#{@type}"
+    end
+  end
+end

data/lib/terraspace/cloud/folder/package.rb

@@ -0,0 +1,33 @@
+require 'zip_folder'
+
+class Terraspace::Cloud::Folder
+  class Package < Base
+    def build
+      copy
+      tidy
+      zip # returns zip path
+    end
+
+    def copy
+      FileUtils.rm_rf(artifacts_path)
+      FileUtils.mkdir_p(File.dirname(artifacts_path))
+
+      expr = "#{@mod.cache_dir}/.terraspace-cache/_cache2/#{@type}/*"
+      Dir.glob(expr).each do |src|
+        dest = "#{artifacts_path}/#{File.basename(src)}"
+        FileUtils.mkdir_p(File.dirname(dest))
+        FileUtils.cp(src, dest)
+      end
+    end
+
+    def tidy
+      Tidy.new(@options).cleanup
+    end
+
+    def zip
+      FileUtils.rm_f(zip_path)
+      ZipFolder.zip(artifacts_path, zip_path)
+      zip_path
+    end
+  end
+end

data/lib/terraspace/cloud/folder/tidy.rb

@@ -0,0 +1,54 @@
+class Terraspace::Cloud::Folder
+  class Tidy < Base
+    def cleanup
+      removals.each do |removal|
+        removal = removal.sub(%r{^/},'') # remove leading slash
+        path = "#{artifacts_path}/#{removal}"
+        rm_rf(path)
+      end
+    end
+
+    def removals
+      removals = always_removals
+      removals += get_removals("#{artifacts_path}/.gitignore")
+      removals = removals.reject do |p|
+        tskeep.find do |keep|
+          p.include?(keep)
+        end
+      end
+      removals.uniq
+    end
+
+    def get_removals(file)
+      path = file
+      return [] unless File.exist?(path)
+
+      removal = File.read(path).split("\n")
+      removal.map {|i| i.strip}.reject {|i| i =~ /^#/ || i.empty?}
+    end
+
+    # We clean out ignored files pretty aggressively. So provide
+    # a way for users to keep files from being cleaned out.
+    def tskeep
+      always_keep = %w[]
+      path = "#{artifacts_path}/.tskeep"
+      return always_keep unless File.exist?(path)
+
+      keep = IO.readlines(path)
+      keep = keep.map {|i| i.strip}.reject { |i| i =~ /^#/ || i.empty? }
+      (always_keep + keep).uniq
+    end
+
+    def rm_rf(path)
+      exists = File.exist?("#{path}/.gitkeep") || File.exist?("#{path}/.keep")
+      return if exists
+
+      FileUtils.rm_rf(path)
+    end
+
+    # These directories will be removed regardless of dir level
+    def always_removals
+      %w[.git spec tmp]
+    end
+  end
+end

data/lib/terraspace/cloud/folder/uploader.rb

@@ -0,0 +1,37 @@
+class Terraspace::Cloud::Folder
+  class Uploader < Base
+    attr_reader :record
+    def upload
+      @record = create_record # set @record for start_plan(uploader.record)
+      upload_project(@record['url'], zip_path)
+    end
+
+    def create_record
+      result = api.create_upload
+      if errors?(result)
+        error_message(result)
+        exit 1 # Consider: raise exception can rescue higher up
+      else
+        load_record(result)
+      end
+    end
+
+    def upload_project(url, path)
+      uri = URI.parse(url)
+      object_content = IO.read(path)
+      resp = Net::HTTP.start(uri.host) do |http|
+        http.send_request(
+          'PUT',
+          uri.request_uri,
+          object_content,
+          'content-type' => ''
+        )
+      end
+      unless resp.code =~ /^20/
+        puts "ERROR: Uploading code"
+        puts "resp.body #{resp.body}"
+        exit 1 # TODO: consider raising error
+      end
+    end
+  end
+end