lono 6.1.11 → 7.0.0

data/lib/lono/sets/instances.rb

@@ -0,0 +1,33 @@
+class Lono::Sets
+  class Instances < Lono::Command
+    opts = Opts.new(self)
+
+    desc "delete STACK_SET", "Delete CloudFormation stack set instances."
+    long_desc Lono::Help.text("sets/instances/delete")
+    opts.delete
+    def delete(stack)
+      Delete.new(options.merge(stack: stack)).run
+    end
+
+    desc "sync STACK_SET", "Sync CloudFormation stack set instances."
+    long_desc Lono::Help.text("sets/instances/sync")
+    opts.sync
+    def sync(stack)
+      Sync.new(options.merge(stack: stack)).run
+    end
+
+    desc "list STACK_SET", "List CloudFormation stack set instances."
+    long_desc Lono::Help.text("sets/instances/list")
+    def list(stack)
+      List.new(options.merge(stack: stack)).run
+    end
+
+    desc "status STACK_SET", "Show current status of stack instances."
+    long_desc Lono::Help.text("sets/instances/status")
+    def status(stack)
+      instances_status = Status.new(options.merge(stack: stack))
+      success = instances_status.run
+      exit 3 unless success
+    end
+  end
+end

data/lib/lono/sets/instances/base.rb

@@ -0,0 +1,30 @@
+class Lono::Sets::Instances
+  class Base < Lono::Sets::Base
+    # Simple structure to help with subtracting logic
+    # [["112233445566", "us-west-1"], ["112233445566", "us-west-1"]]
+    def requested
+      requested = []
+      accounts.each do |a|
+        regions.each do |r|
+          item = [a,r]
+          requested << item
+        end
+      end
+      requested.sort.uniq
+    end
+    memoize :requested
+
+    def accounts
+      @options[:accounts]
+    end
+
+    def regions
+      @options[:regions]
+    end
+
+    def stack_instances
+      resp = cfn.list_stack_instances(stack_set_name: @stack)
+      resp.summaries
+    end
+  end
+end

data/lib/lono/sets/instances/delete.rb

@@ -0,0 +1,69 @@
+class Lono::Sets::Instances
+  class Delete < Base
+    include Lono::AwsServices
+    include Lono::Utils::Sure
+
+    def initialize(options={})
+      @options = options
+      @stack = options[:stack]
+    end
+
+    def run
+      validate!
+
+      sure?("Are you sure you want to delete the #{@stack} instances?", long_desc)
+
+      # delete_stack_instances resp has operation_id
+      # Could also use that to poll for status with the list_stack_set_operation_results
+      # api. Currently, Instance::Status class not using this info. If we need will add the logic.
+      resp = cfn.delete_stack_instances(
+        options = {
+          stack_set_name: @stack,
+          accounts: accounts,
+          regions: regions,
+          retain_stacks: false,
+        }
+      )
+      operation_id = resp.operation_id
+
+      # Status tailing handled by caller
+      o = @options.merge(
+        filter: requested,
+        start_on_outdated: false,
+        operation_id: operation_id,
+      )
+      Lono::Sets::Status::Instance::Base.show_time_progress = true
+      Lono::Sets::Status::Instance::Base.delay_factor = accounts.size * regions.size
+      instances_status = Status.new(o)
+      instances_status.run(to: "deleted") unless @options[:noop] # returns success: true or false
+    end
+
+    def long_desc
+      total = accounts.size * regions.size
+      <<~EOL
+      These stack instances will be deleted:
+
+          accounts: #{accounts.join(',')}
+          regions: #{regions.join(',')}
+
+      Number of stack instances to be deleted: #{total}
+      EOL
+    end
+
+    def validate!
+      invalid = (regions.blank? || accounts.blank?) && !@options[:all]
+      if invalid
+        puts "ERROR: You must provide --accounts and --regions or --all.".color(:red)
+        exit 1
+      end
+    end
+
+    def accounts
+      @options[:all] ? stack_instances.map(&:account).uniq : @options[:accounts]
+    end
+
+    def regions
+      @options[:all] ? stack_instances.map(&:region).uniq : @options[:regions]
+    end
+  end
+end

data/lib/lono/sets/instances/list.rb

@@ -0,0 +1,13 @@
+class Lono::Sets::Instances
+  class List
+    include Lono::AwsServices
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def run
+      Lono::Sets::Status::Instances.new(@options).show
+    end
+  end
+end

data/lib/lono/sets/instances/opts.rb

