lono 3.5.0 → 4.0.0

data/lib/lono/help/script/upload.md

@@ -0,0 +1,8 @@
+Uploads output/scripts/scripts-md5sum.tgz to s3_folder configured in settings.yml.  This command must be ran after `lono script build` since it relies the artifacts of that command. Namely:
+
+  * output/scripts/scripts-md5sum.tgz
+  * output/data/scripts_name.txt
+
+Examples:
+
+  lono script upload

data/lib/lono/help/template.md

@@ -0,0 +1,4 @@
+Examples:
+
+  lono template generate --help
+  lono template bashify --help

data/lib/lono/help/template/bashify.md

@@ -0,0 +1,4 @@
+Examples:
+
+  lono template bashify /path/to/cloudformation-template.json
+  lono template bashify https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2WebSiteSample.template

data/lib/lono/help/template/generate.md

@@ -0,0 +1,7 @@
+Examples:
+
+  lono template generate
+  lono template generate --clean
+  lono template g --clean
+
+Builds the CloudFormation templates files based on lono project and writes them to the output folder on the filesystem.

data/lib/lono/help/user_data.md

@@ -0,0 +1,3 @@
+Generates user_data scripts in `app/user_data` so you can see it for debugging. Let's say you have a script in `app/user_data/bootstrap.sh`. To generate it:
+
+  lono user_data bootstrap

data/lib/lono/importer.rb

@@ -7,7 +7,8 @@ class Lono::Importer
   def initialize(source, options)
     @source = source
     @options = options
-    @format = normalize_format(@options[:format])
+    @format = 'yml'
+    Lono::ProjectChecker.check
   end
 
   def run
@@ -15,20 +16,43 @@ class Lono::Importer
       download_template
       template_definition_path = add_template_definition
       create_params
-      puts "Imported raw CloudFormation template and lono-fied it!"
-      puts "Template definition added to #{template_definition_path}."
-      puts "Params file created to #{params_path}."
+      puts "=> Imported CloudFormation template and lono-fied it.".colorize(:green)
+      puts "Template definition added to #{pretty_path(template_definition_path)}"
+      puts "Params file created to #{pretty_path(params_path)}"
     end
-    puts "Template downloaded to #{template_path}." # like having this message at the end
+    puts "Template downloaded to #{pretty_path(template_path)}" # like having this message at the end
+
+    # at the end display some useful info for the user
+    return unless options[:summary]
+    summarize
+    show_params_file
+  end
+
+  def summarize
+    Lono::Inspector::Summary.new(template_name, @options).run
+  end
+
+  def show_params_file
+    path = "config/params/base/#{template_name}.txt"
+    puts "Here are contents of the params #{path} file:"
+    puts IO.read("#{Lono.root}/#{path}")
+  end
+
+  def json?(text)
+    JSON.load(text)
+    true # if reach here than it's just
+  rescue JSON::ParserError
+    false # not json
   end
 
   def download_template
     template =  open(@source).read
 
-    result = if @format == 'yml'
+    result = if json?(template)
+                # abusing YAML.dump(YAML.load()) to convert json to yaml
                 YAML.dump(YAML.load(template))
               else
-                JSON.pretty_generate(JSON.load(template))
+                template # template is already in YAML format
               end
 
     folder = File.dirname(template_path)
@@ -36,9 +60,9 @@ class Lono::Importer
     IO.write(template_path, result)
   end
 
-  # Add template definition to config/templates/base/stacks.rb.
+  # Add template definition to app/definitions/base.rb.
   def add_template_definition
-    path = "#{Lono.root}/config/templates/base/stacks.rb"
+    path = "#{Lono.config.definitions_path}/base.rb"
     lines = File.exist?(path) ? IO.readlines(path) : []
     new_template_definition = %Q|template "#{template_name}"|
     unless lines.detect { |l| l.include?(new_template_definition) }
@@ -51,11 +75,7 @@ class Lono::Importer
 
   # Creates starter params/base/[stack-name].txt file
   def create_params
