lono 7.4.11 → 8.0.0.pre.rc1

data/lib/lono/sets/instances.rb

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

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

@@ -1,32 +0,0 @@
-# Refer to Lono::Sets::Status::Instance::Base for more detailed docs.
-class Lono::Sets::Status::Instance
-  class Deleted < Base
-    def tail
-      display_one
-      Thread.new do
-        loop!
-      end
-    end
-
-    def loop!
-      # resp.stack_instance.status : one of CURRENT, OUTDATED, INOPERABLE
-      while true
-        begin
-          display_one
-        rescue Aws::CloudFormation::Errors::StackInstanceNotFoundException
-          say status_line(@stack_instance.account, @stack_instance.region, "DELETED")
-          break
-        end
-        delay
-      end
-    end
-
-    def display_one
-      resp = describe_stack_instance
-      stack_instance = resp.stack_instance
-      show_instance(stack_instance)
-      @shown << stack_instance
-      resp
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-class Lono::Sets::Status::Instance
-  class Show < Base
-    def run
-      show_instance(@stack_instance)
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-class Lono::Sets::Status
-  class Instance
-    def initialize(stack_instance)
-      @stack_instance = stack_instance
-    end
-
-    def tail(to="completed")
-      case to
-      when "completed"
-        Completed.new(@stack_instance).tail
-      when "deleted"
-        Deleted.new(@stack_instance).tail
-      end
-    end
-
-    def show
-      Show.new(@stack_instance).run
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-class Lono::Sets::Status
-  class Instances
-    include Lono::AwsServices
-    include Lono::Sets::TimeSpent
-
-    def initialize(options={})
-      @options = options
-      @stack, @operation_id = options[:stack], options[:operation_id]
-      @show_time_spent = options[:show_time_spent].nil? ? true : options[:show_time_spent]
-    end
-
-    def wait(to="completed")
-      puts "Stack Instance statuses... (takes a while)"
-      puts "You can check on the StackSetsole Operations Tab for the operation status."
-      wait_until_outdated if @options[:start_on_outdated]
-
-      threads = start_wait_for_instances_threads
-      wait_until_stack_set_operation_complete # start the the tailer here so the show_aws_cli_command shows up
-      threads.map(&:join)
-    end
-
-    def show
-      if stack_instances.empty?
-        # Note: no access to @blueprint here
-        puts <<~EOL
-          There are 0 stack instances associated with the #{@stack} stack set.  Add files
-          Add accounts and regions configs use `lono sets instances sync` to add stack instances.
-        EOL
-        return
-      end
-
-      threads = start_wait_for_instances_threads
-      wait_until_stack_set_operation_complete
-      threads.map(&:join)
-    end
-
-    def start_wait_for_instances_threads
-      # Tricky: extra sleep so that the show_aws_cli_command in wait_until_stack_set_operation_complete
-      # shows up first. Quickest way to implement.
-      with_instances do |instance|
-        Thread.new { sleep 5;  instance.show }
-      end
-    end
-
-    def with_instances
-      stack_instances.map do |stack_instance|
-        instance = Instance.new(stack_instance)
-        yield(instance)
-      end
-    end
-
-    def wait_until_stack_set_operation_complete
-      status, stack_set_operation = nil, nil
-      until completed?(status)
-        resp = cfn.describe_stack_set_operation(
-          stack_set_name: @stack,
-          operation_id: operation_id,
-        )
-        stack_set_operation = resp.stack_set_operation
-        status = stack_set_operation.status
-        show_aws_cli_command(stack_set_operation.operation_id)
-        # puts "DEBUG: wait_until_stack_set_operation_complete"
-        unless completed?(status)
-          sleep 5
-        end
-      end
-      if @show_time_spent # or else it double shows from `lono sets deploy`. Do want it to show for `lono sets instances sync` though
-        show_time_spent(stack_set_operation)
-        puts "Stack set operation completed."
-      end
-    end
-
-    @@aws_cli_command_shown = false
-    def show_aws_cli_command(operation_id)
-      return if @@aws_cli_command_shown
-
-      command = "aws cloudformation describe-stack-set-operation --stack-set-name #{@stack} --operation-id #{operation_id}"
-      puts <<~EOL
-        Here is also the cli command to check:
-
-            #{command}
-
-      EOL
-      @@aws_cli_command_shown = true
-    end
-
-    # describe_stack_set_operation stack_set_operation.status is
-    # one of RUNNING, SUCCEEDED, FAILED, STOPPING, STOPPED
-    def completed?(status)
-      completed_statuses = %w[SUCCEEDED FAILED STOPPED]
-      completed_statuses.include?(status)
-    end
-
-    # If we dont wait until OUTDATED, during a `lono sets deploy` it'll immediately think that the instance statuses are done
-    def wait_until_outdated
-      outdated = false
-      until outdated
-        outdated = stack_instances.detect { |stack_instance| stack_instance.status == "OUTDATED" }
-        sleep 5
-      end
-    end
-
-    def instances
-      stack_instances.map { |stack_instance| Instance.new(stack_instance) }
-    end
-
-    def stack_instances
-      resp = cfn.list_stack_instances(stack_set_name: @stack)
-      summaries = resp.summaries
-      # filter is really only used internally. So it's fine to keep it as complex data structure since that's what we
-      # build it up as in Lono::Sets::Instances::Deploy
-      filter = @options[:filter] # [["112233445566", "us-west-1"],["112233445566", "us-west-2"]]
-      return summaries unless filter
-
-      summaries.reject do |s|
-        intersect = [[s.account, s.region]] & filter
-        intersect.empty?
-      end
-    end
-
-    def operation_id
-      @operation_id ||= latest_operation_id
-    end
-
-    def latest_operation_id
-      resp = cfn.list_stack_set_operations(
-        stack_set_name: @stack,
-        max_results: 1,
-      )
-      resp.summaries.first.operation_id
-    end
-  end
-end

