lono 6.1.11 → 7.0.0

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

@@ -1,4 +1,4 @@
-class Lono::Template::Dsl::Builder
+class Lono::Template::Strategy::Dsl::Builder
   module Fn
     # Also act as documentation on the method signatures
     # Also used in Coder crafting so should always list all the functions here

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

@@ -0,0 +1,11 @@
+# Built-in helpers for the DSL form
+class Lono::Template::Strategy::Dsl::Builder
+  module Helpers
+    extend Memoist
+    include CoreHelper
+    include FileHelper
+    include LookupHelper
+    include S3Helper
+    include TagsHelper
+  end
+end

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

@@ -0,0 +1,14 @@
+module Lono::Template::Strategy::Dsl::Builder::Helpers
+  module CoreHelper
+    extend Memoist
+
+    def stack_name
+      @options[:stack]
+    end
+
+    def setting
+      Lono::Setting.new
+    end
+    memoize :setting
+  end
+end

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

@@ -0,0 +1,48 @@
+module Lono::Template::Strategy::Dsl::Builder::Helpers
+  module FileHelper
+    extend Memoist
+
+    def content(path)
+      render_file(Lono.config.content_path, path)
+    end
+
+    def user_data(path)
+      render_file(Lono.config.user_data_path, path)
+    end
+
+    def user_data_script
+      unless @user_data_script
+        return <<~EOL
+          # @user_data_script variable not set. IE: @user_data_script = "configs/#{@blueprint}/user-data/boostrap.sh"
+          # Also, make sure that "configs/#{@blueprint}/user-data/boostrap.sh" path you're using exists.
+        EOL
+      end
+
+      if File.exist?(@user_data_script)
+        render_path(@user_data_script)
+      else
+        message = "WARN: #{@user_data_script} not found"
+        puts message.color(:yellow)
+        "# #{message}"
+      end
+    end
+
+    def render_file(folder, path)
+      path = "#{folder}/#{path}"
+      if File.exist?(path)
+        render_path(path)
+      else
+        message = "WARNING: path #{path} not found"
+        puts message.color(:yellow)
+        puts "Called from:"
+        puts caller[2]
+        message
+      end
+    end
+    memoize :render_file
+
+    def render_path(path)
+      RenderMePretty.result(path, context: self)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Lono::Template::Strategy::Dsl::Builder::Helpers
+  module LookupHelper
+    extend Memoist
+    include Lono::AwsServices
+
+    def lookup_output(name)
+      stack_name, key = name.split(".")
+      resp = describe_stacks(stack_name: stack_name)
+      stack = resp.stacks.first
+      if stack
+        o = stack.outputs.detect { |h| h.output_key == key }
+      end
+
+      if o
+        o.output_value
+      else
+        "NOT FOUND: Did not lookup_output #{name} for stack #{stack}"
+      end
+    end
+
+  private
+    def describe_stacks(options={})
+      cfn.describe_stacks(options)
+    end
+    memoize :describe_stacks
+  end
+end

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

@@ -0,0 +1,13 @@
+module Lono::Template::Strategy::Dsl::Builder::Helpers
+  module S3Helper
+    def s3_bucket
+      Lono::S3::Bucket.name
+    end
+
+    def file_s3_key(name, options={})
+      Lono::AppFile::Registry.register(name, @blueprint, options)
+      "file://app/files/#{name}" # placeholder for post processing
+    end
+    alias_method :s3_key, :file_s3_key
+  end
+end

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

@@ -0,0 +1,39 @@
+module Lono::Template::Strategy::Dsl::Builder::Helpers
+  module TagsHelper
+    def tags(hash={})
+      if hash.empty?
+        tag_list(@tags) if @tags # when hash is empty, use @tags variable. If not set then return nil
+      else
+        tag_list(hash)
+      end
+    end
+
+    def tag_list(hash)
+      raise "tags hash cannot be empty" if hash == nil
+
+      if hash.is_a?(Array)
+        hash = hash.inject({}) do |h,i|
+          i.symbolize_keys!
+          h[i[:Key]] = i[:Value]
+          h
+        end
+        return tag_list(hash) # recursive call tag_list to normalized the argument with a Hash
+      end
+
+      propagate = hash[:PropagateAtLaunch] # special treatment
+      list = hash.map do |k,v|
+        h = {Key: k.to_s, Value: v}
+        h[:PropagateAtLaunch] = propagate unless propagate.nil?
+        h
+      end
+      list.reject { |h| h[:Key] == "PropagateAtLaunch" }
+    end
+
+    def dimensions(hash)
+      tag_list(hash).map { |h|
+        h[:Name] = h.delete(:Key) || h.delete(:key)
+        h
+      }
+    end
+  end
+end

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

