awx 0.1.0 → 0.2.0

data/lib/core/config.rb

@@ -0,0 +1,127 @@
+require 'fileutils'
+require 'parseconfig'
+
+module App
+
+    class Config
+
+        @params = {}
+
+        extend ConfigUnique
+        include ConfigUnique
+
+        def self.initialize
+            if config_file_exists?
+                run_load_config
+            else
+                run_first_journey
+            end
+        end
+
+        def self.config_file_exists?
+            unless File.exists? ("#{File.expand_path(CONFIG_FILE)}")
+                return false
+            end
+            true
+        end
+
+        def self.run_load_config
+            config_params_get
+            config_params_validate
+        end
+
+        def self.run_first_journey
+            first_journey_message
+            config_file_create
+            config_file_edit
+            config_params_get
+            config_params_validate(true)
+        end
+
+        def self.first_journey_message
+            puts
+            puts "Thank you for installing the #{Blufin::Terminal::format_highlight("#{GEM_NAME}-cli")} ruby gem."
+            puts "CLI stands for 'Command Line Interface'."
+            puts
+            puts "The first thing you'll need to do is setup your configuration file."
+            puts "The file is located at: #{Blufin::Terminal::format_directory(ConfigUnique::CONFIG_FILE)}"
+            puts
+            puts "You probably won't have this file so the program will create it for you."
+            puts "\n"
+            unless Blufin::Terminal::prompt_yes_no('Create configuration file?')
+                Blufin::Terminal::abort
+            end
+        end
+
+        def self.config_file_edit
+            system("nano #{File.expand_path(CONFIG_FILE)}")
+        end
+
+        def self.config_params_get
+            config = ParseConfig.new("#{File.expand_path(CONFIG_FILE)}")
+            config.get_params.each do |param|
+                @params[param] = config[param]
+            end
+        end
+
+        def self.config_params_validate(show_success_message = false)
+            error_text   = ''
+            missing_keys = get_missing_config_keys
+            if missing_keys.any?
+                missing_keys.each do |key|
+                    error_text = "#{error_text}\x1B[38;5;196mKey/value must exist and cannot be null:\x1B[0m \x1B[38;5;240m#{key}\x1B[0m\n"
+                end
+                error_text = error_text[0..-2]
+            end
+            unless error_text == ''
+                show_error_message(error_text)
+            end
+            if show_success_message
+                Blufin::Terminal::success('Configuration parameters are correct.', "You are now ready to start using this utility.\nStart by typing #{Blufin::Terminal::format_command("#{GEM_NAME} --help")} (or #{Blufin::Terminal::format_command("#{GEM_NAME} -h")}).")
+                exit
+            end
+        end
+
+        def self.show_error_message(error_text)
+            Blufin::Terminal::error('Your configuration parameters are invalid.', "#{error_text}\n\nYou can fix this by running #{Blufin::Terminal::format_command("#{GEM_NAME} setup")} (or #{Blufin::Terminal::format_command("#{GEM_NAME} x")}).")
+            exit
+        end
+
+        def self.get_missing_config_keys
+            missing_keys = required_config_keys.dup
+            @params.each do |key, value|
+                unless value == ''
+                    missing_keys.delete(key)
+                end
+            end
+            missing_keys
+        end
+
+        # Checks if a config parameter exists.
+        # @return boolean
+        def self.param_exists(param_name)
+            @params.has_key?(param_name)
+        end
+
+        # Get ALL config parameters.
+        # @return Hash
+        def self.params
+            @params
+        end
+
+        # Get custom keys from the config file (IE: ssh_ec2=user|host|pem)
+        # @return String
+        def self.get_custom_key(prefix, config_key)
+            if config_key.nil?
+                Blufin::Terminal::error("The script requires a config parameter from your #{Blufin::Terminal::format_directory(ConfigUnique::CONFIG_FILE)} file", "The key should have a prefix of: #{Blufin::Terminal::format_highlight(prefix)}", true)
+            end
+            config_param = (config_key =~ /\A#{prefix}\S+\z/i) ? config_key : "#{prefix}#{config_key}"
+            unless App::Config::param_exists(config_param)
+                Blufin::Terminal::error('Invalid config parameter', "Cannot find #{Blufin::Terminal::format_highlight('key')} #{Blufin::Terminal::format_invalid("\"#{config_param}\"")} in: #{Blufin::Terminal::format_directory(ConfigUnique::CONFIG_FILE)}", true)
+            end
+            App::Config.param(config_param)
+        end
+
+    end
+
+end

data/lib/core/config_unique.rb

@@ -0,0 +1,64 @@
+module ConfigUnique
+
+    @params               = {}
+
+    # USED BY CONFIG CLASS
+    CONFIG_FILE           = '~/.awxrc'
+    GEM_NAME              = 'awx'
+
+    # STORED PARAMETERS
+    PATH_TO_REPO_AWX      = 'path_to_repo_awx'
+    PATH_TO_REPO_SECRETS  = 'path_to_repo_secrets'
+    PATH_TO_LAMBDA_EWORLD = 'path_to_lambda_eworld'
+
+    def param(param_name)
+
+        raise RuntimeError, "Expected String, instead got:#{param_name.class}" unless param_name.is_a?(String)
+
+        unless [
+            PATH_TO_REPO_AWX,
+            PATH_TO_REPO_SECRETS,
+            PATH_TO_LAMBDA_EWORLD
+        ].include?(param_name)
+            unless param_name =~ /^ssh_[a-z_]+$/
+                raise RuntimeError, "#{Blufin::Terminal::format_highlight(param_name)} is not a valid config parameter"
+            end
+        end
+
+        param_value = @params[param_name]
+        return nil if param_value.nil?
+
+        if [
+            PATH_TO_REPO_AWX,
+            PATH_TO_REPO_SECRETS,
+            PATH_TO_LAMBDA_EWORLD
+        ].include?(param_name)
+            begin
+                return "/#{Blufin::Strings.remove_surrounding_slashes(File.expand_path(param_value))}"
+            rescue Exception => e
+                Blufin::Terminal::error("Something went wrong trying to get parameter: #{param_name}", e.message)
+            end
+        end
+
+        param_value
+    end
+
+    def config_file_create
+        File.open("#{File.expand_path(CONFIG_FILE)}", 'w') { |file|
+            file.write("# CONFIGURATION FILE -- Make sure that ALL parameters are correct before saving.\n")
+            file.write("\n")
+            file.write("#{PATH_TO_REPO_AWX}=\n")
+            file.write("#{PATH_TO_REPO_SECRETS}=\n")
+            file.write("#{PATH_TO_LAMBDA_EWORLD}=\n")
+        }
+    end
+
+    def required_config_keys
+        [
+            PATH_TO_REPO_AWX,
+            PATH_TO_REPO_SECRETS,
+            PATH_TO_LAMBDA_EWORLD
+        ]
+    end
+
+end

data/lib/core/opt.rb

@@ -0,0 +1,17 @@
+module App
+
+    class Opt
+
+        OPT_PATH_YML = '/opt/yml'
+
+        # Get PATH to opt files.
+        # @return String
+        def self.get_base_path
+            base_path = File.dirname(File.expand_path(__FILE__))
+            base_path = base_path.gsub(/\/\w+\/\w+\z/i, '')
+            base_path
+        end
+
+    end
+
+end

data/lib/routes/aws_cloudformation_create.rb

@@ -0,0 +1,732 @@
+require 'json'
+require 'securerandom'
+require 'digest'
+
+module AppCommand
+
+    class AWSCloudFormationCreate < ::Convoy::ActionCommand::Base
+
+        DEFAULT            = 'Default'
+        DESCRIPTION        = 'Description'
+        PARAMETERS         = 'Parameters'
+        SPECIAL_METHODS    = [:before_create, :after_create, :before_teardown, :after_teardown]
+        OPTION_TAGS        = %w(stackname description environment project region resource cache_uuid)
+        OPTION_STACK_NAME  = 'StackName'
+        OPTION_DESCRIPTION = 'Description'
+        OPTION_PROJECT     = 'Project'
+        OPTION_ENVIRONMENT = 'Environment'
+        OPTION_REGION      = 'Region'
+        MATCHERS           = %w(CATEGORY TEMPLATE PROJECT ENVIRONMENT REGION UUID)
+        OPTIONS            = 'Options'
+        SPECIAL            = 'AWS-specific'
+        CACHE_UUID         = 'cache_uuid'
+        TEST               = 'test'
+        SPACER             = '<<--Spacer-->>'
+
+        def execute
+
+            begin
+
+                @opts = command_options
+                @args = arguments
+
+                @template             = nil
+                @templates            = {}
+                @params               = {}
+                @output               = {}
+                @regions              = App::AWSCli::get_regions
+                @auto_fetch_resources = {}
+                @auto_fetch_cache     = {}
+                @data                 = nil
+                @table_widths         = {}
+                @export_map           = {}
+                @columns              = {}
+                @options_default      = {} # The options from the cloudformation.rb file (default for all).
+                @cache                = {}
+
+                @columns, @data, @export_map, @table_widths = App::AWSReports::parse_metadata(@regions)
+
+                opts_validate
+                opts_routing
+
+            rescue => e
+
+                Blufin::Terminal::print_exception(e)
+
+            end
+
+        end
+
+        def opts_validate
+
+            # If Terminal window is smaller than 230, bomb-out.
+            terminal_width_actual   = Blufin::Terminal::get_terminal_width
+            terminal_required_width = 227
+            Blufin::Terminal::error("Output for this command \x1B[38;5;240m(#{Blufin::Terminal::format_action(terminal_required_width)}\x1B[38;5;240m-width)\x1B[0m does not fit in Terminal \x1B[38;5;240m(#{Blufin::Terminal::format_action(terminal_width_actual)}\x1B[38;5;240m-width)\x1B[0m", 'Please make your terminal wider and try again.', true) if terminal_width_actual < terminal_required_width
+
+            @warnings                    = []
+            @auto_fetch_resources        = App::AWSReports::get_auto_fetch_resources(@data)
+
+            # Validate the cloudformation.rb file that sits in the root of: blufin-secrets/cloudformation.
+            cloudformation_defaults_file = "#{App::AWSCloudFormation::get_cloudformation_path}/#{App::AWSCloudFormation::FILE_CLOUDFORMATION_DEFAULTS}"
+            if Blufin::Files::file_exists(cloudformation_defaults_file)
+                require cloudformation_defaults_file
+                expected_constants = %w(STACK_NAME PROJECTS ENVIRONMENTS REGIONS)
+                CloudFormation::Defaults::constants.each do |constant|
+                    constant = constant.to_s
+                    expected_constants.delete(constant) if expected_constants.include?(constant)
+                    @options_default[OPTION_STACK_NAME]  = CloudFormation::Defaults::STACK_NAME if constant == 'STACK_NAME'
+                    @options_default[OPTION_PROJECT]     = CloudFormation::Defaults::PROJECTS if constant == 'PROJECTS'
+                    @options_default[OPTION_ENVIRONMENT] = CloudFormation::Defaults::ENVIRONMENTS if constant == 'ENVIRONMENTS'
+                    @options_default[OPTION_REGION]      = CloudFormation::Defaults::REGIONS if constant == 'REGIONS'
+                end
+                raise RuntimeError, "Missing expected constants: #{expected_constants.join(',')}" if expected_constants.any?
+            else
+                raise RuntimeError, "File does not exist: #{cloudformation_defaults_file}"
+            end
+
+            # Loop the entire blufin-secrets/cloudformation path(s) and validate all the template(s).
+            Blufin::Files::get_dirs_in_dir(App::AWSCloudFormation::get_cloudformation_path).each do |path|
+                ps               = path.split('/')
+                category         = ps[ps.length - 1]
+                template_folders = Blufin::Files::get_dirs_in_dir(path)
+                template_folders.each do |path_inner|
+                    ps                     = path_inner.split('/')
+                    template               = ps[ps.length - 1]
+                    template_name          = "#{category}/#{template}"
+                    file_cloudformation    = nil
+                    file_ruby              = nil
+                    method_before_create   = nil
+                    method_after_create    = nil
+                    method_before_teardown = nil
+                    method_after_teardown  = nil
+                    intro                  = nil
+                    stack_name             = nil
+                    projects               = nil
+                    environments           = nil
+                    regions                = nil
+                    parameters             = {}
+                    warnings_count         = @warnings.length
+                    raise RuntimeError, "Template name must consist of [service]/[service-description] with exactly one slash, instead got: #{template_name}" if template_name.strip.split('/').length != 2
+                    Blufin::Files::get_files_in_dir(path_inner).each do |file|
+                        filename = Blufin::Files::extract_file_name(file)
+                        if filename == 'template.yml'
+                            begin
+                                yml_data = YAML.load_file(File.expand_path(file))
+                            rescue Exception => e
+                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Unable to parse #{Blufin::Terminal::format_highlight('template.yml')}\x1B[38;5;240m: #{e.message}"
+                                next
+                            end
+                            if yml_data.is_a?(Hash)
+                                if yml_data.has_key?(DESCRIPTION)
+                                    @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Description must be omitted because this will be handled by the script."
+                                end
+                                if yml_data.has_key?(PARAMETERS) && yml_data[PARAMETERS].is_a?(Hash) && yml_data[PARAMETERS].length > 0
+                                    yml_data[PARAMETERS].each do |resource_name, data|
+                                        # Validate keys are in specific order.
+                                        expected = {
+                                            'Type'                  => true,
+                                            'Description'           => false,
+                                            'Default'               => false,
+                                            'AllowedPattern'        => false,
+                                            'MinLength'             => false,
+                                            'MinValue'              => false,
+                                            'MaxLength'             => false,
+                                            'MaxValue'              => false,
+                                            'ConstraintDescription' => false,
+                                        }
+                                        Blufin::Validate::assert_valid_keys(expected, data.keys, "#{file} \xe2\x86\x92 #{resource_name}")
+                                        @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Template has reserved parameter: #{Blufin::Terminal::format_invalid(resource_name)}" if [OPTION_STACK_NAME.downcase].concat(OPTION_TAGS).include?(resource_name.downcase)
+                                        parameters[resource_name] = data
+                                        if @auto_fetch_resources.has_key?(resource_name)
+                                            @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Parameter: #{resource_name} cannot have default value: '#{data['Default']}' because it is a live look-up list (from AWS)." if data.keys.include?('Default')
+                                        end
+                                        # Validate parameter type.
+                                        valid_parameter_types   = %w(String Number List<Number> CommaDelimitedList)
+                                        valid_parameter_regexes = [/^AWS::[A-Za-z0-9]+::[A-Za-z0-9]+::[A-Za-z0-9]+$/, /^List<AWS::[A-Za-z0-9]+::[A-Za-z0-9]+::[A-Za-z0-9]+>$/]
+                                        unless valid_parameter_types.include?(data['Type'])
+                                            matches_vpr = false
+                                            valid_parameter_regexes.each do |vpr|
+                                                matches_vpr = true if data['Type'] =~ vpr
+                                            end
+                                            if matches_vpr
+                                                constraints = []
+                                                constraints << 'AllowedPattern' if data.has_key?('AllowedPattern')
+                                                constraints << 'MinLength' if data.has_key?('MinLength')
+                                                constraints << 'MaxLength' if data.has_key?('MaxLength')
+                                                constraints << 'MinValue' if data.has_key?('MinValue')
+                                                constraints << 'MaxValue' if data.has_key?('MaxValue')
+                                                if constraints.any?
+                                                    @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid parameter constraint(s): #{Blufin::Terminal::format_invalid(constraints.join(','))}. These don't apply to AWS-Specific parameters."
+                                                end
+                                            else
+                                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid parameter type: #{Blufin::Terminal::format_invalid(data['Type'])}"
+                                            end
+                                        end
+                                        # Can only have Max/MinLength if this is a String.
+                                        if data.has_key?('MinLength') || data.has_key?('MaxLength') || data.has_key?('AllowedPattern')
+                                            unless data['Type'] == 'String'
+                                                constraints = []
+                                                constraints << 'MinLength' if data.has_key?('MinLength')
+                                                constraints << 'MaxLength' if data.has_key?('MaxLength')
+                                                constraints << 'AllowedPattern' if data.has_key?('AllowedPattern')
+                                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid parameter constraint(s): #{Blufin::Terminal::format_invalid(constraints.join(','))}. To use these, type must be String."
+                                            end
+                                        end
+                                        # Can only have Max/MinValue if this is a Number.
+                                        if data.has_key?('MinValue') || data.has_key?('MaxValue')
+                                            unless data['Type'] == 'Number'
+                                                constraints = []
+                                                constraints << 'MinValue' if data.has_key?('MinValue')
+                                                constraints << 'MaxValue' if data.has_key?('MaxValue')
+                                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid parameter constraint(s): #{Blufin::Terminal::format_invalid(constraints.join(','))}. To use these, type must be Number."
+                                            end
+                                        end
+                                    end
+                                end
+                                file_cloudformation = file
+                            end
+                        elsif filename == 'template.rb'
+                            file_ruby = file
+                            # Load the template.rb file/class.
+                            require file
+                            expected_constants = %w(INTRO)
+                            Template::constants.each do |constant|
+                                constant = constant.to_s
+                                expected_constants.delete(constant) if expected_constants.include?(constant)
+                                intro        = Template::INTRO if constant == 'INTRO'
+                                # Optional constants.
+                                stack_name   = Template::STACK_NAME if constant == 'STACK_NAME'
+                                projects     = Template::PROJECTS if constant == 'PROJECTS'
+                                environments = Template::ENVIRONMENTS if constant == 'ENVIRONMENTS'
+                                regions      = Template::REGIONS if constant == 'REGIONS'
+                            end
+                            if stack_name.nil? || stack_name.strip == ''
+                                stack_name = @options_default[OPTION_STACK_NAME]
+                            else
+                                # Validate Stack Name (if exists).
+                                matches = stack_name.scan(/{[A-Za-z0-9]+}/)
+                                matches.each do |match|
+                                    match = match.gsub(/^{/, '').gsub(/}$/, '')
+                                    if match != match.upcase
+                                        @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 All stack-name matchers must be uppercase, found: #{Blufin::Terminal::format_invalid(match)}"
+                                        next
+                                    end
+                                    unless MATCHERS.include?(match)
+                                        @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid stack-name matcher: #{Blufin::Terminal::format_invalid(match)}"
+                                    end
+                                    stack_name_stripped = stack_name.gsub(/{[A-Za-z0-9]+}/, '')
+                                    if stack_name_stripped !~ /[a-z0-9\-]/
+                                        @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Stack-name has invalid or non-matcher, uppercase characters: #{Blufin::Terminal::format_invalid(stack_name)} \x1B[38;5;240m(#{stack_name_stripped})\x1B[0m"
+                                    end
+                                end
+                            end
+                            # If any constants are missing, this should catch it.
+                            expected_constants.each { |missing_constant| @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 The #{Blufin::Terminal::format_highlight('template.rb')}\x1B[38;5;240m file is missing a constant: #{Blufin::Terminal::format_invalid(missing_constant)}" }
+                            Template::methods.each do |method|
+                                if SPECIAL_METHODS.include?(method)
+                                    if method == :before_create
+                                        method_params = Template::method(:before_create).parameters
+                                        if method_params == [[:req, :params]]
+                                            method_before_create = Template::method(:before_create)
+                                        else
+                                            @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid #{Blufin::Terminal::format_highlight(':before_create')}\x1B[38;5;240m parameters: #{Blufin::Terminal::format_invalid(method_params.inspect)}"
+                                        end
+                                    end
+                                    if method == :after_create
+                                        method_params = Template::method(:after_create).parameters
+                                        if method_params == [[:req, :params], [:req, :output]]
+                                            method_after_create = Template::method(:after_create)
+                                        else
+                                            @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid #{Blufin::Terminal::format_highlight(':after_create')}\x1B[38;5;240m parameters: #{Blufin::Terminal::format_invalid(method_params.inspect)}"
+                                        end
+                                    end
+                                    if method == :before_teardown
+                                        method_params = Template::method(:before_teardown).parameters
+                                        if method_params == [[:req, :output]]
+                                            method_before_teardown = Template::method(:before_teardown)
+                                        else
+                                            @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid #{Blufin::Terminal::format_highlight(':before_teardown')}\x1B[38;5;240m parameters: #{Blufin::Terminal::format_invalid(method_params.inspect)}"
+                                        end
+                                    end
+                                    if method == :after_teardown
+                                        method_params = Template::method(:after_teardown).parameters
+                                        if method_params == [[:req, :output]]
+                                            method_after_teardown = Template::method(:after_teardown)
+                                        else
+                                            @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid #{Blufin::Terminal::format_highlight(':after_teardown')}\x1B[38;5;240m parameters: #{Blufin::Terminal::format_invalid(method_params.inspect)}"
+                                        end
+                                    end
+                                end
+                            end
+                            intro      = nil if !intro.nil? && intro.gsub("\n", '').gsub("\t", '').strip == ''
+                            stack_name = nil if !stack_name.nil? && stack_name.gsub("\n", '').gsub("\t", '').strip == ''
+                            # Unload the template.rb file/class.
+                            Object.send(:remove_const, :Template)
+                        end
+                    end
+                    @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 The #{Blufin::Terminal::format_highlight('template.yml')}\x1B[38;5;240m is missing, empty or invalid." if file_cloudformation.nil?
+                    @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 The #{Blufin::Terminal::format_highlight('template.rb')}\x1B[38;5;240m is missing, empty or invalid." if file_ruby.nil?
+                    @templates[category] = {} unless @templates.has_key?(category)
+                    if @warnings.length > warnings_count
+                        @templates[category][template] = {
+                            :name   => template,
+                            :broken => 'Broken'
+                        }
+                    else
+                        @templates[category][template] = {
+                            :name                   => template,
+                            :broken                 => false,
+                            :file_cloudformation    => file_cloudformation,
+                            :file_ruby              => file_ruby,
+                            :method_before_create   => method_before_create,
+                            :method_after_create    => method_after_create,
+                            :method_before_teardown => method_before_teardown,
+                            :method_after_teardown  => method_after_teardown,
+                            :parameters             => parameters,
+                            :intro                  => intro,
+                            :stack_name             => stack_name,
+                            :projects               => projects,
+                            :environments           => environments,
+                            :regions                => regions,
+                        }
+                    end
+                end
+            end
+
+            system('clear')
+
+            if @warnings.any?
+                Blufin::Terminal::warning('Some template(s) had issues:', @warnings)
+                # During test runs, bomb-out if there are warnings (otherwise continue).
+                exit if @opts[:test]
+            end
+
+        end
+
+        def opts_routing
+
+            # Show prompt to select template.
+            category, template, @template = select_template_prompt
+            unless @params.any?
+                if !@template[:parameters].nil? && @template[:parameters].any?
+                    @template[:parameters].each do |(param_name, param_data)|
+                        @params[param_name] = get_parameter_value(param_data, param_name, category, template)
+                        puts
+                    end
+                end
+                # Cache the inputted value(s).
+                cache_params             = @params
+                cache_params[CACHE_UUID] = get_cache_hexdigest(@template[:parameters])
+                Blufin::Files::write_file(get_cache_file(category, template), [cache_params.to_json])
+            end
+
+            # If this is a test-run, abandon ship here.
+            if @opts[:test]
+                puts
+                puts "\x1B[38;5;196m  Exiting because this is only a test-run.\x1B[0m"
+                puts
+                exit
+            end
+
+            # Clear the screen.
+            system('clear')
+
+            capabilities_arr = []
+            capabilities_str = nil
+
+            # Upload the template to S3.
+            App::AWSCloudFormation::upload_cloudformation_template(category, template, @params[OPTION_DESCRIPTION])
+
+            # Validates the template.
+            s3_url     = App::AWSCloudFormation::get_cloudformation_s3_bucket_url(category, template)
+            validation = App::AWSCli::cloudformation_stack_validate(@params[OPTION_REGION], s3_url)
+
+            # Check if validation output is JSON (and output appropriate format).
+            begin
+                hash = JSON.parse(validation.to_json)
+                raise RuntimeError, 'Not a Hash' unless hash.is_a?(Hash)
+                puts
+                puts "     \x1B[38;5;240mAWS says your template is: \x1B[38;5;40mVALID\x1B[0m"
+                puts
+
+                # TODO - Remove (once dev-done).
+                # Blufin::Terminal::code_highlight(hash.to_yaml, 'yml', 4)
+
+                # Extract required capabilities (if any).
+                if hash.has_key?('Capabilities')
+                    capabilities_arr = hash['Capabilities']
+                    capabilities_str = "\"#{capabilities_arr.join('" "')}\""
+                end
+            rescue
+                Blufin::Terminal::error("AWS says your template is: \x1B[38;5;196mINVALID", App::AWSCli::format_cli_error(validation), true)
+            end
+
+            # TODO - 2) Must output parameters to have the colon aligned.
+            # TODO - 3) Implement Stack Termination protection (CRUCIAL!!).
+
+            output                 = {}
+            output['StackName']    = @params[OPTION_STACK_NAME]
+            output['Description']  = @params[OPTION_DESCRIPTION]
+            output['Capabilities'] = capabilities_arr.join(', ') unless capabilities_str.nil?
+            output[SPACER]         = true
+
+            @params.each do |key, value|
+                next if OPTION_TAGS.include?(key.downcase)
+                next if OPTION_STACK_NAME.downcase == key.downcase
+                next if OPTION_DESCRIPTION.downcase == key.downcase
+                output[key] = value
+            end
+
+            # TODO NOW - FINISH THIS!
+            puts output.to_yaml
+            exit
+
+            params_output = []
+            params_output << "\x1B[38;5;240mStackName \xe2\x80\x94 \x1B[38;5;40m#{@params[OPTION_STACK_NAME]}"
+            params_output << "\x1B[38;5;240mCapabilities \xe2\x80\x94 \x1B[38;5;40m#{capabilities_arr.join(', ')}" unless capabilities_str.nil?
+
+            @params.each do |key, value|
+                next if OPTION_TAGS.include?(key.downcase)
+                next if OPTION_STACK_NAME.downcase == key.downcase
+                params_output << "\x1B[38;5;240m#{key} \xe2\x80\x94 \x1B[38;5;40m#{value}"
+            end
+
+            if Blufin::Terminal::prompt_yes_no("Deploy: #{render_category_template(category, template)} ?", params_output, 'Create CloudFormation Stack in AWS', false)
+
+                # Call :before_create() -- if exists.
+                @template[:method_before_create].call(@params) unless @template[:method_before_create].nil?
+
+                # Create the Stack.
+                App::AWSCli::cloudformation_stack_create(@params[OPTION_REGION], @params[OPTION_STACK_NAME], s3_url, params: assemble_params(@params), tags: assemble_tags(@params), capabilities: capabilities_arr)
+
+                # Call :before_create() -- if exists.
+                @template[:method_after_create].call(@params) unless @template[:method_after_create].nil?
+
+                # Success message.
+                Blufin::Terminal::success('Stack creation was successful.')
+            end
+        end
+
+        private
+
+        # Show prompt(s) to select template.
+        # @return void
+        def select_template_prompt
+            if @opts[:test]
+                category = TEST
+                template = TEST
+            else
+                # Get a list of categories which have at least 1 valid template.
+                categories = []
+                @templates.keys.each do |template_category|
+                    next if template_category == TEST
+                    has_valid = false
+                    @templates[template_category].each { |template| has_valid = true unless template[1][:broken] }
+                    categories << template_category if has_valid
+                end
+                # Bomb-out if all templates are broken. This will happen a lot during dev.
+                Blufin::Terminal::error('No valid templates.', 'Please fix the above error(s) and try again.', true) unless categories.any?
+                # Show a prompt identical to the 2nd one, except without a template selected.
+                Blufin::Terminal::custom('CLOUDFORMATION', 55)
+                # Select category prompt.
+                category = Blufin::Terminal::prompt_select('Select Category:', categories)
+                options  = []
+                @templates[category].each do |key, data|
+                    option            = {
+                        :text  => "#{data[:name]}\x1B[38;5;246m\x1B[0m",
+                        :value => data[:name]
+                    }
+                    option[:disabled] = data[:broken] if data[:broken]
+                    options << option
+                end
+                system('clear')
+                # Show a prompt identical to the 2nd one, now with category selected.
+                Blufin::Terminal::custom('CLOUDFORMATION', 55, "Selected template: #{Blufin::Terminal::format_action(category)}")
+                # Select template prompt.
+                template = Blufin::Terminal::prompt_select('Select Template:', options)
+                # If template is broken, bomb-out (in theory, a broken template should never be selectable.).
+                raise RuntimeError, "Template with category: #{category} and Id: #{template} does not exist." unless @templates.has_key?(category) && @templates[category].has_key?(template)
+                Blufin::Terminal::error("Template: #{Blufin::Terminal::format_highlight(@templates[category][template][:name])} is currently broken/incomplete.", 'Please fix error(s) and try again.', true) if @templates[category][template][:broken]
+            end
+            @params   = {}
+            @template = @templates[category][template].dup
+            system('clear')
+            @template[:parameters] = {} if !@template.has_key?(:parameters) || !@template[:parameters].any?
+            # Show summary (with intro if exists).
+            if @template[:intro].nil?
+                template_intro = []
+            else
+                template_intro = @template[:intro].split("\n")
+                template_intro << ''
+            end
+            params_to_fetch         = []
+            params_to_fetch_colored = []
+            # Output the title + intro.
+            Blufin::Terminal::custom('CLOUDFORMATION', 55, "Selected template: #{render_category_template(category, template)}")
+            # TODO - This is where you would put more info about the template (either do later or remove this TODO).
+            # puts "\x1B[38;5;240m   Stack-name: \x1B[38;5;30m#{@template[:stack_name]}\x1B[0m"
+            # puts
+            template_intro.each { |line| puts "\x1B[38;5;240m   #{line}\x1B[0m" }
+            # Prepare options. Merge custom with defaults.
+            options_current = {}
+            @options_default.each do |key, default_options|
+                options_current[OPTION_PROJECT]     = (@template[:projects].nil? ? default_options : @template[:projects]) if key == OPTION_PROJECT
+                options_current[OPTION_ENVIRONMENT] = (@template[:environments].nil? ? default_options : @template[:environments]) if key == OPTION_ENVIRONMENT
+                options_current[OPTION_REGION]      = (@template[:regions].nil? ? default_options : @template[:regions]) if key == OPTION_REGION
+            end
+            @options_default.keys.each do |key|
+                next if key == OPTION_STACK_NAME
+                @template[:parameters][key] = {
+                    'Type'        => 'String',
+                    'Description' => "%w(#{options_current[key].join(' ')})",
+                    OPTIONS       => options_current[key],
+                }
+            end
+            @template[:parameters][OPTION_STACK_NAME]  = {
+                'Type'        => 'String',
+                'Description' => @template[:stack_name].nil? ? default_options : @template[:stack_name],
+                'MinLength'   => 1
+            }
+            @template[:parameters][OPTION_DESCRIPTION] = {
+                'Type'        => 'String',
+                'Description' => 'A quick note to describe this stack (displayed in CloudFormation console).',
+                'MinLength'   => 1
+            }
+            # Get cached values (if exist and parameters haven't changed).
+            # Even a one-character change in a description will invalidate the cache.
+            cache_file                                 = get_cache_file(category, template)
+            @cache                                     = {}
+            if Blufin::Files::file_exists(cache_file)
+                begin
+                    @cache = JSON.parse(`cat #{cache_file}`)
+                rescue
+                    @cache = {}
+                end
+                # Makes sure non of the parameter definitions changed.
+                if @cache.has_key?(CACHE_UUID)
+                    @cache = {} if @cache[CACHE_UUID] != get_cache_hexdigest(@template[:parameters])
+                else
+                    @cache = {}
+                end
+            end
+            # Output the parameters (in table).
+            if @template[:parameters].any?
+                table_data = []
+                # Loop again to build output.
+                @template[:parameters].each do |param_name, param_data|
+                    if @auto_fetch_resources.has_key?(param_name)
+                        params_to_fetch << param_name
+                        params_to_fetch_colored << "\x1B[38;5;61m#{param_name}\x1B[38;5;208m"
+                    end
+                    ti = (param_data.has_key?(OPTIONS) ? :system : :normal)
+                    table_data << {
+                        :type_internal   => @auto_fetch_resources.has_key?(param_name) ? :autocomplete : ti,
+                        :parameter       => param_name,
+                        :type            => %w(string number).include?(param_data['Type'].downcase) ? param_data['Type'] : SPECIAL,
+                        :description     => param_data.has_key?('Description') ? param_data['Description'] : "\xe2\x80\x94",
+                        :allowed_pattern => param_data.has_key?('AllowedPattern') ? param_data['AllowedPattern'] : nil,
+                        :min_length      => param_data.has_key?('MinLength') ? param_data['MinLength'] : nil,
+                        :min_value       => param_data.has_key?('MinValue') ? param_data['MinValue'] : nil,
+                        :max_length      => param_data.has_key?('MaxLength') ? param_data['MaxLength'] : nil,
+                        :max_value       => param_data.has_key?('MaxValue') ? param_data['MaxValue'] : nil,
+                        :cached_value    => @cache.has_key?(param_name) ? @cache[param_name] : "\xe2\x80\x94"
+                    }
+                end
+                # This outputs the actual table with all the parameters.
+                App::AWSOutputter::display_parameters(table_data)
+                puts
+            else
+                puts
+            end
+            # If this template has auto-complete params, this shows a spinner to fetch them (whilst you're reading the intro).
+            empty_options = []
+            if params_to_fetch.any?
+                threads = []
+                params_to_fetch.each do |ptf|
+                    sleep(0.01)
+                    threads << Thread.new {
+                        options = fetch_autocomplete_options(ptf, silent: true)
+                        if options.nil? || !options.any?
+                            empty_options << "\x1B[38;5;196m#{ptf}\x1B[0m \xe2\x80\x94 \x1B[38;5;240mFound 0 result(s)."
+                        end
+                    }
+                end
+                sleep(0.1)
+                Blufin::Terminal::execute_proc("AWS - Getting parameter data: [ #{params_to_fetch_colored.join(' | ')}\x1B[38;5;208m ]", Proc.new {
+                    threads.each { |thread| thread.join }
+                })
+                puts
+            end
+            # If we have any auto-complete options that come back empty, we show an error and disable certain options.
+            if empty_options.any?
+                Blufin::Terminal::error("Cannot currently use this template because some #{Blufin::Terminal::format_highlight('required resources')} don't exist in \x1B[38;5;231m\x1B[48;5;17m AWS \x1B[0m :", empty_options, false)
+                puts
+                choices = []
+            else
+                choices = @cache.any? ? [{value: 'Y', text: "Select this template \x1B[38;5;198m(and apply cached values)\x1B[0m"}] : []
+                choices << {value: 'y', text: 'Select this template'}
+            end
+            # The prompt at the end of the intro.
+            choices << {value: 'n', text: 'Select another template'}
+            choices << {value: 'q', text: 'Quit'}
+            choice = Blufin::Terminal::prompt_select('What would you like to do?', choices)
+            case choice
+                when 'y'
+                    puts
+                    return [category, template, @template]
+                when 'Y'
+                    @params = @cache
+                    return [category, template, @template]
+                when 'n'
+                    system('clear')
+                    select_template_prompt
+                when 'q'
+                    puts
+                    exit
+                else
+                    raise RuntimeError, "Unhandled choice: #{choice}"
+            end
+        end
+
+        # Shows a parameter and gets input from user.
+        # @return void
+        def get_parameter_value(param_data, param_name, category, template)
+            description  = param_data.has_key?(DESCRIPTION) ? param_data[DESCRIPTION] : nil
+            options_text = "Select #{param_name}:"
+            if param_name == OPTION_STACK_NAME
+                constraints = []
+                constraints << "\x1B[38;5;240mMinLength: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['MinLength']}" if param_data.has_key?('MinLength')
+                default = @template[:stack_name]
+                default = default.gsub(/\{\{CATEGORY\}\}/i, category) if default =~ /\{\{CATEGORY\}\}/i
+                default = default.gsub(/\{\{TEMPLATE\}\}/i, template) if default =~ /\{\{TEMPLATE\}\}/i
+                default = default.gsub(/\{\{PROJECT\}\}/i, @params[OPTION_PROJECT]) if default =~ /\{\{PROJECT\}\}/i
+                default = default.gsub(/\{\{ENVIRONMENT\}\}/i, @params[OPTION_ENVIRONMENT]) if default =~ /\{\{ENVIRONMENT\}\}/i
+                default = default.gsub(/\{\{REGION\}\}/i, @params[OPTION_REGION]) if default =~ /\{\{REGION\}\}/i
+                default = default.gsub(/\{\{UUID\}\}/i, SecureRandom.uuid.split('-')[0]) if default =~ /\{\{UUID\{\{/i
+                default = default.downcase
+                return Blufin::Terminal::prompt_ask("Enter #{param_name}#{render_constraints(constraints)}", default: default, help: 'The name of the Stack (as displayed in CloudFormation console).')
+            elsif @auto_fetch_resources.has_key?(param_name)
+                options = fetch_autocomplete_options(param_name, silent: true)
+                return Blufin::Terminal::prompt_select(options_text, options, help: description)
+            elsif param_data.has_key?(OPTIONS)
+                raise RuntimeError, "Expected Array, instead got: #{param_data[OPTIONS].class}" unless param_data[OPTIONS].is_a?(Array)
+                if param_data[OPTIONS].length == 1
+                    default_option = param_data[OPTIONS][0]
+                    puts "#{Blufin::Terminal::display_prompt_text(options_text)} \x1B[38;5;46m#{default_option}\x1B[0m"
+                    return default_option
+                else
+                    return Blufin::Terminal::prompt_select(options_text, param_data[OPTIONS])
+                end
+            else
+                constraints = []
+                constraints << "\x1B[38;5;240mRegex: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['AllowedPattern']}" if param_data.has_key?('AllowedPattern')
+                constraints << "\x1B[38;5;240mMinLength: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['MinLength']}" if param_data.has_key?('MinLength')
+                constraints << "\x1B[38;5;240mMinValue: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['MinValue']}" if param_data.has_key?('MinValue')
+                constraints << "\x1B[38;5;240mMaxLength: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['MaxLength']}" if param_data.has_key?('MaxLength')
+                constraints << "\x1B[38;5;240mMaxValue: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['MaxValue']}" if param_data.has_key?('MaxValue')
+                default = param_data.has_key?('Default') ? param_data['Default'] : nil
+                loop do
+                    value         = Blufin::Terminal::prompt_ask("Enter #{param_name}#{render_constraints(constraints)}", default: default, help: description)
+                    value_invalid = false
+                    value_invalid = true if param_data.has_key?('AllowedPattern') && value !~ /#{param_data['AllowedPattern']}/
+                    value_invalid = true if param_data['Type'] == 'Number' && value.to_s !~/^\d+(\.\d+)?$/
+                    value_invalid = true if param_data.has_key?('MinLength') && value.to_s.length < param_data['MinLength']
+                    value_invalid = true if param_data.has_key?('MaxLength') && value.to_s.length > param_data['MaxLength']
+                    value_invalid = true if param_data.has_key?('MinValue') && value.to_i < param_data['MinValue']
+                    value_invalid = true if param_data.has_key?('MaxValue') && value.to_i > param_data['MaxValue']
+                    if value_invalid
+                        description = nil
+                        puts "\x1B[38;5;196mValue does not meet allowed constraint(s).\x1B[0m"
+                    else
+                        return value
+                    end
+                end
+            end
+            puts
+        end
+
+        # Goes off to AWS and gets values for autocomplete supported fields.
+        # @return string
+        def fetch_autocomplete_options(resource_name, silent: true)
+            raise RuntimeError, "Key not found in @auto_fetch_resources: #{resource_name}" unless @auto_fetch_resources.has_key?(resource_name)
+            return @auto_fetch_cache[resource_name] if @auto_fetch_cache.has_key?(resource_name)
+            resource_title                   = @auto_fetch_resources[resource_name][:resource_title]
+            resource                         = @auto_fetch_resources[resource_name][:resource]
+            results                          = App::AWSReports::get_aws_data(@regions, resource, resource_title, silent: silent)
+            options                          = App::AWSReports::parse_results_for_prompt(resource, results)
+            @auto_fetch_cache[resource_name] = options
+            options
+        end
+
+        # Returns short-hand syntax for tags.
+        # @return string
+        def assemble_tags(params)
+            output = []
+            params.each do |key, value|
+                next unless OPTION_TAGS.include?(key.downcase)
+                output << {
+                    'Key'   => key,
+                    'Value' => value
+                }
+            end
+            output.to_json
+        end
+
+        # Returns JSON syntax for params.
+        # @return string
+        def assemble_params(params)
+            output = []
+            params.each do |key, value|
+                next if OPTION_STACK_NAME.downcase == key.downcase
+                unless OPTION_TAGS.include?(key.downcase)
+                    output << {
+                        'ParameterKey'   => key,
+                        'ParameterValue' => value
+                    }
+                end
+            end
+            output.to_json
+        end
+
+        # Outputs anything returned from the .before() .after() .teardown() methods in templates.
+        # @return void
+        def output_res(res)
+            if res.is_a?(String) && res.length > 0
+                puts "\n\n"
+                puts res
+            elsif res.is_a?(Array) || res.is_a?(Hash)
+                puts "\n\n"
+                Blufin::Terminal::code_highlight(res.to_yaml, 'yml', 4)
+            end
+        end
+
+        # Standardized way of creating cache filename.
+        # @return string
+        def get_cache_file(category, template)
+            "/tmp/aws-cf-cache-#{category}-#{template}.txt"
+        end
+
+        # Takes the parameter keys and hashes them. Helps detect when to invalidate the cache.
+        # @return string
+        def get_cache_hexdigest(parameter_hash)
+            raise RuntimeError, "Expected Hash, instead got #{parameter_hash.class}" unless parameter_hash.is_a?(Hash)
+            Digest::SHA2.hexdigest(parameter_hash.to_s)
+        end
+
+        # Standardized way of rendering category/template output.
+        # @return string
+        def render_category_template(category, template)
+            "#{Blufin::Terminal::format_action(category)} \x1B[38;5;240m[#{Blufin::Terminal::format_highlight(template)}\x1B[38;5;240m]"
+        end
+
+        # Standardized way of rendering constraints output.
+        # @return string
+        def render_constraints(constraints)
+            constraint_bracket_color = 94
+            constraints.any? ? " \x1B[38;5;#{constraint_bracket_color}m[ #{constraints.join("\x1B[38;5;240m | ")} \x1B[38;5;#{constraint_bracket_color}m] \x1B[38;5;214m:" : ':'
+        end
+
+    end
+
+end