bolt 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca6e259cbc835ea3d8b4f5f67d2b199faf19adfeb2a2d9b0b999582b919a863a
-  data.tar.gz: 2152f34ff150aaaf2d1c0a6fb114d401ef3ddf5c2da5a739e8f2fa22ab5565cf
+  metadata.gz: d1188441f6f0d4a4012c0e1bedbfeff66dcafa7624911448865e4081950510c3
+  data.tar.gz: 5add229df85ea63038f8a2492adcd1086ad3d3201280bed7b22fb7cfdaf205a3
 SHA512:
-  metadata.gz: 69fe10cdd01be7f4965a8e6cca73aa9c65f449b94bb35909399839ca4c506107b611df43f3a0e27fe9fce896d3e63261f3dc90ce329d257583ff427e6c712eb3
-  data.tar.gz: 400b7ef4c9b01ad6c5464481ac73f5c3b7774e25aa6780f1aa404e3e6504091c57828d9a0bdaf7a3f4effecd08ff1b35cae4dd8e5b7dd6b6329267805ce0ef77
+  metadata.gz: 49cdd374d0607bfd3ff6367d1c9b3be6061df74a7c1ed57940e07b78f9ae7f9fc8e235769fb741b63b85b136f127ee289ac26110b692c47d03d19cf543e0e495
+  data.tar.gz: 5bdb2cea2de3c6a8696b7e3b76a2ece602d94480f42b30feb8c2531bc93ca5ebadf3ba1b3f6d3bfe9cc5ba0effc0e9d0949729af7df20313d159fcbac554eb03

data/bolt-modules/boltlib/lib/puppet/functions/run_command.rb

@@ -26,7 +26,7 @@ Puppet::Functions.create_function(:run_command) do
   # @param options Additional options: '_catch_errors', '_run_as'.
   # @return A list of results, one entry per target.
   # @example Run a command on targets
-  #   run_command('hostname', $targets, '_catch_errors' => true)
+  #   run_command('hostname', $targets, 'Get hostname')
   dispatch :run_command_with_description do
     param 'String[1]', :command
     param 'Boltlib::TargetSpec', :targets

data/bolt-modules/boltlib/lib/puppet/functions/wait_until_available.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'bolt/util'
+
+# Wait until all targets accept connections.
+Puppet::Functions.create_function(:wait_until_available) do
+  # Wait until targets are available.
+  # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
+  # @param options Additional options: 'description', 'wait_time', 'retry_interval', '_catch_errors'.
+  # @return A list of results, one entry per target. Successful results have no value.
+  # @example Wait for targets
+  #   wait_until_available($targets, wait_time => 300)
+  dispatch :wait_until_available do
+    param 'Boltlib::TargetSpec', :targets
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'ResultSet'
+  end
+
+  def wait_until_available(targets, options = nil)
+    options ||= {}
+
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, operation: 'wait_until_available'
+      )
+    end
+
+    executor = Puppet.lookup(:bolt_executor) { nil }
+    inventory = Puppet.lookup(:bolt_inventory) { nil }
+    unless executor && inventory && Puppet.features.bolt?
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Puppet::Pops::Issues::TASK_MISSING_BOLT, action: _('wait until targets are available')
+      )
+    end
+
+    executor.report_function_call('wait_until_available')
+
+    # Ensure that given targets are all Target instances
+    targets = inventory.get_targets(targets)
+
+    if targets.empty?
+      call_function('debug', "Simulating wait_until_available - no targets given")
+      r = Bolt::ResultSet.new([])
+    else
+      opts = Bolt::Util.symbolize_top_level_keys(options.reject { |k| k == '_catch_errors' })
+      r = executor.wait_until_available(targets, **opts)
+    end
+
+    if !r.ok && !options['_catch_errors']
+      raise Bolt::RunFailure.new(r, 'wait_until_available')
+    end
+    r
+  end
+end

data/lib/bolt/config.rb

@@ -9,13 +9,15 @@ require 'bolt/transport/ssh'
 require 'bolt/transport/winrm'
 require 'bolt/transport/orch'
 require 'bolt/transport/local'
