packaging 0.99.76 → 0.99.77

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d737ac46704906a2bc986128797b3db649dd3e35e1432f2a98f362da67ffa56
-  data.tar.gz: 7a1ae857ec7a92940499a60c9d649f5e5e40fd8f2340aa95d2751f0de29d9fbd
+  metadata.gz: 365629e0e3cba195de934ccd1cee9ecff5c7ed684ac79e4befc883420037b191
+  data.tar.gz: 2498029caf73135b3ee7c5a2704e310ae6398c4eb7716c3687db487fc827dc0d
 SHA512:
-  metadata.gz: cacbbdc7c63c443a6a6bb6c0bc7f77367343b22b8356c4d99c00fe67a1fd448af0c7e0647d616ec533d1cb1cdfb6412fbff953bfb6926dbb4a06911d08da20df
-  data.tar.gz: 39ada32cc8dde4df7d661d00807ba937667338278191391ec534c98423228c594a49e2c74bedd10e9c8bd18601dae6bdff54804d48f2e255bc995b198bef4c13
+  metadata.gz: 4a73420699b6ce732c52c527468c5b9cef405c0565aab9b33c3e592109ddee4aa965f162b4d3950a7900584994dba2994cc07602d75e36b0a53bf8dbbfcd23ec
+  data.tar.gz: f871e9711752e70ac48956663402fa3f0cdf2693ae08eff8aa0ac59384a0081e1dd27fdbac01a3a17964de4a135a9ded98d381808cace9d9dd62c6ac37d20a8d

data/lib/packaging/archive.rb

@@ -33,7 +33,7 @@ module Pkg::Archive
       sudo chmod g+w -R #{Pkg::Config.yum_archive_path}
       mv #{full_directory} #{archive_path}
     CMD
-    Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+    Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
   end
 
   # Move directories from freight path (aka repo staging path) to archive staging paths
@@ -60,7 +60,7 @@ module Pkg::Archive
         mv $pool_directory /opt/tmp-apt
       done
     CMD
-    Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+    Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
   end
 
   # Move downloads directories to archive staging path
@@ -85,7 +85,7 @@ module Pkg::Archive
       sudo chmod g+w -R #{Pkg::Config.downloads_archive_path}
       mv #{full_directory} #{archive_path}
     CMD
-    Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+    Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
   end
 
   # Delete empty directories from repo paths on weth
@@ -104,7 +104,7 @@ module Pkg::Archive
           fi
         done
       CMD
-      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+      Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
     end
   end
 
@@ -112,7 +112,7 @@ module Pkg::Archive
   def remove_dead_symlinks
     base_paths.each do |path|
       command = "find #{path} -xtype l -delete"
-      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+      Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
     end
   end
 
@@ -120,7 +120,7 @@ module Pkg::Archive
   def delete_staged_archives
     archive_paths.each do |archive_path|
       command = "sudo rm -rf #{File.join(archive_path, '*')}"
-      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+      Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
     end
   end
 end

data/lib/packaging/config.rb

@@ -81,7 +81,11 @@ module Pkg
         dir = "/opt/jenkins-builds/#{self.project}/#{self.ref}"
         cmd = "if [ -s \"#{dir}/artifacts\" ]; then cd #{dir};"\
               "find ./artifacts/ -mindepth 2 -type f; fi"
-        artifacts, _ = Pkg::Util::Net.remote_ssh_cmd(self.builds_server, cmd, true)
+        artifacts, _ = Pkg::Util::Net.remote_execute(
+                     self.builds_server,
+                     cmd,
+                     { capture_output: true }
+                   )
 
         artifacts = artifacts.split("\n")
         data = {}

data/lib/packaging/deb/repo.rb

@@ -125,7 +125,7 @@ Description: Apt repository for acceptance testing" >> conf/distributions ; )
       command = repo_creation_command(File.join(artifact_directory, 'repos'), artifact_paths)
 
       begin
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, command)
         # Now that we've created our package repositories, we can generate repo
         # configurations for use with downstream jobs, acceptance clients, etc.
         Pkg::Deb::Repo.generate_repo_configs
@@ -134,7 +134,7 @@ Description: Apt repository for acceptance testing" >> conf/distributions ; )
         Pkg::Deb::Repo.ship_repo_configs
       ensure
         # Always remove the lock file, even if we've failed
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock")
+        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock")
       end
     end
 
