bolt 2.16.0 → 2.21.0

data/lib/bolt/shell/powershell/snippets.rb

@@ -85,12 +85,21 @@ module Bolt
 
           def shell_init
             <<~PS
-            $ENV:PATH += ";${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\bin\\;" +
-            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\puppet\\bin;" +
-            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\sys\\ruby\\bin\\"
-            $ENV:RUBYLIB = "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\puppet\\lib;" +
-            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\facter\\lib;" +
-            "${ENV:ProgramFiles}\\Puppet Labs\\Puppet\\hiera\\lib;" +
+            $installRegKey = Get-ItemProperty -Path "HKLM:\\Software\\Puppet Labs\\Puppet" -ErrorAction 0
+            if(![string]::IsNullOrEmpty($installRegKey.RememberedInstallDir64)){
+              $boltBaseDir = $installRegKey.RememberedInstallDir64
+            }elseif(![string]::IsNullOrEmpty($installRegKey.RememberedInstallDir)){
+              $boltBaseDir = $installRegKey.RememberedInstallDir
+            }else{
+              $boltBaseDir = "${ENV:ProgramFiles}\\Puppet Labs\\Puppet"
+            }
+
+            $ENV:PATH += ";${boltBaseDir}\\bin\\;" +
+            "${boltBaseDir}\\puppet\\bin;" +
+            "${boltBaseDir}\\sys\\ruby\\bin\\"
+            $ENV:RUBYLIB = "${boltBaseDir}\\puppet\\lib;" +
+            "${boltBaseDir}\\facter\\lib;" +
+            "${boltBaseDir}\\hiera\\lib;" +
             $ENV:RUBYLIB
 
             Add-Type -AssemblyName System.ServiceModel.Web, System.Runtime.Serialization

data/lib/bolt/transport/base.rb

@@ -167,6 +167,25 @@ module Bolt
         end
       end
 
+      # Downloads the given source file from a batch of targets to the destination location
+      # on the host.
+      #
+      # The default implementation only supports batches of size 1 and will fail otherwise.
+      #
+      # Transports may override this method to implement their own batch processing.
+      def batch_download(targets, source, destination, options = {}, &callback)
+        require 'erb'
+
+        assert_batch_size_one("batch_download()", targets)
+        target = targets.first
+        with_events(target, callback, 'download') do
+          escaped_name = ERB::Util.url_encode(target.safe_name)
+          target_destination = File.expand_path(escaped_name, destination)
+          @logger.debug { "Downloading: '#{source}' on #{target.safe_name} to #{target_destination}" }
+          download(target, source, target_destination, options)
+        end
+      end
+
       def batch_connected?(targets)
         assert_batch_size_one("connected?()", targets)
         connected?(targets.first)
@@ -201,6 +220,11 @@ module Bolt
         raise NotImplementedError, "upload() must be implemented by the transport class"
       end
 
+      # Transports should override this method with their own implementation of file download.
+      def download(*_args)
+        raise NotImplementedError, "download() 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"

data/lib/bolt/transport/docker.rb

@@ -38,8 +38,18 @@ module Bolt
         end
       end
 
+      def download(target, source, destination, _options = {})
+        with_connection(target) do |conn|
+          download = File.join(destination, Bolt::Util.unix_basename(source))
+          conn.download_remote_content(source, destination)
+          Bolt::Result.for_download(target, source, destination, download)
+        end
+      end
+
       def run_command(target, command, options = {})
-        options[:tty] = target.options['tty']
+        execute_options = {}
+        execute_options[:tty] = target.options['tty']
+        execute_options[:environment] = options[:env_vars]
 
         if target.options['shell-command'] && !target.options['shell-command'].empty?
           # escape any double quotes in command
@@ -47,19 +57,21 @@ module Bolt
           command = "#{target.options['shell-command']} \" #{command}\""
         end
         with_connection(target) do |conn|
-          stdout, stderr, exitcode = conn.execute(*Shellwords.split(command), options)
+          stdout, stderr, exitcode = conn.execute(*Shellwords.split(command), execute_options)
           Bolt::Result.for_command(target, stdout, stderr, exitcode, 'command', command)
         end
       end
 
-      def run_script(target, script, arguments, _options = {})
+      def run_script(target, script, arguments, options = {})
         # unpack any Sensitive data
         arguments = unwrap_sensitive_args(arguments)
+        execute_options = {}
+        execute_options[:environment] = options[:env_vars]
 
         with_connection(target) do |conn|
           conn.with_remote_tmpdir do |dir|
             remote_path = conn.write_remote_executable(dir, script)
-            stdout, stderr, exitcode = conn.execute(remote_path, *arguments, {})
+            stdout, stderr, exitcode = conn.execute(remote_path, *arguments, execute_options)
             Bolt::Result.for_command(target, stdout, stderr, exitcode, 'script', script)
           end
         end

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

