bolt 2.37.0 → 2.44.0

data/lib/bolt/module.rb

@@ -6,8 +6,14 @@ module Bolt
     CONTENT_NAME_REGEX = /\A[a-z][a-z0-9_]*(::[a-z][a-z0-9_]*)*\z/.freeze
     MODULE_NAME_REGEX  = /\A[a-z][a-z0-9_]*\z/.freeze
 
-    def self.discover(modulepath)
-      modulepath.each_with_object({}) do |path, mods|
+    def self.discover(modulepath, project)
+      mods = {}
+
+      if project.load_as_module?
+        mods[project.name] = Bolt::Module.new(project.name, project.path.to_s)
+      end
+
+      modulepath.each do |path|
         next unless File.exist?(path) && File.directory?(path)
         Dir.children(path)
            .map { |dir| File.join(path, dir) }
@@ -20,6 +26,8 @@ module Bolt
           end
         end
       end
+
+      mods
     end
 
     attr_reader :name, :path

data/lib/bolt/module_installer.rb

@@ -17,14 +17,14 @@ module Bolt
 
     # Adds a single module to the project.
     #
-    def add(name, specs, puppetfile_path, moduledir, config_path)
+    def add(name, specs, puppetfile_path, moduledir, project_file, config)
       project_specs = Specs.new(specs)
 
       # Exit early if project config already includes a spec with this name.
       if project_specs.include?(name)
         @outputter.print_message(
-          "Project configuration file #{config_path} already includes specification with name "\
-          "#{name}. Nothing to do."
+          "Project configuration file #{project_file} already includes specification "\
+          "with name #{name}. Nothing to do."
         )
         return true
       end
@@ -47,30 +47,32 @@ module Bolt
       # a version conflict.
       @outputter.print_action_step("Resolving module dependencies, this may take a moment")
 
+      @outputter.start_spin
       begin
         resolve_specs.add_specs('name' => name)
-        puppetfile = Resolver.new.resolve(resolve_specs)
+        puppetfile = Resolver.new.resolve(resolve_specs, config)
       rescue Bolt::Error
         project_specs.add_specs('name' => name)
-        puppetfile = Resolver.new.resolve(project_specs)
+        puppetfile = Resolver.new.resolve(project_specs, config)
       end
+      @outputter.stop_spin
 
       # Display the diff between the existing Puppetfile and the new Puppetfile.
       print_puppetfile_diff(existing_puppetfile, puppetfile)
 
       # Add the module to the project configuration.
-      @outputter.print_action_step("Updating project configuration file at #{config_path}")
+      @outputter.print_action_step("Updating project configuration file at #{project_file}")
 
-      data = Bolt::Util.read_yaml_hash(config_path, 'project')
+      data = Bolt::Util.read_yaml_hash(project_file, 'project')
       data['modules'] ||= []
       data['modules'] << name.tr('-', '/')
 
       begin
-        File.write(config_path, data.to_yaml)
+        File.write(project_file, data.to_yaml)
       rescue SystemCallError => e
         raise Bolt::FileError.new(
           "Unable to update project configuration file: #{e.message}",
-          config
+          project_file
         )
       end
 
@@ -79,7 +81,7 @@ module Bolt
       puppetfile.write(puppetfile_path, moduledir)
 
       # Install the modules.
-      install_puppetfile(puppetfile_path, moduledir)
+      install_puppetfile(puppetfile_path, moduledir, config)
     end
 
     # Outputs a diff of an old Puppetfile and a new Puppetfile.
@@ -145,7 +147,7 @@ module Bolt
 
     # Installs a project's module dependencies.
     #
-    def install(specs, path, moduledir, force: false, resolve: true)
+    def install(specs, path, moduledir, config = {}, force: false, resolve: true)
       @outputter.print_message("Installing project modules\n\n")
 
       if resolve != false
@@ -155,7 +157,11 @@ module Bolt
         # and write a Puppetfile.
         if force || !path.exist?
           @outputter.print_action_step("Resolving module dependencies, this may take a moment")
-          puppetfile = Resolver.new.resolve(specs)
+
+          # This doesn't use the block as it's more testable to just mock *_spin
+          @outputter.start_spin
+          puppetfile = Resolver.new.resolve(specs, config)
+          @outputter.stop_spin
 
           # We get here either through 'bolt module install' which uses the
           # managed modulepath (which isn't configurable) or through bolt
