lono 7.5.2 → 8.0.0.pre.rc3

data/lib/lono/bundler/info.rb

@@ -0,0 +1,39 @@
+module Lono::Bundler
+  class Info < CLI::Base
+    def run
+      file = LB.config.lockfile
+      unless File.exist?(file)
+        logger.info "No #{file} found".color(:red)
+        logger.info "Maybe run: lono bundle"
+        return
+      end
+
+      name = @options[:component]
+      all = lockfile.components.find_all { |c| c.name == @options[:component] }
+      all = all.select { |c| c.type == @options[:type] } if @options[:type]
+      if all.size > 1
+        logger.info "Multiple components found with different types"
+      end
+
+      all.each do |found|
+        show(found)
+      end
+      unless all.size > 0
+        logger.info "Could not find component in #{LB.config.lockfile}: #{name}".color(:red)
+      end
+    end
+
+    def show(component)
+      props = component.props.reject { |k,v| k == :name }.stringify_keys # for sort
+      puts "#{component.name}:"
+      props.keys.sort.each do |k|
+        v = props[k]
+        puts "    #{k}: #{v}" unless v.blank?
+      end
+    end
+
+    def lockfile
+      Lockfile.instance
+    end
+  end
+end

data/lib/lono/bundler/list.rb

@@ -0,0 +1,26 @@
+module Lono::Bundler
+  class List < CLI::Base
+    def run
+      file = LB.config.lockfile
+      unless File.exist?(file)
+        logger.info "No #{file} found".color(:red)
+        logger.info "Maybe run: lono bundle"
+        return
+      end
+
+      logger.info "Components included by #{file}\n\n"
+      presenter = CliFormat::Presenter.new(@options.merge(format: "table"))
+      presenter.header = ["Name", "Type"]
+      lockfile.components.each do |component|
+        row = [component.name, component.type]
+        presenter.rows << row
+      end
+      presenter.show
+      logger.info "\nUse `lono bundle info` to print more detailed information about a component"
+    end
+
+    def lockfile
+      Lockfile.instance
+    end
+  end
+end

data/lib/lono/bundler/lockfile/version_comparer.rb

@@ -0,0 +1,56 @@
+class Lono::Bundler::Lockfile
+  class VersionComparer
+    attr_reader :reason, :changed
+    def initialize(locked, current)
+      @locked, @current = locked, current
+      @changed = false
+    end
+
+    def changed?
+      @changed
+    end
+
+    # Tricky logic, maybe spec this.
+    #
+    #   no components specified:
+    #     lono bundle update  # no components specified => update all
+    #     lono bundle install # no Lonofile.lock => update all
+    #   components specified:
+    #     lono bundle update s3  # explicit component => update s3
+    #     lono bundle install s3 # errors: not possible to specify componentule for install command
+    #
+    # Note: Install with specific components wipes existing components. Not worth it to support.
+    #
+    def run
+      @changed = false
+
+      # Most props are "strict" version checks. So if user changes options generally in the component line
+      # the Lonofile.lock will get updated, which is expected behavior.
+      props = @locked.props.keys + @current.props.keys
+      strict_versions = props.uniq.sort - [:sha, :type]
+      strict_versions.each do |version|
+        @changed = @locked.send(version) != @current.send(version)
+        if @changed
+          @reason = reason_message(version)
+          return @changed
+        end
+      end
+
+      # Lots of nuance with the sha check that works differently
+      # Only check when set.
+      # Also in update mode then always check it.
+      @changed = @current.sha && !@locked.sha.include?(@current.sha) ||
+                 LB.update_mode? && !@current.latest_sha.include?(@locked.sha)
+      if @changed
+        @reason = reason_message("sha")
+        return @changed
+      end
+
+      @changed
+    end
+
+    def reason_message(version)
+      "Replacing component #{@current.name} because #{version} is different in Lonofile and Lonofile.lock"
+    end
+  end
+end

data/lib/lono/bundler/lockfile/yamler.rb

