lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/cfn/cancel.rb

@@ -1,41 +1,24 @@
-class Lono::Cfn
-  class Cancel
-    include Lono::AwsServices
-    include Lono::Utils::Sure
-
-    def initialize(options={})
-      @options = options
-      @stack = options[:stack]
-    end
-
+module Lono::Cfn
+  class Cancel < Base
     def run
-      if @options[:noop]
-        puts "NOOP Canceling #{@stack} stack"
-        return
-      end
-
-      stack = find_stack(@stack)
+      stack = find_stack(@stack_name)
       unless stack
-        puts "The '#{@stack}' stack does not exist. Unable to cancel"
-        exit 1
+        logger.info "The '#{@stack_name}' stack does not exist. Unable to cancel"
+        quit 1
       end
 
-      puts "Canceling updates to #{@stack}."
-      puts "Current stack status: #{stack.stack_status}"
+      logger.info "Canceling updates to #{@stack_name}."
+      logger.info "Current stack status: #{stack.stack_status}"
       if stack.stack_status == "CREATE_IN_PROGRESS"
-        cfn.delete_stack(stack_name: @stack)
-        puts "Canceling stack creation."
+        cfn.delete_stack(stack_name: @stack_name)
+        logger.info "Canceling stack creation."
       elsif stack.stack_status == "UPDATE_IN_PROGRESS"
-        cfn.cancel_update_stack(stack_name: @stack)
-        puts "Canceling stack update."
+        cfn.cancel_update_stack(stack_name: @stack_name)
+        logger.info "Canceling stack update."
         status.wait if @options[:wait]
       else
-        puts "The stack is not in a state to that is cancelable: #{stack.stack_status}"
+        logger.info "The stack is not in a state to that is cancelable: #{stack.stack_status}"
       end
     end
-
-    def status
-      @status ||= Status.new(@stack)
-    end
   end
 end

data/lib/lono/cfn/concerns/build.rb

@@ -0,0 +1,10 @@
+module Lono::Cfn::Concerns
+  module Build
+    extend Memoist
+
+    def build
+      Lono::CLI::Build.new(@options)
+    end
+    memoize :build
+  end
+end

data/lib/lono/cfn/concerns/template_output.rb

@@ -0,0 +1,10 @@
+module Lono::Cfn::Concerns
+  module TemplateOutput
+    extend Memoist
+
+    def template_output
+      Lono::Builder::Template::Output.new(@blueprint)
+    end
+    memoize :template_output
+  end
+end

data/lib/lono/cfn/concerns.rb

@@ -0,0 +1,43 @@
+module Lono::Cfn
+  module Concerns
+    extend Memoist
+
+    include Concerns::Build
+    include Concerns::TemplateOutput
+
+    def iam
+      Deploy::Iam.new(@options)
+    end
+    memoize :iam
+
+    def notification
+      Deploy::Notification.new(@options)
+    end
+    memoize :notification
+
+    def rollback
+      Deploy::Rollback.new(@options)
+    end
+    memoize :rollback
+
+    def operable
+      Deploy::Operable.new(@options)
+    end
+    memoize :operable
+
+    def plan
+      Plan.new(@options.merge(build: build, iam: iam))
+    end
+    memoize :plan
+
+    def status
+      Status.new(@stack)
+    end
+    memoize :status
+
+    def tags
+      Deploy::Tags.new(@options)
+    end
+    memoize :tags
+  end
+end

data/lib/lono/cfn/delete.rb

@@ -1,38 +1,14 @@
-class Lono::Cfn
-  class Delete
-    include Lono::AwsServices
-    include Lono::Utils::Sure
-
-    def initialize(options={})
-      @options = options
-      @stack = options.delete(:stack)
-    end
-
+module Lono::Cfn
+  class Delete < Base
     def run
-      message = "Deleting #{@stack} stack."
-      if @options[:noop]
-        puts "NOOP #{message}"
+      plan.for_delete
+      sure?("Are you sure you want to delete the #{@stack} stack?")
+      cfn.delete_stack(stack_name: @stack)
+      if @options[:wait]
+        status.wait
       else
