lono 5.2.8 → 5.3.0

data/lib/lono/cfn/preview/param.rb

@@ -0,0 +1,73 @@
+module Lono::Cfn::Preview
+  class Param < Lono::Cfn::Base
+    delegate :required_parameters, :optional_parameters, :parameters, :data,
+             to: :output_template
+
+    include DiffViewer
+    include Lono::AwsServices
+
+    def run
+      return unless stack_exists?(@stack_name)
+
+      puts "Parameter Diff Preview:".color(:green)
+      if @options[:noop]
+        puts "NOOP CloudFormation parameters preview for #{@stack_name} update"
+        return
+      end
+
+      params = generate_all
+      write_to_tmp(new_path, params)
+      write_to_tmp(existing_path, existing_parameters)
+
+      show_diff(existing_path, new_path)
+    end
+
+    def existing_parameters
+      resp = cfn.describe_stacks(stack_name: @stack_name)
+      stack = resp.stacks.first
+      parameters = stack.parameters
+
+      # Remove optional parameters if they match already. Produces better diff.
+      optional = optional_parameters.map do |logical_id, attributes|
+        {
+          "ParameterKey" => logical_id,
+          "ParameterValue" => attributes["Default"],
+        }
+      end
+      converted = convert_to_cfn_format(parameters)
+      converted - optional
+    end
+
+  private
+    def output_template
+      Lono::OutputTemplate.new(@blueprint, @template)
+    end
+    memoize :output_template
+
+    def write_to_tmp(path, list)
+      converted = convert_to_cfn_format(list)
+      text = JSON.pretty_generate(converted)
+      FileUtils.mkdir_p(File.dirname(path))
+      IO.write(path, text)
+    end
+
+    def convert_to_cfn_format(list)
+      camelized = list.map(&:to_h).map do |h|
+        h.transform_keys {|k| k.to_s.camelize}
+      end
+      camelized.sort_by { |h| h["ParameterKey"] }
+    end
+
+    def existing_path
+      "#{tmp_base}/existing.json"
+    end
+
+    def new_path
+      "#{tmp_base}/new.json"
+    end
+
+    def tmp_base
+      "/tmp/lono/params-preview"
+    end
+  end
+end

data/lib/lono/cfn/update.rb

@@ -27,16 +27,17 @@ class Lono::Cfn
 
       options = @options.merge(mute_params: true, mute_using: true, keep: true)
       # create new copy of preview when update_stack is called because of IAM retry logic
-      preview = Lono::Cfn::Preview.new(@stack_name, options)
+      changeset_preview = Lono::Cfn::Preview::Changeset.new(@stack_name, options)
 
       error = nil
-      diff.run if @options[:diff]
-      preview.run if @options[:preview]
+      param_preview.run if @options[:param_preview]
+      codediff_preview.run if @options[:codediff_preview]
+      changeset_preview.run if @options[:changeset_preview]
       are_you_sure?(@stack_name, :update)
 
       if @options[:change_set] # defaults to this
-        message << " via change set: #{preview.change_set_name}"
-        preview.execute_change_set
+        message << " via change set: #{changeset_preview.change_set_name}"
+        changeset_preview.execute_change_set
       else
         standard_update(params)
       end
@@ -57,12 +58,18 @@ class Lono::Cfn
         cfn.update_stack(params)
       rescue Aws::CloudFormation::Errors::ValidationError => e
         puts "ERROR: #{e.message}".red
-        error = true
+        false
       end
     end
 
-    def diff
-      @diff ||= Lono::Cfn::Diff.new(@stack_name, @options.merge(mute_params: true, mute_using: true))
+    def codediff_preview
+      Lono::Cfn::Preview::Codediff.new(@stack_name, @options.merge(mute_params: true, mute_using: true))
     end
+    memoize :codediff_preview
+
+    def param_preview
+      Lono::Cfn::Preview::Param.new(@stack_name, @options)
+    end
+    memoize :param_preview
   end
 end

data/lib/lono/inspector.rb

@@ -1,4 +1,4 @@
 module Lono
-  class Inspector
+  module Inspector
   end
 end

data/lib/lono/inspector/base.rb

@@ -1,48 +1,42 @@
-class Lono::Inspector::Base
-  include Lono::Blueprint::Root
+module Lono::Inspector
+  class Base
+    delegate :required_parameters, :optional_parameters, :parameters, :data,
+             to: :output_template
 
