@@ -108,7 +108,7 @@ find %{buildroot}%{_libdir} -name '*.la' -delete

 %changelog

 *   Tue Jan 23 2018 Xiaolin Li <xiaolinl@vmware.com> 1.2.2-2

 -   Add serf-devel to BuildRequires.

-*   Tue Oct 11 2017 Dheeraj Shetty <dheerajs@vmware.com> 1.2.2-1

+*   Tue Oct 10 2017 Dheeraj Shetty <dheerajs@vmware.com> 1.2.2-1

 -   Updated to version 1.2.2

 *   Mon Oct 02 2017 Vinay Kulkarni <kulkarniv@vmware.com> 1.2.0-7

 -   Use multiple cores to build mesos.

@@ -125,7 +125,7 @@

         "pycurl3",

         "python3-yum-metadata-parser",

         "strace",

-        "cracklib-python3",

+        "python3-cracklib",

         "haveged",

         "vim-extra",

         "postgresql",

@@ -243,16 +243,19 @@ class Installer(object):

         # prepare the RPMs list

         json_pkg_to_rpm_map = JsonWrapper(self.install_config["pkg_to_rpm_map_file"])

         pkg_to_rpm_map = json_pkg_to_rpm_map.read()

-

         self.rpms_tobeinstalled = []

         selected_packages = self.install_config['packages']

         for pkg in selected_packages: 

-            if pkg in pkg_to_rpm_map:

-                if not pkg_to_rpm_map[pkg]['rpm'] is None:

-                    name = pkg_to_rpm_map[pkg]['rpm']

+            versionindex = pkg.rfind("-")

+            if versionindex == -1:

+                raise Exception("Invalid pkg name: " + pkg)

+            package = pkg[:versionindex]

+            if package in pkg_to_rpm_map:

+                if pkg_to_rpm_map[package]['rpm']:

+                    name = pkg_to_rpm_map[package]['rpm']

                     basename = os.path.basename(name)

-                    self.rpms_tobeinstalled.append({'filename': basename, 'path': name, 'package' : pkg})

+                    self.rpms_tobeinstalled.append({'filename': basename, 'path': name, 'package' : package})

         # Copy the rpms

         for rpm in self.rpms_tobeinstalled:

@@ -1,4 +1,5 @@

 from Logger import Logger

+from collections import OrderedDict

 from constants import constants

 from sets import Set

 import copy

@@ -6,13 +7,6 @@ from SpecData import SPECS

-def removeDuplicateEntriesInList(myList):

-    myListCopy=[]

-    for p in myList:

-        if p not in myListCopy:

-            myListCopy.append(p)

-    return myListCopy

-

 class PackageBuildDataGenerator(object):

     cycleCount=0

@@ -32,22 +26,29 @@ class PackageBuildDataGenerator(object):

         self.__sortedPackageList=[]

         self.__sortedBuildDependencyGraph={}

+    def removeDuplicateEntries(self, myList):

+        myListCopy = list(OrderedDict.fromkeys(myList))

+        return myListCopy

+

     def getPackageBuildData(self,listPackages):

-        self.__readDependencyGraphAndCyclesForGivenPackages(listPackages)

-        self.__getSortedBuildOrderListForGivenPackages(listPackages)

+        basePackages = []

+        for pkg in listPackages:

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

+        self.__readDependencyGraphAndCyclesForGivenPackages(basePackages)

+        self.__getSortedBuildOrderListForGivenPackages()

         return self.__mapCyclesToPackageList, self.__mapPackageToCycle, self.__sortedPackageList

     #todo

-    def findCompleteListOfPackagesRequiredToBuildGivenPackages(self,listPackages):

-        return self.__buildDependencyGraph.keys()

+    def findCompleteListOfPackagesRequiredToBuildGivenPackages(self):

+        return list(self.__buildDependencyGraph.keys())

     def createSortListForPkg(self,pkg):

-        runTimeDepPkgList=self.__runTimeDependencyGraph[pkg]