+require 'bolt/transport/docker'
 
 module Bolt
   TRANSPORTS = {
     ssh: Bolt::Transport::SSH,
     winrm: Bolt::Transport::WinRM,
     pcp: Bolt::Transport::Orch,
-    local: Bolt::Transport::Local
+    local: Bolt::Transport::Local,
+    docker: Bolt::Transport::Docker
   }.freeze
 
   class UnknownTransportError < Bolt::Error
@@ -50,7 +52,8 @@ module Bolt
       pcp: {
         'task-environment' => 'production'
       },
-      local: {}
+      local: {},
+      docker: {}
     }.freeze
 
     def self.default

data/lib/bolt/error.rb

@@ -50,13 +50,14 @@ module Bolt
   class RunFailure < Bolt::Error
     attr_reader :result_set
 
-    def initialize(result_set, action, object)
+    def initialize(result_set, action, object = nil)
       details = {
         'action' => action,
         'object' => object,
         'result_set' => result_set
       }
-      message = "Plan aborted: #{action} '#{object}' failed on #{result_set.error_set.length} nodes"
+      object_msg = " '#{object}'" if object
+      message = "Plan aborted: #{action}#{object_msg} failed on #{result_set.error_set.length} nodes"
       super(message, 'bolt/run-failure', details)
       @result_set = result_set
       @error_code = 2

data/lib/bolt/executor.rb

@@ -256,6 +256,39 @@ module Bolt
       end
     end
 
+    class TimeoutError < RuntimeError; end
+
+    def wait_until_available(targets,
+                             description: 'wait until available',
+                             wait_time: 120,
+                             retry_interval: 1)
+      log_action(description, targets) do
+        batch_execute(targets) do |transport, batch|
+          with_node_logging('Waiting until available', batch) do
+            begin
+              wait_until(wait_time, retry_interval) { transport.batch_connected?(batch) }
+              batch.map { |target| Result.new(target) }
+            rescue TimeoutError => e
+              batch.map { |target| Result.from_exception(target, e) }
+            end
+          end
+        end
+      end
+    end
+
+    # Used to simplify unit testing, to avoid having to mock other calls to Time.now.
+    private def wait_now
+      Time.now
+    end
+
+    def wait_until(timeout, retry_interval)
+      start = wait_now
+      until yield
+        raise(TimeoutError, 'Timed out waiting for target') if (wait_now - start).to_i >= timeout
+        sleep(retry_interval)
+      end
+    end
+
     # Plan context doesn't make sense for most transports but it is tightly
     # coupled with the orchestrator transport since the transport behaves
     # differently when a plan is running. In order to limit how much this

data/lib/bolt/target.rb

@@ -47,8 +47,8 @@ module Bolt
       @password = t_conf['password']
       @port = t_conf['port']
 
-      url_keys = %w[user password port]
-      @options = t_conf.reject { |k, _| url_keys.include?(k) }.merge(@options)
+      # Preserve everything in options so we can easily create copies of a Target.
+      @options = t_conf.merge(@options)
 
       self
     end

data/lib/bolt/transport/base.rb

@@ -153,6 +153,11 @@ module Bolt
         end
       end
 
+      def batch_connected?(targets)
+        assert_batch_size_one("connected?()", targets)
+        connected?(targets.first)
+      end
+
       # Split the given list of targets into a list of batches. The default
       # implementation returns single-node batches.
       #
@@ -182,6 +187,11 @@ module Bolt
         raise NotImplementedError, "upload() must be implemented by the transport class"
       end
 
+      # Transports should override this method with their own implementation of a connection test.
+      def connected?(_targets)
+        raise NotImplementedError, "connected?() must be implemented by the transport class"
+      end
+
       # Unwraps any Sensitive data in an arguments Hash, so the plain-text is passed
       # to the Task/Script.
       #

