lono 7.5.2 → 8.0.0.pre.rc3

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

@@ -1,10 +1,11 @@
-module Lono::Template::Strategy::Dsl::Builder::Helpers
-  module StackHelper
+module Lono::Builder::Dsl::Helpers
+  module Stack
     extend Memoist
     include Lono::AwsServices
 
     def stack_output(name)
       stack_name, key = name.split(".")
+      stack_name = stack_name(stack_name)
       resp = describe_stacks(stack_name: stack_name)
       stack = resp.stacks.first
       if stack
@@ -14,27 +15,31 @@ module Lono::Template::Strategy::Dsl::Builder::Helpers
       if o
         o.output_value
       else
-        "NOT FOUND: output #{key} for stack #{stack_name}"
+        logger.info "WARN2: NOT FOUND: output #{key} for stack #{stack_name}"
+        nil
       end
     end
 
     def stack_resource(name)
       stack_name, logical_id = name.split(".")
+      stack_name = stack_name(stack_name)
       resp = describe_stack_resources(stack_name: stack_name)
       resources = resp.stack_resources
       resource = resources.find { |r| r.logical_resource_id == logical_id }
       if resource
         resource.physical_resource_id
       else
-        "NOT FOUND: logical_id #{logical_id} for stack #{stack_name}"
+        logger.info "WARN: NOT FOUND: logical_id #{logical_id} for stack #{stack_name}"
+        nil
       end
     end
 
-    def lookup_output(name)
-      result = stack_output(name)
-      return unless ENV['LONO_DEPRECATION_SOFT']
-      puts "DEPRECATION WARNING: lookup_output is deprecated. Please use stack_output instead".color(:yellow)
-      result
+    def stack_name(blueprint)
+      return blueprint unless Lono.config.names.output.expand
+      names = Lono::Names.new(blueprint: blueprint)
+      # explicit expansion pattern provided by user
+      pattern = blueprint.include?(':') ? blueprint : Lono.config.names.output.stack
+      names.expansion(pattern)
     end
 
   private

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

@@ -1,5 +1,5 @@
-module Lono::Template::Strategy::Dsl::Builder::Helpers
-  module TagsHelper
+module Lono::Builder::Dsl::Helpers
+  module Tags
     def tags(hash={})
       if hash.empty?
         tag_list(@tags) if @tags # when hash is empty, use @tags variable. If not set then return nil

data/lib/lono/builder/dsl/helpers/template_file.rb

@@ -0,0 +1,66 @@
+module Lono::Builder::Dsl::Helpers
+  module TemplateFile
+    extend Memoist
+    include Lono::Utils::Pretty
+
+    def template_file(path)
+      path = "#{@blueprint.root}/#{path}"
+      if File.exist?(path)
+        render_file(path)
+      else
+        template_file_missing(path)
+      end
+    end
+    # do not memoize :template_file - it'll hide the template_file_missing error
+
+    # Caller lines are different for OSes:
+    #
+    #   windows: "C:/Ruby31-x64/lib/ruby/gems/3.1.0/gems/lono-1.1.1/lib/lono/builder.rb:34:in `build'"
+    #   linux: "/home/ec2-user/.rvm/gems/ruby-3.0.3/gems/lono-1.1.1/lib/lono/compiler/dsl/syntax/mod.rb:4:in `<module:Mod>'"
+    #
+    class TempleFileNotFoundError < StandardError; end
+    def template_file_missing(path)
+      message = "ERROR: path #{pretty_path(path)} not found"
+      caller_line = caller.find { |l| l =~ %r{/blueprints/} } # TODO: show code itself
+      logger.error message.color(:red)
+      logger.error "Called from:"
+      logger.error "    #{pretty_path(caller_line)}"
+      # Raise an error so Dsl::Evaluator#template_evaluation_error provides user friendly info
+      raise TempleFileNotFoundError.new
+    end
+
+    def render_file(path)
+      if File.exist?(path)
+        RenderMePretty.result(path, context: self)
+      else
+        lines = caller.select { |l| l.include?(Lono.root.to_s) } # TODO: show code itself
+        caller_line = pretty_path(lines.first)
+        message =<<~EOL
+          WARN: #{pretty_path(path)} does not exist
+          Called from: #{caller_line}
+        EOL
+        logger.info message.color(:yellow)
+        message
+      end
+    end
+    alias_method :render_path, :render_file
+
+    def user_data_script
+      unless @user_data_script
+        script_example = pretty_path("#{@blueprint.root}/template/user_data.sh")
+        return <<~EOL
+          # @user_data_script variable not set. IE: @user_data_script = "#{script_example}"
+          # Also, make sure that "#{script_example}" exists.
+        EOL
+      end
+
+      if File.exist?(@user_data_script)
+        render_file(@user_data_script)
+      else
+        message = "WARN: #{@user_data_script} not found"
+        logger.info message.color(:yellow)
+        "# #{message}"
+      end
+    end
+  end
+end

