Simplify version processing.

In response to the cessation of per-commit tarballs produced by the CI
systems, simplify the version processing code. We did many many many
complicated things to support producing release artifacts that were not
actually supported release artifacts. After a bunch of issues emerged, it was
determined that the best way forward was to stop producing quasi-not-really
non-release tarballs. If people want to consume versions of openstack that
are not released versions, the git repos are always available.

Additionally, this patch removes versioninfo and just uses PKG-INFO and
pkg_resources to handle version processing.

Change-Id: I5c799f3520adb2ba5288d852543706d81a92f8a1

1 files changed, 16 insertions, 90 deletions

diff --git a/openstack/common/version.py b/openstack/common/version.py
index c04a695..8f7e1a9 100644
--- a/openstack/common/version.py
+++ b/openstack/common/version.py
@@ -1,6 +1,6 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 #    Copyright 2012 OpenStack LLC
+#    Copyright 2012-2013 Hewlett-Packard Development Company, L.P.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
 #    not use this file except in compliance with the License. You may obtain
@@ -15,116 +15,42 @@
 #    under the License.
 
 """
-Utilities for consuming the auto-generated versioninfo files.
+Utilities for consuming the version from pkg_resources.
 """
 
-import datetime
 import pkg_resources
 
-import setup
-
 
 class VersionInfo(object):
 
-    def __init__(self, package, python_package=None, pre_version=None):
+    def __init__(self, package):
         """Object that understands versioning for a package
-        :param package: name of the top level python namespace. For glance,
-                        this would be "glance" for python-glanceclient, it
-                        would be "glanceclient"
-        :param python_package: optional name of the project name. For
-                               glance this can be left unset. For
-                               python-glanceclient, this would be
-                               "python-glanceclient"
-        :param pre_version: optional version that the project is working to
+        :param package: name of the python package, such as glance, or
+                        python-glanceclient
         """
         self.package = package
-        if python_package is None:
-            self.python_package = package
-        else:
-            self.python_package = python_package
-        self.pre_version = pre_version
         self.version = None
         self._cached_version = None
 
-    def _generate_version(self):
-        """Defer to the openstack.common.setup routines for making a
-        version from git."""
-        if self.pre_version is None:
-            return setup.get_post_version(self.package)
-        else:
-            return setup.get_pre_version(self.package, self.pre_version)
-
-    def _newer_version(self, pending_version):
-        """Check to see if we're working with a stale version or not.
-        We expect a version string that either looks like:
-          2012.2~f3~20120708.10.4426392
-        which is an unreleased version of a pre-version, or:
-          0.1.1.4.gcc9e28a
-        which is an unreleased version of a post-version, or:
-          0.1.1
-        Which is a release and which should match tag.
-        For now, if we have a date-embedded version, check to see if it's
-        old, and if so re-generate. Otherwise, just deal with it.
-        """
-        try:
-            version_date = int(self.version.split("~")[-1].split('.')[0])
-            if version_date < int(datetime.date.today().strftime('%Y%m%d')):
-                return self._generate_version()
-            else:
-                return pending_version
-        except Exception:
-            return pending_version
+    def _get_version_from_pkg_resources(self):
+        """Get the version of the package from the pkg_resources record
+        associated with the package."""
+        requirement = pkg_resources.Requirement.parse(self.package)
+        provider = pkg_resources.get_provider(requirement)
+        return provider.version
 
-    def version_string_with_vcs(self, always=False):
+    def version_string(self):
         """Return the full version of the package including suffixes indicating
         VCS status.
-
-        For instance, if we are working towards the 2012.2 release,
-        canonical_version_string should return 2012.2 if this is a final
-        release, or else something like 2012.2~f1~20120705.20 if it's not.
-
-        :param always: if true, skip all version caching
         """
-        if always:
-            self.version = self._generate_version()
-
         if self.version is None:
-
-            requirement = pkg_resources.Requirement.parse(self.python_package)
-            versioninfo = "%s/versioninfo" % self.package
-            try:
-                raw_version = pkg_resources.resource_string(requirement,
-                                                            versioninfo)
-                self.version = self._newer_version(raw_version.strip())
-            except (IOError, pkg_resources.DistributionNotFound):
-                self.version = self._generate_version()
+            self.version = self._get_version_from_pkg_resources()
 
         return self.version
 
-    def canonical_version_string(self, always=False):
-        """Return the simple version of the package excluding any suffixes.
-
-        For instance, if we are working towards the 2012.2 release,
-        canonical_version_string should return 2012.2 in all cases.
-
-        :param always: if true, skip all version caching
-        """
-        return self.version_string_with_vcs(always).split('~')[0]
-
-    def version_string(self, always=False):
-        """Return the base version of the package.
-
-        For instance, if we are working towards the 2012.2 release,
-        version_string should return 2012.2 if this is a final release, or
-        2012.2-dev if it is not.
-
-        :param always: if true, skip all version caching
-        """
-        version_parts = self.version_string_with_vcs(always).split('~')
-        if len(version_parts) == 1:
-            return version_parts[0]
-        else:
-            return '%s-dev' % (version_parts[0],)
+    # Compatibility functions
+    canonical_version_string = version_string
+    version_string_with_vcs = version_string
 
     def cached_version_string(self, prefix=""):
         """Generate an object which will expand in a string context to