@@ -1,7 +1,8 @@
-class Lono::Template::Dsl::Builder
+module Lono::Template::Strategy::Dsl::Builder::Section
   class Base
-    include Fn
-    include Helpers
+    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
@@ -16,26 +17,14 @@ class Lono::Template::Dsl::Builder
       data = if blueprint_meta.auto_camelize?(target_section)
                CfnCamelizer.transform(attributes)
              else
-               stringify_keys!(attributes)
+               stringify!(attributes)
              end
       clean(data)
     end
 
-    # Accounts for Arrays also. ActiveSupport only works for Hashes.
-    def stringify_keys!(data)
-      case data
-      when Array
-        data.map! { |i| stringify_keys!(i) }
-      when Hash
-        data.deep_transform_keys! { |k| k.to_s }
-      else
-        data # do not transform
-      end
-    end
-
     # Remove items with nil value automatically
     def clean(data)
-      Squeezer.new(data).squeeze
+      Lono::Template::Strategy::Dsl::Builder::Squeezer.new(data).squeeze
     end
   end
 end

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

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

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

@@ -0,0 +1,9 @@
+module Lono::Template::Strategy::Dsl::Builder::Section
+  module Extensions
+    def parameter_group(label)
+      @group_label = label
+      yield
+      @group_label = nil
+    end
+  end
+end

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

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

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

@@ -1,6 +1,6 @@
 # Organize core section method syntax here
-class Lono::Template::Dsl::Builder
-  module SectionMethods
+module Lono::Template::Strategy::Dsl::Builder::Section
+  module Methods
     def aws_template_format_version(version_date)
       @cfn["AWSTemplateFormatVersion"] = version_date
     end
@@ -22,6 +22,13 @@ class Lono::Template::Dsl::Builder
       @cfn["Parameters"] ||= {}
       param = Parameter.new(@blueprint, definition)
       @cfn["Parameters"].merge!(param.template)
+
+      # Additional decorations
+      param.group_label = @group_label
+      @parameters << param # register for to build Metadata Interface later
+      if param.conditional
+        condition("Has#{param.name}", not!(equals(ref(param.name), "")))
+      end
     end
 
     def mapping(*definition)

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

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

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

@@ -0,0 +1,69 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+module Lono::Template::Strategy::Dsl::Builder::Section
+  class Parameter < Base
+    attr_accessor :group_label
+    attr_reader :conditional, :label
+
+    def template
+      camelize(add_required(track_label(track_conditional(standarize(@definition)))))
+    end
+
+    # Type is the only required property: https://amzn.to/2x8W5aD
+    def standarize(definition)
+      first, second, third = definition
+      if definition.size == 1 && first.is_a?(Hash) # long form
+        first # pass through
+      elsif definition.size == 2 && second.is_a?(Hash) # medium form - 1
+        logical_id, properties = first, second
+        { logical_id => properties }
+      elsif definition.size == 3 && !second.is_a?(Hash) && third.is_a?(Hash) # medium form variant - 2
+        third[:Default] = second # probably a String, Integer, or Float
+        logical_id, properties = first, third
+        { logical_id => properties }
+      elsif (definition.size == 2 && valid_value?(second)) || # short form
+            definition.size == 1
+        logical_id = first
+        properties = valid_value?(second) ? { Default: second } : {}
+        { logical_id => properties }
+      else # I dont know what form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+
+    def add_required(attributes)
+      properties = attributes.values.first
+      properties["Type"] ||= 'String'
+      attributes
+    end
+
+    def valid_value?(o)
+      o.is_a?(Float) || o.is_a?(Integer) || o.is_a?(String) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
+    end
+
+    def track_conditional(attributes)
+      properties = attributes.values.first
+      @conditional ||= properties[:Conditional] # flag for later
+      properties.delete(:Conditional) # remove property, it's not a real property, used to flag conditional parameters
+      # Ensure default
+      if @conditional
+        defaults = { Default: "" }
+        properties.reverse_merge!(defaults)
+      end
+      attributes
+    end
+
+    def track_label(attributes)
+      properties = attributes.values.first
+      @label ||= properties[:Label] # flag for later
+      properties.delete(:Label) # remove property, it's not a real property, used to build metadata interface
+      attributes
+    end
+
+    def name
+      template.keys.first # logical_id or name
+    end
+  end
+end

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

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

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

