lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/sets/status.rb

@@ -1,128 +0,0 @@
-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
-      Lono::Sets::Status::Instance::Base.show_time_progress = true
-      Lono::Sets::Status::Instance::Base.delay_factor = stack_instances.size
-
-      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
-      if summaries.empty?
-        puts "No stack operations have been done with this stack set. So there is no status to report."
-        return
-      end
-
-      display_one
-      o = @options.merge(show_time_spent: false)
-      instances_status = Lono::SetInstances::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::SetInstances::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
-      summaries.first.operation_id
-    end
-
-    def summaries
-      resp = cfn.list_stack_set_operations(
-        stack_set_name: @stack,
-        max_results: 1,
-      )
-      resp.summaries
-    end
-
-    def stack_instances
-      Lono::Sets::Status::Instances.new(@options).stack_instances
-    end
-    memoize :stack_instances
-  end
-end

data/lib/lono/sets/summarize.rb

@@ -1,22 +0,0 @@
-class Lono::Sets
-  module Summarize
-    include Lono::AwsServices
-
-    def summarize(operation_id)
-      puts "Stack Set Operation Summary:"
-      resp = cfn.list_stack_set_operation_results(stack_set_name: @stack, operation_id: operation_id)
-      resp.summaries.each do |s|
-        data = {
-          account: s.account,
-          region: s.region,
-          status: s.status,
-        }
-        data["status reason"] = s.status_reason if s.status_reason
-        message = data.inject("") do |text, (k,v)|
-          text += [k.to_s.color(:purple), v].join(" ") + " "
-        end
-        puts message
-      end
-    end
-  end
-end

data/lib/lono/sets/time_spent.rb

@@ -1,11 +0,0 @@
-class Lono::Sets
-  module TimeSpent
-    include Lono::Utils::PrettyTime
-
-    def show_time_spent(stack_set_operation)
-      seconds = stack_set_operation.end_timestamp - stack_set_operation.creation_timestamp
-      time_took = pretty_time(seconds).color(:green)
-      puts "Time took to complete stack set operation: #{time_took}"
-    end
-  end
-end

data/lib/lono/sets/update.rb

@@ -1,74 +0,0 @@
-class Lono::Sets
-  class Update < Base
-    include Summarize
-
-    def save
-      message = "Updating #{@stack} stack set"
-      if @options[:noop]
-        puts "NOOP #{message}"
-        return
-      end
-
-      unless stack_set_exists?(@stack)
-        puts "ERROR: Cannot update a stack set because #{@stack} does not exists.".color(:red)
-        return
-      end
-      exit_unless_updatable!
-
-      param_preview.run if @options[:param_preview]
-      codediff_preview.run if @options[:codediff_preview]
-      # changeset preview not supported for stack sets
-
-      options = build_options
-      show_options(options, "cfn.update_stack_set")
-
-      if stack_instances.empty?
-        puts <<~EOL
-          NOTE: There are 0 stack instances associated with the #{@stack} stack set.
-          Will update the stack set template but there no instances to be updated.
-
-          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
-      else
-        sure?("Are you sure you want to update the #{@stack} stack set?", long_desc)
-      end
-
-      resp = cfn.update_stack_set(options)
-
-      Lono::Sets::Waiter.new(@options).run(resp[:operation_id])
-    end
-
-    def stack_instances
-      Lono::Sets::Status::Instances.new(@options).stack_instances
-    end
-    memoize :stack_instances
-
-    def long_desc
-      info = stack_instances.inject({}) do |result, instance|
-        result[instance.account] ||= []
-        result[instance.account] << instance.region
-        result
-      end
-      message = "Will deploy to:\n"
-      info.each do |account, regions|
-        message << "  account: #{account}\n"
-        message << "  regions: #{regions.join(",")}\n"
-      end
-      message << "\nNumber of stack instances to be updated: #{stack_instances.size}"
-      message
-    end
-
-    def codediff_preview
-      Lono::Sets::Preview::Codediff.new(@options.merge(mute_params: true, mute_using: true))
-    end
-    memoize :codediff_preview
-
-    def param_preview
-      Lono::Sets::Preview::Param.new(@options)
-    end
-    memoize :param_preview
-  end
-end

data/lib/lono/sets/waiter.rb