-    template = if @format == 'yml'
-                YAML.load_file(template_path)
-              else
-                JSON.load(IO.read(template_path))
-              end
+    template = YAML.load_file(template_path)
 
     result = []
     required_parameters.each do |name, attributes|
@@ -73,17 +93,19 @@ class Lono::Importer
   end
 
   def params_path
-    "#{Lono.root}/params/base/#{template_name}.txt"
+    "#{Lono.config.params_path}/base/#{template_name}.txt"
   end
 
 
   def template_path
-    "#{Lono.root}/templates/#{template_name}.#{@format}"
+    "#{Lono.config.templates_path}/#{template_name}.#{@format}"
   end
 
   def template_name
     return @options[:name] if @options[:name]
-    # else infer name from the original source
+    # Else infer name from the original source.
+    # Not really being used since --name is now required but leaving in place
+    # in case we decide to make --name optional again
     name = File.basename(@source, ".*")
     @options[:casing] == "camelcase" ? name.camelize : name.underscore.dasherize
   end
@@ -103,11 +125,12 @@ private
 
   def template_data
     return @template_data if @template_data
-    template_path = "#{Lono.root}/templates/#{template_name}.#{@format}"
+    template_path = "#{Lono.config.templates_path}/#{template_name}.#{@format}"
     @template_data = YAML.load(IO.read(template_path))
   end
 
-  def normalize_format(format)
-    format == 'yaml' ? 'yml' : format
+  # removes the ./ at the beginning if it's there in the path
+  def pretty_path(path)
+    path[0..1] == './' ? path[2..-1] : path
   end
 end

data/lib/lono/inspector.rb

@@ -1,24 +1,7 @@
 require "thor"
 
-class Lono::Inspector < Lono::Command
-  autoload :Help, 'lono/inspector/help'
+class Lono::Inspector
   autoload :Base, 'lono/inspector/base'
-  autoload :Depends, 'lono/inspector/depends'
+  autoload :Graph, 'lono/inspector/graph'
   autoload :Summary, 'lono/inspector/summary'
-
-  class_option :verbose, type: :boolean
-  class_option :noop, type: :boolean
-
-  desc "depends STACK", "Prints dependencies tree of CloudFormation template resources"
-  long_desc Help.depends
-  option :display, type: :string, desc: "graph or text", default: "graph"
-  def depends(name)
-    Depends.new(name, options).run
-  end
-
-  desc "summary STACK", "Prints summary of CloudFormation template"
-  long_desc Help.summary
-  def summary(name)
-    Summary.new(name, options).run
-  end
 end

data/lib/lono/inspector/base.rb

@@ -5,7 +5,7 @@ class Lono::Inspector::Base
   end
 
   def generate_templates
-    Lono::Template::DSL.new(@options.clone).run
+    Lono::Template::DSL.new(@options.clone.merge(quiet: true)).run
   end
 
   def run
@@ -15,7 +15,7 @@ class Lono::Inspector::Base
 
   def data
     return @data if @data
-    template_path = "#{Lono.root}/output/#{@stack_name}.yml"
+    template_path = "#{Lono.config.output_path}/templates/#{@stack_name}.yml"
     check_template_exists(template_path)
     @data = YAML.load(IO.read(template_path))
   end

data/lib/lono/inspector/{depends.rb → graph.rb}

@@ -1,7 +1,7 @@
 require "yaml"
 require "graph"
 
-class Lono::Inspector::Depends < Lono::Inspector::Base
+class Lono::Inspector::Graph < Lono::Inspector::Base
   def initialize(stack_name, options)
     super
     @nodes = [] # lookup map
@@ -38,9 +38,9 @@ class Lono::Inspector::Depends < Lono::Inspector::Base
     end
   end
 
-  # normalized DependsOn attribute to an Array of Strings
+  # normalized DependOn attribute to an Array of Strings
   def normalize_depends_on(resource)
