lono 4.2.7 → 5.0.1

data/lib/lono/blueprint/info.rb

@@ -0,0 +1,10 @@
+# Small wrapper class to keep blueprint name and path.
+# Found this to be a little cleaner than using a hash.
+class Lono::Blueprint
+  class Info
+    attr_reader :name, :path
+    def initialize(name, path)
+      @name, @path = name, path
+    end
+  end
+end

data/lib/lono/blueprint/list.rb

@@ -0,0 +1,14 @@
+class Lono::Blueprint
+  class List
+    class << self
+      def available
+        puts "Current available blueprints:"
+        Find.all_blueprints.each do |b|
+          full_path = Find.find(b)
+          path = full_path.sub("#{Lono.root}/", "")
+          puts "  #{b}: #{path}"
+        end
+      end
+    end
+  end
+end

data/lib/lono/blueprint/root.rb

@@ -0,0 +1,43 @@
+require "bundler"
+
+class Lono::Blueprint
+  module Root
+    # Switch the lono root
+    # TODO: account multimode or only have multimode?
+    # TODO: switch to gem path
+    def set_blueprint_root(blueprint)
+      # puts "blueprint #{blueprint}"
+      # puts caller[0..2]
+
+      blueprint_root = find_blueprint_root(blueprint)
+      if blueprint_root
+        Lono.blueprint_root = blueprint_root
+      else
+        puts "ERROR: Unable to find the blueprint #{blueprint}.  " \
+            "Are you sure it's in your Gemfile or in the blueprints folder "\
+            "with the correct blueprint_name in .lono/config.yml?".color(:red)
+        List.available
+        exit 1
+      end
+    end
+
+    def find_blueprint_root(blueprint)
+      require_bundle_gems # ensures that gem will be found so we can switch to it
+
+      Find.find(blueprint) # blueprint_root
+    end
+
+    def bundler_groups
+      [:default, Lono.env.to_sym]
+    end
+
+    def require_bundle_gems
+      # NOTE: Dont think ENV['BUNDLE_GEMFILE'] is quite working right.  We still need
+      # to be in the project directory.  Leaving logic in here for when it gets fix.
+      if ENV['BUNDLE_GEMFILE'] || File.exist?("Gemfile")
+        require "bundler/setup"
+        Bundler.require(*bundler_groups)
+      end
+    end
+  end
+end

data/lib/lono/cfn.rb

@@ -1,24 +1,13 @@
 require "thor"
+require "cfn/status"
 
 class Lono::Cfn < Lono::Command
-  autoload :AwsService, 'lono/cfn/aws_service'
-  autoload :Base, 'lono/cfn/base'
-  autoload :CLI, 'lono/cfn/cli'
-  autoload :Create, 'lono/cfn/create'
-  autoload :Current, 'lono/cfn/current'
-  autoload :Delete, 'lono/cfn/delete'
-  autoload :Diff, 'lono/cfn/diff'
-  autoload :Download, 'lono/cfn/download'
-  autoload :Preview, 'lono/cfn/preview'
-  autoload :Status, 'lono/cfn/status'
-  autoload :Update, 'lono/cfn/update'
-  autoload :Util, 'lono/cfn/util'
-
   class_option :verbose, type: :boolean
   class_option :noop, type: :boolean
 
   base_options = Proc.new do
     # common to create and update
+    option :blueprint, desc: "override convention and specify the template file to use"
     option :template, desc: "override convention and specify the template file to use"
     option :param, desc: "override convention and specify the param file to use"
     option :lono, type: :boolean, desc: "invoke lono to generate CloudFormation templates", default: true
@@ -30,9 +19,19 @@ class Lono::Cfn < Lono::Command
   wait_option = Proc.new do
     option :wait, type: :boolean, desc: "Wait for stack operation to complete.", default: true
   end
