packaging 0.99.0

data/lib/packaging/util/os.rb

@@ -0,0 +1,17 @@
+# Utility methods for handling system os information
+
+require 'rbconfig'
+
+module Pkg::Util::OS
+  def windows?
+    case RbConfig::CONFIG['host_os']
+    when /mswin|mingw/i
+      true
+    else
+      false
+    end
+  end
+  module_function :windows?
+
+  DEVNULL = windows? ? 'NUL' : '/dev/null'
+end

data/lib/packaging/util/platform.rb

@@ -0,0 +1,40 @@
+module Pkg::Util::Platform
+  module_function
+  ##########################################################################
+  # DEPRECATED METHODS
+  #
+  def platform_tags
+    Pkg::Util.deprecate('Pkg::Util::Platform.platform_tags', 'Pkg::Platforms.platform_tags')
+    Pkg::Platforms.platform_tags
+  end
+
+  def platform_lookup(platform_tag)
+    Pkg::Util.deprecate('Pkg::Util::Platform.platform_lookup', 'Pkg::Platforms.platform_lookup')
+    Pkg::Platforms.platform_lookup(platform_tag)
+  end
+
+  def parse_platform_tag(platform_tag)
+    Pkg::Util.deprecate('Pkg::Util::Platform.parse_platform_tag', 'Pkg::Platforms.parse_platform_tag')
+    Pkg::Platforms.parse_platform_tag(platform_tag)
+  end
+
+  def get_attribute(platform_tag, attribute_name)
+    Pkg::Util.deprecate('Pkg::Util::Platform.get_attribute', 'Pkg::Platforms.get_attribute')
+    Pkg::Platforms.get_attribute(platform_tag, attribute_name)
+  end
+
+  def artifacts_path(platform_tag, package_url = nil)
+    Pkg::Util.deprecate('Pkg::Util::Platform.artifacts_path', 'Pkg::Paths.artifacts_path')
+    Pkg::Paths.artifacts_path(platform_tag)
+  end
+
+  def repo_path(platform_tag)
+    Pkg::Util.deprecate('Pkg::Util::Platform.repo_path', 'Pkg::Paths.repo_path')
+    Pkg::Paths.repo_path(platform_tag)
+  end
+
+  def repo_config_path(platform_tag)
+    Pkg::Util.deprecate('Pkg::Util::Platform.repo_config_path', 'Pkg::Paths.repo_config_path')
+    Pkg::Paths.repo_config_path(platform_tag)
+  end
+end

data/lib/packaging/util/rake_utils.rb