@@ -0,0 +1,36 @@
+require "yaml"
+
+class Lono::Bundler::Lockfile
+  class Yamler
+    def initialize(components)
+      @components = components.sort_by(&:name)
+    end
+
+    def dump
+      YAML.dump(data)
+    end
+
+    def data
+      @components.map do |component|
+        item(component)
+      end
+    end
+
+    def item(component)
+      props = component.props.dup # passthrough: name, url, version, ref, tag, branch etc
+      props[:sha] ||= component.latest_sha
+      props.delete_if { |k,v| v.nil? }
+      props.deep_stringify_keys
+    end
+
+    def write
+      IO.write(LB.config.lockfile, dump)
+    end
+
+    class << self
+      def write(components)
+        new(components).write
+      end
+    end
+  end
+end

data/lib/lono/bundler/lockfile.rb

@@ -0,0 +1,66 @@
+require "yaml"
+
+module Lono::Bundler
+  class Lockfile
+    include Singleton
+    include LB::Util::Logging
+
+    # [{"name"=>"vpc",
+    #   "type"=>"blueprint",
+    #   "sha"=>"52328b2b5197f9b95e3005cfcfb99595040ee45b",
+    #   "source"=>"org/terraform-aws-vpc",
+    #   "url"=>"https://github.com/org/terraform-aws-vpc"},
+    #   {"name" => "instance",
+    #   "type"=>"blueprint",
+    #   "sha"=>"570cca3ea7b25e3af1961dc57b27ca2c129b934a",
+    #   "source"=>"org/terraform-aws-instance",
+    #   "url"=>"https://github.com/org/terraform-aws-instance"}]
+    @@components = nil
+    def components
+      return @@components if @@components
+      lockfile = LB.config.lockfile
+      components = File.exist?(lockfile) ? YAML.load_file(lockfile) : []
+      @@components = components.map do |props|
+        Component.new(props)
+      end
+    end
+
+    # update (if version mismatch) or create (if missing)
+    def sync(component)
+      replace!(component) if changed?(component)
+    end
+
+    # component built from Lonofile
+    def changed?(component)
+      # missing componentule case
+      found = components.find { |locked_component| locked_component.name == component.name }
+      unless found
+        logger.debug "Replacing component: #{component.name}. Not found in Lonofile.lock"
+        return true
+      end
+
+      comparer = VersionComparer.new(found, component)
+      comparer.run
+      logger.debug("REASON: #{comparer.reason}") if comparer.reason
+      comparer.changed?
+    end
+
+    def replace!(component)
+      # components are immediately fresh from writing to @@components directly
+      @@components.delete_if { |c| c.name == component.name && c.type == component.type }
+      @@components << component
+      @@components.sort_by!(&:name)
+    end
+
+    def prune(removed_components)
+      removals = removed_components.map(&:name)
+      @@components.delete_if { |m| removals.include?(m.name) }
+    end
+
+    class << self
+      def write
+        Yamler.write(@@components) if @@components
+      end
+    end
+  end
+end

data/lib/lono/bundler/lonofile.rb

@@ -0,0 +1,32 @@
+module Lono::Bundler
+  class Lonofile
+    include Singleton
+    extend Memoist
+    include LB::Util::Logging
+
+    # dsl meta example:
+    # {:global=>{{:org=>"boltopspro"},
+    #  :components=>[{:source=>"git@github.com:boltopspro/vpc", :type=>"blueprint", :name=>"vpc"}]
+    # }
+    def components
+      LB.dsl.meta[:components].map do |options|
+        Component.new(options)
+      end
+    end
+    memoize :components
+
+    # Checks if any of the components defined in Lonofile has an inferred an org
+    # In this case the org must be set
+    # When a source is set with an inferred org and org is not set it looks like this:
+    #
+    #     dsl.meta has {:source=>"terraform-random-pet"}
+    #     component.source = "terraform-random-pet"
+    #
+    # Using info to detect that the org is missing and the Lonofile definition
+    # has at least one component line that has an inferred org.
+    #
+    def missing_org?
+      components.detect { |component| component.source.split('/').size == 1 } && LB.config.org.nil?
+    end
+  end
+end

data/lib/lono/bundler/runner.rb

