packaging 0.99.76 → 0.99.80

data/spec/lib/packaging/repo_spec.rb

@@ -128,7 +128,7 @@ describe "#Pkg::Repo" do
     end
 
     it 'should execute command if optional params are nil' do
-      expect(Pkg::Util::Net).to receive(:remote_ssh_cmd).with(remote_host, "some command with #{repo_name} and #{repo_path} and stuff")
+      expect(Pkg::Util::Net).to receive(:remote_execute).with(remote_host, "some command with #{repo_name} and #{repo_path} and stuff")
       Pkg::Repo.update_repo(remote_host, repo_command, { :repo_name => repo_name, :repo_path => repo_path })
     end
   end

data/spec/lib/packaging/retrieve_spec.rb

@@ -7,11 +7,12 @@ describe 'Pkg::Retrieve' do
   remote_target = 'repos'
   project = 'puppet-agent'
   ref = 'b25e64984dd505391f248fe5501ad81e2645b6d2'
-  foss_platforms = ['el-7-x86_64', 'ubuntu-16.04-amd64', 'osx-10.11-x86_64', 'windows-2012-x64']
+  foss_platforms = ['el-7-x86_64', 'ubuntu-16.04-amd64', 'osx-10.15-x86_64', 'osx-11-x86_64', 'windows-2012-x64']
   platform_data = {:platform_data => {
-    'aix-6.1-power' => {:artifact => './aix/6.1/PC1/ppc/puppet-agent-5.3.2.155.gb25e649-1.aix6.1.ppc.rpm'},
+    'aix-7.1-power' => {:artifact => './aix/7.1/PC1/ppc/puppet-agent-5.3.2.155.gb25e649-1.aix7.1.ppc.rpm'},
     'el-7-x86_64' => {:artifact => './el/7/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.el7.x86_64.rpm'},
-    'osx-10.11-x86_64' => {:artifact => './apple/10.11/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.osx10.11.dmg'},
+    'osx-10.15-x86_64' => {:artifact => './apple/10.15/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.osx10.15.dmg'},
+    'osx-11-x86_64' => {:artifact => './apple/11/PC1/x86_64/puppet-agent-5.3.2.155.gb25e649-1.osx11.dmg'},
     'sles-11-i386' => {:artifact => './sles/11/PC1/i386/puppet-agent-5.3.2.155.gb25e649-1.sles11.i386.rpm'},
     'solaris-10-sparc' => {:artifact => './solaris/10/PC1/puppet-agent-5.3.2.155.gb25e649-1.sparc.pkg.gz'},
     'ubuntu-16.04-amd64' => {:artifact => './deb/xenial/PC1/puppet-agent_5.3.2.155.gb25e649-1xenial_amd64.deb'},

data/spec/lib/packaging/rpm/repo_spec.rb

@@ -102,10 +102,10 @@ describe "Pkg::Rpm::Repo" do
       Pkg::Repo.should_receive(:directories_that_contain_packages).and_return(pkg_directories)
       Pkg::Repo.should_receive(:populate_repo_directory)
       Pkg::Rpm::Repo.should_receive(:repo_creation_command).and_return(command)
-      Pkg::Util::Net.should_receive(:remote_ssh_cmd).with(Pkg::Config.distribution_server, command)
+      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, command)
       Pkg::Rpm::Repo.should_receive(:generate_repo_configs)
       Pkg::Rpm::Repo.should_receive(:ship_repo_configs)
-      Pkg::Util::Net.should_receive(:remote_ssh_cmd).with(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock" )
+      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock" )
       Pkg::Rpm::Repo.create_remote_repos
     end
   end
@@ -125,7 +125,7 @@ describe "Pkg::Rpm::Repo" do
       repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repo_configs/rpm"
       Pkg::Util::File.should_receive(:empty_dir?).with("pkg/repo_configs/rpm").and_return(false)
       Pkg::Util::RakeUtils.should_receive(:invoke_task).with("pl:fetch")
-      Pkg::Util::Net.should_receive(:remote_ssh_cmd).with(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
+      Pkg::Util::Net.should_receive(:remote_execute).with(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
       Pkg::Util::Execution.should_receive(:retry_on_fail).with(:times => 3)
       Pkg::Rpm::Repo.ship_repo_configs
     end

data/spec/lib/packaging/sign_spec.rb

@@ -65,7 +65,6 @@ DOC
     describe '#sign_all' do
       let(:rpm_directory) { 'foo' }
       let(:rpms_not_to_sign) { [
-        "#{rpm_directory}/aix/6.1/PC1/ppc/puppet-agent-5.5.3-1.aix6.1.ppc.rpm",
         "#{rpm_directory}/aix/7.1/PC1/ppc/puppet-agent-5.5.3-1.aix7.1.ppc.rpm",
       ] }
       let(:v3_rpms) { [
@@ -77,7 +76,6 @@ DOC
       ] }
       let(:rpms) { rpms_not_to_sign + v3_rpms + v4_rpms }
       let(:already_signed_rpms) { [
-        "#{rpm_directory}/cisco-wrlinux/7/PC1/x86_64/puppet-agent-5.5.3-1.cisco_wrlinux7.x86_64.rpm",
         "#{rpm_directory}/el/6/PC1/x86_64/puppet-agent-5.5.3-1.el6.x86_64.rpm",
       ] }
       let(:noarch_rpms) { [

data/spec/lib/packaging/util/net_spec.rb

@@ -54,24 +54,35 @@ describe "Pkg::Util::Net" do
   end
 
   describe "remote_ssh_cmd" do
+    it "should be able to call via deprecated shim" do
+      Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
+      Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
+      Pkg::Util::Execution.should_receive(:success?).and_return(true)
+      Pkg::Util::Net.remote_ssh_cmd("foo", "bar", true)
+    end
+  end
+
+  describe "remote_execute" do
     it "should fail if ssh is not present" do
       Pkg::Util::Tool.stub(:find_tool).with("ssh") { fail }
       Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_raise(RuntimeError)
-      expect{ Pkg::Util::Net.remote_ssh_cmd("foo", "bar") }.to raise_error(RuntimeError)
+      expect{ Pkg::Util::Net.remote_execute("foo", "bar") }.to raise_error(RuntimeError)
     end
 
     it "should be able to not fail fast" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Kernel.should_receive(:system).with("#{ssh}  -t foo 'bar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_ssh_cmd("foo", "bar", false, '', false)
+        Pkg::Util::Net.remote_execute(
+          "foo", "bar", capture_output: false, extra_options: '', fail_fast: false)
     end
 
     it "should be able to trace output" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -x;bar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_ssh_cmd("foo", "bar", false, '', false, true)
+        Pkg::Util::Net.remote_execute(
+          "foo", "bar", capture_output: false, fail_fast: false, trace: true)
     end
 
     context "without output captured" do
@@ -79,21 +90,22 @@ describe "Pkg::Util::Net" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_ssh_cmd("foo", "bar")
+        Pkg::Util::Net.remote_execute("foo", "bar")
       end
 
       it "should escape single quotes in the command" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_ssh_cmd("foo", "b'ar")
+        Pkg::Util::Net.remote_execute("foo", "b'ar")
       end
 
       it "should raise an error if ssh fails" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Kernel.should_receive(:system).with("#{ssh}  -t foo 'set -e;bar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(false)
-        expect{ Pkg::Util::Net.remote_ssh_cmd("foo", "bar") }.to raise_error(RuntimeError, /Remote ssh command failed./)
+        expect{ Pkg::Util::Net.remote_execute("foo", "bar") }
+          .to raise_error(RuntimeError, /failed./)
       end
     end
 
@@ -102,21 +114,22 @@ describe "Pkg::Util::Net" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_ssh_cmd("foo", "bar", true)
+        Pkg::Util::Net.remote_execute("foo", "bar", capture_output: true)
       end
 
       it "should escape single quotes in the command" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;b'\\''ar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(true)
-        Pkg::Util::Net.remote_ssh_cmd("foo", "b'ar", true)
+        Pkg::Util::Net.remote_execute("foo", "b'ar", capture_output: true)
       end
 
       it "should raise an error if ssh fails" do
         Pkg::Util::Tool.should_receive(:check_tool).with("ssh").and_return(ssh)
         Pkg::Util::Execution.should_receive(:capture3).with("#{ssh}  -t foo 'set -e;bar'")
         Pkg::Util::Execution.should_receive(:success?).and_return(false)
-        expect{ Pkg::Util::Net.remote_ssh_cmd("foo", "bar", true) }.to raise_error(RuntimeError, /Remote ssh command failed./)
+        expect{ Pkg::Util::Net.remote_execute("foo", "bar", capture_output: true) }
+          .to raise_error(RuntimeError, /failed./)
       end
     end
   end

data/spec/lib/packaging/util/ship_spec.rb

@@ -126,7 +126,7 @@ describe '#Pkg::Util::Ship' do
       # All of these expects must be called in the same block in order for the
       # tests to work without actually shipping anything
       expect(Pkg::Util::Net)
-        .to receive(:remote_ssh_cmd)
+        .to receive(:remote_execute)
               .with(test_staging_server, /#{test_remote_path}/)
               .exactly(retrieved_packages.count).times
       expect(Pkg::Util::Net)
@@ -167,7 +167,7 @@ describe '#Pkg::Util::Ship' do
       # All of these expects must be called in the same block in order for the
       # tests to work without actually shipping anything
       expect(Pkg::Util::Net)
-        .to receive(:remote_ssh_cmd)
+        .to receive(:remote_execute)
               .with(test_staging_server, /#{test_remote_path}/)
       expect(Pkg::Util::Net)
         .to receive(:rsync_to)

data/tasks/archive.rake

@@ -39,7 +39,7 @@ namespace :pl do
     task :deploy_staged_apt_archives_to_s3 => 'pl:fetch' do
       command = 'sudo /usr/local/bin/s3_repo_sync.sh release-archives.puppet.com/apt'
       Pkg::Util::Execution.retry_on_fail(:times => 3) do
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
       end
     end
 
@@ -47,7 +47,7 @@ namespace :pl do
     task :deploy_staged_yum_archives_to_s3 => 'pl:fetch' do
       command = 'sudo /usr/local/bin/s3_repo_sync.sh release-archives.puppet.com/yum'
       Pkg::Util::Execution.retry_on_fail(:times => 3) do
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
       end
     end
 
@@ -55,7 +55,7 @@ namespace :pl do
     task :deploy_staged_downloads_archives_to_s3 => 'pl:fetch' do
       command = 'sudo /usr/local/bin/s3_repo_sync.sh release-archives.puppet.com/downloads'
       Pkg::Util::Execution.retry_on_fail(:times => 3) do
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
       end
     end
 
@@ -67,4 +67,3 @@ namespace :pl do
     end
   end
 end
-

data/tasks/education.rake

@@ -35,7 +35,7 @@ namespace :pl do
       end
 
       # If the archive directory exists, move old VMs to it
-      Pkg::Util::Net.remote_ssh_cmd(target_host, "if [ -d #{target_directory}/archive ]; then #{archive_cmd}; fi")
+      Pkg::Util::Net.remote_execute(target_host, "if [ -d #{target_directory}/archive ]; then #{archive_cmd}; fi")
 
       # Ship VM and md5 to host
       Pkg::Util::Net.rsync_to(vm, target_host, target_directory)
@@ -45,10 +45,10 @@ namespace :pl do
       link_target.each do |link|
         link_path = File.join(target_directory, link)
         link_md5_path = "#{link_path}.md5"
-        Pkg::Util::Net.remote_ssh_cmd(target_host, "if [[ -L '#{link_path}' ]] && [[ ! -e '#{link_path}' ]] ; then echo '#{link_path} is a broken link, deleting' ; unlink '#{link_path}' ; fi")
-        Pkg::Util::Net.remote_ssh_cmd(target_host, "if [[ -L '#{link_md5_path}' ]] && [[ ! -e '#{link_md5_path}' ]] ; then echo '#{link_md5_path} is a broken link, deleting' ; unlink '#{link_md5_path}' ; fi")
-        Pkg::Util::Net.remote_ssh_cmd(target_host, "cd #{target_directory} ; ln -sf #{File.basename(vm)} #{link}")
-        Pkg::Util::Net.remote_ssh_cmd(target_host, "cd #{target_directory} ; ln -sf #{File.basename(md5)} #{link}.md5")
+        Pkg::Util::Net.remote_execute(target_host, "if [[ -L '#{link_path}' ]] && [[ ! -e '#{link_path}' ]] ; then echo '#{link_path} is a broken link, deleting' ; unlink '#{link_path}' ; fi")
+        Pkg::Util::Net.remote_execute(target_host, "if [[ -L '#{link_md5_path}' ]] && [[ ! -e '#{link_md5_path}' ]] ; then echo '#{link_md5_path} is a broken link, deleting' ; unlink '#{link_md5_path}' ; fi")
+        Pkg::Util::Net.remote_execute(target_host, "cd #{target_directory} ; ln -sf #{File.basename(vm)} #{link}")
+        Pkg::Util::Net.remote_execute(target_host, "cd #{target_directory} ; ln -sf #{File.basename(md5)} #{link}.md5")
       end
 
       puts "'#{vm}' and '#{md5}' have been shipped via rsync to '#{target_host}/#{target_directory}'"

data/tasks/gem.rake

@@ -39,23 +39,24 @@ end
 
 def create_default_gem_spec
   spec = Gem::Specification.new do |s|
-    s.name = Pkg::Config.project                                     unless Pkg::Config.project.nil?
-    s.name = Pkg::Config.gem_name                                    unless Pkg::Config.gem_name.nil?
-    s.version = Pkg::Config.gemversion                               unless Pkg::Config.gemversion.nil?
-    s.author = Pkg::Config.author                                    unless Pkg::Config.author.nil?
-    s.email = Pkg::Config.email                                      unless Pkg::Config.email.nil?
-    s.homepage = Pkg::Config.homepage                                unless Pkg::Config.homepage.nil?
-    s.summary = Pkg::Config.summary                                  unless Pkg::Config.summary.nil?
-    s.summary = Pkg::Config.gem_summary                              unless Pkg::Config.gem_summary.nil?
-    s.description = Pkg::Config.description                          unless Pkg::Config.description.nil?
-    s.description = Pkg::Config.gem_description                      unless Pkg::Config.gem_description.nil?
-    s.files = glob_gem_files                                         unless glob_gem_files.nil?
-    s.executables = Pkg::Config.gem_executables                      unless Pkg::Config.gem_executables.nil?
-    s.require_path = Pkg::Config.gem_require_path                    unless Pkg::Config.gem_require_path.nil?
-    s.required_ruby_version = Pkg::Config.gem_required_ruby_version  unless Pkg::Config.gem_required_ruby_version.nil?
+    s.name = Pkg::Config.project                                            unless Pkg::Config.project.nil?
+    s.name = Pkg::Config.gem_name                                           unless Pkg::Config.gem_name.nil?
+    s.version = Pkg::Config.gemversion                                      unless Pkg::Config.gemversion.nil?
+    s.author = Pkg::Config.author                                           unless Pkg::Config.author.nil?
+    s.email = Pkg::Config.email                                             unless Pkg::Config.email.nil?
+    s.homepage = Pkg::Config.homepage                                       unless Pkg::Config.homepage.nil?
+    s.summary = Pkg::Config.summary                                         unless Pkg::Config.summary.nil?
+    s.summary = Pkg::Config.gem_summary                                     unless Pkg::Config.gem_summary.nil?
+    s.description = Pkg::Config.description                                 unless Pkg::Config.description.nil?
+    s.description = Pkg::Config.gem_description                             unless Pkg::Config.gem_description.nil?
+    s.files = glob_gem_files                                                unless glob_gem_files.nil?
+    s.executables = Pkg::Config.gem_executables                             unless Pkg::Config.gem_executables.nil?
+    s.require_path = Pkg::Config.gem_require_path                           unless Pkg::Config.gem_require_path.nil?
+    s.required_ruby_version = Pkg::Config.gem_required_ruby_version         unless Pkg::Config.gem_required_ruby_version.nil?
     s.required_rubygems_version = Pkg::Config.gem_required_rubygems_version unless Pkg::Config.gem_required_rubygems_version.nil?
-    s.test_files = FileList[Pkg::Config.gem_test_files.split(' ')]   unless Pkg::Config.gem_test_files.nil?
-    s.rubyforge_project = Pkg::Config.gem_forge_project              unless Pkg::Config.gem_forge_project.nil?
+    s.test_files = FileList[Pkg::Config.gem_test_files.split(' ')]          unless Pkg::Config.gem_test_files.nil?
+    s.license = Pkg::Config.gem_license                                     unless Pkg::Config.gem_license.nil?
+    s.rubyforge_project = Pkg::Config.gem_forge_project                     unless Pkg::Config.gem_forge_project.nil?
     Pkg::Config.gem_rdoc_options.each do |option|
       s.rdoc_options << option
     end unless Pkg::Config.gem_rdoc_options.nil?

data/tasks/nightly_repos.rake

@@ -26,10 +26,10 @@ cd #{remote_repo} ;
 #{Pkg::Util::Net.remote_bundle_install_command}
 bundle exec rake pl:jenkins:sign_repos GPG_KEY=#{Pkg::Util::Gpg.key} PARAMS_FILE=#{build_params}
 DOC
-      Pkg::Util::Net.remote_ssh_cmd(signing_server, rake_command)
+      Pkg::Util::Net.remote_execute(signing_server, rake_command)
       Pkg::Util::Net.rsync_from("#{remote_repo}/repos/", signing_server, target)
-      Pkg::Util::Net.remote_ssh_cmd(signing_server, "rm -rf #{remote_repo}")
-      Pkg::Util::Net.remote_ssh_cmd(signing_server, "rm #{build_params}")
+      Pkg::Util::Net.remote_execute(signing_server, "rm -rf #{remote_repo}")
+      Pkg::Util::Net.remote_execute(signing_server, "rm #{build_params}")
       puts "Signed packages staged in '#{target}' directory"
     end
 
@@ -48,7 +48,7 @@ DOC
       target_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{target_prefix}_repos"
       Pkg::Util::Execution.retry_on_fail(:times => 3) do
         # Ship the now signed repos to the distribution server
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "mkdir -p #{target_dir}")
+        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir -p #{target_dir}")
         Pkg::Util::Net.rsync_to("#{target_prefix}_repos/", Pkg::Config.distribution_server, target_dir)
       end
     end
@@ -244,11 +244,11 @@ DOC
       local_pa_latest = "#{pa_source}-latest"
       local_pe_latest = "#{pe_target}-latest"
 
-      Pkg::Util::Net.remote_ssh_cmd(target_host, "mkdir -p '#{pe_target}'")
-      Pkg::Util::Net.remote_ssh_cmd(target_host, "mkdir -p '#{local_pe_latest}'")
-      Pkg::Util::Net.remote_ssh_cmd(target_host, "cp -r #{local_pa_latest}/* #{local_pe_latest}")
-      Pkg::Util::Net.remote_ssh_cmd(target_host, "sed -i 's|/#{File.basename(local_pa_latest)}|/#{pe_version}/#{File.basename(local_pa_latest)}|' #{local_pe_latest}/repo_configs/*/*")
-      Pkg::Util::Net.remote_ssh_cmd(target_host, "ln -sf '#{local_pa}' '#{local_pe}'")
+      Pkg::Util::Net.remote_execute(target_host, "mkdir -p '#{pe_target}'")
+      Pkg::Util::Net.remote_execute(target_host, "mkdir -p '#{local_pe_latest}'")
+      Pkg::Util::Net.remote_execute(target_host, "cp -r #{local_pa_latest}/* #{local_pe_latest}")
+      Pkg::Util::Net.remote_execute(target_host, "sed -i 's|/#{File.basename(local_pa_latest)}|/#{pe_version}/#{File.basename(local_pa_latest)}|' #{local_pe_latest}/repo_configs/*/*")
+      Pkg::Util::Net.remote_execute(target_host, "ln -sf '#{local_pa}' '#{local_pe}'")
     end
 
     task :nightly_repos => ["pl:fetch"] do

data/tasks/pe_ship.rake

@@ -65,7 +65,7 @@ if Pkg::Config.build_pe
           puts "Shipping PE debs to apt repo 'incoming' dir on #{Pkg::Config.apt_host}"
           Pkg::Util::Execution.retry_on_fail(:times => 3) do
             Dir["pkg/pe/deb/#{dist}/*.deb"].each do |deb|
-              Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.apt_host, "mkdir -p '#{target_path}/#{dist}'")
+              Pkg::Util::Net.remote_execute(Pkg::Config.apt_host, "mkdir -p '#{target_path}/#{dist}'")
               Pkg::Util::Net.rsync_to(deb, Pkg::Config.apt_host, "#{target_path}/#{dist}/#{File.basename(deb)}")
             end
           end
@@ -145,23 +145,11 @@ if Pkg::Config.build_pe
         # single line. By breaking it into a series of concatenated strings, we can maintain
         # a semblance of formatting and structure (nevermind readability).
         command  = %(for dir in #{repo_base_path}/{#{rpm_family_and_version.join(",")}}-*; do)
-
-        # For (RE-12463), make this less quiet than it has been.
-        # We're trying to find out why its aborting. Preserve the original
-        # so it can be restored.
-        command += %(  sudo createrepo --checksum=sha --checkts --update --delta-workers=0 --database --update $dir; )
-
-        ## Original
-        # command += %(  sudo createrepo --checksum=sha --checkts --update --delta-workers=0 --quiet --database --update $dir; )
-        ##
+        command += %(  sudo createrepo --checksum=sha --checkts --update --delta-workers=0 --quiet --database --update $dir; )
         command += %(done; )
         command += %(sync)
 
-        # Again for (RE-12463). Make this more verbose temporarily
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.yum_host, command, false, '', true, true)
-
-        ## Original one below
-        # Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.yum_host, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.yum_host, command)
       end
 
       desc "Remotely add shipped packages to apt repo on #{Pkg::Config.apt_host}"
@@ -183,7 +171,11 @@ if Pkg::Config.build_pe
             aptly publish repo -gpg-key=\"8BBEB79B\" #{Pkg::Config::pe_version}-#{dist} #{Pkg::Config::pe_version}
           fi
         eos
-        stdout, stderr = Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.apt_host, cmd, true)
+        stdout, stderr = Pkg::Util::Net.remote_execute(
+                  Pkg::Config.apt_host,
+                  cmd,
+                  { capture_output: true }
+                )
 
         output = stdout.to_s + stderr.to_s
 
@@ -197,7 +189,7 @@ if Pkg::Config.build_pe
         puts
 
         puts "Cleaning up apt repo 'incoming' dir on #{Pkg::Config.apt_host}"
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.apt_host, "rm -r #{incoming_dir}")
+        Pkg::Util::Net.remote_execute(Pkg::Config.apt_host, "rm -r #{incoming_dir}")
 
       end
 
@@ -213,7 +205,7 @@ if Pkg::Config.build_pe
         command += %(done; )
         command += %(sync)
 
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.yum_host, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.yum_host, command)
       end
 
       desc "Remotely link shipped deb packages into feature repo on #{Pkg::Config.apt_host}"
@@ -227,7 +219,7 @@ if Pkg::Config.build_pe
         command += %(done; )
         command += %(sync)
 
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.apt_host, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.apt_host, command)
       end
     end
   end

data/tasks/ship.rake

@@ -83,7 +83,11 @@ namespace :pl do
           source_dir = 'pkg/solaris/11/'
         end
 
-        tmpdir, _ = Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.ips_host, 'mktemp -d -p /var/tmp', true)
+        tmpdir, _ = Pkg::Util::Net.remote_execute(
+                  Pkg::Config.ips_host,
+                  'mktemp -d -p /var/tmp',
+                  { capture_output: true }
+                )
         tmpdir.chomp!
 
         Pkg::Util::Net.rsync_to(source_dir, Pkg::Config.ips_host, tmpdir)
@@ -92,9 +96,9 @@ namespace :pl do
       sudo pkgrecv -s $pkg -d #{Pkg::Config.ips_path} '*';
       done)
 
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.ips_host, remote_cmd)
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.ips_host, "sudo pkgrepo refresh -s #{Pkg::Config.ips_path}")
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.ips_host, "sudo /usr/sbin/svcadm restart svc:/application/pkg/server:#{Pkg::Config.ips_repo || 'default'}")
+        Pkg::Util::Net.remote_execute(Pkg::Config.ips_host, remote_cmd)
+        Pkg::Util::Net.remote_execute(Pkg::Config.ips_host, "sudo pkgrepo refresh -s #{Pkg::Config.ips_path}")
+        Pkg::Util::Net.remote_execute(Pkg::Config.ips_host, "sudo /usr/sbin/svcadm restart svc:/application/pkg/server:#{Pkg::Config.ips_repo || 'default'}")
       end
     end
 
