terraspace 0.0.0 → 0.1.0

data/lib/terraspace/completer/script.rb

@@ -0,0 +1,6 @@
+class Terraspace::Completer::Script
+  def self.generate
+    bash_script = File.expand_path("script.sh", File.dirname(__FILE__))
+    logger.info "source #{bash_script}"
+  end
+end

data/lib/terraspace/completer/script.sh

@@ -0,0 +1,10 @@
+_terraspace() {
+  COMPREPLY=()
+  local word="${COMP_WORDS[COMP_CWORD]}"
+  local words=("${COMP_WORDS[@]}")
+  unset words[0]
+  local completion=$(terraspace completion ${words[@]})
+  COMPREPLY=( $(compgen -W "$completion" -- "$word") )
+}
+
+complete -F _terraspace terraspace

data/lib/terraspace/core.rb

@@ -0,0 +1,46 @@
+module Terraspace
+  module Core
+    extend Memoist
+
+    def env
+      ENV['TS_ENV'] || "dev"
+    end
+    memoize :env
+
+    @@root = nil
+    def root
+      @@root ||= ENV['TS_ROOT'] || Dir.pwd
+    end
+
+    # allow testing frameworks to switch roots
+    def root=(v)
+      @@root = v
+    end
+
+    def cache_root
+      ENV['TS_CACHE_ROOT'] || "#{root}/.terraspace-cache"
+    end
+    memoize :cache_root
+
+    def tmp_root
+      ENV['TS_TMP_ROOT'] || "/tmp/terraspace"
+    end
+    memoize :tmp_root
+
+    def configure(&block)
+      App.instance.configure(&block)
+    end
+
+    # Generally, use the Terraspace.config instead of App.instance.config since it guarantees the load_project_config call
+    def config
+      App.instance.load_project_config
+      App.instance.config
+    end
+    memoize :config
+
+    def logger
+      config.logger
+    end
+    memoize :logger
+  end
+end

data/lib/terraspace/ext.rb

@@ -0,0 +1,2 @@
+require_relative "ext/bundler"
+require_relative "ext/core/module"

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,100 @@
+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 = name, options
+      @consider_stacks = options[:consider_stacks].nil? ? true : options[:consider_stacks]
+      @instance = options[:instance]
+    end
+
+    attr_accessor :root_module
+    def root_module?
+      @root_module
+    end
+
+    def check_exist!
+      check_terraspace_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 check_terraspace_project!
+      return if File.exist?("#{Terraspace.root}/config/app.rb")
+      logger.error "ERROR: It doesnt look like this is a terraspace project. Are you sure you are in a terraspace project?".color(:red)
+      ENV['TS_TEST'] ? raise : exit(1)
+    end
+
+    def to_info
+      {
+        build_dir: build_dir,
+        cache_build_dir: Terraspace::Util.pretty_path(cache_build_dir),
+        name: name,
+        root: Terraspace::Util.pretty_path(root),
+        type: type,
+        type_dir: type_dir,
+      }
+    end
+
+    def root
+      paths.find { |p| File.exist?(p) }
+    end
+    memoize :root
+
+    # 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_build_dir
+      "#{Terraspace.cache_root}/#{Terraspace.env}/#{build_dir}"
+    end
+
+    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_build_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,52 @@
+# 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
+    delegate :build_dir, :type_dir, to: :mod
+
+    attr_reader :mod
+    def initialize(mod)
+      @mod = mod
+    end
+
+    def expand(props={})
+      props.each do |key, value|
+        props[key] = expand_string(value)
+      end
+      props
+    end
+
+    # 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 expand_string(string)
+      return string unless string.is_a?(String) # in case of nil
+
+      vars = string.scan(/:\w+/) # => [":ENV", ":BUILD_DIR"]
+      vars.each do |var|
+        string.gsub!(var, var_value(var))
+      end
+      string
+    end
+
+    def var_value(name)
+      name = name.sub(':','').downcase
+      send(name)
+    end
+
+    def mod_name
+      @mod.name
+    end
+
+    def env
+      Terraspace.env
+    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