@@ -0,0 +1,29 @@
+class Lono::Sets::Instances
+  class Opts < Lono::Sets::Opts
+    def delete
+      operation_preferences_options
+      accounts_options
+      with_cli_scope do
+        option :all, type: :boolean, desc: "Delete stack all instances. Overrides --accounts and --regions options"
+      end
+    end
+
+    def sync
+      operation_preferences_options
+      accounts_options
+      with_cli_scope do
+        option :delete, type: :boolean, default: true, desc: "Delete stack instances that are not provided"
+        option :blueprint, desc: "override convention and specify the template file to use"
+        option :source, desc: "url or path to file with template"
+      end
+    end
+
+    def accounts_options
+      with_cli_scope do
+        option :accounts, type: :array, desc: "List of accounts to apply stack set to. IE: 112233445566 223344556677"
+        option :regions, type: :array, desc: "List of regions to apply stack set to. IE: us-west-2 us-east-1"
+        option :sure, type: :boolean, desc: "Skip are you sure prompt"
+      end
+    end
+  end
+end

data/lib/lono/sets/instances/status.rb

@@ -0,0 +1,12 @@
+class Lono::Sets::Instances
+  class Status
+    def initialize(options={})
+      @options = options
+    end
+
+    def run(to: "completed")
+      instances = Lono::Sets::Status::Instances.new(@options)
+      instances.wait(to)
+    end
+  end
+end

data/lib/lono/sets/instances/sync.rb

