lono 7.5.2 → 8.0.0.pre.rc3

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

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,136 +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 also check with StackSets console at the Operations Tab."
-      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.
-          Use `lono set_instances deploy` to add stack instances. Example:
-
-              lono set_instances deploy #{@stack} --accounts 111 --regions us-west-2 us-east-2
-
-        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 set_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::SetInstances::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