data/lib/lono/builder/dsl/helpers.rb

@@ -0,0 +1,5 @@
+class Lono::Builder::Dsl
+  module Helpers
+    include_modules("helpers")
+  end
+end

data/lib/lono/builder/dsl/syntax/core/base.rb

@@ -0,0 +1,22 @@
+module Lono::Builder::Dsl::Syntax::Core
+  class Base
+    include Lono::Builder::Util::Stringify
+    include Lono::Builder::Dsl::Syntax::Fn
+
+    def initialize(blueprint, *definition)
+      @blueprint = blueprint
+      @definition = definition.flatten
+    end
+
+  private
+    def camelize(attributes)
+      data = stringify!(attributes)
+      clean(data)
+    end
+
+    # Remove items with nil value automatically
+    def clean(data)
+      Squeezer.new(data).squeeze
+    end
+  end
+end

data/lib/lono/{template/strategy/dsl/builder/section → builder/dsl/syntax/core}/condition.rb

@@ -2,7 +2,7 @@
 #
 #   template - uses @definition to build a CloudFormation template section
 #
-module Lono::Template::Strategy::Dsl::Builder::Section
+module Lono::Builder::Dsl::Syntax::Core
   class Condition < Base
     def template
       camelize(standarize(@definition))

data/lib/lono/{template/strategy/dsl/builder/section → builder/dsl/syntax/core}/mapping.rb

@@ -2,7 +2,7 @@
 #
 #   template - uses @definition to build a CloudFormation template section
 #
-module Lono::Template::Strategy::Dsl::Builder::Section
+module Lono::Builder::Dsl::Syntax::Core
   class Mapping < Base
     def template
       camelize(standarize(@definition))

data/lib/lono/{template/strategy/dsl/builder/section → builder/dsl/syntax/core}/output.rb

@@ -2,7 +2,7 @@
 #
 #   template - uses @definition to build a CloudFormation template section
 #
-module Lono::Template::Strategy::Dsl::Builder::Section
+module Lono::Builder::Dsl::Syntax::Core
   class Output < Base
     def template
       camelize(standarize(@definition))

data/lib/lono/{template/strategy/dsl/builder/section → builder/dsl/syntax/core}/parameter.rb

@@ -2,7 +2,7 @@
 #
 #   template - uses @definition to build a CloudFormation template section
 #
-module Lono::Template::Strategy::Dsl::Builder::Section
+module Lono::Builder::Dsl::Syntax::Core
   class Parameter < Base
     attr_accessor :group_label
     attr_reader :conditional, :label

data/lib/lono/{template/strategy/dsl/builder/section → builder/dsl/syntax/core}/resource/property_mover.rb

@@ -1,12 +1,22 @@
-class Lono::Template::Strategy::Dsl::Builder::Section::Resource
+class Lono::Builder::Dsl::Syntax::Core::Resource
   # Moves the property to the top-level attributes *destructively*
   class PropertyMover
     def initialize(resource, logical_id, properties)
       @resource, @logical_id, @properties = resource, logical_id, properties
     end
 
+    # AWS Docs: Resource attribute reference
+    # https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html
     def move!
-      %w[Condition DeletionPolicy DependsOn].each do |attribute_name|
+      %w[
+        Condition
+        CreationPolicy
+        DeletionPolicy
+        DependsOn
+        Metadata
+        UpdatePolicy
+        UpdateReplacePolicy
+      ].each do |attribute_name|
         # Account for camelize, underscore, String, and Symbol
         move(attribute_name.to_sym)
         move(attribute_name.camelize.to_sym)

data/lib/lono/{template/strategy/dsl/builder/section → builder/dsl/syntax/core}/resource.rb