@@ -1,23 +0,0 @@
-class Lono::Sets
-  class Waiter
-    include Lono::Sets::Summarize
-
-    def initialize(options)
-      @options = options
-      @stack = options[:stack]
-      @wait = @options[:wait].nil? ? true : @options[:wait]
-    end
-
-    def run(operation_id)
-      message = "Deploying #{@stack} stack set"
-      puts message unless @options[:mute]
-      return unless @wait
-
-      status = Status.new(@options.merge(operation_id: operation_id))
-      success = status.wait
-      summarize(operation_id)
-      exit 1 unless success
-      success
-    end
-  end
-end

data/lib/lono/sets.rb

@@ -1,34 +0,0 @@
-module Lono
-  class Sets < Command
-    opts = Opts.new(self)
-
-    desc "deploy STACK_SET", "Deploy CloudFormation stack set."
-    long_desc Help.text("sets/deploy")
-    opts.deploy
-    def deploy(stack)
-      Deploy.new(options.merge(stack: stack)).run
-    end
-
-    desc "status STACK_SET", "Show current status of stack set."
-    long_desc Help.text("sets/status")
-    def status(stack)
-      status = Status.new(@options.merge(stack: stack, delay_for_threads: false))
-      success = status.show
-      exit 3 unless success
-    end
-
-    desc "delete STACK_SET", "Delete CloudFormation stack set."
-    long_desc Lono::Help.text("sets/delete")
-    option :sure, type: :boolean, desc: "Skips are you sure prompt"
-    def delete(stack)
-      Delete.new(options.merge(stack: stack)).run
-    end
-
-    desc "list", "List CloudFormation stack sets."
-    long_desc Lono::Help.text("sets/list")
-    option :status, default: "active", desc: "active, all or deleted"
-    def list
-      List.new(options).run
-    end
-  end
-end

data/lib/lono/setting.rb

@@ -1,75 +0,0 @@
-require 'yaml'
-
-module Lono
-  class Setting
-    def initialize(check_lono_project=true)
-      @check_lono_project = check_lono_project
-    end
-
-    # data contains the settings.yml config.  The order or precedence for settings
-    # is the project lono/settings.yml and then the ~/.lono/settings.yml.
-    @@data = nil
-    def data
-      return @@data if @@data
-
-      project_settings_path = lookup_project_settings_path
-
-      # project based settings files
-      project = load_file(project_settings_path)
-
-      user_file = "#{ENV['HOME']}/.lono/settings.yml"
-      user = load_file(user_file)
-
-      default_file = File.expand_path("../default/settings.yml", __FILE__)
-      default = load_file(default_file)
-
-      all_envs = default.deep_merge(user.deep_merge(project))
-      all_envs = merge_base(all_envs)
-      @@data = all_envs[Lono.env] || all_envs["base"] || {}
-    end
-
-    def lookup_project_settings_path
-      standalone_path = "#{Lono.root}/config/settings.yml"
-      multimode_path = "#{Lono.root}/configs/settings.yml"
-      parent_multimode_path = "#{Lono.root}/../../configs/settings.yml"
-
-      settings_path = if File.exist?(standalone_path)
-                        standalone_path
-                      elsif File.exist?(multimode_path)
-                        multimode_path
-                      elsif File.exist?(parent_multimode_path)
-                        parent_multimode_path
-                      end
-
-      if @check_lono_project && !settings_path
-        puts "ERROR: No lono settings file found.  Are you sure you are in a project with lono setup?".color(:red)
-        exit 1
-      end
-
-      settings_path
-    end
-
-  private
-    def load_file(path)
-      return Hash.new({}) unless File.exist?(path)
-
-      content = RenderMePretty.result(path)
-      data = YAML.load(content) || {}
-      # If key is is accidentally set to nil it screws up the merge_base later.
-      # So ensure that all keys with nil value are set to {}
-      data.each do |lono_env, _setting|
-        data[lono_env] ||= {}
-      end
-      data
-    end
-
-    # automatically add base settings to the rest of the environments
-    def merge_base(all_envs)
-      base = all_envs["base"] || {}
-      all_envs.each do |lono_env, env_settings|
-        all_envs[lono_env] = base.merge(env_settings) unless lono_env == "base"
-      end
-      all_envs
-    end
-  end
-end

data/lib/lono/template/aws_service.rb

@@ -1,20 +0,0 @@
-require "aws-sdk-s3"
-
-module Lono::Template::AwsService
-  def s3
-    return @s3 if @s3
-
-    options = {}
-    # allow override of region for s3 client to avoid warning:
-    # S3 client configured for "us-east-1" but the bucket "xxx" is in "us-west-2"; Please configure the proper region to avoid multiple unnecessary redirects and signing attempts
-    # Example: endpoint: 'https://s3.us-west-2.amazonaws.com'
-    settings = Lono::Setting.new.data
-    endpoint = settings["s3_endpoint"]
-    endpoint = ENV['S3_ENDPOINT'] if ENV['S3_ENDPOINT']
-    options[:endpoint] = endpoint if endpoint
-    if options[:endpoint]
-      options[:region] = options[:endpoint].split('.')[1]
-    end
-    @s3 = Aws::S3::Client.new(options)
-  end
-end