@@ -177,18 +183,22 @@ module Bolt
       end
 
       # Install the modules.
-      install_puppetfile(path, moduledir)
+      install_puppetfile(path, moduledir, config)
     end
 
     # Installs the Puppetfile and generates types.
     #
     def install_puppetfile(path, moduledir, config = {})
       @outputter.print_action_step("Syncing modules from #{path} to #{moduledir}")
+      @outputter.start_spin
       ok = Installer.new(config).install(path, moduledir)
+      @outputter.stop_spin
 
       # Automatically generate types after installing modules
-      @outputter.print_action_step("Generating type references")
-      @pal.generate_types
+      if ok
+        @outputter.print_action_step("Generating type references")
+        @pal.generate_types(cache: true)
+      end
 
       @outputter.print_puppetfile_result(ok, path, moduledir)
 

data/lib/bolt/module_installer/resolver.rb

@@ -9,14 +9,19 @@ module Bolt
     class Resolver
       # Resolves module specs and returns a Puppetfile object.
       #
-      def resolve(specs)
+      def resolve(specs, config = {})
         require 'puppetfile-resolver'
 
         # Build the document model from the specs.
-        document = PuppetfileResolver::Puppetfile::Document.new('')
+        document   = PuppetfileResolver::Puppetfile::Document.new('')
+        unresolved = []
 
         specs.specs.each do |spec|
-          document.add_module(spec.to_resolver_module)
+          if spec.resolve
+            document.add_module(spec.to_resolver_module)
+          else
+            unresolved << spec
+          end
         end
 
         # Make sure the document model is valid.
@@ -38,29 +43,49 @@ module Bolt
         # raised by puppetfile-resolver and re-raising them as Bolt errors.
         begin
           result = resolver.resolve(
-            cache:                 nil,
-            ui:                    nil,
-            module_paths:          [],
-            allow_missing_modules: false
+            cache:                       nil,
+            ui:                          nil,
+            allow_missing_modules:       false,
+            spec_searcher_configuration: spec_searcher_config(config)
           )
         rescue StandardError => e
           raise Bolt::Error.new(e.message, 'bolt/module-resolver-error')
         end
 
-        # Convert the specs returned from the resolver into Bolt module objects.
-        modules = result.specifications.values.each_with_object([]) do |mod, acc|
+        # Create the Puppetfile object.
+        generate_puppetfile(specs, result.specifications.values, unresolved)
+      end
+
+      # Creates a puppetfile-resolver config object.
+      #
+      private def spec_searcher_config(config)
+        PuppetfileResolver::SpecSearchers::Configuration.new.tap do |obj|
+          obj.forge.proxy     = config.dig('forge', 'proxy') || config.dig('proxy')
+          obj.git.proxy       = config.dig('proxy')
+          obj.forge.forge_api = config.dig('forge', 'baseurl')
+        end
+      end
+
+      # Creates a Puppetfile object with Module objects created from resolved and
+      # unresolved specs.
+      #
+      private def generate_puppetfile(specs, resolved, unresolved)
+        modules = []
+
+        # Convert the resolved specs into Bolt module objects.
+        resolved.each do |mod|
           # Skip over anything that isn't a module spec, such as a Puppet spec.
           next unless mod.is_a? PuppetfileResolver::Models::ModuleSpecification
 
           case mod.origin
           when :forge
