lono 1.1.3 → 2.0.0

data/lib/lono/template/bashify.rb

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

@@ -0,0 +1,139 @@
+class Lono::Template::DSL
+  def initialize(options={})
+    @options = options
+    @project_root = @options[:project_root] || '.'
+    @path = "#{@project_root}/config/lono.rb"
+    Lono::ProjectChecker.check(@project_root)
+    @templates = []
+    @results = {}
+    @detected_format = nil
+  end
+
+  def run(options={})
+    evaluate_templates
+    build_templates
+    write_output
+  end
+
+  def evaluate_templates
+    instance_eval(File.read(@path), @path)
+    load_subfolder
+    @detected_format = detect_format
+  end
+
+  # Detects the format of the templates.  Simply checks the extension of all the
+  # templates files.
+  # All the templates must be of the same format, either all json or all yaml.
+  def detect_format
+    # @templates contains Array of Hashes. Example:
+    # [{name: ""blog-web-prod.json", block: ...},
+    #  {name: ""api-web-prod.json", block: ...}]
+    formats = @templates.map{ |t| File.extname(t[:name]) }.uniq
+    if formats.size > 1
+      puts "ERROR: Detected multiple formats: #{formats.join(", ")}".colorize(:red)
+      puts "All the source values in the template blocks in the config folder must have the same format extension."
+      exit 1
+    else
+      found_format = formats.first
+      if found_format
+        detected_format = found_format.sub(/^\./,'')
+        detected_format = "yaml" if detected_format == "yml"
+      else # empty templates, no templates defined yet
+        detected_format = "yaml" # defaults to yaml
+      end
+    end
+    detected_format
+  end
+
+  # load any templates defined in project/config/lono/*
+  def load_subfolder
+    Dir.glob("#{File.dirname(@path)}/lono/**/*").select{ |e| File.file? e }.each do |path|
+      instance_eval(File.read(path), path)
+    end
+  end
+
+  def template(name, &block)
+    @templates << {name: name, block: block}
+  end
+
+  def build_templates
+    @templates.each do |t|
+      @results[t[:name]] = Lono::Template::Template.new(t[:name], t[:block], @options).build
+    end
+  end
+
+  def write_output
+    output_path = "#{@project_root}/output"
+    FileUtils.rm_rf(output_path) if @options[:clean]
+    FileUtils.mkdir(output_path) unless File.exist?(output_path)
+    puts "Generating CloudFormation templates:" unless @options[:quiet]
+    @results.each do |name,text|
+      path = "#{output_path}/#{name}".sub(/^\.\//,'')
+      puts "  #{path}" unless @options[:quiet]
+      ensure_parent_dir(path)
+      validate(text, path)
+      File.open(path, 'w') do |f|
+        f.write(output_format(text))
+      end
+    end
+  end
+
+  # TODO: set @detected_format upon DSL.new
+  def validate(text, path)
+    if @detected_format == "json"
+      validate_json(text, path)
+    else
+      validate_yaml(text, path)
+    end
+  end
+
+  def validate_yaml(yaml, path)
+    begin
+      YAML.load(yaml)
+    rescue Psych::SyntaxError => e
+      puts "Invalid yaml.  Output written to #{path} for debugging".colorize(:red)
+      puts "ERROR: #{e.message}".colorize(:red)
+      File.open(path, 'w') {|f| f.write(yaml) }
+      exit 1
+    end
+  end
+
+  def validate_json(json, path)
+    begin
+      JSON.parse(json)
+    rescue JSON::ParserError => e
+      puts "Invalid json.  Output written to #{path} for debugging".colorize(:red)
+      puts "ERROR: #{e.message}".colorize(:red)
+      File.open(path, 'w') {|f| f.write(json) }
+      exit 1
+    end
+  end
+
+  def output_format(text)
+    @options[:pretty] ? prettify(text) : text
+  end
+
+  # Input text is either yaml or json.
+  # Do not prettify yaml format because it removes the !Ref like CloudFormation notation
+  def prettify(text)
+    @detected_format == "json" ? JSON.pretty_generate(JSON.parse(text)) : yaml_format(text)
+  end
+
+  def yaml_format(text)
+    comment =<<~EOS
+      # This file was generated with lono. Do not edit directly, the changes will be lost.
+      # More info: https://github.com/tongueroo/lono
+    EOS
+    "#{comment}#{remove_blank_lines(text)}"
+  end
+
+  # ERB templates leaves blank lines around, remove those lines
+  def remove_blank_lines(text)
+    text.split("\n").reject { |l| l.strip == '' }.join("\n") + "\n"
+  end
+
+  def ensure_parent_dir(path)
+    dir = File.dirname(path)
+    FileUtils.mkdir_p(dir) unless File.exist?(dir)
+  end
+end

data/lib/lono/template/help.rb

@@ -0,0 +1,25 @@
+module Lono::Template::Help
+  def generate
+<<-EOL
+Examples:
+
+$ lono template generate
+
+$ lono template g -c # shortcut
+
+Builds the CloudFormation templates files based on lono project and writes them to the output folder on the filesystem.
+EOL
+  end
+
+  def bashify
+<<-EOL
+Examples:
+
+$ lono template bashify /path/to/cloudformation-template.json
+
+$ lono template bashify https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2WebSiteSample.template
+EOL
+  end
+
+  extend self
+end

data/lib/lono/template/template.rb

@@ -0,0 +1,251 @@
+require 'erb'
+require 'json'
+require 'base64'
+
+class Lono::Template::Template
+  include ERB::Util
+
+  attr_reader :name
+  def initialize(name, block, options={})
+    @name = name
+    @block = block
+    @options = options
+  end
+
+  def build
+    instance_eval(&@block)
+    template = IO.read(@source)
+    erb_result(@source, template)
+  end
+
+  def source(path)
+    @source = path[0..0] == '/' ? path : "#{@options[:project_root]}/templates/#{path}"
+  end
+
+  def variables(vars={})
+    vars.each do |var,value|
+      instance_variable_set("@#{var}", value)
+    end
+  end
+
+  def partial(path,vars={}, options={})
+    path = "#{@options[:project_root]}/templates/partial/#{path}"
+    template = IO.read(path)
+    variables(vars)
+    result = erb_result(path, template)
+    result = indent(result, options[:indent]) if options[:indent]
+    result
+  end
+
+  # add indentation
+  def indent(result, indentation_amount)
+    result.split("\n").map do |line|
+      " " * indentation_amount + line
+    end.join("\n")
+  end
+
+  def erb_result(path, template)
+    begin
+      ERB.new(template, nil, "-").result(binding)
+    rescue Exception => e
+      puts e
+
+      # how to know where ERB stopped? - https://www.ruby-forum.com/topic/182051
+      # syntax errors have the (erb):xxx info in e.message
+      # undefined variables have (erb):xxx info in e.backtrac
+      error_info = e.message.split("\n").grep(/\(erb\)/)[0]
+      error_info ||= e.backtrace.grep(/\(erb\)/)[0]
+      raise unless error_info # unable to find the (erb):xxx: error line
+      line = error_info.split(':')[1].to_i
+      puts "Error evaluating ERB template on line #{line.to_s.colorize(:red)} of: #{path.sub(/^\.\//, '')}"
+
+      template_lines = template.split("\n")
+      context = 5 # lines of context
+      top, bottom = [line-context-1, 0].max, line+context-1
+      spacing = template_lines.size.to_s.size
+      template_lines[top..bottom].each_with_index do |line_content, index|
+        line_number = top+index+1
+        if line_number == line
+          printf("%#{spacing}d %s\n".colorize(:red), line_number, line_content)
+        else
+          printf("%#{spacing}d %s\n", line_number, line_content)
+        end
+      end
+      exit 1 unless ENV['TEST']
+    end
+  end
+
+  def user_data(path, vars={})
+    path = "#{@options[:project_root]}/templates/user_data/#{path}"
+    template = IO.read(path)
+    variables(vars)
+    result = erb_result(path, template)
+    output = []
+    result.split("\n").each do |line|
+      output += transform(line)
+    end
+    json = output.to_json
+    json[0] = '' # remove first char: [
+    json.chop!   # remove last char:  ]
+  end
+
+  def ref(name)
+    %Q|{"Ref"=>"#{name}"}|
+  end
+
+  def find_in_map(*args)
+    %Q|{"Fn::FindInMap" => [ #{transform_array(args)} ]}|
+  end
+
+  def base64(value)
+    %Q|{"Fn::Base64"=>"#{value}"}|
+  end
+
+  def get_att(*args)
+    %Q|{"Fn::GetAtt" => [ #{transform_array(args)} ]}|
+  end
+
+  def get_azs(region="AWS::Region")
+    %Q|{"Fn::GetAZs"=>"#{region}"}|
+  end
+
+  def join(delimiter, values)
+    %Q|{"Fn::Join" => ["#{delimiter}", [ #{transform_array(values)} ]]}|
+  end
+
+  def select(index, list)
+    %Q|{"Fn::Select" => ["#{index}", [ #{transform_array(list)} ]]}|
+  end
+
+  def transform_array(arr)
+    arr.map! {|x| x =~ /=>/ ? x : x.inspect }
+    arr.join(',')
+  end
+
+  # transform each line of bash script to array with cloudformation template objects
+  def transform(data)
+    data = evaluate(data)
+    if data[-1].is_a?(String)
+      data[0..-2] + ["#{data[-1]}\n"]
+    else
+      data + ["\n"]
+    end
+  end
+
+  # Input:
+  #   String
+  # Output:
+  #   Array of parse positions
+  #
+  # The positions of tokens taking into account when brackets start and close,
+  # handles nested brackets.
+  def bracket_positions(line)
+    positions,pair,count = [],[],0
+
+    line.split('').each_with_index do |char,i|
+      pair << i if pair.empty?
+
+      first_pair_char = line[pair[0]]
+      if first_pair_char == '{' # object logic
+        if char == '{'
+          count += 1
+        end
+
+        if char == '}'
+          count -= 1
+          if count == 0
+            pair << i
+            positions << pair
+            pair = []
+          end
+        end
+      else # string logic
+        lookahead = line[i+1]
+        if lookahead == '{'
+          pair << i
+          positions << pair
+          pair = []
+        end
+      end
+    end # end of loop
+
+    # for string logic when lookahead does not contain a object token
+    # need to clear out what's left to match the final pair
+    if !pair.empty?
+      pair << line.size - 1
+      positions << pair
+    end
+
+    positions
+  end
+
+  # Input:
+  #   Array - bracket_positions
+  # Ouput:
+  #   Array - positions that can be use to determine what to parse
+  def parse_positions(line)
+    positions = bracket_positions(line)
+    positions.flatten
+  end
+
+  # Input
+  #   String line of code to decompose into chunks, some can be transformed into objects
+  # Output
+  #   Array of strings, some can be transformed into objects
+  #
+  # Example:
+  # line = 'a{b}c{d{d}d}e' # nested brackets
+  # template.decompose(line).should == ['a','{b}','c','{d{d}d}','e']
+  def decompose(line)
+    positions = parse_positions(line)
+    return [line] if positions.empty?
+
+    result = []
+    str = ''
+    until positions.empty?
+      left = positions.shift
+      right = positions.shift
+      token = line[left..right]
+      # if cfn object, add to the result set but after clearing out
+      # the temp str that is being built up when the token is just a string
+      if cfn_object?(token)
+        unless str.empty? # first token might be a object
+          result << str
+          str = ''
+        end
+        result << token
+      else
+        str << token # keeps building up the string
+      end
+    end
+
+    # at the of the loop there's a leftover string, unless the last token
+    # is an object
+    result << str unless str.empty?
+
+    result
+  end
+
+  def cfn_object?(s)
+    exact = %w[Ref]
+    pattern = %w[Fn::]
+    exact_match = !!exact.detect {|word| s.include?(word)}
+    pattern_match = !!pattern.detect {|p| s =~ Regexp.new(p)}
+    (exact_match || pattern_match) && s =~ /^{/ && s =~ /=>/
+  end
+
+  def recompose(decomposition)
+    decomposition.map { |s| cfn_object?(s) ? eval(s) : s }
+  end
+
+  def evaluate(line)
+    recompose(decompose(line))
+  end
+
+  # For simple just parameters files that can also be generated with lono, the CFN
+  # Fn::Base64 function is not available and as lono is not being used in the context
+  # of CloudFormation.  So this can be used in it's place.
+  def encode_base64(text)
+    Base64.strict_encode64(text).strip
+  end
+end