+  suffix_option = Proc.new do
+    option :suffix, desc: "Suffix for stack name."
+  end
+  update_options = Proc.new do
+    option :change_set, type: :boolean, default: true, desc: "Uses generated change set to update the stack.  If false, will perform normal update-stack."
+    option :diff, type: :boolean, default: true, desc: "Show diff of the source code template changes before continuing."
+    option :preview, type: :boolean, default: true, desc: "Show preview of the stack changes before continuing."
+    option :sure, type: :boolean, desc: "Skips are you sure prompt"
+  end
 
   desc "create STACK", "Create a CloudFormation stack using the generated template."
   base_options.call
+  suffix_option.call
   wait_option.call
   long_desc Lono::Help.text("cfn/create")
   def create(stack_name)
@@ -41,16 +40,23 @@ class Lono::Cfn < Lono::Command
 
   desc "update STACK", "Update a CloudFormation stack using the generated template."
   long_desc Lono::Help.text("cfn/update")
-  option :change_set, type: :boolean, default: true, desc: "Uses generated change set to update the stack.  If false, will perform normal update-stack."
-  option :diff, type: :boolean, default: true, desc: "Show diff of the source code template changes before continuing."
-  option :preview, type: :boolean, default: true, desc: "Show preview of the stack changes before continuing."
-  option :sure, type: :boolean, desc: "Skips are you sure prompt"
   base_options.call
+  update_options.call
   wait_option.call
   def update(stack_name=:current)
     Update.new(stack_name, options).run
   end
 
+  desc "deploy STACK", "Create or update a CloudFormation stack using the generated template."
+  long_desc Lono::Help.text("cfn/deploy")
+  base_options.call
+  suffix_option.call
+  update_options.call
+  wait_option.call
+  def deploy(stack_name=:current)
+    Deploy.new(stack_name, options).run
+  end
+
   desc "delete STACK", "Delete a CloudFormation stack."
   long_desc Lono::Help.text("cfn/delete")
   option :sure, type: :boolean, desc: "Skips are you sure prompt"
@@ -65,6 +71,7 @@ class Lono::Cfn < Lono::Command
   option :keep, type: :boolean, desc: "keep the changeset instead of deleting it afterwards"
   option :diff, type: :boolean, default: true, desc: "Show diff of the source code template changes also."
   base_options.call
+  suffix_option.call
   def preview(stack_name=:current)
     Diff.new(stack_name, options).run if options[:diff]
     Preview.new(stack_name, options).run
@@ -73,6 +80,7 @@ class Lono::Cfn < Lono::Command
   desc "diff STACK", "Diff newly generated template vs existing template."
   long_desc Lono::Help.text("cfn/diff")
   base_options.call
+  suffix_option.call
   def diff(stack_name=:current)
     Diff.new(stack_name, options).run
   end
@@ -81,6 +89,7 @@ class Lono::Cfn < Lono::Command
   long_desc Lono::Help.text("cfn/download")
   option :name, desc: "Name you want to save the template as. Default: existing stack name."
   base_options.call
+  suffix_option.call
   def download(stack_name=:current)
     Download.new(stack_name, options).run
   end
@@ -89,14 +98,17 @@ class Lono::Cfn < Lono::Command
   long_desc Lono::Help.text("cfn/current")
   option :rm, type: :boolean, desc: "Remove all current settings. Removes `.lono/current`"
   option :name, desc: "Current stack name."
-  option :suffix, desc: "Current suffix for stack name."
+  suffix_option.call
   def current
     Current.new(options).run
   end
 
   desc "status", "Shows the current status for the stack."
   long_desc Lono::Help.text("cfn/status")
+  suffix_option.call
   def status(stack_name=:current)
-    Status.new(stack_name, options).run
+    status = Lono::Cfn::Status.new(stack_name, options)
+    success = status.run
+    exit 3 unless success
   end
 end

data/lib/lono/cfn/aws_service.rb