+        runTimeDepPkgList=list(set(self.__runTimeDependencyGraph[pkg]))

         runTimeDepPkgList.append(pkg)

         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)

@@ -61,21 +62,21 @@ class PackageBuildDataGenerator(object):

             circularDependentPackages.remove(pkg)

         return circularDependentPackages

-    def __getSortedBuildOrderListForGivenPackages(self,listPackages):

+    def __getSortedBuildOrderListForGivenPackages(self):

-        alreadyProcessedPackages=[]

-        sortedList=[]

-        completeListPackagesToBuild=self.findCompleteListOfPackagesRequiredToBuildGivenPackages(listPackages)

+        alreadyProcessedPackages = set()

+        sortedList = []

+        completeListPackagesToBuild = self.findCompleteListOfPackagesRequiredToBuildGivenPackages()

         packageIndexInSortedList = 0

-        prevSortListLen=0

+        prevSortListLen = 0

         while completeListPackagesToBuild:

             # find next package to process

-            pkg=None

-            index=-1

-            lenList=len(sortedList)

-            for  i in range(lenList):

+            pkg = None

+            index = -1

+            lenList = len(sortedList)

+            for i in range(lenList):

                 if sortedList[i] in alreadyProcessedPackages:

                     continue

                 pkg = sortedList[i]

@@ -87,72 +88,66 @@ class PackageBuildDataGenerator(object):

                 packageIndexInSortedList = len(sortedList)

             #creating sort list for package

-            sortListForPkg=self.createSortListForPkg(pkg)

+            sortListForPkg = self.createSortListForPkg(pkg)

-            #remove any cyclic packages in sortListForPkg if they already exists in sortedList

-            circularDependentPackages=self.getCircularDependentPackages(pkg)

+            #remove any cyclic packages in sortListForPkg if they already

+            #exists in sortedList

+            circularDependentPackages = self.getCircularDependentPackages(pkg)

             for p in circularDependentPackages:

                 if p in sortedList and p in sortListForPkg:

                     sortListForPkg.remove(p)

             # insert sort list of package in global sorted list

-            index=packageIndexInSortedList

-            subList=[]

+            index = packageIndexInSortedList

+            subList = []

             if packageIndexInSortedList > 0:

-                subList=sortedList[:packageIndexInSortedList]

+                subList = sortedList[:packageIndexInSortedList]

             for p in sortListForPkg:

                 if  p not in subList:

                     sortedList.insert(index, p)

                     index = index + 1

-            alreadyProcessedPackages.append(p)

+            alreadyProcessedPackages.add(p)

             # Remove duplicate entries in sorted list in intervals

-            if (len(sortedList)-prevSortListLen) > 100 :

-                self.logger.info("Removing duplicates in sortedList")

-                sortedList = removeDuplicateEntriesInList(sortedList)

+            if (len(sortedList) - prevSortListLen) > 100:

+                self.logger.debug("Removing duplicates in sortedList")

+                sortedList = self.removeDuplicateEntries(sortedList)

             else:

-                prevSortListLen=len(sortedList)

+                prevSortListLen = len(sortedList)

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

-        sortedList = removeDuplicateEntriesInList(sortedList)

+        self.logger.debug("Removing duplicates in sorted list")

+        sortedList = self.removeDuplicateEntries(sortedList)

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

-        self.logger.info(sortedList)

-        self.__sortedPackageList=sortedList

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

+        self.logger.debug(sortedList)

+        self.__sortedPackageList = sortedList

-    def __constructBuildAndRunTimeDependencyGraph(self,package):

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

-

-        addBuildTimeGraph=True

-        addRunTimeGraph=True

-        if self.__buildDependencyGraph.has_key(basePackage):

+    def __constructBuildAndRunTimeDependencyGraph(self, basePackage):

+        addBuildTimeGraph = True

+        addRunTimeGraph = True

