@@ -14,7 +14,7 @@ from SpecData import SPECS

 class BuildContainer(PackageBuilderBase):

     def __init__(self, mapPackageToCycles, listAvailableCyclicPackages, listBuildOptionPackages, pkgBuildOptionFile, logName=None, logPath=None):

-        PackageBuilderBase.__init__(self, mapPackageToCycles, "continer")

+        PackageBuilderBase.__init__(self, mapPackageToCycles, "container")

         if logName is None:

             logName = "BuildContainer"

         if logPath is None:

@@ -146,10 +146,11 @@ class BuildContainer(PackageBuilderBase):

             listInstalledPackages, listInstalledRPMs = self.findInstalledPackages(containerID)

             self.logger.info(listInstalledPackages)

             listDependentPackages = self.findBuildTimeRequiredPackages(index)

+            listTestPackages=[]

             if constants.rpmCheck and package in constants.testForceRPMS:

                 listDependentPackages.extend(self.findBuildTimeCheckRequiredPackages(index))

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

-                listDependentPackages.extend(testPackages)

+                listTestPackages = list(set(testPackages))

                 listDependentPackages=list(set(listDependentPackages))

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

@@ -157,15 +158,36 @@ class BuildContainer(PackageBuilderBase):

                 self.logger.info("BuildContainer-buildPackage: Installing dependent packages..")

                 self.logger.info(listDependentPackages)

                 for pkg in listDependentPackages:

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

+                    properVersion=pkgUtils.getProperVersion(pkg.package,pkg)

