lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/files/concerns/post_processing.rb

@@ -0,0 +1,35 @@
+module Lono::Files::Concerns
+  module PostProcessing
+    extend Memoist
+
+    def build
+      Lono::Files::Builder.new(@options.merge(files: self)).run
+    end
+
+    def compress
+      Lono::Files::Compressor.new(@options.merge(files: self)).run
+    end
+
+    def upload
+      uploader.upload # Lono::S3::Uploader#upload
+    end
+
+    delegate :s3_path, :s3_key, to: :uploader
+    def uploader
+      Lono::S3::Uploader.new(zip_path)
+    end
+    memoize :uploader
+
+    def zip_name
+      "#{File.basename(full_path)}-#{Lono::Md5.sum(full_path)}.zip"
+    end
+
+    def zip_path
+      "#{File.dirname(output_path)}/#{zip_name}"
+    end
+
+    def output_path
+      "#{Lono.root}/output/#{@blueprint.name}/#{path}"
+    end
+  end
+end

data/lib/lono/files/concerns/registration.rb

@@ -0,0 +1,13 @@
+module Lono::Files::Concerns
+  module Registration
+    def call_line
+      @caller.find do |line|
+        line.include?(Lono.root.to_s)
+      end
+    end
+
+    def marker
+      "LONO://#{@path}"
+    end
+  end
+end

data/lib/lono/files/registry.rb

@@ -0,0 +1,6 @@
+class Lono::Files
+  class Registry
+    class_attribute :files
+    self.files = []
+  end
+end

data/lib/lono/files.rb

@@ -0,0 +1,37 @@
+# Class name is Lono::Files because can represent a single file or a directory.
+# Also, it avoids conflicting with the stdlib File class name.
+# Files is like a "FileList". Using shorter Files name.
+module Lono
+  class Files < Lono::CLI::Base
+    include Concerns::Registration
+    include Concerns::PostProcessing
+
+    attr_reader :path
+    def initialize(options={})
+      super
+      @path = options[:path]
+      @caller = options[:caller] # original caller stack at registration time
+    end
+
+    def full_path
+      "#{@blueprint.root}/#{@path}"
+    end
+
+    class << self
+      def register(options={})
+        path = options[:path]
+        file = files.find { |f| f.path == path }
+        unless file
+          file = Files.new(options.merge(caller: caller))
+          files << file
+        end
+        file.marker
+      end
+
+      delegate :empty?, :files, to: :files
+      def files
+        Registry.files
+      end
+    end
+  end
+end

data/lib/lono/importer/base.rb

@@ -1,11 +1,11 @@
 class Lono::Importer
-  class Base < Lono::AbstractBase
+  class Base < Lono::CLI::Base
     include Download
     include Thor::Actions
     include Thor::Base
 
     def initialize(options)
-      reinitialize(options)
+      super
       @source = options[:source]
       @tmp_path = "/tmp/lono/import/template.yml"
       self.destination_root = Dir.pwd # Thor::Actions require destination_root to be set
@@ -14,7 +14,7 @@ class Lono::Importer
   private
     def summarize
       return unless @options[:summary]
-      puts "Template Summary:"
+      logger.info "Template Summary:"
       Lono::Inspector::Summary.new(@options).run
     end
 
@@ -24,10 +24,10 @@ class Lono::Importer
     end
 
     def create_params_file(template_path, env)
-      params_path = if @blueprint != @template
-                      "configs/#{@blueprint}/params/#{env}/#{@template}.txt"
+      params_path = if @blueprint.name != @template
+                      "config/#{@blueprint.name}/params/#{env}/#{@template}.txt"
                     else
-                      "configs/#{@blueprint}/params/#{env}.txt"
+                      "config/#{@blueprint.name}/params/#{env}.txt"
                     end
       params = Params.new(template_path, params_path)
       params.create

data/lib/lono/importer/download.rb

@@ -23,16 +23,16 @@ class Lono::Importer
     def read_source(source)
       open(source).read
     rescue OpenURI::HTTPError, SocketError, Errno::ENOENT
-      puts "ERROR: Unable to read source template provided: #{source}".color(:red)
+      logger.info "ERROR: Unable to read source template provided: #{source}".color(:red)
       e = $!
