lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/logger.rb

@@ -0,0 +1,32 @@
+require 'logger'
+
+module Lono
+  class Logger < ::Logger
+    def initialize(*args)
+      super
+      self.formatter = Formatter.new
+      self.level = ENV['LONO_LOG_LEVEL'] || :info # note: only respected when config.logger not set in config/app.rb
+    end
+
+    def format_message(severity, datetime, progname, msg)
+      line = if @logdev.dev == $stdout || @logdev.dev == $stderr || @logdev.dev.is_a?(StringIO)
+        msg # super simple format if stdout
+      else
+        super # use the configured formatter
+      end
+      line =~ /\n$/ ? line : "#{line}\n"
+    end
+
+    # Used to allow output to always go to stdout
+    def stdout(msg, newline: true)
+      if newline
+        puts msg
+      else
+        print msg
+      end
+    end
+
+    public :print
+    public :printf
+  end
+end

data/lib/lono/names.rb

@@ -0,0 +1,50 @@
+module Lono
+  class Names
+    extend Memoist
+
+    attr_reader :blueprint
+    def initialize(options={})
+      @options = options
+      @blueprint = options[:blueprint]
+    end
+
+    def stack
+      expansion(Lono.config.names.stack) # IE: :APP-:BLUEPRINT-:ENV
+    end
+    memoize :stack
+
+    def expansion(string)
+      return string unless string.is_a?(String) # in case of nil
+
+      string = string.dup
+      vars = string.scan(/:\w+/) # => [":APP", ":BLUEPRINT", :ENV"]
+      vars.each do |var|
+        string.gsub!(var, var_value(var))
+      end
+      strip(string)
+    end
+
+    def var_value(unexpanded)
+      name = unexpanded.sub(':','').downcase
+      if respond_to?(name)
+        value = send(name).to_s
+      else
+        unexpanded
+      end
+    end
+
+    def strip(string)
+      string.sub(/^-+/,'').sub(/-+$/,'') # remove leading and trailing -
+            .gsub(%r{-+},'-') # remove double dashes are more. IE: -- => -
+            .gsub('_','-')    # underscores are not allowed in CloudFormation stack names
+    end
+
+    def app
+      Lono.app
+    end
+
+    def env
+      Lono.env
+    end
+  end
+end

data/lib/lono/plugin/meta.rb

@@ -0,0 +1,30 @@
+class Lono::Plugin
+  module Meta
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :meta, default: []
+    end
+
+    class_methods do
+      def register(o={})
+        found = meta.find { |m| m[:name] == o[:name] && m[:type] == o[:type] }
+        meta << o unless found
+      end
+
+      def find(o={})
+        found = meta.find { |m| m[:name] == o[:name] && m[:type] == o[:type] }
+        Lono::Plugin.new(found) if found
+      end
+
+      def delegate_to_meta(*attrs)
+        attrs.each do |attr|
+          attr = attr.to_sym
+          define_method attr do
+            @options[attr]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lono/plugin/tester.rb

@@ -0,0 +1,13 @@
+class Lono::Plugin
+  class Tester
+    class << self
+      def register(name, options={})
+        Lono::Plugin.register(
+          name: name,
+          type: "test_framework",
+          root: options[:root],
+        )
+      end
+    end
+  end
+end

data/lib/lono/plugin.rb

@@ -0,0 +1,10 @@
+module Lono
+  class Plugin
+    include Meta
+    delegate_to_meta :name, :root
+
+    def initialize(options={})
+      @options = options
+    end
+  end
+end

data/lib/lono/s3/aws_setup.rb

@@ -1,12 +1,13 @@
-class Lono::S3
+module Lono::S3
   class AwsSetup
     include Lono::AwsServices
+    include Lono::Utils::Logging
 
     def check!
       s3.config.region
     rescue Aws::Errors::MissingRegionError => e
-      puts "ERROR: #{e.class}: #{e.message}".color(:red)
-      puts <<~EOL
+      logger.info "ERROR: #{e.class}: #{e.message}".color(:red)
+      logger.info <<~EOL
         Unable to detect the AWS_REGION to make AWS API calls. This is might be because the AWS access
         has not been set up yet. Please either your ~/.aws files.
       EOL