@@ -0,0 +1,27 @@
+module Lono::Bundler
+  class Runner < CLI::Base
+    def run
+      Syncer.new(@options).run
+      Exporter.new(@options).run
+      # finish_message
+    end
+
+    def finish_message
+      no_components_found = true
+      export_paths.each do |path|
+        found = Dir.exist?(path) && !Dir.empty?(path)
+        next unless found
+        logger.info  "components saved to #{path}"
+        no_components_found = false
+      end
+
+      logger.info("No components were found.") if no_components_found
+    end
+
+    def export_paths
+      export_paths = Lonofile.instance.mods.map(&:export_to).compact.uniq
+      export_paths << LB.config.export_to
+      export_paths
+    end
+  end
+end

data/lib/lono/bundler/syncer.rb

@@ -0,0 +1,70 @@
+module Lono::Bundler
+  class Syncer
+    include LB::Util::Logging
+
+    def initialize(options={})
+      @options = options
+      @component = @options[:component]
+    end
+
+    def run
+      validate!
+      FileUtils.rm_f(LB.config.lockfile) if update_all?
+      logger.info "Bundling with #{LB.config.lonofile}..."
+      if File.exist?(LB.config.lockfile)
+        sync
+      else
+        create
+      end
+      LB::Lockfile.write
+    end
+
+    def sync
+      sync_components
+      removal_components = subtract(lockfile.components, lonofile.components)
+      lockfile.prune(removal_components)
+    end
+
+    def create
+      sync_components
+    end
+
+    def sync_components
+      # VersionComparer is used in lockfile.sync and does heavy lifting to check if component should be updated and replaced
+      lonofile.components.each do |component|
+        next unless sync?(component)
+        logger.debug "Syncing #{component.name}"
+        lockfile.sync(component) # update (if version mismatch) or create (if missing)
+      end
+    end
+
+    def sync?(component)
+      names = @options[:components]
+      names.blank? or names.include?(component.name)
+    end
+
+    def validate!
+      return unless lonofile.missing_org?
+      logger.error "ERROR: org must be set in the #{LB.config.lonofile}.".color(:red)
+      logger.error "Please set org in the Lonofile"
+      exit 1
+    end
+
+    def update_all?
+      LB.update_mode? && @options[:components].empty?
+    end
+
+    def subtract(components1, components2)
+      component2_names = components2.map(&:name)
+      components1.select { |component1| !component2_names.include?(component1.name) }
+    end
+
+    def lonofile
+      Lonofile.instance
+    end
+
+    def lockfile
+      Lockfile.instance
+    end
+  end
+end

data/lib/lono/bundler/util/git.rb

@@ -0,0 +1,37 @@
+module Lono::Bundler::Util
+  module Git
+    include Logging
+
+    def sh(command)
+      command = "#{command} 2>&1" # always need output for the sha
+      logger.debug "=> #{command}"
+      out = `#{command}`
+      unless $?.success?
+        if command.include?("git")
+          raise LB::GitError.new("#{command}\n#{out}")
+        else
+          logger.error "ERROR: running #{command}".color(:red)
+          logger.error out
+          exit $?.exitstatus
+        end
+      end
+      out
+    end
+
+    def git(command)
+      sh("git #{command}")
+    rescue LB::GitError => e
+      action, version = command.split(' ')
+      if action == "checkout" && version !~ /^v/
+        command = "checkout v#{version}"
+        retry
+      else
+        logger.error "ERROR: There was a git error".color(:red)
+        logger.error "Current dir: #{Dir.pwd}"
+        logger.error "The error occur when running:"
+        logger.error e.message
+      end
+      exit 1
+    end
+  end
+end

data/lib/lono/bundler/util/logging.rb

@@ -0,0 +1,7 @@
+module Lono::Bundler::Util
+  module Logging
+    def logger
+      Lono::Bundler.logger
+    end
+  end
+end

data/lib/lono/bundler/util/sure.rb

@@ -0,0 +1,5 @@
+module Lono::Bundler::Util
+  module Sure
+    include Lono::Utils::Sure
+  end
+end

data/lib/lono/{bundle.rb → bundler.rb}

@@ -1,6 +1,7 @@
 module Lono
