terraspace 0.0.0 → 0.2.1

data/lib/terraspace/app.rb

@@ -0,0 +1,36 @@
+module Terraspace
+  class App
+    include Singleton
+    include DslEvaluator
+
+    attr_reader :config
+    def initialize
+      @config = defaults
+    end
+
+    def defaults
+      config = ActiveSupport::OrderedOptions.new
+      config.test_framework = "rspec"
+      config.logger = Logger.new($stdout)
+      config.logger.level = :info
+      config.hooks = Hooks.new
+      config.cloud = ActiveSupport::OrderedOptions.new
+      config.cloud.overwrite = true
+      config.cloud.overwrite_sensitive = true
+      config.build = ActiveSupport::OrderedOptions.new
+      config.build.cache_root = nil # defaults to .terraspace-cache
+      config.build.cache_dir = ":CACHE_ROOT/:REGION/:ENV/:BUILD_DIR"
+      config
+    end
+
+    def configure
+      yield(@config)
+    end
+
+    def load_project_config
+      evaluate_file("#{Terraspace.root}/config/app.rb")
+      path = "#{Terraspace.root}/config/env/#{Terraspace.env}.rb"
+      evaluate_file(path)
+    end
+  end
+end

data/lib/terraspace/app/hooks.rb

@@ -0,0 +1,18 @@
+class Terraspace::App
+  class Hooks
+    class_attribute :hooks
+    self.hooks = {}
+
+    def on_boot(&block)
+      self.class.hooks[:on_boot] = block
+    end
+
+    class << self
+      def run_hook(name)
+        name = name.to_sym
+        hook = hooks[name]
+        hook.call if hook
+      end
+    end
+  end
+end

data/lib/terraspace/autoloader.rb

@@ -0,0 +1,25 @@
+require "terraspace/bundle"
+Terraspace::Bundle.setup
+require "zeitwerk"
+
+module Terraspace
+  class Autoloader
+    class Inflector < Zeitwerk::Inflector
+      def camelize(basename, _abspath)
+        map = { cli: "CLI", version: "VERSION" }
+        map[basename.to_sym] || super
+      end
+    end
+
+    class << self
+      def setup
+        loader = Zeitwerk::Loader.new
+        loader.inflector = Inflector.new
+        loader.push_dir(File.dirname(__dir__)) # lib
+        loader.log! if ENV["TS_AUTOLOAD_LOG"]
+        loader.ignore("#{__dir__}/core_ext.rb")
+        loader.setup
+      end
+    end
+  end
+end

data/lib/terraspace/booter.rb

@@ -0,0 +1,19 @@
+module Terraspace
+  module Booter
+    def boot
+      Terraspace::Bundle.require # load plugins
+      load_plugin_default_configs
+      Terraspace.config # load project config
+      Terraspace::App::Hooks.run_hook(:on_boot)
+    end
+
+    def load_plugin_default_configs
+      Terraspace::Plugin.config_classes.each do |klass|
+        # IE: TerraspacePluginAws::Interfaces::Config.instance.load_project_config
+        klass.instance.load_project_config
+      end
+    end
+
+    extend self
+  end
+end

data/lib/terraspace/builder.rb

@@ -0,0 +1,43 @@
+module Terraspace
+  class Builder < Terraspace::CLI::Base
+    def run
+      Terraspace::CLI::CheckSetup.check!
+      @mod.root_module = true
+      Compiler::Cleaner.new(@mod, @options).clean
+      build_dir = Util.pretty_path(@mod.cache_dir)
+      logger.info "Building #{build_dir}"
+
+      build_all("modules") # build all modules and stacks as dependencies
+      build_all("stacks")
+      build_root_module
+      logger.info "Built in #{build_dir}"
+    end
+
+    def build_root_module
+      Compiler::Builder.new(@mod).build
+    end
+
+    def build_all(type_dir)
+      built = []
+      local_paths(type_dir).each do |path|
+        next unless File.directory?(path)
+        mod_name = File.basename(path)
+        next if built.include?(mod_name) # ensures modules in app folder take higher precedence than vendor folder
+
+        consider_stacks = type_dir == "stacks"
+        mod = Mod.new(mod_name, consider_stacks: consider_stacks)
+
+        Compiler::Builder.new(mod).build
+        built << mod_name
+      end
+    end
+
+    def local_paths(type_dir)
+      dirs("app/#{type_dir}/*") + dirs("vendor/#{type_dir}/*")
+    end
+
+    def dirs(path)
+      Dir.glob("#{Terraspace.root}/#{path}")
+    end
+  end
+end

data/lib/terraspace/bundle.rb