data/lib/lono/s3/bucket.rb

@@ -1,41 +1,23 @@
-class Lono::S3
+module Lono::S3
   class Bucket
-    STACK_NAME = ENV['LONO_STACK_NAME'] || "lono"
     include Lono::AwsServices
+    include Lono::Cfn::Concerns
+    include Lono::Utils::Logging
     extend Lono::AwsServices
     extend Memoist
 
-    class << self
-      @@name = nil
-      def name
-        return @@name if @@name # only memoize once bucket has been created
-
-        check_aws_setup!
-
-        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
-
-      def check_aws_setup!
-        AwsSetup.new.check!
-      end
-    end
-
+    STACK_NAME = ENV['LONO_STACK_NAME'] || "lono"
     def initialize(options={})
       @options = options
     end
 
     def deploy
       stack = find_stack
-      if rollback_complete?(stack)
-        puts "Existing '#{STACK_NAME}' stack in ROLLBACK_COMPLETE state. Deleting stack before continuing."
+      if rollback.complete?
+        logger.info "Existing '#{STACK_NAME}' stack in ROLLBACK_COMPLETE state. Deleting stack before continuing."
+        disable_termination_protection
         cfn.delete_stack(stack_name: STACK_NAME)
         status.wait
-        status.reset
         stack = nil
       end
 
@@ -56,30 +38,29 @@ class Lono::S3
 
     def show
       if bucket_name
-        puts "Lono bucket name: #{bucket_name}"
+        logger.info "Lono bucket name: #{bucket_name}"
       else
-        puts "Lono bucket does not exist yet."
+        logger.info "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"
+      logger.info "Creating #{STACK_NAME} stack for s3 bucket to store templates"
       cfn.create_stack(
         stack_name: STACK_NAME,
         template_body: template_body,
         enable_termination_protection: true,
       )
       success = status.wait
-      status.reset
       unless success
-        puts "ERROR: Unable to create lono stack with managed s3 bucket".color(:red)
+        logger.info "ERROR: Unable to create lono stack with managed s3 bucket".color(:red)
         exit 1
       end
     end
 
     def update
-      puts "Updating #{STACK_NAME} stack with the s3 bucket"
+      logger.info "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")
@@ -88,13 +69,13 @@ class Lono::S3
     def delete
       are_you_sure?
 
-      puts "Deleting #{STACK_NAME} stack with the s3 bucket"
-      disable_termination_protect
+      logger.info "Deleting #{STACK_NAME} stack with the s3 bucket"
+      disable_termination_protection
       empty_bucket!
       cfn.delete_stack(stack_name: STACK_NAME)
     end
 
