bolt 2.24.1 → 2.29.0

data/lib/bolt/pal/yaml_plan/evaluator.rb

@@ -7,7 +7,7 @@ module Bolt
     class YamlPlan
       class Evaluator
         def initialize(analytics = Bolt::Analytics::NoopClient.new)
-          @logger = Logging.logger[self]
+          @logger = Bolt::Logger.logger(self)
           @analytics = analytics
           @evaluator = Puppet::Pops::Parser::EvaluatingParser.new
         end

data/lib/bolt/plugin/puppetdb.rb

@@ -19,7 +19,7 @@ module Bolt
       def initialize(config:, context:)
         pdb_config = Bolt::PuppetDB::Config.load_config(config, context.boltdir)
         @puppetdb_client = Bolt::PuppetDB::Client.new(pdb_config)
-        @logger = Logging.logger[self]
+        @logger = Bolt::Logger.logger(self)
       end
 
       def name

data/lib/bolt/project.rb

@@ -17,37 +17,53 @@ module Bolt
     }.freeze
 
     attr_reader :path, :data, :config_file, :inventory_file, :modulepath, :hiera_config,
-                :puppetfile, :rerunfile, :type, :resource_types, :warnings, :project_file,
+                :puppetfile, :rerunfile, :type, :resource_types, :logs, :project_file,
                 :deprecations, :downloads, :plans_path
 
-    def self.default_project
-      create_project(File.expand_path(File.join('~', '.puppetlabs', 'bolt')), 'user')
+    def self.default_project(logs = [])
+      create_project(File.expand_path(File.join('~', '.puppetlabs', 'bolt')), 'user', logs)
     # If homedir isn't defined use the system config path
     rescue ArgumentError
-      create_project(Bolt::Config.system_path, 'system')
+      create_project(Bolt::Config.system_path, 'system', logs)
     end
 
     # Search recursively up the directory hierarchy for the Project. Look for a
     # directory called Boltdir or a file called bolt.yaml (for a control repo
     # type Project). Otherwise, repeat the check on each directory up the
     # hierarchy, falling back to the default if we reach the root.
-    def self.find_boltdir(dir)
+    def self.find_boltdir(dir, logs = [])
       dir = Pathname.new(dir)
 
       if (dir + BOLTDIR_NAME).directory?
-        create_project(dir + BOLTDIR_NAME, 'embedded')
+        create_project(dir + BOLTDIR_NAME, 'embedded', logs)
       elsif (dir + 'bolt.yaml').file? || (dir + 'bolt-project.yaml').file?
-        create_project(dir, 'local')
+        create_project(dir, 'local', logs)
       elsif dir.root?
-        default_project
+        default_project(logs)
       else
-        find_boltdir(dir.parent)
+        logs << { debug: "Did not detect Boltdir, bolt.yaml, or bolt-project.yaml at '#{dir}'. "\
+                  "This directory won't be loaded as a project." }
+        find_boltdir(dir.parent, logs)
       end
     end
 
-    def self.create_project(path, type = 'option')
+    def self.create_project(path, type = 'option', logs = [])
       fullpath = Pathname.new(path).expand_path
 
