bolt 2.25.0 → 2.30.0

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,142 @@
+# 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, skip_unsupported_modules: false)
+      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?
+        # valid? Just checks if validation_errors is empty, so if we get here we know it's not.
+        raise Bolt::ValidationError, <<~MSG
+        Unable to parse Puppetfile #{path}:
+        #{parsed.validation_errors.join("\n\n")}.
+        This may not be a Puppetfile managed by Bolt.
+        MSG
+      end
+
+      modules = parsed.modules.each_with_object([]) do |mod, acc|
+        unless mod.instance_of? PuppetfileResolver::Puppetfile::ForgeModule
+          next if skip_unsupported_modules
+
+          raise Bolt::ValidationError,
+                "Module '#{mod.title}' is not a Puppet Forge module. Unable to "\
+                "parse Puppetfile #{path}."
+        end
+
+        acc << 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, moduledir = nil)
+      File.open(path, 'w') do |file|
+        file.puts '# This Puppetfile is managed by Bolt. Do not edit.'
+        file.puts "moduledir '#{moduledir.basename}'" if moduledir
+        modules.each { |mod| file.puts mod.to_spec }
+      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: false
+        )
+      rescue StandardError => e
+        raise Bolt::Error.new(e.message, 'bolt/puppetfile-resolver-error')
+      end
+
+      # Turn specifications into module objects. This will skip over anything that is not
+      # a module specification (i.e. a Puppet version specification).
+      @modules = result.specifications.each_with_object(Set.new) do |(_name, spec), acc|
+        next unless spec.instance_of? PuppetfileResolver::Models::ModuleSpecification
+        acc << Bolt::Puppetfile::Module.new(spec.owner, spec.name, spec.version.to_s)
+      end
+    end
+
+    # Adds to the set of modules.
+    #
+    def add_modules(modules)
+      Array(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,90 @@
+# 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 unless version == :latest
+      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
+      alias to_s title
+
+      # 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

data/lib/bolt/r10k_log_proxy.rb

@@ -7,7 +7,7 @@ module Bolt
     def initialize
       super('bolt')
 
-      @logger = Logging.logger[self]
+      @logger = Bolt::Logger.logger(self)
     end
 
     def canonical_log(event)

data/lib/bolt/rerun.rb

@@ -8,7 +8,7 @@ module Bolt
     def initialize(path, save_failures)
       @path = path
       @save_failures = save_failures
-      @logger = Logging.logger[self]
+      @logger = Bolt::Logger.logger(self)
     end
 
     def data
@@ -53,7 +53,7 @@ module Bolt
         end
       end
     rescue StandardError => e
-      @logger.warn("Failed to save result to #{@path}: #{e.message}")
+      Bolt::Logger.warn_once('unwriteable_file', "Failed to save result to #{@path}: #{e.message}")
     end
   end
 end

data/lib/bolt/result.rb

@@ -65,6 +65,25 @@ module Bolt
                             'msg' => msg,
                             'details' => { 'exit_code' => exit_code } }
       end
+
+      if value.key?('_error')
+        unless value['_error'].is_a?(Hash) && value['_error'].key?('msg')
+          value['_error'] = {
+            'msg'     => "Invalid error returned from task #{task}: #{value['_error'].inspect}. Error "\
+                         "must be an object with a msg key.",
+            'kind'    => 'bolt/invalid-task-error',
+            'details' => { 'original_error' => value['_error'] }
+          }
+        end
+
+        value['_error']['kind']    ||= 'bolt/error'
+        value['_error']['details'] ||= {}
+      end
+
+      if value.key?('_sensitive')
+        value['_sensitive'] = Puppet::Pops::Types::PSensitiveType::Sensitive.new(value['_sensitive'])
+      end
+
       new(target, value: value, action: 'task', object: task)
     end
 
@@ -205,5 +224,9 @@ module Bolt
 
       end
     end
+
+    def sensitive
+      value['_sensitive']
+    end
   end
 end

data/lib/bolt/shell.rb

@@ -7,7 +7,7 @@ module Bolt
     def initialize(target, conn)
       @target = target
       @conn = conn
-      @logger = Logging.logger[@target.safe_name]
+      @logger = Bolt::Logger.logger(@target.safe_name)
     end
 
     def run_command(*_args)

data/lib/bolt/shell/bash.rb

@@ -143,7 +143,7 @@ module Bolt
 
             execute_options[:stdin] = stdin
             execute_options[:sudoable] = true if run_as
-            output = execute(remote_task_path, execute_options)
+            output = execute(remote_task_path, **execute_options)
           end
           Bolt::Result.for_task(target, output.stdout.string,
                                 output.stderr.string,

data/lib/bolt/task.rb

@@ -26,7 +26,7 @@ module Bolt
       @metadata = metadata
       @files = files
       @remote = remote
-      @logger = Logging.logger[self]
+      @logger = Bolt::Logger.logger(self)
 
       validate_metadata
     end

data/lib/bolt/transport/base.rb

@@ -40,17 +40,17 @@ module Bolt
       attr_reader :logger
 
       def initialize
-        @logger = Logging.logger[self]
+        @logger = Bolt::Logger.logger(self)
       end
 
       def with_events(target, callback, action)
         callback&.call(type: :node_start, target: target)
 
         result = begin
-                   yield
-                 rescue StandardError, NotImplementedError => e
-                   Bolt::Result.from_exception(target, e, action: action)
-                 end
+          yield
+        rescue StandardError, NotImplementedError => e
+          Bolt::Result.from_exception(target, e, action: action)
+        end
 
         callback&.call(type: :node_result, result: result)
         result

data/lib/bolt/transport/docker/connection.rb

@@ -10,7 +10,7 @@ module Bolt
         def initialize(target)
           raise Bolt::ValidationError, "Target #{target.safe_name} does not have a host" unless target.host
           @target = target
-          @logger = Logging.logger[target.safe_name]
+          @logger = Bolt::Logger.logger(target.safe_name)
           @docker_host = @target.options['service-url']
           @logger.trace("Initializing docker connection to #{@target.safe_name}")
         end

data/lib/bolt/transport/local/connection.rb

@@ -16,7 +16,7 @@ module Bolt
           @target = target
           # The familiar problem: Etc.getlogin is broken on osx
           @user = ENV['USER'] || Etc.getlogin
-          @logger = Logging.logger[self]
+          @logger = Bolt::Logger.logger(self)
         end
 
         def shell

data/lib/bolt/transport/ssh.rb

@@ -17,7 +17,7 @@ module Bolt
         rescue LoadError
           logger.debug("Authentication method 'gssapi-with-mic' (Kerberos) is not available.")
         end
-        @transport_logger = Logging.logger[Net::SSH]
+        @transport_logger = Bolt::Logger.logger(Net::SSH)
         @transport_logger.level = :warn
       end
 

data/lib/bolt/transport/ssh/connection.rb

@@ -26,7 +26,7 @@ module Bolt
           @user = @target.user || ssh_config[:user] || Etc.getlogin
           @strict_host_key_checking = ssh_config[:strict_host_key_checking]
 
-          @logger = Logging.logger[@target.safe_name]
+          @logger = Bolt::Logger.logger(@target.safe_name)
           @transport_logger = transport_logger
           @logger.trace("Initializing ssh connection to #{@target.safe_name}")