@@ -0,0 +1,111 @@
+require 'rake'
+
+# Utility methods for working with rake tasks. These utilities will not work
+# if the packaging repo was loaded as a library unless rake has been required
+# explicitly.
+
+module Pkg::Util::RakeUtils
+  class << self
+    def using_rake?
+      defined?(Rake::Task)
+    end
+
+    def task_defined?(task_name)
+      if using_rake?
+        Rake::Task.task_defined?(task_name)
+      end
+    end
+
+    #  Return the Rake::Task object associated with a task name
+    #
+    def get_task(task_name)
+      if using_rake? and task_defined?(task_name)
+        Rake::Task[task_name]
+      end
+    end
+
+    def invoke_task(task, *args)
+      Rake::Task[task].reenable
+      Rake::Task[task].invoke(*args)
+    end
+
+    #  Add a dependency to a rake task. "depender" must be an instance of
+    #  Rake::Task, but dependency can be either a Rake::Task instance, or a String
+    #  referring to the name of a Rake::Task instance.
+    #
+    def add_dependency(depender, dependency)
+      if using_rake?
+        if !task_defined?(depender)
+          fail "Could not locate a Rake task named '#{depender.to_s}' to add a dependency of '#{dependency.to_s}' to"
+        elsif !task_defined?(dependency)
+          fail "Could not locate a Rake task named '#{dependency.to_s}' to add as a dependency of '#{depender.to_s}'"
+        else
+          depender_task = Rake::Task[depender]
+          depender_task.enhance([dependency])
+        end
+      end
+    end
+
+    #  Evaluate any pre-tasks known by the configuration of this invocation.
+    #  Again, this is quite pointless if the user has not invoked the packaging
+    #  repo via rake, so we're just not going to do anything.
+    #
+    def evaluate_pre_tasks
+      if using_rake? and Pkg::Config.pre_tasks
+        unless Pkg::Config.pre_tasks.is_a?(Hash)
+          fail "The 'pre_tasks' key must be a Hash of depender => dependency pairs"
+        end
+        Pkg::Config.pre_tasks.each do |depender, dependency|
+          add_dependency(depender, dependency)
+        end
+      end
+    end
+
+    def load_packaging_tasks(packaging_root = Pkg::Config.packaging_root)
+      packaging_task_dir = File.join(packaging_root, 'tasks')
+      tasks = [
+        '00_utils.rake',
+        '30_metrics.rake',
+        'apple.rake',
+        'build.rake',
+        'clean.rake',
+        'deb.rake',
+        'deb_repos.rake',
+        'doc.rake',
+        'education.rake',
+        'fetch.rake',
+        'gem.rake',
+        'jenkins.rake',
+        'jenkins_dynamic.rake',
+        'load_extras.rake',
+        'mock.rake',
+        'nightly_repos.rake',
+        'pe_deb.rake',
+        'pe_rpm.rake',
+        'pe_ship.rake',
+        'pe_sign.rake',
+        'pe_tar.rake',
+        'retrieve.rake',
+        'rpm.rake',
+        'rpm_repos.rake',
+        'ship.rake',
+        'sign.rake',
+        'tag.rake',
+        'tar.rake',
+        'update.rake',
+        'vendor_gems.rake',
+        'version.rake',
+        'z_data_dump.rake',
+        'config.rake',
+        'vanagon.rake',
+        'deprecated.rake'
+      ]
+
+      tasks.each do |task|
+        load File.join(packaging_task_dir, task)
+      end
+
+      Pkg::Util::RakeUtils.evaluate_pre_tasks
+    end
+  end
+end

data/lib/packaging/util/serialization.rb

@@ -0,0 +1,19 @@
+# Utility methods for dealing with serialization of Config params
+
+module Pkg::Util::Serialization
+  class << self
+
+    # Given the path to a yaml file, load the yaml file into an object and return the object.
+    def load_yaml(file)
+      require 'yaml'
+      file = File.expand_path(file)
+      begin
+        input_data = YAML.load_file(file) || {}
+      rescue => e
+        fail "There was an error loading data from #{file}.\n#{e}"
+      end
+      input_data
+    end
+  end
+end
+

data/lib/packaging/util/ship.rb

