lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/seed/base.rb

@@ -1,116 +0,0 @@
-require "fileutils"
-require "memoist"
-require "thor"
-require "yaml"
-
-# Subclasses should implement:
-#
-#   variables - Returns String with content of varibles files.
-#   setup - Hook to do extra things like create IAM service roles.
-#   finish - Finish hook after config files have been created.
-#
-# Note there is no params method to hook. The Base class handles params well.
-#
-class Lono::Seed
-  class Base < Lono::AbstractBase
-    include Lono::AwsServices
-    include ServiceRole
-
-    # What's needed for a Thor::Group or "Sequence"
-    # Gives us Thor::Actions commands like create_file
-    include Thor::Actions
-    include Thor::Base
-    # Override Thor::Base initialize
-    def initialize(options={})
-      reinitialize(options)
-    end
-
-    extend Memoist
-
-    def run
-      generate_template
-      setup
-      self.destination_root = Dir.pwd # Thor::Actions require destination_root to be set
-      create_params
-      create_variables
-      finish
-    end
-
-    def generate_template
-      Lono::Template::Generator.new(@options).run
-    end
-
-    def create_params
-      return unless params
-      create_param_file
-    end
-
-    def create_param_file
-      @output_template = Lono::Output::Template.new(@blueprint, @template)
-      if @output_template.parameters.empty?
-        puts "Template has no parameters."
-        return
-      end
-
-      # Generate by parameter group first
-      lines, shown = [], []
-      @output_template.parameter_groups.each do |label, parameters|
-        lines << "# Parameter Group: #{label}"
-        parameters.each do |name|
-          parameter_line = parameter_line(name)
-          lines << parameter_line unless lines.include?(parameter_line)
-          shown << name
-        end
-        lines << ""
-      end if @output_template.parameter_groups
-
-      # Then generate the rest
-      @output_template.parameters.each do |name, data|
-        lines << parameter_line(name) unless shown.include?(name)
-      end
-
-      content = lines.join("\n")
-      dest_path = "configs/#{@blueprint}/params/#{Lono.env}.txt" # only support environment level parameters for now
-      create_file(dest_path, content) # Thor::Action
-    end
-
-    def parameter_line(name)
-      data = @output_template.parameters[name]
-      example = description_example(data["Description"])
-      if data["Default"].nil?
-        line = "#{name}=#{example} # (required)"
-      else
-        default = data["Default"]
-        line = "# #{name}=#{default}"
-        line = "#{line} # #{example}" if example
-      end
-      line
-    end
-
-    def description_example(description)
-      return unless description
-      md = description.match(/(Example|IE): (.*)/)
-      return unless md
-      md[2]
-    end
-
-    def params
-      true
-    end
-
-    def create_variables
-      return unless variables
-      dest_path = "configs/#{@blueprint}/variables/#{Lono.env}.rb"
-      create_file(dest_path, variables) # Thor::Action
-    end
-
-    def setup; end
-    def finish; end
-
-    # Meant to be overriden by subclass
-    # Return String with contents of variables file.
-    def variables
-      false
-    end
-  end
-end

data/lib/lono/seed/service_role.rb

@@ -1,11 +0,0 @@
-class Lono::Seed
-  module ServiceRole
-    def create_service_linked_role(aws_service_name)
-      iam.create_service_linked_role(
-        aws_service_name: aws_service_name
-      )
-    rescue Aws::IAM::Errors::InvalidInput # already exist
-      raise if ENV['LONO_DEBUG_SEED']
-    end
-  end
-end

data/lib/lono/seed.rb

@@ -1,39 +0,0 @@
-module Lono
-  class Seed < AbstractBase
-    def create
-      puts "Creating starter config files for #{@blueprint}"
-      configs_class = load_configs_class # ::Configs or Lono::Seed::Base
-      configs = configs_class.new(@options)
-      # The Configs class implements: variables
-      configs.run # setup the instance variables
-    end
-
-  private
-    def load_configs_class
-      blueprint_root = find_blueprint_root(@blueprint)
-      configs_path = "#{blueprint_root}/seed/configs.rb"
-
-      begin
-        loaded = load configs_path
-      rescue LoadError
-        loaded = false
-      end
-
-      if loaded
-        if defined?(Lono::Seed::Configs)
-          configs_class = Lono::Seed::Configs # blueprint specific Configs
-        else
-          puts <<~EOL
-            Lono::Seed::Configs class not found.
-            Are you sure #{configs_path} contains a Lono::Seed::Configs class?
-          EOL
-          exit 1
-        end
-      else
-        configs_class = Lono::Seed::Base # Generic handling
-      end
-
-      configs_class
-    end
-  end
-end

data/lib/lono/sequence.rb