-  # Named Bundle vs Bundler to avoid having to fully qualify ::Bundler
-  module Bundle
+  module Bundler
+    extend Memoist
+
     # Looks like for zeitwerk module autovivification to work `bundle exec` must be called.
     # This allows zeitwork module autovivification to work even if the user has not called lono with `bundle exec lono`.
     # Bundler.setup is essentially the same as `bundle exec`
@@ -9,7 +10,7 @@ module Lono
     def setup
       return unless gemfile?
       Kernel.require "bundler/setup"
-      Bundler.setup # Same as Bundler.setup(:default)
+      ::Bundler.setup # Same as Bundler.setup(:default)
     rescue LoadError => e
       handle_error(e)
     end
@@ -17,7 +18,7 @@ module Lono
     def require
       return unless gemfile?
       Kernel.require "bundler/setup"
-      Bundler.require(*bundler_groups)
+      ::Bundler.require(*bundler_groups)
     rescue LoadError => e
       handle_error(e)
     end
@@ -50,5 +51,38 @@ module Lono
     end
 
     extend self
+
+    @@logger = nil
+    def logger
+      config.logger
+    end
+
+    def logger=(v)
+      @@logger = v
+    end
+
+    def config
+      Config.instance.config
+    end
+
+    # DSL is evaluated once lazily when it get used
+    def dsl
+      dsl = Dsl.new
+      dsl.run
+      dsl
+    end
+    memoize :dsl
+
+    @@update_mode = false
+    def update_mode
+      @@update_mode
+    end
+    alias_method :update_mode?, :update_mode
+
+    def update_mode=(v)
+      @@update_mode = v
+    end
   end
 end
+
+LB = Lono::Bundler

data/lib/lono/cfn/base.rb

@@ -1,201 +1,15 @@
-require "lono"
-
-class Lono::Cfn
-  class Base < Lono::AbstractBase
+module Lono::Cfn
+  class Base < Lono::CLI::Base
     extend Memoist
+
     include Lono::AwsServices
     include Lono::Utils::Sure
+    include Lono::Utils::Logging
+    include Lono::Utils::Pretty
+    include Lono::Utils::Quit
 