@@ -146,7 +146,7 @@ Description: Apt repository for acceptance testing" >> conf/distributions ; )
 
       Pkg::Util::RakeUtils.invoke_task("pl:fetch")
       repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{target}/deb"
-      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
+      Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
       Pkg::Util::Execution.retry_on_fail(:times => 3) do
         Pkg::Util::Net.rsync_to("pkg/#{target}/deb/", Pkg::Config.distribution_server, repo_dir)
       end
@@ -252,11 +252,11 @@ SignWith: #{Pkg::Config.gpg_key}"
       rsync_command = repo_deployment_command(apt_path, destination_staging_path, destination_server, dryrun)
       cp_command = repo_deployment_command(destination_staging_path, apt_path, nil, dryrun)
 
-      Pkg::Util::Net.remote_ssh_cmd(origin_server, rsync_command)
+      Pkg::Util::Net.remote_execute(origin_server, rsync_command)
       if dryrun
         puts "[DRYRUN] not executing #{cp_command} on #{destination_server}"
       else
-        Pkg::Util::Net.remote_ssh_cmd(destination_server, cp_command)
+        Pkg::Util::Net.remote_execute(destination_server, cp_command)
       end
     end
 

data/lib/packaging/platforms.rb

@@ -12,13 +12,6 @@ module Pkg
     # Each element in this hash
     PLATFORM_INFO = {
       'aix' => {
-        '6.1' => {
-          architectures: ['power'],
-          source_architecture: 'SRPMS',
-          package_format: 'rpm',
-          source_package_formats: ['src.rpm'],
-          repo: false,
-        },
         '7.1' => {
           architectures: ['power'],
           source_architecture: 'SRPMS',
@@ -28,25 +21,6 @@ module Pkg
         },
       },
 
-      'cisco-wrlinux' => {
-        '5' => {
-          architectures: ['x86_64'],
-          source_architecture: 'SRPMS',
-          package_format: 'rpm',
-          source_package_formats: ['src.rpm'],
-          signature_format: 'v4',
-          repo: true,
-        },
-        '7' => {
-          architectures: ['x86_64'],
-          source_architecture: 'SRPMS',
-          package_format: 'rpm',
-          source_package_formats: ['src.rpm'],
-          signature_format: 'v4',
-          repo: true,
-        },
-      },
-
       'debian' => {
         '8' => {
           codename: 'jessie',
@@ -109,14 +83,6 @@ module Pkg
         }
       },
 
-      'eos' => {
-        '4' => {
-          architectures: ['i386'],
-          package_format: 'swix',
-          repo: false,
-        },
-      },
-
       'fedora' => {
         '30' => {
           architectures: ['x86_64'],
@@ -142,6 +108,14 @@ module Pkg
           signature_format: 'v4',
           repo: true,
         },
+        '34' => {
+          architectures: ['x86_64'],
+          source_architecture: 'SRPMS',
+          package_format: 'rpm',
+          source_package_formats: ['src.rpm'],
+          signature_format: 'v4',
+          repo: true,
+        },
       },
 
       'osx' => {
@@ -160,6 +134,11 @@ module Pkg
           package_format: 'dmg',
           repo: false,
         },
+        '11' => {
+          architectures: ['x86_64'],
+          package_format: 'dmg',
+          repo: false,
+        },
       },
 
       'redhatfips' => {

data/lib/packaging/repo.rb

@@ -110,7 +110,11 @@ module Pkg::Repo
       cmd = "[ -d #{artifact_directory} ] || exit 1 ; "
       cmd << "pushd #{artifact_directory} > /dev/null && "
       cmd << "find . -name '*.#{pkg_ext}' -print0 | xargs --no-run-if-empty -0 -I {} dirname {} "
-      stdout, stderr = Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, cmd, true)
+      stdout, _ = Pkg::Util::Net.remote_execute(
+                Pkg::Config.distribution_server,
+                cmd,
+                { capture_output: true }
+              )
       return stdout.split
     rescue => e
       fail "Error: Could not retrieve directories that contain #{pkg_ext} packages in #{Pkg::Config.distribution_server}:#{artifact_directory}"
