lono 8.0.0.pre.rc1 → 8.0.0.pre.rc4

data/lib/lono/hooks/builder.rb

@@ -0,0 +1,50 @@
+module Lono::Hooks
+  class Builder
+    extend Memoist
+    include Dsl
+    include DslEvaluator
+    include Lono::Utils
+
+    # IE: dsl_file: config/hooks.rb
+    attr_accessor :name
+    def initialize(blueprint, name)
+      @blueprint, @name = blueprint, name
+      @hooks = {before: {}, after: {}}
+    end
+
+    def build
+      evaluate_file("#{Lono.root}/config/hooks.rb")
+      evaluate_file("#{@blueprint.root}/config/hooks.rb")
+      @hooks.deep_stringify_keys!
+    end
+    memoize :build
+
+    def run_hooks
+      build
+      run_each_hook("before")
+      out = yield if block_given?
+      run_each_hook("after")
+      out
+    end
+
+    def run_each_hook(type)
+      hooks = @hooks.dig(type, @name) || []
+      hooks.each do |hook|
+        run_hook(type, hook)
+      end
+    end
+
+    def run_hook(type, hook)
+      return unless run?(hook)
+
+      id = "#{type} #{@name}"
+      label = " label: #{hook["label"]}" if hook["label"]
+      logger.info  "Hook: Running #{id} hook#{label}".color(:cyan) if Lono.config.hooks.show
+      Runner.new(@blueprint, hook).run
+    end
+
+    def run?(hook)
+      !!hook["execute"]
+    end
+  end
+end

data/lib/lono/hooks/concern.rb

@@ -0,0 +1,9 @@
+module Lono::Hooks
+  module Concern
+    def run_hooks(name, &block)
+      hooks = Builder.new(@blueprint, name)
+      hooks.build # build hooks
+      hooks.run_hooks(&block)
+    end
+  end
+end

data/lib/lono/hooks/dsl.rb

@@ -0,0 +1,20 @@
+module Lono::Hooks
+  module Dsl
+    def before(*commands, **props)
+      commands.each do |name|
+        each_hook(:before, name, props)
+      end
+    end
+
+    def after(*commands, **props)
+      commands.each do |name|
+        each_hook(:after, name, props)
+      end
+    end
+
+    def each_hook(type, name, props={})
+      @hooks[type][name] ||= []
+      @hooks[type][name] << props
+    end
+  end
+end

data/lib/lono/hooks/runner.rb

@@ -0,0 +1,46 @@
+module Lono::Hooks
+  class Runner
+    include Lono::Utils
+
+    # exposing blueprint and hook so lono hooks have access to them via runner context. IE:
+    #
+    #     class EnvExporter
+    #       def call(runner)
+    #         puts "runner.hook #{runner.hook}"
+    #       end
+    #     end
+    #
+    # Docs: http://lono.cloud/docs/config/hooks/ruby/#method-argument
+    #
+    attr_reader :blueprint, :hook
+    def initialize(blueprint, hook)
+      @blueprint, @hook = blueprint, hook
+      @execute = @hook["execute"]
+    end
+
+    def run
+      case @execute
+      when String
+        sh(@execute, exit_on_fail: @hook["exit_on_fail"])
+      when -> (e) { e.respond_to?(:public_instance_methods) && e.public_instance_methods.include?(:call) }
+        executor = @execute.new
+      when -> (e) { e.respond_to?(:call) }
+        executor = @execute
+      else
+        logger.warn "WARN: execute option not set for hook: #{@hook.inspect}"
+      end
+
+      return unless executor
+
+      meth = executor.method(:call)
+      case meth.arity
+      when 0
+        executor.call # backwards compatibility
+      when 1
+        executor.call(self)
+      else
+        raise "The #{executor} call method definition has been more than 1 arguments and is not supported"
+      end
+    end
+  end
+end

data/lib/lono/layering/layer.rb

@@ -14,10 +14,9 @@ module Lono::Layering
     include Lono::Layering
     include Lono::Utils::Logging
     include Lono::Utils::Pretty
+    include Lono::Concerns::AwsInfo
     extend Memoist
 
-    delegate :region, to: :aws_data
-
     def initialize(blueprint, type)
       @blueprint, @type = blueprint, type
     end