-      puts "#{e.class}: #{e.message}"
-      puts "Please double check the source provided."
+      logger.info "#{e.class}: #{e.message}"
+      logger.info "Please double check the source provided."
       exit 1
     rescue Exception => e
-      puts "ERROR: Unable to read source template provided: #{source}".color(:red)
-      puts "General Exception Error:"
-      puts "#{e.class}: #{e.message}"
-      puts "Please double check the source provided."
+      logger.info "ERROR: Unable to read source template provided: #{source}".color(:red)
+      logger.info "General Exception Error:"
+      logger.info "#{e.class}: #{e.message}"
+      logger.info "Please double check the source provided."
       exit 1
     end
 

data/lib/lono/importer/dsl.rb

@@ -4,7 +4,7 @@ class Lono::Importer
       tmp_template_path = download_template(@source, @tmp_path)
       template = IO.read(tmp_template_path)
 
-      Lono::Blueprint::New.start([@blueprint, "--import", "--type", "dsl"])
+      Lono::Blueprint::New.start([@blueprint.name, "--import", "--type", "dsl"])
 
       translate_to_dsl(template)
       create_params(tmp_template_path)
@@ -19,13 +19,13 @@ class Lono::Importer
       coder = Service::Coder.new(template, @options)
       result = coder.translate
 
-      path = "#{Lono.config.templates_path}/#{@template}.rb"
+      path = "#{Lono.config.paths.templates}/#{@template}.rb"
       FileUtils.mkdir_p(File.dirname(path))
       create_file(path, result) # Thor::Action
     end
 
     def final_message
-      puts <<~EOL
+      logger.info <<~EOL
         #{"="*64}
         Congrats 🎉 You have successfully imported a lono blueprint.
 

data/lib/lono/importer/service/coder.rb

@@ -2,80 +2,84 @@ require 'base64'
 require 'json'
 require 'net/http'
 
-class Lono::Importer::Service::Coder
-  def initialize(template, options={})
-    @template, @options = template, options
-  end
-
-  def translate
-    url = "#{Lono::API}/code"
-    http = net_http_client(url)
-    req = net_http_request(url,
-      template: Base64.encode64(@template), # Base64 JSON for special chars that Rack::LintWrapper cannot process
-      lono_version: Lono::VERSION,
-      lono_command: lono_command,
-    )
-    res = http.request(req) # send request
+module Lono::Importer::Service
+  class Coder
+    include Lono::Utils::Logging
 
-    if res.code == "200"
-      data = JSON.load(res.body)
-      ruby_code = print(data) # returns data["ruby_code"] / passthrough
-      ruby_code
-    else
-      puts "Error: Unable to convert template to Ruby code."
-      puts "The error has been reported."
-      puts "Non-successful http response status code: #{res.code}"
-      # puts "headers: #{res.each_header.to_h.inspect}"
-      exit 1
+    def initialize(template, options={})
+      @template, @options = template, options
     end
-  end
 
-private
-  def print(data)
-    return if ENV['LONO_PRO_TEST']
+    def translate
+      url = "#{Lono::API}/code"
+      http = net_http_client(url)
+      req = net_http_request(url,
+        template: Base64.encode64(@template), # Base64 JSON for special chars that Rack::LintWrapper cannot process
+        lono_version: Lono::VERSION,
+        lono_command: lono_command,
+      )
+      res = http.request(req) # send request
 
-    if data["error"]
-      # Code was processed but there was this error with an HTTP 200 OK
-      $stderr.puts "ERROR: #{data["error"]}".color(:red)
-      if data["message"]
-        $stderr.puts data["message"]
+      if res.code == "200"
+        data = JSON.load(res.body)
+        ruby_code = print(data) # returns data["ruby_code"] / passthrough
+        ruby_code
+      else
+        logger.info "Error: Unable to convert template to Ruby code."
+        logger.info "The error has been reported."
+        logger.info "Non-successful http response status code: #{res.code}"
+        # logger.info "headers: #{res.each_header.to_h.inspect}"
+        exit 1
       end
-      return
     end
 
-    validity = data["valid_ruby"] ? "valid" : "invalid"
-    if validity == "valid"
-      $stderr.puts "INFO: The generated Ruby code is has #{validity} syntax."
-    else
-      $stderr.puts "WARN: The generated Ruby code is has #{validity} syntax. Providing because it may be small errors.".color(:yellow) # note redirection disables color
-    end
+  private
+    def print(data)
+      return if ENV['LONO_PRO_TEST']
 