@@ -120,7 +124,7 @@ module Pkg::Repo
       cmd = "[ -d #{artifact_parent_directory}/artifacts ] || exit 1 ; "
       cmd << "pushd #{artifact_parent_directory} > /dev/null && "
       cmd << 'rsync --archive --verbose --one-file-system --ignore-existing artifacts/ repos/ '
-      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, cmd)
+      Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, cmd)
     rescue => e
       fail "Error: Could not populate repos directory in #{Pkg::Config.distribution_server}:#{artifact_parent_directory}"
     end
@@ -143,7 +147,9 @@ module Pkg::Repo
         __APT_PLATFORMS__: Pkg::Config.apt_releases.join(' '),
         __GPG_KEY__: Pkg::Util::Gpg.key
       }
-      Pkg::Util::Net.remote_ssh_cmd(remote_host, Pkg::Util::Misc.search_and_replace(command, whitelist))
+      Pkg::Util::Net.remote_execute(
+        remote_host,
+        Pkg::Util::Misc.search_and_replace(command, whitelist))
     end
   end
 end

data/lib/packaging/rpm/repo.rb

@@ -16,7 +16,7 @@ module Pkg::Rpm::Repo
 
       Pkg::Util::RakeUtils.invoke_task("pl:fetch")
       repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{target}/rpm"
-      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
+      Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
       Pkg::Util::Execution.retry_on_fail(:times => 3) do
         Pkg::Util::Net.rsync_to("pkg/#{target}/rpm/", Pkg::Config.distribution_server, repo_dir)
       end
@@ -215,7 +215,7 @@ module Pkg::Rpm::Repo
       command = Pkg::Rpm::Repo.repo_creation_command(File.join(artifact_directory, directory), artifact_paths)
 
       begin
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, command)
         # Now that we've created our package repositories, we can generate repo
         # configurations for use with downstream jobs, acceptance clients, etc.
         Pkg::Rpm::Repo.generate_repo_configs
@@ -224,7 +224,7 @@ module Pkg::Rpm::Repo
         Pkg::Rpm::Repo.ship_repo_configs
       ensure
         # Always remove the lock file, even if we've failed
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock")
+        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock")
       end
     end
 
@@ -248,7 +248,7 @@ module Pkg::Rpm::Repo
     def deploy_repos(yum_path, origin_server, destination_server, dryrun = false)
       rsync_command = repo_deployment_command(yum_path, yum_path, destination_server, dryrun)
 
-      Pkg::Util::Net.remote_ssh_cmd(origin_server, rsync_command)
+      Pkg::Util::Net.remote_execute(origin_server, rsync_command)
     end
   end
 end

data/lib/packaging/sign/dmg.rb

@@ -15,10 +15,10 @@ module Pkg::Sign::Dmg
     work_dir  = "/tmp/#{Pkg::Util.rand_string}"
     mount     = File.join(work_dir, "mount")
     signed    = File.join(work_dir, "signed")
-    Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "mkdir -p #{mount} #{signed}")
+    Pkg::Util::Net.remote_execute(ssh_host_string, "mkdir -p #{mount} #{signed}")
     dmgs = Dir.glob("#{target_dir}/apple/**/*.dmg")
     Pkg::Util::Net.rsync_to(dmgs.join(" "), rsync_host_string, work_dir)