@@ -31,6 +31,22 @@ module Lono::Cfn::AwsService
     exist
   end
 
+  def find_stack(stack_name)
+    resp = cfn.describe_stacks(stack_name: stack_name)
+    resp.stacks.first
+  rescue Aws::CloudFormation::Errors::ValidationError => e
+    # example: Stack with id demo-web does not exist
+    if e.message =~ /Stack with/ && e.message =~ /does not exist/
+      nil
+    else
+      raise
+    end
+  end
+
+  def rollback_complete?(stack)
+    stack.stack_status == 'ROLLBACK_COMPLETE'
+  end
+
   def testing_update?
     ENV['TEST'] && self.class.name == "LonoCfn::Update"
   end

data/lib/lono/cfn/base.rb

@@ -1,318 +1,301 @@
 require "lono"
 
-class Lono::Cfn::Base
-  include Lono::Cfn::AwsService
-  include Lono::Cfn::Util
-
-  def initialize(stack_name, options={})
-    @options = options # options must be set first because @option used in append_suffix
-    stack_name = switch_current(stack_name)
-    @stack_name = append_suffix(stack_name)
-    Lono::ProjectChecker.check unless options[:lono] # already ran checker in lono generate
-
-    @template_name = options[:template] || remove_suffix(@stack_name)
-    @param_name = options[:param] || @template_name
-    @template_path = get_source_path(@template_name, :template)
-    @param_path = get_source_path(@param_name, :param)
-    puts "Using template: #{@template_path}" unless @options[:mute_using]
-    puts "Using parameters: #{@param_path}" unless @options[:mute_using]
-  end
+class Lono::Cfn
+  class Base
+    extend Memoist
+    include Lono::AwsServices
+    include Lono::Blueprint::Root
+    include Lono::Conventions
+    include Suffix
+    include Util
 
-  def switch_current(stack_name)
-    Lono::Cfn::Current.name!(stack_name)
-  end
+    def initialize(stack_name, options={})
+      @options = options # options must be set first because @option used in append_suffix
 
-  def starting_message
-    action = self.class.to_s.split('::').last
-    action = action[0..-2] + 'ing' # create => creating
-    puts "#{action} #{@stack_name.color(:green)} stack..."
-  end
+      stack_name = switch_current(stack_name)
+      @stack_name = append_suffix(stack_name)
+      Lono::ProjectChecker.check
 
-  def run
-    starting_message
-    params = generate_all
-    begin
-      save_stack(params) # defined in the sub class
-    rescue Aws::CloudFormation::Errors::InsufficientCapabilitiesException => e
-      capabilities = e.message.match(/\[(.*)\]/)[1]
-      confirm = prompt_for_iam(capabilities)
-      if confirm =~ /^y/
-        @options.merge!(capabilities: [capabilities])
-        puts "Re-running: #{command_with_iam(capabilities).color(:green)}"
-        retry
-      else
-        puts "Exited"
-        exit 1
-      end
-    end
+      @blueprint = options[:blueprint] || remove_suffix(@stack_name)
+      @template, @param = template_param_convention(options)
 
-    return unless @options[:wait]
-    status.wait unless @options[:noop]
-  end
+      # Add template and param to options because used later for Lono::Param::Generator
+      @options[:blueprint], @options[:template], @options[:param] = @blueprint, @template, @param
 
-  def status
-    @status ||= Lono::Cfn::Status.new(@stack_name)
-  end
+      set_blueprint_root(@blueprint)
 
-  def prompt_for_iam(capabilities)
-    puts "This stack will create IAM resources.  Please approve to run the command again with #{capabilities} capabilities."
-    puts "  #{command_with_iam(capabilities)}"
+      @template_path = "#{Lono.config.output_path}/#{@blueprint}/templates/#{@template}.yml"
+    end
 
-    puts "Please confirm (y/n)"
-    $stdin.gets
-  end
+    def switch_current(stack_name)
+      Current.name!(stack_name)
+    end
 