-    dependencies = resource["DependsOn"] || []
+    dependencies = resource["DependOn"] || []
     [dependencies].flatten
   end
 

data/lib/lono/inspector/summary.rb

@@ -1,6 +1,6 @@
 class Lono::Inspector::Summary < Lono::Inspector::Base
   def perform
-    puts "CloudFormation Template Summary:".colorize(:green)
+    puts "=> CloudFormation Template Summary:".colorize(:green)
     return if @options[:noop]
 
     puts "Parameters:"

data/lib/lono/new.rb

@@ -1,31 +1,84 @@
-class Lono::New
-  attr_reader :options
-  def initialize(options)
-    @options = options
-    @project_root = options[:project_root] || '.'
-    @format = options[:format] || 'json'
-  end
+module Lono
+  class New < Sequence
+    autoload :Helper, 'lono/new/helper'
+    autoload :Message, 'lono/new/message'
+    include Helper
+    include Message
+
+    argument :project_name
+
+    # Ugly, but when the class_option is only defined in the Thor::Group class
+    # it doesnt show up with cli-template new help :(
+    # If anyone knows how to fix this let me know.
+    # Also options from the cli can be pass through to here
+    def self.cli_options
+      [
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files."],
+        [:bundle, type: :boolean, default: true, desc: "Runs bundle install on the project"],
+        [:git, type: :boolean, default: true, desc: "Git initialize the project"],
+      ]
+    end
+
+    cli_options.each do |args|
+      class_option *args
+    end
 
-  def run
-    puts "Setting up lono project" unless options[:quiet]
-    source_root = File.expand_path("../../starter_projects/#{@format}_project", __FILE__)
-    paths = Dir.glob("#{source_root}/**/*").
-              select {|p| File.file?(p) }
-    paths.each do |src|
-      # starter_projects/yaml_project/ ->
-      regexp = Regexp.new(".*starter_projects/#{@format}_project/")
-      dest = src.gsub(regexp,'')
-      dest = "#{@project_root}/#{dest}"
-
-      if File.exist?(dest) and !options[:force]
-        puts "already exists: #{dest}" unless options[:quiet]
-      else
-        puts "creating: #{dest}" unless options[:quiet]
-        dirname = File.dirname(dest)
-        FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
-        FileUtils.cp(src, dest)
+    # for specs
+    def set_cwd
+      @cwd = ENV['TEST'] ? File.dirname(Lono.root) : Dir.pwd
+    end
+
+    def create_project
+      puts "=> Creating new project called #{project_name}."
+      directory ".", "#{@cwd}/#{project_name}"
+    end
+
+    def create_empty_directories
+      meths = Lono::Core::Config::PATHS.keys
+      meths.each do |meth|
+        path = "#{@cwd}/#{project_name}/#{Lono.config.send(meth)}"
+        next if File.exist?(path)
+        if ENV['TEST']
+          empty_directory Lono.config.send(meth)
+        else
+          empty_directory path
+        end
       end
     end
-    puts "Starter lono project created" unless options[:quiet]
+
+    # After this commands are executed with the newly created project
+    def set_destination_root
+      destination_root = "#{@cwd}/#{project_name}"
+      self.destination_root = destination_root
+      FileUtils.cd(self.destination_root)
+    end
+
+    def make_executable
+      chmod("exe", 0755 & ~File.umask, verbose: false) if File.exist?("exe")
+    end
+
+    def bundle_install
+      return unless options[:bundle]
+
+      puts "=> Installing dependencies with: bundle install"
+      Bundler.with_clean_env do
+        system("BUNDLE_IGNORE_CONFIG=1 bundle install")
+      end
+    end
+
+    def git_init
+      return if !options[:git]
+      return unless git_installed?
+      return if File.exist?(".git") # this is a clone repo
+
+      puts "=> Initialize git repo"
+      run("git init")
+      run("git add .")
+      run("git commit -m 'first commit'")
+    end
+
+    def final_message
+      puts welcome_message
+    end
   end
 end