-    $stderr.puts <<~EOL
-      Translated ruby code below:
+      if data["error"]
+        # Code was processed but there was this error with an HTTP 200 OK
+        logger.info "ERROR: #{data["error"]}".color(:red)
+        if data["message"]
+          logger.info data["message"]
+        end
+        return
+      end
 
-    EOL
-    ruby_code = data["ruby_code"]
-    puts ruby_code
-    ruby_code
-  end
+      validity = data["valid_ruby"] ? "valid" : "invalid"
+      if validity == "valid"
+        logger.info "INFO: The generated Ruby code is has #{validity} syntax."
+      else
+        logger.info "WARN: The generated Ruby code is has #{validity} syntax. Providing because it may be small errors.".color(:yellow) # note redirection disables color
+      end
 
-  def net_http_client(url)
-    uri = URI(url)
-    http = Net::HTTP.new(uri.host, uri.port)
-    http.open_timeout = http.read_timeout = 30
-    http.use_ssl = true if uri.scheme == 'https'
-    http
-  end
+      logger.info <<~EOL
+        Translated ruby code below:
 
-  def net_http_request(url, data)
-    req = Net::HTTP::Post.new(url) # url includes query string and uri.path does not, must used url
-    text = JSON.dump(data)
-    req.body = text
-    req.content_length = text.bytesize
-    req
-  end
+      EOL
+      ruby_code = data["ruby_code"]
+      logger.info ruby_code
+      ruby_code
+    end
+
+    def net_http_client(url)
+      uri = URI(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = http.read_timeout = 30
+      http.use_ssl = true if uri.scheme == 'https'
+      http
+    end
+
+    def net_http_request(url, data)
+      req = Net::HTTP::Post.new(url) # url includes query string and uri.path does not, must used url
+      text = JSON.dump(data)
+      req.body = text
+      req.content_length = text.bytesize
+      req
+    end
 
-  def lono_command
-    "#{$0} #{ARGV.join(' ')}"
+    def lono_command
+      "#{$0} #{ARGV.join(' ')}"
+    end
   end
 end

data/lib/lono/importer.rb

@@ -1,14 +1,5 @@
 module Lono
-  class Importer
-    def initialize(options)
-      @options = options
-
-      Lono::ProjectChecker.check
-      @blueprint = Lono::Conventions.new(options).blueprint
-      # Dont use set_blueprint_root because it doesnt exist yet. The import creates it
-      Lono.blueprint_root = "#{Lono.root}/app/blueprints/#{@blueprint}"
-    end
-
+  class Importer < Lono::CLI::Base
     def run
       # Examples:
       #   Lono::Importer::Erb.new(source, options.clone).run

data/lib/lono/inspector/base.rb

@@ -1,29 +1,29 @@
 module Lono::Inspector
-  class Base < Lono::AbstractBase
+  class Base < Lono::CLI::Base
     extend Memoist
 
     def run
-      generate
+      build
       templates = @template_name ? [@template_name] : all_templates
       templates.each do |template_name|
         perform(template_name)
       end
     end
 
-    def generate
+    def build
       if @options[:source]
         Lono::Cfn::Download.new(@options).run
       else
-        generate_templates
+        build_templates
       end
     end
 
-    def generate_templates
-      Lono::Template::Generator.new(@options.merge(quiet: false)).run
+    def build_templates
+      Lono::Builder::Template.new(@options.merge(quiet: false)).run
     end
 
     def all_templates
-      templates_path = "#{Lono.config.output_path}/#{@blueprint}/templates"
+      templates_path = "#{Lono.root}/output/#{@blueprint.name}/templates"
       Dir.glob("#{templates_path}/**").map do |path|
         path.sub("#{templates_path}/", '').sub('.yml','') # template_name
       end

data/lib/lono/inspector/summary.rb

@@ -1,43 +1,42 @@
 module Lono::Inspector
   class Summary < Base
-    delegate :required_parameters, :optional_parameters, :parameters, :parameter_groups, :data,
-             to: :output_template
+    include Lono::Cfn::Concerns::TemplateOutput
 
     def perform(template)
       # little dirty but @template is used in data method so we dont have to pass it to the data method
       @template = template
-
-      puts "=> CloudFormation Template Summary for template #{@template.color(:sienna)}:"
-      return if @options[:noop]
-
+      logger.info "=> CloudFormation Template Summary for template #{@template.color(:sienna)}:"
       print_parameters_summary
-      puts "# Resources:"
+      logger.info "# Resources:"
       print_resource_types
     end
 
     def print_parameters_summary
+      parameters = template_output.parameters
+      parameter_groups = template_output.parameter_groups
+
       if parameters.empty?
-        puts "There are no parameters in this template."
+        logger.info "There are no parameters in this template."
         return
       end
 
       shown = []
-      puts "# Parameters Total (#{parameters.size})"
+      logger.info "# Parameters Total (#{parameters.size})"
       parameter_groups.each do |label, parameters|
-        puts "# Parameter Group (#{parameters.size}): #{label}".color(:sienna)
+        logger.info "# Parameter Group (#{parameters.size}): #{label}".color(:sienna)
         parameters.each do |name|
-          puts parameter_line(name)
+          logger.info parameter_line(name)
           shown << name
         end
-      end if output_template.parameter_groups
+      end if parameter_groups
 
       parameters.each do |name, data|
-        puts parameter_line(name) unless shown.include?(name)
+        logger.info parameter_line(name) unless shown.include?(name)
       end
     end
 
     def parameter_line(name)
-      data = parameters[name]
+      data = template_output.parameters[name]
       example = description_example(data["Description"])
       if data["Default"].nil?
         line = "#{name}=#{example} # (required)"
@@ -58,7 +57,7 @@ module Lono::Inspector
     end
 
     def resource_types
-      resources = data["Resources"]
+      resources = template_output.data["Resources"]
       return unless resources
 
       types = Hash.new(0)
@@ -70,7 +69,7 @@ module Lono::Inspector
 
     def print_resource_types
       unless resource_types
-        puts "No resources found."
+        logger.info "No resources found."
         return
       end
 
@@ -83,9 +82,9 @@ module Lono::Inspector
       printf "%3s %s\n", total, "Total"
     end
 
-    def output_template
-      Lono::Output::Template.new(@blueprint, @template)
+    def template_output
+      Lono::Builder::Template::Output.new(@blueprint)
     end
-    memoize :output_template
+    memoize :template_output
   end
 end

data/lib/lono/layering/layer.rb

@@ -0,0 +1,112 @@
+require "aws_data"
+
+# Layers example
+#
+#     app/blueprints/demo/config/params/base.txt
+#     app/blueprints/demo/config/params/dev.txt
+#     app/blueprints/demo/config/params/prod.txt
+#     app/blueprints/demo/config/vars/base.rb
+#     app/blueprints/demo/config/vars/dev.rb
+#     app/blueprints/demo/config/vars/prod.rb
+#
+module Lono::Layering
+  class Layer
+    include Lono::Layering
+    include Lono::Utils::Logging
+    include Lono::Utils::Pretty
+    include Lono::Concerns::AwsInfo
+    extend Memoist
+
+    def initialize(blueprint, type)
+      @blueprint, @type = blueprint, type
+    end
+
+    def paths
+      blueprint = full_layers("app/blueprints/#{@blueprint.name}/config")
+      project = full_layers("config/blueprints/#{@blueprint.name}")
+      paths = blueprint + project
+      add_ext!(paths)
+      paths.map! { |p| "#{Lono.root}/#{p}" }
+      show_layers(paths)
+      paths
+    end
+
+    def full_layering
+      # layers defined in Lono::Layering module
+      all = layers.map { |layer| layer.sub(/\/$/,'') } # strip trailing slash
+      all.inject([]) do |sum, layer|
+        sum += layer_levels(layer) unless layer.nil?
+        sum
+      end
+    end
+
+    # interface method
+    def main_layers
+      [
+        '',
+        region,
+        account,
+        "#{account}/#{region}",
+      ]
+    end
+
+    def account
+      name = aws_data.account
+      # friendly name mapping
+      names = Lono.config.layering.names.stringify_keys
+      names[name] || name
+    end
+
+    # adds prefix and to each layer pair that has base and Lono.env. IE:
+    #
+    #    "#{prefix}/base"
+    #    "#{prefix}/#{Lono.env}"
+    #
+    def layer_levels(prefix=nil)
+      levels = ["base", Lono.env]
+      levels.map! do |i|
+        # base layer has prefix of '', reject with blank so it doesnt produce '//'
+        [prefix, i].reject(&:blank?).join('/')
+      end
+      levels.unshift(prefix) # unless prefix.blank? # IE: params/us-west-2.txt
+      levels
+    end
+
+    def add_ext!(paths)
+      exts = {
+        params: "txt",
+        vars: "rb",
+      }
+      ext = exts[@type.to_sym]
+
+      paths.map! do |path|
+        path = path.sub(/\/$/,'') if path.ends_with?('/')
+        "#{path}.#{ext}"
+      end
+    end
+
+    def full_layers(dir)
+      layers = full_layering.map do |layer|
+        "#{dir}/#{@type}/#{layer}"
+      end
+      if Lono.app
+        app_layers = full_layering.map do |layer|
+          "#{dir}/#{@type}/#{Lono.app}/#{layer}"
+        end
+        layers += app_layers
+      end
+      layers
+    end
+
+    @@shown_layers = {}
+    def show_layers(paths)
+      return if @@shown_layers[@type]
+      logger.debug "#{@type.capitalize} Layers:"
+      paths.each do |path|
+        logger.debug "    #{pretty_path(path)}" if File.exist?(path) || ENV['LONO_SHOW_ALL_LAYERS']
+      end
+      logger.debug ""
+      @@shown_layers[@type] = true
+    end
+  end
+end

data/lib/lono/layering.rb

@@ -1,65 +1,23 @@
-module Lono
-  class Layering < AbstractBase
-    extend Memoist
-
-    def initialize(config, options={}, env=Lono.env, root=Lono.root)
-      super(options)
-      # config can be params or variables
-      @config, @options, @env, @root = config, options, env, root
-      @requested = determine_requested
-    end
-
-    def locations
-      paths = always + requested
-      layers = paths.map do |path|
-        requested_file(path)
-      end.compact
-      print_layers(layers)
-      layers
-    end
-
-    def always
-      base = "#{@root}/configs/#{@blueprint}/#{@config}/base"
-      env = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}"
-      [base, env]
-    end
+require "active_support/lazy_load_hooks"
 
