lono 5.1.1 → 5.2.0

data/lib/lono/param/generator.rb

@@ -1,213 +1,215 @@
-class Lono::Param::Generator
-  include Lono::Blueprint::Root
-  include Lono::Conventions
-
-  attr_reader :env_path, :base_path # set when generate is called
-  def initialize(blueprint, options={})
-    @blueprint, @options = blueprint, options
-    set_blueprint_root(@blueprint)
-    @template, @param = template_param_convention(options)
-  end
-
-  def puts_param_message(type)
-    path = send("#{type}_path")
-    return unless path
-    if File.exist?(path)
-      pretty_path = path.sub("#{Lono.root}/",'')
-      puts "Using param: #{pretty_path}".color(:yellow)
+class Lono::Param
+  class Generator
+    include Lono::Blueprint::Root
+    include Lono::Conventions
+
+    attr_reader :env_path, :base_path # set when generate is called
+    def initialize(blueprint, options={})
+      @blueprint, @options = blueprint, options
+      set_blueprint_root(@blueprint)
+      @template, @param = template_param_convention(options)
     end
-  end
 
-  # Lookup precedence:
-  #
-  #   configs/BLUEPRINT/params/development/TEMPLATE/PARAM.txt
-  #   configs/BLUEPRINT/params/development/PARAM.txt
-  #   configs/BLUEPRINT/params/development.txt
-  #
-  def lookup_param_file(root: Lono.root, env: Lono.env)
-    long_form = "#{root}/configs/#{@blueprint}/params/#{env}/#{@template}/#{@param}.txt"
-    medium_form = "#{root}/configs/#{@blueprint}/params/#{env}/#{@param}.txt"
-    short_form = "#{root}/configs/#{@blueprint}/params/#{env}.txt"
-
-    if ENV['LONO_PARAM_DEBUG']
-      puts "Lono.blueprint_root #{Lono.blueprint_root}"
-      puts "long_form #{long_form}"
-      puts "medium_form #{medium_form}"
-      puts "short_form #{short_form}"
+    def puts_param_message(type)
+      path = send("#{type}_path")
+      return unless path
+      if File.exist?(path)
+        pretty_path = path.sub("#{Lono.root}/",'')
+        puts "Using param: #{pretty_path}".color(:yellow)
+      end
     end
 
-    return long_form if File.exist?(long_form) # always consider this first because its so explicit
+    # Lookup precedence:
+    #
+    #   configs/BLUEPRINT/params/development/TEMPLATE/PARAM.txt
+    #   configs/BLUEPRINT/params/development/PARAM.txt
+    #   configs/BLUEPRINT/params/development.txt
+    #
+    def lookup_param_file(root: Lono.root, env: Lono.env)
+      long_form = "#{root}/configs/#{@blueprint}/params/#{env}/#{@template}/#{@param}.txt"
+      medium_form = "#{root}/configs/#{@blueprint}/params/#{env}/#{@param}.txt"
+      short_form = "#{root}/configs/#{@blueprint}/params/#{env}.txt"
+
+      if ENV['LONO_PARAM_DEBUG']
+        puts "Lono.blueprint_root #{Lono.blueprint_root}"
+        puts "long_form #{long_form}"
+        puts "medium_form #{medium_form}"
+        puts "short_form #{short_form}"
+      end
 
-    # All 3 are the same
-    if @blueprint == @template && @template == @param
-      return medium_form if File.exist?(medium_form) # higher precedence between longer but short form should be encouraged
-      return short_form if File.exist?(short_form)
-      return # cannot find a param file
-    end
+      return long_form if File.exist?(long_form) # always consider this first because its so explicit
+
+      # All 3 are the same
+      if @blueprint == @template && @template == @param
+        return medium_form if File.exist?(medium_form) # higher precedence between longer but short form should be encouraged
+        return short_form if File.exist?(short_form)
+        return # cannot find a param file
+      end
 
-    # Only template and param are the same
-    if @template == @param
-      return medium_form if File.exist?(medium_form) # only consider medium form
-      return # cannot find a param file
+      # Only template and param are the same
+      if @template == @param
+        return medium_form if File.exist?(medium_form) # only consider medium form
+        return # cannot find a param file
+      end
     end