+        if basePackage in self.__buildDependencyGraph:

             addBuildTimeGraph = False

-        if self.__runTimeDependencyGraph.has_key(basePackage):

-            addRunTimeGraph=False

+        if basePackage in self.__runTimeDependencyGraph:

+            addRunTimeGraph = False

-        nextPackagesToConstructGraph=[]

+        nextPackagesToConstructGraph = set()

         if addBuildTimeGraph:

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

-            listDependentPackages=[]

-            for rpmPkg in listDependentRpmPackages:

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

-                if basePkg not in listDependentPackages:

-                    listDependentPackages.append(basePkg)

-            self.__buildDependencyGraph[basePackage]=listDependentPackages

-            nextPackagesToConstructGraph.extend(listDependentPackages)

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

+            dependentPackages = set()

+            for dependentPkg in dependentRpmPackages:

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

+            self.__buildDependencyGraph[basePackage] = dependentPackages

+            nextPackagesToConstructGraph.update(dependentPackages)

         if addRunTimeGraph:

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

-            for rpmPkg in listRpmPackages:

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

-                listDependentPackages=[]

-                for rpmPkgs in listDependentRpmPackages:

-                        listDependentPackages.append(rpmPkgs.package)

-                listDependentPackages = list(set(listDependentPackages))

-                self.__runTimeDependencyGraph[rpmPkg]=listDependentPackages[:]

-                nextPackagesToConstructGraph.extend(listDependentPackages)

-

+            dependentPackages = set()

+            for rpmPkg in SPECS.getData().getPackagesForPkg(basePackage):

+                dependentRpmPackages = SPECS.getData().getRequiresAllForPkg(rpmPkg)

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

+                for pkg in dependentRpmPackages:

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

+            nextPackagesToConstructGraph.update(dependentPackages)

         for pkg in nextPackagesToConstructGraph:

             self.__constructBuildAndRunTimeDependencyGraph(pkg)

@@ -172,57 +167,68 @@ class PackageBuildDataGenerator(object):

         if len(circularDependentPackages) > 0 :

             self.__findCircularDependencies(circularDependentPackages)

-    def topologicalSortPackages(self, dependencyGraph, package=None):

-        noDepPackages = Set()

-        sortedPackageList = []

-        dependentOfPackage = dict()

-

-        dependentPackages={}

+    @staticmethod

+    def _buildDependentPackages(dependencyGraph, package):

+        dependentPackages = {}

         if package is None:

-            dependentPackages=copy.deepcopy(dependencyGraph)

+            dependentPackages = copy.deepcopy(dependencyGraph)

         else:

-            listDepPkgs= Set()

-            listDepPkgs.add(package)

-            while listDepPkgs:

-                pkg = listDepPkgs.pop()

-                if dependentPackages.has_key(pkg):

+            depPkgs = set()

+            depPkgs.add(package)

+            while depPkgs:

+                pkg = depPkgs.pop()

+                if pkg in dependentPackages:

                     continue

-                dependentPackages[pkg]=dependencyGraph[pkg][:]

+                dependentPackages[pkg] = copy.copy(dependencyGraph[pkg])

                 for depPkg in dependencyGraph[pkg]:

-                    listDepPkgs.add(depPkg)

+                    depPkgs.add(depPkg)

+        return dependentPackages

-        #Find packages with no dependencies and generate dependentof_package edge list

+    @staticmethod

+    def _buildDependentOfPackages(dependentPackages):

+        dependentOfPackage = dict()

         for pkg in dependentPackages:

-            if len(dependentPackages[pkg]) == 0:

-                noDepPackages.add(pkg)

-            else:

+            if dependentPackages[pkg]:

                 for depPkg in dependentPackages[pkg]:

-                    if not dependentOfPackage.has_key(depPkg):

-                        dependentOfPackage[depPkg]=[pkg]

+                    if depPkg not in dependentOfPackage:

+                        dependentOfPackage[depPkg] = {pkg}

                     else:

-                        if pkg not in dependentOfPackage[depPkg]:

-                            dependentOfPackage[depPkg].append(pkg)

+                        dependentOfPackage[depPkg].add(pkg)

+        return dependentOfPackage

+

+    @staticmethod

+    def topologicalSortPackages(dependencyGraph, package=None):

+        sortedPackageList = []

+        noDepPackages = set()

+        dependentPackages = PackageBuildDataGenerator._buildDependentPackages(

+            dependencyGraph, package)

+        dependentOfPackage = PackageBuildDataGenerator._buildDependentOfPackages(

+            dependentPackages)

+

+        #Find packages with no dependencies and generate dependentof_package edge list

+        for pkg in dependentPackages:

+            if not dependentPackages[pkg]:

+                noDepPackages.add(pkg)

         while noDepPackages:

             pkg = noDepPackages.pop()

             sortedPackageList.append(pkg)

-            if dependentOfPackage.get(pkg) is not None:

-                for childPkg in list(dependentOfPackage.get(pkg)):

-                    dependentOfPackage.get(pkg).remove(childPkg)

+            if pkg in dependentOfPackage:

+                for childPkg in list(dependentOfPackage[pkg]):

+                    dependentOfPackage[pkg].remove(childPkg)

                     dependentPackages[childPkg].remove(pkg)

-                    if len(dependentPackages[childPkg])==0:

+                    if not dependentPackages[childPkg]:

                         noDepPackages.add(childPkg)

         # creating circular dependency graph for given dependency graph

-        circularDependencyGraph={}

-        listCircularPkg = dependentPackages.keys()

-        for pkg in listCircularPkg:

-            if len(dependentPackages[pkg]) != 0:

-                circularDependencyGraph[pkg]=dependentPackages[pkg]

-

-        #return (non-circular dependent package in sorted order and circular dependent package list in a dependencyGraph)

-        return sortedPackageList,circularDependencyGraph

+        circularDependencyGraph = {}

+        for pkg in dependentPackages.keys():

+            if dependentPackages[pkg]:

+                circularDependencyGraph[pkg] = dependentPackages[pkg]

+        #return (non-circular dependent package in sorted order and circular dependent

+        #package list in a dependencyGraph)

+        return sortedPackageList, circularDependencyGraph

     def __constructDependencyMap(self,cyclicDependencyGraph):

         self.logger.info("Constructing dependency map from circular dependency graph.....")

@@ -286,7 +292,3 @@ class PackageBuildDataGenerator(object):

         else:

             self.logger.info("No circular dependencies found.")

-

-

-

-

@@ -7,6 +7,7 @@ import os.path

 from constants import constants

 import shutil

 from SpecData import SPECS

+from StringUtils import StringUtils

 class PackageBuilderBase(object):

     def __init__(self, mapPackageToCycles, pkgBuildType):

@@ -15,52 +16,45 @@ 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 findPackageNameFromRPMFile(self,rpmfile):

-        rpmfile=os.path.basename(rpmfile)

-        releaseindex=rpmfile.rfind("-")

+    def _findPackageNameAndVersionFromRPMFile(self, rpmfile):

+        rpmfile = os.path.basename(rpmfile)

+        releaseindex = rpmfile.rfind("-")

         if releaseindex == -1:

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

+            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 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)

         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):

-        listRequiredPackages=SPECS.getData().getRequiresForPackage(rpmPackage)

+    def findRunTimeRequiredRPMPackages(self,rpmPackage, version):

+        listRequiredPackages=SPECS.getData().getRequiresForPackage(rpmPackage, version)

         return listRequiredPackages

-    def findBuildTimeRequiredPackages(self, index):

-        listRequiredPackages=SPECS.getData().getBuildRequiresForPackage(self.package, index)

+    def findBuildTimeRequiredPackages(self):

+        listRequiredPackages=SPECS.getData().getBuildRequiresForPackage(self.package, self.version)

         return listRequiredPackages