-    def requested
-      standard_layers + direct_layers
-    end
-
-    def standard_layers
-      config_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@requested}"
-      env_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}/#{@requested}"
-      template_level = "#{@root}/configs/#{@blueprint}/#{@config}/#{@env}/#{@template}/#{@requested}"
-      [config_level, env_level, template_level]
-    end
-
-    def direct_layers
-      if @requested.starts_with?('/')
-        [@requested] # IE: absolute full path
-      else
-        ["#{@root}/#{@requested}"] # IE : relative path within lono project]
-      end
+module Lono
+  module Layering
+    def layers
+      pre_layers + main_layers + post_layers
     end
 
-    def print_layers(layers)
-      return unless ENV["LONO_DEBUG_LAYERING"]
-      puts "layers #{@config}:"
-      pp layers
+    def main_layers
+      super
     end
 
-    def determine_requested
-      # param is usually set from the convention. when set from convention stack name takes higher precedence
-      config_key = @config.singularize.to_sym # param or variable
-      @options[config_key] || @options[:config] || @stack
+    def pre_layers
+      []
     end
 
-    def requested_file(path)
-      # List of paths to consider from initial path provided. Combine params and variables possible paths for simplicity.
-      paths = [path, "#{path}.txt", "#{path}.sh", "#{path}.rb"].compact
-      paths.find { |p| File.file?(p) }
+    def post_layers
+      []
     end
-    memoize :requested_file
   end
 end
+
+ActiveSupport.run_load_hooks(:lono_layering, Lono::Layering)

data/lib/lono/logger/formatter.rb

@@ -0,0 +1,13 @@
+class Lono::Logger
+  class Formatter < ::Logger::Formatter
+    def call(severity, time, progname, msg)
+      # careful changing the format. All::Summary uses a regexp on this format to remove the timestamp
+      "[#{format_datetime(time)} ##{Process.pid} #{progname}]: #{msg}"
+    end
+
+  private
+    def format_datetime(time)
+      time.strftime("%Y-%m-%dT%H:%M:%S")
+    end
+  end
+end