+                    self.installPackage(pkgUtils, pkg.package, properVersion, containerID, destLogPath, 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, containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

+                                flag = True

+                                break;

+                    if flag == False:

+                        self.installPackage(pkgUtils, pkg,"*", containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

                 # Special case sqlite due to package renamed from sqlite-autoconf to sqlite

                 if "sqlite" in listInstalledPackages or "sqlite-devel" in listInstalledPackages or "sqlite-libs" in listInstalledPackages:

+                    properVersion = "*"

                     if "sqlite" not in listInstalledPackages:

-                        self.installPackage(pkgUtils, "sqlite", containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

+                        for lineContent in listDependentPackages:

+                                if lineContent.package == "sqlite":

+                                        properVersion=pkgUtils.getProperVersion(lineContent.package,lineContent)

+                        self.installPackage(pkgUtils, "sqlite",properVersion, containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

                     if "sqlite-devel" not in listInstalledPackages:

-                        self.installPackage(pkgUtils, "sqlite-devel", containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

+                        for lineContent in listDependentPackages:

+                                if lineContent.package == "sqlite":

+                                        properVersion=pkgUtils.getProperVersion(lineContent.package,lineContent)

+                        self.installPackage(pkgUtils, "sqlite-devel",properVersion, containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

                     if "sqlite-libs" not in listInstalledPackages:

-                        self.installPackage(pkgUtils, "sqlite-libs", containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

+                        for lineContent in listDependentPackages:

+                                if lineContent.package == "sqlite":

+                                        properVersion=pkgUtils.getProperVersion(lineContent.package,lineContent)

+                        self.installPackage(pkgUtils, "sqlite-libs", properVersion,containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

                 pkgUtils.installRPMSInAOneShotInContainer(containerID, destLogPath)

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

@@ -195,9 +217,8 @@ class BuildContainer(PackageBuilderBase):

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

             chrUtils.destroyChroot(chrootID)

-    def installPackage(self, pkgUtils, package, containerID, destLogPath, listInstalledPackages, listInstalledRPMs):

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

-        if package in listInstalledPackages and latestRPM in listInstalledRPMs:

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

+        if package in listInstalledPackages:

             return

         self.installDependentRunTimePackages(pkgUtils, package, containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

         noDeps = False

@@ -207,12 +228,14 @@ class BuildContainer(PackageBuilderBase):

             noDeps = True

         if package in constants.noDepsPackageList:

             noDeps = True

-        pkgUtils.prepRPMforInstallInContainer(package, containerID, noDeps, destLogPath)

+        pkgUtils.prepRPMforInstallInContainer(package,packageVersion, containerID, noDeps, destLogPath)

         listInstalledPackages.append(package)

-        listInstalledRPMs.append(latestRPM)

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

+        listInstalledRPMs.append(specificRPM)

     def installDependentRunTimePackages(self, pkgUtils, package, containerID, destLogPath, listInstalledPackages, listInstalledRPMs):

         listRunTimeDependentPackages = self.findRunTimeRequiredRPMPackages(package)

+        listRunTimeDependentPackagesLineContent=self.findRunTimeRequiredRPMPackagesLineContent(package)

         if len(listRunTimeDependentPackages) != 0:

             for pkg in listRunTimeDependentPackages:

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

@@ -220,4 +243,12 @@ class BuildContainer(PackageBuilderBase):

                 latestPkgRPM = os.path.basename(pkgUtils.findRPMFileForGivenPackage(pkg)).replace(".rpm", "")

                 if pkg in listInstalledPackages and latestPkgRPM in listInstalledRPMs:

                     continue

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

+                flag = False

+                for lineContent in listRunTimeDependentPackagesLineContent:

+                    if lineContent.package == pkg:

+                        properVersion=pkgUtils.getProperVersion(pkg,lineContent)

+                        self.installPackage(pkgUtils, pkg,properVersion, containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

+                        flag = True

+                        break;

+                if flag == False:

+                    self.installPackage(pkgUtils, pkg, "*",containerID, destLogPath, listInstalledPackages, listInstalledRPMs)

@@ -12,11 +12,11 @@ def removeDuplicateEntriesInList(myList):

         if p not in myListCopy:

             myListCopy.append(p)

     return myListCopy

-      

+

 class PackageBuildDataGenerator(object):

-    

+

     cycleCount=0

-    

+

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

         if logName is None:

             logName = "PackageBuildDataGenerator"

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

         self.__runTimeDependencyGraph={}

         self.__sortedPackageList=[]

         self.__sortedBuildDependencyGraph={}

-    

+

     def getPackageBuildData(self,listPackages):

         self.__readDependencyGraphAndCyclesForGivenPackages(listPackages)

         self.__getSortedBuildOrderListForGivenPackages(listPackages)

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

-    #todo    

+    #todo

     def findCompleteListOfPackagesRequiredToBuildGivenPackages(self,listPackages):

-        return self.__buildDependencyGraph.keys()    

- 

+        return self.__buildDependencyGraph.keys()

+

     def createSortListForPkg(self,pkg):

         runTimeDepPkgList=self.__runTimeDependencyGraph[pkg]

         runTimeDepPkgList.append(pkg)

         sortListForPkg=[]

-        

+

         for p in runTimeDepPkgList:

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

             for bPkg in self.__sortedBuildDependencyGraph[basePkg]:

                 if bPkg not in sortListForPkg:

                     sortListForPkg.append(bPkg)

-        

+

         return sortListForPkg

-    

+

     def getCircularDependentPackages(self,pkg):

         circularDependentPackages=[]

         if self.__mapPackageToCycle.has_key(pkg):

             circularDependentPackages.extend(self.__mapCyclesToPackageList[self.__mapPackageToCycle[pkg]])

             circularDependentPackages.remove(pkg)

         return circularDependentPackages

-    

+

     def __getSortedBuildOrderListForGivenPackages(self,listPackages):

-        

+

         alreadyProcessedPackages=[]

         sortedList=[]

         completeListPackagesToBuild=self.findCompleteListOfPackagesRequiredToBuildGivenPackages(listPackages)

         packageIndexInSortedList = 0

         prevSortListLen=0

-        

+

         while completeListPackagesToBuild:

-            

+

             # find next package to process

             pkg=None

             index=-1

@@ -81,20 +81,20 @@ class PackageBuildDataGenerator(object):

                 pkg = sortedList[i]

                 packageIndexInSortedList = i

                 break

-                

+

             if pkg is None:

                 pkg = completeListPackagesToBuild.pop()

                 packageIndexInSortedList = len(sortedList)

             #creating sort list for package

             sortListForPkg=self.createSortListForPkg(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=[]

@@ -104,23 +104,23 @@ class PackageBuildDataGenerator(object):

                 if  p not in subList:

                     sortedList.insert(index, p)

                     index = index + 1

-            

+

             alreadyProcessedPackages.append(p)

-        

+

             # Remove duplicate entries in sorted list in intervals

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

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

                 sortedList = removeDuplicateEntriesInList(sortedList)

             else:

                 prevSortListLen=len(sortedList)

-                

+

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

         sortedList = removeDuplicateEntriesInList(sortedList)

-        

+

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

         self.logger.info(sortedList)

         self.__sortedPackageList=sortedList

-    

+

     def __constructBuildAndRunTimeDependencyGraph(self,package):

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

@@ -130,28 +130,32 @@ class PackageBuildDataGenerator(object):

             addBuildTimeGraph = False

         if self.__runTimeDependencyGraph.has_key(basePackage):

             addRunTimeGraph=False

-        

+

         nextPackagesToConstructGraph=[]

         if addBuildTimeGraph:

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

             listDependentPackages=[]

             for rpmPkg in listDependentRpmPackages:

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

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

                 if basePkg not in listDependentPackages:

                     listDependentPackages.append(basePkg)

             self.__buildDependencyGraph[basePackage]=listDependentPackages

             nextPackagesToConstructGraph.extend(listDependentPackages)

-        

+

         if addRunTimeGraph:

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

             for rpmPkg in listRpmPackages:

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

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

-                nextPackagesToConstructGraph.extend(listDependentRpmPackages)

+                listDependentPackages=[]

+                for rpmPkgs in listDependentRpmPackages:

+                        listDependentPackages.append(rpmPkgs.package)

+                listDependentPackages = list(set(listDependentPackages))

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

+                nextPackagesToConstructGraph.extend(listDependentPackages)

         for pkg in nextPackagesToConstructGraph:

             self.__constructBuildAndRunTimeDependencyGraph(pkg)

-    

+

     def __readDependencyGraphAndCyclesForGivenPackages(self,listPackages):

         self.logger.info("Reading dependency graph to check for cycles")

         for pkg in listPackages:

@@ -167,12 +171,12 @@ class PackageBuildDataGenerator(object):

         sortedPackageList,circularDependentPackages = self.topologicalSortPackages(self.__runTimeDependencyGraph)

         if len(circularDependentPackages) > 0 :

             self.__findCircularDependencies(circularDependentPackages)

-    

+

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

         noDepPackages = Set()

         sortedPackageList = []

         dependentOfPackage = dict()

-        

+

         dependentPackages={}

         if package is None:

             dependentPackages=copy.deepcopy(dependencyGraph)

@@ -186,7 +190,7 @@ class PackageBuildDataGenerator(object):

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

                 for depPkg in dependencyGraph[pkg]:

                     listDepPkgs.add(depPkg)

-                    

+

         #Find packages with no dependencies and generate dependentof_package edge list

         for pkg in dependentPackages:

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

@@ -198,7 +202,7 @@ class PackageBuildDataGenerator(object):

                     else:

                         if pkg not in dependentOfPackage[depPkg]:

                             dependentOfPackage[depPkg].append(pkg)

-        

+

         while noDepPackages:

             pkg = noDepPackages.pop()

             sortedPackageList.append(pkg)

@@ -208,18 +212,18 @@ class PackageBuildDataGenerator(object):

                     dependentPackages[childPkg].remove(pkg)

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

                         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

-    

-    

+

+

     def __constructDependencyMap(self,cyclicDependencyGraph):

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

         constructDependencyMap={}

@@ -243,15 +247,15 @@ class PackageBuildDataGenerator(object):

         self.logger.info("Dependency Map:")

         self.logger.info(constructDependencyMap)

         return constructDependencyMap

-        

-        

+

+

     def __findCircularDependencies(self,cyclicDependencyGraph):

         self.logger.info("Looking for circular dependencies")

         if len(cyclicDependencyGraph) == 0:

             return

         #step1: construct dependency map from dependency graph

         constructDependencyMap=self.__constructDependencyMap(cyclicDependencyGraph)

-        

+

         #step2: find cycles in dependency map

         self.logger.info("Finding and adding cycles using constructed dependency map......")

         cycleCount=0

@@ -264,7 +268,7 @@ class PackageBuildDataGenerator(object):

                     x = constructDependencyMap[depPkg]

                     if node in x:

                         cycPkgs.append(depPkg)

-                

+

                 if len(cycPkgs) != 0:

                     cycPkgs.append(node)

                     cycleName="cycle"+str(PackageBuildDataGenerator.cycleCount)

@@ -275,14 +279,14 @@ class PackageBuildDataGenerator(object):

                     self.logger.info("New circular dependency found:")

                     self.logger.info(cycleName+" "+ ",".join(cycPkgs))

                     cycleCount = cycleCount + 1

-        

+

         if cycleCount > 0 :

             self.logger.info("Found "+str(cycleCount) + " cycles.")

             self.logger.info("Successfully added all detected circular dependencies to list.")

         else:

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

-        

-    

-    

-    

+

+

+

+

@@ -71,7 +71,7 @@ class PackageBuilder(PackageBuilderBase):

         self.listBuildOptionPackages=listBuildOptionPackages

         self.pkgBuildOptionFile=pkgBuildOptionFile

-    def prepareBuildRoot(self):

+    def prepareBuildRoot(self,index):

         chrootID=None

         chrootName="build-"+self.package

         try:

@@ -81,7 +81,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)

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

         except Exception as e:

             if chrootID is not None:

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

@@ -135,20 +135,31 @@ class PackageBuilder(PackageBuilderBase):

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

         chrootID=None

         try:

-            chrootID = self.prepareBuildRoot()

+            chrootID = self.prepareBuildRoot(index)

             listInstalledPackages=self.findInstalledPackages(chrootID)

             listDependentPackages=self.findBuildTimeRequiredPackages(index)

+            listTestPackages=[]

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

                 listDependentPackages.extend(self.findBuildTimeCheckRequiredPackages(index))

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

-                listDependentPackages.extend(testPackages)

+                listTestPackages = list(set(testPackages))

                 listDependentPackages=list(set(listDependentPackages))

-

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

             if len(listDependentPackages) != 0:

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

                 for pkg in listDependentPackages:

-                    self.installPackage(pkgUtils, pkg,chrootID,self.logPath,listInstalledPackages)

+                    properVersion=pkgUtils.getProperVersion(pkg.package,pkg)

+                    self.installPackage(pkgUtils,pkg.package,properVersion,chrootID,self.logPath,listInstalledPackages)

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

+                                flag = True

+                                break;

+                    if flag == False:

+                        self.installPackage(pkgUtils,pkg,"*",chrootID,self.logPath,listInstalledPackages)

                 pkgUtils.installRPMSInAOneShot(chrootID,self.logPath)

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

@@ -165,7 +176,7 @@ class PackageBuilder(PackageBuilderBase):

         if chrootID is not None:

             chrUtils.destroyChroot(chrootID)

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

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

         if package in listInstalledPackages:

             return

         # mark it as installed -  to avoid cyclic recursion

@@ -178,7 +189,8 @@ class PackageBuilder(PackageBuilderBase):

             noDeps=True

         if package in constants.noDepsPackageList:

             noDeps=True

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

+

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

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

         listRunTimeDependentPackages=self.findRunTimeRequiredRPMPackages(package)

@@ -188,6 +200,6 @@ class PackageBuilder(PackageBuilderBase):

                     continue

                 if pkg in listInstalledPackages:

                     continue

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

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

@@ -107,7 +107,7 @@ class PackageManager(object):

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

                 needToRebuild = False

                 for dependentPkg in listDependentRpmPackages:

-                    if dependentPkg not in self.listOfPackagesAlreadyBuilt:

+                    if dependentPkg.package not in self.listOfPackagesAlreadyBuilt:

                         needToRebuild = True

                         updateBuiltRPMSList = False

                 if needToRebuild:

@@ -249,7 +249,7 @@ class PackageManager(object):

             if not returnVal:

                 raise Exception("Unable to prepare tool-chain chroot")

             tcUtils = ToolChainUtils("toolchain-chroot", self.logPath)

-            tcUtils.installToolChainRPMS(chrootID, "dummy")

+            tcUtils.installToolChainRPMS(chrootID, "dummy",self.listBuildOptionPackages,self.pkgBuildOptionFile)

         except Exception as e:

             if chrootID is not None:

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

@@ -10,6 +10,7 @@ import PullSources

 import json

 import collections

 from SpecData import SPECS

+from distutils.version import LooseVersion

 class PackageUtils(object):

@@ -51,6 +52,26 @@ 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

@@ -67,11 +88,11 @@ class PackageUtils(object):

             shutil.copyfile(rpmFile,  rpmDestPath)

         return rpmDestPath

-    def installRPM(self,package,chrootID,noDeps=False,destLogPath=None):

+    def installRPM(self,package,version,chrootID,noDeps=False,destLogPath=None):

 #        self.logger.info("Installing rpm for package:"+package)

 #        self.logger.debug("No deps:"+str(noDeps))

-        rpmfile=self.findRPMFileForGivenPackage(package)

+        rpmfile=self.findRPMFileForGivenPackage(package,version)

         if rpmfile is None:

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

             raise Exception("Missing rpm file: "+package)

@@ -309,7 +330,7 @@ class PackageUtils(object):

         if len(listFoundRPMFiles) == 0 :

             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)

+            self.logger.error("Found multiple rpm files for given package in rpm directory.Unable to determine the rpm file for package:"+package+ " list:"+str(listFoundRPMFiles))

             raise Exception("Multiple rpm files found")

     def findPackageNameFromRPMFile(self,rpmfile):

@@ -418,8 +439,8 @@ class PackageUtils(object):

         rpmPath += rpmName

         return rpmPath

-    def prepRPMforInstallInContainer(self, package, containerID, noDeps=False, destLogPath=None):

-        rpmfile = self.findRPMFileForGivenPackage(package)

+    def prepRPMforInstallInContainer(self, package, version, containerID, noDeps=False, destLogPath=None):

+        rpmfile = self.findRPMFileForGivenPackage(package, version)

         if rpmfile is None:

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

             raise Exception("Missing rpm file")

@@ -7,7 +7,7 @@ from Queue import PriorityQueue

 from SpecData import SPECS

 class Scheduler(object):

-    

+

     lock=threading.Lock()

     listOfAlreadyBuiltPackages=[]

     listOfPackagesToBuild=[]

@@ -23,24 +23,23 @@ class Scheduler(object):

     logger=None

     event=None

     stopScheduling=False

-    

+

     @staticmethod

     def setEvent(event):

         Scheduler.event=event

-    

+

     @staticmethod

     def setLog(logName,logPath):

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

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

     @staticmethod

     def getBuildRequiredPackages(package):

         listRequiredRPMPackages = []

         listRequiredRPMPackages.extend(SPECS.getData().getBuildRequiresForPackage(package))

-

         listRequiredPackages = []

         for pkg in listRequiredRPMPackages:

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

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

             if basePkg not in listRequiredPackages:

                 listRequiredPackages.append(basePkg)

@@ -145,22 +144,20 @@ class Scheduler(object):

         Scheduler.listOfPackagesNextToBuild=[]

         Scheduler.listOfFailedPackages=[]

         Scheduler.setPriorities()

-        

+

     @staticmethod

     def getRequiredPackages(package):

         listRequiredRPMPackages=[]

         listRequiredRPMPackages.extend(SPECS.getData().getBuildRequiresForPackage(package))

         listRequiredRPMPackages.extend(SPECS.getData().getRequiresAllForPackage(package))

-        

         listRequiredPackages=[]

         for pkg in listRequiredRPMPackages:

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

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

             if basePkg not in listRequiredPackages:

                 listRequiredPackages.append(basePkg)

-        

         return listRequiredPackages

-    

+

     @staticmethod

     def __getListNextPackagesReadyToBuild():

         listOfPackagesNextToBuild=PriorityQueue()

@@ -230,28 +227,28 @@ class Scheduler(object):

         Scheduler.listOfPackagesCurrentlyBuilding.append(package)

         Scheduler.listOfPackagesToBuild.remove(package)

         return package

-    

+

     #can be synchronized TODO

     @staticmethod

     def notifyPackageBuildCompleted(package):

         if package in Scheduler.listOfPackagesCurrentlyBuilding:

             Scheduler.listOfPackagesCurrentlyBuilding.remove(package)

             Scheduler.listOfAlreadyBuiltPackages.append(package)

-    

-        

+

+

     #can be synchronized TODO

     @staticmethod

     def notifyPackageBuildFailed(package):

         if package in Scheduler.listOfPackagesCurrentlyBuilding:

             Scheduler.listOfPackagesCurrentlyBuilding.remove(package)

             Scheduler.listOfFailedPackages.append(package)

-                

+

     @staticmethod

     def isAllPackagesBuilt():

         if len(Scheduler.listOfPackagesToBuild) == 0 :

             return True

         return False

-    

+

     @staticmethod

     def isAnyPackagesFailedToBuild():

         if len(Scheduler.listOfFailedPackages) != 0:

@@ -177,6 +177,18 @@ class SpecObjectsUtils(object):

         specName=self.getSpecName(package)

         return len(self.mapSpecObjects[specName])

+    def getSpecObj(self, package):

+        specName=self.getSpecName(package)

+        return self.mapSpecObjects[specName]

+

+    def getPkgNamesFromObj(self, objlist):

+        listPkgName=[]

+        listPkgNames=list(set(objlist))

+        for name in listPkgNames:

+                listPkgName.append(name.package)

+        listPkgName=list(set(listPkgName))

+        return listPkgName

+

     def printAllObjects(self):

         listSpecs=self.mapSpecObjects.keys()

         for spec in listSpecs:

@@ -198,11 +210,11 @@ class SpecObjectsUtils(object):

             self.logger.info(" ")

             self.logger.info(" ")

             self.logger.info("Build require packages")

-            self.logger.info(specObj.buildRequirePackages)

+            self.logger.info(self.getPkgNamesFromObj(specObj.buildRequirePackages))

             self.logger.info(" ")

             self.logger.info(" ")

             self.logger.info("install require packages")

-            self.logger.info(specObj.installRequiresAllPackages)

+            self.logger.info(self.getPkgNamesFromObj(specObj.installRequiresAllPackages))

             self.logger.info(" ")

             self.logger.info(specObj.installRequiresPackages)

             self.logger.info("security_hardening: " + specObj.securityHardening)

@@ -364,11 +376,11 @@ class SerializedSpecObjects(object):

                     whoNeedsList.append(specPkg)

                 elif (inputType == "who-needs-build"):

                     for bdrq in specObj.buildRequirePackages:

-                        if (whoBuildDeps.has_key(bdrq)):

-                            whoBuildDeps[bdrq].add(specPkg)

+                        if (whoBuildDeps.has_key(bdrq.package)):

+                            whoBuildDeps[bdrq.package].add(specPkg)

                         else:

-                            whoBuildDeps[bdrq] = set()

-                            whoBuildDeps[bdrq].add(specPkg)

+                            whoBuildDeps[bdrq.package] = set()

+                            whoBuildDeps[bdrq.package].add(specPkg)

                     if(inputValue == specPkg):

                         packageFound = True

                         for depPkg in specObj.listPackages:

@@ -516,5 +528,5 @@ class SerializedSpecObjects(object):

         return self.mapSpecObjects[specName].securityHardening

     def getSpecDetails(self, name):

-        print self.mapSpecObjects[name].installRequiresAllPackages

+        print self.getPkgNamesFromObj(self.mapSpecObjects[name].installRequiresAllPackages)

@@ -147,12 +147,14 @@ class Specutils(object):

         for key in self.spec.packages.keys():

             pkg = self.spec.packages.get(key)

             for dpkg in pkg.requires:

-                dependentPackages.append(dpkg.package)

-        dependentPackages=list(set(dependentPackages))

+                dependentPackages.append(dpkg)

+        listDependentPackages = list(set(dependentPackages))

         packageNames=self.getPackageNames()

         for pkgName in packageNames:

-            if pkgName in dependentPackages:

-                dependentPackages.remove(pkgName)

+            for objName in listDependentPackages:

+                if objName.package == pkgName:

+                        dependentPackages.remove(objName)

+        dependentPackages = list(set(dependentPackages))

         return dependentPackages

     def getBuildRequiresAllPackages(self):

@@ -160,12 +162,14 @@ class Specutils(object):

         for key in self.spec.packages.keys():

             pkg = self.spec.packages.get(key)

             for dpkg in pkg.buildrequires:

-                dependentPackages.append(dpkg.package)

-        dependentPackages=list(set(dependentPackages))

+                dependentPackages.append(dpkg)

+        listDependentPackages = list(set(dependentPackages))

         packageNames=self.getPackageNames()

         for pkgName in packageNames:

-            if pkgName in dependentPackages:

-                dependentPackages.remove(pkgName)

+            for objName in listDependentPackages:

+                if objName.package == pkgName:

+                        dependentPackages.remove(objName)

+        dependentPackages = list(set(dependentPackages))

         return dependentPackages

     def getCheckBuildRequiresAllPackages(self):

@@ -173,8 +177,8 @@ class Specutils(object):

         for key in self.spec.packages.keys():

             pkg = self.spec.packages.get(key)

             for dpkg in pkg.checkbuildrequires:

-                dependentPackages.append(dpkg.package)

-        dependentPackages=list(set(dependentPackages))

+                dependentPackages.append(dpkg)

+        dependentPackages = list(set(dependentPackages))

         return dependentPackages

     def getRequires(self,pkgName):

@@ -10,6 +10,7 @@ import traceback

 import shutil

 import json

 import collections

+from SpecData import SPECS

 class ToolChainUtils(object):

@@ -117,8 +118,14 @@ class ToolChainUtils(object):

             traceback.print_exc()

             raise e

         return pkgCount

-                

-    def installToolChainRPMS(self,chrootID, packageName, listBuildOptionPackages, pkgBuildOptionFile, logPath=None):

+

+    def getListDependentPackageLineContent(self, index):

+        listBuildRequiresPkgLineContent=SPECS.getData().getBuildRequiresForPackage(self.package, index)

+        listBuildRequiresPkgLineContent.extend(SPECS.getData().getCheckBuildRequiresForPackage(self.package, index))

+        listBuildRequiresPkgLineContent=list(set(listBuildRequiresPkgLineContent))

+        return listBuildRequiresPkgLineContent

+

+    def installToolChainRPMS(self,chrootID, packageName, listBuildOptionPackages, pkgBuildOptionFile, logPath=None, index=0):

         if logPath is None:

             logPath=self.logPath

         cmdUtils = CommandUtils()

@@ -126,6 +133,9 @@ class ToolChainUtils(object):

         self.logger.info("Installing Tool Chain RPMS.......")

         rpmFiles = ""

         packages = ""

+        self.package=packageName

+        listBuildRequiresPackageLineContent = self.getListDependentPackageLineContent(index)

+

         for package in constants.listToolChainRPMsToInstall:

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

             rpmFile = None

@@ -144,7 +154,10 @@ class ToolChainUtils(object):

                         for override in overridelist:

                             if package == str(override["package"].encode('utf-8')):

                                 version = str(override["version"].encode('utf-8'))

-

+            if version == "*":

+                for depPkg in listBuildRequiresPackageLineContent:

+                        if depPkg.package == package:

+                                version=pkgUtils.getProperVersion(package,depPkg)

             if constants.rpmCheck:

                 rpmFile=pkgUtils.findRPMFileForGivenPackage(package, version)

             else:

@@ -178,7 +191,7 @@ class ToolChainUtils(object):

         if packageName in constants.perPackageToolChain:

             print constants.perPackageToolChain[packageName]

             self.installCustomToolChainRPMS(chrootID, constants.perPackageToolChain[packageName], packageName);

-   

+

     def installCustomToolChainRPMS(self, chrootID, listOfToolChainPkgs, packageName):

         self.logger.info("Installing package specific tool chain RPMs for " + packageName + ".......")

         rpmFiles = ""