terraspace 0.0.0 → 0.1.0

data/lib/terraspace/compiler/backend.rb

@@ -0,0 +1,66 @@
+require "hcl_parser"
+
+module Terraspace::Compiler
+  class Backend
+    extend Memoist
+
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def create
+      klass = backend_class(backend_name)
+      return unless klass # in case auto-creation is not supported for specific backend
+
+      backend = klass.new(backend_info)
+      backend.call
+    end
+
+    def backend_name
+      backend_raw.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)
+    end
+
+    def backend_path
+      expr = "#{@mod.cache_build_dir}/backend.tf*"
+      Dir.glob(expr).first
+    end
+    memoize :backend_path
+
+    def backend_class(name)
+      return unless name
+      # IE: TerraspacePluginAws::Interfaces::Backend
+      klass_name = Terraspace::Plugin.klass("Backend", backend: name)
+      klass_name.constantize if klass_name
+    rescue NameError
+    end
+  end
+end

data/lib/terraspace/compiler/basename.rb

@@ -0,0 +1,10 @@
+module Terraspace::Compiler
+  module Basename
+    def basename(path)
+      # double escape of \\w is tricky
+      regexp = Regexp.new(".*(app|vendor)\/\\w+\/#{@mod.name}\/")
+      path.sub(%r{.*config/terraform/}, '')
+          .sub(regexp,'')
+    end
+  end
+end

data/lib/terraspace/compiler/builder.rb

@@ -0,0 +1,74 @@
+module Terraspace::Compiler
+  class Builder
+    include Basename
+
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def build
+      build_config
+      build_module
+      build_tfvars
+    end
+
+    # build common config files: provider and backend for the root module
+    def build_config
+      return unless @mod.root_module?
+      build_config_templates
+    end
+
+    def build_module
+      with_mod_file do |src_path|
+        build_mod_file(src_path)
+      end
+    end
+
+    def build_tfvars
+      return unless @mod.root_module?
+      Strategy::Tfvar.new(@mod).run # writer within Strategy to control file ordering
+    end
+
+  private
+    def build_config_templates
+      expr = "#{Terraspace.root}/config/terraform/**/*"
+      Dir.glob(expr).each do |path|
+        next unless File.file?(path)
+        build_config_file(basename(path))
+      end
+    end
+
+    def build_config_file(file)
+      existing = Dir.glob("#{@mod.root}/#{file}").first
+      return if existing && existing.ends_with?(".tf") # do not overwrite existing backend.tf, provider.tf, etc
+
+      if file.ends_with?(".rb")
+        src_path = Dir.glob("#{@mod.root}/#{basename(file)}").first # existing source. IE: backend.rb in module folder
+      end
+      src_path ||= Dir.glob("#{Terraspace.root}/config/terraform/#{file}").first
+      build_mod_file(src_path) if src_path
+    end
+
+    def build_mod_file(src_path)
+      content = Strategy::Mod.new(@mod, src_path).run
+      Writer.new(@mod, src_path: src_path).write(content)
+    end
+
+    def with_mod_file(&block)
+      with_path("#{@mod.root}/**/*", &block) # Only all files
+    end
+
+    def with_path(path)
+      Dir.glob(path).each do |src_path|
+        next if skip?(src_path)
+        yield(src_path)
+      end
+    end
+
+    def skip?(src_path)
+      return true unless File.file?(src_path)
+      # certain folders will be skipped
+      src_path.include?("#{@mod.root}/test")
+    end
+  end
+end

data/lib/terraspace/compiler/cleaner.rb

