lono 6.1.11 → 7.0.0

data/lib/lono/sets/summarize.rb

@@ -0,0 +1,20 @@
+class Lono::Sets
+  module Summarize
+    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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,81 @@
+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/template.rb

@@ -3,24 +3,22 @@ module Lono
     class_option :quiet, type: :boolean, desc: "silence the output"
     class_option :noop, type: :boolean, desc: "noop mode, do nothing destructive"
 
-    desc "generate", "Generate the CloudFormation templates"
+    desc "generate BLUEPRINT", "Generate the CloudFormation templates"
     long_desc Lono::Help.text("template/generate")
     option :clean, type: :boolean, desc: "remove all output files before generating"
-    def generate(blueprint=nil)
-      Blueprint::Find.one_or_all(blueprint).each do |b|
-        Generator.new(b, options).run
-      end
+    def generate(blueprint)
+      Generator.new(options.merge(blueprint: blueprint)).run
     end
 
     desc "upload", "Uploads templates to configured s3 folder"
     def upload(blueprint)
-      Upload.new(blueprint, options.clone).run
+      Upload.new(options.merge(blueprint: blueprint)).run
     end
 
     desc "bashify URL-OR-PATH", "Convert the UserData section of an existing CloudFormation Template to a starter bash script that is compatiable with lono"
     long_desc Lono::Help.text("template/bashify")
     def bashify(path)
-      Bashify.new(path: path).run
+      Bashify.new(options.merge(path: path)).run
     end
   end
 end

data/lib/lono/template/configset_injector.rb

@@ -0,0 +1,50 @@
+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
+
+        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.rb

@@ -1,14 +1,14 @@
 # Encapsulates helper methods and instance variables to be rendered in the ERB templates.
 class Lono::Template
-  class Context
+  class Context < Lono::AbstractBase
     extend Memoist
     include Lono::Template::Helper
     include Loader
     include Helpers # ERB
-    include Dsl::Builder::Syntax # DSL
+    include Strategy::Dsl::Builder::Syntax # DSL
 
-    def initialize(blueprint, options={})
-      @blueprint, @options = blueprint, options
+    def initialize(options={})
+      super
       load_variables
       load_project_helpers
     end

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

@@ -16,22 +16,10 @@ class Lono::Template::Context
       evaluate_variables_file(location.lookup) if location.lookup # config file
     end
 
-    # Load the variables defined in config/variables/* to make available in the
-    # template blocks in config/templates/*.
+    # Load the variables defined in config/variables/* to make available in lono scope.
     #
-    # Example:
-    #
-    #   `config/variables/base.rb`:
-    #     @foo = 123
-    #
-    #   `app/definitions/base.rb`:
-    #      template "mytemplate.yml" do
-    #        source "mytemplate.yml.erb"
-    #        variables(foo: @foo)
-    #      end
-    #
-    # NOTE: Only able to make instance variables avaialble with instance_eval,
-    #   wasnt able to make local variables available.
+    # 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)
@@ -54,4 +42,4 @@ class Lono::Template::Context
       end
     end
   end
-end
+end

data/lib/lono/template/evaluate.rb

@@ -14,7 +14,8 @@ class Lono::Template
 
     # Prints out a user friendly task_definition error message
     def template_evaluation_error(e)
-      error_info = e.backtrace.first
+      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)

data/lib/lono/template/generator.rb

@@ -1,29 +1,31 @@
 require "yaml"
 
 class Lono::Template
-  class Generator
-    include Lono::Blueprint::Root
-
-    def initialize(blueprint, options={})
-      @blueprint, @options = blueprint, ActiveSupport::HashWithIndifferentAccess.new(options.dup)
-      @template = @options[:template] || @blueprint
-      Lono::ProjectChecker.check
-      set_blueprint_root(@blueprint)
-    end
-
+  class Generator < Lono::AbstractBase
     def run
       # Examples:
       #   Erb.new(b, options.dup).run
       #   Dsl.new(b, options.dup).run
-      generator_class = "Lono::Template::#{template_type.classify}"
+      generator_class = "Lono::Template::Strategy::#{template_type.camelize}"
       generator_class = Object.const_get(generator_class)
-      generator_class.new(@blueprint, @options).run
+      generator_class.new(@options).run
+      # The generator strategy class writes template to disk. The inject_configsets reads it back from disk.
+      # Leaving as-is instead of reading all in memory in case there's a reason.
+      inject_configsets
     end
 
     def template_type
-      meta_config = "#{Lono.blueprint_root}/.meta/config.yml"
-      data = YAML.load_file(meta_config)
-      data["template_type"] || "dsl"
+      if @options[:source]
+        "source"
+      else
+        jadespec = Lono::Jadespec.new(Lono.blueprint_root, "unknown") # abusing Jadespec to get template_type
+        jadespec.template_type
+      end
+    end
+
+    def inject_configsets
+      Lono::Configset::Preparer.new(@options).run # register and materialize gems
+      ConfigsetInjector.new(@options).run
     end
   end
 end

