awx 0.2.0 → 0.3.0

data/lib/aws/aws_reports.rb

@@ -12,13 +12,15 @@ module App
         KEY_REGIONS           = 'regions'
         KEY_REGIONS_PREFERRED = 'regionsPreferred'
 
-        YML_FILE = 'aws-reports.yml'
+        YML_FILE = 'reports.yml'
 
         # Parses the YML file and returns a bunch of Hashes. Throws straight-up runtime errors if something is wrong.
         # @return void
         def self.parse_metadata(regions)
 
-            yml_file = "#{App::Opt::get_base_path}#{App::Opt::OPT_PATH_YML}/#{YML_FILE}"
+            yml_file = "#{App::Opt::get_base_path}#{App::Opt::OPT_PATH}/awx/#{YML_FILE}"
+
+            # Throw error if the aws-report.yml isn't found in the /opt folder.
             Blufin::Terminal::error("File not found: #{Blufin::Terminal::format_directory(yml_file)}", 'This file should be located in the /opt folder of the my (ruby-gem) source-code.', true) unless Blufin::Files::file_exists(yml_file)
 
             columns      = {}
@@ -101,15 +103,17 @@ module App
                     end
                 end
                 # Validate Exports.
-                if !data[KEY_EXPORT].nil? && data[KEY_EXPORT].any?
-                    raise RuntimeError, "Expected #{Blufin::Terminal::format_highlight('export')} to be a Hash, instead got: #{data[KEY_EXPORT].class}" unless data[KEY_EXPORT].is_a?(Hash)
-                    raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: id" unless data[KEY_EXPORT].has_key?('id')
-                    raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: value" unless data[KEY_EXPORT].has_key?('value')
-                    raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: description" unless data[KEY_EXPORT].has_key?('description')
-                    # Make sure formatter exists.
-                    App::AWSOutputter::get_formatter(data[KEY_EXPORT]['valueFormatter']) if data[KEY_EXPORT].has_key?('valueFormatter')
-                    data[KEY_EXPORT].each { |key, val| raise RuntimeError, "Unexpected key: #{key} (#{val})" unless %w(id value valueFormatter description).include?(key) }
-                    export_map[data[KEY_EXPORT]['id']] = resource
+                unless data[KEY_EXPORT].nil?
+                    raise RuntimeError, "Expected #{resource}.export to be an Array, instead got: #{data[KEY_EXPORT].class}" unless data[KEY_EXPORT].is_a?(Array)
+                    raise RuntimeError, "Expected #{resource}.export to have at least 1 entry." unless data[KEY_EXPORT].any?
+                    data[KEY_EXPORT].each do |export|
+                        raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: id" unless export.has_key?('id')
+                        raise RuntimeError, "#{resource}.#{KEY_EXPORT} \xe2\x86\x92 Missing: value" unless export.has_key?('value')
+                        # Make sure formatter exists.
+                        App::AWSOutputter::get_formatter(export['valueFormatter']) if export.has_key?('valueFormatter')
+                        export.each { |key, val| raise RuntimeError, "Unexpected key: #{key} (#{val})" unless %w(id value valueFormatter description).include?(key) }
+                        export_map[export['id']] = resource
+                    end
                 end
             end
 