@@ -0,0 +1,171 @@
+# Module for shipping all packages to places
+require 'tmpdir'
+module Pkg::Util::Ship
+  module_function
+
+  def collect_packages(pkg_exts, excludes = []) # rubocop:disable Metrics/MethodLength
+    pkgs = pkg_exts.map { |ext| Dir.glob(ext) }.flatten
+    return [] if pkgs.empty?
+    excludes.each do |exclude|
+      pkgs.delete_if { |p| p.match(exclude) }
+    end if excludes
+    if pkgs.empty?
+      $stdout.puts "No packages with (#{pkg_exts.join(', ')}) extensions found staged in 'pkg'"
+      $stdout.puts "Maybe your excludes argument (#{excludes}) is too restrictive?"
+    end
+    pkgs
+  end
+
+  # Takes a set of packages and reorganizes them into the final repo
+  # structure before they are shipping out to their final destination.
+  #
+  # This assumes the working directory is a temporary directory that will
+  # later be cleaned up
+  #
+  # If this is platform_independent the packages will not get reorganized,
+  # just copied under the tmp directory for more consistent workflows
+  def reorganize_packages(pkgs, tmp, platform_independent = false)
+    new_pkgs = []
+    pkgs.each do |pkg|
+      if platform_independent
+        path = 'pkg'
+      else
+        platform_tag = Pkg::Paths.tag_from_artifact_path(pkg)
+        path = Pkg::Paths.artifacts_path(platform_tag, 'pkg')
+      end
+      FileUtils.mkdir_p File.join(tmp, path)
+      FileUtils.cp pkg, File.join(tmp, path)
+      new_pkgs << File.join(path, File.basename(pkg))
+    end
+    new_pkgs
+  end
+
+  # Take local packages and restructure them to the desired final path before
+  # shipping to the staging server
+  # @param [Array] pkg_exts the file globs for the files you want to ship
+  #   For example, something like ['pkg/**/*.rpm', 'pkg/**/*.deb'] to ship
+  #   the rpms and debs
+  # @param [String] staging_server The hostname to ship the packages to
+  # @param [String] remote_path The base path to ship the packages to on the
+  #   staging_server, for example '/opt/downloads/windows' or
+  #   '/opt/repository/yum'
+  # @param [Hash] opts Additional options that can be used when shipping
+  #   packages
+  # @option opts [Array] :excludes File globs to exclude packages from shipping
+  # @option opts [Boolean] :chattr Whether or not to make the files immutable
+  #   after shipping. Defaults to true.
+  # @option opts [Boolean] :platform_independent Whether or not the path the
+  #   packages ship to has platform-dependent information in it. Defaults to
+  #   false (most paths will be platform dependent), but set to true for gems
+  #   and tarballs since those just land directly under /opt/downloads/<project>
+  #
+  # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+  def ship_pkgs(pkg_exts, staging_server, remote_path, opts = {})
+    options = {
+      excludes: [],
+      chattr: true,
+      platform_independent: false }.merge(opts)
+
+    # First find the packages to be shipped. We must find them before moving
+    # to our temporary staging directory
+    local_packages = collect_packages(pkg_exts, options[:excludes])
+    return if local_packages.empty?
+
+    tmpdir = Dir.mktmpdir
+    staged_pkgs = reorganize_packages(local_packages, tmpdir, options[:platform_independent])
+
+    puts staged_pkgs.sort
+    puts "Do you want to ship the above files to (#{staging_server})?"
+    if Pkg::Util.ask_yes_or_no
+      extra_flags = ['--ignore-existing', '--delay-updates']
+      extra_flags << '--dry-run' if ENV['DRYRUN']
+
+      staged_pkgs.each do |pkg|
+        Pkg::Util::Execution.retry_on_fail(times: 3) do
+          sub_string = 'pkg'
+          remote_pkg = pkg.sub(sub_string, remote_path)
+          remote_basepath = File.dirname(remote_pkg)
+          Pkg::Util::Net.remote_ssh_cmd(staging_server, "mkdir -p #{remote_basepath}")
+          Pkg::Util::Net.rsync_to(
+            File.join(tmpdir, pkg),
+            staging_server,
+            remote_basepath,
+            extra_flags: extra_flags
+          )
+
+          Pkg::Util::Net.remote_set_ownership(staging_server, 'root', 'release', [remote_basepath, remote_pkg])
+          Pkg::Util::Net.remote_set_permissions(staging_server, '775', [remote_basepath])
+          Pkg::Util::Net.remote_set_permissions(staging_server, '0664', [remote_pkg])
+          Pkg::Util::Net.remote_set_immutable(staging_server, [remote_pkg]) if options[:chattr]
+        end
+      end
+    end
+  end
+
+  def rolling_repo_link_command(platform_tag, repo_path)
+    base_path, link_path = Pkg::Paths.artifacts_base_path_and_link_path(platform_tag, repo_path)
+
+    if link_path.nil?
+      puts "No link target set, not creating rolling repo link for #{base_path}"
+      return nil
+    end
+
+    cmd = <<-CMD
+      if [ ! -d #{base_path} ] ; then
+        echo "Link target '#{base_path}' does not exist; skipping"
+        exit 0
+      fi
+      # If it's a link but pointing to the wrong place, remove the link
+      # This is likely to happen around the transition times, like puppet5 -> puppet6
+      if [ -L #{link_path} ] && [ ! #{base_path} -ef #{link_path} ] ; then
+        rm #{link_path}
+      # This is the link you're looking for, nothing to see here
+      elif [ -L #{link_path} ] ; then
+        exit 0
+      # Don't want to delete it if it isn't a link, that could be destructive
+      # So, fail!
+      elif [ -e #{link_path} ] ; then
+        echo "#{link_path} exists but isn't a link, I don't know what to do with this" >&2
+        exit 1
+      fi
+      ln -s #{base_path} #{link_path}
+    CMD
+  end
+
+  def create_rolling_repo_link(platform_tag, staging_server, repo_path)
+    command = rolling_repo_link_command(platform_tag, repo_path)
+
+    Pkg::Util::Net.remote_ssh_cmd(staging_server, command) unless command.nil?
+  rescue => e
+    fail "Failed to create rolling repo link for '#{platform_tag}'.\n#{e}"
+  end
+
+  def test_ship(vm, ship_task)
+    command = 'getent group release || groupadd release'
+    Pkg::Util::Net.remote_ssh_cmd(vm, command)
+    hosts_to_override = %w(
+      APT_HOST
+      DMG_HOST
+      GEM_HOST
+      IPS_HOST
+      MSI_HOST
+      P5P_HOST
+      SVR4_HOST
+      SWIX_HOST
+      TAR_HOST
+      YUM_HOST
+      APT_SIGNING_SERVER
+      APT_STAGING_SERVER
+      DMG_STAGING_SERVER
+      MSI_STAGING_SERVER
+      SWIX_STAGING_SERVER
+      TAR_STAGING_SERVER
+      YUM_STAGING_SERVER
+      STAGING_SERVER
+    )
+    hosts_to_override.each do |host|
+      ENV[host] = vm
+    end
+    Rake::Task[ship_task].invoke
+  end
+end

data/lib/packaging/util/tool.rb

@@ -0,0 +1,41 @@
+# Utility methods for handling system binaries
+
+module Pkg::Util::Tool
+
+  #   Set up utility methods for handling system binaries
+  #
+  class << self
+    def check_tool(tool)
+      find_tool(tool, :required => true)
+    end
+
+    def find_tool(tool, args = { :required => false })
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |root|
+        location = File.join(root, tool)
+
+        if Pkg::Util::OS.windows? && File.extname(location).empty?
+          exts = ENV['PATHEXT']
+          exts = exts ? exts.split(File::PATH_SEPARATOR) : %w(.EXE .BAT .CMD .COM)
+          exts.each do |ext|
+            locationext = File.expand_path(location + ext)
+
+            return locationext if FileTest.executable?(locationext)
+          end
+        end
+
+        return location if FileTest.executable? location
+      end
+      fail "#{tool} tool not found...exiting" if args[:required]
+      return nil
+    end
+
+    alias :has_tool :find_tool
+
+  end
+
+  #   Set up paths to system tools we use in the packaging repo
+  #   no matter what distribution we're packaging for.
+
+  GIT = Pkg::Util::Tool.check_tool('git')
+
+end

data/lib/packaging/util/version.rb

@@ -0,0 +1,326 @@
+require 'json'
+
+# Utility methods used for versioning projects for various kinds of packaging
+module Pkg::Util::Version
+  class << self
+    def uname_r
+      uname = Pkg::Util::Tool.find_tool('uname', required: true)
+      stdout, = Pkg::Util::Execution.capture3("#{uname} -r")
+      stdout.chomp
+    end
+
+    def pwd_version
+      Dir.pwd.split('.')[-1]
+    end
+
+    def debversion
+      base_pkg_version.join('-') << "#{Pkg::Config.packager}1"
+    end
+
+    def origversion
+      Pkg::Config.debversion.split('-')[0]
+    end
+
+    def rpmversion
+      base_pkg_version[0]
+    end
+
+    def rpmrelease
+      base_pkg_version[1]
+    end
+
+    # This is used to set Pkg::Config.version
+    # describe can return a number of potential formats
+    # 5.3.0
+    # 5.3.0-18-gfbddc8f
+    # 5.3.0-18-gfbddc8f-dirty
+    # 0.7.0-rc1
+    # 0.7.0-rc1-63-g51ccc51
+    # 0.7.0-rc1-63-g51ccc51-dirty
+    #
+    # we want all of it except the `gfbddc8f` part.
+    def dash_version
+      describe = Pkg::Util::Git.describe
+      info = describe.split('-')
+
+      if Pkg::Util::Git.ref_type == "tag"
+        describe
+      else
+        info.reject { |d| d.match(/^g.{7}/) }.join('-')
+      end
+    end
+
+    # This version is used for gems and platform types that do not support
+    # dashes in the package version
+    def dot_version(version = Pkg::Config.version)
+      version.tr('-', '.')
+    end
+
+    # Given a version, reformat it to be appropriate for a final package
+    # version. This means we need to add a `0.` before the release version
+    # for non-final builds
+    #
+    # This only applies to packages that are built with the automation in this
+    # repo. This is invalid for all other build automation, like vanagon
+    #
+    # Examples of output:
+    # 4.99.0.22.gf64bc49-1
+    # 4.4.1-0.1SNAPSHOT.2017.05.16T1005
+    # 4.99.0-1
+    # 4.99.0.29.g431768c-1
+    # 2.7.1-1
+    # 5.3.0.rc4-1
+    # 3.0.5.rc6.24.g431768c-1
+    #
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def base_pkg_version(version = Pkg::Config.version)
+      return "#{dot_version(version)}-#{Pkg::Config.release}".split('-') if final?(version) || Pkg::Config.vanagon_project
+
+      if version.include?('SNAPSHOT')
+        new_version = dot_version(version).sub(/\.SNAPSHOT/, "-0.#{Pkg::Config.release}SNAPSHOT")
+      elsif version.include?('rc')
+        rc_ver = dot_version(version).match(/\.?rc(\d+)/)[1]
+        new_version = dot_version(version).sub(/\.?rc(\d+)/, '') + "-0.#{Pkg::Config.release}rc#{rc_ver}"
+      else
+        new_version = dot_version(version) + "-0.#{Pkg::Config.release}"
+      end
+
+      if new_version.include?('dirty')
+        new_version = new_version.sub(/\.?dirty/, '') + 'dirty'
+      end
+
+      new_version.split('-')
+    end
+
+    # Determines if the version we are working with is or is not final
+    #
+    # The version here does not include the release version. Therefore, we
+    # assume that any version that includes a `-\d+` was not built from a tag
+    # and is a non-final version.
+    # Examples:
+    # Final
+    #   - 5.0.0
+    #   - 2016.5.6.7
+    # Nonfinal
+    #   - 4.99.0-22
+    #   - 1.0.0-658-gabc1234
+    #   - 5.0.0.master.SNAPSHOT.2017.05.16T1357
+    #   - 5.9.7-rc4
+    #   - 4.99.0-56-dirty
+    #
+    def final?(version = Pkg::Config.version)
+      case version
+      when /rc/
+        false
+      when /SNAPSHOT/
+        false
+      when /g[a-f0-9]{7}/
+        false
+      when /^(\d+\.)+\d+-\d+/
+        false
+      when /-dirty/
+        Pkg::Config.allow_dirty_tree
+      else
+        true
+      end
+    end
+
+    # This is to support packages that only burn-in the version number in the
+    # release artifact, rather than storing it two (or more) times in the
+    # version control system.  Razor is a good example of that; see
+    # https://github.com/puppetlabs/Razor/blob/master/lib/project_razor/version.rb
+    # for an example of that this looks like.
+    #
+    # If you invoke this the version will only be modified in the temporary copy,
+    # with the intent that it never change the official source tree.
+    #
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def versionbump(workdir = nil)
+      version = ENV['VERSION'] || Pkg::Config.version.to_s.strip
+      new_version = '"' + version + '"'
+
+      version_file = "#{workdir ? workdir + '/' : ''}#{Pkg::Config.version_file}"
+
+      # Read the previous version file in...
+      contents = IO.read(version_file)
+
+      # Match version files containing 'VERSION = "x.x.x"' and just x.x.x
+      if contents =~ /VERSION =.*/
+        old_version = contents.match(/VERSION =.*/).to_s.split[-1]
+      else
+        old_version = contents
+      end
+
+      puts "Updating #{old_version} to #{new_version} in #{version_file}"
+      if contents =~ /@DEVELOPMENT_VERSION@/
+        contents.gsub!('@DEVELOPMENT_VERSION@', version)
+      elsif contents =~ /version\s*=\s*[\'"]DEVELOPMENT[\'"]/
+        contents.gsub!(/version\s*=\s*['"]DEVELOPMENT['"]/, "version = '#{version}'")
+      elsif contents =~ /VERSION = #{old_version}/
+        contents.gsub!("VERSION = #{old_version}", "VERSION = #{new_version}")
+      elsif contents =~ /#{Pkg::Config.project.upcase}VERSION = #{old_version}/
+        contents.gsub!("#{Pkg::Config.project.upcase}VERSION = #{old_version}", "#{Pkg::Config.project.upcase}VERSION = #{new_version}")
+      else
+        contents.gsub!(old_version, Pkg::Config.version)
+      end
+
+      # ...and write it back on out.
+      File.open(version_file, 'w') { |f| f.write contents }
+    end
+
+    # Human readable output for json tags reporting. This will load the
+    # input json file and output if it "looks tagged" or not
+    #
+    # @param json_data [hash] json data hash containing the ref to check
+    def report_json_tags(json_data) # rubocop:disable Metrics/AbcSize
+      puts 'component: ' + File.basename(json_data['url'])
+      puts 'ref: ' + json_data['ref'].to_s
+      if Pkg::Util::Git.remote_tagged?(json_data['url'], json_data['ref'].to_s)
+        tagged = 'Tagged? [ Yes ]'
+      else
+        tagged = 'Tagged? [ No  ]'
+      end
+      col_len = (ENV['COLUMNS'] || 70).to_i
+      puts format("\n%#{col_len}s\n\n", tagged)
+      puts '*' * col_len
+    end
+
+    ##########################################################################
+    # DEPRECATED METHODS
+    #
+    def git_co(ref)
+      Pkg::Util.deprecate('Pkg::Util::Version.git_co', 'Pkg::Util::Git.checkout')
+      Pkg::Util::Git.checkout(ref)
+    end
+
+    def git_tagged?
+      Pkg::Util.deprecate('Pkg::Util::Version.git_tagged?', 'Pkg::Util::Git.tagged?')
+      Pkg::Util::Git.tagged?
+    end
+
+    def git_describe
+      Pkg::Util.deprecate('Pkg::Util::Version.git_describe', 'Pkg::Util::Git.describe')
+      Pkg::Util::Git.describe
+    end
+
+    def git_sha(length = 40)
+      Pkg::Util.deprecate('Pkg::Util::Version.git_sha', 'Pkg::Util::Git.sha')
+      Pkg::Util::Git.sha(length)
+    end
+
+    def git_ref_type
+      Pkg::Util.deprecate('Pkg::Util::Version.git_ref_type', 'Pkg::Util::Git.ref_type')
+      Pkg::Util::Git.ref_type
+    end
+
+    def git_sha_or_tag(length = 40)
+      Pkg::Util.deprecate('Pkg::Util::Version.git_sha_or_tag', 'Pkg::Util::Git.sha_or_tag')
+      Pkg::Util::Git.sha_or_tag(length)
+    end
+
+    def is_git_repo?
+      Pkg::Util.deprecate('Pkg::Util::Version.is_git_repo?', 'Pkg::Util::Git.repo?')
+      Pkg::Util::Git.repo?
+    end
+
+    def git_project_name
+      Pkg::Util.deprecate('Pkg::Util::Version.git_project_name', 'Pkg::Util::Git.project_name')
+      Pkg::Util::Git.project_name
+    end
+
+    def git_describe_version
+      Pkg::Util.deprecate('Pkg::Util::Version.git_describe_version', 'Pkg::Util::Git.describe')
+      Pkg::Util::Git.describe
+    end
+
+    def run_git_describe_internal
+      Pkg::Util.deprecate('Pkg::Util::Version.git_describe_version', 'Pkg::Util::Git.describe')
+      Pkg::Util::Git.describe
+    end
+
+    def get_dash_version
+      Pkg::Util.deprecate('Pkg::Util::Version.get_dash_version', 'Pkg::Util::Version.dash_version')
+      Pkg::Util::Version.dash_version
+    end
+
+    def get_ips_version
+      raise "The IPS build tasks have been removed from puppetlabs/packaging. Please port all Solaris projects to vanagon (https://github.com/puppetlabs/vanagon)"
+    end
+
+    def get_dot_version
+      Pkg::Util.deprecate('Pkg::Util::Version.get_dot_version', 'Pkg::Util::Version.dot_version')
+      Pkg::Util::Version.dot_version
+    end
+
+    def get_pwd_version
+      Pkg::Util.deprecate('Pkg::Util::Version.get_pwd_version', 'Pkg::Util::Version.pwd_version')
+      Pkg::Util::Version.pwd_version
+    end
+
+    def get_base_pkg_version
+      Pkg::Util.deprecate('Pkg::Util::Version.get_base_pkg_version', 'Pkg::Util::Version.base_pkg_version')
+      Pkg::Util::Version.base_pkg_version
+    end
+
+    def get_debversion
+      Pkg::Util.deprecate('Pkg::Util::Version.get_debversion', 'Pkg::Util::Version.debversion')
+      Pkg::Util::Version.debversion
+    end
+
+    def get_origversion
+      Pkg::Util.deprecate('Pkg::Util::Version.get_origversion', 'Pkg::Util::Version.origversion')
+      Pkg::Util::Version.origversion
+    end
+
+    def get_rpmversion
+      Pkg::Util.deprecate('Pkg::Util::Version.get_rpmversion', 'Pkg::Util::Version.rpmversion')
+      Pkg::Util::Version.rpmversion
+    end
+
+    def get_rpmrelease
+      Pkg::Util.deprecate('Pkg::Util::Version.get_rpmrelease', 'Pkg::Util::Version.rpmrelease')
+      Pkg::Util::Version.rpmrelease
+    end
+
+    def source_dirty?
+      Pkg::Util.deprecate('Pkg::Util::Version.source_dirty?', 'Pkg::Util::Git.source_dirty?')
+      Pkg::Util::Git.source_dirty?
+    end
+
+    def fail_on_dirty_source
+      Pkg::Util.deprecate('Pkg::Util::Version.fail_on_dirty_source', 'Pkg::Util::Git.fail_on_dirty_source')
+      Pkg::Util::Git.fail_on_dirty_source
+    end
+
+    def is_final?
+      Pkg::Util.deprecate('Pkg::Util::Version.is_final?', 'Pkg::Util::Version.final?')
+      Pkg::Util::Version.final?
+    end
+
+    def is_rc?
+      Pkg::Util.deprecate('Pkg::Util::Version.is_rc?', 'Pkg::Util::Version.final?')
+      Pkg::Util::Version.final?
+    end
+
+    def is_odd?
+      Pkg::Util.deprecate('Pkg::Util::Version.is_odd?', 'Pkg::Util::Version.final?')
+      Pkg::Util::Version.final?
+    end
+
+    def is_less_than_one?
+      Pkg::Util.deprecate('Pkg::Util::Version.is_less_than_one?', 'Pkg::Util::Version.final?')
+      Pkg::Util::Version.final?
+    end
+
+    def el_version
+      raise "Pkg::Util::Version.el_version has been removed"
+    end
+
+    def tagged?(url, ref)
+      Pkg::Util.deprecate('Pkg::Util::Version.tagged?', 'Pkg::Util::Git.remote_tagged?')
+      Pkg::Util::Git.remote_tagged?(url, ref)
+    end
+  end
+end