@@ -21,7 +21,7 @@ Requires:       jansson

 Requires:       likewise-open >= 6.2.9

 Requires:       netmgmt

 Requires:       systemd

-Requires:       tdnf >= 2.2.0

+Requires:       tdnf >= 2.0.0

 Requires:       lightwave-client-libs

 Requires:       %{name}-libs = %{version}-%{release}

 Requires:       shadow

@@ -44,5 +44,4 @@ class ChrootUtils(object):

         if not returnVal:

             self.logger.error("Unable to destroy chroot:" + chrootID + ".Unknown error.")

             return False

-        self.logger.info("Successfully destroyed chroot:" + chrootID)

         return True

@@ -101,19 +101,19 @@ def buildPackagesList(csvFilename):

         listPackages.sort()

         for package in listPackages:

             name = package

-            version = SPECS.getData().getVersion(package)

-            packagelicense = SPECS.getData().getLicense(package)

-            listPatches = SPECS.getData().getPatches(package)

-            url = SPECS.getData().getURL(package)

-            listSourceNames = SPECS.getData().getSources(package)

-            sources = ""

-            patches = ""

-            if listPatches is not None:

-                patches = " ".join(listPatches)

-            if listSourceNames is not None:

-                sources = " ".join(listSourceNames)

-            csvFile.write(name + "," + version + "," + packagelicense + "," + url + "," +

-                          sources + "," + patches + "\n")

+            for version in SPECS.getData().getVersions(package):

+                packagelicense = SPECS.getData().getLicense(package, version)

+                listPatches = SPECS.getData().getPatches(package, version)

+                url = SPECS.getData().getURL(package, version)

+                listSourceNames = SPECS.getData().getSources(package, version)

+                sources = ""

+                patches = ""

+                if listPatches is not None:

+                    patches = " ".join(listPatches)

+                if listSourceNames is not None:

+                    sources = " ".join(listSourceNames)

+                csvFile.write(name + "," + version + "," + packagelicense + "," + url + "," +

+                            sources + "," + patches + "\n")

 def readBlackListPackages(pkgBlackListFile):

     blackListPkgs = []

@@ -139,39 +139,39 @@ def buildSourcesList(yamlDir, blackListPkgs, logger, singleFile=True):

         if package in blackListPkgs:

             continue

         ossname = package

-        ossversion = SPECS.getData().getVersion(package)

-        modified = False

-        listPatches = SPECS.getData().getPatches(package)

-        if listPatches:

-            modified = True

-        url = SPECS.getData().getSourceURL(package)

-        if url is None:

-            url = SPECS.getData().getURL(package)

-

-        sourceName = None

-        listSourceNames = SPECS.getData().getSources(package)

-        if listSourceNames:

-            sourceName = listSourceNames[0]

-            sha1 = SPECS.getData().getSHA1(package, sourceName)

-            if sha1 is not None:

-                PullSources.get(package, sourceName, sha1, yamlSourceDir,

-                                constants.pullsourcesConfig, logger)

-

-        if not singleFile:

-            yamlFile = open(yamlSourceDir + "/" + ossname + "-" + ossversion + ".yaml", "w")

-        yamlFile.write("vmwsource:" + ossname + ":" + ossversion + ":\n")

-        yamlFile.write("  repository: VMWsource\n")

-        yamlFile.write("  name: '" + ossname + "'\n")

-        yamlFile.write("  version: '" + ossversion + "'\n")

-        yamlFile.write("  url: " + str(url) + "\n")

-        yamlFile.write("  license: UNKNOWN\n")

-        if sourceName is not None:

-            yamlFile.write("  vmwsource-distribution: " + str(sourceName) + "\n")

-        if modified:

-            yamlFile.write("  modified: true\n")

-        yamlFile.write("\n")

-        if not singleFile:

-            yamlFile.close()

+        for version in SPECS.getData().getVersions(package):

+            modified = False

+            listPatches = SPECS.getData().getPatches(package, version)

+            if listPatches:

+                modified = True

+            url = SPECS.getData().getSourceURL(package, version)

+            if url is None:

+                url = SPECS.getData().getURL(package, version)

+

+            sourceName = None

+            listSourceNames = SPECS.getData().getSources(package, version)

+            if listSourceNames:

+                sourceName = listSourceNames[0]

+                sha1 = SPECS.getData().getSHA1(package, version, sourceName)

+                if sha1 is not None:

+                    PullSources.get(package, sourceName, sha1, yamlSourceDir,

+                                    constants.pullsourcesConfig, logger)

+

+            if not singleFile:

+                yamlFile = open(yamlSourceDir + "/" + ossname + "-" + version + ".yaml", "w")

+            yamlFile.write("vmwsource:" + ossname + ":" + version + ":\n")

+            yamlFile.write("  repository: VMWsource\n")

+            yamlFile.write("  name: '" + ossname + "'\n")

+            yamlFile.write("  version: '" + ossversion + "'\n")

+            yamlFile.write("  url: " + str(url) + "\n")

+            yamlFile.write("  license: UNKNOWN\n")

+            if sourceName is not None:

+                yamlFile.write("  vmwsource-distribution: " + str(sourceName) + "\n")

+            if modified:

+                yamlFile.write("  modified: true\n")

+            yamlFile.write("\n")

+            if not singleFile:

+                yamlFile.close()

     if singleFile:

         yamlFile.close()

@@ -192,7 +192,7 @@ def buildSRPMList(srpmPath, yamlDir, blackListPkgs, logger, singleFile=True):

             continue

         ossname = package

         ossversion = SPECS.getData().getVersion(package)

