lono 4.2.7 → 5.0.1

data/lib/lono/param/generator.rb

@@ -1,47 +1,88 @@
 class Lono::Param::Generator
-  def self.generate_all(options)
-    puts "Generating parameter files:"
+  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
 
-    params = param_names("base") + param_names(Lono.env)
-    params.uniq.each do |name|
-      param = Lono::Param::Generator.new(name, options)
-      param.generate
+  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
 
-  # Returns param names
-  # Example:
-  # Given params:
-  #   params/base/a.txt params/base/b.txt params/base/c.txt
-  # Returns:
-  #   param_names("base") => ["a", "b", "c"]
-  def self.param_names(folder)
-    base_folder = "#{Lono.config.params_path}/#{folder}" # Example: "./params/base"
-    Dir.glob("#{base_folder}/**/*.txt").map do |path|
-      path.sub("#{base_folder}/", '').sub('.txt','')
+  # 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
+
+    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
     end
   end
 
-  def initialize(name, options)
-    @name = "#{Lono.env}/#{name}"
-    @options = options
-    @env_path = options[:path] || "#{Lono.config.params_path}/#{@name}.txt"
-    @base_path = @env_path.sub("/#{Lono.env}/", "/base/")
+  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
+
+    [@base_path, @env_path]
   end
 
   def generate
-    # useful option for lono cfn
-    return if @options[:allow_no_file] && !source_exist?
+    puts "Generating parameter files for blueprint #{@blueprint.color(:green)}:"
+
+    @base_path, @env_path = lookup_paths
+
+    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?
 
     if source_exist?
       contents = process_erb
       data = convert_to_cfn_format(contents)
       json = JSON.pretty_generate(data)
       write_output(json)
-      # Example: @name = stag/ecs/private
-      #          pretty_name = ecs/private
-      pretty_name = @name.sub("#{Lono.env}/", '')
-      puts "  #{output_path}" unless @options[:mute]
+      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
@@ -49,10 +90,21 @@ class Lono::Param::Generator
     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
+
   # 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_no_file] && !source_exist?
+    return {} if @options[:allow_not_exists] && !source_exist?
 
     contents = process_erb
     convert_to_cfn_format(contents, casing)
@@ -61,7 +113,7 @@ class Lono::Param::Generator
   # Reads both the base source and env source and overlay the two
   # Example 1:
   #   params/base/mystack.txt - base path
-  #   params/prod/mystack.txt - env 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
@@ -72,17 +124,21 @@ class Lono::Param::Generator
   #   the base/mystack.txt is used to produced a prod/mystack.txt
   #
   # Example 3:
-  #   params/prod/mystack.txt - env path
+  #   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)
-    contents.compact.join("\n")
+    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)
     end
@@ -91,15 +147,7 @@ class Lono::Param::Generator
   # 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.
-  # Example:
-  #   params/base/mystack.txt - base path
-  #   params/prod/mystack.txt - source path
-  def source_exist?
-    File.exist?(@base_path) || File.exist?(@env_path)
+    @context ||= Lono::Template::Context.new(@blueprint, @options)
   end
 
   def parse_contents(contents)
@@ -147,8 +195,14 @@ class Lono::Param::Generator
   end
 
   def output_path
-    name = @name.sub("#{Lono.env}/", "") # remove the Lono.env from the output path
-    "#{Lono.config.output_path}/params/#{name}.json".sub(/\.\//,'')
+    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)

data/lib/lono/project_checker.rb

@@ -4,24 +4,43 @@ module Lono
   # If not, provide a friendly message and possibly exit.
   class ProjectChecker
     class << self
+      # 2 ways to use lono.
+      #
+      #   1. A standalone project - not available below version 5
+      #   2. A multimode project - available after version 5
+      #
+      @@checked = false
       def check
-        check_lono_project
+        return if @@checked
+
+        unless standalone? or multimode?
+          puts "ERROR: Was unable to detect that you are within a lono project. Are you sure you are in lono project?".color(:red)
+          quit 1
+        end
+
+        @@mode = standalone? ? :standalone : :multimode
+
+        @@checked = true
       end
 
