builder: add support to rebuild existing packages
Usage example: sudo make <package-name> REBUILD=1 Other changes: support/package-builder: - Cleanups - Get rid of distutilsversion and introduce rpmversion - Support epoch version comparision Change-Id: I862ed5dbc7a28ae66ac44c508e35fca4292fdaf3 Signed-off-by: Shreenidhi Shedi <shreenidhi.shedi@broadcom.com> Reviewed-on: http://photon-gerrit.lvn.broadcom.net/c/photon/+/25556 Reviewed-by: Srinidhi Rao <srinidhi.rao@broadcom.com> Reviewed-by: Alexey Makhalov <alexey.makhalov@broadcom.com> Tested-by: gerrit-photon <svc.photon-ci@broadcom.com>
This commit is contained in:
Shreenidhi Shedi
parent
e0388f24d9
commit
d79605a71c
8
Makefile
8
Makefile
|
|
@ -5,18 +5,14 @@ CONF := build-config.json
|
|||
all:
|
||||
@if [ -n "$(pkgs)" ]; then \
|
||||
python3 build.py -c $(CONF) --pkgs "$(pkgs)"; \
|
||||
elif [ -n "$(shell echo $(BUILD_EXTRA_PKGS) | grep -Ew "enable|yes|True|1")" ]; then \
|
||||
elif [ "$(BUILD_EXTRA_PKGS)" = "1" ]; then \
|
||||
python3 build.py -c $(CONF) -t extra-packages; \
|
||||
else \
|
||||
python3 build.py -c $(CONF) -t packages; \
|
||||
fi
|
||||
|
||||
%:
|
||||
@if [ -n "$(shell echo $(BUILD_EXTRA_PKGS) | grep -Ew "enable|yes|True")" ]; then\
|
||||
python3 build.py -c $(CONF) -t extra-packages;\
|
||||
else\
|
||||
python3 build.py -c $(CONF) -t $@;\
|
||||
fi
|
||||
@python3 build.py -c $(CONF) -t $@
|
||||
|
||||
help:
|
||||
@python3 build.py --help
|
||||
|
|
|
|||
|
|
@ -149,7 +149,7 @@ popd \
|
|||
%package tests\
|
||||
Summary: Test suite for package %{name}\
|
||||
Group: Development/Debug\
|
||||
Requires: %{name} = %{?epoch:%{epoch}:}%{version}-%{release}\
|
||||
Requires: %{name} = %{version}-%{release}\
|
||||
Requires: /usr/bin/prove \
|
||||
%{?__tests_spkg_req:Requires: %__tests_spkg_req}\
|
||||
%{?__tests_spkg_prov:Provides: %__tests_spkg_prov}\
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
Summary: Package manager
|
||||
Name: rpm
|
||||
Version: 4.19.1.1
|
||||
Release: 3%{?dist}
|
||||
Release: 4%{?dist}
|
||||
License: GPLv2+
|
||||
URL: http://rpm.org
|
||||
Group: Applications/System
|
||||
|
|
@ -369,6 +369,8 @@ rm -rf %{buildroot}
|
|||
%{_docdir}/%{name}/*.md
|
||||
|
||||
%changelog
|
||||
* Mon Apr 21 2025 Shreenidhi Shedi <shreenidhi.shedi@broadcom.com> 4.19.1.1-4
|
||||
- Remove epoch entries from perl macro
|
||||
* Mon Oct 14 2024 Shreenidhi Shedi <shreenidhi.shedi@broadcom.com> 4.19.1.1-3
|
||||
- Remove brp-elfperms script
|
||||
* Tue Aug 06 2024 Shreenidhi Shedi <shreenidhi.shedi@broadcom.com> 4.19.1.1-2
|
||||
|
|
|
|||
19
build.py
19
build.py
|
|
@ -868,10 +868,15 @@ class RpmBuildTarget:
|
|||
)
|
||||
check_prerequesite["updated-packages"] = True
|
||||
|
||||
def buildGivenPackages(self, pkgs):
|
||||
def buildGivenPackages(self, pkgs, rebuild=False):
|
||||
pkgs = pkgs.split(",")
|
||||
self.logger.debug(f"Building following packages: {pkgs}")
|
||||
PackageManager()._buildGivenPackages(pkgs, Build_Config.buildThreads)
|
||||
pkgMgr = PackageManager()
|
||||
pkgMgr._buildGivenPackages(
|
||||
pkgs,
|
||||
Build_Config.buildThreads,
|
||||
rebuild=rebuild
|
||||
)
|
||||
|
||||
def check_packages(self):
|
||||
if check_prerequesite["check-packages"]:
|
||||
|
|
@ -1594,6 +1599,7 @@ def process_env_build_params(ph_build_param):
|
|||
"BUILD_EXTRA_PKGS": "build-extra-pkgs",
|
||||
"RESUME_BUILD": "resume-build",
|
||||
"POI_IMAGE": "poi-image",
|
||||
"REBUILD": "rebuild",
|
||||
}
|
||||
|
||||
os.environ["PHOTON_RELEASE_VER"] = ph_build_param["photon-release-version"]
|
||||
|
|
@ -1621,6 +1627,7 @@ def process_env_build_params(ph_build_param):
|
|||
"ACVP_BUILD",
|
||||
"BUILD_EXTRA_PKGS",
|
||||
"RESUME_BUILD",
|
||||
"REBUILD",
|
||||
}:
|
||||
val = cmdUtils.strtobool(val)
|
||||
elif k == "RPMCHECK":
|
||||
|
|
@ -1668,6 +1675,7 @@ def main():
|
|||
parser.add_argument("-c", "--config", dest="configPath", default=None)
|
||||
parser.add_argument("-t", "--target", dest="targetName", default=None)
|
||||
parser.add_argument("-p", "--pkgs", dest="pkgs", default=None)
|
||||
parser.add_argument("-r", "--rebuild", dest="rebuild", default=False)
|
||||
parser.add_argument("-h", "--help", dest="help", action="store_true")
|
||||
parser.add_argument("args", nargs="*")
|
||||
|
||||
|
|
@ -1681,6 +1689,7 @@ def main():
|
|||
targetName = options.targetName
|
||||
args = options.args
|
||||
pkgs = options.pkgs
|
||||
rebuild = options.rebuild
|
||||
|
||||
build_cfg = "build-config.json"
|
||||
|
||||
|
|
@ -1726,6 +1735,10 @@ def main():
|
|||
ph_build_param = configdict["photon-build-param"]
|
||||
process_env_build_params(ph_build_param)
|
||||
|
||||
rebuild = rebuild or ph_build_param.get("rebuild", False)
|
||||
if rebuild:
|
||||
constants.set_rebuild(True)
|
||||
|
||||
cfgdict_additional_path = configdict["additional-path"]
|
||||
process_additional_cfgs(cfgdict_additional_path)
|
||||
|
||||
|
|
@ -1770,7 +1783,7 @@ def main():
|
|||
CheckTools.check_pre_reqs()
|
||||
|
||||
if pkgs:
|
||||
sys.exit(RpmBuildTarget().buildGivenPackages(pkgs))
|
||||
sys.exit(RpmBuildTarget().buildGivenPackages(pkgs, rebuild))
|
||||
|
||||
try:
|
||||
attr = None
|
||||
|
|
|
|||
|
|
@ -105,6 +105,7 @@ class PackageManager(object):
|
|||
self._createBuildContainer(False)
|
||||
|
||||
def buildPackages(self, listPackages, buildThreads):
|
||||
rebuild = constants.rebuild
|
||||
if constants.rpmCheck:
|
||||
constants.rpmCheck = False
|
||||
constants.addMacro("with_check", "0")
|
||||
|
|
@ -112,7 +113,7 @@ class PackageManager(object):
|
|||
self._buildTestPackages(buildThreads)
|
||||
constants.rpmCheck = True
|
||||
constants.addMacro("with_check", "1")
|
||||
self._buildGivenPackages(listPackages, buildThreads)
|
||||
self._buildGivenPackages(listPackages, buildThreads, rebuild)
|
||||
else:
|
||||
self.buildToolChainPackages(buildThreads)
|
||||
self.logger.info(
|
||||
|
|
@ -120,7 +121,7 @@ class PackageManager(object):
|
|||
)
|
||||
self.logger.info(listPackages)
|
||||
self.logger.info("")
|
||||
self._buildGivenPackages(listPackages, buildThreads)
|
||||
self._buildGivenPackages(listPackages, buildThreads, rebuild)
|
||||
self.logger.info("Package build has been completed")
|
||||
self.logger.info("")
|
||||
|
||||
|
|
@ -167,12 +168,16 @@ class PackageManager(object):
|
|||
|
||||
return listAvailablePackages
|
||||
|
||||
def _calculateParams(self, listPackages):
|
||||
def _calculateParams(self, listPackages, rebuild=False):
|
||||
self.mapCyclesToPackageList.clear()
|
||||
self.mapPackageToCycle.clear()
|
||||
self.sortedPackageList = []
|
||||
|
||||
self.listOfPackagesAlreadyBuilt = self._readAlreadyAvailablePackages()
|
||||
|
||||
if rebuild:
|
||||
self.listOfPackagesAlreadyBuilt = set(self.listOfPackagesAlreadyBuilt) - set(listPackages)
|
||||
|
||||
if self.listOfPackagesAlreadyBuilt:
|
||||
self.logger.debug("List of already available packages:")
|
||||
self.logger.debug(self.listOfPackagesAlreadyBuilt)
|
||||
|
|
@ -224,7 +229,7 @@ class PackageManager(object):
|
|||
Scheduler.setEvent(statusEvent)
|
||||
Scheduler.stopScheduling = False
|
||||
|
||||
def _buildGivenPackages(self, listPackages, buildThreads):
|
||||
def _buildGivenPackages(self, listPackages, buildThreads, rebuild=False):
|
||||
# Extend listPackages from ["name1", "name2",..] to
|
||||
# ["name1-vers1", "name2-vers2",..]
|
||||
listPackageNamesAndVersions = set()
|
||||
|
|
@ -233,7 +238,7 @@ class PackageManager(object):
|
|||
for version in SPECS.getData().getVersions(base):
|
||||
listPackageNamesAndVersions.add(f"{base}-{version}")
|
||||
|
||||
returnVal = self._calculateParams(listPackageNamesAndVersions)
|
||||
returnVal = self._calculateParams(listPackageNamesAndVersions, rebuild=rebuild)
|
||||
if not returnVal:
|
||||
self.logger.error(
|
||||
"Unable to set parameters. Terminating the package manager."
|
||||
|
|
|
|||
|
|
@ -377,7 +377,7 @@ class PackageUtils(object):
|
|||
rpmBuildcmd = f"{self.rpmbuildBinary} {self.rpmbuildBuildallOption}"
|
||||
|
||||
if constants.resume_build:
|
||||
rpmBuildcmd += f" -D \"__spec_prep_cmd /bin/true\" "
|
||||
rpmBuildcmd += " -D \"__spec_prep_cmd /bin/true\" "
|
||||
|
||||
if (
|
||||
not constants.buildDbgInfoRpm
|
||||
|
|
|
|||
|
|
@ -118,7 +118,7 @@ class Chroot(Sandbox):
|
|||
shutil.copy2(src, f"{self.chrootID}{dest}")
|
||||
|
||||
def put_list_of_files(self, sources, dest):
|
||||
if type(sources) == list:
|
||||
if isinstance(sources, list):
|
||||
sources = " ".join(sources)
|
||||
cmd = f"cp -p {sources} {self.chrootID}{dest}"
|
||||
self.logger.debug(cmd)
|
||||
|
|
|
|||
|
|
@ -1,13 +1,11 @@
|
|||
#!/usr/bion/env python3
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import os
|
||||
import re
|
||||
|
||||
from Logger import Logger
|
||||
from constants import constants
|
||||
from StringUtils import StringUtils
|
||||
from distutilsversion import StrictVersion
|
||||
from distutilsversion import LooseVersion
|
||||
from rpmversion import LooseVersion
|
||||
from SpecParser import SpecParser
|
||||
|
||||
|
||||
|
|
@ -78,7 +76,10 @@ class SpecData(object):
|
|||
specObjs = self.getSpecObjects(depPkg.package)
|
||||
try:
|
||||
for obj in specObjs:
|
||||
verrel = obj.version
|
||||
if not obj.epoch:
|
||||
verrel = obj.version
|
||||
else:
|
||||
verrel = f"{obj.epoch}:{obj.version}"
|
||||
if depPkg.compare == ">=":
|
||||
if LooseVersion(verrel) >= LooseVersion(depPkg.version):
|
||||
return obj.version
|
||||
|
|
|
|||
|
|
@ -5,7 +5,9 @@ import re
|
|||
|
||||
from StringUtils import StringUtils
|
||||
from constants import constants
|
||||
from SpecStructures import dependentPackageData, Package, SpecObject
|
||||
from SpecStructures import dependentPackageData
|
||||
from SpecStructures import Package
|
||||
from SpecStructures import SpecObject
|
||||
|
||||
strUtils = StringUtils()
|
||||
|
||||
|
|
@ -46,6 +48,7 @@ class SpecParser(object):
|
|||
totalLines = len(lines)
|
||||
|
||||
i = 0
|
||||
|
||||
def skip_conditional_body(line):
|
||||
deep = 1
|
||||
nonlocal i
|
||||
|
|
@ -301,6 +304,7 @@ class SpecParser(object):
|
|||
"^name:",
|
||||
"^group:",
|
||||
"^license:",
|
||||
"^epoch:",
|
||||
"^version:",
|
||||
"^release:",
|
||||
"^distribution:",
|
||||
|
|
@ -425,10 +429,13 @@ class SpecParser(object):
|
|||
if headerName == "license":
|
||||
pkg.license = headerContent
|
||||
return True
|
||||
if headerName == "version":
|
||||
pkg.version = headerContent
|
||||
if pkg == self.packages["default"]:
|
||||
self.defs["version"] = pkg.version
|
||||
if headerName in {"version", "epoch"}:
|
||||
if headerName == "epoch":
|
||||
self.defs["epoch"] = headerContent
|
||||
elif headerName == "version":
|
||||
pkg.version = headerContent
|
||||
if pkg == self.packages["default"]:
|
||||
self.defs["version"] = pkg.version
|
||||
return True
|
||||
if headerName == "buildarch":
|
||||
pkg.buildarch = headerContent
|
||||
|
|
@ -675,6 +682,7 @@ class SpecParser(object):
|
|||
specObj.specFile = self.specfile
|
||||
defPkg = self.packages.get("default")
|
||||
specObj.name = defPkg.name
|
||||
specObj.epoch = self.defs.get("epoch", 0)
|
||||
specObj.version = f"{defPkg.version}-{defPkg.release}"
|
||||
specObj.release = defPkg.release
|
||||
specObj.checksums = defPkg.checksums
|
||||
|
|
|
|||
|
|
@ -64,6 +64,7 @@ class Package(object):
|
|||
class SpecObject(object):
|
||||
def __init__(self):
|
||||
self.name = ""
|
||||
self.epoch = 0
|
||||
self.version = ""
|
||||
self.release = ""
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#!/usr/bin/env/ python3
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import platform
|
||||
|
||||
|
|
@ -55,6 +55,7 @@ class constants(object):
|
|||
buildDbgInfoRpmList = []
|
||||
extraPackagesList = []
|
||||
CopyToSandboxDict = {}
|
||||
rebuild = False
|
||||
|
||||
noDepsPackageList = [
|
||||
"texinfo",
|
||||
|
|
@ -388,7 +389,7 @@ class constants(object):
|
|||
"/usr/bin/mv": "coreutils",
|
||||
"/sbin/ldconfig": "glibc",
|
||||
"/usr/bin/containerd-shim-runc-v2": "containerd-extras",
|
||||
"jre":"openjdk11"
|
||||
"jre": "openjdk11"
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
|
|
@ -571,6 +572,7 @@ class constants(object):
|
|||
def storeScriptsToCopy(key, val):
|
||||
constants.CopyToSandboxDict[key] = deepcopy(val)
|
||||
|
||||
@staticmethod
|
||||
def checkIfHostRpmNotUsable():
|
||||
if constants.hostRpmIsNotUsable >= 0:
|
||||
return constants.hostRpmIsNotUsable
|
||||
|
|
@ -594,9 +596,16 @@ class constants(object):
|
|||
|
||||
return constants.hostRpmIsNotUsable
|
||||
|
||||
@staticmethod
|
||||
def enable_fips_in_make_check():
|
||||
constants.listMakeCheckRPMPkgtoInstall.append("openssl-fips-provider")
|
||||
|
||||
@staticmethod
|
||||
def set_resume_build(val):
|
||||
if val:
|
||||
constants.resume_build = True
|
||||
|
||||
@staticmethod
|
||||
def set_rebuild(val):
|
||||
if val:
|
||||
constants.rebuild = True
|
||||
|
|
|
|||
|
|
@ -1,363 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
"""
|
||||
Taken from
|
||||
https://github.com/pypa/distutils/blob/main/distutils/version.py
|
||||
distutils/version.py
|
||||
|
||||
Implements multiple version numbering conventions for the
|
||||
Python Module Distribution Utilities.
|
||||
|
||||
Provides classes to represent module version numbers (one class for
|
||||
each style of version numbering). There are currently two such classes
|
||||
implemented: StrictVersion and LooseVersion.
|
||||
|
||||
Every version number class implements the following interface:
|
||||
* the 'parse' method takes a string and parses it to some internal
|
||||
representation; if the string is an invalid version number,
|
||||
'parse' raises a ValueError exception
|
||||
* the class constructor takes an optional string argument which,
|
||||
if supplied, is passed to 'parse'
|
||||
* __str__ reconstructs the string that was passed to 'parse' (or
|
||||
an equivalent string -- ie. one that will generate an equivalent
|
||||
version number instance)
|
||||
* __repr__ generates Python code to recreate the version number instance
|
||||
* _cmp compares the current instance with either another instance
|
||||
of the same class or a string (which will be parsed to an instance
|
||||
of the same class, thus must follow the same rules)
|
||||
"""
|
||||
|
||||
import re
|
||||
import warnings
|
||||
import contextlib
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def suppress_known_deprecation():
|
||||
with warnings.catch_warnings(record=True) as ctx:
|
||||
warnings.filterwarnings(
|
||||
action="default",
|
||||
category=DeprecationWarning,
|
||||
message="distutils Version classes are deprecated.",
|
||||
)
|
||||
yield ctx
|
||||
|
||||
|
||||
class Version:
|
||||
"""Abstract base class for version numbering classes. Just provides
|
||||
constructor (__init__) and reproducer (__repr__), because those
|
||||
seem to be the same for all version numbering classes; and route
|
||||
rich comparisons to _cmp.
|
||||
"""
|
||||
|
||||
def __init__(self, vstring=None):
|
||||
if vstring:
|
||||
self.parse(vstring)
|
||||
warnings.warn(
|
||||
"distutils Version classes are deprecated. "
|
||||
"Use packaging.version instead.",
|
||||
DeprecationWarning,
|
||||
stacklevel=2,
|
||||
)
|
||||
|
||||
def __repr__(self):
|
||||
return "{} ('{}')".format(self.__class__.__name__, str(self))
|
||||
|
||||
def __eq__(self, other):
|
||||
c = self._cmp(other)
|
||||
if c is NotImplemented:
|
||||
return c
|
||||
return c == 0
|
||||
|
||||
def __lt__(self, other):
|
||||
c = self._cmp(other)
|
||||
if c is NotImplemented:
|
||||
return c
|
||||
return c < 0
|
||||
|
||||
def __le__(self, other):
|
||||
c = self._cmp(other)
|
||||
if c is NotImplemented:
|
||||
return c
|
||||
return c <= 0
|
||||
|
||||
def __gt__(self, other):
|
||||
c = self._cmp(other)
|
||||
if c is NotImplemented:
|
||||
return c
|
||||
return c > 0
|
||||
|
||||
def __ge__(self, other):
|
||||
c = self._cmp(other)
|
||||
if c is NotImplemented:
|
||||
return c
|
||||
return c >= 0
|
||||
|
||||
|
||||
# Interface for version-number classes -- must be implemented
|
||||
# by the following classes (the concrete ones -- Version should
|
||||
# be treated as an abstract class).
|
||||
# __init__ (string) - create and take same action as 'parse'
|
||||
# (string parameter is optional)
|
||||
# parse (string) - convert a string representation to whatever
|
||||
# internal representation is appropriate for
|
||||
# this style of version numbering
|
||||
# __str__ (self) - convert back to a string; should be very similar
|
||||
# (if not identical to) the string supplied to parse
|
||||
# __repr__ (self) - generate Python code to recreate
|
||||
# the instance
|
||||
# _cmp (self, other) - compare two version numbers ('other' may
|
||||
# be an unparsed version string, or another
|
||||
# instance of your version class)
|
||||
|
||||
|
||||
class StrictVersion(Version):
|
||||
|
||||
"""Version numbering for anal retentives and software idealists.
|
||||
Implements the standard interface for version number classes as
|
||||
described above. A version number consists of two or three
|
||||
dot-separated numeric components, with an optional "pre-release" tag
|
||||
on the end. The pre-release tag consists of the letter 'a' or 'b'
|
||||
followed by a number. If the numeric components of two version
|
||||
numbers are equal, then one with a pre-release tag will always
|
||||
be deemed earlier (lesser) than one without.
|
||||
|
||||
The following are valid version numbers (shown in the order that
|
||||
would be obtained by sorting according to the supplied cmp function):
|
||||
|
||||
0.4 0.4.0 (these two are equivalent)
|
||||
0.4.1
|
||||
0.5a1
|
||||
0.5b3
|
||||
0.5
|
||||
0.9.6
|
||||
1.0
|
||||
1.0.4a3
|
||||
1.0.4b1
|
||||
1.0.4
|
||||
|
||||
The following are examples of invalid version numbers:
|
||||
|
||||
1
|
||||
2.7.2.2
|
||||
1.3.a4
|
||||
1.3pl1
|
||||
1.3c4
|
||||
|
||||
The rationale for this version numbering system will be explained
|
||||
in the distutils documentation.
|
||||
"""
|
||||
|
||||
version_re = re.compile(
|
||||
r"^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$", re.VERBOSE | re.ASCII
|
||||
)
|
||||
|
||||
def parse(self, vstring):
|
||||
match = self.version_re.match(vstring)
|
||||
if not match:
|
||||
raise ValueError("invalid version number '%s'" % vstring)
|
||||
|
||||
(major, minor, patch, prerelease, prerelease_num) = match.group(
|
||||
1, 2, 4, 5, 6
|
||||
)
|
||||
|
||||
if patch:
|
||||
self.version = tuple(map(int, [major, minor, patch]))
|
||||
else:
|
||||
self.version = tuple(map(int, [major, minor])) + (0,)
|
||||
|
||||
if prerelease:
|
||||
self.prerelease = (prerelease[0], int(prerelease_num))
|
||||
else:
|
||||
self.prerelease = None
|
||||
|
||||
def __str__(self):
|
||||
|
||||
if self.version[2] == 0:
|
||||
vstring = ".".join(map(str, self.version[0:2]))
|
||||
else:
|
||||
vstring = ".".join(map(str, self.version))
|
||||
|
||||
if self.prerelease:
|
||||
vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
|
||||
|
||||
return vstring
|
||||
|
||||
def _cmp(self, other): # noqa: C901
|
||||
if isinstance(other, str):
|
||||
with suppress_known_deprecation():
|
||||
other = StrictVersion(other)
|
||||
elif not isinstance(other, StrictVersion):
|
||||
return NotImplemented
|
||||
|
||||
if self.version != other.version:
|
||||
# numeric versions don't match
|
||||
# prerelease stuff doesn't matter
|
||||
if self.version < other.version:
|
||||
return -1
|
||||
else:
|
||||
return 1
|
||||
|
||||
# have to compare prerelease
|
||||
# case 1: neither has prerelease; they're equal
|
||||
# case 2: self has prerelease, other doesn't; other is greater
|
||||
# case 3: self doesn't have prerelease, other does: self is greater
|
||||
# case 4: both have prerelease: must compare them!
|
||||
|
||||
if not self.prerelease and not other.prerelease:
|
||||
return 0
|
||||
elif self.prerelease and not other.prerelease:
|
||||
return -1
|
||||
elif not self.prerelease and other.prerelease:
|
||||
return 1
|
||||
elif self.prerelease and other.prerelease:
|
||||
if self.prerelease == other.prerelease:
|
||||
return 0
|
||||
elif self.prerelease < other.prerelease:
|
||||
return -1
|
||||
else:
|
||||
return 1
|
||||
else:
|
||||
assert False, "never get here"
|
||||
|
||||
|
||||
# end class StrictVersion
|
||||
|
||||
|
||||
# The rules according to Greg Stein:
|
||||
# 1) a version number has 1 or more numbers separated by a period or by
|
||||
# sequences of letters. If only periods, then these are compared
|
||||
# left-to-right to determine an ordering.
|
||||
# 2) sequences of letters are part of the tuple for comparison and are
|
||||
# compared lexicographically
|
||||
# 3) recognize the numeric components may have leading zeroes
|
||||
#
|
||||
# The LooseVersion class below implements these rules: a version number
|
||||
# string is split up into a tuple of integer and string components, and
|
||||
# comparison is a simple tuple comparison. This means that version
|
||||
# numbers behave in a predictable and obvious way, but a way that might
|
||||
# not necessarily be how people *want* version numbers to behave. There
|
||||
# wouldn't be a problem if people could stick to purely numeric version
|
||||
# numbers: just split on period and compare the numbers as tuples.
|
||||
# However, people insist on putting letters into their version numbers;
|
||||
# the most common purpose seems to be:
|
||||
# - indicating a "pre-release" version
|
||||
# ('alpha', 'beta', 'a', 'b', 'pre', 'p')
|
||||
# - indicating a post-release patch ('p', 'pl', 'patch')
|
||||
# but of course this can't cover all version number schemes, and there's
|
||||
# no way to know what a programmer means without asking him.
|
||||
#
|
||||
# The problem is what to do with letters (and other non-numeric
|
||||
# characters) in a version number. The current implementation does the
|
||||
# obvious and predictable thing: keep them as strings and compare
|
||||
# lexically within a tuple comparison. This has the desired effect if
|
||||
# an appended letter sequence implies something "post-release":
|
||||
# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
|
||||
#
|
||||
# However, if letters in a version number imply a pre-release version,
|
||||
# the "obvious" thing isn't correct. Eg. you would expect that
|
||||
# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
|
||||
# implemented here, this just isn't so.
|
||||
#
|
||||
# Two possible solutions come to mind. The first is to tie the
|
||||
# comparison algorithm to a particular set of semantic rules, as has
|
||||
# been done in the StrictVersion class above. This works great as long
|
||||
# as everyone can go along with bondage and discipline. Hopefully a
|
||||
# (large) subset of Python module programmers will agree that the
|
||||
# particular flavour of bondage and discipline provided by StrictVersion
|
||||
# provides enough benefit to be worth using, and will submit their
|
||||
# version numbering scheme to its domination. The free-thinking
|
||||
# anarchists in the lot will never give in, though, and something needs
|
||||
# to be done to accommodate them.
|
||||
#
|
||||
# Perhaps a "moderately strict" version class could be implemented that
|
||||
# lets almost anything slide (syntactically), and makes some heuristic
|
||||
# assumptions about non-digits in version number strings. This could
|
||||
# sink into special-case-hell, though; if I was as talented and
|
||||
# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
|
||||
# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
|
||||
# just as happy dealing with things like "2g6" and "1.13++". I don't
|
||||
# think I'm smart enough to do it right though.
|
||||
#
|
||||
# In any case, I've coded the test suite for this module (see
|
||||
# ../test/test_version.py) specifically to fail on things like comparing
|
||||
# "1.2a2" and "1.2". That's not because the *code* is doing anything
|
||||
# wrong, it's because the simple, obvious design doesn't match my
|
||||
# complicated, hairy expectations for real-world version numbers. It
|
||||
# would be a snap to fix the test suite to say, "Yep, LooseVersion does
|
||||
# the Right Thing" (ie. the code matches the conception). But I'd rather
|
||||
# have a conception that matches common notions about version numbers.
|
||||
|
||||
|
||||
class LooseVersion(Version):
|
||||
|
||||
"""Version numbering for anarchists and software realists.
|
||||
Implements the standard interface for version number classes as
|
||||
described above. A version number consists of a series of numbers,
|
||||
separated by either periods or strings of letters. When comparing
|
||||
version numbers, the numeric components will be compared
|
||||
numerically, and the alphabetic components lexically. The following
|
||||
are all valid version numbers, in no particular order:
|
||||
|
||||
1.5.1
|
||||
1.5.2b2
|
||||
161
|
||||
3.10a
|
||||
8.02
|
||||
3.4j
|
||||
1996.07.12
|
||||
3.2.pl0
|
||||
3.1.1.6
|
||||
2g6
|
||||
11g
|
||||
0.960923
|
||||
2.2beta29
|
||||
1.13++
|
||||
5.5.kw
|
||||
2.0b1pl0
|
||||
|
||||
In fact, there is no such thing as an invalid version number under
|
||||
this scheme; the rules for comparison are simple and predictable,
|
||||
but may not always give the results you want (for some definition
|
||||
of "want").
|
||||
"""
|
||||
|
||||
component_re = re.compile(r"(\d+ | [a-z]+ | \.)", re.VERBOSE)
|
||||
|
||||
def parse(self, vstring):
|
||||
# I've given up on thinking I can reconstruct the version string
|
||||
# from the parsed tuple -- so I just store the string here for
|
||||
# use by __str__
|
||||
self.vstring = vstring
|
||||
components = [
|
||||
x for x in self.component_re.split(vstring) if x and x != "."
|
||||
]
|
||||
for i, obj in enumerate(components):
|
||||
try:
|
||||
components[i] = int(obj)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
self.version = components
|
||||
|
||||
def __str__(self):
|
||||
return self.vstring
|
||||
|
||||
def __repr__(self):
|
||||
return "LooseVersion ('%s')" % str(self)
|
||||
|
||||
def _cmp(self, other):
|
||||
if isinstance(other, str):
|
||||
other = LooseVersion(other)
|
||||
elif not isinstance(other, LooseVersion):
|
||||
return NotImplemented
|
||||
|
||||
if self.version == other.version:
|
||||
return 0
|
||||
if self.version < other.version:
|
||||
return -1
|
||||
if self.version > other.version:
|
||||
return 1
|
||||
|
||||
|
||||
# end class LooseVersion
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import json
|
||||
import collections
|
||||
|
||||
|
||||
class JsonWrapper(object):
|
||||
def __init__(self, filename):
|
||||
self.filename = filename
|
||||
self.data = None
|
||||
|
||||
def read(self):
|
||||
try:
|
||||
with open(self.filename) as json_data:
|
||||
self.data = json.load(
|
||||
json_data, object_pairs_hook=collections.OrderedDict
|
||||
)
|
||||
except Exception:
|
||||
raise Exception(f"Unable to read {self.filename}")
|
||||
return self.data
|
||||
|
||||
def write(self, data):
|
||||
self.data = data
|
||||
try:
|
||||
with open(self.filename, "w") as outfile:
|
||||
json.dump(data, outfile)
|
||||
except Exception:
|
||||
raise Exception(f"Unable to write {self.filename}")
|
||||
|
|
@ -0,0 +1,103 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import re
|
||||
|
||||
from functools import total_ordering
|
||||
|
||||
|
||||
def split_evr(evr):
|
||||
"""
|
||||
Splits EVR string into (epoch, version, release).
|
||||
"""
|
||||
if ":" in evr:
|
||||
epoch, rest = evr.split(":", 1)
|
||||
else:
|
||||
epoch = "0"
|
||||
rest = evr
|
||||
if "-" in rest:
|
||||
version, release = rest.rsplit("-", 1)
|
||||
else:
|
||||
version, release = rest, ""
|
||||
return epoch, version, release
|
||||
|
||||
|
||||
def rpmvercmp_part(a, b):
|
||||
"""
|
||||
Compares individual version or release strings using RPM logic.
|
||||
"""
|
||||
|
||||
def split_segments(s):
|
||||
return re.findall(r"\d+|[a-zA-Z]+|[^a-zA-Z\d]+", s)
|
||||
|
||||
sa = split_segments(a)
|
||||
sb = split_segments(b)
|
||||
|
||||
while sa or sb:
|
||||
x = sa.pop(0) if sa else ""
|
||||
y = sb.pop(0) if sb else ""
|
||||
|
||||
if x == y:
|
||||
continue
|
||||
|
||||
if x.isdigit():
|
||||
if not y.isdigit():
|
||||
return 1
|
||||
return (int(x) > int(y)) - (int(x) < int(y))
|
||||
if y.isdigit():
|
||||
return -1
|
||||
|
||||
return (x > y) - (x < y)
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
@total_ordering
|
||||
class LooseVersion:
|
||||
"""
|
||||
RPM-aware LooseVersion class that compares EVR (epoch:version-release).
|
||||
"""
|
||||
|
||||
def __init__(self, vstring):
|
||||
self.vstring = vstring
|
||||
self.epoch, self.version, self.release = split_evr(vstring)
|
||||
|
||||
def __eq__(self, other):
|
||||
return (
|
||||
int(self.epoch) == int(other.epoch)
|
||||
and rpmvercmp_part(self.version, other.version) == 0
|
||||
and rpmvercmp_part(self.release, other.release) == 0
|
||||
)
|
||||
|
||||
def __lt__(self, other):
|
||||
if int(self.epoch) != int(other.epoch):
|
||||
return int(self.epoch) < int(other.epoch)
|
||||
ver_cmp = rpmvercmp_part(self.version, other.version)
|
||||
if ver_cmp != 0:
|
||||
return ver_cmp < 0
|
||||
rel_cmp = rpmvercmp_part(self.release, other.release)
|
||||
return rel_cmp < 0
|
||||
|
||||
def __repr__(self):
|
||||
return f"LooseVersion('{self.vstring}')"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
versions = [
|
||||
"1:1.2.3-1",
|
||||
"0:1.2.3-2",
|
||||
"1.2.3-1",
|
||||
"1:1.2.4-0",
|
||||
"2:1.0-1",
|
||||
"1.0-1",
|
||||
"1.0a-2",
|
||||
"1.10.a-2",
|
||||
]
|
||||
sorted_versions = sorted(LooseVersion(v) for v in versions)
|
||||
for v in sorted_versions:
|
||||
print(v)
|
||||
|
||||
x = "1.26.2-4.ph5"
|
||||
y = "1:1.26.2-4.ph5"
|
||||
assert not LooseVersion(x) > LooseVersion(y)
|
||||
assert not LooseVersion(x) == LooseVersion(y)
|
||||
assert LooseVersion(x) < LooseVersion(y)
|
||||
Loading…
Reference in New Issue