-    def starting_message
-      action = self.class.to_s.split('::').last
-      puts "#{action} #{@stack.color(:green)} stack..."
-    end
-
-    def run
-      starting_message
-      parameters = generate_all
-      begin
-        save(parameters) # defined in the sub class
-      rescue Aws::CloudFormation::Errors::InsufficientCapabilitiesException => e
-        yes = rerun_with_iam?(e)
-        retry if yes
-      rescue Aws::CloudFormation::Errors::ValidationError => e
-        if e.message.include?("No updates") # No updates are to be performed.
-          puts "WARN: #{e.message}".color(:yellow)
-        elsif e.message.include?("UPDATE_ROLLBACK_FAILED") # https://amzn.to/2IiEjc5
-          continue_update_rollback
-        else
-          puts "ERROR: #{e.message}".color(:red)
-          exit 1
-        end
-      end
-
-      return unless @options[:wait]
-
-      success = false
-      if !@options[:noop]
-        success = status.wait
-      end
-
-      # exit code for cfn.rb cli, so there's less duplication
-      exit 1 unless success
-      success
-    end
-
-    def continue_update_rollback_sure?
-      puts <<~EOL
-        The stack is in the UPDATE_ROLLBACK_FAILED state. More info here: https://amzn.to/2IiEjc5
-        Would you like to try to continue the update rollback? (y/N)
-      EOL
-
-      sure = @options[:sure] ? "y" : $stdin.gets
-      unless sure =~ /^y/
-        puts "Exiting without continuing the update rollback."
-        exit 0
-      end
-    end
-
-    def continue_update_rollback
-      continue_update_rollback_sure?
-      options = {stack_name: @stack}
-      show_options(options, "cfn.continue_update_rollback")
-      begin
-        cfn.continue_update_rollback(options)
-      rescue Aws::CloudFormation::Errors::ValidationError => e
-        puts "ERROR5: #{e.message}".color(:red)
-        exit 1
-      end
-    end
-
-    def delete_rollback_stack
-      rollback = Rollback.new(@stack)
-      rollback.delete_stack
-    end
-
-    def status
-      Status.new(@stack)
-    end
-    memoize :status
-
-    def rerun_with_iam?(e)
-      # e.message is "Requires capabilities : [CAPABILITY_IAM]"
-      # grab CAPABILITY_IAM with regexp
-      capabilities = e.message.match(/\[(.*)\]/)[1]
-      confirm = prompt_for_iam(capabilities)
-      if confirm =~ /^y/
-        @options.merge!(capabilities: [capabilities])
-        puts "Re-running: #{command_with_iam(capabilities).color(:green)}"
-        true
-      else
-        puts "Exited"
-        exit 1
-      end
-    end
-
-    def prompt_for_iam(capabilities)
-      puts "This stack will create IAM resources.  Please approve to run the command again with #{capabilities} capabilities."
-      puts "  #{command_with_iam(capabilities)}"
-
-      puts "Please confirm (y/N)"
-      $stdin.gets
-    end
-
-    def command_with_iam(capabilities)
-      "#{File.basename($0)} #{ARGV.join(' ')} --capabilities #{capabilities}"
-    end
-
-    def generate_all
-      Lono::Generate.new(@options).all
-    end
-
-    # Maps to CloudFormation format.  Example:
-    #
-    #   {"a"=>"1", "b"=>"2"}
-    # To
-    #   [{key: "a", value: "1"}, {key: "b", value: "2"}]
-    #
-    def tags
-      tags = @options[:tags] || []
-      tags = tags.map do |k,v|
-        { key: k, value: v }
-      end
-
-      update_operation = %w[Preview Update].include?(self.class.to_s)
-      if tags.empty? && update_operation
-        resp = cfn.describe_stacks(stack_name: @stack)
-        tags = resp.stacks.first.tags
-        tags = tags.map(&:to_h)
-      end
-
-      tags
-    end
-
-    def exit_unless_updatable!
-      return true if testing_update?
-      return false if @options[:noop]
-
-      status = stack_status
-      unless status =~ /_COMPLETE$/ || status == "UPDATE_ROLLBACK_FAILED"
-        puts "Cannot create a change set for the stack because the #{@stack} is not in an updatable state.  Stack status: #{status}".color(:red)
-        quit(1)
-      end
-    end
-
-    # All CloudFormation states listed here:
-    # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
-    def stack_status
-      return true if testing_update?
-      return false if @options[:noop]
-      resp = cfn.describe_stacks(stack_name: @stack)
-      resp.stacks[0].stack_status
-    end
-
-    # To allow mocking in specs
-    def quit(signal)
-      exit signal
-    end
-
-    def capabilities
-      return @options[:capabilities] if @options[:capabilities]
-      if @options[:sure] || @options[:iam]
-        ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
-      end
-    end
-
-    def notification_arns
-      @setting ||= Lono::Setting.new
-      settings = @setting.data
-      arns = @options["notification_arns"] || settings["notification_arns"]
-      arns == [''] ? [] : arns # allow removing the notification_arns setting
-    end
-
-    def show_options(options, meth=nil)
-      options = options.clone.compact
-      if options[:template_body] # continue_update_rollback
-        options[:template_body] = "Hidden due to size... View at: #{pretty_path(template_path)}"
-        options[:template_url] = options[:template_url].sub(/\?.*/,'')
-      end
-      to = meth || "AWS API"
-      puts "Parameters passed to #{to}:"
-      puts YAML.dump(options.deep_stringify_keys)
-    end
-
-    # Lono always uploads the template to s3 so we can use much larger templates.
-    #
-    #   template_body: 51,200 bytes - filesystem limit
-    #   template_url: 460,800 bytes - s3 limit
-    #
-    # Reference: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
-    def set_template_url!(options)
-      url_path = template_path.sub("#{Lono.root}/",'')
-      url = Lono::S3::Uploader.new(url_path).presigned_url
-      url.gsub!(/\.yml.*/, ".yml") # Interesting dont need presign query string. For stack sets it actually breaks it. So removing.
-      options[:template_url] = url
-      options
-    end
+    include Concerns
 
-    def pretty_path(path)
-      path.sub("#{Lono.root}/",'')
-    end
+    delegate :template_path, to: :build
   end
-end
+end