-  def command_with_iam(capabilities)
-    "#{File.basename($0)} #{ARGV.join(' ')} --capabilities #{capabilities}"
-  end
+    def starting_message
+      action = self.class.to_s.split('::').last
+      puts "#{action} #{@stack_name.color(:green)} stack..."
+    end
 
-  def generate_all
-    if @options[:lono]
-      build_scripts
-      generate_templates
-      unless @options[:noop]
-        upload_scripts
-        upload_files
-        upload_templates
+    def run
+      starting_message
+      params = generate_all
+      begin
+        save_stack(params) # defined in the sub class
+      rescue Aws::CloudFormation::Errors::InsufficientCapabilitiesException => e
+        capabilities = e.message.match(/\[(.*)\]/)[1]
+        confirm = prompt_for_iam(capabilities)
+        if confirm =~ /^y/
+          @options.merge!(capabilities: [capabilities])
+          puts "Re-running: #{command_with_iam(capabilities).color(:green)}"
+          retry
+        else
+          puts "Exited"
+          exit
+        end
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        if e.message.include?("No updates") # No updates are to be performed.
+          puts "WARN: #{e.message}".color(:yellow)
+        elsif e.message.include?("UPDATE_ROLLBACK_FAILED") # https://amzn.to/2IiEjc5
+          continue_update_rollback
+        else
+          puts "ERROR: #{e.message}".color(:red)
+          exit 1
+        end
       end
+
+      return unless @options[:wait]
+
+      success = false
+      if !@options[:noop]
+        success = status.wait
+      end
+
+      # exit code for cfn.rb cli, so there's less duplication
+      exit 1 unless success
+      success
     end
-    params = generate_params(mute: @options[:mute_params])
-    check_for_errors
-    params
-  end
 
-  def build_scripts
-    Lono::Script::Build.new.run
-  end
+    def continue_update_rollback_sure?
+      puts <<~EOL
+        The stack is in the UPDATE_ROLLBACK_FAILED state. More info here: https://amzn.to/2IiEjc5
+        Would you like to try to continue the update rollback? (y/N)
+      EOL
 
-  def generate_templates
-    Lono::Template::DSL.new.run
-  end
+      sure = @options[:sure] ? "y" : $stdin.gets
+      unless sure =~ /^y/
+        puts "Exiting without continuing the update rollback."
+        exit 0
+      end
+    end
 
-  # only upload templates if s3_folder configured in settings
-  def upload_templates
-    Lono::Template::Upload.new.run if s3_folder
-  end
+    def continue_update_rollback
+      continue_update_rollback_sure?
+      params = {stack_name: @stack_name}
+      show_parameters(params, "cfn.continue_update_rollback")
+      begin
+        cfn.continue_update_rollback(params)
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        puts "ERROR5: #{e.message}".red
+        exit 1
+      end
+    end
 
-  # only upload templates if s3_folder configured in settings
-  def upload_scripts
-    return unless s3_folder
-    Lono::Script::Upload.new.run
-  end
+    def delete_rollback_stack
+      rollback = Rollback.new(@stack_name)
+      rollback.delete_stack
+    end
 
-  def upload_files
-    return unless s3_folder
-    Lono::FileUploader.new.upload_all
-  end
+    def status
+      @status ||= Cfn::Status.new(@stack_name)
+    end
 
-  def generate_params(options={})
-    generator_options = {
-      path: @param_path,
-      allow_no_file: true
-    }.merge(options)
-    generator = Lono::Param::Generator.new(@param_name, generator_options)
-    generator.generate  # Writes the json file in CamelCase keys format
-    generator.params    # Returns Array in underscore keys format
-  end
+    def prompt_for_iam(capabilities)
+      puts "This stack will create IAM resources.  Please approve to run the command again with #{capabilities} capabilities."
+      puts "  #{command_with_iam(capabilities)}"
 