@@ -0,0 +1,182 @@
+class Lono::Sets::Instances
+  class Sync < Base
+    include Lono::Sets::Summarize
+    include Lono::Utils::Sure
+
+    def initialize(options={})
+      super # need conventions so config lookup will work
+      @regions, @accounts = [], []
+    end
+
+    def run
+      unless stack_set_exists?(@stack)
+        puts "ERROR: Cannot update a stack set because #{@stack} does not exists.".color(:red)
+        return
+      end
+      exit_unless_updatable!
+
+      validate!
+
+      existing = stack_instances.map do |summary|
+        [summary.account, summary.region]
+      end
+
+      creates = requested - existing
+      deletes = existing - requested
+
+      if creates.empty? and deletes.empty?
+        puts <<~EOL
+          Nothing to be synced. IE: No stack instances need to be added or removed.  If you want to update the
+          stack set and update all stack instances instead, use the `lono sets deploy` command.
+        EOL
+        return
+      end
+      sure?("Are you sure you want to sync stack instances?", long_desc(creates: creates, deletes: deletes))
+
+      # Note: Not calling update_stack_instances because after deleting stacks it instances in in a weird state
+      # where an update_stack_instances fails. Can reproduce this by deleting stacks and then trying an update_stack_instances
+      # with the AWS CLI. In theory, we never really should have to call update_stack_instances anyway because
+      # updating the stack set at the parent level kicks off an update_stack_instances automatically.
+      operation_id = execute(:create_stack_instances, creates)
+      summarize(operation_id) if operation_id
+      if @options[:delete]
+        operation_id = execute(:delete_stack_instances, deletes)
+        summarize(operation_id) if operation_id
+      end
+    end
+
+  private
+
+    # data:
+    #    {creates: creates, deletes: deletes}
+    # where creates and deletes are instances_data structures:
+    #    [["112233445566", "us-west-1"], ["112233445566", "us-west-1"]]
+    def long_desc(data={})
+      desc = "lono will run:\n"
+      verbs = [:creates, :deletes]
+      verbs.each do |verb|
+        accounts = accounts_list(data[verb])
+        regions = regions_list(data[verb])
+        unless data[verb].empty?
+          info = {
+            accounts: accounts.join(','),
+            regions: regions.join(','),
+          }
+          change_total = accounts.size * regions.size
+          singular_verb = verb.to_s.singularize
+          past_verb = verb.to_s.sub(/s$/,'d')
+          message = <<~EOL
+            #{singular_verb}_stack_instances for:
+              accounts: #{info[:accounts]}
+              regions: #{info[:regions]}
+
+            Number of stack instances to be #{past_verb}: #{change_total}
+          EOL
+          desc << message
+        end
+      end
+      desc
+    end
+
+    # meth:
+    #    create_stack_set
+    #    update_stack_set
+    #    delete_stack_set
+    #
+    # instances_data:
+    #   [["112233445566", "us-west-1"], ["112233445566", "us-west-1"]]
+    #
+    def execute(meth, instances_data)
+      accounts = accounts_list(instances_data)
+      regions = regions_list(instances_data)
+      if accounts.empty? or regions.empty?
+        # puts "Cannot have one empty. accounts: #{accounts.size} regions: #{regions.size}. No executing #{meth}." # uncomment to debug
+        return # no  operation_id
+      end
+
+      options = {
+        stack_set_name: @stack,
+        accounts: accounts,
+        regions: regions,
+      }
+      options[:retain_stacks] = false if meth == :delete_stack_instances
+      puts <<~EOL
+        => Running #{meth} on:
+          accounts: #{accounts.join(',')}
+          regions: #{regions.join(',')}
+      EOL
+      resp = cfn.send(meth, options) # resp has resp[:operation_id]
+      operation_id = resp.operation_id
+
+      # Status tailing
+      o = @options.merge(
+        filter: instances_data,
+        operation_id: operation_id,
+        start_on_outdated: meth != :delete_stack_instances,
+      )
+      Lono::Sets::Status::Instance::Base.show_time_progress = true
+      Lono::Sets::Status::Instance::Base.delay_factor = accounts.size * regions.size
+      instances_status = Status.new(o)
+      final_status = meth == :delete_stack_instances ? "deleted" : "completed"
+      instances_status.run(to: final_status) unless @options[:noop] # returns success: true or false
+      operation_id
+    end
+
+    def accounts_list(instances_data)
+      instances_data.map { |a| a[0] }.sort.uniq
+    end
+
+    def regions_list(instances_data)
+      instances_data.map { |a| a[1] }.sort.uniq
+    end
+
+    # Override accounts and regions
+    def accounts
+      @options[:accounts] || lookup(:accounts)
+    end
+
+    def regions
+      @options[:regions] || lookup(:regions)
+    end
+
+    def lookup(config_type)
+      config_type = config_type.to_s
+      base_path = lookup_config_location(config_type, "base")
+      env_path = lookup_config_location(config_type, Lono.env)
+      items = load_config(base_path)
+      items += load_config(env_path)
+      items = items.sort.uniq
+      if config_type == :accounts
+        @accounts = items
+      else
+        @regions = items
+      end
+    end
+
+    def load_config(path)
+      return [] unless path
+
+      items = []
+      lines = IO.readlines(path)
+      lines.map do |l|
+        l = l.strip
+        l = l.sub(/ #.*/, '') # trailing comment
+        items << l unless l.empty? || l.match(/^\s*#/) # dont include empty linnks or commented lines
+      end
+      items
+    end
+
+    def lookup_config_location(config_type, env)
+      location = Lono::ConfigLocation.new(config_type, @options, env)
+      env == "base" ? location.lookup_base : location.lookup
+    end
+
+    def validate!
+      invalid = regions.blank? || accounts.blank?
+      if invalid
+        puts "ERROR: You must provide accounts and regions.".color(:red)
+        exit 1
+      end
+    end
+  end
+end

data/lib/lono/sets/list.rb

@@ -0,0 +1,35 @@
+require "text-table"
+
+class Lono::Sets
+  class List
+    include Lono::AwsServices
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def run
+      table = Text::Table.new
+      table.head = ["Stack Set Name", "Status"]
+      summaries = stack_sets_summaries
+      summaries.each do |s|
+        table.rows << [s.stack_set_name, s.status]
+      end
+      puts table
+    end
+
+  private
+    def stack_sets_summaries
+      next_token, summaries = :start, []
+      while next_token
+        o = {}
+        o[:next_token] = next_token unless next_token == :start or next_token.nil?
+        o[:status] = @options[:status].upcase if @options[:status] && @options[:status] != "all"
+        resp = cfn.list_stack_sets(o)
+        next_token = resp.next_token
+        summaries += resp.summaries
+      end
+      summaries
+    end
+  end
+end

data/lib/lono/sets/opts.rb

@@ -0,0 +1,18 @@
+class Lono::Sets
+  class Opts < Lono::Cfn::Opts
+    def deploy
+      super
+      operation_preferences_options
+    end
+
+    def operation_preferences_options
+      with_cli_scope do
+        option :region_order, type: :array, desc: "region_order"
+        option :failure_tolerance_count, type: :numeric, desc: "failure_tolerance_count"
+        option :failure_tolerance_percentage, type: :numeric, desc: "failure_tolerance_percentage"
+        option :max_concurrent_count, type: :numeric, desc: "max_concurrent_count"
+        option :max_concurrent_percentage, type: :numeric, desc: "max_concurrent_percentage"
+      end
+    end
+  end
+end

data/lib/lono/sets/preview/codediff.rb

@@ -0,0 +1,35 @@
+module Lono::Sets::Preview
+  class Codediff < Lono::Sets::Base
+    include Lono::Cfn::Preview::DiffViewer
+
+    def run
+      unless stack_set_exists?(@stack)
+        puts "WARN: Cannot create a diff for the stack set because the #{@stack} does not exists.".color(:yellow)
+        return
+      end
+
+      if @options[:noop]
+        puts "NOOP Generating CloudFormation source code diff..."
+      else
+        generate_all # from Base superclass. Generates the output lono teplates
+        puts "Generating CloudFormation source code diff..."
+        download_existing_cfn_template
+        show_diff(existing_template_path, new_cfn_template)
+      end
+    end
+
+    def download_existing_cfn_template
+      resp = cfn.describe_stack_set(stack_set_name: @stack)
+      IO.write(existing_template_path, resp.stack_set.template_body)
+    end
+
+    # for clarity
+    def new_cfn_template
+      template_path
+    end
+
+    def existing_template_path
+      "/tmp/existing_stack_set.yml"
+    end
+  end
+end