-    def findBuildTimeCheckRequiredPackages(self, index):

-        listRequiredPackages=SPECS.getData().getCheckBuildRequiresForPackage(self.package, index)

+    def findBuildTimeCheckRequiredPackages(self):

+        listRequiredPackages=SPECS.getData().getCheckBuildRequiresForPackage(self.package, self.version)

         return listRequiredPackages

-    @staticmethod

-    def getNumOfVersions(package):

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

-

 class PackageBuilder(PackageBuilderBase):

     def __init__(self,mapPackageToCycles,listAvailableCyclicPackages,listBuildOptionPackages,pkgBuildOptionFile):

@@ -71,9 +65,9 @@ class PackageBuilder(PackageBuilderBase):

         self.listBuildOptionPackages=listBuildOptionPackages

         self.pkgBuildOptionFile=pkgBuildOptionFile

-    def prepareBuildRoot(self,index):

+    def prepareBuildRoot(self):

         chrootID=None

-        chrootName="build-"+self.package

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

         try:

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

             returnVal,chrootID = chrUtils.createChroot(chrootName)

@@ -81,7 +75,7 @@ class PackageBuilder(PackageBuilderBase):

             if not returnVal:

                 raise Exception("Unable to prepare build root")

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

-            tUtils.installToolChainRPMS(chrootID, self.package, self.listBuildOptionPackages, self.pkgBuildOptionFile, self.logPath,index)

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

         except Exception as e:

             if chrootID is not None:

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

@@ -89,58 +83,57 @@ class PackageBuilder(PackageBuilderBase):

             raise e

         return chrootID

-    def findInstalledPackages(self,chrootID):

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

-        listInstalledRPMs=pkgUtils.findInstalledRPMPackages(chrootID)

-        listInstalledPackages=[]

+    def findInstalledPackages(self, instanceID):

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

+        if self.pkgBuildType == "chroot":

+            listInstalledRPMs = pkgUtils.findInstalledRPMPackages(instanceID)

+        listInstalledPackages = []

         for installedRPM in listInstalledRPMs:

-            packageName=self.findPackageNameFromRPMFile(installedRPM)

-            if packageName is not None:

-                listInstalledPackages.append(packageName)

-        return listInstalledPackages

+            pkg = self._findPackageNameAndVersionFromRPMFile(installedRPM)

+            if pkg is not None:

+                listInstalledPackages.append(pkg)

+        return listInstalledPackages, listInstalledRPMs

     def buildPackageThreadAPI(self,package,outputMap, threadName,):

-        self.package=package

-        self.logName="build-"+package

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

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

-            cmdUtils = CommandUtils()

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

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

-        versions = self.getNumOfVersions(package)

-        if(versions < 1):

-            raise Exception("No package exists")

-        for version in range(0, versions):

-            try:

-                self.buildPackage(version)

-                outputMap[threadName]=True

-            except Exception as e:

-                # TODO: self.logger might be None

-                self.logger.exception(e)

-                outputMap[threadName]=False

-                raise e

-

-    def buildPackage(self, index):

+        packageName, packageVersion = StringUtils.splitPackageNameAndVersion(package)

         #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 self.checkIfPackageIsAlreadyBuilt(packageName, packageVersion):

             if not constants.rpmCheck:

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

+                outputMap[threadName]=True

                 return

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

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

+            elif constants.rpmCheck and packageName not in constants.testForceRPMS:

+                outputMap[threadName]=True

                 return

+        self.package=packageName

+        self.version=packageVersion

+        self.logName="build-"+package

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

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

+            cmdUtils = CommandUtils()

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

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

+        try:

+            self.buildPackage()

+            outputMap[threadName]=True

+        except Exception as e:

+            # TODO: self.logger might be None

+            self.logger.exception(e)

+            outputMap[threadName]=False

+            raise e

+

+    def buildPackage(self):

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

         chrootID=None

         try:

-            chrootID = self.prepareBuildRoot(index)