@@ -82,7 +82,9 @@ module Bolt
         def write_remote_file(source, destination)
           @logger.debug { "Uploading #{source}, to #{destination}" }
           _, stdout_str, status = execute_local_docker_command('cp', [source, "#{container_id}:#{destination}"])
-          raise "Error writing file to container #{@container_id}: #{stdout_str}" unless status.exitstatus.zero?
+          unless status.exitstatus.zero?
+            raise "Error writing file to container #{@container_id}: #{stdout_str}"
+          end
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
@@ -90,7 +92,23 @@ module Bolt
         def write_remote_directory(source, destination)
           @logger.debug { "Uploading #{source}, to #{destination}" }
           _, stdout_str, status = execute_local_docker_command('cp', [source, "#{container_id}:#{destination}"])
-          raise "Error writing directory to container #{@container_id}: #{stdout_str}" unless status.exitstatus.zero?
+          unless status.exitstatus.zero?
+            raise "Error writing directory to container #{@container_id}: #{stdout_str}"
+          end
+        rescue StandardError => e
+          raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
+        end
+
+        def download_remote_content(source, destination)
+          @logger.debug { "Downloading #{source} to #{destination}" }
+          # Create the destination directory, otherwise copying a source directory with Docker will
+          # copy the *contents* of the directory.
+          # https://docs.docker.com/engine/reference/commandline/cp/
+          FileUtils.mkdir_p(destination)
+          _, stdout_str, status = execute_local_docker_command('cp', ["#{container_id}:#{source}", destination])
+          unless status.exitstatus.zero?
+            raise "Error downloading content from container #{@container_id}: #{stdout_str}"
+          end
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end

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

@@ -27,7 +27,7 @@ module Bolt
                      end
         end
 
-        def copy_file(source, dest)
+        def upload_file(source, dest)
           @logger.debug { "Uploading #{source}, to #{dest}" }
           if source.is_a?(StringIO)
             Tempfile.create(File.basename(dest)) do |f|
@@ -45,6 +45,19 @@ module Bolt
           raise Bolt::Node::FileError.new(message, 'COPY_ERROR')
         end
 
+        def download_file(source, dest, _download)
+          @logger.debug { "Downloading #{source} to #{dest}" }
+          # Create the destination directory for the target, or the
+          # copied file will have the target's name
+          FileUtils.mkdir_p(dest)
+          # Mimic the behavior of `cp --remove-destination`
+          # since the flag isn't supported on MacOS
+          FileUtils.cp_r(source, dest, remove_destination: true)
+        rescue StandardError => e
+          message = "Could not download file to #{dest}: #{e}"
+          raise Bolt::Node::FileError.new(message, 'DOWNLOAD_ERROR')
+        end
+
         def execute(command)
           if Bolt::Util.windows?
             # If it's already a powershell command then invoke it normally.

data/lib/bolt/transport/orch.rb

@@ -82,6 +82,10 @@ module Bolt
       end
 
       def batch_command(targets, command, options = {}, &callback)
+        if options[:env_vars] && !options[:env_vars].empty?
+          raise NotImplementedError, "pcp transport does not support setting environment variables"
+        end
+
         params = {
           'command' => command
         }
@@ -98,6 +102,10 @@ module Bolt
       end
 
       def batch_script(targets, script, arguments, options = {}, &callback)