-  end
 
-  def lookup_paths
-    @base_path = lookup_param_file(env: "base")
-    @env_path = lookup_param_file(env: Lono.env)
+    def lookup_paths
+      @base_path = lookup_param_file(env: "base")
+      @env_path = lookup_param_file(env: Lono.env)
 
-    if ENV['LONO_PARAM_DEBUG']
-      puts "  @base_path #{@base_path.inspect}"
-      puts "  @env_path #{@env_path.inspect}"
-    end
+      if ENV['LONO_PARAM_DEBUG']
+        puts "  @base_path #{@base_path.inspect}"
+        puts "  @env_path #{@env_path.inspect}"
+      end
 
-    [@base_path, @env_path]
-  end
+      [@base_path, @env_path]
+    end
 
-  def generate
-    puts "Generating parameter files for blueprint #{@blueprint.color(:green)}:"
+    def generate
+      puts "Generating parameter files for blueprint #{@blueprint.color(:green)}:"
 
-    @base_path, @env_path = lookup_paths
+      @base_path, @env_path = lookup_paths
 
-    return unless @base_path || @env_path
+      return unless @base_path || @env_path
 
-    # useful option for lono cfn, since some templates dont require params
-    return if @options[:allow_not_exists] && !source_exist?
+      # useful option for lono cfn, since some templates dont require params
+      return if @options[:allow_not_exists] && !source_exist?
 
-    if source_exist?
-      contents = process_erb
-      data = convert_to_cfn_format(contents)
-      json = JSON.pretty_generate(data)
-      write_output(json)
-      unless @options[:mute]
-        short_output_path = output_path.sub("#{Lono.root}/","")
-        puts "  #{short_output_path}"
+      if source_exist?
+        contents = process_erb
+        data = convert_to_cfn_format(contents)
+        json = JSON.pretty_generate(data)
+        write_output(json)
+        unless @options[:mute]
+          short_output_path = output_path.sub("#{Lono.root}/","")
+          puts "  #{short_output_path}"
+        end
+      else
+        puts "#{@base_path} or #{@env_path} could not be found?  Are you sure it exist?"
+        exit 1
       end
-    else
-      puts "#{@base_path} or #{@env_path} could not be found?  Are you sure it exist?"
-      exit 1
+      json
     end
-    json
-  end
 
-  # Checks both base and source path for existing of the param file.
-  # Example:
-  #   params/base/mystack.txt - base path
-  #   params/production/mystack.txt - source path
-  def source_exist?
-    @base_path && File.exist?(@base_path) ||
-    @env_path && File.exist?(@env_path)
-  end
+    # Checks both base and source path for existing of the param file.
+    # Example:
+    #   params/base/mystack.txt - base path
+    #   params/production/mystack.txt - source path
+    def source_exist?
+      @base_path && File.exist?(@base_path) ||
+      @env_path && File.exist?(@env_path)
+    end
 
-  # useful for when calling CloudFormation via the aws-sdk gem
-  def params(casing = :underscore)
-    @base_path, @env_path = lookup_paths
+    # useful for when calling CloudFormation via the aws-sdk gem
+    def params(casing = :underscore)
+      @base_path, @env_path = lookup_paths
 
-    # useful option for lono cfn
-    return {} if @options[:allow_not_exists] && !source_exist?
+      # useful option for lono cfn
+      return {} if @options[:allow_not_exists] && !source_exist?
 
-    contents = process_erb
-    convert_to_cfn_format(contents, casing)
-  end
+      contents = process_erb
+      convert_to_cfn_format(contents, casing)
+    end
 