data/lib/lono/template/helper.rb

@@ -41,27 +41,27 @@ BASH_CODE
   end
 
   def scripts_s3_path
-    upload = Lono::Script::Upload.new(@blueprint)
+    upload = Lono::Script::Upload.new(@options)
     upload.s3_dest
   end
 
   def template_s3_path(template_name)
     # high jacking Upload for useful s3_https_url method
     template_path = "output/#{@blueprint}/templates/#{template_name}.yml"
-    upload = Lono::Template::Upload.new(@blueprint, @options)
+    upload = Lono::Template::Upload.new(@options)
     upload.s3_https_url(template_path)
   end
 
   def template_params(param_name)
-    generator_options = {
+    o = {
       allow_not_exists: true
     }.merge(@options)
-    generator_options["param"] = param_name
-    generator = Lono::Param::Generator.new(@blueprint, generator_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
-    params = generator.params    # Returns Array in underscore keys format
+    parameters = generator.parameters    # Returns Array in underscore keys format
     # convert Array to simplified hash structure
-    params.inject({}) do |h, param|
+    parameters.inject({}) do |h, param|
       h.merge(param[:parameter_key] => param[:parameter_value])
     end
   end

data/lib/lono/template/post_processor.rb

@@ -1,15 +1,5 @@
 class Lono::Template
-  class PostProcessor
-    include Lono::Blueprint::Root
-    extend Memoist
-
-    def initialize(blueprint, options={})
-      @blueprint, @options = blueprint, options
-      @template = @options[:template] || @blueprint
-      Lono::ProjectChecker.check
-      set_blueprint_root(@blueprint)
-    end
-
+  class PostProcessor < Lono::AbstractBase
     def run
       replacements.each do |placeholder, replacement|
         update_template!(template)
@@ -18,7 +8,7 @@ class Lono::Template
     end
 
     def write_template!
-      IO.write(template_path, YAML.dump(template)) # unless ENV['TEST'] # additional safeguard for testing
+      IO.write(template_path, YAML.dump(template)) # unless ENV['LONO_TEST'] # additional safeguard for testing
     end
 
     def replacements

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

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

data/lib/lono/template/{dsl.rb → strategy/dsl.rb}

@@ -1,16 +1,14 @@
-class Lono::Template
+module Lono::Template::Strategy
   class Dsl < Base
     attr_reader :results
-    def initialize(blueprint, options={})
+    def initialize(options={})
       super
     end
 
     def run
       puts "Generating CloudFormation templates for blueprint #{@blueprint.color(:green)}:" unless @options[:quiet]
-      paths = Dir.glob("#{Lono.config.templates_path}/**/*.rb")
-      paths.select{ |e| File.file?(e) }.each do |path|
-        build_template(path)
-      end
+      template_path = "#{Lono.config.templates_path}/#{@template}.rb"
+      build_template(template_path)
     end
 
     def build_template(path)

data/lib/lono/template/{dsl → strategy/dsl}/builder.rb

@@ -1,4 +1,4 @@
-class Lono::Template::Dsl
+class Lono::Template::Strategy::Dsl
   class Builder
     include Lono::Template::Util
     include Lono::Template::Context::Loader
@@ -9,38 +9,34 @@ class Lono::Template::Dsl
     def initialize(path, blueprint, options={})
       @path, @blueprint, @options = path, blueprint, options
       @template = @path.sub("#{Lono.config.templates_path}/",'').sub(/\.rb$/,'')
+      @parameters = [] # registry
       @cfn = {}
     end
 
     def build
       load_context
       evaluate_template_path(@path) # modifies @cfn
-      build_template
+      finalize
+      to_yaml
       write_output
-      template
+      @cfn
     end
 
-    # Useful for lono seed to get the template in memory
-    def template
-      load_context
-      evaluate_template_path(@path) # modifies @cfn
-      @cfn
+    def finalize
+      o = @options.merge(parameters: @parameters)
+      @cfn = Finalizer.new(@cfn, o).run
     end
-    memoize :template
 
-    def build_template
+    def to_yaml
       @results = YAML.dump(@cfn)
     end
 
     def write_output
-      output_path = "#{Lono.config.output_path}/#{@blueprint}/templates"
-      FileUtils.mkdir_p(output_path)
-
-      path = "#{output_path}/#{@template}.yml"
+      path = "#{Lono.config.output_path}/#{@blueprint}/templates/#{@template}.yml"
       ensure_parent_dir(path)
       IO.write(path, @results)
 
-      validate_yaml(path)
+      Lono::Yamler::Validator.new(path).validate!
 
       unless @options[:quiet]
         pretty_path = path.sub("#{Lono.root}/",'')