-        ossrelease = SPECS.getData().getRelease(package)

+        ossrelease = SPECS.getData().getRelease(package, ossversion)

         listFoundSRPMFiles = cmdUtils.findFile(ossname + "-" + ossversion + "-" + ossrelease

                                                + ".src.rpm",

@@ -4,6 +4,7 @@ from collections import OrderedDict

 from Logger import Logger

 from constants import constants

 from SpecData import SPECS

+from StringUtils import StringUtils

 def removeDuplicateEntries(myList):

     myListCopy = list(OrderedDict.fromkeys(myList))

@@ -27,10 +28,9 @@ class PackageBuildDataGenerator(object):

         self.__sortedBuildDependencyGraph = {}

     def getPackageBuildData(self, listPackages):

-        basePackages = set()

+        basePackages = []

         for pkg in listPackages:

-            basePackage = SPECS.getData().getSpecName(pkg)

-            basePackages.add(basePackage)

+            basePackages.append(SPECS.getData().getBasePkg(pkg))

         self._readDependencyGraphAndCyclesForGivenPackages(basePackages)

         self._getSortedBuildOrderList()

@@ -46,7 +46,7 @@ class PackageBuildDataGenerator(object):

         sortListForPkg = []

         for p in runTimeDepPkgList:

-            basePkg = SPECS.getData().getSpecName(p)

+            basePkg = SPECS.getData().getBasePkg(p)

             for bPkg in self.__sortedBuildDependencyGraph[basePkg]:

                 if bPkg not in sortListForPkg:

                     sortListForPkg.append(bPkg)

@@ -118,7 +118,7 @@ class PackageBuildDataGenerator(object):

         self.logger.info("Removing duplicates in sorted list")

         sortedList = removeDuplicateEntries(sortedList)

-        self.logger.info("Sorted list:")

+        self.logger.info("Sorted list: ")

         self.logger.info(sortedList)

         self.__sortedPackageList = sortedList

@@ -129,28 +129,25 @@ class PackageBuildDataGenerator(object):

             addBuildTimeGraph = False

         if basePackage in self.__runTimeDependencyGraph:

             addRunTimeGraph = False

-

+        

         nextPackagesToConstructGraph = set()

         if addBuildTimeGraph:

-            dependentRpmPackages = SPECS.getData().getBuildRequiresForPackage(basePackage)

+            dependentRpmPackages = SPECS.getData().getBuildRequiresForPkg(basePackage)

             dependentPackages = set()

-            for rpmPkg in dependentRpmPackages:

-                basePkg = SPECS.getData().getSpecName(rpmPkg.package)

-                dependentPackages.add(basePkg)

+            for dependentPkg in dependentRpmPackages:

+                dependentPackages.add(SPECS.getData().getBasePkg(dependentPkg))

             self.__buildDependencyGraph[basePackage] = dependentPackages

             nextPackagesToConstructGraph.update(dependentPackages)

         if addRunTimeGraph:

-            rpmPackages = SPECS.getData().getPackages(basePackage)

+            packageName, packageVersion = StringUtils.splitPackageNameAndVersion(basePackage)

+            rpmPackages = SPECS.getData().getPackages(packageName, packageVersion)

             dependentPackages = set()

-            dependentRpmPackagesNames= set()

             for rpmPkg in rpmPackages:

-                dependentRpmPackages = SPECS.getData().getRequiresAllForPackage(rpmPkg)

-                for pkgName in dependentRpmPackages:

-                    dependentRpmPackagesNames.add(pkgName.package)

-                self.__runTimeDependencyGraph[rpmPkg] = copy.copy(dependentRpmPackagesNames)

-                for pkg in dependentRpmPackagesNames:

-                    dependentPackages.add(SPECS.getData().getSpecName(pkg))

+                dependentRpmPackages = SPECS.getData().getRequiresAllForPackage(rpmPkg, packageVersion)

+                self.__runTimeDependencyGraph[rpmPkg+"-"+packageVersion] = copy.copy(set(dependentRpmPackages))

+                for pkg in dependentRpmPackages:

+                    dependentPackages.add(SPECS.getData().getBasePkg(pkg))

             nextPackagesToConstructGraph.update(dependentPackages)

         for pkg in nextPackagesToConstructGraph:

@@ -9,6 +9,7 @@ from constants import constants

 from SpecData import SPECS

 import docker

 from distutils.version import LooseVersion

+from StringUtils import StringUtils

 class PackageBuilderBase(object):

     def __init__(self, mapPackageToCycles, pkgBuildType):

@@ -17,46 +18,50 @@ class PackageBuilderBase(object):

         self.logPath = None

         self.logger = None

         self.package = None

+        self.version = None

         self.mapPackageToCycles = mapPackageToCycles

         self.listNodepsPackages = ["glibc", "gmp", "zlib", "file", "binutils", "mpfr",

                                    "mpc", "gcc", "ncurses", "util-linux", "groff", "perl",

                                    "texinfo", "rpm", "openssl", "go"]

         self.pkgBuildType = pkgBuildType

-    def buildPackageFunction(self, package):

-        self._buildPackagePrepareFunction(package)

-        versions = self.getNumOfVersions(package)

-        if(versions < 1):

-            raise Exception("No package exists")

-        for version in range(0, versions):

-            try:

-                self._buildPackage(version)

-            except Exception as e:

-                # TODO: self.logger might be None

-                self.logger.exception(e)

-                raise e

+    def buildPackageFunction(self, pkg):

+        packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

+        #do not build if RPM is already built

+        #test only if the package is in the testForceRPMS with rpmCheck

+        #build only if the package is not in the testForceRPMS with rpmCheck

+        if self._checkIfPackageIsAlreadyBuilt(packageName, packageVersion):

+            if not constants.rpmCheck:

+                return

+            elif constants.rpmCheck and self.package not in constants.testForceRPMS:

+                return

-    def _buildPackagePrepareFunction(self, package):

+        self._buildPackagePrepareFunction(packageName, packageVersion)

+        try:

+            self._buildPackage()

+        except Exception as e:

+            # TODO: self.logger might be None

+            self.logger.exception(e)

+            raise e

+

+    def _buildPackagePrepareFunction(self, package, version):

         self.package = package

-        self.logName = "build-" + package

-        self.logPath = constants.logPath + "/build-" + package

+        self.version = version

+        self.logName = "build-" + package + "-" + version

+        self.logPath = constants.logPath + "/" + package + "-" + version

         if not os.path.isdir(self.logPath):

             cmdUtils = CommandUtils()

             cmdUtils.runCommandInShell("mkdir -p " + self.logPath)

         self.logger = Logger.getLogger(self.logName, self.logPath)

-    def _findPackageNameFromRPMFile(self, rpmfile):

+    def _findPackageNameAndVersionFromRPMFile(self, rpmfile):

         rpmfile = os.path.basename(rpmfile)

         releaseindex = rpmfile.rfind("-")

         if releaseindex == -1:

             self.logger.error("Invalid rpm file:" + rpmfile)

             return None

-        versionindex = rpmfile[0:releaseindex].rfind("-")

-        if versionindex == -1:

-            self.logger.error("Invalid rpm file:" + rpmfile)

-            return None

-        packageName = rpmfile[0:versionindex]

-        return packageName

+        pkg = rpmfile[0:releaseindex]

+        return pkg

     def _findInstalledPackages(self, instanceID):

         pkgUtils = PackageUtils(self.logName, self.logPath)

@@ -66,40 +71,45 @@ class PackageBuilderBase(object):

             listInstalledRPMs = pkgUtils.findInstalledRPMPackagesInContainer(instanceID)

         listInstalledPackages = []

         for installedRPM in listInstalledRPMs:

-            packageName = self._findPackageNameFromRPMFile(installedRPM)

-            if packageName is not None:

-                listInstalledPackages.append(packageName)

+            pkg = self._findPackageNameAndVersionFromRPMFile(installedRPM)

+            if pkg is not None:

+                listInstalledPackages.append(pkg)

         return listInstalledPackages, listInstalledRPMs

-    def _checkIfPackageIsAlreadyBuilt(self, index=0):

-        basePkg = SPECS.getData().getSpecName(self.package)

-        listRPMPackages = SPECS.getData().getRPMPackages(basePkg, index)

+    def _checkIfPackageIsAlreadyBuilt(self, package, version):

+        basePkg = SPECS.getData().getSpecName(package)

+        listRPMPackages = SPECS.getData().getRPMPackages(basePkg, version)

         packageIsAlreadyBuilt = True

-        pkgUtils = PackageUtils(self.logName, self.logPath)

+        pkgUtils = PackageUtils()

         for pkg in listRPMPackages:

-            if pkgUtils.findRPMFileForGivenPackage(pkg,"*", index) is None:

+            if pkgUtils.findRPMFileForGivenPackage(pkg, version) is None:

                 packageIsAlreadyBuilt = False

                 break

         return packageIsAlreadyBuilt

-    def _findRunTimeRequiredRPMPackages(self, rpmPackage, index=0):

-        return SPECS.getData().getRequiresForPackage(rpmPackage, index)

+    def _findRunTimeRequiredRPMPackages(self, rpmPackage, version):

+        return SPECS.getData().getRequiresForPackage(rpmPackage, version)

-    def _findBuildTimeRequiredPackages(self, index=0):

-        return SPECS.getData().getBuildRequiresForPackage(self.package, index)

+    def _findBuildTimeRequiredPackages(self):

+        return SPECS.getData().getBuildRequiresForPackage(self.package, self.version)

-    def _findBuildTimeCheckRequiredPackages(self, index=0):

-        return SPECS.getData().getCheckBuildRequiresForPackage(self.package, index)

+    def _findBuildTimeCheckRequiredPackages(self):

+        return SPECS.getData().getCheckBuildRequiresForPackage(self.package, self.version)

     def _installPackage(self, pkgUtils, package,packageVersion, instanceID, destLogPath,

                         listInstalledPackages, listInstalledRPMs):

-        specificRPM = os.path.basename(pkgUtils.findRPMFileForGivenPackage(package,packageVersion)).replace(".rpm", "")

-        if package in listInstalledPackages:

+        rpmfile = pkgUtils.findRPMFileForGivenPackage(package,packageVersion);

+        if rpmfile is None:

+            self.logger.error("No rpm file found for package: " + package + "-" + packageVersion)

+            raise Exception("Missing rpm file")

+        specificRPM = os.path.basename(rpmfile.replace(".rpm", ""))

+        pkg = package+"-"+packageVersion

+        if pkg in listInstalledPackages:

                 return

         # mark it as installed -  to avoid cyclic recursion

-        listInstalledPackages.append(package)

+        listInstalledPackages.append(pkg)

         listInstalledRPMs.append(specificRPM)

-        self._installDependentRunTimePackages(pkgUtils, package, instanceID, destLogPath,

+        self._installDependentRunTimePackages(pkgUtils, package, packageVersion, instanceID, destLogPath,

                                               listInstalledPackages, listInstalledRPMs)

         noDeps = False

         if (package in self.mapPackageToCycles or

@@ -111,37 +121,41 @@ class PackageBuilderBase(object):

         elif self.pkgBuildType == "container":

             pkgUtils.prepRPMforInstallInContainer(package,packageVersion, instanceID, noDeps, destLogPath)

-    def _installDependentRunTimePackages(self, pkgUtils, package, instanceID, destLogPath,

+    def _installDependentRunTimePackages(self, pkgUtils, package, packageVersion, instanceID, destLogPath,

                                          listInstalledPackages, listInstalledRPMs):

-        listRunTimeDependentPackages = self._findRunTimeRequiredRPMPackages(package)

+        listRunTimeDependentPackages = self._findRunTimeRequiredRPMPackages(package, packageVersion)

         if listRunTimeDependentPackages:

             for pkg in listRunTimeDependentPackages:

                 if pkg in self.mapPackageToCycles:

                     continue

+                packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

                 latestPkgRPM = os.path.basename(

-                    pkgUtils.findRPMFileForGivenPackage(pkg)).replace(".rpm", "")

+                    pkgUtils.findRPMFileForGivenPackage(packageName, packageVersion)).replace(".rpm", "")

                 if pkg in listInstalledPackages and latestPkgRPM in listInstalledRPMs:

                     continue

-                self._installPackage(pkgUtils, pkg,"*", instanceID, destLogPath,listInstalledPackages, listInstalledRPMs)

+                self._installPackage(pkgUtils, packageName,packageVersion, instanceID, destLogPath,listInstalledPackages, listInstalledRPMs)

-    def _findDependentPackagesAndInstalledRPM(self, instanceID, index=0):

+    def _findDependentPackagesAndInstalledRPM(self, instanceID):

         listInstalledPackages, listInstalledRPMs = self._findInstalledPackages(instanceID)

         self.logger.info(listInstalledPackages)

-        listDependentPackages = self._findBuildTimeRequiredPackages(index)

+        listDependentPackages = self._findBuildTimeRequiredPackages()

         listTestPackages=[]

         if constants.rpmCheck and self.package in constants.testForceRPMS:

-            listDependentPackages.extend(self._findBuildTimeCheckRequiredPackages(index))

-            testPackages = (set(constants.listMakeCheckRPMPkgtoInstall) -

+            # One time optimization

+            if constants.listMakeCheckRPMPkgWithVersionstoInstall is None:

+                constants.listMakeCheckRPMPkgWithVersionstoInstalli=[]

+                for package in constants.listMakeCheckRPMPkgtoInstall:

+                    version = SPECS.getData().getHighestVersion(package)

+                    constants.listMakeCheckRPMPkgWithVersionstoInstall.append(package+"-"+version)

+

+            listDependentPackages.extend(self._findBuildTimeCheckRequiredPackages())

+            testPackages = (set(constants.listMakeCheckRPMPkgWithVersionstoInstall) -

                             set(listInstalledPackages) -

-                            set([self.package]))

+                            set([self.package+"-"+self.version]))

             listTestPackages=list(set(testPackages))

             listDependentPackages = list(set(listDependentPackages))

         return listDependentPackages, listTestPackages, listInstalledPackages, listInstalledRPMs

-    @staticmethod

-    def getNumOfVersions(package):

-        return SPECS.getData().getNumberOfVersions(package)

-

 class PackageBuilderContainer(PackageBuilderBase):

     def __init__(self, mapPackageToCycles, pkgBuildType):

         self.buildContainerImage = "photon_build_container:latest"

@@ -149,11 +163,11 @@ class PackageBuilderContainer(PackageBuilderBase):

         PackageBuilderBase.__init__(self, mapPackageToCycles, pkgBuildType)

-    def _prepareBuildContainer(self, containerTaskName, packageName,

+    def _prepareBuildContainer(self, containerTaskName, packageName, packageVersion,

                                isToolChainPackage=False):

         # Prepare an empty chroot environment to let docker use the BUILD folder.

         # This avoids docker using overlayFS which will cause make check failure.

-        chrootName = "build-" + packageName

+        chrootName = packageName + "-" + packageVersion

         chrUtils = ChrootUtils(self.logName, self.logPath)

         returnVal, chrootID = chrUtils.createChroot(chrootName)

         if not returnVal:

@@ -217,18 +231,7 @@ class PackageBuilderContainer(PackageBuilderBase):

             raise e

         return containerID, chrootID

-    def _buildPackage(self, index=0):

-        #do not build if RPM is already built

-        #test only if the package is in the testForceRPMS with rpmCheck

-        #build only if the package is not in the testForceRPMS with rpmCheck

-        if self._checkIfPackageIsAlreadyBuilt(index):

-            if not constants.rpmCheck:

-                self.logger.info("Skipping building the package:" + self.package)

-                return

-            elif constants.rpmCheck and self.package not in constants.testForceRPMS:

-                self.logger.info("Skipping testing the package:" + self.package)

-                return

-

+    def _buildPackage(self):

         #should initialize a logger based on package name

         containerTaskName = "build-" + self.package

         containerID = None

@@ -239,7 +242,7 @@ class PackageBuilderContainer(PackageBuilderBase):

         destLogPath = constants.logPath + "/build-" + self.package

         try:

             containerID, chrootID = self._prepareBuildContainer(

-                containerTaskName, self.package, isToolChainPackage)

+                containerTaskName, self.package, self.version, isToolChainPackage)

             tcUtils = ToolChainUtils(self.logName, self.logPath)

             if self.package in constants.perPackageToolChain:

@@ -250,7 +253,7 @@ class PackageBuilderContainer(PackageBuilderBase):

                     self.package)

             listDependentPackages, listTestPackages, listInstalledPackages, listInstalledRPMs = (

-                self._findDependentPackagesAndInstalledRPM(containerID, index))

+                self._findDependentPackagesAndInstalledRPM(containerID))

             pkgUtils = PackageUtils(self.logName, self.logPath)

             if listDependentPackages:

@@ -258,29 +261,29 @@ class PackageBuilderContainer(PackageBuilderBase):

                                  "Installing dependent packages..")

                 self.logger.info(listDependentPackages)

                 for pkg in listDependentPackages:

-                    properVersion=pkgUtils._getProperVersion(pkg.package,pkg)

-                    self._installPackage(pkgUtils, pkg.package,properVersion, containerID, destLogPath,listInstalledPackages, listInstalledRPMs)

+                    packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

+                    self._installPackage(pkgUtils, packageName, packageVersion, containerID, destLogPath,listInstalledPackages, listInstalledRPMs)

                 for pkg in listTestPackages:

+                    packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

                     flag = False

-                    for lineContent in listDependentPackages:

-                        if lineContent.package == pkg:

-                                properVersion=pkgUtils._getProperVersion(pkg,lineContent)

-                                self._installPackage(pkgUtils, pkg,properVersion, containerID, destLogPath,listInstalledPackages, listInstalledRPMs)

-                                flag = True

-                                break;

+                    for depPkg in listDependentPackages:

+                        depPackageName, depPackageVersion = StringUtils.splitPackageNameAndVersion(depPkg)

+                        if depPackageName == packageName:

+                            flag = True

+                            break;

                     if flag == False:

-                        self._installPackage(pkgUtils, pkg,"*", containerID, destLogPath,listInstalledPackages, listInstalledRPMs)

+                        self._installPackage(pkgUtils, packageName,packageVersion, containerID, destLogPath,listInstalledPackages, listInstalledRPMs)

                 pkgUtils.installRPMSInAOneShotInContainer(containerID, destLogPath)

                 self.logger.info("Finished installing the build time dependent packages....")

             self.logger.info("BuildContainer-buildPackage: Start building the package: " +

                              self.package)