@@ -104,7 +108,7 @@ namespace :pl do
       if Pkg::Util.ask_yes_or_no
         Pkg::Util::Execution.retry_on_fail(times: 3) do
           cmd = Pkg::Util::Net.rsync_cmd(Pkg::Config.dmg_path, target_host: Pkg::Config.dmg_host, extra_flags: ['--update'])
-          Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.dmg_staging_server, cmd)
+          Pkg::Util::Net.remote_execute(Pkg::Config.dmg_staging_server, cmd)
         end
       end
     end
@@ -115,7 +119,7 @@ namespace :pl do
       if Pkg::Util.ask_yes_or_no
         Pkg::Util::Execution.retry_on_fail(times: 3) do
           cmd = Pkg::Util::Net.rsync_cmd(Pkg::Config.swix_path, target_host: Pkg::Config.swix_host, extra_flags: ['--update'])
-          Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.swix_staging_server, cmd)
+          Pkg::Util::Net.remote_execute(Pkg::Config.swix_staging_server, cmd)
         end
       end
     end
@@ -130,7 +134,7 @@ namespace :pl do
         else
           Pkg::Util::Execution.retry_on_fail(times: 3) do
             cmd = Pkg::Util::Net.rsync_cmd(Pkg::Config.tarball_path, target_host: Pkg::Config.tar_host, extra_flags: ['--update'])