-            listInstalledPackages=self.findInstalledPackages(chrootID)

-            listDependentPackages=self.findBuildTimeRequiredPackages(index)

+            chrootID = self.prepareBuildRoot()

+            listInstalledPackages, listInstalledRPMs=self.findInstalledPackages(chrootID)

+            listDependentPackages=self.findBuildTimeRequiredPackages()

             listTestPackages=[]

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

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

+                listDependentPackages.extend(self.findBuildTimeCheckRequiredPackages())

                 testPackages=set(constants.listMakeCheckRPMPkgtoInstall)-set(listInstalledPackages)-set([self.package])

                 listTestPackages = list(set(testPackages))

                 listDependentPackages=list(set(listDependentPackages))

@@ -148,23 +141,23 @@ class PackageBuilder(PackageBuilderBase):

             if len(listDependentPackages) != 0:

                 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)

+                    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)

+                    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)

+                        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.listBuildOptionPackages,self.pkgBuildOptionFile,self.logPath, index)

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

+            pkgUtils.buildRPMSForGivenPackage(self.package,self.version,chrootID,self.listBuildOptionPackages,self.pkgBuildOptionFile,self.logPath)

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

         except Exception as e:

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

@@ -176,12 +169,28 @@ class PackageBuilder(PackageBuilderBase):

         if chrootID is not None:

             chrUtils.destroyChroot(chrootID)

-    def installPackage(self,pkgUtils,package,packageVersion,chrootID,destLogPath,listInstalledPackages):

-        if package in listInstalledPackages:

+    def installPackage(self,pkgUtils,package,packageVersion,chrootID,destLogPath,listInstalledPackages,listInstalledRPMs):

+        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

+        # For linux packages, install the gcc dependencies from publish rpms

+        if self.package in self.listBuildOptionPackages:

+            if SPECS.getData().getSpecName(package) == "gcc":

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

+                overridenPkgVer = tUtils.getOverridenPackageVersion(self.package, package, self.listBuildOptionPackages, self.pkgBuildOptionFile)

+                overridenPkg = package+"-"+overridenPkgVer

+                if overridenPkg in listInstalledPackages:

+                    return

+

         # mark it as installed -  to avoid cyclic recursion

-        listInstalledPackages.append(package)

-        self.installDependentRunTimePackages(pkgUtils,package,chrootID,destLogPath,listInstalledPackages)

+        listInstalledPackages.append(pkg)

+        listInstalledRPMs.append(specificRPM)

+        self.installDependentRunTimePackages(pkgUtils,package,packageVersion, chrootID,destLogPath,listInstalledPackages,listInstalledRPMs)

         noDeps=False

         if self.mapPackageToCycles.has_key(package):

             noDeps = True

@@ -192,14 +201,17 @@ class PackageBuilder(PackageBuilderBase):

         pkgUtils.installRPM(package,packageVersion,chrootID,noDeps,destLogPath)

-    def installDependentRunTimePackages(self,pkgUtils,package,chrootID,destLogPath,listInstalledPackages):

-        listRunTimeDependentPackages=self.findRunTimeRequiredRPMPackages(package)

+    def installDependentRunTimePackages(self,pkgUtils,package,packageVersion,chrootID,destLogPath,listInstalledPackages,listInstalledRPMs):

+        listRunTimeDependentPackages=self.findRunTimeRequiredRPMPackages(package,packageVersion)

         if len(listRunTimeDependentPackages) != 0:

             for pkg in listRunTimeDependentPackages:

-                if self.mapPackageToCycles.has_key(pkg) and pkg not in self.listAvailableCyclicPackages:

+                if self.mapPackageToCycles.has_key(pkg):

                     continue

-                if pkg in listInstalledPackages:

+                packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)