-            pkgUtils.adjustGCCSpecsInContainer(self.package, containerID, destLogPath, index)

+            pkgUtils.adjustGCCSpecsInContainer(self.package, self.version, containerID, destLogPath)

             pkgUtils.buildRPMSForGivenPackageInContainer(

                 self.package,

+                self.version,

                 containerID,

-                destLogPath,

-                index)

+                destLogPath)

             self.logger.info("BuildContainer-buildPackage: Successfully built the package: " +

                              self.package)

         except Exception as e:

@@ -307,7 +310,7 @@ class PackageBuilderChroot(PackageBuilderBase):

     def _prepareBuildRoot(self):

         chrootID = None

-        chrootName = "build-" + self.package

+        chrootName = self.package + "-" + self.version

         try:

             chrUtils = ChrootUtils(self.logName, self.logPath)

             returnVal, chrootID = chrUtils.createChroot(chrootName)

@@ -315,7 +318,7 @@ class PackageBuilderChroot(PackageBuilderBase):

             if not returnVal:

                 raise Exception("Unable to prepare build root")

             tUtils = ToolChainUtils(self.logName, self.logPath)

-            tUtils.installToolChainRPMS(chrootID, self.package, self.logPath)

+            tUtils.installToolChainRPMS(self.package, self.version, chrootID, self.logPath)

         except Exception as e:

             if chrootID is not None:

                 self.logger.debug("Deleting chroot: " + chrootID)