-  def initialize(blueprint, template, options)
-    @blueprint, @template, @options = blueprint, template, options
-  end
+    extend Memoist
+    include Lono::Blueprint::Root
 
-  def run
-    blueprints = Lono::Blueprint::Find.one_or_all(@blueprint)
-    blueprints.each do |blueprint|
-      @blueprint_name = blueprint
+    def initialize(blueprint, template, options)
+      @blueprint, @template, @options = blueprint, template, options
+    end
 
-      generate_templates
-      set_blueprint_root(blueprint)
-      templates = @template ? [@template] : all_templates
-      templates.each do |template_name|
-        perform(template_name)
+    def run
+      blueprints = Lono::Blueprint::Find.one_or_all(@blueprint)
+      blueprints.each do |blueprint|
+        @blueprint = blueprint # intentional overwrite
+        generate_templates
+        set_blueprint_root(blueprint)
+        templates = @template_name ? [@template_name] : all_templates
+        templates.each do |template_name|
+          perform(template_name)
+        end
       end
     end
-  end
-
-  def generate_templates
-    Lono::Template::Generator.new(@blueprint_name, @options.clone.merge(quiet: false)).run
-  end
 
-  def all_templates
-    templates_path = "#{Lono.config.output_path}/#{@blueprint_name}/templates"
-    Dir.glob("#{templates_path}/**").map do |path|
-      path.sub("#{templates_path}/", '').sub('.yml','') # template_name
+    def generate_templates
+      Lono::Template::Generator.new(@blueprint, @options.clone.merge(quiet: false)).run
     end
-  end
 
-  def data
-    template_path = "#{Lono.config.output_path}/#{@blueprint_name}/templates/#{@template_name}.yml"
-    check_template_exists(template_path)
-    YAML.load(IO.read(template_path))
-  end
+    def all_templates
+      templates_path = "#{Lono.config.output_path}/#{@blueprint}/templates"
+      Dir.glob("#{templates_path}/**").map do |path|
+        path.sub("#{templates_path}/", '').sub('.yml','') # template_name
+      end
+    end
 
-  # Check if the template exists and print friendly error message.  Exits if it
-  # does not exist.
-  def check_template_exists(template_path)
-    unless File.exist?(template_path)
-      puts "The template #{template_path} does not exist. Are you sure you use the right template name?  The template name does not require the extension.".color(:red)
-      exit 1
+    def output_template
+      Lono::OutputTemplate.new(@blueprint, @template)
     end
+    memoize :output_template
   end
-
 end

data/lib/lono/inspector/graph.rb

@@ -1,124 +1,125 @@
 require "yaml"
 require "graph"
 
-class Lono::Inspector::Graph < Lono::Inspector::Base
-  def initialize(blueprint, template, options)
-    super
-    @nodes = [] # lookup map
-  end
-
-  def perform(template_name)
-    # little dirty but @template_name is used in data method
-    # so we dont have to pass it to the data method
-    @template_name = template_name
-
-    puts "Generating dependencies tree for template #{@template_name}..."
-    return if @options[:noop]
-
-    # First loop through top level nodes and build set depends_on property
-    node_list = [] # top level node list
-    resources = data["Resources"]
-    resources.each do |logical_id, resource|
-      node = Node.new(logical_id)
-      node.depends_on = normalize_depends_on(resource)
-      node.resource_type = normalize_resource_type(resource)
-      node_list << node
+module Lono::Inspector
+  class Graph < Base
+    def initialize(blueprint, template, options)
+      super
+      @nodes = [] # lookup map
     end
 
-    # Now that we have loop through all the top level resources once
-    # we can use the depends_on attribute on each node and set the
-    # children property since the identity nodes are in memory.
-    node_list.each do |node|
-      node.children = normalize_children(node_list, node)
-    end
+    def perform(template)
+      # little dirty but @template is used in data method so we dont have to pass it to the data method
+      @template = template
+
+      puts "Generating dependencies tree for template #{@template}..."
+      return if @options[:noop]
+
+      # First loop through top level nodes and build set depends_on property
+      node_list = [] # top level node list
+      resources = data["Resources"]
+      resources.each do |logical_id, resource|
+        node = Node.new(logical_id)
+        node.depends_on = normalize_depends_on(resource)
+        node.resource_type = normalize_resource_type(resource)
+        node_list << node
+      end
 