+      if type == 'user'
+        begin
+          # This is already expanded if the type is user
+          FileUtils.mkdir_p(path)
+        rescue StandardError
+          logs << { warn: "Could not create default project at #{path}. Continuing without a writeable project. "\
+                    "Log and rerun files will not be written." }
+        end
+      end
+
+      if type == 'option' && !File.directory?(path)
+        raise Bolt::Error.new("Could not find project at #{path}", "bolt/project-error")
+      end
+
       if !Bolt::Util.windows? && type != 'environment' && fullpath.world_writable?
         raise Bolt::Error.new(
           "Project directory '#{fullpath}' is world-writable which poses a security risk. Set "\
@@ -58,15 +74,18 @@ module Bolt
 
       project_file = File.join(fullpath, 'bolt-project.yaml')
       data = Bolt::Util.read_optional_yaml_hash(File.expand_path(project_file), 'project')
-      new(data, path, type)
+      default = type =~ /user|system/ ? 'default ' : ''
+      exist = File.exist?(File.expand_path(project_file))
+      logs << { info: "Loaded #{default}project from '#{fullpath}'" } if exist
+      new(data, path, type, logs)
     end
 
-    def initialize(raw_data, path, type = 'option')
+    def initialize(raw_data, path, type = 'option', logs = [])
       @path = Pathname.new(path).expand_path
 
       @project_file = @path + 'bolt-project.yaml'
 
-      @warnings = []
+      @logs = logs
       @deprecations = []
       if (@path + 'bolt.yaml').file? && project_file?
         msg = "Project-level configuration in bolt.yaml is deprecated if using bolt-project.yaml. "\
@@ -88,7 +107,7 @@ module Bolt
       tc = Bolt::Config::INVENTORY_OPTIONS.keys & raw_data.keys
       if tc.any?
         msg = "Transport configuration isn't supported in bolt-project.yaml. Ignoring keys #{tc}"
-        @warnings << { msg: msg }
+        @logs << { warn: msg }
       end
 
       @data = raw_data.reject { |k, _| Bolt::Config::INVENTORY_OPTIONS.include?(k) }
@@ -98,7 +117,7 @@ module Bolt
       @config_file = if (Bolt::Config::BOLT_OPTIONS & @data.keys).any?
                        if (@path + 'bolt.yaml').file?
                          msg = "bolt-project.yaml contains valid config keys, bolt.yaml will be ignored"
-                         @warnings << { msg: msg }
+                         @logs << { warn: msg }
                        end
                        @project_file
                      else
@@ -114,7 +133,9 @@ module Bolt
     # This API is used to prepend the project as a module to Puppet's internal
     # module_references list. CHANGE AT YOUR OWN RISK
     def to_h
-      { path: @path.to_s, name: name }
+      { path: @path.to_s,
+        name: name,
+        load_as_module?: load_as_module? }
     end
 
     def eql?(other)
@@ -126,6 +147,10 @@ module Bolt
       @project_file.file?
     end
 
+    def load_as_module?
+      !name.nil?
+    end
+
     def name
       @data['name']
     end
@@ -138,6 +163,10 @@ module Bolt
       @data['plans']
     end
 
+    def modules
+      @data['modules']
+    end
+
     def validate
       if name
         if name !~ Bolt::Module::MODULE_NAME_REGEX
@@ -151,7 +180,7 @@ module Bolt
         end
       else
         message = "No project name is specified in bolt-project.yaml. Project-level content will not be available."
-        @warnings << { msg: message }
+        @logs << { warn: message }
       end
 
       %w[tasks plans].each do |conf|
@@ -159,6 +188,22 @@ module Bolt
           raise Bolt::ValidationError, "'#{conf}' in bolt-project.yaml must be an array"
         end
       end
+
+      if @data['modules']
+        unless @data['modules'].is_a?(Array)
+          raise Bolt::ValidationError, "'modules' in bolt-project.yaml must be an array"
+        end
+
+        @data['modules'].each do |mod|
+          next if mod.is_a?(Hash)
+          raise Bolt::ValidationError, "Module declaration #{mod.inspect} must be a hash"
+        end
+
+        unknown_keys = data['modules'].flat_map(&:keys).uniq - %w[name version_requirement]
+        if unknown_keys.any?
+          @logs << { warn: "Ignoring unknown keys in module declarations: #{unknown_keys.join(', ')}." }
+        end
+      end
     end
 
     def check_deprecated_file

data/lib/bolt/puppetdb/client.rb

@@ -13,7 +13,7 @@ module Bolt
         @config = config
         @bad_urls = []
         @current_url = nil
-        @logger = Logging.logger[self]
+        @logger = Bolt::Logger.logger(self)
       end
 
       def query_certnames(query)

data/lib/bolt/puppetdb/config.rb

@@ -35,7 +35,7 @@ module Bolt
         begin
           config = JSON.parse(File.read(filepath)) if filepath
         rescue StandardError => e
-          Logging.logger[self].error("Could not load puppetdb.conf from #{filepath}: #{e.message}")
+          Bolt::Logger.logger(self).error("Could not load puppetdb.conf from #{filepath}: #{e.message}")
         end
 
         config = config.fetch('puppetdb', {})

data/lib/bolt/puppetfile.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+require 'bolt/puppetfile/module'
+
+# This class manages the logical contents of a Puppetfile. It includes methods
+# for parsing a Puppetfile and its modules, resolving module dependencies,
+# and writing a Puppetfile.
+#
+module Bolt
+  class Puppetfile
+    attr_reader :modules
+
+    def initialize(modules = [])
+      @modules = Set.new
+      add_modules(modules)
+    end
+
+    # Loads a Puppetfile and parses its module specifications, returning a
+    # Bolt::Puppetfile object with the modules set.
+    #
+    def self.parse(path)
+      require 'puppetfile-resolver'
+      require 'puppetfile-resolver/puppetfile/parser/r10k_eval'
+
+      begin
+        parsed = ::PuppetfileResolver::Puppetfile::Parser::R10KEval.parse(File.read(path))
+      rescue StandardError => e
+        raise Bolt::Error.new(
+          "Unable to parse Puppetfile #{path}: #{e.message}",
+          'bolt/puppetfile-parsing'
+        )
+      end
+
+      unless parsed.valid?
+        raise Bolt::ValidationError,
+              "Unable to parse Puppetfile #{path}"
+      end
+
+      modules = parsed.modules.map do |mod|
+        Bolt::Puppetfile::Module.new(mod.owner, mod.name, mod.version)
+      end
+
+      new(modules)
+    end
+
+    # Writes a Puppetfile that includes specifications for each of the
+    # modules.
+    #
+    def write(path, force: false)
+      if File.exist?(path) && !force
+        raise Bolt::FileError.new(
+          "Cannot overwrite existing Puppetfile at #{path}. To forcibly overwrite, "\
+          "run with the '--force' option.",
+          path
+        )
+      end
+
+      File.open(path, 'w') do |file|
+        file.puts '# This Puppetfile is managed by Bolt. Do not edit.'
+        modules.each { |mod| file.puts mod.to_spec }
+        file.puts
+      end
+    rescue SystemCallError => e
+      raise Bolt::FileError.new(
+        "#{e.message}: unable to write Puppetfile.",
+        path
+      )
+    end
+
+    # Resolves module dependencies using the puppetfile-resolver library. The
+    # resolver will return a document model including all module dependencies
+    # and the latest version that can be installed for each. The document model
+    # is parsed and turned into a Set of Bolt::Puppetfile::Module objects.
+    #
+    def resolve
+      require 'puppetfile-resolver'
+
+      # Build the document model from the modules.
+      model = PuppetfileResolver::Puppetfile::Document.new('')
+
+      @modules.each do |mod|
+        model.add_module(
+          PuppetfileResolver::Puppetfile::ForgeModule.new(mod.title).tap do |tap|
+            tap.version = mod.version || :latest
+          end
+        )
+      end
+
+      # Make sure the Puppetfile model is valid.
+      unless model.valid?
+        raise Bolt::ValidationError,
+              "Unable to resolve dependencies for modules: #{@modules.map(&:title).join(', ')}"
+      end
+
+      # Create the resolver using the Puppetfile model. nil disables Puppet
+      # version restrictions.
+      resolver = PuppetfileResolver::Resolver.new(model, nil)
+
+      # Configure and resolve the dependency graph, catching any errors
+      # raised by puppetfile-resolver and re-raising them as Bolt errors.
+      begin
+        result = resolver.resolve(
+          cache:                 nil,
+          ui:                    nil,
+          module_paths:          [],
+          allow_missing_modules: true
+        )
+      rescue StandardError => e
+        raise Bolt::Error.new(e.message, 'bolt/puppetfile-resolver-error')
+      end
+
+      # Validate that the modules exist.
+      missing_graph = result.specifications.select do |_name, spec|
+        spec.instance_of? PuppetfileResolver::Models::MissingModuleSpecification
+      end
+
+      if missing_graph.any?
+        titles = model.modules.each_with_object({}) do |mod, acc|
+          acc[mod.name] = mod.title
+        end
+
+        names = titles.values_at(*missing_graph.keys)
+        plural = names.count == 1 ? '' : 's'
+
+        raise Bolt::Error.new(
+          "Unknown module name#{plural} #{names.join(', ')}",
+          'bolt/unknown-modules'
+        )
+      end
+
+      # Filter the dependency graph to only include module specifications. This
+      # will only remove the Puppet version specification, which is not needed.
+      specs = result.specifications.select do |_name, spec|
+        spec.instance_of? PuppetfileResolver::Models::ModuleSpecification
+      end
+
+      @modules = specs.map do |_name, spec|
+        Bolt::Puppetfile::Module.new(spec.owner, spec.name, spec.version.to_s)
+      end.to_set
+    end
+
+    # Adds to the set of modules.
+    #
+    def add_modules(modules)
+      modules.each do |mod|
+        case mod
+        when Bolt::Puppetfile::Module
+          @modules << mod
+        when Hash
+          @modules << Bolt::Puppetfile::Module.from_hash(mod)
+        else
+          raise Bolt::ValidationError, "Module must be a Bolt::Puppetfile::Module or Hash."
+        end
+      end
+
+      @modules
+    end
+  end
+end

data/lib/bolt/puppetfile/installer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'r10k/cli'
+require 'bolt/r10k_log_proxy'
+require 'bolt/error'
+
+# This class is used to install modules from a Puppetfile to a module directory.
+#
+module Bolt
+  class Puppetfile
+    class Installer
+      def initialize(config = {})
+        @config = config
+      end
+
+      def install(path, moduledir)
+        unless File.exist?(path)
+          raise Bolt::FileError.new(
+            "Could not find a Puppetfile at #{path}",
+            path
+          )
+        end
+
+        r10k_opts = {
+          root:       File.dirname(path),
+          puppetfile: path.to_s,
+          moduledir:  moduledir.to_s
+        }
+
+        settings = R10K::Settings.global_settings.evaluate(@config)
+        R10K::Initializers::GlobalInitializer.new(settings).call
+        install_action = R10K::Action::Puppetfile::Install.new(r10k_opts, nil)
+
+        # Override the r10k logger with a proxy to our own logger
+        R10K::Logging.instance_variable_set(:@outputter, Bolt::R10KLogProxy.new)
+
+        install_action.call
+      rescue R10K::Error => e
+        raise PuppetfileError, e
+      end
+    end
+  end
+end

data/lib/bolt/puppetfile/module.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# This class represents a module specification. It used by the Bolt::Puppetfile
+# class to have a consistent API for accessing a module's attributes.
+#
+module Bolt
+  class Puppetfile
+    class Module
+      attr_reader :owner, :name, :version
+
+      def initialize(owner, name, version = nil)
+        @owner   = owner
+        @name    = name
+        @version = version
+      end
+
+      # Creates a new module from a hash.
+      #
+      def self.from_hash(mod)
+        unless mod['name'].is_a?(String)
+          raise Bolt::ValidationError,
+                "Module name must be a String, not #{mod['name'].inspect}"
+        end
+
+        owner, name = mod['name'].tr('/', '-').split('-', 2)
+
+        unless owner && name
+          raise Bolt::ValidationError, "Module name #{mod['name']} must include both the owner and module name."
+        end
+
+        new(owner, name, mod['version_requirement'])
+      end
+
+      # Returns the module's title.
+      #
+      def title
+        "#{@owner}-#{@name}"
+      end
+
+      # Checks two modules for equality.
+      #
+      def eql?(other)
+        self.class == other.class &&
+          @owner == other.owner &&
+          @name == other.name &&
+          versions_intersect?(other)
+      end
+      alias == eql?
+
+      # Returns true if the versions of two modules intersect. Used to determine
+      # if an installed module satisfies the version requirement of another.
+      #
+      def versions_intersect?(other)
+        range       = ::SemanticPuppet::VersionRange.parse(@version || '')
+        other_range = ::SemanticPuppet::VersionRange.parse(other.version || '')
+
+        range.intersection(other_range) != ::SemanticPuppet::VersionRange::EMPTY_RANGE
+      end
+
+      # Hashes the module.
+      #
+      def hash
+        [@owner, @name].hash
+      end
+
+      # Returns a hash representation similar to the module
+      # declaration.
+      #
+      def to_hash
+        {
+          'name'                => title,
+          'version_requirement' => version
+        }.compact
+      end
+
+      # Returns the Puppetfile specification for the module.
+      #
+      def to_spec
+        if @version
+          "mod #{title.inspect}, #{@version.inspect}"
+        else
+          "mod #{title.inspect}"
+        end
+      end
+    end
+  end
+end