packaging 0.88.77 → 0.99.0

data/lib/packaging/repo.rb

@@ -1,108 +1,35 @@
 module Pkg::Repo
 
   class << self
-
-    ##
-    ## Construct a local_target based upon the versioning style
-    ##
-    def construct_local_target_path(project, versioning)
-      case versioning
-      when 'ref'
-        return File.join(project, Pkg::Config.ref)
-      when 'version'
-        return File.join(project, Pkg::Util::Version.dot_version)
-      else
-        fail "Error: Unknown versioning argument: #{versioning}"
-      end
-    end
-
-    ##
-    ## Put a single signed repo into a tarball stored in
-    ## 'pkg/<local_target>/<archive_name>.tar.gz'
-    ##
-    def create_signed_repo_archive(repo_location, archive_name, versioning)
+    def create_signed_repo_archive(path_to_repo, name_of_archive, versioning)
       tar = Pkg::Util::Tool.check_tool('tar')
-
-      local_target = construct_local_target_path(Pkg::Config.project, versioning)
-
-      if Pkg::Util::File.empty_dir?(File.join('pkg', local_target, repo_location))
-        if ENV['FAIL_ON_MISSING_TARGET'] == "true"
-          raise "Error: missing packages under #{repo_location}"
+      Dir.chdir("pkg") do
+        if versioning == 'ref'
+          local_target = File.join(Pkg::Config.project, Pkg::Config.ref)
+        elsif versioning == 'version'
+          local_target = File.join(Pkg::Config.project, Pkg::Util::Version.dot_version)
         end
-        warn "Warn: Skipping #{archive_name} because #{repo_location} has no files"
-        return
-      end
-
-      Dir.chdir(File.join('pkg', local_target)) do
-        puts "Info: Archiving #{repo_location} as #{archive_name}"
-        target_tarball = File.join('repos', "#{archive_name}.tar.gz")
-        tar_command = "#{tar} --owner=0 --group=0 --create --gzip --file #{target_tarball} #{repo_location}"
-        stdout, _, _ = Pkg::Util::Execution.capture3(tar_command)
-        return stdout
-      end
-    end
-
-    ##
-    ## Add a single repo tarball into the 'all' tarball located in
-    ## 'pkg/<local_target>/<project>-all.tar'
-    ## Create the 'all' tarball if needed.
-    ##
-    def update_tarball_of_all_repos(project, platform, versioning)
-      tar = Pkg::Util::Tool.check_tool('tar')
-
-      all_repos_tarball_name = "#{project}-all.tar"
-      archive_name = "#{project}-#{platform['name']}"
-      local_target = construct_local_target_path(project, versioning)
-      repo_tarball_name = "#{archive_name}.tar.gz"
-      repo_tarball_path = File.join('repos', repo_tarball_name)
-
-      Dir.chdir(File.join('pkg', local_target)) do
-        unless Pkg::Util::File.exist?(repo_tarball_path)
-          warn "Skipping #{archive_name} because it (#{repo_tarball_path}) contains no files"
-          next
+        Dir.chdir(local_target) do
+          if Pkg::Util::File.empty_dir?(path_to_repo)
+            if ENV['FAIL_ON_MISSING_TARGET'] == "true"
+              raise "ERROR: missing packages under #{path_to_repo}"
+            else
+              warn "Skipping #{name_of_archive} because #{path_to_repo} has no files"
+            end
+          else
+            puts "Archiving #{path_to_repo} as #{name_of_archive}"
+            stdout, _, _ = Pkg::Util::Execution.capture3("#{tar} --owner=0 --group=0 --create --gzip --file #{File.join('repos', "#{name_of_archive}.tar.gz")} #{path_to_repo}")
+            stdout
+          end
         end
-
-        tar_action = "--create"
-        if File.exist?(all_repos_tarball_name)
-          tar_action = "--update"
-        end
-
-        tar_command = "#{tar} --owner=0 --group=0 #{tar_action} --file #{all_repos_tarball_name} #{repo_tarball_path}"
-        stdout, _, _ = Pkg::Util::Execution.capture3(tar_command)
-        puts stdout
       end
     end
 
-    ##
-    ## Invoke gzip to compress the 'all' tarball located in
-    ## 'pkg/<local_target>/<project>-all.tar'
-    ##
-    def compress_tarball_of_all_repos(all_repos_tarball_name)
-      gzip = Pkg::Util::Tool.check_tool('gzip')
-
-      gzip_command = "#{gzip} --fast #{all_repos_tarball_name}"
-      stdout, _, _ = Pkg::Util::Execution.capture3(gzip_command)
-      puts stdout
-    end
-
-    ##
-    ## Generate each of the repos listed in <Config.platform_repos>.
-    ## Update the 'all repos' tarball as we do each one.
-    ## Compress the 'all repos' tarball when all the repos have been generated
-    ##
     def create_all_repo_archives(project, versioning)
       platforms = Pkg::Config.platform_repos
-      local_target = construct_local_target_path(project, versioning)
-      all_repos_tarball_name = "#{project}-all.tar"
-
       platforms.each do |platform|
         archive_name = "#{project}-#{platform['name']}"
         create_signed_repo_archive(platform['repo_location'], archive_name, versioning)
-        update_tarball_of_all_repos(project, platform, versioning)
-      end
-
-      Dir.chdir(File.join('pkg', local_target)) do
-        compress_tarball_of_all_repos(all_repos_tarball_name)
       end
     end
 
@@ -110,46 +37,19 @@ 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, _ = Pkg::Util::Net.remote_execute(
-                Pkg::Config.distribution_server,
-                cmd,
-                { capture_output: true }
-              )
+      stdout, stderr = Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, cmd, true)
       return stdout.split
     rescue => e