data/lib/lono/template/bashify.rb

@@ -1,39 +0,0 @@
-require 'open-uri'
-
-class Lono::Template::Bashify
-  def initialize(options={})
-    @options = options
-    @path = options[:path]
-  end
-
-  def user_data_paths(data,path="")
-    paths = []
-    paths << path
-    data.each do |key,value|
-      if value.is_a?(Hash)
-        paths += user_data_paths(value,"#{path}/#{key}")
-      else
-        paths += ["#{path}/#{key}"]
-      end
-    end
-    paths.select {|p| p =~ /UserData/ && p =~ /Fn::Join/ }
-  end
-
-  def run
-    raw = open(@path).read
-    json = JSON.load(raw)
-    paths = user_data_paths(json)
-    if paths.empty?
-      puts "No UserData script found"
-      return
-    end
-    paths.each do |path|
-      puts "UserData script for #{path}:"
-      key = path.sub('/','').split("/").map {|x| "['#{x}']"}.join('')
-      user_data = eval("json#{key}")
-      delimiter = user_data[0]
-      script = user_data[1]
-      puts script.join(delimiter)
-    end
-  end
-end

data/lib/lono/template/configset_injector.rb

@@ -1,52 +0,0 @@
-class Lono::Template
-  class ConfigsetInjector < Lono::AbstractBase
-    def initialize(options={})
-      super
-    end
-
-    def run
-      @cfn = load_template # initial
-      @cfn = inject # overwrite
-      write(@cfn)
-      @cfn
-    end
-
-    def inject
-      metadata_map.each do |logical_id, metadata_configset|
-        resource = @cfn["Resources"][logical_id]
-
-        unless resource
-          puts "WARN: Resources.#{logical_id} not found in the template. Are you sure you are specifying the correct resource id in your configsets configs?".color(:yellow)
-          next
-        end
-
-        resource["Metadata"] ||= metadata_configset["Metadata"]
-
-        # metdata = resource["Metadata"] ||= {}
-        # metdata["AWS::CloudFormation::Init"] ||= {}
-        # # The metadata_configset has been combined with the original AWS::CloudFormation::Init if it exists
-        # metdata["AWS::CloudFormation::Init"] = metadata_configset["AWS::CloudFormation::Init"]
-      end
-
-      @cfn
-    end
-
-    def metadata_map
-      combiner = Lono::Configset::Combiner.new(@cfn, @options)
-      combiner.metadata_map
-    end
-    memoize :metadata_map
-
-    def write(cfn)
-      IO.write(template_path, YAML.dump(cfn))
-    end
-
-    def load_template
-      YAML.load_file(template_path)
-    end
-
-    def template_path
-      "#{Lono.config.output_path}/#{@blueprint}/templates/#{@template}.yml"
-    end
-  end
-end

data/lib/lono/template/context/loader/load_files.rb

@@ -1,24 +0,0 @@
-module Lono::Template::Context::Loader
-  module LoadFiles
-    # Load custom helper methods from project
-    def load_files(root)
-      paths = Dir.glob("#{root}/**/*.rb")
-      paths.sort_by! { |p| p.size } # so namespaces are loaded first
-      paths.each do |path|
-        # lib = gem extensions
-        # app = project extensions
-        filename = path.sub(%r{.*/lib/},'').sub(%r{.*/app/helpers/},'').sub('.rb','')
-        module_name = filename.camelize
-
-        # Prepend a period so require works LONO_ROOT is set to a relative path without a period.
-        #
-        # Example: LONO_ROOT=tmp/lono_project
-        first_char = path[0..0]
-        path = "./#{path}" unless %w[. /].include?(first_char)
-
-        require path
-        self.class.send :include, module_name.constantize
-      end
-    end
-  end
-end

data/lib/lono/template/context/loader.rb