@@ -323,48 +326,37 @@ class PackageBuilderChroot(PackageBuilderBase):

             raise e

         return chrootID

-    def _buildPackage(self, index=0):

-        #do not build if RPM is already built

-        #test only if the package is in the testForceRPMS with rpmCheck

-        #build only if the package is not in the testForceRPMS with rpmCheck

-        if self._checkIfPackageIsAlreadyBuilt(index):

-            if not constants.rpmCheck:

-                self.logger.info("Skipping building the package:" + self.package)

-                return

-            elif constants.rpmCheck and self.package not in constants.testForceRPMS:

-                self.logger.info("Skipping testing the package:" + self.package)

-                return

-

+    def _buildPackage(self):

         chrUtils = ChrootUtils(self.logName, self.logPath)

         chrootID = None

         try:

             chrootID = self._prepareBuildRoot()

             listDependentPackages, listTestPackages, listInstalledPackages, listInstalledRPMs = (

-                self._findDependentPackagesAndInstalledRPM(chrootID, index))

+                self._findDependentPackagesAndInstalledRPM(chrootID))

             pkgUtils = PackageUtils(self.logName, self.logPath)

             if listDependentPackages:

                 self.logger.info("Installing the build time dependent packages......")

                 for pkg in listDependentPackages:

-                    properVersion=pkgUtils._getProperVersion(pkg.package, pkg)

-                    self._installPackage(pkgUtils, pkg.package,properVersion, chrootID, self.logPath,listInstalledPackages, listInstalledRPMs)

+                    packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

+                    self._installPackage(pkgUtils, packageName, packageVersion, chrootID, self.logPath,listInstalledPackages, listInstalledRPMs)

                 for pkg in listTestPackages:

                     flag = False

-                    for lineContent in listDependentPackages:

-                        if lineContent.package == pkg:

-                                properVersion=pkgUtils._getProperVersion(pkg,lineContent)

-                                self._installPackage(pkgUtils, pkg,properVersion, chrootID, self.logPath,listInstalledPackages, listInstalledRPMs)

+                    packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