@@ -131,8 +135,8 @@ module App
                 response[region] = {} if response[region].nil?
                 sleep(0.01) unless silent
                 threads << Thread.new {
-                    cmd = "aws #{resource[App::AWSReports::KEY_CLI][App::AWSReports::KEY_COMMAND]}#{region == App::AWSReports::CONST_GLOBAL ? '' : " --region #{region}"}"
-                    puts "  \x1B[38;5;70m$ \x1B[38;5;240m#{cmd}\x1B[0m" unless silent
+                    cmd = "aws #{resource[App::AWSReports::KEY_CLI][App::AWSReports::KEY_COMMAND]}#{region == App::AWSReports::CONST_GLOBAL ? '' : " --region #{region}"} --profile #{App::AWSProfile::get_profile_name}"
+                    App::AWSOutputter::output_cli_command(cmd) unless silent
                     json = `#{cmd}`
                     begin
                         semaphore.synchronize do
@@ -152,7 +156,7 @@ module App
             puts unless silent
 
             # Display spinner while waiting for threads to finish.
-            Blufin::Terminal::execute_proc("AWS - Fetching: #{Blufin::Terminal::format_highlight(resource_title, false)}", Proc.new {
+            Blufin::Terminal::execute_proc("AWS \xe2\x80\x94 Fetching: #{Blufin::Terminal::format_highlight(resource_title, false)}", Proc.new {
                 threads.each { |thread| thread.join }
             }, verbose: !silent)
             puts unless silent
@@ -178,33 +182,50 @@ module App
             auto_fetch_resources = {}
             data.each do |resource|
                 if resource[1].has_key?(App::AWSReports::KEY_EXPORT)
-                    if resource[1][App::AWSReports::KEY_EXPORT].has_key?('id')
-                        auto_fetch_resources[resource[1][App::AWSReports::KEY_EXPORT]['id']] = {
-                            :resource_title => resource[0],
-                            :resource       => resource[1]
-                        }
+                    resource[1][App::AWSReports::KEY_EXPORT].each do |export|
+                        if export.has_key?('id')
+                            auto_fetch_resources[export['id']] = {
+                                :resource_title => resource[0],
+                                :resource       => resource[1]
+                            }
+                        end
                     end
                 end
             end
             auto_fetch_resources
         end
 
-        # Takes AWS api results and translates it to an array of key/value pairs we can pass to Blufin::Terminal::prompt_select().
+        # Takes AWS API results and translates it to an array of key/value pairs we can pass to Blufin::Terminal::prompt_select().
         # @return Array (of Hashes)
-        def self.parse_results_for_prompt(resource, results)
+        def self.parse_results_for_prompt(resource, export_id, results)
             options = []
             values  = []
+            export  = nil
+            resource[App::AWSReports::KEY_EXPORT].each do |exp|
+                if exp['id'] == export_id
+                    export = exp
+                    break
+                end
+            end
+            raise RuntimeError, "Export with ID not found: #{export_id}" if export.nil?
             results.each do |result|
-                value = result[resource[App::AWSReports::KEY_EXPORT]['value']]
-                value = App::AWSOutputter::get_formatter(resource[App::AWSReports::KEY_EXPORT]['valueFormatter']).call(value)[0] if resource[App::AWSReports::KEY_EXPORT].has_key?('valueFormatter')
+                value = result[export['value']]
+                value = App::AWSOutputter::get_formatter(export['valueFormatter']).call(value)[0] if export.has_key?('valueFormatter')
                 values << value
             end
             results.each do |result|
-                value = result[resource[App::AWSReports::KEY_EXPORT]['value']]
-                value = App::AWSOutputter::get_formatter(resource[App::AWSReports::KEY_EXPORT]['valueFormatter']).call(value)[0] if resource[App::AWSReports::KEY_EXPORT].has_key?('valueFormatter')
+                value = result[export['value']]
+                value = App::AWSOutputter::get_formatter(export['valueFormatter']).call(value)[0] if export.has_key?('valueFormatter')
+                sort  = result[export['description']] # Used for sorting.
+                if export.has_key?('description')
+                    text = "#{value.rjust(values.max_by(&:length).length.to_i, ' ')} \x1B[38;5;246m\xe2\x80\x94 \x1B[38;5;240m#{sort}\x1B[0m"
+                else
+                    text = value
+                end
                 options << {
                     :value => value,
-                    :text  => "#{value.rjust(values.max_by(&:length).length.to_i, ' ')} \x1B[38;5;246m\xe2\x80\x94 \x1B[38;5;240m#{result[resource[App::AWSReports::KEY_EXPORT]['description']]}\x1B[0m",
+                    :text  => text,
+                    :sort  => sort,
                 }
             end
             options

data/lib/awx.rb

@@ -4,40 +4,58 @@ require 'yaml'
 require 'blufin-lib'
 
 require_relative 'version'
-require 'core/config_unique'
-require 'aws/aws_config'
+require 'core/opt'
 require 'aws/aws_credentials'
+require 'aws/aws_profile'
 
-Dir["#{File.dirname(__FILE__)}/aws/**/*.rb"].each { |file| load(file) unless file =~ /\/(config_unique|aws_config|aws_credentials)\.rb\z/ }
-Dir["#{File.dirname(__FILE__)}/core/**/*.rb"].each { |file| load(file) unless file =~ /\/(config_unique|aws_config|aws_credentials)\.rb\z/ }
+Dir["#{File.dirname(__FILE__)}/aws/**/*.rb"].each { |file| load(file) unless file =~ /\/(aws_credentials|aws_profile)\.rb\z/ }
+Dir["#{File.dirname(__FILE__)}/core/**/*.rb"].each { |file| load(file) unless file =~ /\/(opt)\.rb\z/ }
 Dir["#{File.dirname(__FILE__)}/routes/**/*.rb"].each { |file| load(file) }
 
 module App
 
+    GEM_NAME = 'awx'
+    SCHEMA_FILE = "#{App::Opt::get_base_path}#{App::Opt::OPT_PATH}/config/schema.yml"
+    TEMPLATE_FILE = "#{App::Opt::get_base_path}#{App::Opt::OPT_PATH}/config/template.yml"
+    CONFIG_FILE = '~/.awx.yml'
+    SECRET = 'gts8cxeCn1EkzxH3ASXwnz7nboOnf6AjnQhqdjQp8kzxH7q7Ne'
+
     def self.execute
 
         begin
 
-            unless !ARGV.any? || ARGV[0] == 'setup' || ARGV[0] == 'x'
-                App::Config.initialize
+            unless ARGV[0] == 'config' || ARGV[0] == 'x'
+                Blufin::Config::init(SCHEMA_FILE, TEMPLATE_FILE, CONFIG_FILE, GEM_NAME)
+                App::AWSProfile::init(Blufin::Config::get)
             end
 
             Convoy::App.create do |awx|
 
                 awx.version AWX_VERSION
-                awx.summary "\x1B[38;5;198mAWX\x1B[0m \x1B[38;5;134m\xe2\x80\x94 Amazon Web-Services X-Tender (Beta)\x1B[0m"
+                awx.summary <<TEMPLATE
+ \x1B[48;5;130m\x1B[38;5;255m AWX \x1B[0m\x1B[0m \x1B[38;5;130m\xe2\x80\x94 Amazon Web-Services X️-Tender\x1B[38;5;248m
+
+       _____  __      ______  ___
+      /  _  \\/  \\    /  \\   \\/  /
+     /  /_\\  \\   \\/\\/   /\\     /
+    /    |    \\        / /     \\
+    \\____|__  /\\__/\\  / /___/\\  \\
+            \\/      \\/        \\_/\x1B[0m
+TEMPLATE
                 awx.description 'An abstraction layer built around the AWS-cli (written by: Albert Rannetsperger)'
 
-                # Checks whether a AWS 'blufin-cli' profile exists within ~/.awx ...
-                unless App::AWSConfig::get_credentials(App::AWSConfig::AWS_PROFILE_ALBERT_CLI).nil?
-                    # cf - AWS CLOUD FORMATION
+                # c - AWS CLOUD FORMATION
+                if ARGV[0] != 'setup' && ARGV[0] != 'x' && App::AWSProfile::get_profile.has_key?('CloudFormation')
                     awx.command :cloudformation, :aliases => [:c] do |awx_cloudformation|
                         awx_cloudformation.summary 'Create, list and delete cloud-formation stacks'
                         # c - AWS CLOUD FORMATION CREATE
                         awx_cloudformation.command :create, :aliases => [:c] do |awx_cloudformation_create|
                             awx_cloudformation_create.summary 'Create stack'
                             awx_cloudformation_create.options do |opts|
-                                opts.opt :test, 'Run through test-template.', :short => '-t', :long => '--test', :type => :boolean
+                                if Blufin::Files::path_exists("#{File.expand_path(App::AWSProfile::get_profile['CloudFormation']['TemplatePath'])}/test")
+                                    opts.opt :test, 'Run through test-template.', :short => '-t', :long => '--test', :type => :boolean
+                                end
+                                opts.opt :test, "Re-run previous with cached values (if exists) \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-R', :long => '--re-run', :type => :boolean
                             end
                             awx_cloudformation_create.action do |opts, args|
                                 AppCommand::AWSCloudFormationCreate.new(opts, args).execute
@@ -45,7 +63,7 @@ module App
                         end
                         # d - AWS CLOUD FORMATION DETECT-DRIFT
                         awx_cloudformation.command :detect_drift, :aliases => [:d] do |awx_cloudformation_detect_drift|
-                            awx_cloudformation_detect_drift.summary 'Detect drift (for stack)'
+                            awx_cloudformation_detect_drift.summary 'Detect drift (currently for all stacks)'
                             awx_cloudformation_detect_drift.action do |opts, args|
                                 AppCommand::AWSCloudFormationDetectDrift.new(opts, args).execute
                             end
@@ -58,52 +76,77 @@ module App
                             end
                         end
                         awx_cloudformation.action do
-                            system("#{ConfigUnique::GEM_NAME} c -h")
+                            system("#{App::GEM_NAME} c -h")
                         end
                     end
-                    # l - AWS LIST
-                    awx.command :list, :aliases => [:l] do |awx_list|
-                        awx_list.summary 'List AWS instances/resources'
-                        awx_list.options do |opts|
-                            opts.opt :json, 'Return data as JSON', :short => '-j', :long => '--json', :type => :boolean
-                            opts.opt :json_prompt, 'Return data as JSON (for Terminal::prompt)', :short => '-J', :long => '--json-prompt', :type => :boolean
-                            opts.opt :yaml, 'Return data as Yaml', :short => '-y', :long => '--yaml', :type => :boolean
-                            opts.opt :resource, "Specify a resource. For all resources type: #{Blufin::Terminal::format_command('all')}", :short => '-r', :long => '--resource', :type => :string
-                            opts.opt :verbose, 'Output the original response from AWS (with all fields).', :short => '-v', :long => '--verbose', :type => :boolean
-                            opts.opt :metadata, 'Output the YML definition file metadata.', :short => '-m', :long => '--metadata', :type => :boolean
-                            # TODO - Implement Region + Project filtering (possibly more).
-                            opts.opt :region, "Specify a region \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-R', :long => '--region', :type => :string
-                            opts.opt :environment, "Specify a environment \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-e', :long => '--environment', :type => :string
-                            opts.opt :project, "Specify a project \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-p', :long => '--project', :type => :string
-                        end
-                        awx_list.action do |opts, args|
-                            AppCommand::AWSList.new(opts, args).execute
+                end
+
+                # d - DYNAMO-DB
+                if ARGV[0] != 'setup' && ARGV[0] != 'x' && Blufin::Config::get.has_key?('DynamoDBPath')
+                    awx.command :dynamodb, :aliases => [:db] do |db|
+                        db.summary 'Run a local instance of DynamoDB'
+                        db.action do |opts, args|
+                            AppCommand::AWSDynamoDB.new(opts, args).execute
                         end
                     end
-                    # L - AWS LAMBDA
-                    awx.command :lambda, :aliases => [:L] do |awx_lambda|
-                        awx_lambda.summary 'Quickly invoke a Lambda function locally (without the need to deploy)'
-                        awx_lambda.options do |opts|
-                            opts.opt :headers_file, 'The path to a JSON containing HTTP Headers you want to send', :short => '-H', :long => '--headers-file', :type => :string
-                            opts.opt :payload_file, 'The path to a JSON payload you want to send', :short => '-p', :long => '--pay-load-file', :type => :string
+                end
+
+                # D - DEPLOY
+                if ARGV[0] != 'setup' && ARGV[0] != 'x' && (App::AWSProfile::get_profile.has_key?('Projects'))
+                    awx.command :deploy, :aliases => [:D] do |deploy|
+                        deploy.summary 'Deploy application(s) to AWS'
+                        deploy.options do |opts|
+                            opts.opt :skip_build, 'Skip build', :short => '-S', :long => '--skip-build', :type => :boolean
+                        end
+                        deploy.action do |opts, args|
+                            AppCommand::AWSDeploy.new(opts, args).execute
                         end
-                        awx_lambda.action do |opts, args|
-                            AppCommand::AWSLambda.new(opts, args).execute
+                    end
+                end
+
+                # l - AWS LIST
+                awx.command :list, :aliases => [:l] do |awx_list|
+                    awx_list.summary 'List AWS instances/resources'
+                    awx_list.options do |opts|
+                        opts.opt :json, 'Return data as JSON', :short => '-j', :long => '--json', :type => :boolean
+                        opts.opt :json_prompt, 'Return data as JSON (for Terminal::prompt)', :short => '-J', :long => '--json-prompt', :type => :boolean
+                        opts.opt :yaml, 'Return data as Yaml', :short => '-y', :long => '--yaml', :type => :boolean
+                        opts.opt :yaml_colored, 'Return data as Yaml (colored)', :short => '-Y', :long => '--yaml-colored', :type => :boolean
+                        opts.opt :resource, "Specify a resource. For all resources type: #{Blufin::Terminal::format_command('all')}", :short => '-r', :long => '--resource', :type => :string
+                        opts.opt :verbose, 'Output the original response from AWS (with all fields).', :short => '-v', :long => '--verbose', :type => :boolean
+                        opts.opt :metadata, 'Output the YML definition file metadata.', :short => '-m', :long => '--metadata', :type => :boolean
+                        # TODO - Implement Region + Project filtering (possibly more).
+                        opts.opt :region, "Specify a region \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-R', :long => '--region', :type => :string
+                        opts.opt :environment, "Specify a environment \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-e', :long => '--environment', :type => :string
+                        opts.opt :project, "Specify a project \xe2\x80\x94 #{Blufin::Terminal::format_invalid('@NotImplemented')}", :short => '-p', :long => '--project', :type => :string
+                    end
+                    awx_list.action do |opts, args|
+                        AppCommand::AWSList.new(opts, args).execute
+                    end
+                end
+
+                # s - SWITCH
+                if ARGV[0] != 'setup' && ARGV[0] != 'x' && App::AWSProfile::get_profile_names.length > 1
+                    # Only show if we have multiple profiles.
+                    awx.command :switch, :aliases => [:s] do |switch|
+                        switch.summary 'Switch Profiles'
+                        switch.action do |opts, args|
+                            AppCommand::AWSSwitch.new(opts, args).execute
                         end
                     end
                 end
 
-                # x - SETUP
-                awx.command :setup, :aliases => [:x] do |setup|
-                    setup.summary 'Setup your configuration file'
-                    setup.action do |opts, args|
-                        AppCommand::Setup.new(opts, args).execute
+                # x - CONFIG
+                awx.command :config, :aliases => [:x] do |config|
+                    config.summary 'Setup your configuration file'
+                    config.action do
+                        Blufin::Config::edit_config(App::CONFIG_FILE)
                     end
                 end
 
-                # AWX (DEFAULT)
+                # awx - DEFAULT
                 awx.action do
-                    system("#{ConfigUnique::GEM_NAME} -h")
+                    system("#{App::GEM_NAME} -h")
                 end
 
             end
@@ -111,8 +154,18 @@ module App
         rescue RuntimeError => e
 
             Blufin::Terminal::print_exception(e);
+
         end
 
     end
 
+    # Very hacky code that looks in the configuration file for a key/pair value and if exists, returns true.
+    # @return bool
+    def self.is_albert_mac
+        if Blufin::Config::get.has_key?('CustomOptions') && Blufin::Config::get['CustomOptions'].has_key?('Secret')
+            return Blufin::Config::get['CustomOptions']['Secret'] == SECRET
+        end
+        false
+    end
+
 end

data/lib/core/opt.rb

@@ -2,7 +2,7 @@ module App
 
     class Opt
 
-        OPT_PATH_YML = '/opt/yml'
+        OPT_PATH = '/opt'
 
         # Get PATH to opt files.
         # @return String

data/lib/routes/aws_cloudformation_create.rb

@@ -1,27 +1,34 @@
 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-->>'
+        DEFAULT                 = 'Default'
+        PARAMETERS              = 'Parameters'
+        SPECIAL_METHODS         = [:before_create, :after_create, :before_teardown, :after_teardown]
+        AWS_TAGS                = %w(Environment Project Region Category Template)
+        RESERVED_WORDS          = %w(stackname description environment project region timeout resource cache_uuid category template terminationprotection projectid)
+        OPTION_PROJECT_ID       = 'ProjectId'
+        OPTION_DEPLOYMENT_STACK = 'DeploymentStack'
+        OPTION_STACK_NAME       = 'StackName'
+        OPTION_TIMEOUT          = 'Timeout'
+        OPTION_DESCRIPTION      = 'Description'
+        OPTION_PROJECT          = 'Project'
+        OPTION_ENVIRONMENT      = 'Environment'
+        OPTION_REGION           = 'Region'
+        OPTION_CATEGORY         = 'Category'
+        OPTION_TEMPLATE         = 'Template'
+        OPTION_TERM_PROTECT     = 'TerminationProtection'
+        MATCHERS                = %w(CATEGORY TEMPLATE PROJECT ENVIRONMENT REGION UUID)
+        OPTIONS                 = 'Options'
+        SPECIAL                 = 'AWS-specific'
+        CACHE_UUID              = 'cache_uuid'
+        TEST                    = 'test'
+        SPACER                  = '<<--Spacer-->>'
+        CAPABILITIES            = 'Capabilities'
+        RETURN_VALUE            = 'PjNkHK33EopWxCpzOQfuku3la'
 
         def execute
 
@@ -41,11 +48,16 @@ module AppCommand
                 @table_widths         = {}
                 @export_map           = {}
                 @columns              = {}
-                @options_default      = {} # The options from the cloudformation.rb file (default for all).
+                @options_default      = {}
                 @cache                = {}
+                @cache_valid          = false
+                @projects             = {}
 
+                @terminal_width                             = Blufin::Terminal::get_terminal_width
                 @columns, @data, @export_map, @table_widths = App::AWSReports::parse_metadata(@regions)
 
+                Blufin::Projects::init(App::AWSProfile::get_profile, App::CONFIG_FILE)
+
                 opts_validate
                 opts_routing
 
@@ -64,26 +76,14 @@ module AppCommand
             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
+            @warnings             = []
+            @auto_fetch_resources = App::AWSReports::get_auto_fetch_resources(@data)
+
+            @options_default[OPTION_ENVIRONMENT] = Blufin::Projects::get_environments
+            @options_default[OPTION_REGION]      = App::AWSProfile::get_profile['CloudFormation']['Defaults']['Regions']
+            @options_default[OPTION_STACK_NAME]  = App::AWSProfile::get_profile['CloudFormation']['Defaults']['StackName']
+            @options_default[OPTION_TIMEOUT]     = App::AWSProfile::get_profile['CloudFormation']['Defaults']['Timeout']
+            @options_default[OPTION_PROJECT]     = Blufin::Projects::get_project_names
 
             # 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|
@@ -101,10 +101,14 @@ module AppCommand
                     method_before_teardown = nil
                     method_after_teardown  = nil
                     intro                  = nil
+                    description            = nil
                     stack_name             = nil
                     projects               = nil
                     environments           = nil
                     regions                = nil
+                    timeout                = nil
+                    single_serve           = false
+                    deployment_stack       = 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
@@ -114,13 +118,13 @@ module AppCommand
                             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}"
+                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 #{e.message.split('template.yml): ')[1].capitalize}"
                                 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
+                                file_cloudformation = file
+                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 AWSTemplateFormatVersion: '2010-09-09' is missing." unless yml_data.has_key?('AWSTemplateFormatVersion')
+                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 This template either has no resources, invalid resources, or something else wrong with the resources." if !yml_data.has_key?('Resources') || yml_data['Resources'].nil? || !yml_data['Resources'].is_a?(Hash) || yml_data['Resources'].length == 0
                                 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.
@@ -128,6 +132,7 @@ module AppCommand
                                             'Type'                  => true,
                                             'Description'           => false,
                                             'Default'               => false,
+                                            'AllowedValues'         => false,
                                             'AllowedPattern'        => false,
                                             'MinLength'             => false,
                                             'MinValue'              => false,
@@ -136,10 +141,10 @@ module AppCommand
                                             '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)
+                                        @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(RESERVED_WORDS).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')
+                                            @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)
@@ -182,32 +187,77 @@ module AppCommand
                                                 @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
+                                        # If Allowed Values is set, certain conditions must apply.
+                                        if data.has_key?('AllowedValues')
+                                            %w(AllowedPattern MinLength MaxLength MinValue MaxValue).each do |invalid_key|
+                                                if data.has_key?(invalid_key)
+                                                    @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 AllowedValues is set so cannot have: #{Blufin::Terminal::format_invalid(data['invalid_key'])}"
+                                                end
+                                            end
+                                            # Must be Array.
+                                            unless data['AllowedValues'].is_a?(Array)
+                                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 AllowedValues must be Array, instead got: #{Blufin::Terminal::format_invalid(data['AllowedValues'].class)}"
+                                            end
+                                        end
+                                    end
+                                end
+                                # Validate description (if exists).
+                                if yml_data.has_key?(OPTION_DESCRIPTION)
+                                    description = yml_data[OPTION_DESCRIPTION]
+                                    # Validate replaceable value(s) exist.
+                                    matches = description.scan(/{{[A-Za-z0-9]+}}/)
+                                    matches.each do |match|
+                                        match = match.gsub(/^{{/, '').gsub(/}}$/, '')
+                                        unless parameters.keys.include?(match)
+                                            @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Invalid description matcher: #{Blufin::Terminal::format_invalid(match)}"
+                                        end
+                                    end
+                                else
+                                    @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 Template is missing description."
+                                end
+                                # Look for (and validate) DeletionPolicy: Retain
+                                if yml_data.has_key?('Resources') && yml_data['Resources'].is_a?(Hash)
+                                    key_has_dp = {}
+                                    yml_data['Resources'].keys { |k| key_has_dp[k] = 0 }
+                                    yml_data['Resources'].each do |key, value|
+                                        key_has_dp[key] = 1 if value.is_a?(Hash) && value.has_key?('DeletionPolicy') && value['DeletionPolicy'].downcase == 'retain'
+                                    end
+                                    key_has_dp_sum = 0
+                                    key_has_dp.each { |k, v| key_has_dp_sum += v }
+                                    if key_has_dp_sum == 0 || key_has_dp_sum == yml_data['Resources'].keys.length
+                                        # If we have at least 1 DeletionPolicy: Retain and no errors, this is a single-serve template.
+                                        single_serve = key_has_dp_sum > 0
+                                    else
+                                        # Add a warning if not all resources have the DeletionPolicy: Retain.
+                                        @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 If DeletionPolicy: Retain is used, it must be set on all resources for template."
                                     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)
+                            expected_constants = %w()
                             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'
+                                intro            = Template::INTRO if constant == 'INTRO'
+                                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'
+                                timeout          = Template::TIMEOUT if constant == 'TIMEOUT'
+                                deployment_stack = Template::DEPLOYMENT_STACK if constant == 'DEPLOYMENT_STACK'
                             end
+                            # Validate stack name.
                             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 = stack_name.scan(/{{[A-Za-z0-9]+}}/)
                                 matches.each do |match|
-                                    match = match.gsub(/^{/, '').gsub(/}$/, '')
+                                    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
@@ -215,12 +265,16 @@ module AppCommand
                                     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]+}/, '')
+                                    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
+                            # Make sure deployment stack is not a reserved word.
+                            if deployment_stack.is_a?(String) && %w(lambda).include?(deployment_stack.downcase)
+                                @warnings << "\x1B[38;5;196m#{template_name}\x1B[38;5;240m \xe2\x80\x94 #{Blufin::Terminal::format_highlight('DEPLOYMENT_STACK')} value is a reserved word: #{Blufin::Terminal::format_invalid(deployment_stack)}"
+                            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|
@@ -259,8 +313,9 @@ module AppCommand
                                     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 == ''
+                            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 == ''
+                            description = nil if !description.nil? && description.gsub("\n", '').gsub("\t", '').strip == ''
                             # Unload the template.rb file/class.
                             Object.send(:remove_const, :Template)
                         end
@@ -274,7 +329,7 @@ module AppCommand
                             :broken => 'Broken'
                         }
                     else
-                        @templates[category][template] = {
+                        @templates[category][template]                    = {
                             :name                   => template,
                             :broken                 => false,
                             :file_cloudformation    => file_cloudformation,
@@ -285,11 +340,15 @@ module AppCommand
                             :method_after_teardown  => method_after_teardown,
                             :parameters             => parameters,
                             :intro                  => intro,
+                            :description            => description,
                             :stack_name             => stack_name,
                             :projects               => projects,
                             :environments           => environments,
                             :regions                => regions,
+                            :timeout                => timeout,
+                            :single_serve           => single_serve
                         }
+                        @templates[category][template][:deployment_stack] = deployment_stack unless deployment_stack.nil?
                     end
                 end
             end
@@ -306,15 +365,50 @@ module AppCommand
 
         def opts_routing
 
+            used_cache   = true
+            showing_tags = false
+
             # Show prompt to select template.
             category, template, @template = select_template_prompt
-            unless @params.any?
+
+            if @params.any?
+                # Here we replace the UUID for the stack-name at the last-second to enable parallel, identical runs (if exists).
+                @params[OPTION_STACK_NAME] = replace_stack_suffix(@params[OPTION_STACK_NAME]) if @params.has_key?(OPTION_STACK_NAME)
+            else
+                used_cache = false
                 if !@template[:parameters].nil? && @template[:parameters].any?
-                    @template[:parameters].each do |(param_name, param_data)|
+                    @template[:parameters].each_with_index do |(param_name, param_data), idx|
+                        if AWS_TAGS.include?(param_name) && !showing_tags
+                            showing_tags = true
+                            puts "\x1B[38;5;#{App::AWSOutputter::DIVIDER_COLOR}m--- \x1B[38;5;136m[Tags]\x1B[0m\x1B[38;5;#{App::AWSOutputter::DIVIDER_COLOR}m #{'-' * (@terminal_width - 17)}\x1B[0m"
+                            puts
+                        end
+                        # Deployment ID needs to be handled here because we need to know what the project/region/environment is before we can display the options.
+                        if param_name == OPTION_PROJECT_ID
+                            # Figure out which deployments are eligible for this stack.
+                            if @template.has_key?(:deployment_stack)
+                                @projects = Blufin::Projects::get_deployments(
+                                    @params[OPTION_PROJECT],
+                                    @template[:deployment_stack],
+                                    @params[OPTION_REGION],
+                                    @params[OPTION_ENVIRONMENT]
+                                )
+                                if @projects.any?
+                                    project_options = []
+                                    @projects.each { |project| project_options << project[1][Blufin::Projects::DEPLOYMENT_ID] }
+                                    @params[param_name] = Blufin::Terminal::prompt_select('Select Project ID:', project_options, help: param_data[OPTION_DESCRIPTION])
+                                    puts
+                                end
+                            end
+                            next
+                        end
                         @params[param_name] = get_parameter_value(param_data, param_name, category, template)
-                        puts
+                        # Puts space unless it's a hidden parameter. Keeps spacing consistent.
+                        puts unless [OPTION_TIMEOUT].include?(param_name)
                     end
                 end
+                @params[OPTION_CATEGORY] = category
+                @params[OPTION_TEMPLATE] = template
                 # Cache the inputted value(s).
                 cache_params             = @params
                 cache_params[CACHE_UUID] = get_cache_hexdigest(@template[:parameters])
@@ -323,88 +417,115 @@ module AppCommand
 
             # If this is a test-run, abandon ship here.
             if @opts[:test]
-                puts
+                puts if used_cache
                 puts "\x1B[38;5;196m  Exiting because this is only a test-run.\x1B[0m"
                 puts
+                puts "\x1B[38;5;246m#{@params.to_yaml}\x1B[0m"
                 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])
+            s3_url = 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)
-
+                Blufin::Terminal::success("AWS says your template is: \x1B[38;5;40mVALID")
+                # Output the AWS response in YML format.
+                Blufin::Terminal::code_highlight(hash.to_yaml, 'yml', 4)
                 # Extract required capabilities (if any).
-                if hash.has_key?('Capabilities')
-                    capabilities_arr = hash['Capabilities']
+                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
+            output                     = {}
+            output[OPTION_STACK_NAME]  = @params[OPTION_STACK_NAME]
+            output[OPTION_DESCRIPTION] = @params[OPTION_DESCRIPTION]
+            output[SPACER]             = true
+            if @template.has_key?(:deployment_stack) && !@params[OPTION_PROJECT_ID].nil? && @params[OPTION_PROJECT_ID].length > 0
+                output[OPTION_DEPLOYMENT_STACK] = @template[:deployment_stack]
+                output[OPTION_PROJECT_ID]       = @params[OPTION_PROJECT_ID]
+            end
+            output[OPTION_TIMEOUT]      = @params[OPTION_TIMEOUT]
+            output[OPTION_TERM_PROTECT] = @params[OPTION_TERM_PROTECT] unless @template[:single_serve]
+            output[CAPABILITIES]        = 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
-                next if OPTION_DESCRIPTION.downcase == key.downcase
+                next if RESERVED_WORDS.include?(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?
+            padding       = output.keys.max_by(&:length).length
+            spacer_passed = false
+            output.each do |key, value|
+                next if [OPTION_DEPLOYMENT_STACK, OPTION_PROJECT_ID, OPTION_TIMEOUT, OPTION_TERM_PROTECT, CAPABILITIES].include?(key)
+                if key == SPACER
+                    spacer_passed = true
+                    next
+                end
+                if spacer_passed
+                    params_output << "\x1B[38;5;240m#{key.rjust(padding, ' ')} : \x1B[38;5;28m#{value}"
+                else
+                    params_output << "\x1B[38;5;240m#{key.rjust(padding, ' ')} : \x1B[38;5;28m#{value}"
+                end
+            end
 
-            @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}"
+            if @template.has_key?(:deployment_stack)
+                params_output << "\x1B[38;5;240m#{OPTION_PROJECT_ID.rjust(padding, ' ')} : \x1B[38;5;246m#{output[OPTION_PROJECT_ID]}" if output.has_key?(OPTION_PROJECT_ID)
+                params_output << "\x1B[38;5;240m#{OPTION_DEPLOYMENT_STACK.rjust(padding, ' ')} : \x1B[38;5;246m#{output[OPTION_DEPLOYMENT_STACK]}" if output.has_key?(OPTION_DEPLOYMENT_STACK)
             end
+            params_output << "\x1B[38;5;240m#{OPTION_TIMEOUT.rjust(padding, ' ')} : \x1B[38;5;246m#{output[OPTION_TIMEOUT]} Minute(s)\x1B[0m"
+            params_output << "\x1B[38;5;240m#{OPTION_TERM_PROTECT.rjust(padding, ' ')} : #{output[OPTION_TERM_PROTECT] ? "\x1B[38;5;246mYES\x1B[0m" : "\x1B[38;5;246mNO\x1B[0m"}" unless @template[:single_serve]
+            params_output << "\x1B[38;5;240m#{CAPABILITIES.rjust(padding, ' ')} : \x1B[38;5;196m#{output[CAPABILITIES]}" if output.has_key?(CAPABILITIES)
+
+            if Blufin::Terminal::prompt_yes_no("Review: #{App::AWSOutputter::render_selection(category, template)}", params_output, 'Create Stack?', false)
 
-            if Blufin::Terminal::prompt_yes_no("Deploy: #{render_category_template(category, template)} ?", params_output, 'Create CloudFormation Stack in AWS', false)
+                # If no 'after' actions necessary, give option to terminate script.
+                term_script = false
+                if @template[:method_after_create].nil? && !@template[:single_serve]
+                    term_script = Blufin::Terminal::prompt_yes?('     End script after CloudFormation starts running?')
+                    puts
+                end
 
                 # 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)
+                # Create the Stack (if term_scrip == TRUE, script terminates inside).
+                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,
+                                                         term_protect: @template[:single_serve] ? false : @params[OPTION_TERM_PROTECT],
+                                                         term_script:  term_script,
+                                                         timeout:      @params[OPTION_TIMEOUT])
 
-                # Call :before_create() -- if exists.
+                # Call :after_create() -- if exists.
                 @template[:method_after_create].call(@params) unless @template[:method_after_create].nil?
 
-                # Success message.
-                Blufin::Terminal::success('Stack creation was successful.')
+                # Success/Failure messages.
+                if @template[:single_serve]
+                    if App::AWSCli::execute_as_proc("Deleting Stack: #{Blufin::Terminal::format_highlight(@params[OPTION_STACK_NAME])}", "cloudformation delete-stack --stack-name #{@params[OPTION_STACK_NAME]}", @params[OPTION_REGION])
+                        Blufin::Terminal::success("#{App::AWSOutputter::render_selection(category, template)} was successfully created (and stack removed).") unless term_script
+                    else
+                        Blufin::Terminal::error('Something went wrong.')
+                    end
+                else
+                    Blufin::Terminal::success('Stack creation was successful.') unless term_script
+                end
             end
         end
 
@@ -412,39 +533,47 @@ module AppCommand
 
         # Show prompt(s) to select template.
         # @return void
-        def select_template_prompt
+        def select_template_prompt(first_time = true)
             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]
+                template = nil
+                while template == RETURN_VALUE || template.nil? do
+                    system('clear') if !first_time || template == RETURN_VALUE
+                    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, nil, nil, !(@warnings.any? && first_time))
+                    # 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
+                    options << {
+                        :text  => "\x1B[38;5;240m#{Blufin::Strings::RETURN_CHARACTER}\x1B[0m",
+                        :value => RETURN_VALUE
                     }
-                    option[:disabled] = data[:broken] if data[:broken]
-                    options << option
+                    system('clear')
+                    # Show a prompt identical to the 2nd one, now with category selected.
+                    Blufin::Terminal::custom('CLOUDFORMATION', 55, "Selected template: #{App::AWSOutputter::render_selection(category)}")
+                    # Select template prompt.
+                    template = Blufin::Terminal::prompt_select('Select Template:', options)
                 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]
@@ -460,44 +589,69 @@ module AppCommand
                 template_intro = @template[:intro].split("\n")
                 template_intro << ''
             end
+            unless template_intro.any?
+                if @template.has_key?(:description) && !@template[:description].nil? && @template[:description].to_s.strip != ''
+                    template_intro << @template[:description]
+                    template_intro << ''
+                end
+            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" }
+            Blufin::Terminal::custom('CLOUDFORMATION', 55, "Selected template: #{App::AWSOutputter::render_selection(category, @template[:single_serve] ? "#{template} 💥 " : template)}")
+            template_intro.each { |line| puts "\x1B[38;5;246m   #{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
+                options_current[OPTION_TIMEOUT]     = (@template[:timeout].nil? ? default_options : @template[:timeout]) if key == OPTION_TIMEOUT
             end
             @options_default.keys.each do |key|
-                next if key == OPTION_STACK_NAME
+                next if [OPTION_STACK_NAME, OPTION_TIMEOUT].include?(key)
                 @template[:parameters][key] = {
-                    'Type'        => 'String',
-                    'Description' => "%w(#{options_current[key].join(' ')})",
-                    OPTIONS       => options_current[key],
+                    'Type'             => 'String',
+                    OPTION_DESCRIPTION => "[#{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
+            unless @template[:deployment_stack].nil?
+                @template[:parameters][OPTION_PROJECT_ID] = {
+                    'Type'             => 'String',
+                    OPTION_DESCRIPTION => 'Project ID (used for associating this Stack with an existing Project).'
+                }
+            end
+            @template[:parameters][OPTION_STACK_NAME]           = {
+                'Type'             => 'String',
+                OPTION_DESCRIPTION => @template[:stack_name].nil? ? default_options : @template[:stack_name],
+                'MinLength'        => 1
+            }
+            @template[:parameters][OPTION_DESCRIPTION]          = {
+                'Type'             => 'String',
+                OPTION_DESCRIPTION => @template[:description],
+                'MinLength'        => 1
             }
-            @template[:parameters][OPTION_DESCRIPTION] = {
-                'Type'        => 'String',
-                'Description' => 'A quick note to describe this stack (displayed in CloudFormation console).',
-                'MinLength'   => 1
+            # Add default if Description exists in template.yml (must come after above line).
+            @template[:parameters][OPTION_DESCRIPTION][DEFAULT] = @template[:description] if @template.has_key?(:description) && !@template[:description].nil? && @template[:description].to_s.strip != ''
+            @template[:parameters][OPTION_TIMEOUT]              = {
+                'Type'             => 'Number',
+                OPTION_DESCRIPTION => 'The amount of minutes that can pass before the stack aborts the mission.',
+                DEFAULT            => options_current[OPTION_TIMEOUT]
             }
+            unless @template[:single_serve]
+                @template[:parameters][OPTION_TERM_PROTECT] = {
+                    'Type'             => 'Boolean',
+                    OPTION_DESCRIPTION => 'Should this stack be protected against accidental Termination?'
+                }
+            end
             # 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                                     = {}
+            cache_file = get_cache_file(category, template)
+            @cache     = {}
             if Blufin::Files::file_exists(cache_file)
+                @cache       = nil
+                @cache_valid = false
                 begin
                     @cache = JSON.parse(`cat #{cache_file}`)
                 rescue
@@ -505,9 +659,7 @@ module AppCommand
                 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 = {}
+                    @cache_valid = true if @cache[CACHE_UUID] == get_cache_hexdigest(@template[:parameters])
                 end
             end
             # Output the parameters (in table).
@@ -523,7 +675,7 @@ module AppCommand
                     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,
+                        :type            => %w(string number boolean).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,
@@ -553,7 +705,7 @@ module AppCommand
                     }
                 end
                 sleep(0.1)
-                Blufin::Terminal::execute_proc("AWS - Getting parameter data: [ #{params_to_fetch_colored.join(' | ')}\x1B[38;5;208m ]", Proc.new {
+                Blufin::Terminal::execute_proc("AWS \xe2\x80\x94 Getting parameter data: [ #{params_to_fetch_colored.join(' | ')}\x1B[38;5;208m ]", Proc.new {
                     threads.each { |thread| thread.join }
                 })
                 puts
@@ -564,12 +716,11 @@ module AppCommand
                 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'}
+                choices = [{ value: 'y', text: 'Select this template' }]
+                choices << { value: 'Y', text: "Select this template \x1B[38;5;198m(and apply cached values)\x1B[0m" } if @cache_valid
             end
             # The prompt at the end of the intro.
-            choices << {value: 'n', text: 'Select another template'}
-            choices << {value: 'q', text: 'Quit'}
+            choices << { value: 'n', text: "\x1B[38;5;240m#{Blufin::Strings::RETURN_CHARACTER}\x1B[0m" }
             choice = Blufin::Terminal::prompt_select('What would you like to do?', choices)
             case choice
                 when 'y'
@@ -580,10 +731,7 @@ module AppCommand
                     return [category, template, @template]
                 when 'n'
                     system('clear')
-                    select_template_prompt
-                when 'q'
-                    puts
-                    exit
+                    select_template_prompt(false)
                 else
                     raise RuntimeError, "Unhandled choice: #{choice}"
             end
@@ -592,31 +740,60 @@ module AppCommand
         # 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
+            description  = param_data.has_key?(OPTION_DESCRIPTION) ? param_data[OPTION_DESCRIPTION] : nil
             options_text = "Select #{param_name}:"
-            if param_name == OPTION_STACK_NAME
+            if [OPTION_STACK_NAME].include?(param_name)
+                constraints = []
+                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;240mMaxLength: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['MaxLength']}" if param_data.has_key?('MaxLength')
+                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, random_stack_suffix) if default =~ /{{UUID}}/i
+                default   = default.downcase
+                help_text = 'Stack Name (will be displayed in CloudFormation console).'
+                return Blufin::Terminal::prompt_ask("Enter #{param_name}#{render_constraints(constraints)}", default: default, help: help_text)
+            elsif param_name == OPTION_DESCRIPTION
                 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).')
+                constraints << "\x1B[38;5;240mMaxLength: \x1B[38;5;#{App::AWSOutputter::CONSTRAINT_COLOR}m#{param_data['MaxLength']}" if param_data.has_key?('MaxLength')
+                default = param_data.has_key?(DEFAULT) ? param_data[DEFAULT] : nil
+                unless default.nil?
+                    # Check if description has any replaceable values.
+                    default = replace_matchers_with_params(default, @params)
+                end
+                help_text = 'Description (will be displayed in CloudFormation console).'
+                return Blufin::Terminal::prompt_ask("Enter #{param_name}#{render_constraints(constraints)}", default: default, help: help_text)
+            elsif param_name == OPTION_TIMEOUT
+                return param_data[DEFAULT]
+            elsif param_name == OPTION_TERM_PROTECT
+                return Blufin::Terminal::prompt_yes?('Protect against accidental Termination?')
             elsif @auto_fetch_resources.has_key?(param_name)
+                # Sort alphabetically.
                 options = fetch_autocomplete_options(param_name, silent: true)
+                options.sort_by! { |hsh| hsh[:sort] }
+                # If we have a cached value, make that the first in the options list.
+                options = move_default_option_to_top(options, param_name) if @cache.has_key?(param_name)
                 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"
+            elsif param_data.has_key?(OPTIONS) || param_data.has_key?('AllowedValues')
+                options = param_data[OPTIONS]
+                options = param_data['AllowedValues'] if param_data.has_key?('AllowedValues')
+                raise RuntimeError, "Expected Array, instead got: #{options.class} (#{options.inspect})" unless options.is_a?(Array)
+                if options.length == 1
+                    default_option = options[0]
+                    puts Blufin::Terminal::display_prompt_text(options_text, default_option)
                     return default_option
                 else
-                    return Blufin::Terminal::prompt_select(options_text, param_data[OPTIONS])
+                    # Sort alphabetically.
+                    options.uniq!
+                    options.sort!
+                    # If we have a cached value, make that the first in the options list.
+                    options = move_default_option_to_top(options, param_name) if @cache.has_key?(param_name)
+                    puts Blufin::Terminal::display_prompt_help(param_data[OPTION_DESCRIPTION]) if param_data.has_key?(OPTION_DESCRIPTION)
+                    return Blufin::Terminal::prompt_select(options_text, options)
                 end
             else
                 constraints = []
@@ -625,19 +802,28 @@ module AppCommand
                 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
+                default = param_data.has_key?(DEFAULT) ? param_data[DEFAULT] : nil
+                if default.nil?
+                    default = @cache[param_name] if @cache.has_key?(param_name)
+                else
+                    if default =~ /{{(System):([A-Za-z0-9]+)}}/
+                        matches = default.scan(/{{(System):([A-Za-z0-9]+)}}/)
+                        default = replace_with_dynamic_data(default, matches) if matches.any?
+                    end
+                end
                 loop do
                     value         = Blufin::Terminal::prompt_ask("Enter #{param_name}#{render_constraints(constraints)}", default: default, help: description)
+                    value         = value.nil? ? '' : value
                     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']
+                    value_invalid = true if param_data.has_key?('MinLength') && value.to_s.length < param_data['MinLength'].to_i
+                    value_invalid = true if param_data.has_key?('MaxLength') && value.to_s.length > param_data['MaxLength'].to_i
+                    value_invalid = true if param_data.has_key?('MinValue') && value.to_i < param_data['MinValue'].to_i
+                    value_invalid = true if param_data.has_key?('MaxValue') && value.to_i > param_data['MaxValue'].to_i
                     if value_invalid
                         description = nil
-                        puts "\x1B[38;5;196mValue does not meet allowed constraint(s).\x1B[0m"
+                        puts "\x1B[38;5;196mValue does not meet allowed constraint(s): #{value.inspect}\x1B[0m"
                     else
                         return value
                     end
@@ -646,6 +832,53 @@ module AppCommand
             puts
         end
 
+        # TODO - Think about possible combining both of the below methods?
+
+        # Takes something like "{{System:RandomString}}" and returns "aif8d5njk".
+        # @return string
+        def replace_with_dynamic_data(original_string, matcher_pairs)
+            raise RuntimeError, "Expected Array, instead got: #{matcher_pairs.class}" unless matcher_pairs.is_a?(Array)
+            matcher_pairs.each do |pair|
+                matcher = "#{pair[0]}:#{pair[1]}"
+                case matcher
+                    when 'System:RandomString'
+                        original_string = original_string.gsub('{{System:RandomString}}', Blufin::Strings::random_string)
+                    else
+                        raise RuntimeError, "Unrecognized matcher: #{Blufin::Terminal::format_invalid(matcher)}"
+                end
+            end
+            original_string
+        end
+
+        # Takes a string like: '{{Subdomain}}.{{Route53DomainName}}' and converts it to -> nuxt-v1.blufin.org
+        # @return void
+        def replace_matchers_with_params(default, params)
+            unless default.nil? || !default.is_a?(String)
+                matches = default.scan(/{{[A-Za-z0-9]+}}/)
+                matches.each do |match|
+                    match   = match.gsub(/^{{/, '').gsub(/}}$/, '')
+                    default = default.gsub(/{{#{match}}}/, params[match]) if params.has_key?(match)
+                end
+            end
+            default
+        end
+
+        # Moves the default option to the top of the list.
+        # @return Array
+        def move_default_option_to_top(options, param_name)
+            options_rearranged = []
+            options.each do |option|
+                if option.is_a?(Hash)
+                    options_rearranged.unshift(option) if option[:value] == @cache[param_name]
+                    options_rearranged << option unless option[:value] == @cache[param_name]
+                else
+                    options_rearranged.unshift(option) if option == @cache[param_name]
+                    options_rearranged << option unless option == @cache[param_name]
+                end
+            end
+            options_rearranged
+        end
+
         # Goes off to AWS and gets values for autocomplete supported fields.
         # @return string
         def fetch_autocomplete_options(resource_name, silent: true)
@@ -654,7 +887,7 @@ module AppCommand
             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)
+            options                          = App::AWSReports::parse_results_for_prompt(resource, resource_name, results)
             @auto_fetch_cache[resource_name] = options
             options
         end
@@ -664,12 +897,22 @@ module AppCommand
         def assemble_tags(params)
             output = []
             params.each do |key, value|
-                next unless OPTION_TAGS.include?(key.downcase)
+                next unless AWS_TAGS.include?(key)
                 output << {
                     'Key'   => key,
                     'Value' => value
                 }
             end
+            if @template.has_key?(:deployment_stack) && params.has_key?(OPTION_PROJECT_ID)
+                output << {
+                    'Key'   => OPTION_DEPLOYMENT_STACK,
+                    'Value' => @template[:deployment_stack].to_s
+                }
+                output << {
+                    'Key'   => OPTION_PROJECT_ID,
+                    'Value' => params[OPTION_PROJECT_ID]
+                }
+            end
             output.to_json
         end
 
@@ -678,8 +921,7 @@ module AppCommand
         def assemble_params(params)
             output = []
             params.each do |key, value|
-                next if OPTION_STACK_NAME.downcase == key.downcase
-                unless OPTION_TAGS.include?(key.downcase)
+                unless RESERVED_WORDS.include?(key.downcase)
                     output << {
                         'ParameterKey'   => key,
                         'ParameterValue' => value
@@ -711,13 +953,14 @@ module AppCommand
         # @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]"
+            parameter_hash_standardized = {}
+            parameter_hash.each do |k, v|
+                parameter_hash_standardized[k] = v
+                if v.has_key?(OPTIONS)
+                    parameter_hash_standardized[k][OPTIONS].sort!.uniq!
+                end
+            end
+            Digest::SHA2.hexdigest(parameter_hash_standardized.to_s)
         end
 
         # Standardized way of rendering constraints output.
@@ -727,6 +970,18 @@ module AppCommand
             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
 
+        # Generates a random stack suffix that always has the same patters: a[a-z0-9]w[a-z0-9]x
+        # @return string
+        def random_stack_suffix
+            "a#{Blufin::Strings::random_string}10w17#{Blufin::Strings::random_string}x"
+        end
+
+        # Replaces current random stack suffix with another one.
+        # @return string
+        def replace_stack_suffix(current)
+            current.gsub(/a[0-9a-z]{8}10w17[0-9a-z]{8}x/, random_stack_suffix)
+        end
+
     end
 
 end