lono 7.5.1 → 8.0.0.pre.rc2

data/lib/lono/set_instances/sync.rb

@@ -1,181 +0,0 @@
-class Lono::SetInstances
-  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
-      puts "DEPRECATED: The sync command is deprecated, in favor of the deploy command.".color(:yellow)
-      puts "Found more success with an explicit approach. sync may be removed in future versions of lono."
-
-      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,
-      )
-      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
-
-      items = []
-      layering = Lono::Layering.new(config_type, @options, Lono.env)
-      layering.locations.each do |path|
-        items += load_config(path)
-      end
-      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 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/set_instances/update.rb

@@ -1,15 +0,0 @@
-class Lono::SetInstances
-  class Update < Changeable
-    def perform(options)
-      cfn.update_stack_instances(options)
-    rescue Aws::CloudFormation::Errors::StackInstanceNotFoundException => e
-      puts "#{e.class}: #{e.message}".color(:red)
-      puts <<~EOL
-        One of the provided stack instance was not found. Unable to update the stack instances unless all stack instances
-        already exist. It may be helpful to check the StackSet console Instances Tab. You can also use the
-        `lono set_instances deploy` command instead.
-      EOL
-      exit 1
-    end
-  end
-end

data/lib/lono/set_instances.rb

@@ -1,54 +0,0 @@
-module Lono
-  class SetInstances < Lono::Command
-    opts = Opts.new(self)
-
-    desc "create STACK_SET", "Create CloudFormation stack set instances."
-    long_desc Lono::Help.text("set_instances/create")
-    opts.create
-    def create(stack)
-      Create.new(options.merge(stack: stack)).run
-    end
-
-    desc "update STACK_SET", "Update CloudFormation stack set instances."
-    long_desc Lono::Help.text("set_instances/update")
-    opts.update
-    def update(stack)
-      Update.new(options.merge(stack: stack)).run
-    end
-
-    desc "deploy STACK_SET", "Deploy CloudFormation stack set instances"
-    long_desc Lono::Help.text("set_instances/deploy")
-    opts.deploy
-    def deploy(stack)
-      Deploy.new(options.merge(stack: stack)).run
-    end
-
-    desc "delete STACK_SET", "Delete CloudFormation stack set instances."
-    long_desc Lono::Help.text("set_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("set_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("set_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("set_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/base.rb

@@ -1,50 +0,0 @@
-class Lono::Sets
-  class Base < Lono::Cfn::Base
-    def initialize(options={})
-      options[:iam] = true # easy to forget the --iam option. Default to turning it on for StackSets
-      super
-    end
-
-    def run
-      generate_all
-      save
-    end
-
-    def exit_unless_updatable!
-      return true if ENV['LONO_ENV']
-      return false if @options[:noop]
-
-      status = Status.new(@options) # using status for completed?
-      return if status.stack_instances.empty?
-      completed = status.completed?(status.stack_set_status)
-      unless completed
-        puts "Cannot update stack set because #{@stack} is not in an updatable state.  Stack set status: #{status.stack_set_status}".color(:red)
-        quit(1)
-      end
-    end
-
-    def build_options
-      parameters = generate_all
-      options = {
-        stack_set_name: @stack,
-        parameters: parameters,
-        capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
-      }
-      options[:tags] = tags unless tags.empty?
-      options[:operation_preferences] = operation_preferences unless operation_preferences.empty?
-      options.reject! {|k, v| v.nil? }
-      set_template_url!(options)
-      options
-    end
-
-    def operation_preferences
-      o = {}
-      o[:failure_tolerance_count] = @options[:failure_tolerance_count]
-      o[:failure_tolerance_percentage] = @options[:failure_tolerance_percentage]
-      o[:max_concurrent_count] = @options[:max_concurrent_count]
-      o[:max_concurrent_percentage] = @options[:max_concurrent_percentage]
-      o.reject! {|k, v| v.nil? }
-      o
-    end
-  end
-end

data/lib/lono/sets/create.rb

@@ -1,27 +0,0 @@
-class Lono::Sets
-  class Create < Base
-    def save
-      message = "Creating #{@stack.color(:green)} stack set."
-      if @options[:noop]
-        puts "NOOP #{message}"
-        return
-      end
-
-      if stack_set_exists?(@stack)
-        puts "Cannot create #{@stack.color(:green)} stack set because it already exists.".color(:red)
-        return
-      end
-
-      unless File.exist?(template_path)
-        puts "Cannot create #{@stack.color(:green)} template not found: #{template_path}."
-        return
-      end
-
-      options = build_options
-      show_options(options, "cfn.create_stack_set")
-      cfn.create_stack_set(options) # resp.stack_set_id => String. There is no resp.operation_id
-      puts message unless @options[:mute]
-      true # There is no resp.operation_id
-    end
-  end
-end

data/lib/lono/sets/delete.rb

@@ -1,43 +0,0 @@
-class Lono::Sets
-  class Delete
-    include Lono::AwsServices
-    include Lono::Sets::Summarize
-    include Lono::Utils::Sure
-
-    def initialize(options={})
-      @options = options
-      @stack = options[:stack]
-    end
-
-    def run
-      message = "Deleting #{@stack} stack set."
-      if @options[:noop]
-        puts "NOOP #{message}"
-      else
-        desc =<<~EOL
-          Be sure that the emptied StackSet instances is emptied first.
-          You can empty it with a separate command: lono set_instances delete #{@stack} --all
-          This command will only delete the StackSet itself after its been emptied.
-        EOL
-        sure?("Are you sure you want to delete the #{@stack} stack set?", desc)
-
-        if stack_set_exists?(@stack)
-          cfn.delete_stack_set(stack_set_name: @stack) # resp is an Empty structure, so must get operation_id from status
-          puts message
-        else
-          puts "#{@stack.inspect} stack set does not exist".color(:red)
-          return
-        end
-      end
-    rescue Aws::CloudFormation::Errors::StackSetNotEmptyException => e
-      puts "ERROR: #{e.class}: #{e.message}".color(:red)
-      puts <<~EOL
-        The stack set must be empty before deleting. Cannot delete stack set until all stack instances are first
-        deleted. If you want to delete all stack instances you can use:
-
-            lono set_instances delete #{@stack} --all
-
-      EOL
-    end
-  end
-end

data/lib/lono/sets/deploy.rb

@@ -1,11 +0,0 @@
-class Lono::Sets
-  class Deploy < Base
-    def run
-      if stack_set_exists?(@stack)
-        Update.new(@options).run
-      else
-        Create.new(@options).run
-      end
-    end
-  end
-end

data/lib/lono/sets/list.rb

@@ -1,35 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

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

@@ -1,32 +0,0 @@
-module Lono::Sets::Preview
-  # Inherits from Lono::Cfn::Preview::Param and override what's needed:
-  #
-  #      stack_parameters
-  #
-  class Param < Lono::Cfn::Preview::Param
-    def run
-      return unless stack_set_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
-
-      write_to_tmp(existing_path, existing_params)
-      write_to_tmp(new_path, new_params)
-
-      show_diff(existing_path, new_path)
-    end
-
-    def stack_parameters
-      stack_set_parameters
-    end
-
-    def stack_set_parameters
-      resp = cfn.describe_stack_set(stack_set_name: @stack)
-      resp.stack_set.parameters
-    end
-  end
-end

data/lib/lono/sets/status/instance/base.rb

@@ -1,120 +0,0 @@
-# The Completed and Deleted classes inherit from Base.
-# They implement `tail` and should not override `show`.
-#
-# They guarantee at least one status line is shown.
-# After which they start a thread that tails until a "terminal" status is detected. However, describe_stack_instance
-# resp.stack_instance.status returns:
-#
-#   CURRENT, OUTDATED, INOPERABLE
-#
-# There is no well-defined terminal status. For example, sometimes the terminal status is `CURRENT`, when the stack
-# instance updates successfully:
-#
-#   CURRENT -> OUTDATED -> CURRENT (terminal)
-#
-# But sometimes the terminal state is `OUTDATED`, when the stack instance fails to update:
-#
-#   CURRENT -> OUTDATED (terminal)
-#
-# Essentially, the `describe_stack_instance` resp does not provide enough information to determine the completion of
-# the `tail` logic.
-#
-# Hence the Completed and Deleted classes cannot be used to control the end of the polling loop. Instead, the calling
-# logic is responsible for and should control when to end the polling loop.
-#
-# Example in Lono::Sets::Status::Instances:
-#
-#   with_instances do |instance|
-#     Thread.new { instance.tail(to) }
-#   end.map(&:join)
-#   wait_until_stack_set_operation_complete
-#
-# The Instances logic waits on the operation results instead because its more accurate. We know from
-# `describe_stack_set_operation` when the status is actually complete. The describe_stack_set_operation
-# stack_set_operation.status is one of RUNNING, SUCCEEDED, FAILED, STOPPING, STOPPED.
-#
-# In this case, there are threads within threads. The first thread at the Instances level starts polling status
-# in parallel. The instance.tail delegates to the Completed and Deleted classes.
-#
-# Finally, the Completed and Deleted classes are designed to block with the first poll request. So it can show at
-# least one status line. Then it starts it's own thread to poll for more statuses.  Those latter statuses are not
-# guaranteed to be shown. This is the responsibility of the Instances class since it has the information required to
-# determine when to finish the polling loop.
-#
-class Lono::Sets::Status::Instance
-  class Base
-    include Lono::AwsServices
-
-    class_attribute :show_time_progress
-    class_attribute :delay_factor
-
-    def initialize(stack_instance)
-      @stack_instance = stack_instance
-      @shown = []
-      @output = "" # for say method and specs
-    end
-
-    def show_instance(stack_instance)
-      already_shown = @shown.detect do |o|
-        o[:account] == stack_instance[:account] &&
-        o[:region] == stack_instance[:region] &&
-        o[:status] == stack_instance[:status] &&
-        o[:status_reason] == stack_instance[:status_reason]
-      end
-      return if already_shown
-
-      s = stack_instance
-      say status_line(s.account, s.region, s.status, s.status_reason)
-    end
-
-    def show_time_progress
-      self.class.show_time_progress
-    end
-
-    def status_line(account, region, status, reason=nil)
-      time = Time.now.strftime("%F %I:%M:%S%p") if show_time_progress
-      items = [
-        time,
-        "Stack Instance:",
-        "account".color(:purple), account,
-        "region".color(:purple), region,
-        "status".color(:purple), status,
-      ]
-      items += ["reason".color(:purple), reason] if reason
-      items.compact.join(" ")
-    end
-
-    def say(text)
-      ENV["LONO_TEST"] ? @output << "#{text}\n" : puts(text)
-    end
-
-    def describe_stack_instance
-      retries = 0
-      begin
-        cfn.describe_stack_instance(
-          stack_instance_account: @stack_instance.account,
-          stack_instance_region: @stack_instance.region,
-          stack_set_name: @stack_instance.stack_set_id)
-      rescue Aws::CloudFormation::Errors::Throttling => e
-        retries += 1
-        delay = 2 ** retries
-        if ENV['LONO_DEBUG_THROTTLE']
-          puts "#{e.class}: #{e.message}"
-          puts "Backing off for #{delay}s and will retry"
-        end
-        sleep delay
-        retry
-      end
-    end
-
-    def delay
-      # delay factor based on number of stack instances
-      factor = self.class.delay_factor || 1
-      base = 4.5
-      delay = factor * base
-      delay = [delay, 30].min # limit the delay to a max
-      puts "Sleeping for #{delay}s..." if ENV['LONO_DEBUG_THROTTLE']
-      sleep delay
-    end
-  end
-end

data/lib/lono/sets/status/instance/completed.rb

@@ -1,35 +0,0 @@
-# Refer to Lono::Sets::Status::Instance::Base for more detailed docs.
-class Lono::Sets::Status::Instance
-  class Completed < Base
-    def tail
-      display_one
-      Thread.new do
-        loop!
-      end
-    end
-
-    def loop!
-      # resp.stack_instance.status : one of CURRENT, OUTDATED, INOPERABLE
-      status = nil
-      until completed?(status)
-        resp = display_one
-        status = resp.stack_instance.status
-        delay unless completed?(status)
-      end
-    end
-
-    def display_one
-      resp = describe_stack_instance
-      stack_instance = resp.stack_instance
-      show_instance(stack_instance)
-      @shown << stack_instance
-      resp
-    end
-
-    # status: one of CURRENT, OUTDATED, INOPERABLE
-    def completed?(status)
-      completed_statuses = %w[CURRENT INOPERABLE]
-      completed_statuses.include?(status)
-    end
-  end
-end