-        sure?("Are you sure you want to delete the #{@stack} stack?")
-
-        if stack_exists?(@stack)
-          cfn.delete_stack(stack_name: @stack)
-          puts message
-        else
-          puts "#{@stack.inspect} stack does not exist".color(:red)
-          return
-        end
+        logger.info "Deleting stack #{@stack}"
       end
-
-      return unless @options[:wait]
-      start_time = Time.now
-      status.wait unless @options[:noop]
-      took = Time.now - start_time
-      puts "Time took for stack deletion: #{status.pretty_time(took).color(:green)}."
-    end
-
-    def status
-      @status ||= Status.new(@stack)
     end
   end
 end

data/lib/lono/cfn/deploy/base.rb

@@ -0,0 +1,4 @@
+class Lono::Cfn::Deploy
+  class Base < Lono::Cfn::Base
+  end
+end

data/lib/lono/cfn/deploy/iam.rb

@@ -0,0 +1,48 @@
+class Lono::Cfn::Deploy
+  class Iam < Base
+    attr_reader :options
+
+    def rerun?(e)
+      # e.message is "Requires capabilities : [CAPABILITY_IAM]"
+      # grab CAPABILITY_IAM with regexp
+      capabilities = e.message.match(/\[(.*)\]/)[1]
+      confirm = prompt(capabilities)
+      if confirm =~ /^y/
+        logger.info "Re-running: #{command_with_iam(capabilities).color(:green)}"
+        @retry_capabilities = [capabilities]
+        true
+      else
+        logger.info "Exited"
+        quit 1
+      end
+    end
+
+    def prompt(capabilities)
+      logger.info <<~EOL
+        This stack will create IAM resources.  Please approve to run the command again with #{capabilities} capabilities.
+
+            #{command_with_iam(capabilities)}
+
+        You can also avoid this prompt by setting config.up.capabilities in config/app.rb
+        See: https://lono.cloud/docs/config/reference/
+
+      EOL
+      logger.print "Please confirm (y/N) "
+      $stdin.gets
+    end
+
+    def command_with_iam(capabilities)
+      "lono #{Lono.argv.join(' ')} --capabilities #{capabilities}"
+    end
+
+    def capabilities
+      return @retry_capabilities if @retry_capabilities
+      return @options[:capabilities] if @options[:capabilities]
+      if @options[:iam]
+        ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
+      else
+        Lono.config.up.capabilities
+      end
+    end
+  end
+end

data/lib/lono/cfn/deploy/notification.rb

@@ -0,0 +1,8 @@
+class Lono::Cfn::Deploy
+  class Notification < Base
+    def arns
+      arns = @options["notification_arns"] || Lono.config.up.notification_arns
+      arns == [''] ? [] : arns # allow removing the notification_arns setting
+    end
+  end
+end

data/lib/lono/cfn/deploy/operable.rb

@@ -0,0 +1,18 @@
+class Lono::Cfn::Deploy
+  class Operable < Base
+    def check!
+      status = stack_status
+      unless status =~ /_COMPLETE$/ || status == "UPDATE_ROLLBACK_FAILED"
+        logger.info "Cannot create run operation on stack #{@stack} is not in an updatable state.  Stack status: #{status}".color(:red)
+        quit 1
+      end
+    end
+
+    # All CloudFormation states listed here:
+    # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+    def stack_status
+      resp = cfn.describe_stacks(stack_name: @stack)
+      resp.stacks[0].stack_status
+    end
+  end
+end

data/lib/lono/cfn/deploy/opts.rb