-    # At this point we have a tree of nodes.
-    if @options[:display] == "text"
-      puts "CloudFormation Dependencies:"
-      node_list.each { |node| print_tree(node) }
-    else
-      print_graph(node_list)
-      puts "CloudFormation Dependencies graph generated."
-    end
-  end
+      # Now that we have loop through all the top level resources once
+      # we can use the depends_on attribute on each node and set the
+      # children property since the identity nodes are in memory.
+      node_list.each do |node|
+        node.children = normalize_children(node_list, node)
+      end
 
-  # normalized DependOn attribute to an Array of Strings
-  def normalize_depends_on(resource)
-    dependencies = resource["DependOn"] || []
-    [dependencies].flatten
-  end
+      # At this point we have a tree of nodes.
+      if @options[:display] == "text"
+        puts "CloudFormation Dependencies:"
+        node_list.each { |node| print_tree(node) }
+      else
+        print_graph(node_list)
+        puts "CloudFormation Dependencies graph generated."
+      end
+    end
 
-  def normalize_resource_type(resource)
-    type = resource["Type"]
-    type.sub("AWS::", "") # strip out AWS to make less verbose
-  end
+    # normalized DependOn attribute to an Array of Strings
+    def normalize_depends_on(resource)
+      dependencies = resource["DependOn"] || []
+      [dependencies].flatten
+    end
 
-  # It is possible with bad CloudFormation templates that the dependency is not
-  # resolved, but we wont deal with that.  Users can validate their CloudFormation
-  # template before using this tool.
-  def normalize_children(node_list, node)
-    kids = []
-    node.depends_on.each do |dependent_logical_id|
-      node = node_list.find { |n| n.name == dependent_logical_id }
-      kids << node
+    def normalize_resource_type(resource)
+      type = resource["Type"]
+      type.sub("AWS::", "") # strip out AWS to make less verbose
     end
-    kids
-  end
 
-  def print_tree(node, depth=0)
-    spacing = "  " * depth
-    puts "#{spacing}#{node.name}"
-    node.children.each do |node|
-      print_tree(node, depth+1)
+    # It is possible with bad CloudFormation templates that the dependency is not
+    # resolved, but we wont deal with that.  Users can validate their CloudFormation
+    # template before using this tool.
+    def normalize_children(node_list, node)
+      kids = []
+      node.depends_on.each do |dependent_logical_id|
+        node = node_list.find { |n| n.name == dependent_logical_id }
+        kids << node
+      end
+      kids
     end
-  end
 
-  def print_graph(node_list)
-    check_graphviz_installed
-    digraph do
-      # graph_attribs << 'size="6,6"'
-      node_attribs << lightblue << filled
+    def print_tree(node, depth=0)
+      spacing = "  " * depth
+      puts "#{spacing}#{node.name}"
+      node.children.each do |node|
+        print_tree(node, depth+1)
+      end
+    end
 
-      node_list.each do |n|
-        node(n.graph_name)
-        n.children.each do |child|
-          edge n.graph_name, child.graph_name
+    def print_graph(node_list)
+      check_graphviz_installed
+      digraph do
+        # graph_attribs << 'size="6,6"'
+        node_attribs << lightblue << filled
+
+        node_list.each do |n|
+          node(n.graph_name)
+          n.children.each do |child|
+            edge n.graph_name, child.graph_name
+          end
         end
-      end
 
-      random = (0...8).map { (65 + rand(26)).chr }.join
-      path = "/tmp/cloudformation-depends-on-#{random}"
-      save path, "png"
-      # Check if open command exists and use it to open the image.
-      system "open #{path}.png" if system("type open > /dev/null")
+        random = (0...8).map { (65 + rand(26)).chr }.join
+        path = "/tmp/cloudformation-depends-on-#{random}"
+        save path, "png"
+        # Check if open command exists and use it to open the image.
+        system "open #{path}.png" if system("type open > /dev/null")
+      end
     end
-  end
 
-  # Check if Graphiz is installed and prints a user friendly message if it is not installed.
-  # Provide instructions if on macosx.
-  def check_graphviz_installed
-    installed = system("type dot > /dev/null") # dot is a command that is part of the graphviz package
-    unless installed
-      puts "It appears that the Graphviz is not installed.  Please install it to generate the graph."
-      if RUBY_PLATFORM =~ /darwin/
-        puts "You can install Graphviz with homebrew:"
-        puts "  brew install brew install graphviz"
+    # Check if Graphiz is installed and prints a user friendly message if it is not installed.
+    # Provide instructions if on macosx.
+    def check_graphviz_installed
+      installed = system("type dot > /dev/null") # dot is a command that is part of the graphviz package
+      unless installed
+        puts "It appears that the Graphviz is not installed.  Please install it to generate the graph."
+        if RUBY_PLATFORM =~ /darwin/
+          puts "You can install Graphviz with homebrew:"
+          puts "  brew install brew install graphviz"
+        end
+        exit 1
       end
