lono 7.5.2 → 8.0.0.pre.rc3

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

@@ -0,0 +1,48 @@
+class Lono::Cfn::Plan::Changeset
+  class Resources < Base
+    def changes
+      return if @change_set.changes.empty?
+      logger.info "Resource Changes"
+      changes = @change_set.changes.sort_by do |change|
+        change["resource_change"]["action"]
+      end
+      changes.each do |change|
+        display_change(change)
+      end
+    end
+
+    # Private: formats a Aws::CloudFormation::Types::Change in pretty human readable form
+    #
+    # change  - Aws::CloudFormation::Types::Change
+    #
+    # Examples
+    #
+    #   display_change(change)
+    #   => Remove AWS::Route53::RecordSet: DnsRecord testsubdomain.sub.tongueroo.com
+    #
+    # Returns nil
+    #
+    # change.to_h
+    # {:type=>"Resource",
+    #  :resource_change=>
+    #   {:action=>"Remove",
+    #    :logical_resource_id=>"DnsRecord",
+    #    :physical_resource_id=>"testsubdomain.sub.tongueroo.com",
+    #    :resource_type=>"AWS::Route53::RecordSet",
+    #    :scope=>[],
+    #    :details=>[]}}
+    def display_change(change)
+      message = if change.type == "Resource"
+        c = change.resource_change
+        "    #{c.action} #{c.resource_type}: #{c.logical_resource_id} #{c.physical_resource_id}"
+      else
+        change.to_h
+      end
+
+      colors = { Remove: :red, Add: :green, Modify: :yellow }
+      action = change.resource_change.action.to_sym
+      message = message.color(colors[action]) if colors.has_key?(action)
+      logger.info message
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class Lono::Cfn::Plan::Changeset
+  class Tags < Base
+    def changes
+      old = simplify(stack.tags)
+      new = simplify(@change_set.tags)
+      diff = Lono::Cfn::Plan::Diff::Data.new(old, new)
+      diff.show("Tag Changes:")
+    end
+
+    def simplify(tags)
+      tags.inject({}) do |result, i|
+        result.merge(i.key => i.value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+class Lono::Cfn::Plan
+  class Changeset < Base
+    # used by deploy to see whether or not to continue and bypass sure prompt
+    attr_reader :changed
+    alias_method :changed?, :changed
+
+    # Override run from Base superclass, the run method is different enough with Preview
+    def create
+      @build.all
+      @changed = false
+      logger.info "Change Set Changes:".color(:green) if Lono.config.plan.changeset
+      preview_change_set
+      logger.info "" # newline
+    end
+
+    def display_changes(change_set)
+      options = {change_set: change_set, blueprint: @blueprint, stack: @stack}
+      Tags.new(options).changes
+      Outputs.new(options).changes
+      Resources.new(options).changes
+      Notifications.new(options).changes
+    end
+
+    def preview_change_set
+      create_change_set
+      change_set = wait_for_change_set
+      @changed = change_set.status == "CREATE_COMPLETE"
+      handle_out(change_set)
+      display(change_set)
+    end
+
+    def wait_for_change_set
+      change_set = describe_change_set
+      newline_needed = false
+      until change_set_finished?(change_set) do
+        change_set = describe_change_set
+        sleep 1
+        unless newline_needed
+          logger.print "Determining Change Set"
+        end
+        newline_needed = true
+        logger.print '.'
+      end
+      logger.print "\n" if newline_needed
+      change_set
+    end
+
+    def create_change_set
+      unless stack_exists?(@stack)
+        logger.info "WARN: Cannot create a change set for the stack because the #{@stack} does not exists.".color(:yellow)
+        return false
+      end
+      operable.check!
+
+      options = {
+        change_set_name: change_set_name,
+        stack_name: @stack,
+        parameters: @build.parameters,
+      }
+
+      opts = Lono::Cfn::Deploy::Opts.new(@blueprint, "create_change_set", @iam, options)
+      opts.show
+      options = opts.values
+
+      begin
+        # Tricky for preview need to set capabilities so that it gets updated. For Base#run save within the begin block already.
+        options[:capabilities] = iam.capabilities # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
+        resp = cfn.create_change_set(options)
+      rescue Aws::CloudFormation::Errors::InsufficientCapabilitiesException => e
+        # If coming from cfn_preview_command automatically add iam capabilities
+        cfn_preview_command = ARGV.join(" ").include?("cfn preview")
+        if cfn_preview_command
+          # e.message is "Requires capabilities : [CAPABILITY_IAM]"
+          # grab CAPABILITY_IAM with regexp
+          capabilities = e.message.match(/\[(.*)\]/)[1]
+          @options.merge!(capabilities: [capabilities])
+          retry
+        end
+        yes = iam.rerun?(e)
+        @options = iam.options
+        retry if yes
+      end
+    end
+
+    def display(change_set)
+      return unless Lono.config.plan.changeset
+      case change_set.status
+      when "CREATE_COMPLETE"
+        display_changes(change_set)
+      when "FAILED"
+        logger.info "No changes"
+        logger.debug change_set.status_reason # The submitted information didn't contain changes. Submit different information to create a change set.
+      else
+        raise "hell: never come here"
+      end
+      change_set
+    end
+
+    def execute_change_set
+      return unless @changed
+      cfn.execute_change_set(
+        change_set_name: change_set_name,
+        stack_name: @stack
+      )
+    end
+
+    # generates a change set name
+    def change_set_name
+      @change_set_name ||= "changeset-#{Time.now.strftime("%Y%d%m%H%M%S")}"
+    end
+
+  private
+    def change_set_finished?(change_set)
+      change_set.status =~ /_COMPLETE/ || change_set.status == "FAILED"
+    end
+
+    def describe_change_set
+      cfn.describe_change_set(
+        change_set_name: change_set_name,
+        stack_name: @stack
+      )
+    end
+
+    def handle_out(change_set)
+      out = @options[:out]
+      return unless out
+      logger.info "Change Set ARN: #{change_set.change_set_id}"
+      if change_set.status == "FAILED"
+        logger.info "Note: #{change_set.status_reason}"
+      end
+      logger.info "Change Set info saved to #{out}"
+      FileUtils.mkdir_p(File.dirname(out))
+      IO.write(out, JSON.pretty_generate(change_set.to_h))
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+class Lono::Cfn::Plan
+  module Concerns
+    extend Memoist
+
+    def summary
+      Summary.new
+    end
+    memoize :summary
+  end
+end

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

@@ -0,0 +1,16 @@
+class Lono::Cfn::Plan
+  class Delete < Lono::Cfn::Base
+    include Concerns
+
+    def run
+      stack = find_stack(@stack)
+      unless stack
+        logger.info "ERROR: stack #{@stack} not found".color(:red)
+        quit 1
+      end
+
+      logger.info "Will delete".color(:green)
+      Lono::Cfn::Show.new(@options).print
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Lono::Cfn::Plan::Diff
+  class Base
+    include Lono::Utils::Logging
+    include Lono::Utils::Pretty
+
+    def initialize(options={})
+      @options = options
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Lono::Cfn::Plan::Diff
+  class Data < Base
+    extend Memoist
+
+    def initialize(old, new)
+      @old = old
+      @new = new
+    end
+
+    def show(header_message=nil)
+      changes = calculate
+      if !changes && header_message
+        return
+      end
+      logger.info header_message if header_message
+
+      unless @added_keys.empty?
+        logger.info "Added:"
+        @added_keys.each do |k|
+          logger.info "    #{k}: #{@new[k]}"
+        end
+      end
+      unless @removed_keys.empty?
+        logger.info "Removed:"
+        @removed_keys.each do |k|
+          logger.info "    #{k}: #{@old[k]}"
+        end
+      end
+      unless @modified_keys.empty?
+        logger.info "Modified:"
+        @modified_keys.each do |k|
+          logger.info "    #{k}: #{show_old(@old[k])} -> #{@new[k]}"
+        end
+      end
+
+      unless changes
+        logger.info "No changes"
+      end
+    end
+
+    def show_old(v)
+      if v.nil?
+        '(unset)'
+      elsif v == ''
+        "''"
+      else
+        v
+      end
+    end
+
+    def calculate
+      @added_keys = @new.keys - @old.keys
+      @removed_keys = @old.keys - @new.keys
+      all_keys = (@old.keys + @new.keys).uniq
+      kept_keys = all_keys - @added_keys - @removed_keys
+      @modified_keys = kept_keys.select { |k| @old[k] != @new[k] }
+      no_changes = @added_keys.empty? && @removed_keys.empty? && @modified_keys.empty?
+      !no_changes
+    end
+    memoize :calculate
+  end
+end

data/lib/lono/cfn/plan/diff/file.rb

@@ -0,0 +1,57 @@
+module Lono::Cfn::Plan::Diff
+  class File < Base
+    def show(existing_path, new_path)
+      if @options[:mode] == true || @options[:mode] == "summary"
+        summary(existing_path, new_path)
+      else # full
+        full(existing_path, new_path)
+      end
+    end
+
+    def summary(existing_path, new_path)
+      command = "diff #{existing_path} #{new_path} -u -s"
+      # actually use diff but show colordiff in pretty_command
+      pretty_command = "#{diff_viewer} #{pretty_path(existing_path)} #{pretty_path(new_path)}"
+      logger.info "=> #{pretty_command}"
+      out = `#{command}`
+      lines = out.split("\n")
+      lines.reject! { |l| l =~ /^\+\+\+ / || l =~ /^--- / } # remove header lines
+      stats = lines.inject(Hash.new(0)) do |stats,line|
+        char = line[0] # first char will be - +
+        case char
+        when '+'
+          stats[:insertions] += 1
+        when '-'
+          stats[:deletions] += 1
+        end
+        stats
+      end
+      if stats.all? { |_,count| count == 0 }
+        logger.info "No changes"
+      else
+        logger.info "    #{stats[:insertions]} insertions(+), #{stats[:deletions]} deletions(-)"
+      end
+    end
+
+    def full(existing_path, new_path)
+      command = "#{diff_viewer} #{existing_path} #{new_path}"
+      pretty_command = "#{diff_viewer} #{pretty_path(existing_path)} #{pretty_path(new_path)}"
+      logger.info "=> #{pretty_command}"
+      out = `#{command}`
+      if out.strip == ''
+        logger.info "No changes"
+      else
+        logger.info out
+      end
+    end
+
+    def diff_viewer
+      return ENV['LONO_DIFF'] if ENV['LONO_DIFF']
+      colordiff_installed = system("type colordiff > /dev/null 2>&1")
+      unless colordiff_installed
+        logger.info "INFO: colordiff it not available. Recommend installing it."
+      end
+      colordiff_installed ? "colordiff" : "diff"
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+class Lono::Cfn::Plan
+  class New < Lono::Cfn::Base
+    include Concerns
+
+    def run
+      if resource_types.empty?
+        logger.info "ERROR: At least one Resource member must be defined in the template".color(:red)
+        quit 1
+      end
+
+      logger.info "Will create".color(:green)
+      summary.print(resource_types)
+    end
+
+    def resource_types
+      resources = template_output.resources
+      return {} unless resources
+
+      types = Hash.new(0)
+      resources.each do |logical_id, resource|
+        types[resource["Type"]] += 1
+      end
+      types
+    end
+  end
+end

data/lib/lono/cfn/{preview → plan}/param.rb

@@ -1,25 +1,14 @@
-module Lono::Cfn::Preview
-  class Param < Lono::Cfn::Base
-    delegate :required_parameters, :optional_parameters, :parameters, :data,
-             to: :output_template
-
-    include DiffViewer
-    include Lono::AwsServices
-
+class Lono::Cfn::Plan
+  class Param < Base
     def run
-      return unless stack_exists?(@stack)
-
-      generated_parameters # eager call generated_parameters so its output is above Parameter Diff Preview
-      puts "Parameter Diff Preview:".color(:green)
-      if @options[:noop]
-        puts "NOOP CloudFormation parameters preview for #{@stack} update"
-        return
-      end
-
+      return unless Lono.config.plan.params && stack_exists?(@stack)
+      logger.info "Parameter Changes:".color(:green)
       write_to_tmp(existing_path, existing_params)
       write_to_tmp(new_path, new_params)
-
-      show_diff(existing_path, new_path)
+      logger.debug "=> diff #{pretty_path(existing_path)} #{pretty_path(new_path)}"
+      diff = Diff::Data.new(json_load(existing_path), json_load(new_path))
+      diff.show
+      logger.info "" # newline
     end
 
     def existing_params
@@ -30,11 +19,21 @@ module Lono::Cfn::Preview
     memoize :existing_params
 
     def new_params
-      params = optional_params.merge(generated_parameters)
+      parameters = @build.parameters
+      params = normalize(parameters)
+      params = optional_params.merge(params)
+      params = replace_noecho_values!(params)
       subtract(params, noecho_params)
     end
 
-    # Remove items with the same key. The value can be different. This removes the noecho params.
+    def replace_noecho_values!(params)
+      template_output.parameters.each do |key, data|
+        params[key] = '**** (NoEcho)' if data['NoEcho'] # mimic noecho
+      end
+      params
+    end
+
+    # Remove existing items with the same key. The value can be different. This removes the noecho params.
     def subtract(h1,h2)
       hash = h1.reject do |k,v|
         h2.keys.include?(k)
@@ -42,15 +41,9 @@ module Lono::Cfn::Preview
       Hash[hash.sort_by {|k,v| k}]
     end
 
-    def generated_parameters
-      parameters = generate_all
-      normalize(parameters)
-    end
-    memoize :generated_parameters
-
     def optional_params
       # normalizing to simple Hash
-      optional_parameters.inject({}) do |result,(k,v)|
+      template_output.optional_parameters.inject({}) do |result,(k,v)|
         result.merge(k => v["Default"].to_s)
       end
     end
@@ -69,11 +62,6 @@ module Lono::Cfn::Preview
     memoize :stack_parameters
 
   private
-    def output_template
-      Lono::Output::Template.new(@blueprint, @template)
-    end
-    memoize :output_template
-
     def write_to_tmp(path, hash)
       text = JSON.pretty_generate(hash)
       FileUtils.mkdir_p(File.dirname(path))
@@ -104,7 +92,11 @@ module Lono::Cfn::Preview
     end
 
     def tmp_base
-      "/tmp/lono/params-preview"
+      "/tmp/lono/diff/params"
+    end
+
+    def json_load(path)
+      JSON.load(IO.read(path))
     end
   end
 end

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

@@ -0,0 +1,16 @@
+class Lono::Cfn::Plan
+  class Summary
+    include Lono::Utils::Logging
+
+    def print(resource_types)
+      types = resource_types.sort_by {|r| r[0]} # Hash -> 2D Array
+      types.each do |a|
+        type, count = a
+        logger.info "%3s %s" % [count, type]
+      end
+      total = types.inject(0) { |sum,(type,count)| sum += count }
+      logger.info "%3s %s" % [total, "Total"]
+      logger.info "" # newline
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+class Lono::Cfn::Plan
+  class Template < Base
+    def run
+      return unless Lono.config.plan.template
+      @build.all
+      logger.info "Template Changes:".color(:green)
+      download_existing_cfn_template
+      diff = Diff::File.new(mode: Lono.config.plan.template)
+      diff.show(existing_template_path, new_cfn_template)
+      logger.info "" # newline
+    end
+
+    def download_existing_cfn_template
+      resp = cfn.get_template(stack_name: @stack, template_stage: "Original")
+      FileUtils.mkdir_p(File.dirname(existing_template_path))
+      IO.write(existing_template_path, resp.template_body)
+    end
+
+    # for clarity
+    def new_cfn_template
+      @blueprint.output_path
+    end
+
+    def existing_template_path
+      "/tmp/lono/diff/template/existing.yml"
+    end
+  end
+end

data/lib/lono/cfn/plan.rb

@@ -0,0 +1,34 @@
+module Lono::Cfn
+  class Plan < Base
+    def run
+      build.all
+      if stack_exists?(@stack)
+        for_update
+      else
+        for_create
+      end
+    end
+
+    def for_update
+      # Allow passing down of the build object from Cfn::Deploy so build.all only runs once.
+      # Fallback to creating new build object but still pass one build object instance down.
+      @options[:build] ||= build
+      if @options[:iam] == true
+        @options[:iam] = Lono::Cfn::Deploy::Iam.new(@options)
+      end
+      Template.new(@options).run
+      Param.new(@options).run
+      changeset = Changeset.new(@options)
+      changeset.create
+      changeset # return changeset so it can be executed
+    end
+
+    def for_create
+      New.new(@options).run
+    end
+
+    def for_delete
+      Delete.new(@options).run
+    end
+  end
+end

data/lib/lono/cfn/show.rb

@@ -0,0 +1,30 @@
+module Lono::Cfn
+  class Show < Base
+    include Plan::Concerns
+
+    def run
+      logger.info "Info for stack: #{@stack.color(:green)}"
+      logger.info "Resources:".color(:green)
+      print
+      Output.new(@options).run
+    end
+
+    def print
+      summary.print(resource_types)
+    end
+
+    def resource_types
+      resources = find_stack_resources(@stack)
+      unless resources
+        logger.info "ERROR: Stack #{@stack} not found".color(:red)
+        exit 1
+      end
+
+      types = Hash.new(0)
+      resources.each do |resource|
+        types[resource.resource_type] += 1
+      end
+      types
+    end
+  end
+end

data/lib/lono/cfn/status.rb

@@ -1,4 +1,4 @@
-class Lono::Cfn
+module Lono::Cfn
   class Status < CfnStatus
   end
 end

data/lib/lono/cli/abstract.rb

@@ -0,0 +1,11 @@
+class Lono::CLI
+  class Abstract
+    extend Memoist
+    include Lono::Utils::Logging
+    include Lono::Utils::Pretty
+
+    def initialize(options={})
+      @options = options
+    end
+  end
+end

data/lib/lono/cli/base.rb

@@ -0,0 +1,11 @@
+class Lono::CLI
+  class Base < Abstract
+    include Lono::Concerns::Names
+
+    def initialize(options={})
+      super
+      @blueprint = Lono::Blueprint.new(options.merge(name: options[:blueprint]))
+      @stack = names.stack
+    end
+  end
+end

data/lib/lono/cli/build.rb

@@ -0,0 +1,47 @@
+class Lono::CLI
+  class Build < Base
+    def all
+      check_allow!
+      Clean.new(@options.merge(mute: true)).run
+      ensure_s3_bucket_exist
+      template_builder.run # build with placeholders IE: file://app/files/index.rb
+      upload_templates
+      parameters = param_builder.build  # Writes the json file in CamelCase keys format
+      logger.info "" # newline
+      parameters
+    end
+    memoize :all
+    alias_method :parameters, :all
+
+    def check_allow!
+      Lono::Builder::Allow.new(@options).check!
+    end
+
+    def ensure_s3_bucket_exist
+      return unless upload?
+      bucket = Lono::S3::Bucket.new
+      return if bucket.exist?
+      bucket.deploy
+    end
+
+    def upload_templates
+      return unless upload?
+      Lono::Builder::Template::Upload.new(@options).run
+    end
+
+    def param_builder
+      Lono::Builder::Param.new(@options)
+    end
+    memoize :param_builder
+
+    def template_builder
+      Lono::Builder::Template.new(@options) # write templates to disk
+    end
+    memoize :template_builder
+
+    # Useful for dev and debugging
+    def upload?
+      ENV['LONO_UPLOAD'] != '0'
+    end
+  end
+end