data/lib/bolt/transport/docker.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'shellwords'
+require 'bolt/transport/base'
+
+module Bolt
+  module Transport
+    class Docker < Base
+      def self.options
+        %w[service-url service-options tmpdir]
+      end
+
+      PROVIDED_FEATURES = ['shell'].freeze
+
+      def self.validate(options)
+        if (url = options['service-url'])
+          unless url.instance_of?(String)
+            raise Bolt::ValidationError, 'service-url must be a string'
+          end
+        end
+
+        if (opts = options['service-options'])
+          unless opts.instance_of?(Hash)
+            raise Bolt::ValidationError, 'service-options must be a hash'
+          end
+        end
+      end
+
+      def with_connection(target)
+        conn = Connection.new(target)
+        conn.connect
+        yield conn
+      end
+
+      def upload(target, source, destination, _options = {})
+        with_connection(target) do |conn|
+          conn.with_remote_tempdir do |dir|
+            basename = File.basename(destination)
+            tmpfile = "#{dir}/#{basename}"
+            if File.directory?(source)
+              conn.write_remote_directory(source, tmpfile)
+            else
+              conn.write_remote_file(source, tmpfile)
+            end
+
+            _, stderr, exitcode = conn.execute('mv', tmpfile, destination, {})
+            if exitcode != 0
+              message = "Could not move temporary file '#{tmpfile}' to #{destination}: #{stderr.join}"
+              raise Bolt::Node::FileError.new(message, 'MV_ERROR')
+            end
+          end
+          Bolt::Result.for_upload(target, source, destination)
+        end
+      end
+
+      def run_command(target, command, _options = {})
+        with_connection(target) do |conn|
+          stdout, stderr, exitcode = conn.execute(*Shellwords.split(command), {})
+          Bolt::Result.for_command(target, stdout.join, stderr.join, exitcode)
+        end
+      end
+
+      def run_script(target, script, arguments, _options = {})
+        # unpack any Sensitive data
+        arguments = unwrap_sensitive_args(arguments)
+
+        with_connection(target) do |conn|
+          conn.with_remote_tempdir do |dir|
+            remote_path = conn.write_remote_executable(dir, script)
+            stdout, stderr, exitcode = conn.execute(remote_path, *arguments, {})
+            Bolt::Result.for_command(target, stdout.join, stderr.join, exitcode)
+          end
+        end
+      end
+
+      def run_task(target, task, arguments, _options = {})
+        implementation = task.select_implementation(target, PROVIDED_FEATURES)
+        executable = implementation['path']
+        input_method = implementation['input_method']
+        extra_files = implementation['files']
+        input_method ||= 'both'
+
+        # unpack any Sensitive data
+        arguments = unwrap_sensitive_args(arguments)
+        with_connection(target) do |conn|
+          execute_options = {}
+
+          conn.with_remote_tempdir do |dir|
+            if extra_files.empty?
+              task_dir = dir
+            else
+              # TODO: optimize upload of directories
+              arguments['_installdir'] = dir
+              task_dir = File.join(dir, task.tasks_dir)
+              conn.mkdirs([task_dir] + extra_files.map { |file| File.join(dir, File.dirname(file['name'])) })
+              extra_files.each do |file|
+                conn.write_remote_file(file['path'], File.join(dir, file['name']))
+              end
+            end
+
+            remote_task_path = conn.write_remote_executable(task_dir, executable)
+
+            if STDIN_METHODS.include?(input_method)
+              execute_options[:stdin] = StringIO.new(JSON.dump(arguments))
+            end
+
+            if ENVIRONMENT_METHODS.include?(input_method)
+              execute_options[:environment] = envify_params(arguments)
+            end
+
+            stdout, stderr, exitcode = conn.execute(remote_task_path, execute_options)
+            Bolt::Result.for_task(target, stdout.join, stderr.join, exitcode)
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'bolt/transport/docker/connection'

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'docker'
+require 'logging'
+require 'bolt/node/errors'
+
+module Bolt
+  module Transport
+    class Docker < Base
+      class Connection
+        def initialize(target)
+          @target = target
+          @logger = Logging.logger[target.host]
+        end
+
+        def connect
+          # Explicitly create the new Connection to avoid relying on global state in the Docker module.
+          url = @target.options['service-url'] || ::Docker.url
+          options = ::Docker.options.merge(@target.options['service-options'] || {})
+          @container = ::Docker::Container.get(@target.host, {}, ::Docker::Connection.new(url, options))
+          @logger.debug { "Opened session" }
+        rescue StandardError => e
+          raise Bolt::Node::ConnectError.new(
+            "Failed to connect to #{@target.uri}: #{e.message}",
+            'CONNECT_ERROR'
+          )
+        end
+
+        def execute(*command, options)
+          if options[:environment]
+            envs = options[:environment].map { |env, val| "#{env}=#{val}" }
+            command = ['env'] + envs + command
+          end
+
+          @logger.debug { "Executing: #{command}" }
+          result = @container.exec(command, options) { |stream, chunk| @logger.debug("#{stream}: #{chunk}") }
+          if result[2] == 0
+            @logger.debug { "Command returned successfully" }
+          else
+            @logger.info { "Command failed with exit code #{result[2]}" }
+          end
+          result
+        rescue StandardError
+          @logger.debug { "Command aborted" }
+          raise
+        end
+
+        def write_remote_file(source, destination)
+          @container.store_file(destination, File.binread(source))
+        rescue StandardError => e
+          raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
+        end
+
+        def write_remote_directory(source, destination)
+          tar = ::Docker::Util.create_dir_tar(source)
+          mkdirs([destination])
+          @container.archive_in_stream(destination) { tar.read(Excon.defaults[:chunk_size]).to_s }
+        rescue StandardError => e
+          raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
+        end
+
+        def mkdirs(dirs)
+          _, stderr, exitcode = execute('mkdir', '-p', *dirs, {})
+          if exitcode != 0
+            message = "Could not create directories: #{stderr.join}"
+            raise Bolt::Node::FileError.new(message, 'MKDIR_ERROR')
+          end
+        end
+
+        def make_tempdir
+          tmpdir = @target.options.fetch('tmpdir', '/tmp')
+          tmppath = "#{tmpdir}/#{SecureRandom.uuid}"
+
+          stdout, stderr, exitcode = execute('mkdir', '-m', '700', tmppath, {})
+          if exitcode != 0
+            raise Bolt::Node::FileError.new("Could not make tempdir: #{stderr.join}", 'TEMPDIR_ERROR')
+          end
+          tmppath || stdout.first
+        end
+
+        def with_remote_tempdir
+          dir = make_tempdir
+          yield dir
+        ensure
+          if dir
+            _, stderr, exitcode = execute('rm', '-rf', dir, {})
+            if exitcode != 0
+              @logger.warn("Failed to clean up tempdir '#{dir}': #{stderr.join}")
+            end
+          end
+        end
+
+        def write_remote_executable(dir, file, filename = nil)
+          filename ||= File.basename(file)
+          remote_path = File.join(dir.to_s, filename)
+          write_remote_file(file, remote_path)
+          make_executable(remote_path)
+          remote_path
+        end
+
+        def make_executable(path)
+          _, stderr, exitcode = execute('chmod', 'u+x', path, {})
+          if exitcode != 0
+            message = "Could not make file '#{path}' executable: #{stderr.join}"
+            raise Bolt::Node::FileError.new(message, 'CHMOD_ERROR')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/transport/local.rb