-    Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, %Q[for dmg in #{dmgs.map { |d| File.basename(d, ".dmg") }.join(" ")}; do
+    Pkg::Util::Net.remote_execute(ssh_host_string, %Q[for dmg in #{dmgs.map { |d| File.basename(d, ".dmg") }.join(" ")}; do
       /usr/bin/hdiutil attach #{work_dir}/$dmg.dmg -mountpoint #{mount} -nobrowse -quiet ;
       /usr/bin/security -q unlock-keychain -p "#{Pkg::Config.osx_signing_keychain_pw}" "#{Pkg::Config.osx_signing_keychain}" ;
         for pkg in $(ls #{mount}/*.pkg | xargs -n 1 basename); do
@@ -36,6 +36,6 @@ module Pkg::Sign::Dmg
     dmgs.each do | dmg |
       Pkg::Util::Net.rsync_from("#{work_dir}/#{File.basename(dmg)}", rsync_host_string, File.dirname(dmg))
     end
-    Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "if [ -d '#{work_dir}' ]; then rm -rf '#{work_dir}'; fi")
+    Pkg::Util::Net.remote_execute(ssh_host_string, "if [ -d '#{work_dir}' ]; then rm -rf '#{work_dir}'; fi")
   end
 end

data/lib/packaging/sign/ips.rb

@@ -15,14 +15,14 @@ module Pkg::Sign::Ips
       repo_dir     = "#{work_dir}/repo"
       signed_dir   = "#{work_dir}/pkgs"
 
-      Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "mkdir -p #{repo_dir} #{unsigned_dir} #{signed_dir}")
+      Pkg::Util::Net.remote_execute(ssh_host_string, "mkdir -p #{repo_dir} #{unsigned_dir} #{signed_dir}")
       Pkg::Util::Net.rsync_to(p5p, rsync_host_string, unsigned_dir)
 
       # Before we can get started with signing packages we need to create a repo
-      Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "sudo -E /usr/bin/pkgrepo create #{repo_dir}")
-      Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "sudo -E /usr/bin/pkgrepo set -s #{repo_dir} publisher/prefix=puppetlabs.com")
+      Pkg::Util::Net.remote_execute(ssh_host_string, "sudo -E /usr/bin/pkgrepo create #{repo_dir}")
+      Pkg::Util::Net.remote_execute(ssh_host_string, "sudo -E /usr/bin/pkgrepo set -s #{repo_dir} publisher/prefix=puppetlabs.com")
       # And import all the packages into the repo.
-      Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "sudo -E /usr/bin/pkgrecv -s #{unsigned_dir}/#{File.basename(p5p)} -d #{repo_dir} '*'")
+      Pkg::Util::Net.remote_execute(ssh_host_string, "sudo -E /usr/bin/pkgrecv -s #{unsigned_dir}/#{File.basename(p5p)} -d #{repo_dir} '*'")
       # We are going to hard code the values for signing cert locations for now.
       # This autmation will require an update to actually become reusable, but
       # for now these values will stay this way so solaris signing will stop
@@ -37,21 +37,21 @@ module Pkg::Sign::Ips
                   -k /root/signing/signing_key_2020.pem \
                   -s 'file://#{work_dir}/repo' '*'"
       puts "About to sign #{p5p} with #{sign_cmd} in #{work_dir}"
-      Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, sign_cmd.squeeze(' '))
+      Pkg::Util::Net.remote_execute(ssh_host_string, sign_cmd.squeeze(' '))
       # pkgrecv with -a will pull packages out of the repo, so we need to do that too to actually get the packages we signed
-      Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "sudo -E /usr/bin/pkgrecv -d #{signed_dir}/#{File.basename(p5p)} -a -s #{repo_dir} '*'")
+      Pkg::Util::Net.remote_execute(ssh_host_string, "sudo -E /usr/bin/pkgrecv -d #{signed_dir}/#{File.basename(p5p)} -a -s #{repo_dir} '*'")
       begin
         # lets make sure we actually signed something?
         # **NOTE** if we're repeatedly trying to sign the same version this
         # might explode because I don't know how to reset the IPS cache.
         # Everything is amazing.
-        Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "sudo -E /usr/bin/pkg contents -m -g #{signed_dir}/#{File.basename(p5p)} '*' | grep '^signature '")
+        Pkg::Util::Net.remote_execute(ssh_host_string, "sudo -E /usr/bin/pkg contents -m -g #{signed_dir}/#{File.basename(p5p)} '*' | grep '^signature '")
       rescue RuntimeError
         raise "Looks like #{File.basename(p5p)} was not signed correctly, quitting!"
       end
       # and pull the packages back.
       Pkg::Util::Net.rsync_from("#{signed_dir}/#{File.basename(p5p)}", rsync_host_string, File.dirname(p5p))
-      Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "if [ -e '#{work_dir}' ] ; then sudo rm -r '#{work_dir}' ; fi")
+      Pkg::Util::Net.remote_execute(ssh_host_string, "if [ -e '#{work_dir}' ] ; then sudo rm -r '#{work_dir}' ; fi")
     end
   end
 end

data/lib/packaging/sign/msi.rb

@@ -8,7 +8,7 @@ module Pkg::Sign::Msi
     rsync_host_string = "-e 'ssh #{use_identity}' Administrator@#{Pkg::Config.msi_signing_server}"
 
     work_dir = "Windows/Temp/#{Pkg::Util.rand_string}"
