lono 7.5.2 → 8.0.0.pre.rc1

data/lib/lono/registration/check.rb

@@ -1,15 +0,0 @@
-# Incentive to register. Not meant for security.
-class Lono::Registration
-  class Check
-    extend Memoist
-
-    def initialize(options={})
-      @options = options
-    end
-
-    def check
-      return true if User.new(@options).check
-      Temp.new(@options).check
-    end
-  end
-end

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/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