lono 6.1.11 → 7.0.0

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

@@ -0,0 +1,32 @@
+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.rb

@@ -0,0 +1,116 @@
+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/status/instance.rb

@@ -0,0 +1,20 @@
+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/instance/base.rb

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

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

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

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

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

@@ -0,0 +1,111 @@
+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)"
+      wait_until_outdated if @options[:start_on_outdated]
+
+      with_instances do |instance|
+        Thread.new { instance.tail(to) }
+      end.map(&:join)
+      wait_until_stack_set_operation_complete
+    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
+
+      with_instances do |instance|
+        Thread.new { instance.show }
+      end.map(&:join)
+      wait_until_stack_set_operation_complete
+    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
+        # 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
+
+    # 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