@@ -32,6 +32,8 @@ module Bolt
         Dir.mktmpdir(*args) do |dir|
           yield dir
         end
+      rescue StandardError => e
+        raise Bolt::Node::FileError.new("Could not make tempdir: #{e.message}", 'TEMPDIR_ERROR')
       end
       private :in_tmpdir
 
@@ -117,6 +119,10 @@ module Bolt
           Bolt::Result.for_task(target, output.stdout.string, output.stderr.string, output.exit_code)
         end
       end
+
+      def connected?(_targets)
+        true
+      end
     end
   end
 end

data/lib/bolt/transport/orch.rb

@@ -211,6 +211,11 @@ module Bolt
         end
       end
 
+      def batch_connected?(targets)
+        resp = get_connection(targets.first.options).query_inventory(targets)
+        resp['items'].all? { |node| node['connected'] }
+      end
+
       # run_task generates a result that makes sense for a generic task which
       # needs to be unwrapped to extract stdout/stderr/exitcode.
       #

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

@@ -52,7 +52,7 @@ module Bolt
           if @plan_job
             @client.command.plan_finish(
               plan_job: @plan_job,
-              result: plan_result.value,
+              result: plan_result.value || '',
               status: plan_result.status
             )
           end
@@ -75,6 +75,10 @@ module Bolt
           body = build_request(targets, task, arguments, options['_description'])
           @client.run_task(body)
         end
