terraspace 0.0.0 → 0.2.1

data/lib/terraspace/ext/bundler.rb

@@ -0,0 +1,7 @@
+# Bundler 2.0 does yet not have with_unbundled_env
+# Bundler 2.1 deprecates with_clean_env for with_unbundled_env
+
+require "bundler"
+def Bundler.with_unbundled_env(&block)
+  with_clean_env(&block)
+end unless Bundler.respond_to?(:with_unbundled_env)

data/lib/terraspace/ext/core/module.rb

@@ -0,0 +1,19 @@
+class Module
+  # Include all modules within the relative folder. IE: for dsl/syntax/mod/*
+  #
+  #    include Common
+  #    include Provider
+  #    # etc
+  #
+  def include_dir(dir)
+    calling_file = caller[0].split(':').first # IE: /home/ec2-user/environment/terraspace/lib/terraspace/compiler/dsl/syntax/mod.rb
+    parent_dir = File.dirname(calling_file)
+
+    full_dir = "#{parent_dir}/#{dir}"
+    Dir.glob("#{full_dir}/**/*").each do |path|
+      regexp = Regexp.new(".*/lib/")
+      klass = path.sub(regexp, '').sub('.rb','').camelize
+      include klass.constantize
+    end
+  end
+end

data/lib/terraspace/logger.rb

@@ -0,0 +1,26 @@
+require 'logger'
+
+module Terraspace
+  class Logger < ::Logger
+    # Only need to override the add method as the other calls all lead to it.
+    def add(severity, message = nil, progname = nil)
+      # Taken from Logger#add source
+      # https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html#method-i-add
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+
+      super # original logic
+    end
+
+    # plain formatting
+    def format_message(severity, timestamp, progname, msg)
+      "#{msg}\n"
+    end
+  end
+end

data/lib/terraspace/mod.rb

