lono 7.4.11 → 8.0.0.pre.rc1

data/lib/lono/sets/update.rb

@@ -1,81 +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.
-          Add `configs/#{@blueprint}/accounts` and `configs/#{@blueprint}/regions` settings
-          and use `lono sets instances sync` to add stack instances.
-        EOL
-      else
-        sure?("Are you sure you want to update the #{@stack} stack set?", long_desc)
-      end
-
-      resp = cfn.update_stack_set(options)
-      operation_id = resp[:operation_id]
-      puts message unless @options[:mute]
-
-      return true if @options[:noop] || !@options[:wait]
-
-      Lono::Sets::Status::Instance::Base.show_time_progress = true
-      Lono::Sets::Status::Instance::Base.delay_factor = stack_instances.size
-      status = Status.new(@options.merge(operation_id: operation_id))
-      success = status.wait
-      summarize(operation_id)
-      exit 1 unless success
-      success
-    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.rb

@@ -1,38 +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
-
-    desc "instances SUBCOMMAND", "instances subcommands"
-    long_desc Help.text("sets/instances")
-    subcommand "instances", Instances
-  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/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/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

data/lib/lono/template/helper.rb

@@ -1,152 +0,0 @@
-require "aws-sdk-core"
-
-# This is included into Lono::Template::Context.
-# It has access to the original thor CLI options via @options.
-#
-# @options gets passed into:
-#
-#   Lono::Template::Context.new(blueprint, @options)
-module Lono::Template::Helper
-  def template_s3_path(template_name)
-    # hi-jacking Uploader for https_url
-    template_path = "output/#{@blueprint}/templates/#{template_name}.yml"
-    Lono::S3::Uploader.new(template_path).s3_https_url
-  end
-
-  def template_params(param_name)
-    o = {
-      allow_not_exists: true
-    }.merge(@options)
-    o["param"] = param_name
-    generator = Lono::Param::Generator.new(o)
-    # do not generate because lono cfn calling logic already generated it we only need the values
-    parameters = generator.parameters    # Returns Array in underscore keys format
-    # convert Array to simplified hash structure
-    parameters.inject({}) do |h, param|
-      h.merge(param[:parameter_key] => param[:parameter_value])
-    end
-  end
-
-  # Adjust the partial path so that it will use app/user_data
-  def user_data(path,vars={}, options={})
-    options.merge!(user_data: true)
-    partial(path,vars, options)
-  end
-
-  # The partial's path is a relative path.
-  #
-  # Example:
-  # Given file in app/partials/iam/docker.yml
-  #
-  #   <%= partial("iam/docker", {}, indent: 10) %>
-  #   <%= partial("iam/docker.yml", {}, indent: 10) %>
-  #
-  # If the user specifies the extension then use that instead of auto-adding
-  # the detected format.
-  def partial(path,vars={}, options={})
-    path = options[:user_data] ?
-              user_data_path_for(path) :
-              partial_path_for(path)
-    path = auto_add_format(path)
-
-    instance_variables!(vars)
-    result = render_path(path)
-
-    result = indent(result, options[:indent]) if options[:indent]
-    result + "\n"
-  end
-
-  # add indentation
-  def indent(text, indentation_amount)
-    text.split("\n").map do |line|
-      " " * indentation_amount + line
-    end.join("\n")
-  end
-
-  def partial_exist?(path)
-    path = partial_path_for(path)
-    path = auto_add_format(path)
-    path && File.exist?(path)
-  end
-
-  def current_region
-    region = Aws.config[:region]
-    region ||= ENV['AWS_REGION']
-    return region if region
-
-    default_region = 'us-east-1' # fallback if default not found in ~/.aws/config
-    if ENV['AWS_PROFILE']
-      path = "#{ENV['HOME']}/.aws/config"
-      if File.exist?(path)
-        lines = IO.readlines(path)
-        capture_default, capture_current = false, false
-        lines.each do | line|
-          if line.include?('[default]')
-            capture_default = true # next line
-            next
-          end
-          if capture_default && line.match(/region = /)
-            # over default from above
-            default_region = line.split(' = ').last.strip
-            capture_default = false
-          end
-
-          md = line.match(/\[profile (.*)\]/)
-          if md && md[1] == ENV['AWS_PROFILE']
-            capture_current = true
-            next
-          end
-          if capture_current && line.match(/region = /)
-            region = line.split(' = ').last.strip
-            capture_current = false
-          end
-        end
-      end
-
-      region ||= default_region
-      return region if region
-    end
-
-    'us-east-1' # default
-  end
-
-private
-  def render_path(path)
-    RenderMePretty.result(path, context: self)
-  end
-
-  def user_data_path_for(path)
-    "#{Lono.config.user_data_path}/#{path}"
-  end
-
-  def partial_path_for(path)
-    "#{Lono.config.partials_path}/#{path}"
-  end
-
-  def auto_add_format(path)
-    # Return immediately if user provided explicit extension
-    extension = File.extname(path) # current extension
-    return path if !extension.empty?
-
-    # Else let's auto detect
-    paths = Dir.glob("#{path}.*")
-
-    if paths.size == 1 # non-ambiguous match
-      return paths.first
-    end
-
-    if paths.size > 1 # ambiguous match
-      puts "ERROR: Multiple possible partials found:".color(:red)
-      paths.each do |path|
-        puts "  #{path}"
-      end
-      puts "Please specify an extension in the name to remove the ambiguity.".color(:green)
-      exit 1
-    end
-
-    # Account for case when user wants to include a file with no extension at all
-    return path if File.exist?(path) && !File.directory?(path)
-
-    path # original path if this point is reached
-  end
-end