-  # Maps to CloudFormation format.  Example:
-  #
-  #   {"a"=>"1", "b"=>"2"}
-  # To
-  #   [{key: "a", value: "1"}, {key: "b", value: "2"}]
-  #
-  def tags
-    tags = @options[:tags] || []
-    tags = tags.map do |k,v|
-      { key: k, value: v }
+      puts "Please confirm (y/n)"
+      $stdin.gets
     end
 
-    update_operation = %w[Lono::Cfn::Preview Lono::Cfn::Update].include?(self.class.to_s)
-    if tags.empty? && update_operation
-      resp = cfn.describe_stacks(stack_name: @stack_name)
-      tags = resp.stacks.first.tags
-      tags = tags.map(&:to_h)
+    def command_with_iam(capabilities)
+      "#{File.basename($0)} #{ARGV.join(' ')} --capabilities #{capabilities}"
     end
 
-    tags
-  end
+    # Use class variable to cache this only runs once across all classes. base.rb, diff.rb, preview.rb
+    @@generate_all = nil
+    def generate_all
+      return @@generate_all if @@generate_all
+
+      if @options[:lono]
+        ensure_s3_bucket_exist
+
+        build_scripts
+        generate_templates # generates with some placeholders for build_files IE: file://app/files/my.rb
+        build_files # builds app/files to output/BLUEPRINT/files
+
+        post_process_templates
+
+        unless @options[:noop]
+          upload_files
+          upload_scripts
+          upload_templates
+        end
+      end
 
-  def check_for_errors
-    errors, warns = check_files
-    unless errors.empty?
-      puts "Please double check the command you ran.  There were some errors."
-      puts "ERROR: #{errors.join("\n")}".color(:red)
-      exit
+      # Pass down all options to generate_params because it eventually uses template
+      param_generator.generate  # Writes the json file in CamelCase keys format
+      @@generate_all = param_generator.params    # Returns Array in underscore keys format
+
+      # At this point we have the info about params path used so we can display it.
+      # We display other useful info here too so it's together logically.
+      unless @options[:mute_using]
+        puts "Using template: #{pretty_path(@template_path)}"
+        param_generator.puts_param_message(:base)
+        param_generator.puts_param_message(:env)
+      end
+
+      check_for_errors
+      @@generate_all
     end
-    unless warns.empty?
-      puts "Please double check the command you ran.  There were some warnings."
-      puts "WARN: #{warns.join("\n")}".color(:yellow)
+
+    def param_generator
+      generator_options = {
+        regenerate: false,
+        allow_not_exists: true
+      }.merge(@options)
+      Lono::Param::Generator.new(@blueprint, generator_options)
     end
-  end
+    memoize :param_generator
 
-  def check_files
-    errors, warns = [], []
-    unless File.exist?(@template_path)
-      errors << "Template file missing: could not find #{@template_path}"
+    def ensure_s3_bucket_exist
+      bucket = Lono::S3::Bucket.new
+      return if bucket.exist?
+      bucket.create
     end
-    # Examples:
-    #   @param_path = params/prod/ecs.txt
-    #              => output/params/prod/ecs.json
-    output_param_path = @param_path.sub(/\.txt/, '.json')
-    output_param_path = "#{Lono.config.output_path}/#{output_param_path}"
-    if @options[:param] && !File.exist?(output_param_path)
-      warns << "Parameters file missing: could not find #{output_param_path}"
+
+    def build_scripts
+      Lono::Script::Build.new(@blueprint, @options).run
     end
-    [errors, warns]
-  end
 
-  # if existing in params path then use that
-  # if it doesnt assume it is a full path and check that
-  # else fall back to convention, which also eventually gets checked in check_for_errors
-  #
-  # Type - :param or :template
-  def get_source_path(path, type)
-    if path.nil?
-      convention_path(@stack_name, type) # default convention
-    else
-      # convention path based on the input from the user
-      convention_path(path, type)
+    def build_files
+      Lono::AppFile::Build.new(@blueprint, @options).run
     end