-      fail "Error: Could not retrieve directories that contain #{pkg_ext} packages in #{Pkg::Config.distribution_server}:#{artifact_directory}"
+      fail "Could not retrieve directories that contain #{pkg_ext} packages in #{Pkg::Config.distribution_server}:#{artifact_directory}"
     end
 
     def populate_repo_directory(artifact_parent_directory)
       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_execute(Pkg::Config.distribution_server, cmd)
+      Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, cmd)
     rescue => e
-      fail "Error: Could not populate repos directory in #{Pkg::Config.distribution_server}:#{artifact_parent_directory}"
-    end
-
-    def argument_required?(argument_name, repo_command)
-      repo_command.include?("__#{argument_name.upcase}__")
-    end
-
-    def update_repo(remote_host, command, options = {})
-      fail_message = "Error: Missing required argument '%s', update your build_defaults?"
-      [:repo_name, :repo_path, :repo_host, :repo_url].each do |option|
-        fail fail_message % option.to_s if argument_required?(option.to_s, command) && !options[option]
-      end
-
-      whitelist = {
-        __REPO_NAME__: options[:repo_name],
-        __REPO_PATH__: options[:repo_path],
-        __REPO_HOST__: options[:repo_host],
-        __REPO_URL__: options[:repo_url],
-        __APT_PLATFORMS__: Pkg::Config.apt_releases.join(' '),
-        __GPG_KEY__: Pkg::Util::Gpg.key
-      }
-      Pkg::Util::Net.remote_execute(
-        remote_host,
-        Pkg::Util::Misc.search_and_replace(command, whitelist))
+      fail "Could not populate repos directory in #{Pkg::Config.distribution_server}:#{artifact_parent_directory}"
     end
   end
 end

data/lib/packaging/retrieve.rb

@@ -8,37 +8,9 @@ module Pkg::Retrieve
   # --directory-prefix = where to save to disk (defaults to ./)
   # --reject = Reject all hits that match the supplied regex
 
-  def default_wget_command(local_target, url, additional_options = {})
-    default_options = {
-      'quiet' => true,
-      'recursive' => true,
-      'no-parent' => true,
-      'no-host-directories' => true,
-      'level' => 0,
-      'cut-dirs' => 3,
-      'directory-prefix' => local_target,
-      'reject' => "'index*'",
-    }
-    options = default_options.merge(additional_options)
+  def default_wget(local_target, url)
     wget = Pkg::Util::Tool.check_tool('wget')