@@ -0,0 +1,46 @@
+module Terraspace::Compiler
+  class Cleaner
+    def initialize(mod, options={})
+      @mod, @options = mod, options
+    end
+
+    def clean
+      return if ENV['TS_NO_CLEAN']
+      backend_change_purge
+      remove_materialized_artifacts
+      # remove_materialized_artifacts_dot_terraform
+      remove_empty_directories
+    end
+
+    def backend_change_purge
+      BackendChange.new(@mod, @options).purge
+    end
+
+    # only remove .tf* files. leaving cache .terraform and terraform.state files
+    def remove_materialized_artifacts
+      Dir.glob("#{Terraspace.cache_root}/**/*").each do |path|
+        next if path.include?(".tfstate")
+        FileUtils.rm_f(path) if File.file?(path)
+      end
+    end
+
+    # Tricky: Reason we remove these artifacts is because they get written to the same source location.
+    # So when `terraspace build` is ran twice. The 2nd run will pick up the artifacts and process those again.
+    #
+    # Comment out for now. Running twice doesnt hurt because it just uses the pass.rb strategy and just copies
+    # the file again. With verbose logging, it shows it twice so that's a little bit confusing though.
+    #
+    # def remove_materialized_artifacts_dot_terraform
+    #   expr = "#{@mod.cache_build_dir}/.terraform/**/*"
+    #
+    #   Dir.glob(expr).each do |path|
+    #     logger.info "path #{path}"
+    #   end
+    # end
+
+    def remove_empty_directories
+      return unless File.exist?(Terraspace.cache_root)
+      Dir["#{Terraspace.cache_root}/**/"].reverse_each { |d| Dir.rmdir d if Dir.entries(d).size == 2 }
+    end
+  end
+end

data/lib/terraspace/compiler/cleaner/backend_change.rb

@@ -0,0 +1,45 @@
+class Terraspace::Compiler::Cleaner
+  class BackendChange
+    include Terraspace::Util
+
+    def initialize(mod, options={})
+      @mod, @options = mod, options
+    end
+
+    def purge
+      return unless purge?
+
+      cache_root = Terraspace::Util.pretty_path(Terraspace.cache_root)
+      message =<<~EOL
+        Backend change detected. Will remove #{cache_root} for complete reinitialization
+        WARN: If you are using local storage for state, this will remove it.
+        Will remove #{cache_root}
+      EOL
+      sure?(message.strip)
+      logger.info "Backend change detected. Removing #{cache_root} for complete reinitialization"
+      FileUtils.rm_rf(Terraspace.cache_root)
+    end
+
+    # Whenever the backend is changed, purge the cache entirely
+    def purge?
+      return false unless current_backend
+      current_backend != fresh_backend
+    end
+
+    def current_backend
+      materialized_path = find_src_path("#{@mod.cache_build_dir}/backend*")
+      IO.read(materialized_path) if materialized_path
+    end
+
+    def fresh_backend
+      src_path = find_src_path("#{Terraspace.root}/config/terraform/backend*")
+      Terraspace::Compiler::Strategy::Mod.new(@mod, src_path).run if src_path
+    end
+
+  private
+    def find_src_path(expr)
+      path = Dir.glob(expr).first
+      path if path && File.exist?(path)
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/base.rb

@@ -0,0 +1,12 @@
+module Terraspace::Compiler::Dsl
+  class Base
+    include DslEvaluator
+
+    attr_reader :structure, :options
+    def initialize(mod, src_path)
+      @mod, @src_path = mod, src_path
+      @options = mod.options # so user has access to cli options
+      @structure = {}
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/meta/local.rb

@@ -0,0 +1,7 @@
+module Terraspace::Compiler::Dsl::Meta
+  class Local
+    def method_missing(name, *args, &block)
+      "${local.#{name}}"
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/meta/var.rb

@@ -0,0 +1,7 @@
+module Terraspace::Compiler::Dsl::Meta
+  class Var
+    def method_missing(name, *args, &block)
+      "${var.#{name}}"
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/mod.rb

@@ -0,0 +1,19 @@
+module Terraspace::Compiler::Dsl
+  class Mod < Base
+    include Syntax::Mod
+
+    def build
+      evaluate
+      build_content
+    end
+
+    def evaluate
+      evaluate_file(@src_path)
+    end
+
+    def build_content
+      result = @structure.deep_stringify_keys
+      JSON.pretty_generate(result)
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/helpers/common.rb