+                    for depPkg in listDependentPackages:

+                        depPackageName, depPackageVersion = StringUtils.splitPackageNameAndVersion(depPkg)

+                        if depPackageName == packageName:

                                 flag = True

                                 break;

                     if flag == False:

-                        self._installPackage(pkgUtils, pkg,"*", chrootID, self.logPath,listInstalledPackages, listInstalledRPMs)

+                        self._installPackage(pkgUtils, packageName,packageVersion, chrootID, self.logPath,listInstalledPackages, listInstalledRPMs)

                 pkgUtils.installRPMSInAOneShot(chrootID, self.logPath)

                 self.logger.info("Finished installing the build time dependent packages....")

-            pkgUtils.adjustGCCSpecs(self.package, chrootID, self.logPath, index)

-            pkgUtils.buildRPMSForGivenPackage(self.package, chrootID,

-                                              self.logPath, index)

+            pkgUtils.adjustGCCSpecs(self.package, self.version, chrootID, self.logPath)

+            pkgUtils.buildRPMSForGivenPackage(self.package, self.version, chrootID,

+                                              self.logPath)

             self.logger.info("Successfully built the package:" + self.package)

         except Exception as e:

             self.logger.error("Failed while building package:" + self.package)

@@ -24,8 +24,8 @@ class PackageInfo(object):

         listRPMFiles = []

         cmdUtils = CommandUtils()

         for package in listPackages:

-            release = SPECS.getData().getRelease(package)

             version = SPECS.getData().getVersion(package)

+            release = SPECS.getData().getRelease(package, version)

             listRPMPackages = SPECS.getData().getRPMPackages(package)

             srpmFileName = package + "-" + version + "-" + release + ".src.rpm"

             srpmFiles = cmdUtils.findFile(srpmFileName, constants.sourceRpmPath)

@@ -12,6 +12,7 @@ from ToolChainUtils import ToolChainUtils

 from Scheduler import Scheduler

 from ThreadPool import ThreadPool

 from SpecData import SPECS

+from StringUtils import StringUtils

 class PackageManager(object):

@@ -79,57 +80,25 @@ class PackageManager(object):

             return False

         return True

+    # Returns list of package names which spec file has all subpackages built

+    # Returns set of package name and version like

+    # ["name1-vers1", "name2-vers2",..]

     def _readAlreadyAvailablePackages(self):

         listAvailablePackages = set()

-        listFoundRPMPackages = set()

-        listRPMFiles = set()

-        listDirectorys = set()

-        mapPackageVersion={}

-        mapPackageRelease={}

-        listDirectorys.add(constants.rpmPath)

-        if constants.inputRPMSPath is not None:

-            listDirectorys.add(constants.inputRPMSPath)

-

-        while listDirectorys:

-            dirPath = listDirectorys.pop()

-            for dirEntry in os.listdir(dirPath):

-                dirEntryPath = os.path.join(dirPath, dirEntry)

-                if os.path.isfile(dirEntryPath) and dirEntryPath.endswith(".rpm"):

-                    listRPMFiles.add(dirEntryPath)

-                elif os.path.isdir(dirEntryPath):

-                    listDirectorys.add(dirEntryPath)

         pkgUtils = PackageUtils(self.logName, self.logPath)

-        for rpmfile in listRPMFiles:

-            package, version, release = pkgUtils.findPackageInfoFromRPMFile(rpmfile)

-            if package in mapPackageVersion:

-                mapPackageVersion[package].append(version)

-                mapPackageRelease[package].append(release)

-            else:

-                mapPackageVersion[package]=[version]

-                mapPackageRelease[package]=[release]

-        for package in mapPackageVersion:

-            if SPECS.getData().isRPMPackage(package):

-                numVersions=SPECS.getData().getNumberOfVersions(package)

-                flag=True;

-                for index in range(0, numVersions):

-                        specVersion=SPECS.getData().getVersion(package,index)

-                        specRelease=SPECS.getData().getRelease(package,index)

-                        if  specVersion not in mapPackageVersion[package] and specRelease not in mapPackageRelease[package]:

-                                flag=False

-                if flag:

-                        listFoundRPMPackages.add(package)

-        #Mark package available only if all sub packages are available

-        for package in listFoundRPMPackages:

-            basePkg = SPECS.getData().getSpecName(package)

-            if basePkg in listAvailablePackages:

-                continue

-            listRPMPackages = SPECS.getData().getRPMPackages(basePkg)

-            packageIsAlreadyBuilt = True

-            for rpmpkg in listRPMPackages:

-                if rpmpkg not in listFoundRPMPackages:

-                    packageIsAlreadyBuilt = False

-            if packageIsAlreadyBuilt:

-                listAvailablePackages.add(package)

+        listPackages = SPECS.getData().getListPackages()

+        for package in listPackages:

+            for version in SPECS.getData().getVersions(package):

+                # Mark package available only if all subpackages are available

+                packageIsAlreadyBuilt=True

+                listRPMPackages = SPECS.getData().getRPMPackages(package, version)

+                for rpmPkg in listRPMPackages:

+                    if pkgUtils.findRPMFileForGivenPackage(rpmPkg) is None:

+                        packageIsAlreadyBuilt=False

+                        break;

+                if packageIsAlreadyBuilt:

+                    listAvailablePackages.add(package+"-"+version)

+

         self.logger.info("List of Already built packages")

         self.logger.info(listAvailablePackages)

         return listAvailablePackages

@@ -139,14 +108,15 @@ class PackageManager(object):

         self.mapPackageToCycle.clear()

         self.sortedPackageList = []

-        self.listOfPackagesAlreadyBuilt = self._readAlreadyAvailablePackages()