@@ -1,35 +0,0 @@
-require 'fileutils'
-require 'active_support/core_ext/string'
-require 'thor'
-require 'bundler'
-
-class Lono::Sequence < Thor::Group
-  include Thor::Actions
-
-  def self.source_root
-    File.expand_path("../templates/skeleton", File.dirname(__FILE__))
-  end
-
-private
-  def git_installed?
-    system("type git > /dev/null 2>&1")
-  end
-
-  def run_git?
-    options[:git] && git_installed?
-  end
-
-  def run_git_init
-    return unless run_git?
-    puts "=> Initialize git repo"
-    run("git init")
-  end
-
-  def run_git_commit
-    return unless run_git?
-
-    puts "=> Commit git repo"
-    run("git add .")
-    run("git commit -m 'first commit'")
-  end
-end

data/lib/lono/set_instances/base.rb

@@ -1,30 +0,0 @@
-class Lono::SetInstances
-  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/set_instances/changeable.rb

@@ -1,53 +0,0 @@
-class Lono::SetInstances
-  class Changeable < Base
-    include Lono::AwsServices
-    include Lono::Utils::Sure
-
-    def initialize(options={})
-      super # need conventions so config lookup will work
-      @regions, @accounts = [], []
-    end
-
-    def run
-      validate!
-
-      unless stack_set_exists?(@stack)
-        puts "ERROR: Cannot update a stack set because #{@stack} does not exists.".color(:red)
-        return
-      end
-      exit_unless_updatable!
-
-      options = {
-        stack_set_name: @stack,
-        accounts: accounts,
-        regions: regions,
-      }
-      begin
-        resp = perform(options)
-      rescue Aws::CloudFormation::Errors::ValidationError => e
-        # IE: Aws::CloudFormation::Errors::ValidationError: Region eu-north-1 is not supported
-        puts "#{e.class}: #{e.message}".color(:red)
-        exit 1
-      end
-
-      return true if @options[:noop]
-      Lono::Sets::Waiter.new(@options).run(resp[:operation_id])
-    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/set_instances/create.rb

@@ -1,7 +0,0 @@
-class Lono::SetInstances
-  class Create < Changeable
-    def perform(options)
-      cfn.create_stack_instances(options)
-    end
-  end
-end

data/lib/lono/set_instances/delete.rb

@@ -1,47 +0,0 @@
-class Lono::SetInstances
-  class Delete < Changeable
-    def initialize(options={})
-      super
-      @stack = options[:stack]
-    end
-
-    def run
-      validate!
-
-      sure?("Are you sure you want to delete the #{@stack} 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.
-      retain_stacks = @options[:retain_stacks] ? @options[:retain_stacks] : false
-      resp = cfn.delete_stack_instances(
-        stack_set_name: @stack,
-        accounts: accounts,
-        regions: regions,
-        retain_stacks: retain_stacks,
-      )
-      operation_id = resp.operation_id
-
-      # Status tailing handled by caller
-      o = @options.merge(
-        filter: requested,
-        start_on_outdated: false,
-        operation_id: operation_id,
-      )
-      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
-  end
-end

data/lib/lono/set_instances/deploy.rb

@@ -1,52 +0,0 @@
-class Lono::SetInstances
-  class Deploy < Changeable
-    def run
-      # computes whether create or update should be ran for stack instances within each account
-      updates, creates = Hash.new([]), Hash.new([])
-      accounts.each do |account|
-        regions.each do |region|
-          if stack_instance_exists?(account, region)
-            updates[account] += [region] # += [item] works, << item doesnt seem to work
-          else
-            creates[account] += [region] # += [item] works, << item doesnt seem to work
-          end
-        end
-      end
-
-      deploy(:create, creates)
-      deploy(:update, updates)
-    end
-
-    def deploy(type, changes)
-      changes.each do |account, regions|
-        run_action(type, account, regions)
-      end
-    end
-
-    def run_action(type, account, regions)
-      klass = "Lono::SetInstances::#{type.to_s.camelize}"
-      klass = klass.constantize
-      command = lono_command(klass)
-      puts "Running #{command.color(:green)} on account: #{account} regions: #{regions.join(',')}"
-
-      options = @options.dup
-      options[:accounts] = [account]
-      options[:regions] = regions
-      klass.new(options).run
-    end
-
-    def lono_command(klass)
-      klass = klass.to_s
-      klass.split('::').map(&:underscore).join(' ')
-    end
-
-    def stack_instance_exists?(account, region)
-      existing = stack_instances.map do |summary|
-        [summary.account, summary.region]
-      end
-      intersect = existing & [[account, region]]
-      !intersect.empty?
-    end
-
-  end
-end

data/lib/lono/set_instances/list.rb

@@ -1,13 +0,0 @@
-class Lono::SetInstances
-  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/set_instances/opts.rb

@@ -1,37 +0,0 @@
-class Lono::SetInstances
-  class Opts < Lono::Sets::Opts
-    def update
-      delete
-    end
-
-    def create
-      delete
-    end
-
-    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/set_instances/status.rb

@@ -1,12 +0,0 @@
-class Lono::SetInstances
-  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/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