-            Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.tar_staging_server, cmd)
+            Pkg::Util::Net.remote_execute(Pkg::Config.tar_staging_server, cmd)
           end
         end
       end
@@ -146,7 +150,7 @@ namespace :pl do
         else
           Pkg::Util::Execution.retry_on_fail(times: 3) do
             cmd = Pkg::Util::Net.rsync_cmd(Pkg::Config.msi_path, target_host: Pkg::Config.msi_host, extra_flags: ['--update'])
-            Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.msi_staging_server, cmd)
+            Pkg::Util::Net.remote_execute(Pkg::Config.msi_staging_server, cmd)
           end
         end
       end
@@ -174,7 +178,7 @@ namespace :pl do
       if Pkg::Util.ask_yes_or_no
         Pkg::Util::Execution.retry_on_fail(:times => 3) do
           command = 'sudo /usr/local/bin/s3_repo_sync.sh apt.puppetlabs.com'
-          Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.apt_signing_server, command)
+          Pkg::Util::Net.remote_execute(Pkg::Config.apt_signing_server, command)
         end
       end
     end
@@ -200,7 +204,7 @@ namespace :pl do
       if Pkg::Util.ask_yes_or_no
         Pkg::Util::Execution.retry_on_fail(:times => 3) do
           command = 'sudo /usr/local/bin/s3_repo_sync.sh yum.puppetlabs.com'