+        self.listOfPackagesAlreadyBuilt = list(self._readAlreadyAvailablePackages())

         updateBuiltRPMSList = False

         while not updateBuiltRPMSList:

             updateBuiltRPMSList = True

-            listOfPackagesAlreadyBuilt = list(self.listOfPackagesAlreadyBuilt)

+            listOfPackagesAlreadyBuilt = self.listOfPackagesAlreadyBuilt

             for pkg in listOfPackagesAlreadyBuilt:

-                listDependentRpmPackages = SPECS.getData().getRequiresAllForPackage(pkg)

+                packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

+                listDependentRpmPackages = SPECS.getData().getRequiresAllForPackage(packageName, packageVersion)

                 needToRebuild = False

                 for dependentPkg in listDependentRpmPackages:

                     if dependentPkg not in self.listOfPackagesAlreadyBuilt:

@@ -178,17 +148,26 @@ class PackageManager(object):

     def _initializeScheduler(self, statusEvent):

         Scheduler.setLog(self.logName, self.logPath)

-        Scheduler.setParams(self.sortedPackageList, self.listOfPackagesAlreadyBuilt)

+        Scheduler.setParams(self.sortedPackageList, set(self.listOfPackagesAlreadyBuilt))

         Scheduler.setEvent(statusEvent)

         Scheduler.stopScheduling = False

     def _buildGivenPackages(self, listPackages, buildThreads):

+        # Extend listPackages from ["name1", "name2",..] to ["name1-vers1", "name2-vers2",..]

+        listPackageNamesAndVersions=[]

+        for pkg in listPackages:

+            for version in SPECS.getData().getVersions(pkg):

+                listPackageNamesAndVersions.append(pkg+"-"+version)

+            

         if constants.rpmCheck:

+            listMakeCheckPackages=set()

+            for pkg in listPackages:

+                version = SPECS.getData().getHighestVersion(pkg)

+                listMakeCheckPackages.add(pkg+"-"+version)

             alreadyBuiltRPMS = self._readAlreadyAvailablePackages()

-            listPackages = (list(set(listPackages)|(set(constants.listMakeCheckRPMPkgtoInstall)-

-                                                    alreadyBuiltRPMS)))

+            listPackageNamesAndVersions = (list(set(listPackageNamesAndVersions)|(listMakeCheckPackages-alreadyBuiltRPMS)))

-        returnVal = self._calculateParams(listPackages)

+        returnVal = self._calculateParams(listPackageNamesAndVersions)

         if not returnVal:

             self.logger.error("Unable to set paramaters. Terminating the package manager.")

             raise Exception("Unable to set paramaters")

@@ -15,7 +15,7 @@ class PackageUtils(object):

     def __init__(self, logName=None, logPath=None):

         if logName is None:

-            self.logName = "PackageUtils"

+            logName = "PackageUtils"

         if logPath is None:

             logPath = constants.logPath

         self.logName = logName

@@ -85,12 +85,12 @@ class PackageUtils(object):

                 self.logger.error("Unable to install rpms")

                 raise Exception("RPM installation failed")

-    def buildRPMSForGivenPackage(self, package, chrootID, destLogPath=None, index=0):

+    def buildRPMSForGivenPackage(self, package, version, chrootID, destLogPath=None):

         self.logger.info("Building rpm's for package:" + package)

-        listSourcesFiles = SPECS.getData().getSources(package, index)

-        listPatchFiles = SPECS.getData().getPatches(package, index)

-        specFile = SPECS.getData().getSpecFile(package, index)

+        listSourcesFiles = SPECS.getData().getSources(package, version)

+        listPatchFiles = SPECS.getData().getPatches(package, version)

+        specFile = SPECS.getData().getSpecFile(package, version)

         specName = SPECS.getData().getSpecName(package) + ".spec"

         chrootSourcePath = chrootID + constants.topDirPath + "/SOURCES/"

@@ -101,8 +101,8 @@ class PackageUtils(object):

         # FIXME: some sources are located in SPECS/.. how to mount?

         #        if os.geteuid()==0:

-        self._copySourcesTobuildroot(listSourcesFiles, package, chrootSourcePath, index)

-        self._copySourcesTobuildroot(listPatchFiles, package, chrootSourcePath, index)

+        self._copySourcesTobuildroot(listSourcesFiles, package, version, chrootSourcePath)

+        self._copySourcesTobuildroot(listPatchFiles, package, version, chrootSourcePath)

         macros = []

         listAdditionalFiles, macros = self._getAdditionalBuildFiles(package)

@@ -144,24 +144,19 @@ class PackageUtils(object):

         for srpmFile in listSRPMFiles:

             srpmDestFile = self._copyRPM(chrootID + "/" + srpmFile, constants.sourceRpmPath)

-    def findRPMFileForGivenPackage(self, package,version="*", index=0):

+    def findRPMFileForGivenPackage(self, package,version="*"):

         cmdUtils = CommandUtils()

-        release = "*"

         if version == "*":

-                version = SPECS.getData().getVersion(package, index)

-                release = SPECS.getData().getRelease(package, index)

+                version = SPECS.getData().getHighestVersion(package)

+        release = SPECS.getData().getRelease(package, version)