+
+        def query_inventory(targets)
+          @client.post('inventory', nodes: targets.map(&:host))
+        end
       end
     end
   end

data/lib/bolt/transport/ssh.rb

@@ -187,6 +187,12 @@ module Bolt
 EOF
 SCRIPT
       end
+
+      def connected?(target)
+        with_connection(target) { true }
+      rescue Bolt::Node::ConnectError
+        false
+      end
     end
   end
 end

data/lib/bolt/transport/winrm.rb

@@ -216,6 +216,12 @@ try { & "#{remote_task_path}" @taskArgs } catch { Write-Error $_.Exception; exit
           end
         end
       end
+
+      def connected?(target)
+        with_connection(target) { true }
+      rescue Bolt::Node::ConnectError
+        false
+      end
     end
   end
 end

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

data/lib/bolt_server/config.rb

@@ -9,6 +9,9 @@ module BoltServer
                    'ssl-cipher-suites', 'loglevel', 'logfile', 'whitelist', 'concurrency',
                    'cache-dir', 'file-server-conn-timeout', 'file-server-uri'].freeze
 
+    ENV_KEYS = ['ssl-cert', 'ssl-key', 'ssl-ca-cert', 'loglevel',
+                'concurrency', 'file-server-conn-timeout', 'file-server-uri'].freeze
+
     DEFAULTS = {
       'host' => '127.0.0.1',
       'port' => 62658,
@@ -40,7 +43,7 @@ module BoltServer
       @config_path = nil
     end
 
-    def load_config(path)
+    def load_file_config(path)
       @config_path = path
       begin
         parsed_hocon = Hocon.load(path)['bolt-server']
@@ -53,10 +56,20 @@ module BoltServer
       raise "Could not find bolt-server config at #{path}" if parsed_hocon.nil?
 
       parsed_hocon = parsed_hocon.select { |key, _| CONFIG_KEYS.include?(key) }
+
       @data = @data.merge(parsed_hocon)
+    end
 
-      validate
-      self
+    def load_env_config
+      ENV_KEYS.each do |key|
+        transformed_key = "BOLT_#{key.tr('-', '_').upcase}"
+        next unless ENV.key?(transformed_key)
+        @data[key] = if ['concurrency', 'file-server-conn-timeout'].include?(key)
+                       ENV[transformed_key].to_i
+                     else
+                       ENV[transformed_key]
+                     end
+      end
     end
 
     def natural?(num)

data/lib/bolt_server/transport_app.rb

@@ -2,6 +2,7 @@
 
 require 'sinatra'
 require 'bolt'
+require 'bolt/error'
 require 'bolt/target'
 require 'bolt/task/puppet_server'
 require 'bolt_server/file_cache'
@@ -30,6 +31,22 @@ module BoltServer
       super(nil)
     end
 
+    def scrub_stack_trace(result)
+      if result.dig(:result, '_error', 'details', 'stack_trace')
+        result[:result]['_error']['details'].reject! { |k| k == 'stack_trace' }
+      end
+      result
+    end
+
+    def validate_schema(schema, body)
+      schema_error = JSON::Validator.fully_validate(schema, body)
+      if schema_error.any?
+        Bolt::Error.new("There was an error validating the request body.",
+                        'boltserver/schema-error',
+                        schema_error)
+      end
+    end
+
     get '/' do
       200
     end
@@ -53,8 +70,8 @@ module BoltServer
       content_type :json
 
       body = JSON.parse(request.body.read)
-      schema_error = JSON::Validator.fully_validate(@schemas["ssh-run_task"], body)
-      return [400, schema_error.join] if schema_error.any?
+      error = validate_schema(@schemas["ssh-run_task"], body)
+      return [400, error.to_json] unless error.nil?
 
       opts = body['target']
       if opts['private-key-content']
@@ -70,15 +87,16 @@ module BoltServer
 
       # Since this will only be on one node we can just return the first result
       results = @executor.run_task(target, task, parameters)
-      [200, results.first.to_json]
+      result = scrub_stack_trace(results.first.status_hash)
+      [200, result.to_json]
     end
 
     post '/winrm/run_task' do
       content_type :json
 
       body = JSON.parse(request.body.read)
-      schema_error = JSON::Validator.fully_validate(@schemas["winrm-run_task"], body)
-      return [400, schema_error.join] if schema_error.any?
+      error = validate_schema(@schemas["winrm-run_task"], body)
+      return [400, error.to_json] unless error.nil?
 
       opts = body['target'].merge('protocol' => 'winrm')
 
@@ -90,16 +108,21 @@ module BoltServer
 
       # Since this will only be on one node we can just return the first result
       results = @executor.run_task(target, task, parameters)
-      [200, results.first.to_json]
+      result = scrub_stack_trace(results.first.status_hash)
+      [200, result.to_json]
     end
 
     error 404 do
-      [404, "Could not find route #{request.path}"]
+      err = Bolt::Error.new("Could not find route #{request.path}",
+                            'boltserver/not-found')
+      [404, err.to_json]
     end
 
     error 500 do
       e = env['sinatra.error']
-      [500, "500: Unknown error: #{e.message}"]
+      err = Bolt::Error.new("500: Unknown error: #{e.message}",
+                            'boltserver/server-error')
+      [500, err.to_json]
     end
   end
 end

data/lib/bolt_spec/plans.rb

@@ -91,6 +91,16 @@ require 'bolt/pal'
 #
 module BoltSpec
   module Plans
+    def self.init
+      # Ensure tasks are enabled when rspec-puppet sets up an environment so we get task loaders.
+      # Note that this is probably not safe to do in modules that also test Puppet manifest code.
+      Bolt::PAL.load_puppet
+      Puppet[:tasks] = true
+
+      # Ensure logger is initialized with Puppet levels so 'notice' works when running plan specs.
+      Logging.init :debug, :info, :notice, :warn, :error, :fatal, :any
+    end
+
     # Override in your tests if needed
     def modulepath
       [RSpec.configuration.module_path]

data/lib/bolt_spec/plans/mock_executor.rb

@@ -209,10 +209,18 @@ module BoltSpec
         @task_doubles[task_name] ||= TaskDouble.new
       end
 
+      def wait_until_available(targets, _options)
+        targets.map { |target| Bolt::Result.new(target) }
+      end
+
       def log_plan(_plan_name)
         yield
       end
 
+      def without_default_logging
+        yield
+      end
+
       def report_function_call(_function); end
 
       def report_bundled_content(_mode, _name); end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-30 00:00:00.000000000 Z
+date: 2018-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.34'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.34'
 - !ruby/object:Gem::Dependency
   name: logging
   requirement: !ruby/object:Gem::Requirement
@@ -283,6 +297,7 @@ files:
 - bolt-modules/boltlib/lib/puppet/functions/set_var.rb
 - bolt-modules/boltlib/lib/puppet/functions/upload_file.rb
 - bolt-modules/boltlib/lib/puppet/functions/vars.rb
+- bolt-modules/boltlib/lib/puppet/functions/wait_until_available.rb
 - bolt-modules/boltlib/lib/puppet/functions/without_default_logging.rb
 - bolt-modules/boltlib/types/planresult.pp
 - bolt-modules/boltlib/types/targetspec.pp
@@ -323,6 +338,8 @@ files:
 - lib/bolt/task.rb
 - lib/bolt/task/puppet_server.rb
 - lib/bolt/transport/base.rb
+- lib/bolt/transport/docker.rb
+- lib/bolt/transport/docker/connection.rb
 - lib/bolt/transport/local.rb
 - lib/bolt/transport/local/shell.rb
 - lib/bolt/transport/orch.rb