-  # Reads both the base source and env source and overlay the two
-  # Example 1:
-  #   params/base/mystack.txt - base path
-  #   params/production/mystack.txt - env path
-  #
-  #   the base/mystack.txt gets combined with the prod/mystack.txt
-  #   it produces a final prod/mystack.txt
-  #
-  # Example 2:
-  #   params/base/mystack.txt - base path
-  #
-  #   the base/mystack.txt is used to produced a prod/mystack.txt
-  #
-  # Example 3:
-  #   params/production/mystack.txt - env path
-  #
-  #   the prod/mystack.txt is used to produced a prod/mystack.txt
-  def process_erb
-    contents = []
-    contents << render_erb(@base_path)
-    contents << render_erb(@env_path)
-    result = contents.compact.join("\n")
-    # puts "process_erb result".color(:yellow)
-    # puts result
-    result
-  end
+    # Reads both the base source and env source and overlay the two
+    # Example 1:
+    #   params/base/mystack.txt - base path
+    #   params/production/mystack.txt - env path
+    #
+    #   the base/mystack.txt gets combined with the prod/mystack.txt
+    #   it produces a final prod/mystack.txt
+    #
+    # Example 2:
+    #   params/base/mystack.txt - base path
+    #
+    #   the base/mystack.txt is used to produced a prod/mystack.txt
+    #
+    # Example 3:
+    #   params/production/mystack.txt - env path
+    #
+    #   the prod/mystack.txt is used to produced a prod/mystack.txt
+    def process_erb
+      contents = []
+      contents << render_erb(@base_path)
+      contents << render_erb(@env_path)
+      result = contents.compact.join("\n")
+      # puts "process_erb result".color(:yellow)
+      # puts result
+      result
+    end
 
-  def render_erb(path)
-    return unless path
-    if File.exist?(path)
-      RenderMePretty.result(path, context: context)
+    def render_erb(path)
+      return unless path
+      if File.exist?(path)
+        RenderMePretty.result(path, context: context)
+      end
     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(@blueprint, @options)
-  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(@blueprint, @options)
+    end
 
