lono 4.2.7 → 5.0.1

data/lib/lono/help/generate.md

@@ -10,7 +10,6 @@ Generates CloudFormation template, parameter files, and scripts in lono project
 
     $ lono generate
     Generating CloudFormation templates, parameters, and scripts
-    No detected app/scripts
     Generating CloudFormation templates:
       output/templates/ec2.yml
     Generating parameter files:

data/lib/lono/help/new.md

@@ -1,54 +1,60 @@
 ## Examples
 
-    lono new infra # skeleton project with barebones structure
-    TEMPLATE=ec2 lono new infra # creates a single server
-    TEMPLATE=autoscaling lono new infra
+    lono new infra # starter project with demo blueprint
 
 By default, `lono new` generates a skeleton project. Use `TEMPLATE` to generate different starter projects. List of the [starter templates](https://github.com/tongueroo/lono/tree/master/lib/starter_projects).
 
 ## Example Output
 
-    $ lono new ec2
-    => Creating new project called ec2.
-          create  ec2
-          create  ec2/.gitignore
-          create  ec2/Gemfile
-          create  ec2/Guardfile
-          create  ec2/README.md
-          create  ec2/app/definitions/base.rb
-          create  ec2/config/settings.yml
-          create  ec2/welcome.txt
-          create  ec2/app/helpers
-          create  ec2/app/partials
-          create  ec2/app/scripts
-          create  ec2/app/templates
-          create  ec2/app/user_data
-          create  ec2/config/params
-          create  ec2/config/variables
-          create  ec2/output
-    => Installing dependencies with: bundle install
+    $ lono new infra
+    => Creating new project called infra.
+          create  infra
+          create  infra/.gitignore
+          create  infra/Gemfile
+          create  infra/Guardfile
+          create  infra/README.md
+          create  infra/configs/settings.yml
+    => Creating new blueprint called demo.
+          create  infra/blueprints/demo
+          create  infra/blueprints/demo/demo.gemspec
+          create  infra/blueprints/demo/.gitignore
+          create  infra/blueprints/demo/.meta/config.yml
+          create  infra/blueprints/demo/Gemfile
+          create  infra/blueprints/demo/README.md
+          create  infra/blueprints/demo/setup/configs.rb
+           exist  infra/blueprints/demo
+          create  infra/blueprints/demo/app/templates/demo.rb
+          create  infra/blueprints/demo/app/user_data/bootstrap.sh
+           exist  infra/blueprints/demo/app/templates
+           exist  infra
+          create  infra/configs/demo/params/base.txt
+          create  infra/configs/demo/params/development.txt
+          create  infra/configs/demo/variables/base.rb
+          create  infra/configs/demo/variables/development.rb
     => Initialize git repo
+    => Installing dependencies with: bundle install
+    => Commit git repo
     ================================================================
-    Congrats 🎉 You have successfully created a lono project.
+    Congrats  You have successfully created a lono project.  A starter demo blueprint was created
+    and is at blueprints/demo.  Check things out by going into the created infra folder.
 
-    Cd into your project and check things out:
+      cd infra
 
-      cd ec2
+    To generate the blueprint templates without launching a stack, you can run:
 
-    Add and edit templates for your project.  When you are ready to launch a CloudFormation stack run:
+      lono generate demo
 
-      lono cfn create STACK_NAME
+    The generated files are created at `output/demo/templates` and `output/demo/params`.
 
-    You can also get started quickly by importing other CloudFormation templates into lono.  For example:
+    To deploy the CloudFormation stack:
 
-      lono import https://s3-us-west-2.amazonaws.com/cloudformation-templates-us-west-2/EC2InstanceWithSecurityGroupSample.template --name ec2
+      lono cfn deploy my-demo --blueprint demo
 
-    To re-generate your templates without launching a stack, you can run:
+    If you name the stack according to conventions, you can simply run:
 
-      lono generate
+      lono cfn deploy demo
 
-    The generated CloudFormation templates are in the output/templates folder.
-    The generated stack parameters are in the output/params folder.  Here's the command with some output filtered to focus on learning.
+    To list and create additional blueprints refer to https://lono.cloud/docs/core/blueprints
 
     More info: http://lono.cloud/
-    $
+    $

data/lib/lono/help/param.md

@@ -1,3 +1,3 @@
 ## Examples
 
-  lono param generate
+    lono param generate

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

@@ -1,5 +1,5 @@
 ## Example
 
-To generate CloudFormation json parameter files in the params folder to `output/params`:
+To generate CloudFormation json parameter files in the `output` folder:
 
     lono param generate

data/lib/lono/help/template.md

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

data/lib/lono/help/xgraph.md

@@ -2,7 +2,7 @@
 
 With more complex CloudFormation templates, the dependency can get difficult to follow.  Visualizing the dependencies is helpful.
 
-    lono import https://s3.amazonaws.com/solutions-reference/aws-waf-security-automations/latest/aws-waf-security-automations.template --name waf
+    lono import https://s3.amazonaws.com/solutions-reference/aws-waf-security-automations/latest/aws-waf-security-automations.template --blueprint waf
     lono xgraph waf
 
 This above command generates a dependency chart.  The command uses the DependsOn attribute specified in each resource to figure this out.  It does not show implied dependencies that CloudFormaton automatically computes for us.  The chart looks like this:

data/lib/lono/inspector.rb

@@ -2,6 +2,6 @@ require "thor"
 
 class Lono::Inspector
   autoload :Base, 'lono/inspector/base'
-  autoload :Graph, 'lono/inspector/graph'
   autoload :Summary, 'lono/inspector/summary'
+  autoload :Graph, 'lono/inspector/graph'
 end

data/lib/lono/inspector/base.rb

@@ -1,23 +1,39 @@
 class Lono::Inspector::Base
-  def initialize(stack_name, options)
-    @stack_name = stack_name
-    @options = options
+  include Lono::Blueprint::Root
+
+  def initialize(blueprint, template, options)
+    @blueprint, @template, @options = blueprint, template, options
+  end
+
+  def run
+    blueprints = Lono::Blueprint::Find.one_or_all(@blueprint)
+    blueprints.each do |blueprint|
+      @blueprint_name = blueprint
+
+      generate_templates
+      set_blueprint_root(blueprint)
+      templates = @template ? [@template] : all_templates
+      templates.each do |template_name|
+        perform(template_name)
+      end
+    end
   end
 
   def generate_templates
-    Lono::Template::DSL.new(@options.clone.merge(quiet: true)).run
+    Lono::Template::Generator.new(@blueprint_name, @options.clone.merge(quiet: false)).run
   end
 
-  def run
-    generate_templates
-    perform
+  def all_templates
+    templates_path = "#{Lono.config.output_path}/#{@blueprint_name}/templates"
+    Dir.glob("#{templates_path}/**").map do |path|
+      path.sub("#{templates_path}/", '').sub('.yml','') # template_name
+    end
   end
 
   def data
-    return @data if @data
-    template_path = "#{Lono.config.output_path}/templates/#{@stack_name}.yml"
+    template_path = "#{Lono.config.output_path}/#{@blueprint_name}/templates/#{@template_name}.yml"
     check_template_exists(template_path)
-    @data = YAML.load(IO.read(template_path))
+    YAML.load(IO.read(template_path))
   end
 
   # Check if the template exists and print friendly error message.  Exits if it

data/lib/lono/inspector/graph.rb

@@ -2,13 +2,17 @@ require "yaml"
 require "graph"
 
 class Lono::Inspector::Graph < Lono::Inspector::Base
-  def initialize(stack_name, options)
+  def initialize(blueprint, template, options)
     super
     @nodes = [] # lookup map
   end
 
-  def perform
-    puts "Generating dependencies tree..."
+  def perform(template_name)
+    # little dirty but @template_name is used in data method
+    # so we dont have to pass it to the data method
+    @template_name = template_name
+
+    puts "Generating dependencies tree for template #{@template_name}..."
     return if @options[:noop]
 
     # First loop through top level nodes and build set depends_on property

data/lib/lono/inspector/summary.rb

@@ -1,6 +1,10 @@
 class Lono::Inspector::Summary < Lono::Inspector::Base
-  def perform
-    puts "=> CloudFormation Template Summary:".color(:green)
+  def perform(template_name)
+    # little dirty but @template_name is used in data method
+    # so we dont have to pass it to the data method
+    @template_name = template_name
+
+    puts "=> CloudFormation Template Summary for template #{@template_name.color(:sienna)}:"
     return if @options[:noop]
 
     print_parameters_summary
@@ -46,14 +50,22 @@ class Lono::Inspector::Summary < Lono::Inspector::Base
   end
 
   def resource_types
+    resources = data["Resources"]
+    return unless resources
+
     types = Hash.new(0)
-    data["Resources"].each do |logical_id, resource|
+    resources.each do |logical_id, resource|
       types[resource["Type"]] += 1
     end
     types
   end
 
   def print_resource_types
+    unless resource_types
+      puts "No resources found."
+      return
+    end
+
     types = resource_types.sort_by {|r| r[1] * -1} # Hash -> 2D Array
     types.each do |a|
       type, count = a

data/lib/lono/md5.rb

@@ -0,0 +1,46 @@
+require "digest"
+
+# 1. md5sum the file or zipfile - shared
+# 2. add prefix and md5sum - shared, lets break out prefix adding logic to elsewhere
+
+# Using md5sum on the zipped file will an always changing value since the timestamp and other metadata of the zipfile
+# changes whenever we create it.
+#
+# This is custom checksum logic that only accounts for the contents of the files in the directory.
+module Lono
+  class Md5
+    class << self
+      extend Memoist
+
+      # This checksum within the file name is to mainly make sure that Lambda::Function resources "change" and an update is triggered.
+      # There's another checksum in the upload code that makes sure we don't upload the code again to speed up things.
+      def sum(path)
+        files = Dir["#{path}/**/*"]
+        files = files.reject { |f| File.directory?(f) }
+                     .reject { |f| File.symlink?(f) }
+        files.sort!
+        content = files.map do |f|
+          Digest::MD5.file(f).to_s[0..7]
+        end.join
+
+        md5 = Digest::MD5.new
+        md5.update(content)
+        md5.hexdigest.to_s[0..7]
+      end
+      memoize :sum
+
+      def name(path)
+        relative_path = name_without_md5(path)
+        relative_path = relative_path.sub(/\.(\w+)$/,'') # strip extension
+        ext = File.directory?(path) ? "zip" : $1
+        md5 = sum(path)
+        "#{relative_path}-#{md5}.#{ext}"
+      end
+
+      def name_without_md5(path)
+        regexp = %r{.*/output/[\w_-]+/files/}
+        path.sub(regexp, '') # relative_path w/o md5
+      end
+    end
+  end
+end

data/lib/lono/new.rb

@@ -1,9 +1,6 @@
 module Lono
   class New < Sequence
-    autoload :Helper, 'lono/new/helper'
-    autoload :Message, 'lono/new/message'
     include Helper
-    include Message
 
     argument :project_name
 
@@ -13,19 +10,20 @@ module Lono
     # 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"],
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files."],
         [:git, type: :boolean, default: true, desc: "Git initialize the project"],
+        [:type, default: "dsl", desc: "Blueprint type: dsl or erb"],
       ]
     end
 
     cli_options.each do |args|