+        buildarch=SPECS.getData().getBuildArch(package, version)

         listFoundRPMFiles = sum([cmdUtils.findFile(package + "-" + version + "-" + release + "." +

-                                                   platform.machine()+".rpm",

-                                                   constants.rpmPath),

-                                 cmdUtils.findFile(package + "-" + version + "-" + release +

-                                                   ".noarch.rpm",

+                                                   buildarch+".rpm",

                                                    constants.rpmPath)], [])

         if constants.inputRPMSPath is not None:

             listFoundRPMFiles = sum([cmdUtils.findFile(package + "-" + version + "-" + release +

-                                                       "." + platform.machine()+".rpm",

-                                                       constants.inputRPMSPath),

-                                     cmdUtils.findFile(package + "-" + version + "-" + release +

-                                                       ".noarch.rpm", constants.inputRPMSPath)],

+                                                       "." + buildarch+".rpm",

+                                                       constants.inputRPMSPath)],

                                     listFoundRPMFiles)

         if len(listFoundRPMFiles) == 1:

             return listFoundRPMFiles[0]

@@ -169,26 +164,10 @@ class PackageUtils(object):

             return None

         if len(listFoundRPMFiles) > 1:

             self.logger.error("Found multiple rpm files for given package in rpm directory." +

-                              "Unable to determine the rpm file for package:" + package)

+                              "Unable to determine the rpm file for package:" + package +

+                              " : " + str(listFoundRPMFiles))

             raise Exception("Multiple rpm files found")

-    def findPackageInfoFromRPMFile(self, rpmfile):

-        rpmfile = os.path.basename(rpmfile)

-        rpmfile = rpmfile.replace("." + platform.machine() + ".rpm", "")

-        rpmfile = rpmfile.replace(".noarch.rpm", "")

-        releaseindex = rpmfile.rfind("-")

-        if releaseindex == -1:

-            self.logger.error("Invalid rpm file:" + rpmfile)

-            raise Exception("Invalid RPM")

-        versionindex = rpmfile[0:releaseindex].rfind("-")

-        if versionindex == -1:

-            self.logger.error("Invalid rpm file:" + rpmfile)

-            raise Exception("Invalid RPM")

-        packageName = rpmfile[0:versionindex]

-        version = rpmfile[versionindex + 1:releaseindex]

-        release = rpmfile[releaseindex + 1:]

-        return packageName, version, release

-

     def findInstalledRPMPackages(self, chrootID):

         cmd = self.rpmBinary + " " + self.queryRpmPackageOptions

         chrootCmd = self.runInChrootCommand + " " + chrootID

@@ -198,8 +177,8 @@ class PackageUtils(object):

             return result.decode().split()

         return result

-    def adjustGCCSpecs(self, package, chrootID, logPath, index=0):

-        opt = " " + SPECS.getData().getSecurityHardeningOption(package, index)

+    def adjustGCCSpecs(self, package, version, chrootID, logPath):

+        opt = " " + SPECS.getData().getSecurityHardeningOption(package, version)

         cmdUtils = CommandUtils()

         cpcmd = ("cp " + self.adjustGCCSpecScript + " " + chrootID +

                  "/tmp/" + self.adjustGCCSpecScript)

@@ -316,8 +295,8 @@ class PackageUtils(object):

             return result.decode().split()

         return result

-    def adjustGCCSpecsInContainer(self, package, containerID, logPath, index=0):

-        opt = " " + SPECS.getData().getSecurityHardeningOption(package, index)

+    def adjustGCCSpecsInContainer(self, package, version, containerID, logPath):

+        opt = " " + SPECS.getData().getSecurityHardeningOption(package, version)

         adjustCmd = "/" + self.adjustGCCSpecScript + opt

         adjustCmd = "/bin/bash -l -c '" + adjustCmd + "'"

         logFile = logPath + "/adjustGCCSpecScript.log"

@@ -335,13 +314,13 @@ class PackageUtils(object):

         self.logger.error("Failed while adjusting gcc specs")

         raise Exception("Failed while adjusting gcc specs")

-    def buildRPMSForGivenPackageInContainer(self, package, containerID, destLogPath=None, index=0):

+    def buildRPMSForGivenPackageInContainer(self, package, version, containerID, destLogPath=None):

         self.logger.info("Building rpm's for package " + package + " in container " +

                          containerID.short_id)

-        listSourcesFiles = SPECS.getData().getSources(package, index)

-        listPatchFiles = SPECS.getData().getPatches(package, index)

-        specFile = SPECS.getData().getSpecFile(package, index)

+        listSourcesFiles = SPECS.getData().getSources(package, version)

+        listPatchFiles = SPECS.getData().getPatches(package, version)

+        specFile = SPECS.getData().getSpecFile(package, version)

         specName = SPECS.getData().getSpecName(package) + ".spec"

         sourcePath = constants.topDirPath + "/SOURCES/"

         specPath = constants.topDirPath + "/SPECS/"

@@ -361,9 +340,9 @@ class PackageUtils(object):

         #        if os.geteuid()==0:

         #TODO: mount it in, don't copy

         macros = []

-        self._copySourcesToContainer(listSourcesFiles, package, containerID, sourcePath, index)

+        self._copySourcesToContainer(listSourcesFiles, package, version, containerID, sourcePath)

         #TODO: mount it in, don't copy

-        self._copySourcesToContainer(listPatchFiles, package, containerID, sourcePath, index)

+        self._copySourcesToContainer(listPatchFiles, package, version, containerID, sourcePath)

         listAdditionalFiles, macros = self._getAdditionalBuildFiles(package)

         self._copyAdditionalBuildFilesToContainer(listAdditionalFiles, containerID)

@@ -382,6 +361,7 @@ class PackageUtils(object):

                 destLogFile,

                 containerID,

                 package,

+                version,

                 macros)

             self.logger.info("Successfully built rpm:" + package)

         except Exception as e:

@@ -392,7 +372,7 @@ class PackageUtils(object):