@@ -2,7 +2,7 @@
 #
 #   template - uses @definition to build a CloudFormation template section
 #
-module Lono::Template::Strategy::Dsl::Builder::Section
+module Lono::Builder::Dsl::Syntax::Core
   class Resource < Base
     def template
       camelize(standarize(@definition))

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

@@ -2,7 +2,7 @@
 #
 #   template - uses @definition to build a CloudFormation template section
 #
-module Lono::Template::Strategy::Dsl::Builder::Section
+module Lono::Builder::Dsl::Syntax::Core
   class Section < Base
     def template
       hash, _ = @definition

data/lib/lono/builder/dsl/syntax/core/squeezer.rb

@@ -0,0 +1,38 @@
+module Lono::Builder::Dsl::Syntax::Core
+  class Squeezer
+    def initialize(data)
+      @data = data
+    end
+
+    def squeeze(new_data=nil, previous_key=nil)
+      data = new_data.nil? ? @data : new_data
+
+      case data
+      when Array
+        data.map! { |v| squeeze(v) }
+      when Hash
+        data.each_with_object({}) do |(k,v), squeezed|
+          # only remove nil and empty Array values within Hash structures
+          squeezed[k] = squeeze(v, k) unless v.nil? # || empty_array?(v, previous_key)
+          squeezed
+        end
+      else
+        data # do not transform
+      end
+    end
+
+    # Special case do not squeeze empty Array when previous_key is "yum". Handles:
+    #
+    #   Metadata:
+    #     AWS::CloudFormation::Init:
+    #       config:
+    #         packages:
+    #           yum:
+    #             httpd: []
+    #
+    def empty_array?(v, previous_key)
+      return false if previous_key.to_s == "yum"
+      v.is_a?(Array) && v.empty?
+    end
+  end
+end

data/lib/lono/{template/strategy/dsl/builder/section/methods.rb → builder/dsl/syntax/core.rb}

@@ -1,6 +1,6 @@
 # Organize core section method syntax here
-module Lono::Template::Strategy::Dsl::Builder::Section
-  module Methods
+module Lono::Builder::Dsl::Syntax
+  module Core
     def aws_template_format_version(version_date)
       @cfn["AWSTemplateFormatVersion"] = version_date
     end
@@ -20,7 +20,7 @@ module Lono::Template::Strategy::Dsl::Builder::Section
 
     def parameter(*definition)
       @cfn["Parameters"] ||= {}
-      param = Parameter.new(@blueprint, definition)
+      param = Parameter.new(@blueprint.name, definition)
       @cfn["Parameters"].merge!(param.template)
 
       # Additional decorations
@@ -33,32 +33,32 @@ module Lono::Template::Strategy::Dsl::Builder::Section
 
     def mapping(*definition)
       @cfn["Mappings"] ||= {}
-      mapping = Mapping.new(@blueprint, definition)
+      mapping = Mapping.new(@blueprint.name, definition)
       @cfn["Mappings"].merge!(mapping.template)
     end
 
     def resource(*definition)
       @cfn["Resources"] ||= {}
-      resource = Resource.new(@blueprint, definition)
+      resource = Resource.new(@blueprint.name, definition)
       @cfn["Resources"].merge!(resource.template)
     end
 
     def condition(*definition)
       @cfn["Conditions"] ||= {}
-      condition = Condition.new(@blueprint, definition)
+      condition = Condition.new(@blueprint.name, definition)
       @cfn["Conditions"].merge!(condition.template)
     end
 
     def output(*definition)
       @cfn["Outputs"] ||= {}
-      output = Output.new(@blueprint, definition)
+      output = Output.new(@blueprint.name, definition)
       @cfn["Outputs"].merge!(output.template)
     end
 
     # Generic section method in case CloudFormation adds a new future section.
     # The generic section method adds a new top-level key
     def section(key, definition)
-      @cfn[key] = Section.new(@blueprint, definition).template
+      @cfn[key] = Section.new(@blueprint.name, definition).template
     end
   end
 end

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

@@ -1,4 +1,4 @@
-class Lono::Template::Strategy::Dsl::Builder
+module Lono::Builder::Dsl::Syntax
   module Fn
     # Also act as documentation on the method signatures
     # Also used in Coder crafting so should always list all the functions here
