lono 7.5.1 → 8.0.0.pre.rc2

data/lib/lono/bundler/exporter/base.rb

@@ -0,0 +1,6 @@
+class Lono::Bundler::Exporter
+  class Base
+    include LB::Component::Concerns::PathConcern
+    include LB::Util::Logging
+  end
+end

data/lib/lono/bundler/exporter/copy.rb

@@ -0,0 +1,22 @@
+class Lono::Bundler::Exporter
+  class Copy < Base
+    def initialize(component)
+      @component = component
+    end
+
+    def component
+      FileUtils.rm_rf(@component.export_path)
+      FileUtils.mkdir_p(File.dirname(@component.export_path))
+      logger.debug "Copy: cp -r #{src_path} #{@component.export_path}"
+      FileUtils.cp_r(src_path, @component.export_path)
+      FileUtils.rm_rf("#{@component.export_path}/.git")
+    end
+
+    # src path is from the stage area
+    def src_path
+      path = stage_path(rel_dest_dir)
+      path = "#{path}/#{@component.subfolder}" if @component.subfolder
+      path
+    end
+  end
+end

data/lib/lono/bundler/exporter.rb

@@ -0,0 +1,50 @@
+module Lono::Bundler
+  class Exporter
+    include LB::Component::Concerns::PathConcern
+    include LB::Util::Logging
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def run
+      purge_all
+      components.each do |component|
+        logger.info "Exporting #{component.export_path}"
+        purge(component)
+        export(component)
+      end
+    end
+
+    def components
+      components = lockfile.components
+      if LB.update_mode? && !@options[:components].empty?
+        components.select! { |component| @options[:components].include?(component.name) }
+      end
+      components
+    end
+
+    def export(component)
+      fetcher = Component::Fetcher.new(component).instance
+      fetcher.run
+      fetcher.switch_version(component.sha)
+      copy = Copy.new(component)
+      copy.component
+    end
+
+  private
+    def purge_all
+      return if LB.update_mode?
+      return unless LB.config.export_purge
+      FileUtils.rm_rf(LB.config.export_to)
+    end
+
+    def purge(component)
+      FileUtils.rm_rf(component.export_path)
+    end
+
+    def lockfile
+      Lockfile.instance
+    end
+  end
+end

data/lib/lono/bundler/extract/tar.rb

@@ -0,0 +1,33 @@
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+# Thanks: https://gist.github.com/ForeverZer0/2adbba36fd452738e7cca6a63aee2f30
+class Lono::Bundler::Extract
+  class Tar
+    # tar_gz_archive = '/tmp/lono/bundler/stage/s3-us-west-2.amazonaws.com/demo-terraform-test/blueprints/example-module.tgz'
+    # destination = '/tmp/lono/where/extract/to'
+    def self.extract(tar_gz_archive, destination)
+      reader = Zlib::GzipReader.open(tar_gz_archive)
+      Gem::Package::TarReader.new(reader) do |tar|
+        dest = nil
+        tar.each do |entry|
+          dest ||= File.join destination, entry.full_name
+          if entry.directory?
+            FileUtils.rm_rf dest unless File.directory? dest
+            FileUtils.mkdir_p dest, :mode => entry.header.mode, :verbose => false
+          elsif entry.file?
+            FileUtils.rm_rf dest unless File.file? dest
+            File.open dest, "wb" do |f|
+              f.print entry.read
+            end
+            FileUtils.chmod entry.header.mode, dest, :verbose => false
+          elsif entry.header.typeflag == '2' #Symlink!
+            File.symlink entry.header.linkname, dest
+          end
+          dest = nil
+        end
+      end
+    end
+  end
+end

data/lib/lono/bundler/extract/zip.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'zip'
+
+class Lono::Bundler::Extract
+  class Zip
+    def self.extract(file, dest)
+      ::Zip::File.open(file) { |zip_file|
+        zip_file.each { |f|
+          f_path=File.join(dest, f.name)
+          FileUtils.mkdir_p(File.dirname(f_path))
+          zip_file.extract(f, f_path) unless File.exist?(f_path)
+        }
+      }
+    end
+  end
+end

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