-      def check_lono_project
+      def mode
+        @@mode
+      end
+
+      def standalone?
         paths = %w[
-          config/settings.yml
           app/definitions
           app/templates
         ]
-        paths.each do |path|
-          unless File.exist?("#{Lono.root}/#{path}")
-            puts "ERROR: The #{path} does not exist in this project.  Are you sure you are in lono project?".color(:red)
-            quit 1
-          end
+        paths.all? do |path|
+          File.exist?("#{Lono.root}/#{path}")
         end
       end
 
+      def multimode?
+        File.exist?("#{Lono.root}/configs/settings.yml")
+      end
+
       # Dont exit for this one. It's okay. But show a warning.
       def empty_templates
         if Dir["#{Lono.config.templates_path}/**/*"].empty?

data/lib/lono/s3.rb

@@ -0,0 +1,23 @@
+module Lono
+  class S3 < Command
+    desc "deploy", "deploys lono managed s3 bucket"
+    long_desc Help.text("s3/deploy")
+    def deploy
+      Bucket.new(options).deploy
+    end
+
+    desc "show", "shows lono managed s3 bucket"
+    long_desc Help.text("s3/show")
+    option :sure, type: :boolean, desc: "Bypass are you sure prompt"
+    def show
+      Bucket.new(options).show
+    end
+
+    desc "delete", "deletes lono managed s3 bucket"
+    long_desc Help.text("s3/delete")
+    option :sure, type: :boolean, desc: "Bypass are you sure prompt"
+    def delete
+      Bucket.new(options).delete
+    end
+  end
+end

data/lib/lono/s3/bucket.rb

@@ -0,0 +1,123 @@
+class Lono::S3
+  class Bucket
+    STACK_NAME = ENV['LONO_STACK_NAME'] || "lono"
+    include Lono::AwsServices
+    extend Lono::AwsServices
+
+    class << self
+      @@name = nil
+      def name
+        return @@name if @@name # only memoize once bucket has been created
+
+        stack = new.find_stack
+        return unless stack
+
+        resp = cfn.describe_stack_resources(stack_name: STACK_NAME)
+        bucket = resp.stack_resources.find { |r| r.logical_resource_id == "Bucket" }
+        @@name = bucket.physical_resource_id # actual bucket name
+      end
+    end
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def deploy
+      stack = find_stack
+      if stack
+        update
+      else
+        create
+      end
+    end
+
+    def exist?
+      !!bucket_name
+    end
+
+    def bucket_name
+      self.class.name
+    end
+
+    def show
+      if bucket_name
+        puts "Lono bucket name: #{bucket_name}"
+      else
+        puts "Lono bucket does not exist yet."
+      end
+    end
+
+    # 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
+    end
+
+    def update
+      puts "Updating #{STACK_NAME} stack with the s3 bucket"
+      cfn.update_stack(stack_name: STACK_NAME, template_body: template_body)
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      raise unless e.message.include?("No updates are to be performed")
+    end
+
+    def delete
+      are_you_sure?
+
+      puts "Deleting #{STACK_NAME} stack with the s3 bucket"
+      empty_bucket!
+      cfn.delete_stack(stack_name: STACK_NAME)
+    end
+
+    def find_stack
+      resp = cfn.describe_stacks(stack_name: STACK_NAME)
+      resp.stacks.first
+    rescue Aws::CloudFormation::Errors::ValidationError
+      nil
+    end
+
+  private
+
+    def empty_bucket!
+      resp = s3.list_objects(bucket: bucket_name)
+      if resp.contents.size > 0
+        # IE: objects = [{key: "objectkey1"}, {key: "objectkey2"}]
+        objects = resp.contents.map { |item| {key: item.key} }
+        s3.delete_objects(
+          bucket: bucket_name,
+          delete: {
+            objects: objects,
+            quiet: false,
+          }
+        )
+        empty_bucket! # keep deleting objects until bucket is empty
+      end
+    end
+
+
+    def are_you_sure?
+      return true if @options[:sure]
+
+      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
+      unless yes
+        puts "Phew that was close."
+        exit
+      end
+    end
+
+    def template_body
+      <<~YAML
+        Resources:
+          Bucket:
+            Type: AWS::S3::Bucket
+            Properties:
+              Tags:
+                - Key: Name
+                  Value: lono
+      YAML
+    end
+  end
+end