@@ -0,0 +1,54 @@
+module Terraspace
+  # Named Bundle vs Bundler to avoid having to fully qualify ::Bundler
+  module Bundle
+    # Looks like for zeitwerk module autovivification to work `bundle exec` must be called.
+    # This allows zeitwork module autovivification to work even if the user has not called terraspace with `bundle exec terraspace`.
+    # Bundler.setup is essentially the same as `bundle exec`
+    # Reference: https://www.justinweiss.com/articles/what-are-the-differences-between-irb/
+    #
+    def setup
+      return unless gemfile?
+      Kernel.require "bundler/setup"
+      Bundler.setup # Same as Bundler.setup(:default)
+    rescue LoadError => e
+      handle_error(e)
+    end
+
+    def require
+      return unless gemfile?
+      Kernel.require "bundler/setup"
+      Bundler.require(*bundler_groups)
+    rescue LoadError => e
+      handle_error(e)
+    end
+
+    def handle_error(e)
+      puts e.message
+      return if e.message.include?("already activated")
+      puts <<~EOL.color(:yellow)
+        WARNING: Unable to require "bundler/setup"
+        There may be something funny with your ruby and bundler setup.
+        You can try upgrading bundler and rubygems:
+
+            gem update --system
+            gem install bundler
+
+        Here are some links that may be helpful:
+
+        * https://bundler.io/blog/2019/01/03/announcing-bundler-2.html
+
+        Also, running bundle exec in front of your command may remove this message.
+      EOL
+    end
+
+    def gemfile?
+      ENV['BUNDLE_GEMFILE'] || File.exist?("Gemfile")
+    end
+
+    def bundler_groups
+      [:default, Terraspace.env.to_sym]
+    end
+
+    extend self
+  end
+end

data/lib/terraspace/cli.rb

@@ -0,0 +1,202 @@
+module Terraspace
+  class CLI < Command
+    class_option :verbose, type: :boolean
+    class_option :noop, type: :boolean
+
+    yes_option = Proc.new {
+      option :yes, aliases: :y, type: :boolean, desc: "-auto-approve the terraform apply"
+    }
+    format_option = Proc.new {
+      option :format, desc: "output formats: json, text"
+    }
+    out_option = Proc.new {
+      option :out, aliases: :o, desc: "write the output to path"
+    }
+    input_option = Proc.new {
+      option :input, type: :boolean, desc: "Ask for input for variables if not directly set."
+    }
+    auto_option = Proc.new {
+      option :auto, type: :boolean, desc: "Auto mode is useful for CI automation. It enables appropriate flags."
+    }
+    instance_option = Proc.new {
+      option :instance, aliases: %w[i], desc: "Instance of stack"
+    }
+    init_option = Proc.new {
+      option :init, type: :boolean, default: true, desc: "Instance of stack"
+    }
+    reconfigure_option = Proc.new {
+      option :reconfigure, type: :boolean, desc: "Add terraform -reconfigure option"
+    }
+
+    desc "new SUBCOMMAND", "new subcommands"
+    long_desc Help.text(:new)
+    subcommand "new", New
+
+    desc "cloud SUBCOMMAND", "cloud subcommands"
+    long_desc Help.text(:cloud)
+    subcommand "cloud", Cloud
+
+    desc "build STACK", "build"
+    long_desc Help.text(:build)
+    option :quiet, type: :boolean, default: true, desc: "quiet output"
+    instance_option.call
+    yes_option.call
+    def build(mod)
+      Terraspace::Builder.new(@options.merge(mod: mod)).run
+    end
+
+    desc "bundle", "bundle"
+    long_desc Help.text(:bundle)
+    def bundle(*args)
+      Bundle.new(options.merge(args: args)).run
+    end
+
+    desc "check_setup", "check_setup"
+    long_desc Help.text(:check_setup)
+    def check_setup
+      CheckSetup.new(options).run
+    end
+
+    desc "clean", "clean .terraspace-cache dir"
+    long_desc Help.text(:clean)
+    def clean
+      Clean.new(options).run
+    end
+
+    desc "console STACK", "console .terraspace-cache dir"
+    long_desc Help.text(:console)
+    instance_option.call
+    def console(mod)
+      Commander.new("console", options.merge(mod: mod)).run
+    end
+
+    desc "down STACK", "down"
+    long_desc Help.text(:down)
+    instance_option.call
+    yes_option.call
+    reconfigure_option.call
+    option :destroy_workspace, type: :boolean, desc: "Also destroy the Cloud workspace. Only applies when using Terraform Cloud remote backend."
+    def down(mod)
+      Commander.new("destroy", options.merge(mod: mod, command: "down")).run
+      Terraspace::Terraform::Cloud::Workspace.new(options.merge(mod: mod)).destroy if @options[:destroy_workspace]
+    end
+
+    desc "info STACK", "info"
+    long_desc Help.text(:info)
+    format_option.call
+    instance_option.call
+    def info(mod)
+      Info.new(options.merge(mod: mod)).run
+    end
+
+    desc "list", "list stacks and modules"
+    long_desc Help.text(:list)
+    def list
+      List.new(options).run
+    end
+
+    desc "plan STACK", "plan stack"
+    long_desc Help.text(:plan)
+    auto_option.call
+    input_option.call
+    instance_option.call
+    out_option.call
+    reconfigure_option.call
+    def plan(mod)
+      Commander.new("plan", options.merge(mod: mod)).run
+    end
+
+    desc "providers STACK", "providers"
+    long_desc Help.text(:providers)
+    instance_option.call
+    def providers(mod)
+      Commander.new("providers", options.merge(mod: mod)).run
+    end
+
+    desc "refresh STACK", "refresh"
+    long_desc Help.text(:refresh)
+    instance_option.call
+    def refresh(mod)
+      Commander.new("refresh", options.merge(mod: mod)).run
+    end
+
+    desc "seed STACK", "seed"
+    long_desc Help.text(:seed)
+    option :yes, aliases: :y, type: :boolean, desc: "bypass prompts and force overwrite files"
+    option :where, desc: "where to create file. either under app or seed folder structure. values: app or stack"
+    init_option.call
+    instance_option.call
+    def seed(mod)
+      Seed.new(options.merge(mod: mod)).run
+    end
+
+    desc "summary", "Summary of resources"
+    long_desc Help.text(:clean)
+    option :mod, desc: "Module to build to generate a backend file for discovery. By default the last module is used. Usually, it wont matter."
+    init_option.call
+    option :short, aliases: %w[s], type: :boolean, desc: "Only show statefiles"
+    def summary
+      Summary.new(options).run
+    end
+
+    desc "show STACK", "show"
+    long_desc Help.text(:show)
+    instance_option.call
+    def show(mod)
+      Commander.new("show", options.merge(mod: mod)).run
+    end
+
+    desc "test", "test"
+    long_desc Help.text(:test)
+    def test
+      Test.new(options).run
+    end
+
+    desc "output STACK", "output"
+    long_desc Help.text(:output)
+    format_option.call
+    instance_option.call
+    out_option.call
+    def output(mod)
+      Commander.new("output", options.merge(mod: mod)).run
+    end
+
+    desc "update STACK", "Update infrasturcture. IE: apply plan"
+    long_desc Help.text(:update)
+    auto_option.call
+    init_option.call
+    input_option.call
+    instance_option.call
+    yes_option.call
+    reconfigure_option.call
+    option :plan, desc: "Execution plan that can be used to only execute a pre-determined set of actions."
+    option :var_files, type: :array, desc: "list of var files"
+    def update(mod)
+      Commander.new("apply", options.merge(mod: mod)).run
+    end
+
+    desc "validate STACK", "validate"
+    long_desc Help.text(:validate)
+    instance_option.call
+    def validate(mod)
+      Commander.new("validate", options.merge(mod: mod)).run
+    end
+
+    desc "completion *PARAMS", "Prints words for auto-completion."
+    long_desc Help.text(:completion)
+    def completion(*params)
+      Completer.new(CLI, *params).run
+    end
+
+    desc "completion_script", "Generates a script that can be eval to setup auto-completion."
+    long_desc Help.text(:completion_script)
+    def completion_script
+      Completer::Script.generate
+    end
+
+    desc "version", "prints version"
+    def version
+      puts VERSION
+    end
+  end
+end