-            acc << Bolt::ModuleInstaller::Puppetfile::ForgeModule.new(
+            modules << Bolt::ModuleInstaller::Puppetfile::ForgeModule.new(
               "#{mod.owner}/#{mod.name}",
               mod.version.to_s
             )
           when :git
             spec = specs.specs.find { |s| s.name == mod.name }
-            acc << Bolt::ModuleInstaller::Puppetfile::GitModule.new(
+            modules << Bolt::ModuleInstaller::Puppetfile::GitModule.new(
               spec.name,
               spec.git,
               spec.sha
@@ -68,7 +93,35 @@ module Bolt
           end
         end
 
-        # Create the Puppetfile object.
+        # Error if there are any name conflicts between unresolved specs and
+        # resolved modules. r10k will error if a Puppetfile includes duplicate
+        # names, but we error early here to provide a more helpful message.
+        if (name_conflicts = modules.map(&:name) & unresolved.map(&:name)).any?
+          raise Bolt::Error.new(
+            "Detected unresolved module specifications with the same name as a resolved module "\
+            "dependency: #{name_conflicts.join(', ')}. Either remove the unresolved module specification "\
+            "or set the module with the conflicting dependency to not resolve.",
+            "bolt/module-name-conflict-error"
+          )
+        end
+
+        # Convert the unresolved specs into Bolt module objects.
+        unresolved.each do |spec|
+          case spec.type
+          when :forge
+            modules << Bolt::ModuleInstaller::Puppetfile::ForgeModule.new(
+              spec.full_name,
+              spec.version_requirement
+            )
+          when :git
+            modules << Bolt::ModuleInstaller::Puppetfile::GitModule.new(
+              spec.name,
+              spec.git,
+              spec.ref
+            )
+          end
+        end
+
         Bolt::ModuleInstaller::Puppetfile.new(modules)
       end
     end

data/lib/bolt/module_installer/specs/forge_spec.rb

@@ -13,14 +13,20 @@ module Bolt
       class ForgeSpec
         NAME_REGEX    = %r{\A[a-zA-Z0-9]+[-/](?<name>[a-z][a-z0-9_]*)\z}.freeze
         REQUIRED_KEYS = Set.new(%w[name]).freeze
-        KNOWN_KEYS    = Set.new(%w[name version_requirement]).freeze
+        KNOWN_KEYS    = Set.new(%w[name resolve version_requirement]).freeze
 
-        attr_reader :full_name, :name, :semantic_version, :type
+        attr_reader :full_name, :name, :resolve, :semantic_version, :type, :version_requirement
 
         def initialize(init_hash)
+          @resolve                                = init_hash.key?('resolve') ? init_hash['resolve'] : true
           @full_name, @name                       = parse_name(init_hash['name'])
           @version_requirement, @semantic_version = parse_version_requirement(init_hash['version_requirement'])
           @type                                   = :forge
+
+          unless @resolve == true || @resolve == false
+            raise Bolt::ValidationError,
+                  "Option 'resolve' for module spec #{@full_name} must be a Boolean"
+          end
         end
 
         def self.implements?(hash)

data/lib/bolt/module_installer/specs/git_spec.rb

@@ -13,18 +13,31 @@ module Bolt
       class GitSpec
         NAME_REGEX    = %r{\A(?:[a-zA-Z0-9]+[-/])?(?<name>[a-z][a-z0-9_]*)\z}.freeze
         REQUIRED_KEYS = Set.new(%w[git ref]).freeze
+        KNOWN_KEYS    = Set.new(%w[git name ref resolve]).freeze
 
-        attr_reader :git, :ref, :type
+        attr_reader :git, :ref, :resolve, :type
 
         def initialize(init_hash)
+          @resolve    = init_hash.key?('resolve') ? init_hash['resolve'] : true
           @name       = parse_name(init_hash['name'])
           @git, @repo = parse_git(init_hash['git'])
           @ref        = init_hash['ref']
           @type       = :git
+
+          if @name.nil? && @resolve == false
+            raise Bolt::ValidationError,
+                  "Missing name for Git module specification: #{@git}. Git module specifications "\
+                  "must include a 'name' key when 'resolve' is false."
+          end
+
+          unless @resolve == true || @resolve == false
+            raise Bolt::ValidationError,
+                  "Option 'resolve' for module spec #{@git} must be a Boolean"
+          end
         end
 
         def self.implements?(hash)
-          REQUIRED_KEYS == hash.keys.to_set
+          KNOWN_KEYS.superset?(hash.keys.to_set) && REQUIRED_KEYS.subset?(hash.keys.to_set)
         end
 
         # Parses the name into owner and name segments, and formats the full
@@ -47,6 +60,8 @@ module Bolt
         # Gets the repo from the git URL.
         #
         private def parse_git(git)
+          return [git, nil] unless @resolve
+
           repo = if git.start_with?('git@github.com:')
                    git.split('git@github.com:').last.split('.git').first
                  elsif git.start_with?('https://github.com')

data/lib/bolt/outputter.rb

@@ -2,24 +2,25 @@
 
 module Bolt
   class Outputter
-    def self.for_format(format, color, verbose, trace)
+    def self.for_format(format, color, verbose, trace, spin)
       case format
       when 'human'
-        Bolt::Outputter::Human.new(color, verbose, trace)
+        Bolt::Outputter::Human.new(color, verbose, trace, spin)
       when 'json'
-        Bolt::Outputter::JSON.new(color, verbose, trace)
+        Bolt::Outputter::JSON.new(color, verbose, trace, false)
       when 'rainbow'
-        Bolt::Outputter::Rainbow.new(color, verbose, trace)
+        Bolt::Outputter::Rainbow.new(color, verbose, trace, spin)
       when nil
         raise "Cannot use outputter before parsing."
       end
     end
 
-    def initialize(color, verbose, trace, stream = $stdout)
+    def initialize(color, verbose, trace, spin, stream = $stdout)
       @color = color
       @verbose = verbose
       @trace = trace
       @stream = stream
+      @spin = spin
     end
 
     def indent(indent, string)
@@ -34,6 +35,19 @@ module Bolt
     def print_error
       raise NotImplementedError, "print_error() must be implemented by the outputter class"
     end
+
+    def start_spin; end
+
+    def stop_spin; end
+
+    def spin
+      start_spin
+      begin
+        yield
+      ensure
+        stop_spin
+      end
+    end
   end
 end
 

data/lib/bolt/outputter/human.rb

@@ -14,12 +14,13 @@ module Bolt
 
       def print_head; end
 
-      def initialize(color, verbose, trace, stream = $stdout)
+      def initialize(color, verbose, trace, spin, stream = $stdout)
         super
         # Plans and without_default_logging() calls can both be nested, so we
         # track each of them with a "stack" consisting of an integer.
         @plan_depth = 0
         @disable_depth = 0
+        @pinwheel = %w[- \\ | /]
       end
 
       def colorize(color, string)
@@ -30,6 +31,24 @@ module Bolt
         end
       end
 
+      def start_spin
+        return unless @spin && @stream.isatty && !@spinning
+        @spinning = true
+        @spin_thread = Thread.new do
+          loop do
+            sleep(0.1)
+            @stream.print(colorize(:cyan, @pinwheel.rotate!.first + "\b"))
+          end
+        end
+      end
+
+      def stop_spin
+        return unless @spin && @stream.isatty && @spinning
+        @spinning = false
+        @spin_thread.terminate
+        @stream.print("\b")
+      end
+
       def remove_trail(string)
         string.sub(/\s\z/, '')
       end
@@ -62,6 +81,10 @@ module Bolt
             print_plan_start(event)
           when :plan_finish
             print_plan_finish(event)
+          when :start_spin
+            start_spin
+          when :stop_spin
+            stop_spin
           end
         end
       end

data/lib/bolt/outputter/json.rb

@@ -3,7 +3,7 @@
 module Bolt
   class Outputter
     class JSON < Bolt::Outputter
-      def initialize(color, verbose, trace, stream = $stdout)
+      def initialize(color, verbose, trace, spin, stream = $stdout)
         super
         @items_open = false
         @object_open = false

data/lib/bolt/outputter/logger.rb

@@ -6,7 +6,7 @@ module Bolt
   class Outputter
     class Logger < Bolt::Outputter
       def initialize(verbose, trace)
-        super(false, verbose, trace)
+        super(false, verbose, trace, false)
         @logger = Bolt::Logger.logger(self)
       end
 

data/lib/bolt/outputter/rainbow.rb

@@ -5,7 +5,7 @@ require 'bolt/pal'
 module Bolt
   class Outputter
     class Rainbow < Bolt::Outputter::Human
-      def initialize(color, verbose, trace, stream = $stdout)
+      def initialize(color, verbose, trace, spin, stream = $stdout)
         begin
           require 'paint'
           if Bolt::Util.windows?
@@ -62,6 +62,17 @@ module Bolt
         end
       end
 
+      def start_spin
+        return unless @spin && @stream.isatty && !@spinning
+        @spinning = true
+        @spin_thread = Thread.new do
+          loop do
+            sleep(0.1)
+            @stream.print(colorize(:rainbow, @pinwheel.rotate!.first + "\b"))
+          end
+        end
+      end
+
       def print_summary(results, elapsed_time = nil)
         ok_set = results.ok_set
         unless ok_set.empty?