data/lib/lono/script.rb

@@ -1,19 +1,15 @@
 module Lono
   class Script < Command
-    autoload :Base, "lono/script/base"
-    autoload :Build, "lono/script/build"
-    autoload :Upload, "lono/script/upload"
-
     desc "build", "Builds `output/scripts/scripts-md5sum.tgz` from `app/script` folder"
     long_desc Help.text("script/build")
-    def build
-      Build.new(options).run
+    def build(blueprint)
+      Build.new(blueprint, options).run
     end
 
     desc "upload", "Uploads `output/scripts/scripts-md5sum.tgz` to s3"
     long_desc Help.text("script/upload")
-    def upload
-      Upload.new(options).run
+    def upload(blueprint)
+      Upload.new(blueprint, options).run
     end
   end
 end

data/lib/lono/script/base.rb

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

data/lib/lono/script/build.rb

@@ -11,11 +11,10 @@ class Lono::Script
     def run
       Lono::ProjectChecker.check
       reset
-      if Dir["#{Lono.root}/app/scripts/*"].empty?
-        puts "No detected app/scripts"
+      if Dir["#{Lono.blueprint_root}/app/scripts/*"].empty?
         return
       else
-        puts "Detected app/scripts"
+        puts "Detected app/scripts for blueprint #{@blueprint}"
       end
 
       puts "Tarballing app/scripts folder to scripts.tgz"
@@ -36,12 +35,12 @@ class Lono::Script
     def create_tarball
       # https://apple.stackexchange.com/questions/14980/why-are-dot-underscore-files-created-and-how-can-i-avoid-them
       # using system to avoid displaying command
-      system "cd app && dot_clean ." if system("type dot_clean > /dev/null 2>&1")
+      system "cd #{Lono.blueprint_root}/app && dot_clean ." if system("type dot_clean > /dev/null 2>&1")
 
       # https://serverfault.com/questions/110208/different-md5sums-for-same-tar-contents
       # Using tar czf directly results in a new m5sum each time because the gzip
       # timestamp is included.  So using:  tar -c ... | gzip -n
-      sh "cd app && tar -c scripts | gzip -n > scripts.tgz" # temporary app/scripts.tgz file
+      sh "cd #{Lono.blueprint_root}/app && tar -c scripts | gzip -n > scripts.tgz" # temporary app/scripts.tgz file
 
       rename_with_md5!
     end
@@ -49,9 +48,9 @@ class Lono::Script
     # Apppend a md5 to file after it's been created and moves it to
     # output/scripts/scripts-[MD5].tgz
     def rename_with_md5!
-      md5_path = "output/scripts/scripts-#{md5sum}.tgz"
+      md5_path = "output/#{@blueprint}/scripts/scripts-#{md5sum}.tgz"
       FileUtils.mkdir_p(File.dirname(md5_path))
-      FileUtils.mv("app/scripts.tgz", md5_path)
+      FileUtils.mv("#{Lono.blueprint_root}/app/scripts.tgz", md5_path)
       md5_path
     end
 
@@ -62,7 +61,7 @@ class Lono::Script
 
     # cache this because the file will get removed
     def md5sum
-      @md5sum ||= Digest::MD5.file("app/scripts.tgz").to_s[0..7]
+      @md5sum ||= Digest::MD5.file("#{Lono.blueprint_root}/app/scripts.tgz").to_s[0..7]
     end
 
     def sh(command)