@@ -0,0 +1,28 @@
+module Terraspace::Compiler::Dsl::Syntax::Helpers
+  module Common
+    extend Memoist
+
+    Meta = Terraspace::Compiler::Dsl::Meta
+
+    def var
+      Meta::Var.new
+    end
+    memoize :var
+
+    def local
+      Meta::Local.new
+    end
+    memoize :local
+
+    # Only show the first 2 args and now the options. Examples:
+    #
+    #     terraspace_command => "terraspace up demo"
+    #     terraspace_command('-') => "terraspace-up-demo"
+    #
+    def terraspace_command(separator=' ')
+      args = ARGV[0..1] || []
+      command = ["terraspace"] + args
+      command.join(separator)
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod.rb

@@ -0,0 +1,6 @@
+module Terraspace::Compiler::Dsl::Syntax
+  module Mod
+    include_dir("mod")
+    include_dir("helpers")
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/backend.rb

@@ -0,0 +1,18 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Backend
+    def backend(name, props={})
+      terraform = @structure[:terraform] ||= {}
+      backend = terraform[:backend] ||= {}
+      backend_expand_all!(name, props)
+      backend[name] = props
+    end
+
+    def backend_expand_all!(backend_name, props={})
+      Terraspace::Compiler::Expander.new(@mod, backend_name).expand(props)
+    end
+
+    def backend_expand(backend_name, string)
+      Terraspace::Compiler::Expander.new(@mod, backend_name).expand_string(string)
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/data.rb

@@ -0,0 +1,9 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Data
+    def data(type, name, props={})
+      resource = @structure[:data] ||= {}
+      resource_type = resource[type] ||= {}
+      resource_type[name] = props
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/locals.rb

@@ -0,0 +1,7 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Locals
+    def locals(props={})
+      @structure[:locals] ||= props
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/module.rb

@@ -0,0 +1,10 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Module
+    def module!(name, props={})
+      output = @structure[:module] ||= {}
+      output[name] = props
+    end
+    alias_method :mod, :module!
+    alias_method :module, :module! # must use self.module to call because module is a keyword though
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/output.rb

@@ -0,0 +1,8 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Output
+    def output(name, props={})
+      output = @structure[:output] ||= {}
+      output[name] = props
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/provider.rb

@@ -0,0 +1,8 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Provider
+    def provider(name, props={})
+      provider = @structure[:provider] ||= []
+      provider << {name => props}
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/resource.rb

@@ -0,0 +1,24 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Resource
+    def resource(type, name, props={})
+      resource = @structure[:resource] ||= {}
+      resource_type = resource[type] ||= {}
+      props = decorate(type, props)
+      resource_type[name] = props
+    end
+
+    def decorate(type, props)
+      klass = decorator_class(type)
+      return props unless klass
+      decorator = klass.new(type, props)
+      decorator.call
+    end
+
+    def decorator_class(type)
+      # IE: TerraspacePluginAws::Interfaces::Decorator
+      klass_name = Terraspace::Plugin.klass("Decorator", resource: type)
+      klass_name.constantize if klass_name
+    rescue NameError
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/terraform.rb

@@ -0,0 +1,8 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Terraform
+    def terraform(name, props={})
+      terraform = @structure[:terraform] ||= {}
+      terraform[name] = props
+    end
+  end
+end

data/lib/terraspace/compiler/dsl/syntax/mod/variable.rb

@@ -0,0 +1,12 @@
+module Terraspace::Compiler::Dsl::Syntax::Mod
+  module Variable
+    def variable(name, props={})
+      variable = @structure[:variable] ||= {}
+
+      default = { type: "string" }
+      props.reverse_merge!(default)
+
+      variable[name] = props
+    end
+  end
+end