@@ -1,4 +1,4 @@
-class Lono::Template::Dsl::Builder::Resource
+class Lono::Template::Strategy::Dsl::Builder::Section::Resource
   # Moves the property to the top-level attributes *destructively*
   class PropertyMover
     def initialize(resource, logical_id, properties)

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

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

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

@@ -1,4 +1,4 @@
-class Lono::Template::Dsl::Builder
+class Lono::Template::Strategy::Dsl::Builder
   class Squeezer
     def initialize(data)
       @data = data

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

@@ -0,0 +1,15 @@
+class Lono::Template::Strategy::Dsl::Builder
+  module Stringify
+    # Accounts for Arrays also. ActiveSupport only works for Hashes.
+    def stringify!(data)
+      case data
+      when Array
+        data.map! { |i| stringify!(i) }
+      when Hash
+        data.deep_transform_keys! { |k| k.to_s }
+      else
+        data # do not transform
+      end
+    end
+  end
+end

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

@@ -1,9 +1,10 @@
 # Encapsulates syntax methods so they can be included in both the Builder and Context scope
-class Lono::Template::Dsl::Builder
+class Lono::Template::Strategy::Dsl::Builder
   module Syntax
     include Fn
     include Lono::Template::Evaluate
-    include SectionMethods
+    include Section::Methods
+    include Section::Extensions
     include Helpers # built-in helpers
   end
 end

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

@@ -0,0 +1,12 @@
+class Lono::Template::Strategy::Dsl
+  class Finalizer
+    def initialize(cfn, options={})
+      @cfn, @options = cfn, options
+    end
+
+    def run
+      @cfn = ParameterGroups.new(@cfn, @options[:parameters]).run
+      @cfn
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+class Lono::Template::Strategy::Dsl::Finalizer
+  class ParameterGroups
+    extend Memoist
+    include Lono::Template::Strategy::Dsl::Builder::Stringify
+
+    def initialize(cfn, parameters)
+      @cfn, @parameters = cfn, parameters
+    end
+
+    def run
+      return @cfn if parameter_groups.empty?
+      @cfn["Metadata"] ||= {}
+      @cfn["Metadata"]["AWS::CloudFormation::Interface"] = stringify!(interface)
+      @cfn
+    end
+
+    def interface
+      interface = {}
+      parameter_groups.each do |group_label, parameters|
+        group = {
+          Label: { default: group_label},
+          Parameters: parameters,
+        }
+        interface[:ParameterGroups] ||= []
+        interface[:ParameterGroups] << group
+      end
+      parameter_labels.each do |name, label|
+        l = { name => { default: label } }
+        interface[:ParameterLabels] ||= {}
+        interface[:ParameterLabels].merge!(l)
+      end
+      interface
+    end
+
+    def parameter_groups
+      parameter_groups = {}
+      @parameters.each do |p|
+        next unless p.group_label
+        parameter_groups[p.group_label] ||= []
+        parameter_groups[p.group_label] << p.name
+      end
+      parameter_groups
+    end
+    memoize :parameter_groups
+
+    def parameter_labels
+      parameter_labels = {}
+      @parameters.each do |p|
+        next unless p.label
+        parameter_labels[p.name] = p.label
+      end
+      parameter_labels
+    end
+    memoize :parameter_labels
+  end
+end