lono 7.4.11 → 8.0.0.pre.rc1

data/lib/lono/registration/temp.rb

@@ -1,53 +0,0 @@
-# Incentive to register. Not meant for security.
-class Lono::Registration
-  class Temp < Base
-    def check
-      info = read_registration
-      if info
-        resp = request_verification(info)
-        puts "request_verification resp #{resp.inspect}" if ENV['LONO_DEBUG_REGISTRATION']
-        # resp nil means non-200 http response. Failsafe behavior is to continue.
-        return true if resp.nil?
-      end
-
-      prompt unless resp && resp[:valid]
-      true
-    end
-
-    def read_registration
-      YAML.load_file(temp_path) if File.exist?(temp_path)
-    end
-
-    def prompt
-      return if ENV['LONO_TEST']
-
-      puts <<~EOL
-
-        Looks like lono is not registered. Lono registration is optional and free.
-        If you like lono though, please register to help support it. You can register at:
-
-            https://register.lono.cloud
-
-        This prompt appears every 24 hours when lono is not registered. Registration removes
-        this message. Registered users can also optionally receive updates and special offers,
-        including discounts to BoltOps Pro:
-
-            https://lono.cloud/docs/boltops-pro/
-
-      EOL
-
-      # resp nil means non-200 http response
-      resp = get_temp_key
-      save_temp_key(resp) unless resp.nil? # save temp key so prompt only happens periodically
-    end
-
-    def save_temp_key(info)
-      FileUtils.mkdir_p(File.dirname(temp_path))
-      IO.write(temp_path, YAML.dump(info.deep_stringify_keys))
-    end
-
-    def temp_path
-      "#{ENV['HOME']}/.lono/temp.yml"
-    end
-  end
-end

data/lib/lono/registration/user.rb

@@ -1,60 +0,0 @@
-class Lono::Registration
-  class User < Base
-    include Lono::Template::Context::Helpers # for ssm helper
-
-    def check
-      info = read_registration
-      unless info
-        say "Lono is not registered."
-        say "The .lono/registration.yml and ~/.lono/registration.yml file does not exist."
-        return false
-      end
-      unless info[:content].is_a?(Hash)
-        say "Lono is not registered."
-        say "#{info[:path]} does not have the right structure"
-        return false
-      end
-
-      @resp = request_verification(info[:content])
-      # A non-200 response means there was a non-200 http response. Failsafe behavior is to continue.
-      # Unless called from the cli: lono registration check
-      if @resp.nil?
-        if @options[:cli]
-          puts "There was an error with the API. Unable to confirm lono registration."
-          return false
-        else
-          return true
-        end
-      end
-
-      if @resp[:valid]
-        say "Lono registration looks good!"
-        return true
-      end
-
-      if @resp[:message]
-        say "Lono is not correctly registered. Unable to confirm info in #{info[:path]}"
-        say @resp[:message]
-      end
-      false
-    end
-
-    def read_registration
-      folders = [Lono.root, ENV['HOME']]
-      files = folders.map { |f| "#{f}/.lono/registration.yml" }
-      found = files.find do |path|
-        File.exist?(path)
-      end
-      return unless found
-
-      content = RenderMePretty.result(found, context: self)
-      if @options[:debug]
-        puts "Debug mode enabled. Here's the lono registration info being used:"
-        puts "Using: #{found}"
-        puts content
-        puts
-      end
-      {path: found, content: YAML.load(content)}
-    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/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,30 +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")
-
-      sure?("Are you sure you want to create the #{@stack} 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,52 +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.delete(: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 sets instances delete #{@stack} --all
-          This command will only delete the StackSet itself after it's 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 much get operation_id from status
-          puts message
-        else
-          puts "#{@stack.inspect} stack set does not exist".color(:red)
-          return
-        end
-      end
-
-      return true if @options[:noop] || !@options[:wait]
-
-      status = Status.new(@options)
-      success = status.wait
-      operation_id = status.operation_id # getting operation_id from status because cfn.delete_stack_set resp is an Empty structure
-      summarize(operation_id)
-      exit 1 unless success
-
-    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 sets 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/instances/base.rb

@@ -1,30 +0,0 @@
-class Lono::Sets::Instances
-  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/sets/instances/delete.rb

@@ -1,69 +0,0 @@
-class Lono::Sets::Instances
-  class Delete < Base
-    include Lono::AwsServices
-    include Lono::Utils::Sure
-
-    def initialize(options={})
-      @options = options
-      @stack = options[:stack]
-    end
-
-    def run
-      validate!
-
-      sure?("Are you sure you want to delete the #{@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.
-      resp = cfn.delete_stack_instances(
-        options = {
-          stack_set_name: @stack,
-          accounts: accounts,
-          regions: regions,
-          retain_stacks: false,
-        }
-      )
-      operation_id = resp.operation_id
-
-      # Status tailing handled by caller
-      o = @options.merge(
-        filter: requested,
-        start_on_outdated: false,
-        operation_id: operation_id,
-      )
-      Lono::Sets::Status::Instance::Base.show_time_progress = true
-      Lono::Sets::Status::Instance::Base.delay_factor = accounts.size * regions.size
-      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
-
-    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/sets/instances/list.rb

@@ -1,13 +0,0 @@
-class Lono::Sets::Instances
-  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/sets/instances/opts.rb

@@ -1,29 +0,0 @@
-class Lono::Sets::Instances
-  class Opts < Lono::Sets::Opts
-    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/sets/instances/status.rb

@@ -1,12 +0,0 @@
-class Lono::Sets::Instances
-  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/sets/instances/sync.rb

@@ -1,180 +0,0 @@
-class Lono::Sets::Instances
-  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
-      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,
-      )
-      Lono::Sets::Status::Instance::Base.show_time_progress = true
-      Lono::Sets::Status::Instance::Base.delay_factor = accounts.size * regions.size
-      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