-          Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.yum_staging_server, command)
+          Pkg::Util::Net.remote_execute(Pkg::Config.yum_staging_server, command)
         end
       end
     end
@@ -211,7 +215,7 @@ namespace :pl do
       if Pkg::Util.ask_yes_or_no
         Pkg::Util::Execution.retry_on_fail(:times => 3) do
           command = 'sudo /usr/local/bin/s3_repo_sync.sh downloads.puppetlabs.com'
-          Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+          Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
         end
       end
     end
@@ -228,7 +232,7 @@ namespace :pl do
       puts "Deploying nightly builds from #{Pkg::Config.staging_server} to AWS S3..."
       Pkg::Util::Execution.retry_on_fail(:times => 3) do
         command = 'sudo /usr/local/bin/s3_repo_sync.sh nightlies.puppet.com'
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+        Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
       end
     end
 
@@ -242,7 +246,7 @@ namespace :pl do
             ['apt', 'yum'].each do |repo|
               # Don't --delete so that folks using archived packages can continue to do so
               command = "sudo su - rsync --command 'rsync --verbose -a --exclude '*.html' /opt/repo-s3-stage/repositories/#{repo}.puppetlabs.com/ rsync@#{rsync_server}:/opt/repository/#{repo}'"
-              Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, command)
+              Pkg::Util::Net.remote_execute(Pkg::Config.staging_server, command)
             end
           end
         end