+        if options[:env_vars] && !options[:env_vars].empty?
+          raise NotImplementedError, "pcp transport does not support setting environment variables"
+        end
+
         content = File.open(script, &:read)
         content = Base64.encode64(content)
         params = {
@@ -176,6 +184,18 @@ module Bolt
         end
       end
 
+      def batch_download(targets, *_args)
+        error = {
+          'kind'    => 'bolt/not-supported-error',
+          'msg'     => 'pcp transport does not support downloading files',
+          'details' => {}
+        }
+
+        targets.map do |target|
+          Bolt::Result.new(target, error: error, action: 'download')
+        end
+      end
+
       def batches(targets)
         targets.group_by { |target| Connection.get_key(target.options) }.values
       end

data/lib/bolt/transport/simple.rb

@@ -32,6 +32,12 @@ module Bolt
         end
       end
 
+      def download(target, source, destination, options = {})
+        with_connection(target) do |conn|
+          conn.shell.download(source, destination, options)
+        end
+      end
+
       def run_script(target, script, arguments, options = {})
         with_connection(target) do |conn|
           conn.shell.run_script(script, arguments, options)

data/lib/bolt/transport/ssh.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'bolt/logger'
 require 'bolt/node/errors'
 require 'bolt/transport/simple'
 
@@ -21,7 +22,12 @@ module Bolt
       end
 
       def with_connection(target)
-        conn = if target.transport_config['ssh-command']
+        if target.transport_config['ssh-command'] && !target.transport_config['native-ssh']
+          Bolt::Logger.warn_once("ssh-command and native-ssh conflict",
+                                 "native-ssh must be true to use ssh-command")
+        end
+
+        conn = if target.transport_config['native-ssh']
                  ExecConnection.new(target)
                else
                  Connection.new(target, @transport_logger)

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

@@ -235,7 +235,7 @@ module Bolt
           raise Bolt::Error.new(msg, 'bolt/too-many-files')
         end
 
-        def copy_file(source, destination)
+        def upload_file(source, destination)
           # Do not log wrapper script content
           @logger.debug { "Uploading #{source}, to #{destination}" } unless source.is_a?(StringIO)
           @session.scp.upload!(source, destination, recursive: true)
@@ -243,6 +243,14 @@ module Bolt
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
 
+        def download_file(source, destination, _download)
+          # Do not log wrapper script content
+          @logger.debug { "Downloading #{source} to #{destination}" }
+          @session.scp.download!(source, destination, recursive: true)
+        rescue StandardError => e
+          raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
+        end
+
         # This handles renaming Net::SSH verifiers between version 4.x and 5.x
         # of the gem
         def net_ssh_verifier(verifier)

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

@@ -58,14 +58,14 @@ module Bolt
         end
 
         def build_ssh_command(command)
-          ssh_conf = @target.transport_config['ssh-command']
+          ssh_conf = @target.transport_config['ssh-command'] || 'ssh'
           ssh_cmd = Array(ssh_conf)
           ssh_cmd += ssh_opts
           ssh_cmd << userhost
           ssh_cmd << command
         end
 
-        def copy_file(source, dest)
+        def upload_file(source, dest)
           @logger.debug { "Uploading #{source}, to #{userhost}:#{dest}" } unless source.is_a?(StringIO)
 
           cp_conf = @target.transport_config['copy-command'] || ["scp", "-r"]
@@ -94,6 +94,27 @@ module Bolt
           end
         end
 
+        def download_file(source, dest, _download)
+          @logger.debug { "Downloading #{userhost}:#{source} to #{dest}" }
+
+          FileUtils.mkdir_p(dest)
+
+          cp_conf = @target.transport_config['copy-command'] || ["scp", "-r"]
+          cp_cmd = Array(cp_conf)
+          cp_cmd += ssh_opts
+          cp_cmd << "#{userhost}:#{Shellwords.escape(source)}"
+          cp_cmd << dest
+
+          _, err, stat = Open3.capture3(*cp_cmd)
+
+          if stat.success?
+            @logger.debug "Successfully downloaded #{userhost}:#{source} to #{dest}"
+          else
+            message = "Could not copy file to #{dest}: #{err}"
+            raise Bolt::Node::FileError.new(message, 'COPY_ERROR')
+          end
+        end
+
         def execute(command)
           cmd_array = build_ssh_command(command)
           Open3.popen3(*cmd_array)

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

@@ -111,12 +111,21 @@ module Bolt
           out_rd, out_wr = IO.pipe('UTF-8')
           err_rd, err_wr = IO.pipe('UTF-8')
           th = Thread.new do
+            # By default, any exception raised in a thread will be reported to
+            # stderr as a stacktrace. Since we know these errors are going to
+            # propagate to the main thread via the shell, there's no chance
+            # they will be unhandled, so the default stack trace is unneeded.
+            Thread.current.report_on_exception = false
             result = @session.run(command)
             out_wr << result.stdout
             err_wr << result.stderr
             out_wr.close
             err_wr.close
             result.exitcode
+          ensure
+            # Close the streams to avoid the caller deadlocking
+            out_wr.close
+            err_wr.close
           end
 
           [inp, out_rd, err_rd, th]
@@ -129,23 +138,23 @@ module Bolt
           raise
         end
 
-        def copy_file(source, destination)
+        def upload_file(source, destination)
           @logger.debug { "Uploading #{source}, to #{destination}" }
           if target.options['file-protocol'] == 'smb'
-            copy_file_smb(source, destination)
+            upload_file_smb(source, destination)
           else
-            copy_file_winrm(source, destination)
+            upload_file_winrm(source, destination)
           end
         end
 
-        def copy_file_winrm(source, destination)
+        def upload_file_winrm(source, destination)
           fs = ::WinRM::FS::FileManager.new(@connection)
           fs.upload(source, destination)
         rescue StandardError => e
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
 
-        def copy_file_smb(source, destination)
+        def upload_file_smb(source, destination)
           # lazy-load expensive gem code
           require 'ruby_smb'
 
@@ -165,7 +174,7 @@ module Bolt
           client = smb_client_login
           tree = client.tree_connect(path)
           begin
-            copy_file_smb_recursive(tree, source, dest)
+            upload_file_smb_recursive(tree, source, dest)
           ensure
             tree.disconnect!
           end
@@ -175,6 +184,61 @@ module Bolt
           raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
         end
 
+        def download_file(source, destination, download)
+          @logger.debug { "Downloading #{source} to #{destination}" }
+          if target.options['file-protocol'] == 'smb'
+            download_file_smb(source, destination)
+          else
+            download_file_winrm(source, destination, download)
+          end
+        end
+
+        def download_file_winrm(source, destination, download)
+          # The winrm gem doesn't create the destination directory if it's missing,
+          # so create it here
+          FileUtils.mkdir_p(destination)
+          fs = ::WinRM::FS::FileManager.new(@connection)
+          # params: source, destination, chunksize, first
+          # first needs to be set to false, otherwise if the source is a directory it
+          # will be nested inside a directory with the same name
+          fs.download(source, download, 1024 * 1024, false)
+        rescue StandardError => e
+          raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
+        end
+
+        def download_file_smb(source, destination)
+          # lazy-load expensive gem code
+          require 'ruby_smb'
+
+          win_source = source.tr('/', '\\')
+          if (md = win_source.match(/^([a-z]):\\(.*)/i))
+            # if drive, use admin share for that drive, so path is '\\host\C$'
+            path = "\\\\#{@target.host}\\#{md[1]}$"
+            src  = md[2]
+          elsif (md = win_source.match(/^(\\\\[^\\]+\\[^\\]+)\\(.*)/))
+            # if unc, path is '\\host\share'
+            path = md[1]
+            src  = md[2]
+          else
+            raise ArgumentError, "Unknown source '#{source}'"
+          end
+
+          client = smb_client_login
+          tree = client.tree_connect(path)
+
+          begin
+            # Make sure the root download directory for the target exists
+            FileUtils.mkdir_p(destination)
+            download_file_smb_recursive(tree, src, destination)
+          ensure
+            tree.disconnect!
+          end
+        rescue ::RubySMB::Error::UnexpectedStatusCode => e
+          raise Bolt::Node::FileError.new("SMB Error: #{e.message}", 'DOWNLOAD_ERROR')
+        rescue StandardError => e
+          raise Bolt::Node::FileError.new(e.message, 'DOWNLOAD_ERROR')
+        end
+
         def shell
           @shell ||= Bolt::Shell::Powershell.new(target, self)
         end
@@ -230,13 +294,13 @@ module Bolt
           )
         end
 