data/lib/lono/template/strategy/base.rb

@@ -1,4 +0,0 @@
-module Lono::Template::Strategy
-  class Base < Lono::AbstractBase
-  end
-end

data/lib/lono/template/strategy/common/helpers.rb

@@ -1,44 +0,0 @@
-module Lono::Template::Strategy::Common
-  module Helpers
-    # Bash code that is meant to included in user-data
-    def extract_scripts(options={})
-      settings = setting.data["extract_scripts"] || {}
-      options = settings.merge(options)
-      # defaults also here in case they are removed from settings
-      to = options[:to] || "/opt"
-      user = options[:as] || "ec2-user"
-
-      if Dir.glob("#{Lono.config.scripts_path}/*").empty?
-        puts "WARN: you are using the extract_scripts helper method but you do not have any app/scripts.".color(:yellow)
-        calling_line = caller[0].split(':')[0..1].join(':')
-        puts "Called from: #{calling_line}"
-        return ""
-      end
-
-      <<~BASH_CODE
-        # Generated from the lono extract_scripts helper.
-        # Downloads scripts from s3, extract them, and setup.
-        mkdir -p #{to}
-        aws s3 cp #{scripts_s3_path} #{to}/
-        (
-          cd #{to}
-          tar zxf #{to}/#{scripts_name}
-          chown -R #{user}:#{user} #{to}/scripts
-        )
-      BASH_CODE
-    end
-
-    def scripts_name
-      File.basename(scripts_s3_path)
-    end
-
-    def scripts_s3_path
-      upload = Lono::Script::Upload.new(@options)
-      upload.s3_dest
-    end
-
-    def setting
-      @setting ||= Lono::Setting.new
-    end
-  end
-end

data/lib/lono/template/strategy/dsl/builder/section/base.rb

@@ -1,30 +0,0 @@
-module Lono::Template::Strategy::Dsl::Builder::Section
-  class Base
-    include Lono::Template::Strategy::Dsl::Builder::Fn
-    include Lono::Template::Strategy::Dsl::Builder::Helpers
-    include Lono::Template::Strategy::Dsl::Builder::Stringify
-
-    def initialize(blueprint, *definition)
-      @blueprint = blueprint
-      @definition = definition.flatten
-    end
-
-  private
-    def camelize(attributes)
-      blueprint_meta = Lono::Blueprint::Meta.new(@blueprint)
-      target_section = self.class.to_s.split('::').last.underscore
-      # target_section: Lono::Template::Dsl::Builder::Parameter => parameter
-      data = if blueprint_meta.auto_camelize?(target_section)
-               CfnCamelizer.transform(attributes)
-             else
-               stringify!(attributes)
-             end
-      clean(data)
-    end
-
-    # Remove items with nil value automatically
-    def clean(data)
-      Lono::Template::Strategy::Dsl::Builder::Squeezer.new(data).squeeze
-    end
-  end
-end

data/lib/lono/template/strategy/dsl/builder.rb

@@ -1,59 +0,0 @@
-class Lono::Template::Strategy::Dsl
-  class Builder
-    include Lono::Template::Util
-    include Lono::Template::Context::Loader
-    include Lono::Extensions::Loader
-
-    include Syntax
-    extend Memoist
-
-    def initialize(options={})
-      @options = options
-      @stack, @blueprint, @template, @param = Lono::Conventions.new(options).values
-      @template_path = "#{Lono.config.templates_path}/#{@template}.rb"
-      @parameters = [] # registry
-      @cfn = {}
-    end
-
-    def build
-      load_extensions # load_extensions before project helpers
-      load_context # variables and project helpers
-      evaluate_template_path(@template_path) # modifies @cfn
-      finalize
-      to_yaml
-      write_output
-      @cfn
-    end
-
-    # load_extensions and evaluate extend_with methods earlier than load_context so project helpers can override extensions
-    def load_extensions # evaluates extend_with
-      Lono::Extensions::Preparer.new(@options).run
-      load_all_extension_helpers # after Extensions::Preparer#run
-    end
-
-    def finalize
-      o = @options.merge(parameters: @parameters)
-      @cfn = Finalizer.new(@cfn, o).run
-    end
-
-    def to_yaml
-      # https://stackoverflow.com/questions/24508364/how-to-emit-yaml-in-ruby-expanding-aliases
-      # Trick to prevent YAML from emitting aliases
-      @cfn = YAML.load(@cfn.to_json)
-      @results = YAML.dump(@cfn)
-    end
-
-    def write_output
-      path = "#{Lono.config.output_path}/#{@blueprint}/templates/#{@template}.yml"
-      ensure_parent_dir(path)
-      IO.write(path, @results)
-
-      Lono::Yamler::Validator.new(path).validate!
-
-      unless @options[:quiet]
-        pretty_path = path.sub("#{Lono.root}/",'')
-        puts "  #{pretty_path}"
-      end
-    end
-  end
-end

data/lib/lono/template/strategy/dsl.rb

@@ -1,14 +0,0 @@
-module Lono::Template::Strategy
-  class Dsl < Base
-    attr_reader :results
-    def run
-      puts "Generating CloudFormation templates for blueprint #{@blueprint.color(:green)}:" unless @options[:quiet]
-      build_template
-    end
-
-    def build_template
-      builder = Builder.new(@options)
-      builder.build
-    end
-  end
-end