data/lib/lono/new/helper.rb

@@ -0,0 +1,16 @@
+module Lono::New::Helper
+  private
+  def project_class_name
+    project_name.underscore.camelize
+  end
+
+  # Files should be named with underscores instead of dashes even
+  # though project name can contain a dash. This is because autoloading
+  # works will underscores in the filenames only.
+  def underscored_name
+    project_name.underscore
+  end
+
+  # project_name is also available from new.rb:
+  #   argument :project_name
+end

data/lib/lono/new/message.rb

@@ -0,0 +1,35 @@
+module Lono::New::Message
+  private
+  def welcome_message
+    <<-EOL
+#{"="*64}
+Congrats 🎉 You have successfully created a lono project.
+
+Cd into your project and check things out:
+
+  cd #{project_name}
+
+#{template_specific_message}
+To re-generate your templates without launching a stack, you can run:
+
+  lono generate
+
+The generated CloudFormation templates are in the output/templates folder.
+The generated stack parameters are in the output/params folder.
+
+More info: http://lono.cloud/
+EOL
+  end
+
+  def template_specific_message
+    starter_projects = File.expand_path("../../starter_projects", File.dirname(__FILE__))
+    welcome_path = "#{starter_projects}/#{ENV['TEMPLATE']}/welcome.txt"
+    puts "welcome_path #{welcome_path.inspect}"
+
+    # default to the skeleton welcome message
+    unless File.exist?(welcome_path)
+      welcome_path = "#{starter_projects}/skeleton/welcome.txt"
+    end
+    IO.read(welcome_path)
+  end
+end

data/lib/lono/param.rb

@@ -1,7 +1,6 @@
 require "thor"
 
 class Lono::Param < Lono::Command
-  autoload :Help, 'lono/param/help'
   autoload :Generator, 'lono/param/generator'
 
   class_option :verbose, type: :boolean
@@ -9,7 +8,7 @@ class Lono::Param < Lono::Command
   class_option :mute, type: :boolean
 
   desc "generate", "generate all parameter files to json format"
-  long_desc Help.generate
+  long_desc Lono::Help.text("param/generate")
   option :path, desc: "Name of the source that maps to the params txt file.  name -> params/NAME.txt.  Use this to override the params/NAME.txt convention"
   def generate
     Generator.generate_all(options)

data/lib/lono/param/generator.rb

@@ -1,8 +1,6 @@
 class Lono::Param::Generator
-  include Lono::CurrentRegion
-
   def self.generate_all(options)
-    puts "Generating params files"
+    puts "Generating parameter files:"
 
     params = param_names("base") + param_names(Lono.env)
     params.uniq.each do |name|
@@ -18,39 +16,48 @@ class Lono::Param::Generator
   # Returns:
   #   param_names("base") => ["a", "b", "c"]
   def self.param_names(folder)
-    base_folder = "#{Lono.root}/params/#{folder}" # Example: "./params/base"
+    base_folder = "#{Lono.config.params_path}/#{folder}" # Example: "./params/base"
     Dir.glob("#{base_folder}/**/*.txt").map do |path|
       path.sub("#{base_folder}/", '').sub('.txt','')
     end
   end
 
   def initialize(name, options)
-    @_name = "#{Lono.env}/#{name}"
-    @_options = options
-    @_env_path = options[:path] || "#{Lono.root}/params/#{@_name}.txt"
-    @_base_path = @_env_path.sub("/#{Lono.env}/", "/base/")
+    @name = "#{Lono.env}/#{name}"
+    @options = options
+    @env_path = options[:path] || "#{Lono.config.params_path}/#{@name}.txt"
+    @base_path = @env_path.sub("/#{Lono.env}/", "/base/")
   end
 
   def generate
     # useful option for lono cfn
-    return if @_options[:allow_no_file] && !source_exist?
+    return if @options[:allow_no_file] && !source_exist?
 
     if source_exist?