-      exit 1
     end
-  end
 
-  class Node
-    attr_accessor :name, :resource_type, :children, :depends_on
-    def initialize(name)
-      @name = name
-      @children = []
-      @depends_on = []
-    end
+    class Node
+      attr_accessor :name, :resource_type, :children, :depends_on
+      def initialize(name)
+        @name = name
+        @children = []
+        @depends_on = []
+      end
 
-    def graph_name
-      type = "(#{resource_type})" if resource_type
-      [name, type].compact.join("\n")
+      def graph_name
+        type = "(#{resource_type})" if resource_type
+        [name, type].compact.join("\n")
+      end
     end
   end
 end

data/lib/lono/inspector/summary.rb

@@ -1,76 +1,65 @@
-class Lono::Inspector::Summary < Lono::Inspector::Base
-  def perform(template_name)
-    # little dirty but @template_name is used in data method
-    # so we dont have to pass it to the data method
-    @template_name = template_name
+module Lono::Inspector
+  class Summary < Base
+    def perform(template)
+      # little dirty but @template is used in data method so we dont have to pass it to the data method
+      @template = template
 
-    puts "=> CloudFormation Template Summary for template #{@template_name.color(:sienna)}:"
-    return if @options[:noop]
+      puts "=> CloudFormation Template Summary for template #{@template.color(:sienna)}:"
+      return if @options[:noop]
 
-    print_parameters_summary
+      print_parameters_summary
 
-    puts "Resources:"
-    print_resource_types
-  end
+      puts "Resources:"
+      print_resource_types
+    end
 
-  def print_parameters_summary
-    if parameters.empty?
-      puts "There are no parameters in this template."
-    else
-      print_parameters("Required Parameters", required_parameters)
-      print_parameters("Optional Parameters", optional_parameters)
+    def print_parameters_summary
+      if parameters.empty?
+        puts "There are no parameters in this template."
+      else
+        print_parameters("Required Parameters", required_parameters)
+        print_parameters("Optional Parameters", optional_parameters)
+      end
     end
-  end
 
-  def print_parameters(label, parameters)
-    puts "#{label}:"
-    if parameters.empty?
-      puts "  There are no #{label.downcase} parameters"
-    else
-      parameters.each do |logical_id, p|
-        output = "  #{logical_id} (#{p["Type"]})"
-        if p["Default"]
-          output << " Default: #{p["Default"]}"
+    def print_parameters(label, parameters)
+      puts "#{label}:"
+      if parameters.empty?
+        puts "  There are no #{label.downcase} parameters"
+      else
+        parameters.each do |logical_id, p|
+          output = "  #{logical_id} (#{p["Type"]})"
+          if p["Default"]
+            output << " Default: #{p["Default"]}"
+          end
+          puts output
         end
-        puts output
       end
     end
-  end
-
-  def required_parameters
-    parameters.reject { |logical_id, p| p["Default"] }
-  end
-
-  def optional_parameters
-    parameters.select { |logical_id, p| p["Default"] }
-  end
-
-  def parameters
-    data["Parameters"] || []
-  end
 
-  def resource_types
-    resources = data["Resources"]
-    return unless resources
+    def resource_types
+      resources = data["Resources"]
+      return unless resources
 
-    types = Hash.new(0)
-    resources.each do |logical_id, resource|
-      types[resource["Type"]] += 1
+      types = Hash.new(0)
+      resources.each do |logical_id, resource|
+        types[resource["Type"]] += 1
+      end
+      types
     end
-    types
-  end
 
-  def print_resource_types
-    unless resource_types
-      puts "No resources found."
-      return
-    end
+    def print_resource_types
+      unless resource_types
+        puts "No resources found."
+        return
+      end
 
-    types = resource_types.sort_by {|r| r[1] * -1} # Hash -> 2D Array
-    types.each do |a|
-      type, count = a
-      printf "%3s %s\n", count, type
+      types = resource_types.sort_by {|r| r[1] * -1} # Hash -> 2D Array
+      types.each do |a|
+        type, count = a
+        printf "%3s %s\n", count, type
+      end
+      printf "%3s %s\n", resource_types.size, "Total"
     end
-    printf "%3s %s\n", resource_types.size, "Total"
   end
 end