@@ -1,52 +0,0 @@
-class Lono::Template::Context
-  module Loader
-    include LoadFiles
-
-    private
-    # Not using Lono::Template::Context because that works differently.
-    # That is used to load a context object that is passed to RenderMePretty's context.
-    # So that we can load context for params files and erb templates.
-    #
-    # In this case builder is actually the dsl context.
-    # We want to load variables and helpers into this builder context directly.
-    # This loads additional context. It looks very similar to Lono::Template::Context
-    def load_context
-      load_variables
-      load_helpers
-    end
-
-    # Variables in base.rb are overridden by their environment specific variables
-    # file.  Example, file LONO_ENV=development:
-    #
-    #   config/variables/base.rb
-    #   config/variables/development.rb - will override any variables in base.rb
-    #
-    def load_variables
-      options = ActiveSupport::HashWithIndifferentAccess.new(@options.dup)
-      options[:blueprint] = @blueprint
-      options[:stack] ||= @blueprint
-      layering = Lono::Layering.new("variables", options, Lono.env)
-      layering.locations.each do |path|
-        evaluate_variables_file(path)
-      end
-    end
-
-    # Load the variables defined in config/variables/* to make available in lono scope.
-    #
-    # NOTE: Was only able to make instance variables avaialble with instance_eval, wasnt able to make local variables
-    # available.
-    def evaluate_variables_file(path)
-      return unless File.exist?(path)
-      instance_eval(IO.read(path), path)
-    end
-
-    # Load custom helper methods from project
-    def load_helpers
-      load_project_helpers # project helpers will override extension helpers
-    end
-
-    def load_project_helpers
-      load_files(Lono.config.helpers_path)
-    end
-  end
-end

data/lib/lono/template/context.rb

@@ -1,29 +0,0 @@
-# Encapsulates helper methods and instance variables to be rendered in the ERB templates.
-class Lono::Template
-  class Context < Lono::AbstractBase
-    extend Memoist
-    include Lono::Template::Helper
-    include Loader
-    include Helpers # ERB
-    include Strategy::Dsl::Builder::Syntax # DSL
-
-    def initialize(options={})
-      super
-      load_context
-    end
-
-    # Take a hash and makes them instance variables in the current scope.
-    # Use this in custom helper methods to make variables accessible to ERB templates.
-    def instance_variables!(variables)
-      variables.each do |key, value|
-        instance_variable_set('@' + key.to_s, value)
-      end
-    end
-
-    # For Lono::AppFile::Build usage of Thor::Action directory
-    # For some reason a send(:binding) doesnt work but get_binding like this works.
-    def get_binding
-      binding
-    end
-  end
-end

data/lib/lono/template/evaluate.rb

@@ -1,40 +0,0 @@
-class Lono::Template
-  module Evaluate
-    def evaluate_template_path(path)
-      return unless File.exist?(path)
-
-      begin
-        instance_eval(File.read(path), path)
-      rescue Exception => e
-        template_evaluation_error(e)
-        puts "\nFull error:"
-        raise
-      end
-    end
-
-    # Prints out a user friendly task_definition error message
-    def template_evaluation_error(e)
-      lines = e.backtrace.reject { |l| l.include?("/lib/lono/") }
-      error_info = lines.first
-      path, line_no, _ = error_info.split(':')
-      line_no = line_no.to_i
-      puts "Error evaluating #{path}:".color(:red)
-      puts e.message
-      puts "Here's the line in #{path} with the error:\n\n"
-
-      contents = IO.read(path)
-      content_lines = contents.split("\n")
-      context = 5 # lines of context
-      top, bottom = [line_no-context-1, 0].max, line_no+context-1
-      spacing = content_lines.size.to_s.size
-      content_lines[top..bottom].each_with_index do |line_content, index|
-        line_number = top+index+1
-        if line_number == line_no
-          printf("%#{spacing}d %s\n".color(:red), line_number, line_content)
-        else
-          printf("%#{spacing}d %s\n", line_number, line_content)
-        end
-      end
-    end
-  end
-end

data/lib/lono/template/generator.rb

@@ -1,23 +0,0 @@
-require "yaml"
-
-class Lono::Template
-  class Generator < Lono::AbstractBase
-    def run
-      # Examples:
-      #   Erb.new(options).run
-      #   Dsl.new(options).run
-      generator_class = "Lono::Template::Strategy::#{lono_strategy.camelize}"
-      generator_class = Object.const_get(generator_class)
-      generator_class.new(@options).run # The generator strategy classes write templates to disk
-    end
-
-    def lono_strategy
-      if @options[:source]
-        "source"
-      else
-        jadespec = Lono::Jadespec.new(Lono.blueprint_root, "unknown") # abusing Jadespec to get lono_strategy
-        jadespec.lono_strategy
-      end
-    end
-  end
-end