@@ -263,7 +267,7 @@ namespace :pl do
 
       command += %(; sync)
 
-      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.gem_host, command)
+      Pkg::Util::Net.remote_execute(Pkg::Config.gem_host, command)
     end
   end
 
@@ -499,7 +503,11 @@ namespace :pl do
     # Check for ability to sign OSX. Should just need to be able to unlock keychain
     begin
       unless ssh_errs.include?(Pkg::Config.osx_signing_server)
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.osx_signing_server, %(/usr/bin/security -q unlock-keychain -p "#{Pkg::Config.osx_signing_keychain_pw}" "#{Pkg::Config.osx_signing_keychain}"), false, '-oBatchMode=yes')
+        Pkg::Util::Net.remote_execute(
+          Pkg::Config.osx_signing_server,
+          %(/usr/bin/security -q unlock-keychain -p "#{Pkg::Config.osx_signing_keychain_pw}" "#{Pkg::Config.osx_signing_keychain}"),
+          { extra_options: '-oBatchMode=yes' }
+        )
       end
     rescue
       errs << "Unlocking the OSX keychain failed! Check the password in your .bashrc on #{Pkg::Config.osx_signing_server}"
@@ -545,7 +553,17 @@ namespace :pl do
       artifactory = Pkg::ManageArtifactory.new(Pkg::Config.project, Pkg::Config.ref)
 
       local_dir = args.local_dir || 'pkg'