@@ -32,30 +31,18 @@ module Lono::Layering
       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
+    def full_layers(dir)
+      layers = layer_levels("#{dir}/#{@type}") # root
+      if Lono.role
+        layers += layer_levels("#{dir}/#{@type}/#{Lono.role}")
       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
+      if Lono.app
+        layers += layer_levels("#{dir}/#{@type}/#{Lono.app}")
+      end
+      if Lono.app && Lono.role
+        layers += layer_levels("#{dir}/#{@type}/#{Lono.app}/#{Lono.role}")
+      end
+      layers
     end
 
     # adds prefix and to each layer pair that has base and Lono.env. IE:
@@ -63,64 +50,85 @@ module Lono::Layering
     #    "#{prefix}/base"
     #    "#{prefix}/#{Lono.env}"
     #
+    # Params Layers:
+    #     config/blueprints/demo/params/txt
+    #     config/blueprints/demo/params/base.txt
+    #     config/blueprints/demo/params/dev.txt
     def layer_levels(prefix=nil)
-      levels = ["base", Lono.env]
+      levels = ["", "base", Lono.env]
+      levels << "#{Lono.env}-#{Lono.extra}" if Lono.extra
       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.map! { |level| level.sub(/\/$/,'') } # strip trailing slash
+
+      # layers = pre_layers + main_layers + post_layers
+      levels = layers.inject([]) do |sum, layer|
+        layer_levels = levels.map do |level|
+          [level, layer].reject(&:blank?).join('/')
+        end
+        sum += layer_levels
+        sum
+      end
+
       levels
     end
 
+    # Interface method: layers = pre_layers + main_layers + post_layers
+    # Simple layering is default. Can set with:
+    #
+    #      config.layering.mode = "simple" # simple of full
+    #
+    def main_layers
+      if Lono.config.layering.mode == "simple"
+        ['']
+      else # full
+        # includes region, account, and account/region layers
+        # More powerful but less used and more complex to understand
+        [
+          '',
+          region,
+          account,
+          "#{account}/#{region}",
+        ]
+      end
+    end
+
     def add_ext!(paths)
       exts = {
-        params: "txt",
+        params: "env",
         vars: "rb",
       }
       ext = exts[@type.to_sym]
 
       paths.map! do |path|
-        if path.include?("teams")
-          puts "path: #{path}"
-        end
-
-        if path.ends_with?('/')
-          "#{path.sub(/\/$/,'')}.#{ext}"
-        else
-          "#{path}.#{ext}"
-        end
-      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
+        path = path.sub(/\/$/,'') if path.ends_with?('/')
+        "#{path}.#{ext}"
       end
-      layers
     end
 
     @@shown_layers = {}
     def show_layers(paths)
       return if @@shown_layers[@type]
       logger.debug "#{@type.capitalize} Layers:"
+      show = Lono.config.layering.show || ENV['LONO_LAYERS']
       paths.each do |path|
-        logger.debug "    #{pretty_path(path)}" if File.exist?(path) || ENV['LONO_SHOW_ALL_LAYERS']
+        # next if path.include?("app/blueprints/") # more useful to show only config layers
+        if ENV['LONO_LAYERS_ALL']
+          logger.info "    #{pretty_path(path)}"
+        elsif show
+          logger.info "    #{pretty_path(path)}" if File.exist?(path)
+        end
       end
       logger.debug ""
       @@shown_layers[@type] = true
     end
 
-  private
-    def aws_data
-      AwsData.new
+    def account
+      name = aws_data.account
+      # friendly name mapping
+      names = Lono.config.layering.names.stringify_keys
+      names[name] || name
     end
-    memoize :aws_data
   end
 end

data/lib/lono/logger.rb

@@ -17,9 +17,7 @@ module Lono
       line =~ /\n$/ ? line : "#{line}\n"
     end
 
-    # Used to allow terraform output to always go to stdout
-    # Terraspace output goes to stderr by default
-    # See: terraspace/shell.rb
+    # Used to allow output to always go to stdout
     def stdout(msg, newline: true)
       if newline
         puts msg
@@ -29,5 +27,6 @@ module Lono
     end
 
     public :print
+    public :printf
   end
 end