-      contents = overlay_sources
+      contents = process_erb
       data = convert_to_cfn_format(contents)
       json = JSON.pretty_generate(data)
       write_output(json)
-      # Example: @_name = stag/ecs/private
+      # Example: @name = stag/ecs/private
       #          pretty_name = ecs/private
-      pretty_name = @_name.sub("#{Lono.env}/", '')
-      puts "Params file generated for #{pretty_name} at #{output_path}" unless @_options[:mute]
+      pretty_name = @name.sub("#{Lono.env}/", '')
+      puts "  #{output_path}" unless @options[:mute]
     else
-      puts "#{@_base_path} or #{@_env_path} could not be found?  Are you sure it exist?"
+      puts "#{@base_path} or #{@env_path} could not be found?  Are you sure it exist?"
       exit 1
     end
     json
   end
 
+  # useful for when calling CloudFormation via the aws-sdk gem
+  def params(casing = :underscore)
+    # useful option for lono cfn
+    return {} if @options[:allow_no_file] && !source_exist?
+
+    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
@@ -68,51 +75,23 @@ class Lono::Param::Generator
   #   params/prod/mystack.txt - env path
   #
   #   the prod/mystack.txt is used to produced a prod/mystack.txt
-  def overlay_sources
+  def process_erb
     contents = []
-    contents << process_erb(@_base_path)
-    contents << process_erb(@_env_path)
+    contents << render_erb(@base_path)
+    contents << render_erb(@env_path)
     contents.compact.join("\n")
   end
 
-  def process_erb(path)
+  def render_erb(path)
     if File.exist?(path)
-      template = IO.read(path)
-      erb_result(path, template)
+      RenderMePretty.result(path, context: context)
     end
   end
 
-  def erb_result(path, template)
-    load_variables
-    begin
-      ERB.new(template, nil, "-").result(binding)
-    rescue Exception => e
-      puts e
-      puts e.backtrace if ENV['DEBUG']
-
-      # 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(/^\.\//, '').colorize(:green)}"
-
-      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
+  # 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
 
   # Checks both base and source path for existing of the param file.
@@ -120,16 +99,7 @@ class Lono::Param::Generator
   #   params/base/mystack.txt - base path
   #   params/prod/mystack.txt - source path
   def source_exist?
-    File.exist?(@_base_path) || File.exist?(@_env_path)
-  end
-
-  # useful for when calling CloudFormation via the aws-sdk gem
-  def params(casing = :underscore)
-    # useful option for lono cfn
-    return {} if @_options[:allow_no_file] && !source_exist?
-
-    contents = overlay_sources
-    convert_to_cfn_format(contents, casing)
+    File.exist?(@base_path) || File.exist?(@env_path)
   end
 
   def parse_contents(contents)
@@ -177,35 +147,13 @@ class Lono::Param::Generator
   end
 
   def output_path
-    "#{Lono.root}/output/params/#{@_name}.json".sub(/\.\//,'')
+    name = @name.sub("#{Lono.env}/", "") # remove the Lono.env from the output path
+    "#{Lono.config.output_path}/params/#{name}.json".sub(/\.\//,'')
   end
 
   def write_output(json)
     dir = File.dirname(output_path)
-    FileUtils.mkdir_p(dir) unless File.exist?(dir)
+    FileUtils.mkdir_p(dir)
     IO.write(output_path, json)
   end
-
-
-  def load_variables
-    load_variables_folder("base")
-    load_variables_folder(Lono.env)
-  end
-
-  # Load the variables defined in config/variables/* to make available the params/*.txt files
-  #
-  # Example:
-  #
-  #   `config/variables/base/variables.rb`:
-  #      @ami = 123
-  #
-  #   `params/ecs/private.txt`:
-  #     AmiId=<%= @ami %>
-  #
-  def load_variables_folder(folder)
-    paths = Dir.glob("#{Lono.root}/config/variables/#{folder}/**/*")
-    paths.select{ |e| File.file? e }.each do |path|
-      instance_eval(IO.read(path))
-    end
-  end
 end