-    def disable_termination_protect
+    def disable_termination_protection
       cfn.update_termination_protection(
         stack_name: STACK_NAME,
         enable_termination_protection: false,
@@ -111,7 +92,6 @@ class Lono::S3
     def status
       CfnStatus.new(STACK_NAME)
     end
-    memoize :status
 
   private
 
@@ -135,18 +115,18 @@ class Lono::S3
 
 
     def are_you_sure?
-      return true if @options[:sure]
+      return true if @options[:yes]
 
       if bucket_name.nil?
-        puts "The lono stack and s3 bucket does not exist."
+        logger.info "The lono stack and s3 bucket does not exist."
         exit
       end
 
-      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."
+      logger.info "Are you yes you want the lono bucket #{bucket_name.color(:green)} to be emptied and deleted? (y/N)"
+      yes = $stdin.gets.strip
+      confirmed = yes =~ /^Y/i
+      unless confirmed
+        logger.info "Phew that was close."
         exit
       end
     end
@@ -167,5 +147,25 @@ class Lono::S3
                   Value: lono
       YAML
     end
+
+    def rollback
+      Rollback.new(STACK_NAME)
+    end
+
+    class << self
+      @@name = nil
+      def name
+        return @@name if @@name # only memoize once bucket has been created
+
+        AwsSetup.new.check!
+
+        stack = new.find_stack
+        return unless stack
+
+        stack_resources = find_stack_resources(STACK_NAME)
+        bucket = stack_resources.find { |r| r.logical_resource_id == "Bucket" }
+        @@name = bucket.physical_resource_id # actual bucket name
+      end
+    end
   end
 end

data/lib/lono/s3/rollback.rb

@@ -0,0 +1,8 @@
+module Lono::S3
+  class Rollback < Lono::Cfn::Deploy::Rollback
+    # override initialize
+    def initialize(stack)
+      @stack = stack
+    end
+  end
+end

data/lib/lono/s3/uploader.rb

@@ -1,57 +1,48 @@
-class Lono::S3
+module Lono::S3
   class Uploader
-    include Lono::AwsServices
     extend Memoist
+    include Lono::AwsServices
+    include Lono::Utils::Logging
+    include Lono::Utils::Pretty
 
-    attr_reader :path
-    def initialize(path, options={})
-      @path, @options = path, options
+    attr_reader :local_path
+    def initialize(local_path, options={})
+      @local_path, @options = local_path, options
       @checksums = {}
     end
 
     # Inputs:
     #
-    #   path: can be full path or relative path
+    #   local_path: can be full path or relative path
     #
     def upload
-      return if @options[:noop] || ENV['LONO_TEST'] == '1'
-
-      path = @path.gsub("#{Lono.root}/",'') # remove Lono.root
-      key = "#{Lono.env}/#{path}"
-
-      pretty_path = path.sub(/^\.\//, '')
-      s3_full_path = "s3://#{s3_bucket}/#{key}"
+      logger.debug "May upload   #{local_path}"
+      logger.debug "To           #{s3_path}"
 
-      local_checksum = Digest::MD5.hexdigest(IO.read(path))
-      remote_checksum = remote_checksum(key)
+      local_checksum = Digest::MD5.hexdigest(IO.read(local_path))
       if local_checksum == remote_checksum
-        puts("Not modified: #{pretty_path} to #{s3_full_path}".color(:yellow)) unless @options[:noop]
+        logger.debug "Not modified #{s3_path}"
         return # do not upload unless the checksum has changed
       else
         # Example output:
-        # Uploaded: app/files/docker.yml to s3://boltops-dev/s3_folder/templates/development/docker.yml
-        # Uploaded: app/files/ecs/private.yml to s3://boltops-dev/s3_folder/templates/development/ecs/private.yml
-        message = "Uploading: #{pretty_path} to #{s3_full_path}".color(:green)
-        message = "NOOP: #{message}" if @options[:noop]
-        puts message
+        # Uploaded: files/ecs/private.yml to s3://bucket/output/demo/files/ecs/private.yml
+        logger.debug "Uploading #{pretty_path(local_path)} to #{s3_path}"
       end
 
       s3.put_object(
-        body: IO.read(path),
+        body: IO.read(local_path),
         bucket: s3_bucket,
-        key: key,
-      ) unless @options[:noop]
+        key: s3_key,
+      )
     end
 
     # https://s3.amazonaws.com/mybucket/development/output/blueprint/templates/blueprint.yml
     def https_url
-      key = "#{Lono.env}/#{@path}"
-      "https://s3.amazonaws.com/#{s3_bucket}/#{key}"
+      "https://s3.amazonaws.com/#{s3_bucket}/#{s3_key}"
     end
 
     def presigned_url
-      key = "#{Lono.env}/#{@path}"
-      s3_presigner.presigned_url(:get_object, bucket: s3_bucket, key: key)
+      s3_presigner.presigned_url(:get_object, bucket: s3_bucket, key: s3_key)
     end
 
     # used for file_s3_key helper
@@ -64,7 +55,7 @@ class Lono::S3
       resp = s3.list_objects(bucket: s3_bucket, prefix: prefix)
       resp.contents.each do |object|
         # key does not include the bucket name
-        #    full path = s3://my-bucket/s3_folder/files/production/my-template.yml
+        #    full path = s3://my-bucket/files/production/my-template.yml
         #    key = s3_folder/files/production/my-template.yml
         # etag is the checksum as long as the file is not a multi-part file upload
         # it has extra double quotes wrapped around it.
@@ -76,17 +67,25 @@ class Lono::S3
     memoize :load_checksums!
 
     # key example: cloudformation/production/files/lifecycle-0719ab81.zip
-    # s3 path: s3://boltops-dev/cloudformation/production/files/lifecycle-0719ab81.zip
-    # s3_folder: s3://boltops-dev/cloudformation
-    def remote_checksum(key)
-      load_checksums!(key)
-      @checksums[key]
+    # s3 path: s3://bucket/cloudformation/production/files/lifecycle-0719ab81.zip
+    # s3_folder: s3://bucket/cloudformation
+    def remote_checksum
+      load_checksums!(s3_key)
+      @checksums[s3_key]
     end
 
     def strip_surrounding_quotes(string)
       string.sub(/^"/,'').sub(/"$/,'')
     end
 
+    def s3_path
+      "s3://#{s3_bucket}/#{s3_key}"
+    end
+
+    def s3_key
+      "#{Lono.env}/#{pretty_path(local_path)}"
+    end
+
     def s3_bucket
       Lono::S3::Bucket.name
     end

data/lib/lono/script/base.rb

@@ -1,5 +1,5 @@
-class Lono::Script
-  class Base < Lono::AbstractBase
-    SCRIPTS_INFO_PATH = "#{Lono.config.output_path}/data/scripts_info.txt"
+module Lono::Script
+  class Base < Lono::CLI::Base
+    SCRIPTS_INFO_PATH = "#{Lono.root}/output/data/scripts_info.txt"
   end
 end

data/lib/lono/script/build.rb

@@ -1,7 +1,7 @@
 require "digest"
 require "fileutils"
 
-class Lono::Script
+module Lono::Script
   class Build < Base
     # Only avaialble after script has been built.
     def self.scripts_name
@@ -9,18 +9,17 @@ class Lono::Script
     end
 
     def run
-      Lono::ProjectChecker.check
       reset
-      if Dir["#{Lono.blueprint_root}/app/scripts/*"].empty?
+      if Dir["#{@blueprint.root}/scripts/*"].empty?
         return
       else
-        puts "Detected app/scripts for blueprint #{@blueprint}"
+        logger.info "Detected scripts"
       end
 
-      puts "Tarballing app/scripts folder to scripts.tgz"
+      logger.info "Tarballing scripts folder to scripts.tgz"
       tarball_path = create_tarball
       save_scripts_info(tarball_path)
-      puts "Tarball created at #{tarball_path}"
+      logger.info "Tarball created at #{tarball_path}"
     end
 
     # Only avaialble after script has been built.
@@ -35,12 +34,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 #{Lono.blueprint_root}/app && dot_clean ." if system("type dot_clean > /dev/null 2>&1")
+      system "cd #{@blueprint.root} && 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 #{Lono.blueprint_root}/app && tar -c scripts | gzip -n > scripts.tgz" # temporary app/scripts.tgz file
+      sh "cd #{@blueprint.root} && tar -c scripts | gzip -n > scripts.tgz" # temporary scripts.tgz file
 
       rename_with_md5!
     end
@@ -48,9 +47,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/#{@blueprint}/scripts/scripts-#{md5sum}.tgz"
+      md5_path = "output/#{@blueprint.name}/scripts/scripts-#{md5sum}.tgz"
       FileUtils.mkdir_p(File.dirname(md5_path))
-      FileUtils.mv("#{Lono.blueprint_root}/app/scripts.tgz", md5_path)
+      FileUtils.mv("#{@blueprint.root}/scripts.tgz", md5_path)
       md5_path
     end
 
@@ -61,11 +60,11 @@ class Lono::Script
 
     # cache this because the file will get removed
     def md5sum
-      @md5sum ||= Digest::MD5.file("#{Lono.blueprint_root}/app/scripts.tgz").to_s[0..7]
+      @md5sum ||= Digest::MD5.file("#{@blueprint.root}/scripts.tgz").to_s[0..7]
     end
 
     def sh(command)
-      puts "=> #{command}"
+      logger.info "=> #{command}"
       system command
     end
 

data/lib/lono/script/upload.rb

@@ -1,25 +1,25 @@
 require "filesize"
 
-class Lono::Script
+module Lono::Script
   class Upload < Base
     include Lono::AwsServices
-    include Lono::Utils::PrettyTime
+    include Lono::Utils::Pretty
+    include Lono::Utils::Logging
 
     def run
-      Lono::ProjectChecker.check
       return unless scripts_built?
 
       upload(tarball_path)
-      puts "Uploaded #{File.basename(s3_dest)} to s3."
+      logger.info "Uploaded #{File.basename(s3_dest)} to s3."
     end
 
     def upload(tarball_path)
-      puts "Uploading scripts.tgz (#{filesize}) to #{s3_dest}"
+      logger.info "Uploading scripts.tgz (#{filesize}) to #{s3_dest}"
       obj = s3_resource.bucket(bucket_name).object(key)
       start_time = Time.now
       obj.upload_file(tarball_path)
       time_took = pretty_time(Time.now-start_time).color(:green)
-      puts "Time took to upload code to s3: #{time_took}"
+      logger.info "Time took to upload code to s3: #{time_took}"
     end
 
     def filesize
@@ -43,7 +43,7 @@ class Lono::Script
       "#{Lono.env}/scripts"
     end
 
-    # Scripts are only built if the app/scripts folder is non empty
+    # Scripts are only built if the scripts folder is non empty
     def scripts_built?
       File.exist?(SCRIPTS_INFO_PATH) && !tarball_path.empty?
     end

data/lib/lono/seeder.rb

@@ -0,0 +1,110 @@
+require "fileutils"
+require "memoist"
+require "thor"
+require "yaml"
+
+module Lono
+  class Seeder < Lono::CLI::Base
+    extend Memoist
+    include Lono::AwsServices
+    include Lono::Cfn::Concerns::TemplateOutput
+
+    def run
+      build_template
+      build_params
+      build_vars
+    end
+
+    def build_template
+      Lono::Builder::Template.new(@options).run
+    end
+
+    def build_params
+      if template_output.parameters.empty?
+        logger.info "Template has no parameters."
+        return
+      end
+
+      # Generate by parameter group first
+      lines, shown = [], []
+      template_output.parameter_groups.each do |label, parameters|
+        lines << "# Parameter Group: #{label}"
+        parameters.each do |name|
+          parameter_line = parameter_line(name)
+          lines << parameter_line unless lines.include?(parameter_line)
+          shown << name
+        end
+        lines << ""
+      end if template_output.parameter_groups
+
+      # Then generate the rest
+      template_output.parameters.each do |name, data|
+        lines << parameter_line(name) unless shown.include?(name)
+      end
+
+      content = lines.join("\n")
+      dest_path = "#{dest_folder}/params/#{Lono.env}.txt" # only support environment level parameters for now
+      create_file(dest_path, content) # Thor::Action
+    end
+
+    def parameter_line(name)
+      data = template_output.parameters[name]
+      example = description_example(data["Description"])
+      if data["Default"].nil?
+        line = "#{name}=#{example} # (required)"
+      else
+        default = data["Default"]
+        line = "# #{name}=#{default}"
+        line = "#{line} # #{example}" if example
+      end
+      line
+    end
+
+    def description_example(description)
+      return unless description
+      md = description.match(/(Example|IE): (.*)/)
+      return unless md
+      md[2]
+    end
+
+    def build_vars
+      src = "#{@blueprint.root}/seed/vars"
+      dest = "#{dest_folder}/vars"
+      directory(src, dest) if File.exist?(src)
+    end
+
+    # config structure:
+    #
+    #   config/blueprints/demo
+    #
+    # general structure:
+    #
+    #   app/blueprints/demo/config
+    #   vendor/blueprints/demo/config
+    #
+    def dest_folder
+      where = @options[:where] || Lono.config.seed.where
+      if where == "config"
+        "#{Lono.root}/config/blueprints/#{@blueprint.name}"
+      else # app or vendor
+        "#{Lono.root}/#{where}/blueprints/#{@blueprint.name}/config"
+      end
+    end
+
+  private
+    def create_file(dest_path, content) # Thor::Action)
+      sequence.create_file(dest_path, content)
+    end
+
+    def directory(src, dest)
+      sequence.send(:set_template_paths, src)
+      sequence.destination_root = Lono.root
+      sequence.directory(".", dest, context: binding) # Thor::Action
+    end
+
+    def sequence
+      sequence = Lono::CLI::New::Sequence.new(@options)
+    end
+    memoize :sequence
+  end
+end