-  end
 
-  def convention_path(name, type)
-    path = case type
-    when :template
-      "#{Lono.config.output_path}/templates/#{name}.yml"
-    when :param
-      "#{Lono.config.params_path}/#{Lono.env}/#{name}.txt"
-    else
-      raise "hell: dont come here"
+    def generate_templates
+      Lono::Template::Generator.new(@blueprint, @options).run
     end
-    path.sub(/^\.\//, '')
-  end
 
-  # All CloudFormation states listed here:
-  # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
-  def stack_status(stack_name)
-    return true if testing_update?
-    return false if @options[:noop]
+    def post_process_templates
+      Lono::Template::PostProcessor.new(@blueprint, @options).run
+    end
 
-    resp = cfn.describe_stacks(stack_name: stack_name)
-    resp.stacks[0].stack_status
-  end
+    def upload_templates
+      Lono::Template::Upload.new(@blueprint).run
+    end
 
-  def exit_unless_updatable!(status)
-    return true if testing_update?
-    return false if @options[:noop]
+    def upload_scripts
+      Lono::Script::Upload.new(@blueprint).run
+    end
 
-    unless status =~ /_COMPLETE$/
-      puts "Cannot create a change set for the stack because the #{@stack_name} is not in an updatable state.  Stack status: #{status}".color(:red)
-      quit(1)
+    def upload_files
+      Lono::AppFile::Upload.new(@blueprint).upload
     end
-  end
 
-  # To allow mocking in specs
-  def quit(signal)
-    exit signal
-  end
+    # Maps to CloudFormation format.  Example:
+    #
+    #   {"a"=>"1", "b"=>"2"}
+    # To
+    #   [{key: "a", value: "1"}, {key: "b", value: "2"}]
+    #
+    def tags
+      tags = @options[:tags] || []
+      tags = tags.map do |k,v|
+        { key: k, value: v }
+      end
 
-  # Appends a short suffix at the end of a stack name.
-  # Lono internally strips this same suffix for the template name.
-  # Makes it convenient for the development flow.
-  #
-  #   lono cfn current --suffix 1
-  #   lono cfn create demo => demo-1
-  #   lono cfn update demo-1
-  #
-  # Instead of typing:
-  #
-  #   lono cfn create demo-1 --template demo
-  #   lono cfn update demo-1 --template demo
-  #
-  # The suffix can be specified at the CLI but can also be saved as a
-  # preference.
-  #
-  # A random suffix can be specified with random. Example:
-  #
-  #   lono cfn current --suffix random
-  #   lono cfn create demo => demo-[RANDOM], example: demo-abc
-  #   lono cfn update demo-abc
-  #
-  # It is not a default setting because it might confuse new lono users.
-  def append_suffix(stack_name)
-    suffix = Lono.suffix == 'random' ? random_suffix : Lono.suffix
-    [stack_name, suffix].compact.join('-')
-  end
+      update_operation = %w[Preview Update].include?(self.class.to_s)
+      if tags.empty? && update_operation
+        resp = cfn.describe_stacks(stack_name: @stack_name)
+        tags = resp.stacks.first.tags
+        tags = tags.map(&:to_h)
+      end
 
-  def remove_suffix(stack_name)
-    return stack_name unless Lono.suffix
+      tags
+    end
 
-    if stack_name_suffix == 'random'
-      stack_name.sub(/-(\w{3})$/,'') # strip the random suffix at the end
-    elsif stack_name_suffix
-      pattern = Regexp.new("-#{stack_name_suffix}$",'')
-      stack_name.sub(pattern, '') # strip suffix
-    else
-      stack_name
+    def check_for_errors
+      errors = check_files
+      unless errors.empty?
+        puts "Please double check the command you ran.  There were some errors."
+        puts "ERROR: #{errors.join("\n")}".color(:red)
+        exit
+      end
     end
-  end
 
-  # only generate random suffix for Lono::Cfn::Create class
-  def random_suffix
-    return nil unless self.class.name.to_s =~ /Create/
-    (0...3).map { (65 + rand(26)).chr }.join.downcase # Ex: jhx
-  end
+    def check_files
+      errors = []
+      unless File.exist?(@template_path)
+        errors << "Template file missing: could not find #{@template_path}"
+      end
+      errors
+    end
+
+    # All CloudFormation states listed here:
+    # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+    def stack_status(stack_name)
+      return true if testing_update?
+      return false if @options[:noop]
 
-  def stack_name_suffix
-    if @options[:suffix] && !@options[:suffix].nil?
-      return @options[:suffix] # CLI option takes highest precedence
+      resp = cfn.describe_stacks(stack_name: stack_name)
+      resp.stacks[0].stack_status
     end
 
-    # otherwise use the settings preference
-    settings = Lono::Setting.new
-    settings.data['stack_name_suffix']
-  end
+    def exit_unless_updatable!(status)
+      return true if testing_update?
+      return false if @options[:noop]
+
+      unless status =~ /_COMPLETE$/ || status == "UPDATE_ROLLBACK_FAILED"
+        puts "Cannot create a change set for the stack because the #{@stack_name} is not in an updatable state.  Stack status: #{status}".color(:red)
+        quit(1)
+      end
+    end
 
-  def capabilities
-    return @options[:capabilities] if @options[:capabilities]
-    if @options[:iam]
-      ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
+    # To allow mocking in specs
+    def quit(signal)
+      exit signal
     end
-  end
 
-  def show_parameters(params, meth=nil)
-    params = params.clone.compact
-    params[:template_body] = "Hidden due to size... View at: #{@template_path}"
-    to = meth || "AWS API"
-    puts "Parameters passed to #{to}:"
-    puts YAML.dump(params.deep_stringify_keys)
-  end
+    def capabilities
+      return @options[:capabilities] if @options[:capabilities]
+      if @options[:iam]
+        ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
+      end
+    end
 
-  def s3_folder
-    setting = Lono::Setting.new
-    setting.s3_folder
-  end
+    def show_parameters(params, meth=nil)
+      params = params.clone.compact
+      params[:template_body] = "Hidden due to size... View at: #{pretty_path(@template_path)}"
+      to = meth || "AWS API"
+      puts "Parameters passed to #{to}:"
+      puts YAML.dump(params.deep_stringify_keys)
+    end
 
-  # Either set the templmate_body or template_url attribute based on
-  # if template was uploaded to s3.
-  # Nice to reference s3 url because the max size of the template body is
-  # greater if the template body is on s3. Limits:
-  #
-  #   template_body: 51,200 bytes
-  #   template_url: 460,800 bytes
-  #
-  # Reference: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
-  def set_template_body!(params)
-    # if s3_folder is set this means s3 upload is enabled
-    if s3_folder # s3_folder defined in cfn/base.rb
-      upload = Lono::Template::Upload.new
-      url = upload.s3_presigned_url(@template_path)
+    # Lono always uploads the template to s3 so we can use much larger templates.
+    #
+    #   template_body: 51,200 bytes - filesystem limit
+    #   template_url: 460,800 bytes - s3 limit
+    #
+    # Reference: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
+    def set_template_body!(params)
+      upload = Lono::Template::Upload.new(@blueprint)
+      url_path = @template_path.sub("#{Lono.root}/",'')
+      url = upload.s3_presigned_url(url_path)
       params[:template_url] = url
-    else
-      params[:template_body] = IO.read(@template_path)
+      params
     end
 
-    params
+    def pretty_path(path)
+      path.sub("#{Lono.root}/",'')
+    end
   end
-end
+end