packaging 0.99.0

data/lib/packaging.rb

@@ -0,0 +1,32 @@
+module Pkg
+
+  LIBDIR = File.expand_path(File.dirname(__FILE__))
+
+  $:.unshift(LIBDIR) unless
+    $:.include?(File.dirname(__FILE__)) || $:.include?(LIBDIR)
+
+  require 'packaging/platforms'
+  require 'packaging/util'
+  require 'packaging/config'
+  require 'packaging/paths'
+  require 'packaging/tar'
+  require 'packaging/deb'
+  require 'packaging/rpm'
+  require 'packaging/osx'
+  require 'packaging/ips'
+  require 'packaging/nuget'
+  require 'packaging/gem'
+  require 'packaging/msi'
+  require 'packaging/repo'
+  require 'packaging/artifactory'
+  require 'packaging/retrieve'
+
+  # Load configuration defaults
+  Pkg::Config.load_defaults
+  Pkg::Config.load_default_configs
+  Pkg::Config.load_versioning
+  Pkg::Config.load_overrides
+  Pkg::Config.load_envvars
+  Pkg::Config.issue_reassignments
+  Pkg::Config.issue_deprecations
+end

data/lib/packaging/artifactory.rb

@@ -0,0 +1,278 @@
+module Pkg
+
+  # The Artifactory class
+  # This class provides automation to access the artifactory repos maintained
+  # by the Release Engineering team at Puppet. It has the ability to both push
+  # artifacts to the repos, and to retrieve them back from the repos.
+  class ManageArtifactory
+
+    DEFAULT_REPO_TYPE = 'generic'
+    DEFAULT_REPO_BASE = 'development'
+
+    # @param project [String] The name of the project this package is for
+    # @param project_version [String] The version of the project we want the
+    #   package for. This can be one of three things:
+    #     1) the final tag of the project the packages  were built from
+    #     2) the long git sha the project the packages were built from
+    #     3) the EZBake generated development sha where the packages live
+    # @option :artifactory_uri [String] the uri for the artifactory server.
+    #   This currently defaults to 'https://artifactory.delivery.puppetlabs.net/artifactory'
+    # @option :repo_base [String] The base of all repos, set for consistency.
+    #   This currently defaults to 'development'
+    def initialize(project, project_version, opts = {})
+      require 'artifactory'
+
+      @artifactory_uri = opts[:artifactory_uri] || 'https://artifactory.delivery.puppetlabs.net/artifactory'
+      @repo_base = opts[:repo_base] || DEFAULT_REPO_BASE
+
+      @project = project
+      @project_version = project_version
+
+      Artifactory.endpoint = @artifactory_uri
+    end
+
+    # @param platform_tag [String] The platform tag string for the repo we need
+    #   information on. If generic information is needed, pass in `generic`
+    # @return [Array] An array containing three items, first being the main repo
+    #   name for the platform_tag, the second being the subdirectories of the
+    #   repo leading to the artifact we want to install, and the third being the
+    #   alternate subdirectories for a given repo. This last option is only
+    #   currently used for debian platforms, where the path to the repo
+    #   specified in the list file is different than the full path to the repo.
+    def location_for(platform_tag)
+      toplevel_repo = DEFAULT_REPO_TYPE
+      repo_subdirectories = File.join(@repo_base, @project, @project_version)
+      alternate_subdirectories = repo_subdirectories
+
+      unless platform_tag == DEFAULT_REPO_TYPE
+        format = Pkg::Platforms.package_format_for_tag(platform_tag)
+        platform, version, architecture = Pkg::Platforms.parse_platform_tag(platform_tag)
+      end
+
+      case format
+      when 'rpm'
+        toplevel_repo = 'rpm'
+        repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}-#{architecture}")
+        alternate_subdirectories = repo_subdirectories
+      when 'deb'
+        toplevel_repo = 'debian__local'
+        repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}")
+        alternate_subdirectories = File.join('pool', repo_subdirectories)
+      when 'swix', 'dmg', 'svr4', 'ips'
+        repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{version}-#{architecture}")
+        alternate_subdirectories = repo_subdirectories
+      when 'msi'
+        repo_subdirectories = File.join(repo_subdirectories, "#{platform}-#{architecture}")
+        alternate_subdirectories = repo_subdirectories
+      end
+
+      [toplevel_repo, repo_subdirectories, alternate_subdirectories]
+    end
+
+    # @param platform_tag [String] The platform tag specific to the information
+    #   we need. If only the generic information is needed, pass in `generic`
+    # @return [Hash] Returns a hash of data specific to this platform tag
+    def platform_specific_data(platform_tag)
+      unless platform_tag == DEFAULT_REPO_TYPE
+        platform, version, architecture = Pkg::Platforms.parse_platform_tag(platform_tag)
+        package_format = Pkg::Platforms.package_format_for_tag(platform_tag)
+        if package_format == 'deb'
+          codename = Pkg::Platforms.codename_for_platform_version(platform, version)
+        end
+      end
+
+      repo_name, repo_subdirectories, alternate_subdirectories = location_for(platform_tag)
+      full_artifactory_path = File.join(repo_name, alternate_subdirectories)
+
+      {
+        platform: platform,
+        platform_version: version,
+        architecture: architecture,
+        codename: codename,
+        package_format: package_format,
+        repo_name: repo_name,
+        repo_subdirectories: repo_subdirectories,
+        alternate_subdirectories: alternate_subdirectories,
+        full_artifactory_path: full_artifactory_path
+      }
+    end
+
+    # @param platform_tag [String] The platform to generate the list contents
+    #   for
+    # @return [String] The contents of the debian list file to enable the
+    #   debian artifactory repos for the specified project and version
+    def deb_list_contents(platform_tag)
+      data = platform_specific_data(platform_tag)
+      if data[:package_format] == 'deb'
+        return "deb #{@artifactory_uri}/#{data[:repo_name]} #{data[:codename]} #{data[:repo_subdirectories]}"
+      end
+      raise "The platform '#{platform_tag}' is not an apt-based system."
+    end
+
+    # @param platform_tag [String] The platform to generate the repo file
+    #   contents for
+    # @return [String] The contents of the rpm repo file to enable the rpm
+    #   artifactory repo for the specified project and version
+    def rpm_repo_contents(platform_tag)
+      data = platform_specific_data(platform_tag)
+      if data[:package_format] == 'rpm'
+        return <<-DOC
+  [Artifactory #{@project} #{@project_version} for #{platform_tag}]
+  name=Artifactory Repository for #{@project} #{@project_version} for #{platform_tag}
+  baseurl=#{@artifactory_uri}/#{data[:repo_name]}/#{data[:repo_subdirectories]}
+  enabled=1
+  gpgcheck=0
+  #Optional - if you have GPG signing keys installed, use the below flags to verify the repository metadata signature:
+  #gpgkey=#{@artifactory_uri}/#{data[:repo_name]}/#{data[:repo_subdirectories]}/repomd.xml.key
+  #repo_gpgcheck=1
+        DOC
+      end
+      raise "The platform '#{platform_tag}' is not a yum-based system"
+    end
+
+    # Verify the correct environment variables are set in order to process
+    # authorization to access the artifactory repos
+    def check_authorization
+      unless (ENV['ARTIFACTORY_USERNAME'] && ENV['ARTIFACTORY_PASSWORD']) || ENV['ARTIFACTORY_API_KEY']
+        raise <<-DOC
+  Unable to determine credentials for Artifactory. Please set one of the
+  following environment variables:
+
+  For basic authentication, please set:
+  ARTIFACTORY_USERNAME
+  ARTIFACTORY_PASSWORD
+
+  If you would like to use the API key, ensure ARTIFACTORY_USERNAME and
+  ARTIFACTORY_PASSWORD are not set, as these take precedence. Instead, please
+  set:
+  ARTIFACTORY_API_KEY
+
+  You can also set the path to a pem file with your custom certificates with:
+  ARTIFACTORY_SSL_PEM_FILE
+        DOC
+      end
+    end
+
+    # @param platform_tag [String] The platform tag to generate deploy
+    #   properties for
+    # @return [String] Any required extra bits that we need for the curl
+    #   command used to deploy packages to artifactory
+    #
+    #   These are a few examples from chef/artifactory-client. These could
+    #   potentially be very powerful, but we should decide how to use them.
+    #     status: 'DEV',
+    #     rating: 5,
+    #     branch: 'master'
+    #
+    #   Currently we are including everything that would be included in the yaml
+    #   file that is generated at package build time.
+    def deploy_properties(platform_tag)
+      data = platform_specific_data(platform_tag)
+
+      # TODO This method should be returning the entire contents of the yaml
+      # file in hash form to include as metadata for these artifacts. In this
+      # current iteration, the hash isn't formatted properly and the attempt to
+      # deploy to Artifactory bails out. I'm leaving this in so that we at least
+      # have multiple places to remind us that it needs to happen.
+      #properties_hash = Pkg::Config.config_to_hash
+      properties_hash = {}
+      if data[:package_format] == 'deb'
+        properties_hash.merge!({
+          'deb.distribution' => data[:codename],
+          'deb.component' => data[:repo_subdirectories],
+          'deb.architecture' => data[:architecture],
+        })
+      end
+      properties_hash
+    end
+
+    # @param package [String] The full relative path to the package to be
+    #   shipped, relative from the current working directory
+    def deploy_package(package)
+      platform_tag = Pkg::Paths.tag_from_artifact_path(package) || DEFAULT_REPO_TYPE
+      data = platform_specific_data(platform_tag)
+
+      check_authorization
+      artifact = Artifactory::Resource::Artifact.new(local_path: package)
+      artifact.upload(
+        data[:repo_name],
+        File.join(data[:alternate_subdirectories], File.basename(package)),
+        deploy_properties(platform_tag)
+      )
+    rescue
+      raise "Attempt to upload '#{package}' to #{File.join(@artifactory_uri, data[:full_artifactory_path])} failed"
+    end
+
+    # @param directory [String] optional, The directory where the yaml file will
+    #   be downloaded
+    # @return [String] The path to the downloaded file
+    def retrieve_yaml_data_file(directory = nil)
+      directory ||= Dir.mktmpdir
+      retrieve_package(DEFAULT_REPO_TYPE, "#{@project_version}.yaml", directory)
+      File.join(directory, "#{@project_version}.yaml")
+    end
+
+    # @param platform_data [Hash] The has of the platform data that needs to be
+    #   parsed
+    # @param platform_tag [String] The tag that the data we want belongs to
+    # @return [String] The name of the package for the given project,
+    #   project_version, and platform_tag
+    def package_name(platform_data, platform_tag)
+      return File.basename(platform_data[platform_tag][:artifact])
+    rescue
+      fail_message = <<-DOC
+  Package name could not be found from loaded yaml data. Either this package
+  does not exist, or '#{@platform_tag}' is not present in this dataset.
+
+  The following are available platform tags for '#{@project}' '#{@project_version}':
+    #{platform_data.keys.sort}
+      DOC
+      raise fail_message
+    end
+
+    # @param platform_tags [Array[String], String] optional, either a string, or
+    #   an array of strings. These are the platform or platforms that we will
+    #   download packages for.
+    # @param package [String] optional, the name of the package to be
+    #   retrieved. If the user does not know this information, we can derive it
+    #   from the yaml data. This ignores everything but the package name. Any
+    #   customization for where the user wants to fetch the package is via the
+    #   download_path parameter.
+    # @param download_path [String] Optional, an optional path set to where
+    #   the user wants the retrieved package to end up. If no path is specified
+    #   this defaults to the pkg directory.
+    def retrieve_package(platform_tags = nil, package = nil, download_path = nil)
+
+      if platform_tags.nil? && !package.nil?
+        platform_tags = Pkg::Paths.tag_from_artifact_path(package) || DEFAULT_REPO_TYPE
+      elsif platform_tags.nil? && package.nil?
+        yaml_file = retrieve_yaml_data_file(download_path)
+        yaml_data = Pkg::Config.config_from_yaml(yaml_file)
+        platform_data = yaml_data[:platform_data]
+        platform_tags = platform_data.keys
+      end
+
+      Array(platform_tags).each do |platform_tag|
+        puts "fetching package for #{platform_tag}"
+        data = platform_specific_data(platform_tag)
+        if package.nil?
+          package_for_tag = package_name(platform_data, platform_tag)
+          puts "package name is #{package_for_tag}"
+        else
+          package_for_tag = package
+        end
+        download_path_for_tag = download_path || data[:repo_subdirectories].sub(@repo_base, 'pkg')
+
+        check_authorization
+        artifact = Artifactory::Resource::Artifact.new(
+          download_uri: File.join(@artifactory_uri, data[:full_artifactory_path], File.basename(package_for_tag))
+        )
+        artifact.download(download_path_for_tag)
+      end
+    rescue
+      raise "Attempt to download '#{File.basename(package)}' from #{File.join(@artifactory_uri, data[:full_artifactory_path])} failed."
+    end
+
+    private :check_authorization
+  end
+end

data/lib/packaging/config.rb

@@ -0,0 +1,392 @@
+module Pkg
+  ##
+  #   This class is meant to encapsulate all of the data we know about a build invoked with
+  #   `rake package:<build>` or `rake pl:<build>`. It can read in this data via a yaml file,
+  #   have it set via accessors, and serialize it back to yaml for easy transport.
+  #
+  class Config
+    require 'packaging/config/params.rb'
+    require 'yaml'
+
+    class << self
+      ##
+      #   Returns a hash with string keys that maps instance variable
+      #   names without "@"" to their corresponding values.
+      #
+      def instance_values
+        Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+      end
+
+      #   Every element in Pkg::Params::BUILD_PARAMS is a configurable setting
+      #   for the build. We use Pkg::Params::BUILD_PARAMS as the source of
+      #   truth for defining the the class instance variables and their
+      #   accessors of the Pkg::Config class
+      Pkg::Params::BUILD_PARAMS.each do |v|
+        attr_accessor v
+      end
+
+      #   Return the binding of class context. Used for erb templates.
+      #
+      def get_binding
+        return binding
+      end
+
+      ##
+      #   Take a hash of Config parameters, and iterate over them, setting the
+      #   value for each Config param to the corresponding hash key,value.
+      #
+      def config_from_hash(data = {})
+        data.each do |param, value|
+          if Pkg::Params::BUILD_PARAMS.include?(param.to_sym)
+            self.instance_variable_set("@#{param}", value)
+          else
+            warn "Warning - No build data parameter found for '#{param}'. Perhaps you have an erroneous entry in your yaml file?"
+          end
+        end
+      end
+
+      ##
+      # Load a yaml file and use its contents to set the values for Pkg::Config
+      # class instance variables
+      #
+      def config_from_yaml(file)
+        build_data = Pkg::Util::Serialization.load_yaml(file)
+        config_from_hash(build_data)
+      end
+
+      ##
+      # By default return a hash of the names, values of current Pkg::Config
+      # instance variables. With :format => :yaml, write a yaml file containing
+      # the current names,values of Pkg::Config class instance variables
+      #
+      def config(args = { :target => nil, :format => :hash })
+        case args[:format]
+          when :hash
+            self.config_to_hash
+          when :yaml
+            self.config_to_yaml(args[:target])
+        end
+      end
+
+      ##
+      # For each platform we ship for, find paths to its artifact and repo_config (if applicable).
+      # This is to be consumed by beaker and later replaced with our metadata service.
+      #
+      def platform_data
+        if self.project && self.ref && Pkg::Util::Net.check_host_ssh([self.builds_server]).empty?
+          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 = artifacts.split("\n")
+          data = {}
+          artifacts.each do |artifact|
+            tag = Pkg::Paths.tag_from_artifact_path(artifact)
+            platform, version, arch = Pkg::Platforms.parse_platform_tag(tag)
+            arch = 'ppc' if platform == 'aix'
+            package_format = Pkg::Platforms.get_attribute(tag, :package_format)
+
+            # Skip this if it's an unversioned MSI. We create these to help
+            # beaker install the msi without having to know any version
+            # information, but we should report the versioned artifact in
+            # platform_data
+            next if platform == 'windows' && File.basename(artifact) == "#{self.project}-#{arch}.#{package_format}"
+            # Sometimes we have source or debug packages. We don't want to save
+            # these paths in favor of the artifact paths.
+            if platform == 'solaris'
+              next if version == '10' && File.extname(artifact) != '.gz'
+              next if version == '11' && File.extname(artifact) != '.p5p'
+            else
+              next if File.extname(artifact) != ".#{package_format}"
+            end
+            next if /#{self.project}-[a-z]+/.match(File.basename(artifact))
+
+            case package_format
+            when 'deb'
+              repo_config = "../repo_configs/deb/pl-#{self.project}-#{self.ref}-#{Pkg::Platforms.get_attribute(tag, :codename)}.list"
+            when 'rpm'
+              repo_config = "../repo_configs/rpm/pl-#{self.project}-#{self.ref}-#{tag}.repo" unless tag.include? 'aix'
+            when 'swix', 'svr4', 'ips', 'dmg', 'msi'
+              # No repo_configs for these platforms, so do nothing.
+            else
+              fail "Not sure what to do with packages with a package format of '#{package_format}' - maybe update PLATFORM_INFO?"
+            end
+            # Remove the f-prefix from the fedora platform tag keys so that
+            # beaker can rely on consistent keys once we rip out the f for good
+            tag = tag.sub(/fedora-f/, 'fedora-')
+            data[tag] = { :artifact => artifact.sub('artifacts/', ''),
+                          :repo_config => repo_config,
+                        }
+          end
+          return data
+        else
+          warn "Skipping platform_data collection, but don't worry about it."
+          return nil
+        end
+      end
+
+      ##
+      # Return a hash of all build parameters and their values, nil if unassigned.
+      #
+      def config_to_hash
+        data = {}
+        Pkg::Params::BUILD_PARAMS.each do |param|
+          data.store(param, self.instance_variable_get("@#{param}"))
+        end
+        data.store(:platform_data, platform_data)
+        data
+      end
+
+      ##
+      # Write all build parameters to a yaml file, either one specified or in a
+      # temporary location. Print the path to the file and return it as a
+      # string. Accept an argument for the write target file. If not specified,
+      # the name of the params file is the current git commit sha or tag.
+      #
+      def config_to_yaml(target = nil)
+        file = "#{self.ref}.yaml"
+        target = target.nil? ? File.join(Pkg::Util::File.mktemp, "#{self.ref}.yaml") : File.join(target, file)
+        Pkg::Util::File.file_writable?(File.dirname(target), :required => true)
+        File.open(target, 'w') do |f|
+          f.puts self.config_to_hash.to_yaml
+        end
+        puts target
+        target
+      end
+
+      ##
+      # Print the names and values of all the params known to the build object
+      #
+      def print_config
+        self.config_to_hash.each { |k, v| puts "#{k}: #{v}" }
+      end
+
+      ##
+      # Return the names of all of the cows for the project, taking off the
+      # base prefix, the architecture, and the .cow suffix. This is helpful in
+      # the debian changelog.
+      #
+      def cow_list
+        self.cows.split(' ').map do
+          |cow| cow.split('-')[1]
+        end.uniq.join(' ')
+      end
+
+      def default_project_root
+        # Assume that either PROJECT_ROOT has been set, or we're running from the
+        # project root
+        #
+        ENV['PROJECT_ROOT'] || Dir.pwd
+      end
+
+      def default_packaging_root
+        # Assume that PACKAGING_ROOT has been set, or set the PACKAGING_ROOT to
+        # one directory above the LIBDIR
+        #
+        defined?(PACKAGING_ROOT) ? File.expand_path(PACKAGING_ROOT) : File.expand_path(File.join(LIBDIR, ".."))
+      end
+
+      def load_default_configs
+        got_config = false
+        default_project_data = { :path => File.join(@project_root, "ext", "project_data.yaml"), :required => false }
+        default_build_defaults = { :path => File.join(@project_root, "ext", "build_defaults.yaml"), :required => true }
+
+        [default_project_data, default_build_defaults].each do |config|
+          if File.readable? config[:path]
+            self.config_from_yaml(config[:path])
+            got_config = true if config[:required]
+          else
+            puts "Skipping load of expected default config #{config[:path]}, cannot read file."
+          end
+        end
+
+        if got_config
+          self.config
+        else
+          # Since the default configuration files are not readable, most
+          # likely not present, at this point we assume the project_root
+          # isn't what we hoped it would be, and unset it.
+          @project_root = nil
+        end
+      end
+
+      #   Set all aspects of how the package will be versioned. Versioning
+      #   relies exclusively on the git describe of the project, which will
+      #   fail if either Pkg::Config.project_root is nil, isn't in a git repo,
+      #   or is in a git repo, but there are no tags in the repo, in which case
+      #   git-describe will fail.
+      #
+      #   It probably seems odd to load packaging-specific version
+      #   determinations, such as rpmversion here, at the top-level, and it is.
+      #   The reason for this that the creation of the most basic package
+      #   composition, the tarball, includes the generation of many different
+      #   packaging-specific files from templates in the source, and if faced
+      #   with loading rpmversion in the Tar object vs rpmversion in the
+      #   Config, I opt for the latter. It's basically a lose-lose, since it
+      #   really belongs in the Rpm object.
+
+      def load_versioning
+        if @project_root and Pkg::Util::Git.describe
+          @ref         = Pkg::Util::Git.sha_or_tag
+          @short_ref   = Pkg::Util::Git.sha_or_tag(7)
+          @version     = Pkg::Util::Version.dash_version
+          @gemversion  = Pkg::Util::Version.dot_version
+          @debversion  = Pkg::Util::Version.debversion
+          @origversion = Pkg::Util::Version.origversion
+          @rpmversion  = Pkg::Util::Version.rpmversion
+          @rpmrelease  = Pkg::Util::Version.rpmrelease
+        else
+          puts "Skipping determination of version via git describe, Pkg::Config.project_root is not set to the path of a tagged git repo."
+        end
+      end
+
+      ##
+      #   Since we're dealing with rake, much of the parameter override support
+      #   is via environment variables passed on the command line to a rake task.
+      #   These override any existing values of Pkg::Config class instance
+      #   variables
+      #
+      def load_envvars
+        Pkg::Params::ENV_VARS.each do |v|
+          if var = ENV[v[:envvar].to_s]
+            case v[:type]
+            when :bool
+              self.instance_variable_set("@#{v[:var]}", Pkg::Util.boolean_value(var))
+            when :array
+              self.instance_variable_set("@#{v[:var]}", string_to_array(var))
+            else
+              self.instance_variable_set("@#{v[:var]}", var)
+            end
+          end
+        end
+      end
+
+      ##
+      #   We supply several values by default, if they haven't been specified
+      #   already by config or environment variable. This includes the project
+      #   root as the default project root, which is relative to the
+      #   packaging path
+      #
+      def load_defaults
+        @project_root   ||= default_project_root
+        @packaging_root ||= default_packaging_root
+
+        Pkg::Params::DEFAULTS.each do |v|
+          unless self.instance_variable_get("@#{v[:var]}")
+            self.instance_variable_set("@#{v[:var]}", v[:val])
+          end
+        end
+      end
+
+      ##
+      #
+      #   Several workflows rely on being able to supply an optional yaml
+      #   parameters file that overrides all set values with its data. This has
+      #   always been supplied as an environment variable, "PARAMS_FILE." To
+      #   honor this, we have a method in config to override values as
+      #   expected. There is, however, a twist - it is absolutely essential
+      #   that the overrides do not override the project_root or packaging_root
+      #   settings, because this is environment-specific, and any value in a
+      #   params file is going to be wrong. Thus, if we have a project root or
+      #   packaging root before we begin overriding, we save it and restore it
+      #   after overrides.
+      #
+      def load_overrides
+        if ENV['PARAMS_FILE'] && ENV['PARAMS_FILE'] != ''
+          if File.readable?(ENV['PARAMS_FILE'])
+            project_root = self.instance_variable_get("@project_root")
+            packaging_root = self.instance_variable_get("@packaging_root")
+            self.config_from_yaml(ENV['PARAMS_FILE'])
+            self.instance_variable_set("@project_root", project_root) if project_root
+            self.instance_variable_set("@packaging_root", packaging_root) if packaging_root
+          else
+            fail "PARAMS_FILE was set, but not to the path to a readable file."
+          end
+        end
+      end
+
+      ##
+      #   We also have renamed various variables as part of deprecations, and
+      #   if any of these are still in use, we want to assign the values to the
+      #   new variables. However, we skip this if they target variable is already
+      #   populated, to avoid overwriting in the case that the user has started
+      #   by populating the new variable name but left the old crufty one behind.
+      #
+      def issue_reassignments
+        Pkg::Params::REASSIGNMENTS.each do |v|
+          oldval = self.instance_variable_get("@#{v[:oldvar]}")
+          newval = self.instance_variable_get("@#{v[:newvar]}")
+          if newval.nil? && oldval
+            self.instance_variable_set("@#{v[:newvar]}", oldval)
+          end
+        end
+      end
+
+      ##
+      #   Quite a few variables we also want to issue custom warnings about.
+      #   These are they.
+      #
+      def issue_deprecations
+        Pkg::Params::DEPRECATIONS.each do |v|
+          if self.instance_variable_get("@#{v[:var]}")
+            warn v[:message]
+          end
+        end
+      end
+
+      def string_to_array(str)
+        delimiters = /[,\s;]/
+        return str if str.respond_to?('each')
+        str.split(delimiters).reject { |s| s.empty? }.map { |s| s.strip }
+      end
+
+      # This method is duplicated from enterprise-dist so we can access it here.
+      def cow_to_codename_arch(cow)
+        /^base-(.*)-(.*)\.cow$/.match(cow).captures
+      end
+
+      # This method is duplicated from enterprise-dist so we can access it here.
+      def mock_to_dist_version_arch(mock)
+        # We care about matching against two patterns here:
+        # pupent-3.4-el5-i386 <= old style with PE_VER baked into the mock name
+        # pupent-el5-i386     <= new style derived from a template
+        mock.match(/pupent(-\d\.\d)?-([a-z]*)(\d*)-([^-]*)/)[2..4]
+      end
+
+      def deb_build_targets
+        if self.vanagon_project
+          self.deb_targets.split(' ')
+        else
+          self.cows.split(' ').map do |cow|
+            codename, arch = self.cow_to_codename_arch(cow)
+            "#{codename}-#{arch}"
+          end
+        end
+      end
+
+      def rpm_build_targets
+        if self.vanagon_project
+          self.rpm_targets.split(' ')
+        else
+          self.final_mocks.split(' ').map do |mock|
+            platform, version, arch = self.mock_to_dist_version_arch(mock)
+            "#{platform}-#{version}-#{arch}"
+          end
+        end
+      end
+
+      def yum_target_path(feature_branch = false)
+        if feature_branch || Pkg::Config.pe_feature_branch
+          return "#{Pkg::Config.yum_repo_path}/#{Pkg::Config.pe_version}/feature/repos/"
+        end
+        "#{Pkg::Config.yum_repo_path}/#{Pkg::Config.pe_version}/repos/"
+      end
+
+      def apt_target_path(feature_branch = false)
+        if feature_branch || Pkg::Config.pe_feature_branch
+          return "#{Pkg::Config.apt_repo_path}/#{Pkg::Config.pe_version}/feature/repos/"
+        end
+        "#{Pkg::Config.apt_repo_path}/#{Pkg::Config.pe_version}/repos/"
+      end
+    end
+  end
+end