@@ -83,7 +83,7 @@ class Lono::Template::Strategy::Dsl::Builder
       end
     end
 
-    def conditional_ref(name, options)
+    def conditional_ref(name, options={})
       fallback = options[:Fallback] || options[:fallback] || ref("AWS::NoValue")
       if!("Has#{name}", ref(name, options), fallback)
     end

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

@@ -1,4 +1,4 @@
-module Lono::Template::Strategy::Dsl::Builder::Syntax
+module Lono::Builder::Dsl::Syntax
   module ParameterGroup
     def parameter_group(label)
       @group_label = label

data/lib/lono/builder/dsl/syntax.rb

@@ -0,0 +1,9 @@
+# Encapsulates syntax methods so they can be included in both the Evaluator and Context scope
+class Lono::Builder::Dsl
+  module Syntax
+    include Fn
+    include Core
+    include ParameterGroup
+    include Helpers
+  end
+end

data/lib/lono/builder/dsl.rb

@@ -0,0 +1,14 @@
+module Lono::Builder
+  class Dsl < Lono::CLI::Base
+    attr_reader :results
+    def run
+      logger.info "Building template" unless @options[:quiet]
+      build_template
+    end
+
+    def build_template
+      evaluator = Evaluator.new(@options)
+      evaluator.evaluate
+    end
+  end
+end

data/lib/lono/{param/generator.rb → builder/param.rb}

@@ -1,15 +1,19 @@
-class Lono::Param
-  class Generator < Lono::AbstractBase
-    attr_reader :env_path, :base_path # set when generate is called
+module Lono::Builder
+  class Param < Lono::CLI::Base
+    attr_reader :env_path, :base_path # set when build is called
+    include Lono::Builder::Dsl::Syntax
+    # Overriding output resource DSL method
+    alias_method :output, :stack_output
 
-    def generate
-      puts "Generating parameter files for blueprint #{@blueprint.color(:green)}:"
+    def build
+      logger.info "Building parameters"
 
       contents = []
-      layering = Lono::Layering.new("params", @options, Lono.env)
-      layering.locations.each do |path|
-        contents << render_erb(path)
+
+      layers.each do |layer|
+        contents << render_erb(layer)
       end
+
       contents = contents.compact.join("\n") # result
 
       data = convert_to_cfn_format(contents)
@@ -17,30 +21,28 @@ class Lono::Param
       json = JSON.pretty_generate(camel_data)
       write_output(json)
       unless @options[:mute]
-        short_output_path = output_path.sub("#{Lono.root}/","")
-        puts "  #{short_output_path}"
+        short_param_path = param_path.sub("#{Lono.root}/","")
+        logger.info "    #{short_param_path}"
       end
 
       data
     end
 
+    def layers
+      Lono::Layering::Layer.new(@blueprint, "params").paths
+    end
+
     def parameters
-      generate
+      build
     end
 
     def render_erb(path)
       return unless path
       if File.exist?(path)
-        RenderMePretty.result(path, context: context)
+        RenderMePretty.result(path, context: self)
       end
     end
 
-    # Context for ERB rendering.
-    # This is where we control what references get passed to the ERB rendering.
-    def context
-      @context ||= Lono::Template::Context.new(@options)
-    end
-
     def convert_to_cfn_format(contents, casing=:underscore)
       lines = parse_contents(contents)
 
@@ -96,14 +98,14 @@ class Lono::Param
       end
     end
 
-    def output_path
-      "#{Lono.root}/output/#{@blueprint}/params/#{@stack}.json"
+    def param_path
+      "#{Lono.root}/output/#{@blueprint.name}/params.json"
     end
 
     def write_output(json)
-      dir = File.dirname(output_path)
+      dir = File.dirname(param_path)
       FileUtils.mkdir_p(dir)
-      IO.write(output_path, json)
+      IO.write(param_path, json)
     end
   end
 end

data/lib/lono/builder/template/aws_service.rb

@@ -0,0 +1,15 @@
+require "aws-sdk-s3"
+
+class Lono::Builder::Template::AwsService
+  def s3
+    return @s3 if @s3
+
+    options = {}
+    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/builder/template/bashify.rb