+                latestPkgRPM = os.path.basename(

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

+                if pkg in listInstalledPackages and latestPkgRPM in listInstalledRPMs:

                     continue

-                self.installPackage(pkgUtils,pkg,"*",chrootID,destLogPath,listInstalledPackages)

+                self.installPackage(pkgUtils,packageName,packageVersion,chrootID,destLogPath,listInstalledPackages,listInstalledRPMs)

@@ -24,29 +24,31 @@ class PackageInfo(object):

         listRPMFiles = []

         cmdUtils = CommandUtils()

         for package in listPackages:

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

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

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

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

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

-            srpmFile = None

-            if len(srpmFiles) == 1:

-                srpmFile = srpmFiles[0]

-            debugrpmFileName = package+"-debuginfo-"+version+"-"+release+"*"

-            debugrpmFiles = cmdUtils.findFile(debugrpmFileName, constants.rpmPath)

-            debugrpmFile = None

-            if len(debugrpmFiles) == 1:

-                debugrpmFile = debugrpmFiles[0]

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

-            for rpmPkg in listRPMPackages:

-                rpmFile = pkgUtils.findRPMFileForGivenPackage(rpmPkg)

-                if rpmFile is not None:

-                    listRPMFiles.append(rpmFile)

-                    listPkgAttributes = {"sourcerpm":srpmFile, "rpm":rpmFile, "debugrpm":debugrpmFile}

-                    self.pkgList[rpmPkg] = listPkgAttributes

-                    self.logger.debug("Added "+rpmPkg +" rpm package to the list")

-                else:

-                    self.logger.error("Missing rpm file for package:"+rpmPkg)

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

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

+                if release is None:

+                        release = "*"

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

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

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

+                srpmFile = None

+                if len(srpmFiles) == 1:

+                        srpmFile = srpmFiles[0]

+                debugrpmFileName = package+"-debuginfo-"+version+"-"+release+"*"

+                debugrpmFiles = cmdUtils.findFile(debugrpmFileName, constants.rpmPath)

+                debugrpmFile = None

+                if len(debugrpmFiles) == 1:

+                        debugrpmFile = debugrpmFiles[0]

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

+                for rpmPkg in listRPMPackages:

+                        rpmFile = pkgUtils.findRPMFileForGivenPackage(rpmPkg)

+                        if rpmFile is not None:

+                                listRPMFiles.append(rpmFile)

+                                listPkgAttributes = {"sourcerpm":srpmFile, "rpm":rpmFile, "debugrpm":debugrpmFile}

+                                self.pkgList[rpmPkg] = listPkgAttributes

+                                self.logger.debug("Added "+rpmPkg +" rpm package to the list")

+                        else:

+                                self.logger.error("Missing rpm file for package:"+rpmPkg)

     def writePkgListToFile(self, fileName):

          self.logger.info("Writing package list to the json file")

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

 from Scheduler import Scheduler

 from ThreadPool import ThreadPool

 from SpecData import SPECS

+from StringUtils import StringUtils

 class PackageManager(object):

@@ -46,43 +47,21 @@ class PackageManager(object):

         return True

     def readAlreadyAvailablePackages(self):

-        listAvailablePackages=[]

-        listFoundRPMPackages=[]

-        listRPMFiles=[]

-        listDirectorys=[]

-        listDirectorys.append(constants.rpmPath)

-        if constants.inputRPMSPath is not None:

-            listDirectorys.append(constants.inputRPMSPath)

+        listAvailablePackages = set()

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

+        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, version) is None:

+                        packageIsAlreadyBuilt=False

+                        break;

+                if packageIsAlreadyBuilt:

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

-        while len(listDirectorys) > 0:

-            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.append(dirEntryPath)

-                elif os.path.isdir(dirEntryPath):

-                    listDirectorys.append(dirEntryPath)

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

-        for rpmfile in listRPMFiles:

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

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

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

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

-                if version == specVersion and release == specRelease:

-                    listFoundRPMPackages.append(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.append(package)

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

         self.logger.info(listAvailablePackages)

         return listAvailablePackages

@@ -96,7 +75,7 @@ class PackageManager(object):

         self.sortedPackageList=[]

         listOfPackagesAlreadyBuilt = []

-        listOfPackagesAlreadyBuilt = self.readAlreadyAvailablePackages()

+        listOfPackagesAlreadyBuilt = list(self.readAlreadyAvailablePackages())

         self.listOfPackagesAlreadyBuilt = listOfPackagesAlreadyBuilt[:]

         updateBuiltRPMSList = False

@@ -104,10 +83,11 @@ class PackageManager(object):

             updateBuiltRPMSList = True

             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.package not in self.listOfPackagesAlreadyBuilt:

+                    if dependentPkg not in self.listOfPackagesAlreadyBuilt:

                         needToRebuild = True

                         updateBuiltRPMSList = False

                 if needToRebuild:

@@ -117,7 +97,6 @@ class PackageManager(object):

         for pkg in listPackages:

             if pkg in self.listOfPackagesAlreadyBuilt and not constants.rpmCheck:

                 listPackagesToBuild.remove(pkg)

-

         if not self.readPackageBuildData(listPackagesToBuild):

             return False

         return True

@@ -181,11 +160,20 @@ class PackageManager(object):

         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:

             alreadyBuiltRPMS=self.readAlreadyAvailablePackages()

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

+            listMakeCheckPackages=set()

+            for pkg in listPackages:

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

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

+            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")

@@ -16,7 +16,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

@@ -52,26 +52,6 @@ class PackageUtils(object):

             arch="noarch"

         return arch

-    def getProperVersion(self,package,parseSpecObj):

-        listOfVersionObjs=SPECS.getData().getSpecObj(package)

-        for num in listOfVersionObjs:

-                if parseSpecObj.compare == 'gte':

-                        if LooseVersion(num.version) >= LooseVersion(parseSpecObj.version):

-                                return num.version

-                elif parseSpecObj.compare == 'lte':

-                        if LooseVersion(num.version) <= LooseVersion(parseSpecObj.version):

-                                return num.version

-                elif parseSpecObj.compare == 'eq':

-                        if LooseVersion(num.version) == LooseVersion(parseSpecObj.version):

-                                return num.version

-                elif parseSpecObj.compare == 'lt':

-                        if LooseVersion(num.version) < LooseVersion(parseSpecObj.version):

-                                return num.version

-                elif parseSpecObj.compare == 'gt':

-                        if LooseVersion(num.version) > LooseVersion(parseSpecObj.version):

-                                return num.version

-        return "*"

-

     def getRPMDestDir(self,rpmName,rpmDir):

         arch = self.getRPMArch(rpmName)

         rpmDestDir=rpmDir+"/"+arch

@@ -129,10 +109,10 @@ class PackageUtils(object):

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

                 raise Exception("RPM installation failed")

-    def verifyShaAndGetSourcePath(self, source, package, index=0):

+    def verifyShaAndGetSourcePath(self, source, package, version):

         cmdUtils = CommandUtils()

         # Fetch/verify sources if sha1 not None.

-        sha1 = SPECS.getData().getSHA1(package, source, index)

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

         if sha1 is not None:

             PullSources.get(package, source, sha1, constants.sourcePath, constants.pullsourcesConfig, self.logger)

@@ -160,9 +140,9 @@ class PackageUtils(object):

             listSourceFiles,

             package,

             destDir,

-            index=0):

+            version):

         for source in listSourceFiles:

-            sourcePath = self.verifyShaAndGetSourcePath(source, package, index)

+            sourcePath = self.verifyShaAndGetSourcePath(source, package, version)

             self.logger.info("Copying... Source path :" + source + " Source filename: " + sourcePath[0])

             shutil.copy2(sourcePath[0], destDir)

@@ -198,16 +178,16 @@ class PackageUtils(object):

     def buildRPMSForGivenPackage(

             self,

             package,

+            version,

             chrootID,

             listBuildOptionPackages,

             pkgBuildOptionFile,