data/lib/lono/names.rb

@@ -9,7 +9,7 @@ module Lono
     end
 
     def stack
-      expansion(Lono.config.names.stack)
+      expansion(Lono.config.names.stack) # IE: :APP-:BLUEPRINT-:ENV
     end
     memoize :stack
 
@@ -21,30 +21,27 @@ module Lono
       vars.each do |var|
         string.gsub!(var, var_value(var))
       end
-      strip(string)
+      cleanse(string)
     end
 
     def var_value(unexpanded)
       name = unexpanded.sub(':','').downcase
       if respond_to?(name)
-        value = send(name).to_s
+        send(name).to_s # value
       else
         unexpanded
       end
     end
 
-    def strip(string)
+    def cleanse(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
+    delegate :app, :role, :env, :extra, to: :lono
+    def lono
+      Lono
     end
   end
 end

data/lib/lono/s3/bucket.rb

@@ -1,41 +1,24 @@
 module Lono::S3
   class Bucket
-    STACK_NAME = ENV['LONO_STACK_NAME'] || "lono"
-    include Lono::AwsServices
-    include Lono::Utils::Logging
     extend Lono::AwsServices
     extend Memoist
+    include Lono::AwsServices
+    include Lono::Cfn::Concerns
+    include Lono::Utils::Logging
+    include Lono::Utils::Sure
 
-    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
-
-        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
-
-      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?
         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
 
@@ -71,7 +54,6 @@ module Lono::S3
         enable_termination_protection: true,
       )
       success = status.wait
-      status.reset
       unless success
         logger.info "ERROR: Unable to create lono stack with managed s3 bucket".color(:red)
         exit 1
@@ -89,12 +71,12 @@ module Lono::S3
       are_you_sure?
 
       logger.info "Deleting #{STACK_NAME} stack with the s3 bucket"
-      disable_termination_protect
+      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 +93,6 @@ module Lono::S3
     def status
       CfnStatus.new(STACK_NAME)
     end
-    memoize :status
 
   private
 
@@ -135,20 +116,12 @@ module Lono::S3
 
 
     def are_you_sure?
-      return true if @options[:yes]
-
       if bucket_name.nil?
         logger.info "The lono stack and s3 bucket does not exist."
         exit
       end
 
-      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
+      sure?("Will empty and delete bucket #{bucket_name.color(:green)}. Are you sure?")
     end
 
     def template_body
@@ -165,7 +138,40 @@ module Lono::S3
               Tags:
                 - Key: Name
                   Value: lono
+        Outputs:
+          Bucket:
+            Value:
+              Ref: Bucket
       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
+
+      @@ensure_exist = false
+      def ensure_exist
+        return if @@ensure_exist
+        bucket = Lono::S3::Bucket.new
+        return if bucket.exist?
+        bucket.deploy
+        @@ensure_exist = true
+      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

@@ -3,53 +3,50 @@ module Lono::S3
     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
-      path = @path.gsub("#{Lono.root}/",'') # remove Lono.root
-      key = "#{Lono.env}/#{path}"
+      logger.debug "May upload   #{local_path}"
+      logger.debug "To           #{s3_path}"
 
-      pretty_path = path.sub(/^\.\//, '')
-      s3_path = "s3://#{s3_bucket}/#{key}"
-
-      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
-        logger.debug "Not modified: #{pretty_path} to #{s3_path}"
+        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_path}"
-        logger.debug 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,
+        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)
+      # Here because want to lazily create this bucket only after user has confirmed lono up
+      # This is the first time bucket needs to exists
+      # Called at Deploy::Opts#template_url which gets passed to cfn.create and calls template_url
+      Lono::S3::Bucket.ensure_exist
+      s3_presigner.presigned_url(:get_object, bucket: s3_bucket, key: s3_key)
     end
 
     # used for file_s3_key helper
@@ -62,7 +59,7 @@ module 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.
@@ -74,17 +71,25 @@ module 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/build.rb

@@ -63,10 +63,5 @@ module Lono::Script
       @md5sum ||= Digest::MD5.file("#{@blueprint.root}/scripts.tgz").to_s[0..7]
     end
 
-    def sh(command)
-      logger.info "=> #{command}"
-      system command
-    end
-
   end
 end