@@ -0,0 +1,43 @@
+require 'open-uri'
+
+class Lono::Builder::Template
+  class Bashify
+    include Lono::Utils::Logging
+
+    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?
+        logger.info "No UserData script found"
+        return
+      end
+      paths.each do |path|
+        logger.info "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]
+        logger.info script.join(delimiter)
+      end
+    end
+  end
+end

data/lib/lono/{output/template.rb → builder/template/output.rb}

@@ -1,9 +1,9 @@
-module Lono::Output
-  class Template
+class Lono::Builder::Template
+  class Output
     extend Memoist
 
-    def initialize(blueprint, template)
-      @blueprint, @template = blueprint, template
+    def initialize(blueprint)
+      @blueprint = blueprint
     end
 
     def required_parameters
@@ -34,8 +34,16 @@ module Lono::Output
       end
     end
 
+    def outputs
+      data["Outputs"] || {}
+    end
+
+    def resources
+      data["Resources"] || {}
+    end
+
     def data
-      template_path = "#{Lono.config.output_path}/#{@blueprint}/templates/#{@template}.yml"
+      template_path = "#{Lono.root}/output/#{@blueprint.name}/template.yml"
       check_template_exists!(template_path)
       YAML.load(IO.read(template_path))
     end
@@ -55,8 +63,7 @@ module Lono::Output
     # does not exist.
     def check_template_exists!(template_path)
       return if File.exist?(template_path)
-      puts "The template #{template_path} does not exist. Are you sure you use the right template name?  The template name does not require the extension.".color(:red)
-      exit 1
+      raise "The template #{template_path} does not exist. Are you sure you use the right template name?  The template name does not require the extension.".color(:red)
     end
   end
 end

data/lib/lono/{template → builder/template}/post_processor.rb

@@ -1,5 +1,5 @@
-class Lono::Template
-  class PostProcessor < Lono::AbstractBase
+class Lono::Builder::Template
+  class PostProcessor < Lono::CLI::Base
     def run
       replacements.each do |placeholder, replacement|
         update_template!(template)
@@ -20,7 +20,7 @@ class Lono::Template
         elsif item.directory? || item.file?
           placeholder = "file://app/files/file/#{item.name}"
         else
-          puts "WARN: PostProcessor replacements Cannot find file: #{item.output_path}"
+          logger.info "WARN: PostProcessor replacements Cannot find file: #{item.output_path}"
           next
         end
         map[placeholder] = item.s3_path
@@ -61,7 +61,7 @@ class Lono::Template
     memoize :template
 
     def template_path
-      "#{Lono.config.output_path}/#{@blueprint}/templates/#{@template}.yml"
+      "#{Lono.root}/output/#{@blueprint.name}/templates/#{@template}.yml"
     end
   end
 end

data/lib/lono/builder/template/upload.rb

@@ -0,0 +1,8 @@
+class Lono::Builder::Template
+  class Upload < Lono::CLI::Base
+    def run
+      path = "#{Lono.root}/output/#{@blueprint.name}/template.yml"
+      Lono::S3::Uploader.new(path).upload
+    end
+  end
+end

data/lib/lono/builder/template.rb

@@ -0,0 +1,55 @@
+require "yaml"
+
+module Lono::Builder
+  class Template < Lono::CLI::Base
+    extend Memoist
+
+    def run
+      check_blueprint_exist!
+      data = dsl.run # The generator strategy classes write templates to disk
+      write_output(data)
+    end
+
+  private
+    def check_blueprint_exist!
+      return if @blueprint.exist?
+      logger.error "ERROR: Blueprint #{@blueprint.name} not found.".color(:red)
+      logger.error <<~EOL
+        Searched:
+
+            app/blueprints
+            vendor/blueprints
+
+        Are you sure it exists? To check, you can run:
+
+            lono list
+
+      EOL
+      exit 1
+    end
+
+    def write_output(data)
+      path = @blueprint.output_path
+      ensure_parent_dir(path)
+      text = YAML.dump(data)
+      IO.write(path, text)
+
+      Lono::Yamler::Validator.new(path).validate!
+
+      unless @options[:quiet]
+        pretty_path = path.sub("#{Lono.root}/",'')
+        logger.info "    #{pretty_path}"
+      end
+    end
+
+    def ensure_parent_dir(path)
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir) unless File.exist?(dir)
+    end
+
+    def dsl
+      Dsl.new(@options)
+    end
+    memoize :dsl
+  end
+end