-  def parse_contents(contents)
-    lines = contents.split("\n")
-    # remove comment at the end of the line
-    lines.map! { |l| l.sub(/#.*/,'').strip }
-    # filter out commented lines
-    lines = lines.reject { |l| l =~ /(^|\s)#/i }
-    # filter out empty lines
-    lines = lines.reject { |l| l.strip.empty? }
-    lines
-  end
+    def parse_contents(contents)
+      lines = contents.split("\n")
+      # remove comment at the end of the line
+      lines.map! { |l| l.sub(/#.*/,'').strip }
+      # filter out commented lines
+      lines = lines.reject { |l| l =~ /(^|\s)#/i }
+      # filter out empty lines
+      lines = lines.reject { |l| l.strip.empty? }
+      lines
+    end
 
-  def convert_to_cfn_format(contents, casing=:camel)
-    lines = parse_contents(contents)
+    def convert_to_cfn_format(contents, casing=:camel)
+      lines = parse_contents(contents)
 
-    # First use a Hash structure so that overlay env files will override
-    # the base param file.
-    data = {}
-    lines.each do |line|
-      key,value = line.strip.split("=").map {|x| x.strip}
-      data[key] = value
-    end
+      # First use a Hash structure so that overlay env files will override
+      # the base param file.
+      data = {}
+      lines.each do |line|
+        key,value = line.strip.split("=").map {|x| x.strip}
+        data[key] = value
+      end
 
-    # Now build up the aws json format for parameters
-    params = []
-    data.each do |key,value|
-      param = if value == "use_previous_value"
-                {
-                  "ParameterKey": key,
-                  "UsePreviousValue": true
-                }
-              elsif value
-                {
-                  "ParameterKey": key,
-                  "ParameterValue": value
-                }
-              end
-      if param
-        param = param.to_snake_keys if casing == :underscore
-        params << param
+      # Now build up the aws json format for parameters
+      params = []
+      data.each do |key,value|
+        param = if value == "use_previous_value"
+                  {
+                    "ParameterKey": key,
+                    "UsePreviousValue": true
+                  }
+                elsif value
+                  {
+                    "ParameterKey": key,
+                    "ParameterValue": value
+                  }
+                end
+        if param
+          param = param.to_snake_keys if casing == :underscore
+          params << param
+        end
       end
+      params
     end
-    params
-  end
 
-  def output_path
-    output = Lono.config.output_path.sub("#{Lono.root}/","")
-    path = if @base_path && !@env_path
-             # Handle case when base config exist but the env config does not
-             @base_path.sub("configs", output).sub("base", Lono.env)
-           else
-             @env_path.sub("configs", output)
-           end
-    path.sub(/\.txt$/,'.json')
-  end
+    def output_path
+      output = Lono.config.output_path.sub("#{Lono.root}/","")
+      path = if @base_path && !@env_path
+               # Handle case when base config exist but the env config does not
+               @base_path.sub("configs", output).sub("base", Lono.env)
+             else
+               @env_path.sub("configs", output)
+             end
+      path.sub(/\.txt$/,'.json')
+    end
 
-  def write_output(json)
-    dir = File.dirname(output_path)
-    FileUtils.mkdir_p(dir)
-    IO.write(output_path, json)
+    def write_output(json)
+      dir = File.dirname(output_path)
+      FileUtils.mkdir_p(dir)
+      IO.write(output_path, json)
+    end
   end
-end
+end

data/lib/lono/param.rb

@@ -1,12 +1,10 @@
-require "thor"
-
 module Lono
-  class Param < Lono::Command
+  class Param < Command
     class_option :verbose, type: :boolean
     class_option :noop, type: :boolean
     class_option :mute, type: :boolean
 
-    desc "generate", "Generate all parameter files to `output/params`."
+    desc "generate", "Generate parameter output files to `output/params`."
     long_desc Lono::Help.text("param/generate")
     def generate(blueprint=nil)
       Blueprint::Find.one_or_all(blueprint).each do |b|

data/lib/lono/s3/bucket.rb

@@ -3,6 +3,7 @@ class Lono::S3
     STACK_NAME = ENV['LONO_STACK_NAME'] || "lono"
     include Lono::AwsServices
     extend Lono::AwsServices
+    extend Memoist
 
     class << self
       @@name = nil
@@ -24,6 +25,14 @@ class Lono::S3
 
     def deploy
       stack = find_stack
+      if rollback_complete?(stack)
+        puts "Existing '#{STACK_NAME}' stack in ROLLBACK_COMPLETE state. Deleting stack before continuing."
+        cfn.delete_stack(stack_name: STACK_NAME)
+        status.wait
+        status.reset
+        stack = nil
+      end
+
       if stack
         update
       else
@@ -50,9 +59,17 @@ class Lono::S3
     # Launches a cloudformation to create an s3 bucket
     def create
       puts "Creating #{STACK_NAME} stack with the s3 bucket"
-      cfn.create_stack(stack_name: STACK_NAME, template_body: template_body)
-      status = ::Cfn::Status.new(STACK_NAME)
-      status.wait
+      cfn.create_stack(
+        stack_name: STACK_NAME,
+        template_body: template_body,
+        enable_termination_protection: true,
+      )
+      success = status.wait
+      status.reset
+      unless success
+        puts "ERROR: Unable to create lono stack with managed s3 bucket".color(:red)
+        exit 1
+      end
     end
 
     def update
@@ -66,10 +83,18 @@ class Lono::S3
       are_you_sure?
 
       puts "Deleting #{STACK_NAME} stack with the s3 bucket"
+      disable_termination_protect
       empty_bucket!
       cfn.delete_stack(stack_name: STACK_NAME)
     end
 
+    def disable_termination_protect
+      cfn.update_termination_protection(
+        stack_name: STACK_NAME,
+        enable_termination_protection: false,
+      )
+    end
+
     def find_stack
       resp = cfn.describe_stacks(stack_name: STACK_NAME)
       resp.stacks.first
@@ -77,6 +102,11 @@ class Lono::S3
       nil
     end
 
+    def status
+      ::Cfn::Status.new(STACK_NAME)
+    end
+    memoize :status
+
   private
 
     def empty_bucket!
@@ -99,6 +129,11 @@ class Lono::S3
     def are_you_sure?
       return true if @options[:sure]
 
+      if bucket_name.nil?
+        puts "The lono stack and s3 bucket does not exist."
+        exit
+      end
+
       puts "Are you sure you want the lono bucket #{bucket_name.color(:green)} to be emptied and deleted? (y/N)"
       sure = $stdin.gets.strip
       yes = sure =~ /^Y/i

data/lib/lono/script/base.rb

@@ -3,7 +3,7 @@ class Lono::Script
     SCRIPTS_INFO_PATH = "#{Lono.config.output_path}/data/scripts_info.txt"
     include Lono::Blueprint::Root
 
-    def initialize(blueprint, options = {})
+    def initialize(blueprint, options={})
       @blueprint, @options = blueprint, options
       @template = @options[:template] || @blueprint
       Lono::ProjectChecker.check

data/lib/lono/seed/base.rb

@@ -0,0 +1,148 @@
+require "fileutils"
+require "memoist"
+require "yaml"
+
+# Subclasses should implement:
+#
+#   variables - Returns String with content of varibles files.
+#   setup - Hook to do extra things like create IAM service roles.
+#   finish - Finish hook after config files have been created.
+#
+# Note there is no params method to hook. The Base class handles params well.
+#
+class Lono::Seed
+  class Base
+    include Lono::Blueprint::Root
+    include Lono::AwsServices
+    include Lono::Conventions
+    extend Memoist
+
+    def initialize(blueprint, options)
+      @blueprint, @options = blueprint, options
+      @template, @param = template_param_convention(options)
+    end
+
+    def run
+      check_dsl_type!
+      setup
+      create_params
+      create_variables
+      finish
+    end
+
+    # Always create params files
+    def create_params
+      with_each_template do |path|
+        create_param_file(path)
+      end
+    end
+
+    def create_variables
+      return unless variables
+      dest_path = "configs/#{@blueprint}/variables/#{Lono.env}.rb"
+      write(dest_path, variables)
+      puts "Starter variables created: #{dest_path}"
+    end
+
+    def check_dsl_type!
+      dsl_type = template_type == 'dsl'
+      unless dsl_type
+        puts "Detected template_type: #{template_type}"
+        puts "lono seed only supports dsl template types currently."
+        exit 1
+      end
+    end
+
+    def template_type
+      blueprint_root = find_blueprint_root(@blueprint)
+      meta_config = "#{blueprint_root}/.meta/config.yml"
+      return false unless File.exist?(meta_config)
+
+      meta = YAML.load_file(meta_config)
+      meta['template_type']
+    end
+
+    def setup; end
+    def finish; end
+
+    # Meant to be overriden by subclass
+    # Return String with contents of variables file.
+    def variables
+      false
+    end
+
+    def create_param_file(app_template_path)
+      parameters = parameters(app_template_path)
+
+      lines = []
+      required = required(parameters)
+      lines << "# Required parameters:" unless required.empty?
+      required.each do |name, data|
+        example = description_example(data["Description"])
+        lines << "#{name}=#{example}"
+      end
+      optional = optional(parameters)
+      lines << "# Optional parameters:" unless optional.empty?
+      optional.each do |name, data|
+        value = default_value(data)
+        lines << "# #{name}=#{value}"
+      end
+
+      if lines.empty?
+        puts "Template has no parameters."
+        return
+      end
+
+      content = lines.join("\n") + "\n"
+      dest_path = "configs/#{@blueprint}/params/#{Lono.env}.txt" # only support environment level parameters for now
+      write(dest_path, content)
+      puts "Starter params created:    #{dest_path}"
+    end
+
+    def write(path, content)
+      FileUtils.mkdir_p(File.dirname(path))
+      IO.write(path, content)
+    end
+
+    def description_example(description)
+      default = '...'
+      return default unless description
+      md = description.match(/(Example|IE): (.*)/)
+      return default unless md
+      md[2]
+    end
+
+    def default_value(data)
+      value = data["Default"]
+      if value.blank?
+        description_example(data["Description"])
+      else
+        value
+      end
+    end
+
+    def parameters(app_template_path)
+      builder = Lono::Template::Dsl::Builder.new(app_template_path, @blueprint, quiet: false)
+      template = builder.template
+      template["Parameters"] || []
+    end
+    memoize :parameters
+
+    def required(parameters)
+      parameters.reject { |logical_id, p| p["Default"] }
+    end
+
+    def optional(parameters)
+      parameters.select { |logical_id, p| p["Default"] }
+    end
+
+  private
+    def with_each_template
+      paths = Dir.glob("#{Lono.config.templates_path}/**/*.rb")
+      files = paths.select{ |e| File.file?(e) }
+      files.each do |path|
+        yield(path)
+      end
+    end
+  end
+end