-      class_option *args
+      class_option(*args)
     end
 
     # for specs
     def set_cwd
-      @cwd = ENV['TEST'] ? File.dirname(Lono.root) : Dir.pwd
+      @cwd = Dir.pwd
     end
 
     def create_project
@@ -33,17 +31,9 @@ module Lono
       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
+    def create_starter_blueprint
+      # https://github.com/erikhuda/thor/wiki/Invocations
+      Lono::Blueprint.start(["demo", "--from-new", "--type", @options[:type], "--project-name", project_name])
     end
 
     # After this commands are executed with the newly created project
@@ -57,6 +47,11 @@ module Lono
       chmod("exe", 0755 & ~File.umask, verbose: false) if File.exist?("exe")
     end
 
+    def git_init
+      return if File.exist?(".git") # this is a clone repo
+      run_git_init
+    end
+
     def bundle_install
       return unless options[:bundle]
 
@@ -66,19 +61,36 @@ module Lono
       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'")
+    def git_commit
+      run_git_commit
     end
 
-    def final_message
-      puts welcome_message
+    def welcome_message
+      puts <<~EOL
+        #{"="*64}
+        Congrats 🎉 You have successfully created a lono project.  A starter demo blueprint was created
+        and is at blueprints/demo.  Check things out by going into the created infra folder.
+
+          cd #{project_name}
+
+        To generate the blueprint templates without launching a stack, you can run:
+
+          lono generate demo
+
+        The generated files are created at `output/demo/templates` and `output/demo/params`.
+
+        To deploy the CloudFormation stack:
+
+          lono cfn deploy my-demo --blueprint demo
+
+        If you name the stack according to conventions, you can simply run:
+
+          lono cfn deploy demo
+
+        To list and create additional blueprints refer to https://lono.cloud/docs/core/blueprints
+
+        More info: http://lono.cloud/
+      EOL
     end
   end
 end

data/lib/lono/new/helper.rb

@@ -4,9 +4,8 @@ module Lono::New::Helper
     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.
+  # Files should be named with underscores instead of dashes even though project name can contain a dash.
+  # This is because autoloading works with underscores in the filenames only.
   def underscored_name
     project_name.underscore
   end

data/lib/lono/param.rb

@@ -1,16 +1,17 @@
 require "thor"
 
-class Lono::Param < Lono::Command
-  autoload :Generator, 'lono/param/generator'
+module Lono
+  class Param < Lono::Command
+    class_option :verbose, type: :boolean
+    class_option :noop, type: :boolean
+    class_option :mute, type: :boolean
 
-  class_option :verbose, type: :boolean
-  class_option :noop, type: :boolean
-  class_option :mute, type: :boolean
-
-  desc "generate", "Generate all parameter files to `output/params`."
-  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)
+    desc "generate", "Generate all parameter files to `output/params`."
+    long_desc Lono::Help.text("param/generate")
+    def generate(blueprint=nil)
+      Blueprint::Find.one_or_all(blueprint).each do |b|
+        Generator.new(b, options).generate
+      end
+    end
   end
 end