-    Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "mkdir -p C:/#{work_dir}")
+    Pkg::Util::Net.remote_execute(ssh_host_string, "mkdir -p C:/#{work_dir}")
     msis = Dir.glob("#{target_dir}/windows*/**/*.msi")
     Pkg::Util::Net.rsync_to(msis.join(" "), rsync_host_string, "/cygdrive/c/#{work_dir}",
                            extra_flags: ["--ignore-existing --relative"])
@@ -111,10 +111,14 @@ for msipath in #{msis.join(" ")}; do
 done
 CMD
 
-    Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, sign_command, false, '', false)
+    Pkg::Util::Net.remote_execute(
+      ssh_host_string,
+      sign_command,
+      { fail_fast: false }
+    )
     msis.each do | msi |
       Pkg::Util::Net.rsync_from("/cygdrive/c/#{work_dir}/#{msi}", rsync_host_string, File.dirname(msi))
     end
-    Pkg::Util::Net.remote_ssh_cmd(ssh_host_string, "if [ -d '/cygdrive/c/#{work_dir}' ]; then rm -rf '/cygdrive/c/#{work_dir}'; fi")
+    Pkg::Util::Net.remote_execute(ssh_host_string, "if [ -d '/cygdrive/c/#{work_dir}' ]; then rm -rf '/cygdrive/c/#{work_dir}'; fi")
   end
 end

data/lib/packaging/util/net.rb

@@ -20,13 +20,11 @@ module Pkg::Util::Net
     end
 
     # Check that the current host matches the one we think it should
-    def check_host(host, args = { :required => true })
-      if hostname == host
-        return true
-      else
-        fail "#{hostname} does not match #{host}" if args[:required]
-        return nil
-      end
+    def check_host(host, options = { required: true })
+      return true if hostname == host
+
+      fail "Error: #{hostname} does not match #{host}" if options[:required]
+      return nil
     end
 
     # @param hosts - An array of hosts to try ssh-ing into
@@ -38,7 +36,7 @@ module Pkg::Util::Net
       errs = []
       Array(hosts).flatten.each do |host|
         begin
-          remote_ssh_cmd(host, 'exit', false, '-oBatchMode=yes')
+          remote_execute(host, 'exit', { extra_options: '-oBatchMode=yes' })
         rescue
           errs << host
         end
@@ -56,7 +54,8 @@ module Pkg::Util::Net
       errs = []
       Array(hosts).flatten.each do |host|
         begin
-          remote_ssh_cmd(host, "gpg --list-secret-keys #{gpg} > /dev/null 2&>1", false, '-oBatchMode=yes')
+          remote_execute(host, "gpg --list-secret-keys #{gpg} > /dev/null 2&>1",
+                         { extra_options: '-oBatchMode=yes' })
         rescue
           errs << host
         end
@@ -64,40 +63,62 @@ module Pkg::Util::Net
       return errs
     end
 
-    def remote_ssh_cmd(target, command, capture_output = false, extra_options = '', fail_fast = true, trace = false)  # rubocop:disable Style/ParameterLists
+    def remote_execute(target_host, command, user_options = {})
+      option_defaults = {
+        capture_output: false,
+        extra_options: '',
+        fail_fast: true,
+        trace: false
+      }
+      options = option_defaults.merge(user_options)
 
       ssh = Pkg::Util::Tool.check_tool('ssh')
 
       # we pass some pretty complicated commands in via ssh. We need this to fail
       # if any part of the remote ssh command fails.
       shell_flags = ''
-      shell_flags += 'set -e;' if fail_fast
-      shell_flags += 'set -x;' if trace
+      shell_flags += 'set -e;' if options[:fail_fast]
+      shell_flags += 'set -x;' if options[:trace]
       shell_commands = "#{shell_flags}#{command}"
 
-      cmd = "#{ssh} #{extra_options} -t #{target} '#{shell_commands.gsub("'", "'\\\\''")}'"
+      remote_command = "#{ssh} #{options[:extra_options]} -t #{target_host} " +
+                       "'#{shell_commands.gsub("'", "'\\\\''")}'"
 
       # This is NOT a good way to support this functionality.