@@ -0,0 +1,125 @@
+module Terraspace
+  # Example properties:
+  #
+  #     name: vpc
+  #     root: app/modules/vpc, app/stacks/vpc, vendor/modules/vpc or vendor/stacks/vpc
+  #     type: module or stack
+  #
+  class Mod
+    extend Memoist
+    include Terraspace::Util
+
+    attr_reader :name, :consider_stacks, :instance, :options
+    def initialize(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!
+      Terraspace.check_project!
+      return if root
+
+      pretty_paths = paths.map { |p| Terraspace::Util.pretty_path(p) }
+      logger.error "ERROR: Unable to find #{@name.color(:green)} module. Searched paths: #{pretty_paths}"
+      ENV['TS_TEST'] ? raise : exit(1)
+    end
+
+    def to_info
+      {
+        build_dir: build_dir,
+        cache_dir: Terraspace::Util.pretty_path(cache_dir),
+        name: name,
+        root: Terraspace::Util.pretty_path(root),
+        type: type,
+        type_dir: type_dir,
+      }
+    end
+
+    def root
+      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
+    #     app/stacks/vpc
+    #     vendor/modules/vpc
+    #     vendor/stacks/vpc
+    #
+    # The build folder does not include the app or vendor info.
+    #
+    #     modules/vpc
+    #
+    def build_dir(disable_instance: false)
+      if !disable_instance && !@instance.nil?
+        # add _ in front so instance doesnt collide with other default stacks
+        instance_name = [name, @instance].compact.join('.')
+      else
+        instance_name = name
+      end
+      [type_dir, instance_name].compact.join('/')
+    end
+
+    # Full path with 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"
+    end
+
+    def type_dir
+      type.pluralize
+    end
+
+  private
+    def paths
+      paths = []
+      root = Terraspace.root
+      paths << "#{root}/app/stacks/#{@name}" if @consider_stacks
+      paths << "#{root}/app/modules/#{@name}"
+      paths << "#{root}/vendor/stacks/#{@name}" if @consider_stacks
+      paths << "#{root}/vendor/modules/#{@name}"
+      paths
+    end
+  end
+end

data/lib/terraspace/mod/remote.rb

@@ -0,0 +1,18 @@
+class Terraspace::Mod
+  class Remote < Terraspace::Mod
+    def initialize(meta, parent)
+      # meta: from .terraform/modules/modules.json. Example structure: spec/fixtures/initialized/modules.json
+      # parent: parent module or stack. IE: terraspace build MOD
+      @meta, @parent  = meta, parent
+      @name = @meta['Key']
+    end
+
+    def root
+      "#{@parent.cache_dir}/#{@meta['Dir']}"
+    end
+
+    def type
+      "module"
+    end
+  end
+end

data/lib/terraspace/plugin.rb

@@ -0,0 +1,73 @@
+module Terraspace
+  module Plugin
+    extend Memoist
+
+    # The plugin metadata
+    #
+    # Example meta:
+    #
+    #    {
+    #      "aws  => {root: "/path", backend: "s3"}
+    #      "google" => {root: "/path", backend: "gcs"},
+    #    }
+    #
+    @@meta = {}
+    def meta
+      @@meta
+    end
+
+    def layer_classes
+      @@meta.map { |plugin, data| data[:layer_class] }.compact
+    end
+
+    def config_classes
+      @@meta.map { |plugin, data| data[:config_class] }.compact
+    end
+
+    # The resource map can be used to customized the mapping from the resource "first word" to the plugin.
+    #
+    # resource map is in meta structure.
+    #
+    #    {
+    #      "long_cloud_plugin_name" => {resource_map: {"long_cloud_plugin_name" => "short_name"}
+    #    }
+    #
+    # This is use by Plugin::Finder#find_with_resource
+    # Allows mapping of different values in case the terraspace plugin name doesnt match with the
+    # resource first word.
+    #
+    # Generally we try to avoid this and the terraspace plugin name should match the resource "first word"
+    # when possible.
+    #
+    def resource_map
+      @@meta.inject({}) do |result, (plugin, data)|
+        map = data[:resource_map] || {}
+        result.merge(map.deep_stringify_keys)
+      end
+    end
+
+    def register(plugin, data)
+      @@meta[plugin] = data
+    end
+
+    # Example return:
+    #
+    #      TerraspacePluginAws::Interfaces::Backend
+    #      TerraspacePluginAws::Interfaces::Expander
+    #      TerraspacePluginGcp::Interfaces::Backend
+    #      TerraspacePluginGcp::Interfaces::Expander
+    #
+    def klass(interface_class, options={})
+      meta = find_with(options)
+      return unless meta
+      "TerraspacePlugin#{meta.plugin}::Interfaces::#{interface_class}"
+    end
+
+    def find_with(options={})
+      Finder.new.find_with(options)
+    end
+    memoize :find_with
+
+    extend self
+  end
+end

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

@@ -0,0 +1,8 @@
+# Should implement call method
+module Terraspace::Plugin::Backend
+  module Interface
+    def initialize(info)
+      @info = info
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# Should implement methods:
+#    defaults
+#    provider
+module Terraspace::Plugin::Config
+  module Interface
+    include DslEvaluator
+
+    attr_reader :config
+    def initialize
+      @config = defaults # plugin should implement defaults
+    end
+
+    # meant to be overridden by plugin
+    def defaults
+      ActiveSupport::OrderedOptions.new
+    end
+
+    def load_project_config
+      project_config = "#{Terraspace.root}/config/plugins/#{provider}.rb"
+      evaluate_file(project_config)
+    end
+
+    def configure
+      yield(@config)
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# Should implement call method
+module Terraspace::Plugin::Decorator
+  module Interface
+    def initialize(type, props={})
+      @type, @props = type, props
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Terraspace::Plugin::Expander
+  class Generic
+    include Interface
+  end
+end

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

@@ -0,0 +1,95 @@
+# Should implement additional methods that correspond to additional provider specific variables
+# available for substitution. For example:
+#
+#   AWS has :REGION and :ACCOUNT variables.
+#   So the aws provider implements the region and account methods.
+#
+module Terraspace::Plugin::Expander
+  module Interface
+    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] = 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 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
+      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)
+      name = name.sub(':','').downcase
+      send(name)
+    end
+
+    def mod_name
+      @mod.name
+    end
+
+    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

data/lib/terraspace/plugin/finder.rb

@@ -0,0 +1,45 @@
+module Terraspace::Plugin
+  class Finder
+    def find_with(options)
+      result = if options.key?(:plugin)
+                 find_with_plugin(options[:plugin])
+               elsif options.key?(:backend)
+                 find_with_backend(options[:backend])
+               elsif options.key?(:resource)
+                 find_with_resource(options[:resource])
+               else
+                 raise "Must provide backend, plugin, or resource option."
+               end
+      return unless result
+      raw = Hash[*result] # convert result to Hash instead of an Array
+      Meta.new(raw)
+    end
+
+    def find_with_backend(backend)
+      meta.find do |provider, data|
+        data[:backend] == backend
+      end
+    end
+
+    def find_with_plugin(plugin)
+      meta.find do |plugin_name, data|
+        plugin_name == plugin
+      end
+    end
+
+    def find_with_resource(resource)
+      map = resource_map
+      base = resource.split('_').first # google_compute_firewall => google, aws_security_group => aws
+      plugin = map[base] || base
+      find_with_plugin(plugin)
+    end
+
+    def resource_map
+      Terraspace::Plugin.resource_map
+    end
+
+    def meta
+      Terraspace::Plugin.meta
+    end
+  end
+end