terraspace 0.0.0 → 0.1.0

data/lib/terraspace/app.rb

@@ -0,0 +1,30 @@
+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
+    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,87 @@
+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_build_dir)
+      logger.info "Building #{build_dir}"
+
+      build_all("modules") # build all modules and stacks as dependencies
+      build_all("stacks")
+      build_root_module    # build root module at the end
+
+      auto_create_backend
+      Terraform::Runner.new("init", @options).run if !auto? && @options[:init] != false # will run on @options[:init].nil?
+      build_remote_dependencies # runs after terraform init, which downloads remote modules
+      logger.info "Built in #{build_dir}"
+    end
+
+    def auto?
+      # command is only passed from CLI in the update specifically for this check
+      @options[:auto] && @options[:command] == "update"
+    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)
+        next if root?(mod) # will build root module at the end
+
+        Compiler::Builder.new(mod).build
+        built << mod_name
+      end
+    end
+
+    def root?(mod)
+      mod.name == @mod.name && mod.type == @mod.type
+    end
+
+    def auto_create_backend
+      return unless @options[:command] == "update"
+      Compiler::Backend.new(@mod).create
+    end
+
+    def local_paths(type_dir)
+      dirs("app/#{type_dir}/*") + dirs("vendor/#{type_dir}/*")
+    end
+
+    def dirs(path)
+      Dir.glob("#{Terraspace.root}/#{path}")
+    end
+
+    # Currently only handles remote modules only one-level deep.
+    def build_remote_dependencies
+      modules_json_path = "#{@mod.cache_build_dir}/.terraform/modules/modules.json"
+      return unless File.exist?(modules_json_path)
+
+      initialized_modules = JSON.load(IO.read(modules_json_path))
+      # For example of structure see spec/fixtures/initialized/modules.json
+      initialized_modules["Modules"].each do |meta|
+        build_remote_mod(meta)
+      end
+    end
+
+    def build_remote_mod(meta)
+      return if local_source?(meta["Source"])
+      return if meta['Dir'] == '.' # root is already built
+
+      remote_mod = Mod::Remote.new(meta, @mod)
+      Compiler::Builder.new(remote_mod).build
+    end
+
+  private
+    def local_source?(s)
+       s =~ %r{^\.} || s =~ %r{^/}
+    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,185 @@
+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"
+    }
+
+    desc "new SUBCOMMAND", "new subcommands"
+    long_desc Help.text(:new)
+    subcommand "new", New
+
+    desc "build MODULE", "build"
+    long_desc Help.text(:build)
+    option :quiet, type: :boolean, default: true, desc: "quiet output"
+    auto_option.call
+    init_option.call
+    input_option.call
+    instance_option.call
+    def build(mod)
+      Build.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", "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 MODULE", "down"
+    long_desc Help.text(:down)
+    instance_option.call
+    yes_option.call
+    def down(mod)
+      Commander.new("destroy", options.merge(mod: mod)).run
+    end
+
+    desc "info MODULE", "info"
+    long_desc Help.text(:info)
+    format_option.call
+    instance_option.call
+    def info(mod)
+      Info.new(options.merge(mod: mod)).run
+    end
+
+    desc "plan MODULE", "plan module"
+    long_desc Help.text(:plan)
+    auto_option.call
+    input_option.call
+    instance_option.call
+    out_option.call
+    def plan(mod)
+      Commander.new("plan", options.merge(mod: mod)).run
+    end
+
+    desc "providers MODULE", "providers"
+    long_desc Help.text(:providers)
+    instance_option.call
+    def providers(mod)
+      Commander.new("providers", options.merge(mod: mod)).run
+    end
+
+    desc "refresh", "refresh"
+    long_desc Help.text(:refresh)
+    instance_option.call
+    def refresh(mod)
+      Commander.new("refresh", options.merge(mod: mod)).run
+    end
+
+    desc "seed MODULE", "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
+    def summary
+      Summary.new(options).run
+    end
+
+    desc "show MODULE", "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 MODULE", "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 MODULE", "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
+    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, command: "update")).run
+    end
+
+    desc "validate MODULE", "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.rb

@@ -0,0 +1,7 @@
+class Terraspace::CLI
+  class Build < Base
+    def run
+      Terraspace::Builder.new(@options).run
+    end
+  end
+end