@@ -0,0 +1,49 @@
+class Lono::Cfn::Deploy
+  class Opts < Base
+    def initialize(blueprint, meth, iam, options={})
+      @blueprint, @meth, @iam, @options = blueprint, meth, iam, options
+    end
+
+    def values
+      # important to use local options variable to not stomp on @options
+      options = @options.clone.compact
+      options[:capabilities] = @iam.capabilities if @iam.capabilities
+      options[:disable_rollback] = disable_rollback if !disable_rollback.nil? && @meth != "create_change_set"
+      options[:notification_arns] = notification.arns if notification.arns
+      options[:tags] = tags.values unless tags.values.nil?
+      options[:template_url] = template_url
+      options.reject { |k,v| v.nil? }
+    end
+
+    def show
+      logger.debug "Options passed to #{@meth}"
+      vals = values
+      vals[:template_body] = "Hidden due to size... View at: #{pretty_path(@blueprint.output_path)}" if vals[:template_body]
+      logger.debug YAML.dump(vals.deep_stringify_keys)
+    end
+
+    # Uploads the template to s3 to allow larger templates.
+    #
+    #   template_body: 51,200 bytes - filesystem limit
+    #   template_url:  1MB - s3 limit
+    #
+    # Reference: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
+    def template_url
+      url_path = @blueprint.output_path.sub("#{Lono.root}/",'')
+      url = Lono::S3::Uploader.new(url_path).presigned_url
+      # Interesting dont need presign query string. For stack sets it actually breaks it. So removing.
+      url.gsub!(/\.yml.*/, ".yml")
+      url.sub!(/\?.*/,'')
+      url
+    end
+    memoize :template_url
+
+    def disable_rollback
+      if !@options[:rollback].nil?
+        !@options[:rollback]
+      elsif !Lono.config.up.rollback.nil?
+        !Lono.config.up.rollback
+      end
+    end
+  end
+end

data/lib/lono/cfn/deploy/rollback.rb

@@ -0,0 +1,46 @@
+class Lono::Cfn::Deploy
+  class Rollback < Base
+    def delete_stack
+      return unless complete?
+      logger.info "Existing stack in ROLLBACK_COMPLETE state. Deleting stack before continuing."
+      cfn.delete_stack(stack_name: @stack)
+      status.wait
+      status.reset
+      true
+    end
+
+    def continue_update
+      continue_update?
+      options = {stack_name: @stack}
+      show_options(options, "continue_update_rollback")
+      begin
+        cfn.continue_update_rollback(options)
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        logger.info "ERROR: Continue update: #{e.message}".color(:red)
+        quit 1
+      end
+    end
+
+    def continue_update?
+      logger.info <<~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
+
+      yes = @options[:yes] ? "y" : $stdin.gets
+      unless yes =~ /^y/
+        logger.info "Exiting without continuing the update rollback."
+        quit 0
+      end
+    end
+
+    def complete?
+      stack&.stack_status == 'ROLLBACK_COMPLETE'
+    end
+
+    def stack
+      find_stack(@stack)
+    end
+    memoize :stack
+  end
+end

data/lib/lono/cfn/deploy/tags.rb

@@ -0,0 +1,18 @@
+class Lono::Cfn::Deploy
+  class Tags < Base
+    # Maps to CloudFormation format.  Example:
+    #
+    #   {"a"=>"1", "b"=>"2"}
+    # To
+    #   [{key: "a", value: "1"}, {key: "b", value: "2"}]
+    #
+    def values
+      tags = Lono.config.up.tags
+      return if tags.nil? # nil = keep current tags. [] = remove all tags
+
+      tags.map do |k,v|
+        { key: k.to_s, value: v }
+      end
+    end
+  end
+end

data/lib/lono/cfn/deploy.rb

@@ -1,11 +1,106 @@
-class Lono::Cfn
+module Lono::Cfn
   class Deploy < Base