-        def copy_file_smb_recursive(tree, source, dest)
+        def upload_file_smb_recursive(tree, source, dest)
           if Dir.exist?(source)
             tree.open_directory(directory: dest, write: true, disposition: ::RubySMB::Dispositions::FILE_OPEN_IF)
 
             Dir.children(source).each do |child|
               child_dest = dest + '\\' + child
-              copy_file_smb_recursive(tree, File.join(source, child), child_dest)
+              upload_file_smb_recursive(tree, File.join(source, child), child_dest)
             end
             return
           end
@@ -255,6 +319,52 @@ module Bolt
             file.close
           end
         end
+
+        def download_file_smb_recursive(tree, source, destination)
+          dest = File.expand_path(Bolt::Util.windows_basename(source), destination)
+
+          # Check if the source is a directory by attempting to list its children.
+          # If the source is a directory, create the directory on the host and then
+          # recurse through the children.
+          if (children = list_directory_children_smb(tree, source))
+            FileUtils.mkdir_p(dest)
+
+            children.each do |child|
+              # File names are encoded UTF_16LE.
+              filename = child.file_name.encode(Encoding::UTF_8)
+
+              next if %w[. ..].include?(filename)
+
+              src = source + '\\' + filename
+              download_file_smb_recursive(tree, src, dest)
+            end
+          # If the source wasn't a directory and just returns 'STATUS_NOT_A_DIRECTORY, then
+          # it is a file. Write it to the host.
+          else
+            begin
+              file = tree.open_file(filename: source)
+              data = file.read
+
+              # Files may be encoded UTF_16LE
+              data = data.encode(Encoding::UTF_8) if data.encoding == Encoding::UTF_16LE
+
+              File.write(dest, data)
+            ensure
+              file.close
+            end
+          end
+        end
+
+        # Lists the children of a directory using rb_smb
+        # Returns an array of RubySMB::Fscc::FileInformation::FileIdFullDirectoryInformation objects
+        # if the source is a directory, or raises RubySMB::Error::UnexpectedStatusCode otherwise.
+        def list_directory_children_smb(tree, source)
+          tree.list(directory: source)
+        rescue RubySMB::Error::UnexpectedStatusCode => e
+          unless e.message == 'STATUS_NOT_A_DIRECTORY'
+            raise e
+          end
+        end
       end
     end
   end