-      Dir.glob("#{local_dir}/**/*").reject { |e| File.directory? e }.each do |artifact|
+      artifacts = Dir.glob("#{local_dir}/**/*").reject { |e| File.directory? e }
+      artifacts.sort! do |a, b|
+        if File.extname(a) =~ /(md5|sha\d+)/ && File.extname(b) !~ /(md5|sha\d+)/
+          1
+        elsif File.extname(b) =~ /(md5|sha\d+)/ && File.extname(a) !~ /(md5|sha\d+)/
+          -1
+        else
+          a <=> b
+        end
+      end
+      artifacts.each do |artifact|
         if File.extname(artifact) == ".yaml" || File.extname(artifact) == ".json"
           artifactory.deploy_package(artifact)
         elsif artifactory.package_exists_on_artifactory?(artifact)
@@ -652,8 +670,8 @@ namespace :pl do
       end
 
       Pkg::Util::Execution.retry_on_fail(times: 3) do
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "mkdir --mode=775 -p #{project_basedir}")
-        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "mkdir -p #{artifact_dir}")
+        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir --mode=775 -p #{project_basedir}")
+        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir -p #{artifact_dir}")
         Pkg::Util::Net.rsync_to("#{local_dir}/", Pkg::Config.distribution_server, "#{artifact_dir}/", extra_flags: ['--ignore-existing', '--exclude repo_configs'])
       end