-    def save(parameters)
-      if stack_exists?(@stack)
-        Update.new(@options).save(parameters)
+    def run
+      start_message
+      perform # create or update
+      success = status.wait
+      if success
+        finish_message
+        logger.info "" # newline
+      end
+      outputs
+    end
+
+    def perform
+      build.all
+      @action = create? ? "create" : "update"
+      send(@action)
+    rescue Aws::CloudFormation::Errors::InsufficientCapabilitiesException => e
+      @sure = true
+      yes = iam.rerun?(e)
+      retry if yes
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      case e.message
+      when /No updates/ # No updates are to be performed.
+        logger.info "WARN: #{e.message}".color(:yellow)
+      when /UPDATE_ROLLBACK_FAILED/ # https://amzn.to/2IiEjc5
+        rollback.continue_update
+      when /YAML not well-formed/ # happens if a value is a serialize Ruby Object. See: https://gist.github.com/tongueroo/737531d0bc8c92d92b5cd00493e15d9e
+        # e.message: Template format error: YAML not well-formed. (line 207, column 9)
+        print_code(e)
       else
-        Create.new(@options).save(parameters)
+        logger.info "ERROR: #{e.message}".color(:red)
+        logger.info "Check: #{pretty_path(@blueprint.output_path)}"
+        quit 1
+      end
+    end
+
+    def print_code(exception)
+      md = exception.message.match(/line (\d+),/)
+      line_number = md[1]
+      logger.error "Template for debugging: #{pretty_path(@blueprint.output_path)}"
+      if md
+        DslEvaluator.print_code(@blueprint.output_path, line_number)
+        exit 1
+      else
+        raise
+      end
+    end
+
+    def create
+      plan.for_create
+      @sure || sure?("Going to create stack #{@stack} with blueprint #{@blueprint.name}.")
+      upload_files
+      options = {
+        stack_name: @stack,
+        parameters: build.parameters,
+      }
+      opts = Opts.new(@blueprint, "create_stack", iam, options)
+      opts.show
+      options = opts.values
+      cfn.create_stack(options)
+    end
+
+    def update
+      if rollback.delete_stack
+        create
+        return
+      end
+
+      operable.check!
+      changeset = plan.for_update
+      !changeset.changed? || @sure || sure?("Are you sure you want to update the #{@stack} stack?")
+      upload_files
+      changeset.execute_change_set
+    end
+
+    # Upload files right before create_stack or execute_change_set
+    # Its better to upload here as part of a deploy vs a build
+    # IE: lono build should try not to do a remote write to s3 if possible
+    def upload_files
+      # Files built and compressed in
+      #     Lono::Builder::Dsl::Finalizer::Files::Build#build_files
+      Lono::Files.files.each do |file| # using singular file, but is like a "file_list"
+        file.upload
       end
     end
+
+    def create?
+      !stack_exists?(@stack)
+    end
+
+    def start_message
+      action = self.class.to_s.split('::').last
+      logger.info "#{action}ing #{@stack.color(:green)} stack"
+    end
+
+    def finish_message
+      message = "#{@action.capitalize}d #{@stack.color(:green)} stack."
+      logger.info message unless @options[:mute]
+    end
+
+    def outputs
+      Output.new(@options).run
+    end
   end
 end

data/lib/lono/cfn/download.rb

@@ -1,14 +1,11 @@
 require 'json'
 require 'open-uri'
 
-class Lono::Cfn
-  class Download < Lono::AbstractBase
-    include Lono::AwsServices
-
+module Lono::Cfn
+  class Download < Base
     def run
       pretty_path = download_path.sub("#{Lono.root}/", '')
-      puts "Downloading template to: #{pretty_path}"
-      return if @options[:noop]
+      logger.info "Downloading template to: #{pretty_path}"
       download_template
     end
 
@@ -41,7 +38,7 @@ class Lono::Cfn
     end
 
     def download_path
-      "#{Lono.config.output_path}/#{@blueprint}/templates/#{@blueprint}.yml"
+      "#{Lono.root}/output/#{@blueprint.name}/templates/#{@blueprint.name}.yml"
     end
 
     def name

data/lib/lono/cfn/output.rb