-      # It needs to be refactored into a set of methods that
-      # other methods can use to safely and deterministically
-      # support dry-run operations.
-      # But I need to ship packages RIGHT NOW.
-      # - Ryan McKern, 13/01/2016
       if ENV['DRYRUN']
         puts "[DRY-RUN] Executing '#{command}' on #{target}"
         puts "[DRY-RUN] #{cmd}"
-        return
+        return ''
       end
 
-      puts "Executing '#{command}' on #{target}"
-      if capture_output
-        stdout, stderr, exitstatus = Pkg::Util::Execution.capture3(cmd)
-        Pkg::Util::Execution.success?(exitstatus) or raise "Remote ssh command failed."
+      # We're forced to make different calls depending on the capture_output option
+      # because something about our #capture3 method screws up gpg. This should
+      # be untangled.
+      if options[:capture_output]
+        stdout, stderr, exitstatus = Pkg::Util::Execution.capture3(remote_command)
+        Pkg::Util::Execution.success?(exitstatus) or
+          raise "Remote ssh command (\"#{remote_command}\") failed."
         return stdout, stderr
-      else
-        Kernel.system(cmd)
-        Pkg::Util::Execution.success? or raise "Remote ssh command failed."
       end
+
+      # Pkg::Util::Execution.capture3 reports its command but Kernel.system does not
+      # Let's print it out for some amount of consistency.
+      puts "Remote Execute: '#{remote_command}'"
+      Kernel.system(remote_command)
+      Pkg::Util::Execution.success? or
+        raise "Remote ssh command (\"#{remote_command}\") failed."
+    end
+
+    ###
+    ### Deprecated method implemented as a shim to the new `remote_execute` method
+    ###
+    def remote_ssh_cmd(target, command, capture_output = false, extra_options = '', fail_fast = true, trace = false)  # rubocop:disable Style/ParameterLists
+      puts "Warn: \"remote_ssh_cmd\" call in packaging is deprecated. Use \"remote_execute\" instead."
+      remote_execute(target, command, {
+                       capture_output: capture_output,
+                       extra_options: extra_options,
+                       fail_fast: fail_fast,
+                       trace: trace })
     end
 
     # Construct a valid rsync command
@@ -272,17 +293,17 @@ module Pkg::Util::Net
 
     def remote_set_ownership(host, owner, group, files)
       remote_cmd = "for file in #{files.join(" ")}; do if [[ -d $file ]] || ! `lsattr $file | grep -q '\\-i\\-'`; then sudo chown #{owner}:#{group} $file; else echo \"$file is immutable\"; fi; done"
-      Pkg::Util::Net.remote_ssh_cmd(host, remote_cmd)
+      Pkg::Util::Net.remote_execute(host, remote_cmd)
     end
 
     def remote_set_permissions(host, permissions, files)
       remote_cmd = "for file in #{files.join(" ")}; do if [[ -d $file ]] || ! `lsattr $file | grep -q '\\-i\\-'`; then sudo chmod #{permissions} $file; else echo \"$file is immutable\"; fi; done"
-      Pkg::Util::Net.remote_ssh_cmd(host, remote_cmd)
+      Pkg::Util::Net.remote_execute(host, remote_cmd)
     end
 
     # Remotely set the immutable bit on a list of files
     def remote_set_immutable(host, files)
-      Pkg::Util::Net.remote_ssh_cmd(host, "sudo chattr +i #{files.join(" ")}")
+      Pkg::Util::Net.remote_execute(host, "sudo chattr +i #{files.join(" ")}")
     end
 
     # Create a symlink indicating the latest version of a package
@@ -328,7 +349,8 @@ module Pkg::Util::Net
         ln -sf "$link_target" #{full_package_name}-latest.#{platform_ext}
       CMD
 
-      _, err = Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, cmd, true)
+      _, err = Pkg::Util::Net.remote_execute(
+           Pkg::Config.staging_server, cmd, { capture_output: true })
       $stderr.puts err
     end
 
@@ -365,7 +387,7 @@ module Pkg::Util::Net
 #{tar} -zxvf /tmp/#{tarball_name}.tar.gz -C /tmp/ ;
 git clone --recursive /tmp/#{tarball_name} #{git_bundle_directory} ;
 DOC
-      Pkg::Util::Net.remote_ssh_cmd(host, command)
+      Pkg::Util::Net.remote_execute(host, command)
       return git_bundle_directory
     end