-    wget_command = wget
-    options.each do |option, value|
-      next unless value
-      if value.is_a?(TrueClass)
-        wget_command << " --#{option}"
-      else
-        wget_command << " --#{option}=#{value}"
-      end
-    end
-    wget_command << " #{url}"
-    return wget_command
-  end
-
-  # NOTE: When supplying additional options, if you want your value to be
-  # quoted (e.g. --reject='index*'), you must include the quotes as part of
-  # your string (e.g. {'reject' => "'index*'"}).
-  def default_wget(local_target, url, additional_options = {})
-    wget_command = default_wget_command(local_target, url, additional_options)
+    wget_command = "#{wget} --quiet --recursive --no-parent --no-host-directories --level=0 --cut-dirs 3 --directory-prefix=#{local_target} --reject 'index*' #{url}"
     puts "Executing #{wget_command} . . ."
     %x(#{wget_command})
   end
@@ -48,25 +20,24 @@ module Pkg::Retrieve
     unless Pkg::Config.foss_platforms
       fail "FOSS_ONLY specified, but I don't know anything about FOSS_PLATFORMS. Retrieve cancelled."
     end
-    default_wget(local_target, "#{build_url}/", { 'level' => 1 })
+    default_wget(local_target, "#{build_url}/artifacts/#{Pkg::Config.ref}.yaml")
     yaml_path = File.join(local_target, "#{Pkg::Config.ref}.yaml")
     unless File.readable?(yaml_path)
       fail "Couldn't read #{Pkg::Config.ref}.yaml, which is necessary for FOSS_ONLY. Retrieve cancelled."
     end
     platform_data = Pkg::Util::Serialization.load_yaml(yaml_path)[:platform_data]
     platform_data.each do |platform, paths|
-      path_to_retrieve = File.dirname(paths[:artifact])
-      default_wget(local_target, "#{build_url}/#{path_to_retrieve}/") if Pkg::Config.foss_platforms.include?(platform)
+      default_wget(local_target, "#{build_url}/artifacts/#{paths[:artifact]}") if Pkg::Config.foss_platforms.include?(platform)
     end
   end
 
-  def retrieve_all(build_url, rsync_path, local_target)
+  def retrieve_all(build_url, rsync_path, remote_target, local_target)
     if Pkg::Util::Tool.find_tool("wget")
-      default_wget(local_target, "#{build_url}/")
+      default_wget(local_target, "#{build_url}/#{remote_target}/")
     else
       warn "Could not find `wget` tool. Falling back to rsyncing from #{Pkg::Config.distribution_server}."
       begin
-        Pkg::Util::Net.rsync_from("#{rsync_path}/", Pkg::Config.distribution_server, "#{local_target}/")
+        Pkg::Util::Net.rsync_from("#{rsync_path}/#{remote_target}/", Pkg::Config.distribution_server, "#{local_target}/")
       rescue => e
         fail "Couldn't rsync packages from distribution server.\n#{e}"
       end

data/lib/packaging/rpm/repo.rb

@@ -14,9 +14,9 @@ module Pkg::Rpm::Repo
         return
       end
 
-      Pkg::Util::RakeUtils.invoke_task("pl:fetch")
+      invoke_task("pl:fetch")
       repo_dir = "#{Pkg::Config.jenkins_repo_path}/#{Pkg::Config.project}/#{Pkg::Config.ref}/#{target}/rpm"
-      Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, "mkdir -p #{repo_dir}")
+      Pkg::Util::Net.remote_ssh_cmd(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
@@ -75,6 +75,9 @@ module Pkg::Rpm::Repo
       path = Pathname.new(origin_path)
       dest_path = Pathname.new(destination_path)
 
+      # You may think "rsync doesn't actually remove the sticky bit, let's
+      # remove the Dugo-s from the chmod". However, that will make your rsyncs
+      # fail due to permission errors.
       options = %w(
         rsync
         --recursive
@@ -215,7 +218,7 @@ module Pkg::Rpm::Repo
       command = Pkg::Rpm::Repo.repo_creation_command(File.join(artifact_directory, directory), artifact_paths)
 
       begin
-        Pkg::Util::Net.remote_execute(Pkg::Config.distribution_server, command)
+        Pkg::Util::Net.remote_ssh_cmd(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 +227,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_execute(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock")
+        Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/repos/.lock")
       end
     end
 
@@ -248,7 +251,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_execute(origin_server, rsync_command)
+      Pkg::Util::Net.remote_ssh_cmd(origin_server, rsync_command)
     end
   end
 end

data/lib/packaging/tar.rb

@@ -14,10 +14,6 @@ module Pkg
       @files    = Pkg::Config.files
       @target   = File.join(Pkg::Config.project_root, "pkg", "#{@project}-#{@version}.tar.gz")
 
-      # If the user did not specify any files, then archive the entire working directory
-      # instead
-      @files ||= Dir.glob('*')
-
       # We require that the excludes list be a string (which is space
       # separated, we hope)(deprecated) or an array.
       #
@@ -34,11 +30,6 @@ module Pkg
         @excludes = []
       end
 
-      # If the user has specified things to exclude via config file, they will be
-      # honored by the tar class, but we also always exclude the packaging repo
-      # and 'pkg' directory.
-      @excludes += ['pkg', 'ext/packaging']
-
       # On the other hand, support for explicit templates started with Arrays,
       # so that's all we support.
       #

data/lib/packaging/util/date.rb

@@ -11,10 +11,5 @@ module Pkg::Util::Date
       end
       Time.now.strftime(format)
     end
-
-    def today
-      format = "%m/%d/%Y"
-      Time.now.strftime(format)
-    end
   end
 end

data/lib/packaging/util/execution.rb

@@ -58,7 +58,7 @@ module Pkg::Util::Execution
     # Loop a block up to the number of attempts given, exiting when we receive success
     # or max attempts is reached. Raise an exception unless we've succeeded.
     def retry_on_fail(args, &blk)
-      success = false
+      success = FALSE
       exception = ''
 
       if args[:times].respond_to?(:times) and block_given?
@@ -69,7 +69,7 @@ module Pkg::Util::Execution
 
           begin
             blk.call
-            success = true
+            success = TRUE
             break
           rescue => err
             puts "An error was encountered evaluating block. Retrying.."

data/lib/packaging/util/git.rb

@@ -6,7 +6,7 @@ module Pkg::Util::Git
     # Git utility to create a new git commit
     def commit_file(file, message = 'changes')
       fail_unless_repo
-      puts 'Committing changes:'
+      puts 'Commiting changes:'
       puts
       diff, = Pkg::Util::Execution.capture3("#{Pkg::Util::Tool::GIT} diff HEAD #{file}")
       puts diff

data/lib/packaging/util/gpg.rb

@@ -25,7 +25,7 @@ module Pkg::Util::Gpg
           kill_keychain
           start_keychain
         end
-        @keychain_loaded = true
+        @keychain_loaded = TRUE
       end
     end
 
@@ -51,10 +51,6 @@ module Pkg::Util::Gpg
       gpg ||= Pkg::Util::Tool.find_tool('gpg')
 
       if gpg
-        if File.exist? "#{file}.asc"
-          warn "Signature on #{file} exists, skipping..."
-          return true
-        end
         use_tty = "--no-tty --use-agent" if ENV['RPM_GPG_AGENT']
         stdout, _, _ = Pkg::Util::Execution.capture3("#{gpg} #{use_tty} --armor --detach-sign -u #{key} #{file}")
         stdout

data/lib/packaging/util/net.rb

@@ -20,11 +20,13 @@ module Pkg::Util::Net
     end
 
     # Check that the current host matches the one we think it should
-    def check_host(host, options = { required: true })
-      return true if hostname == host
-
-      fail "Error: #{hostname} does not match #{host}" if options[:required]
-      return nil
+    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
     end
 
     # @param hosts - An array of hosts to try ssh-ing into
@@ -36,7 +38,7 @@ module Pkg::Util::Net
       errs = []
       Array(hosts).flatten.each do |host|
         begin
-          remote_execute(host, 'exit', { extra_options: '-oBatchMode=yes' })
+          remote_ssh_cmd(host, 'exit', false, '-oBatchMode=yes')
         rescue
           errs << host
         end
@@ -54,8 +56,7 @@ module Pkg::Util::Net
       errs = []
       Array(hosts).flatten.each do |host|
         begin
-          remote_execute(host, "gpg --list-secret-keys #{gpg} > /dev/null 2&>1",
-                         { extra_options: '-oBatchMode=yes' })
+          remote_ssh_cmd(host, "gpg --list-secret-keys #{gpg} > /dev/null 2&>1", false, '-oBatchMode=yes')
         rescue
           errs << host
         end
@@ -63,62 +64,35 @@ module Pkg::Util::Net
       return errs
     end
 
-    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)
-
+    def remote_ssh_cmd(target, command, capture_output = false, extra_options = '', fail_fast = true)
       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 options[:fail_fast]
-      shell_flags += 'set -x;' if options[:trace]
-      shell_commands = "#{shell_flags}#{command}"
-
-      remote_command = "#{ssh} #{options[:extra_options]} -t #{target_host} " +
-                       "'#{shell_commands.gsub("'", "'\\\\''")}'"
+      command = "set -e; #{command}" if fail_fast
+      cmd = "#{ssh} #{extra_options} -t #{target} '#{command.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
 
-      # 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."
+      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."
         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
@@ -156,7 +130,7 @@ module Pkg::Util::Net
       raise(ArgumentError, "Cannot sync between two remote hosts") if
         options[:origin_host] && options[:target_host]
 
-      raise(ArgumentError, "Cannot sync path '#{origin}' because both origin_host and target_host are nil. Perhaps you need to set TEAM=release ?") unless
+      raise(ArgumentError, "Cannot sync path '#{origin}' to itself") unless
         options[:origin_host] || options[:target_host]
 
       cmd = %W(
@@ -293,17 +267,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_execute(host, remote_cmd)
+      Pkg::Util::Net.remote_ssh_cmd(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_execute(host, remote_cmd)
+      Pkg::Util::Net.remote_ssh_cmd(host, remote_cmd)
     end
 
     # Remotely set the immutable bit on a list of files
     def remote_set_immutable(host, files)
-      Pkg::Util::Net.remote_execute(host, "sudo chattr +i #{files.join(" ")}")
+      Pkg::Util::Net.remote_ssh_cmd(host, "sudo chattr +i #{files.join(" ")}")
     end
 
     # Create a symlink indicating the latest version of a package
@@ -319,14 +293,10 @@ module Pkg::Util::Net
     #   @option :excludes [Array] Strings you want to exclude from your search,
     #     e.g. 'agent' if only searching for 'puppet'.
     def remote_create_latest_symlink(package_name, dir, platform_ext, options = {})
-      ls_cmd = "ls -1 *.#{platform_ext} | grep -v latest | grep -v rc | grep -P '#{package_name}-\\d' "
-
-      # store this in a separate var to avoid side affects
-      full_package_name = String.new(package_name)
-
+      ls_cmd = "ls -1 *.#{platform_ext} | grep -v latest | grep -v rc | grep #{package_name} "
       if options[:arch]
         ls_cmd << "| grep #{options[:arch]}"
-        full_package_name << "-#{options[:arch]}"
+        package_name << "-#{options[:arch]}"
       end
       if options[:excludes]
         options[:excludes].each do |excl|
@@ -342,15 +312,14 @@ module Pkg::Util::Net
         pushd '#{dir}'
         link_target=$(#{ls_cmd})
         if [ -z "$link_target" ] ; then
-          echo "Unable to find a link target for '#{full_package_name}' in '#{dir}'; skipping link creation"
+          echo "Unable to find a link target for '#{package_name}' in '#{dir}'; skipping link creation"
           exit 0
         fi
         echo "creating link to '$link_target'"
-        ln -sf "$link_target" #{full_package_name}-latest.#{platform_ext}
+        ln -sf "$link_target" #{package_name}-latest.#{platform_ext}
       CMD
 
-      _, err = Pkg::Util::Net.remote_execute(
-           Pkg::Config.staging_server, cmd, { capture_output: true })
+      _, err = Pkg::Util::Net.remote_ssh_cmd(Pkg::Config.staging_server, cmd, true)
       $stderr.puts err
     end
 
@@ -374,7 +343,7 @@ module Pkg::Util::Net
     # We take a tar argument for cases where `tar` isn't best, e.g. Solaris.  We
     # also take an optional argument of the tarball containing the git bundle to
     # use.
-    def remote_unpack_git_bundle(host, treeish, tar_cmd = nil, tarball = nil)
+    def remote_bootstrap(host, treeish, tar_cmd = nil, tarball = nil)
       unless tar = tar_cmd
         tar = 'tar'
       end
@@ -382,19 +351,8 @@ module Pkg::Util::Net
       tarball_name = File.basename(tarball).gsub('.tar.gz', '')
       Pkg::Util::Net.rsync_to(tarball, host, '/tmp')
       appendix = Pkg::Util.rand_string
-      git_bundle_directory = File.join('/tmp', "#{Pkg::Config.project}-#{appendix}")
-      command = <<-DOC
-#{tar} -zxvf /tmp/#{tarball_name}.tar.gz -C /tmp/ ;
-git clone --recursive /tmp/#{tarball_name} #{git_bundle_directory} ;
-DOC
-      Pkg::Util::Net.remote_execute(host, command)
-      return git_bundle_directory
-    end
-
-    def remote_bundle_install_command
-      export_packaging_location = ''
-      export_packaging_location = "export PACKAGING_LOCATION='#{ENV['PACKAGING_LOCATION']}';" if ENV['PACKAGING_LOCATION'] && !ENV['PACKAGING_LOCATION'].empty?
-      command = "source /usr/local/rvm/scripts/rvm; rvm use ruby-2.5.1; #{export_packaging_location} bundle install --path .bundle/gems ;"
+      Pkg::Util::Net.remote_ssh_cmd(host, "#{tar} -zxvf /tmp/#{tarball_name}.tar.gz -C /tmp/ ; git clone --recursive /tmp/#{tarball_name} /tmp/#{Pkg::Config.project}-#{appendix} ; cd /tmp/#{Pkg::Config.project}-#{appendix} ; rake package:bootstrap")
+      "/tmp/#{Pkg::Config.project}-#{appendix}"
     end
 
     # Given a BuildInstance object and a host, send its params to the host. Return

data/lib/packaging/util/rake_utils.rb

@@ -67,7 +67,6 @@ module Pkg::Util::RakeUtils
         '00_utils.rake',
         '30_metrics.rake',
         'apple.rake',
-        'archive.rake',
         'build.rake',
         'clean.rake',
         'deb.rake',