@@ -0,0 +1,49 @@
+module Lono::Cfn
+  class Output < Base
+    def run
+      stack = find_stack(@stack)
+      unless stack
+        logger.info "ERROR: stack #{@stack} not found".color(:red)
+        quit 1
+      end
+
+      outputs = stack.outputs.map(&:to_h)
+      logger.info <<~EOL
+        #{"Outputs:".color(:green)}
+
+      EOL
+      if outputs.empty?
+        logger.stdout outputs.inspect
+      else
+        logger.stdout pretty(outputs)
+      end
+    end
+
+  private
+    # Input:
+    #
+    #      [{
+    #        output_key: "SecurityGroup",
+    #        output_value: "demo-dev-SecurityGroup-142DZFIEG3G9L"
+    #      }]
+    #
+    # Output:
+    #
+    #      { "SecurityGroup" => "demo-dev-SecurityGroup-142DZFIEG3G9L" }
+    #
+    def pretty(outputs)
+      outs = outputs.inject({}) do |result,h|
+        result.merge!(h[:output_key] => h[:output_value])
+      end
+      default = {format: "equal"}
+      options = default.merge(@options.symbolize_keys)
+      presenter = CliFormat::Presenter.new(options)
+      presenter.header = ["Key", "Value"] unless presenter.format == "equal"
+      outs.keys.sort.each do |k|
+        row = [k,outs[k]]
+        presenter.rows << row
+      end
+      presenter.show
+    end
+  end
+end

data/lib/lono/cfn/plan/base.rb

@@ -0,0 +1,19 @@
+class Lono::Cfn::Plan
+  class Base < Lono::Cfn::Base
+    def initialize(options={})
+      super
+      # Allow build and iam to be passed from Cfn::Deploy. Reasons:
+      #
+      #   1. build.all only needs to be called once.
+      #   2. iam.capabilities can be adjusted with retry
+      #   3. objects are passed in a clear single direction.
+      #
+      # However, for CLI commands like `lono plan`, no objects are passed.
+      # In this case, new instances are created. In both cases the same options
+      # to the build and iam instances are used.
+      #
+      @build = options[:build] || build
+      @iam = options[:iam] || iam
+    end
+  end
+end

data/lib/lono/cfn/plan/changeset/base.rb

@@ -0,0 +1,19 @@
+class Lono::Cfn::Plan::Changeset
+  class Base
+    extend Memoist
+    include Lono::AwsServices
+    include Lono::Utils::Logging
+    include Lono::Cfn::Concerns::TemplateOutput
+
+    def initialize(options={})
+      @blueprint = options[:blueprint]
+      @change_set = options[:change_set]
+      @stack = options[:stack]
+    end
+
+    def stack
+      find_stack(@stack)
+    end
+    memoize :stack
+  end
+end

data/lib/lono/cfn/plan/changeset/notifications.rb

@@ -0,0 +1,24 @@
+class Lono::Cfn::Plan::Changeset
+  class Notifications < Base
+    def changes
+      old = stack.notification_arns
+      new = @change_set.notification_arns
+      added = new - old
+      removed = old - new
+      return if added.empty? && removed.empty?
+
+      logger.info "Changes to notifications"
+      log = Proc.new do |k|
+        logger.info "    #{k}"
+      end
+      unless added.empty?
+        logger.info "Added:"
+        added.each(&log)
+      end
+      unless removed.empty?
+        logger.info "Removed:"
+        removed.each(&log)
+      end
+    end
+  end
+end

data/lib/lono/cfn/plan/changeset/outputs.rb

@@ -0,0 +1,25 @@
+class Lono::Cfn::Plan::Changeset
+  class Outputs < Base
+    # Not enough info to show value changes. Show whats possible: Added and Removed keys
+    def changes
+      old_keys = stack.outputs.map { |output| output[:output_key] }
+      new_keys = template_output.outputs.map { |k,_| k }
+      added_keys = new_keys - old_keys
+      removed_keys = old_keys - new_keys
+      return if added_keys.empty? && removed_keys.empty?
+
+      logger.info "Changes to outputs"
+      log = Proc.new do |k|
+        logger.info "    #{k}"
+      end
+      unless added_keys.empty?
+        logger.info "Added:"
+        added_keys.each(&log)
+      end
+      unless removed_keys.empty?
+        logger.info "Removed:"
+        removed_keys.each(&log)
+      end
+    end
+  end
+end