data/lib/terraspace/cli/base.rb

@@ -0,0 +1,11 @@
+class Terraspace::CLI
+  class Base
+    include Terraspace::Util
+
+    def initialize(options={})
+      @options = options
+      @mod = Terraspace::Mod.new(options[:mod], @options) # mod metadata
+      @mod.check_exist!
+    end
+  end
+end

data/lib/terraspace/cli/build/placeholder.rb

@@ -0,0 +1,40 @@
+# The placeholder stack is a special stack that is useful in case there are no app/stacks.
+# We build a placeholder back just so we have backend.tf to be used to grab info.
+# It's useful for the summary command.
+module Terraspace::CLI::Build
+  class Placeholder
+    include Terraspace::Util::Logging
+
+    def initialize(options={})
+      @options = options
+    end
+
+    # Grab the last module and build that.
+    # Assume the backend key has the same prefix
+    # Note: Tried building a empty "null" stack but with TFC a null space workspace is created, which is undesired.
+    def build
+      return if ENV['TS_SUMMARY_BUILD'] == '0'
+
+      mod = @options[:mod]
+      if !mod or mod == "placeholder"
+        logger.info "Building one of the modules to get backend.tf info"
+        mod = find_mod
+      end
+      Terraspace::Builder.new(@options.merge(mod: mod, init: false)).run # generate and init
+      Terraspace::Mod.new(mod, @options) # mod metadata
+    end
+
+    # Used by: terraspace build placeholder
+    def find_mod
+      mod_path = Dir.glob("{app,vendor}/{modules,stacks}/*").last
+      unless mod_path
+        logger.info <<~EOL
+          No modules or stacks found.
+          Unable to determine the backend state path without at least one module.
+        EOL
+        exit 0
+      end
+      File.basename(mod_path) # mod name
+    end
+  end
+end