data/lib/lono/sets/status.rb

@@ -1,116 +0,0 @@
-class Lono::Sets
-  class Status
-    extend Memoist
-    include Lono::AwsServices
-    include Summarize
-    include TimeSpent
-
-    attr_reader :operation_id
-    def initialize(options={})
-      @options = options
-      @stack, @operation_id = options[:stack], options[:operation_id]
-      @shown = []
-      @output = "" # for say method and specs
-    end
-
-    def wait
-      status = nil
-      until completed?(status)
-        resp = display_one
-        stack_set_operation = resp.stack_set_operation
-        status = stack_set_operation.status
-        # always sleep delay even if completed to provide start_instances_status_waiter some extra time to complete
-        sleep 5
-        if completed?(status)
-          show_time_spent(stack_set_operation)
-        else
-          start_instances_status_waiter
-        end
-      end
-      status == "SUCCEEDED"
-    end
-
-    def display_one
-      resp = cfn.describe_stack_set_operation(
-        stack_set_name: @stack,
-        operation_id: operation_id,
-      )
-      stack_set_operation = resp.stack_set_operation
-      show_stack_set_operation(stack_set_operation)
-      @shown << stack_set_operation
-      resp
-    end
-
-    def show
-      display_one
-      o = @options.merge(show_time_spent: false)
-      instances_status = Lono::Sets::Instances::Status.new(o)
-      instances_status.run
-      summarize(operation_id)
-    end
-
-    @@instances_status_waiter_started = false
-    def start_instances_status_waiter
-      return if @@instances_status_waiter_started
-      if stack_instances.empty?
-        @@instances_status_waiter_started = true
-        return
-      end
-
-      Thread.new do
-        # show_time_spent because we already show it in this status class. Dont want it to show twice.
-        o = @options.merge(start_on_outdated: true, show_time_spent: false)
-        instances_status = Lono::Sets::Instances::Status.new(o)
-        instances_status.run
-      end
-      @@instances_status_waiter_started = true
-    end
-
-    def show_stack_set_operation(stack_set_operation)
-      already_shown = @shown.detect do |o|
-        o[:status] == stack_set_operation[:status]
-      end
-      return if already_shown
-
-      say "Stack Set Operation Status: #{stack_set_operation.status}"
-    end
-
-    def say(text)
-      ENV["LONO_TEST"] ? @output << "#{text}\n" : puts(text)
-    end
-
-    # describe_stack_set_operation stack_set_operation.status is
-    # one of RUNNING, SUCCEEDED, FAILED, STOPPING, STOPPED
-    def completed?(status)
-      completed_statuses = %w[SUCCEEDED FAILED STOPPED]
-      completed_statuses.include?(status)
-    end
-
-    def stack_set_status
-      resp = cfn.describe_stack_set_operation(
-        stack_set_name: @stack,
-        operation_id: operation_id,
-      )
-      # describe_stack_set_operation stack_set_operation.status is
-      # status one of RUNNING, SUCCEEDED, FAILED, STOPPING, STOPPED
-      resp.stack_set_operation.status
-    end
-
-    def operation_id
-      @operation_id ||= latest_operation_id
-    end
-
-    def latest_operation_id
-      resp = cfn.list_stack_set_operations(
-        stack_set_name: @stack,
-        max_results: 1,
-      )
-      resp.summaries.first.operation_id
-    end
-
-    def stack_instances
-      Lono::Sets::Status::Instances.new(@options).stack_instances
-    end
-    memoize :stack_instances
-  end
-end

data/lib/lono/sets/summarize.rb

@@ -1,20 +0,0 @@
-class Lono::Sets
-  module Summarize
-    def summarize(operation_id)
-      puts "Stack Set Operation Summary:"
-      resp = cfn.list_stack_set_operation_results(stack_set_name: @stack, operation_id: operation_id)
-      resp.summaries.each do |s|
-        data = {
-          account: s.account,
-          region: s.region,
-          status: s.status,
-        }
-        data["status reason"] = s.status_reason if s.status_reason
-        message = data.inject("") do |text, (k,v)|
-          text += [k.to_s.color(:purple), v].join(" ") + " "
-        end
-        puts message
-      end
-    end
-  end
-end

data/lib/lono/sets/time_spent.rb

@@ -1,11 +0,0 @@
-class Lono::Sets
-  module TimeSpent
-    include Lono::Utils::PrettyTime
-
-    def show_time_spent(stack_set_operation)
-      seconds = stack_set_operation.end_timestamp - stack_set_operation.creation_timestamp
-      time_took = pretty_time(seconds).color(:green)
-      puts "Time took to complete stack set operation: #{time_took}"
-    end
-  end
-end