@@ -112,7 +112,7 @@ class ChrootUtils(object):

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

             return False

         cmdUtils=CommandUtils()

-        cmdUtils.run_command("rm -rf "+chrootID)

+        cmdUtils.runCommandInShell("rm -rf "+chrootID)

         ChrootUtils.lockForTrackingChroots.acquire()

         ChrootUtils.lockForTrackingChroots.release()

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

@@ -1,29 +1,21 @@

 import subprocess

 import os

-import re

 class CommandUtils(object):

     def __init__(self):

-        self.rpmbuild_binary = "rpmbuild"

-        self.rpmbuild_buildall_option = "-ba"

-        self.rpmbuild_nocheck_option = "--nocheck"

-        self.rpm_binary = "rpm"

-        self.install_rpm_package_options = "-Uvh"

-        self.nodeps_rpm_package_options = "--nodeps"

-        self.query_rpm_package_options = "-qa"

-        self.force_rpm_package_options = "--force"

-        self.find_command = "find"

+        self.findBinary = "find"

-

-    def find_file (self, filename, sourcePath):

-        process = subprocess.Popen([self.find_command,  sourcePath,  "-name", filename],  stdout=subprocess.PIPE)

+    def findFile (self, filename, sourcePath):

+        process = subprocess.Popen([self.findBinary,  sourcePath,  "-name", filename],  stdout=subprocess.PIPE)

         returnVal = process.wait()

+        if returnVal != 0:

+            return None

         result=process.communicate()[0]

         if result is None:

             return None

         return result.split()

-    def run_command(self,cmd,logfilePath=None,chrootCmd=None):

+    def runCommandInShell(self,cmd,logfilePath=None,chrootCmd=None):

         if chrootCmd is not None:

             cmd = chrootCmd+" "+cmd

         if logfilePath is None:

@@ -35,59 +27,16 @@ class CommandUtils(object):

         if retval==0:

             return True

         return False

-

-    def find_installed_rpm_packages(self, chrootCmd=None):

-        cmd = self.rpm_binary+" "+self.query_rpm_package_options

+    

+    def runCommandInShell2(self,cmd,chrootCmd=None):

         if chrootCmd is not None:

             cmd = chrootCmd+" "+cmd

-        #process may hang if buffer is full

         process = subprocess.Popen("%s" %cmd,shell=True,stdout=subprocess.PIPE)

         retval = process.wait()

+        if retval != 0:

+            return None

         result = process.communicate()[0]

+        if result is None:

+            return None

         return result.split()

-    def installRPM(self, rpmfilepath,logfilePath, chrootCmd=None, withNodeps=False):

-        print "Installing RPM...",rpmfilepath

-        rpmInstallcmd=self.rpm_binary+" "+ self.install_rpm_package_options

-

-        if withNodeps:

-            rpmInstallcmd+=" "+self.nodeps_rpm_package_options

-

-        rpmInstallcmd+=" "+rpmfilepath

-        if chrootCmd is not None:

-            rpmInstallcmd= chrootCmd +" "+rpmInstallcmd

-        logfile=open(logfilePath,'w')

-        process = subprocess.Popen("%s" %rpmInstallcmd,shell=True,stdout=logfile,stderr=logfile)

-        retval = process.wait()

-        logfile.close()

-        if retval != 0:

-            return False

-        return True

-

-    def buildRPM(self, specfilepath, logfilePath, chrootCmd=None):

-        print "Building RPM...",specfilepath

-        rpmBuildcmd= self.rpmbuild_binary+" "+self.rpmbuild_buildall_option+" "+self.rpmbuild_nocheck_option

-        rpmBuildcmd+=" "+specfilepath

-        if chrootCmd is not None:

-            rpmBuildcmd=chrootCmd +" "+rpmBuildcmd

-

-        logfile=open(logfilePath,'w')

-        process = subprocess.Popen("%s" %rpmBuildcmd,shell=True,stdout=logfile,stderr=logfile)

-        retval = process.wait()

-        logfile.close()

-        if retval != 0:

-            print "Building rpm is failed"

-            return False, None

-

-        #Extracting rpms created from log file

-        logfile=open(logfilePath,'r')

-        fileContents=logfile.readlines()

-        logfile.close()

-        listRpms=[]

-        for i in range(0,len(fileContents)):

-            if re.search("^Wrote:",fileContents[i]):

-                listcontents=fileContents[i].split()

-                if (len(listcontents) == 2) and listcontents[1].strip()[-4:] == ".rpm" and listcontents[1].find("/RPMS/") != -1:

-                    listRpms.append(listcontents[1])

-

-        return True, listRpms

\ No newline at end of file

@@ -32,5 +32,5 @@ class MiscUtils(object):

 if __name__=="__main__":

     listInputFiles=["SpecParser.py","Logger.py"]

-    listOutputFiles=["Main.py"]

+    listOutputFiles=["builder.py"]

     print MiscUtils.isOutdated(listInputFiles, listOutputFiles)

\ No newline at end of file

@@ -3,7 +3,15 @@ from constants import constants

 from sets import Set

 import copy

-     

+

+

+def removeDuplicateEntriesInList(myList):

+    myListCopy=[]

+    for p in myList:

+        if p not in myListCopy:

+            myListCopy.append(p)

+    return myListCopy

+      

 class PackageBuildDataGenerator(object):

     cycleCount=0

@@ -24,154 +32,129 @@ class PackageBuildDataGenerator(object):

         self.__sortedBuildDependencyGraph={}

     def getPackageBuildData(self,listPackages):

-        if not self.__readDependencyGraphAndCyclesForGivenPackages(listPackages):

-            return False,None,None,None

-        

-        self.logger.info("sorted build order")

-        self.logger.info(self.__sortedBuildDependencyGraph)

-        #self.logger.info("Map cycles to package list")

-        #self.logger.info(self.__mapCyclesToPackageList)

+        self.__readDependencyGraphAndCyclesForGivenPackages(listPackages)

+        self.__getSortedBuildOrderListForGivenPackages(listPackages)

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

-        if not self.__getSortedBuildOrderListForGivenPackages(listPackages):

-            return False,None,None,None

+    #todo    

+    def findCompleteListOfPackagesRequiredToBuildGivenPackages(self,listPackages):

+        return self.__buildDependencyGraph.keys()    

+ 

+    def createSortListForPkg(self,pkg):

+        runTimeDepPkgList=self.__runTimeDependencyGraph[pkg]

+        runTimeDepPkgList.append(pkg)

+        sortListForPkg=[]

-        return True,self.__mapCyclesToPackageList,self.__mapPackageToCycle,self.__sortedPackageList

+        for p in runTimeDepPkgList:

+            basePkg=constants.specData.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):

-        #should not include toolchain packages

         alreadyProcessedPackages=[]

-        sList=[]

-        listPackagesCopy=self.__buildDependencyGraph.keys()#listPackages[:]

-        sortedListIndex = 0

+        sortedList=[]

+        completeListPackagesToBuild=self.findCompleteListOfPackagesRequiredToBuildGivenPackages(listPackages)

+        packageIndexInSortedList = 0

+        prevSortListLen=0

-        listPkgsRequiredToBuildToolchain=["linux-api-headers", "glibc","glibc-devel",  "zlib","zlib-devel",  "file",

-            "binutils","binutils-devel",  "gmp","gmp-devel", "mpfr", "mpfr-devel", "mpc",

-            "libgcc","libgcc-devel","libstdc++","libstdc++-devel","libgomp","libgomp-devel","gcc",

-            "pkg-config", "ncurses", "bash", "bzip2", "sed","ncurses-devel","procps-ng","coreutils", "m4","grep",

-            "readline", "diffutils","gawk", "findutils", "gettext", "gzip","make",  "patch",

-            "util-linux", "tar", "xz","libtool", "flex",  "bison",

-            "readline-devel", "lua","lua-devel","popt","popt-devel","nspr","sqlite-autoconf","nss","nss-devel",

-            "bzip2-devel","elfutils-libelf","elfutils","elfutils-libelf-devel","elfutils-devel",

-            "expat","libffi","libpipeline", "gdbm","perl","texinfo","autoconf","automake",

-            "openssl","openssl-devel","python2","python2-libs","python2-devel","rpm",

-            "groff", "man-db", "man-pages","cpio"]

-        '''

-        toolChainPackagesCount=0

-        toolChainPackagelist=[]

-        for p in listPkgsRequiredToBuildToolchain:

-            basePkg=constants.specData.getSpecName(p)

-            if basePkg in listPackagesCopy:

-                listPackagesCopy.remove(basePkg)

-                toolChainPackagelist.append(basePkg)

-                toolChainPackagesCount = toolChainPackagesCount + 1

-        '''

-        sListLenBackUp=0

-        while listPackagesCopy:

-            pkg = None

-            lenIndex=len(sList)

-            for  i in range(lenIndex):

-                if sList[i] in alreadyProcessedPackages:

+        while completeListPackagesToBuild:

+            

+            # find next package to process

+            pkg=None

+            index=-1

+            lenList=len(sortedList)

+            for  i in range(lenList):

+                if sortedList[i] in alreadyProcessedPackages:

                     continue

-                pkg = sList[i]

-                sortedListIndex = i

+                pkg = sortedList[i]

+                packageIndexInSortedList = i

                 break

-            

             if pkg is None:

-                pkg = listPackagesCopy.pop()

-                sortedListIndex = len(sList)

-            

-            rbrList=[]

-            for p in self.__runTimeDependencyGraph[pkg]:

-                if p not in rbrList:

-                    rbrList.append(p)

-            rbrList.append(pkg)

-            brList=[]

-            

-            for p in rbrList:

-                basePkg=constants.specData.getSpecName(p)

-                for bPkg in self.__sortedBuildDependencyGraph[basePkg]:

-                    if bPkg not in brList:

-                        brList.append(bPkg)

-            

-            #remove any cyclic packages in brList if they exists in sList

-            circularDependentPackages=[]

-            if self.__mapPackageToCycle.has_key(pkg):

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

-                circularDependentPackages.remove(pkg)

+                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 sList:

-                    if p in brList:

-                        brList.remove(p)

+                if p in sortedList and p in sortListForPkg:

+                    sortListForPkg.remove(p)

-            index=sortedListIndex

+            # insert sort list of package in global sorted list

+            index=packageIndexInSortedList

             subList=[]

-            if sortedListIndex > 0:

-                subList=sList[:sortedListIndex]

-            for p in brList:

+            if packageIndexInSortedList > 0:

+                subList=sortedList[:packageIndexInSortedList]

+            for p in sortListForPkg:

                 if  p not in subList:

-                    sList.insert(index, p)

+                    sortedList.insert(index, p)

                     index = index + 1

+            

             alreadyProcessedPackages.append(p)

-            if (len(sList)-sListLenBackUp) > 100 :

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

-                sListCopy=[]

-                for p in sList:

-                    if p not in sListCopy:

-                        sListCopy.append(p)

-                sList = sListCopy

+            # Remove duplicate entries in sorted list in intervals

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

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

+                sortedList = removeDuplicateEntriesInList(sortedList)

             else:

-                sListLenBackUp=len(sList)

+                prevSortListLen=len(sortedList)

-        self.logger.info("Only final step remains....")

-        sListCopy=[]

-        for p in sList:

-            #if p in toolChainPackagelist:

-            #    continue

-            if p not in sListCopy:

-                sListCopy.append(p)

-        sList = sListCopy

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

-        self.logger.info("sorted list")

-        self.logger.info(sList)

-        self.__sortedPackageList=sList

-        return True

+        basePackage=constants.specData.getSpecName(package)

+

+        addBuildTimeGraph=True

+        addRunTimeGraph=True

+        if self.__buildDependencyGraph.has_key(basePackage):

+            addBuildTimeGraph = False

+        if self.__runTimeDependencyGraph.has_key(basePackage):

+            addRunTimeGraph=False

-    def __constructBuildTimeDependencyGraph(self,package):

-        if self.__buildDependencyGraph.has_key(package):

-            return True

-        listDependentRpmPackages=constants.specData.getBuildRequiresForPackage(package)

-        listDependentPackages=[]

-        for rpmPkg in listDependentRpmPackages:

-            basePkg=constants.specData.getSpecName(rpmPkg)

-            if basePkg not in listDependentPackages:

-                listDependentPackages.append(basePkg)

-                

-        self.__buildDependencyGraph[package]=listDependentPackages

-        for basePkg in listDependentPackages:

-            self.__constructBuildTimeDependencyGraph(basePkg)

-            self.__constructRunTimeDependencyGraph(basePkg)

-    

-    def __constructRunTimeDependencyGraph(self,package):

-        if self.__runTimeDependencyGraph.has_key(package):

-            return True

-        listRpmPackages=constants.specData.getPackages(package)

-        for rpmPkg in listRpmPackages:

-            listDependentRpmPackages=constants.specData.getRequiresAllForPackage(rpmPkg)

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

-        for rpmPkg in listRpmPackages:

-            for pkg in self.__runTimeDependencyGraph[rpmPkg]:

-                self.__constructRunTimeDependencyGraph(pkg)

-                self.__constructBuildTimeDependencyGraph(pkg)

+        nextPackagesToConstructGraph=[]

+        if addBuildTimeGraph:

+            listDependentRpmPackages=constants.specData.getBuildRequiresForPackage(basePackage)

+            listDependentPackages=[]

+            for rpmPkg in listDependentRpmPackages:

+                basePkg=constants.specData.getSpecName(rpmPkg)

+                if basePkg not in listDependentPackages:

+                    listDependentPackages.append(basePkg)

+            self.__buildDependencyGraph[basePackage]=listDependentPackages

+            nextPackagesToConstructGraph.extend(listDependentPackages)

+        

+        if addRunTimeGraph:

+            listRpmPackages=constants.specData.getPackages(basePackage)

+            for rpmPkg in listRpmPackages:

+                listDependentRpmPackages=constants.specData.getRequiresAllForPackage(rpmPkg)

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

+                nextPackagesToConstructGraph.extend(listDependentRpmPackages)

+        for pkg in nextPackagesToConstructGraph:

+            self.__constructBuildAndRunTimeDependencyGraph(pkg)

+    

     def __readDependencyGraphAndCyclesForGivenPackages(self,listPackages):

         for pkg in listPackages:

-            self.__constructBuildTimeDependencyGraph(pkg)

-            self.__constructRunTimeDependencyGraph(pkg)

+            self.__constructBuildAndRunTimeDependencyGraph(pkg)

         packagesToBUild=self.__buildDependencyGraph.keys()

         for pkg in packagesToBUild:

@@ -179,21 +162,20 @@ class PackageBuildDataGenerator(object):

             if len(circularDependentPackages) > 0 :

                 self.logger.error("Found circular dependency")

                 self.logger.error(circularDependentPackages)

-                return False

+                raise Exception("Build Time Circular Dependency")

             self.__sortedBuildDependencyGraph[pkg]=sortedPackageList

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

         if len(circularDependentPackages) > 0 :

             self.__findCircularDependencies(circularDependentPackages)

-        return True

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

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

         noDepPackages = Set()

         sortedPackageList = []

         dependentOfPackage = dict()

         dependentPackages={}

         if package is None:

-            dependentPackages=copy.deepcopy(dependentPackages1)

+            dependentPackages=copy.deepcopy(dependencyGraph)

         else:

             listDepPkgs= Set()

             listDepPkgs.add(package)

@@ -201,9 +183,10 @@ class PackageBuildDataGenerator(object):

                 pkg = listDepPkgs.pop()

                 if dependentPackages.has_key(pkg):

                     continue

-                dependentPackages[pkg]=dependentPackages1[pkg][:]

-                for depPkg in dependentPackages1[pkg]:

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

@@ -226,28 +209,28 @@ class PackageBuildDataGenerator(object):

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

                         noDepPackages.add(childPkg)

-        circularDependentGraph={}

+        # creating circular dependency graph for given dependency graph

+        circularDependencyGraph={}

         listCircularPkg = dependentPackages.keys()

         for pkg in listCircularPkg:

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

-                circularDependentGraph[pkg]=dependentPackages[pkg]

+                circularDependencyGraph[pkg]=dependentPackages[pkg]

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

-        return sortedPackageList,circularDependentGraph

+        return sortedPackageList,circularDependencyGraph

-    def __findCircularDependencies(self,cyclicDependentGraph):

-        if len(cyclicDependentGraph) == 0:

-            return True

-        #step1: construct dependency map from dependency graph

+    

+    def __constructDependencyMap(self,cyclicDependencyGraph):

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

         constructDependencyMap={}

-        listNodes=cyclicDependentGraph.keys()

+        listNodes=cyclicDependencyGraph.keys()

         for node in listNodes:

             tmpDepNodeList=[]

             tmpDepNodeList.append(node)

             depNodeList=[]

             while len(tmpDepNodeList)!=0:

                 currentNode = tmpDepNodeList.pop()

-                addDepNodeList = cyclicDependentGraph[currentNode]

+                addDepNodeList = cyclicDependencyGraph[currentNode]

                 depNodeList.append(currentNode)

                 for depNode in addDepNodeList:

                     if depNode in depNodeList:

@@ -259,8 +242,19 @@ class PackageBuildDataGenerator(object):

             constructDependencyMap[node]=depNodeList

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

         self.logger.info(constructDependencyMap)

+        return constructDependencyMap

+        

+        

+    def __findCircularDependencies(self,cyclicDependencyGraph):

+        if len(cyclicDependencyGraph) == 0:

+            return

+        #step1: construct dependency map from dependency graph

+        constructDependencyMap=self.__constructDependencyMap(cyclicDependencyGraph)

-        #find cycles in dependency map

+        #step2: find cycles in dependency map

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

+        cycleCount=0

+        listNodes=cyclicDependencyGraph.keys()

         for node in listNodes:

             listDepPkg=constructDependencyMap[node]

             cycPkgs=[]

@@ -277,9 +271,16 @@ class PackageBuildDataGenerator(object):

                     for x in cycPkgs:

                         self.__mapPackageToCycle[x]=cycleName

                     self.__mapCyclesToPackageList[cycleName]=cycPkgs

-                    self.logger.info("New Circular dependency found")

-                    self.logger.info(cycPkgs)

-        return True

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

+        

@@ -8,12 +8,6 @@ from constants import constants

 class PackageBuilder(object):

-    #logger=None

-    

-    #@staticmethod

-    #def setLog(logPath):

-    #   PackageBuilder.logger=Logger.getLogger(logPath+"/PackageBuilder")

-    

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

         if logName is None:

             logName = "PackageBuilder"

@@ -22,22 +16,25 @@ class PackageBuilder(object):

         self.logName=logName

         self.logPath=logPath

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

-        self.runInChrootCommand="./run-in-chroot.sh"

         self.mapPackageToCycles = mapPackageToCycles

         self.listAvailableCyclicPackages = listAvailableCyclicPackages

         self.listNodepsPackages = ["glibc","gmp","zlib","file","binutils","mpfr","mpc","gcc","ncurses","util-linux","groff","perl","texinfo","rpm","openssl","go"]

     #assumes tool chain is already built

     def prepareBuildRoot(self):

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

-        returnVal,chrootID = chrUtils.createChroot()

-        if not returnVal:

-            self.logger.error("Unable to build tool chain.")

-            chrUtils.destroyChroot(chrootID)

-            return False 

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

-        returnVal = tUtils.installToolChain(chrootID)

-        return returnVal,chrootID

+        chrootID=None

+        try:

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

+            returnVal,chrootID = chrUtils.createChroot()

+            if not returnVal:

+                raise Exception("Unable to prepare build root")

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

+            tUtils.installToolChain(chrootID)

+        except Exception as e:

+            if chrootID is not None:

+                chrUtils.destroyChroot(chrootID)

+            raise e

+        return chrootID

     def findPackageNameFromRPMFile(self,rpmfile):

         rpmfile=os.path.basename(rpmfile)

@@ -53,8 +50,8 @@ class PackageBuilder(object):

         return packageName

     def findInstalledPackages(self,chrootID):

-        cmdUtils = CommandUtils()

-        listInstalledRPMs=cmdUtils.find_installed_rpm_packages(self.runInChrootCommand+" "+chrootID)

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

+        listInstalledRPMs=pkgUtils.findInstalledRPMPackages(chrootID)

         listInstalledPackages=[]

         for installedRPM in listInstalledRPMs:

             packageName=self.findPackageNameFromRPMFile(installedRPM)

@@ -63,90 +60,74 @@ class PackageBuilder(object):

         return listInstalledPackages

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

-        returnVal=self.buildPackage(package)

-        outputMap[threadName]=returnVal

+        try:

+            self.buildPackage(package)

+            outputMap[threadName]=True

+        except Exception as e:

+            self.logger.error(e)

+            outputMap[threadName]=False

     def buildPackage(self,package):

         #should initialize a logger based on package name

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

-        returnVal,chrootID = self.prepareBuildRoot()

-        if not returnVal:

-            return False

-        

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

-        if not os.path.isdir(destLogPath):

-            cmdUtils = CommandUtils()

-            cmdUtils.run_command("mkdir -p "+destLogPath)

-        

-        listInstalledPackages=self.findInstalledPackages(chrootID)

-        self.logger.info("List of installed packages")

-        self.logger.info(listInstalledPackages)

-        returnVal,listDependentPackages=self.findBuildTimeRequiredPackages(package)

-        if not returnVal:

-            chrUtils.destroyChroot(chrootID)

-            self.logger.error ("Failed during building the package"+package)

-            return False

-        

-        if len(listDependentPackages) != 0:

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

-            for pkg in listDependentPackages:

-                returnVal = self.installPackage(pkg,chrootID,destLogPath,listInstalledPackages)

-                if not returnVal:

-                    self.logger.error("Failed while installing the build time dependent package"+pkg)

-                    chrUtils.destroyChroot(chrootID)

-                    return False

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

+        chrootID=None

+        try:

+            chrootID = self.prepareBuildRoot()

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

+            if not os.path.isdir(destLogPath):

+                cmdUtils = CommandUtils()

+                cmdUtils.runCommandInShell("mkdir -p "+destLogPath)

+            

+            listInstalledPackages=self.findInstalledPackages(chrootID)

+            self.logger.info("List of installed packages")

+            self.logger.info(listInstalledPackages)

+            listDependentPackages=self.findBuildTimeRequiredPackages(package)

+            

+            if len(listDependentPackages) != 0:

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

+                for pkg in listDependentPackages:

+                    self.installPackage(pkg,chrootID,destLogPath,listInstalledPackages)

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

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

-        returnVal = pkgUtils.buildRPMSForGivenPackage(package,chrootID,destLogPath)

-        if not returnVal:

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

-            chrUtils.destroyChroot(chrootID)

-            return False

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

-        chrUtils.destroyChroot(chrootID)

-        return True

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

+            pkgUtils.buildRPMSForGivenPackage(package,chrootID,destLogPath)

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

+        except Exception as e:

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

+            raise e

+        finally:

+            if chrootID is not None:

+                chrUtils.destroyChroot(chrootID)

+        

     def findRunTimeRequiredRPMPackages(self,rpmPackage):

         listRequiredPackages=constants.specData.getRequiresForPackage(rpmPackage)

-        return True,listRequiredPackages

+        return listRequiredPackages

     def findBuildTimeRequiredPackages(self,package):

         listRequiredPackages=constants.specData.getBuildRequiresForPackage(package)

-        return True,listRequiredPackages

+        return listRequiredPackages

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

-        #if toolchain package called this method, preventing from installing again

         if package in listInstalledPackages:

-            return True

-        returnVal = self.installDependentRunTimePackages(package,chrootID,destLogPath,listInstalledPackages)

-        if not returnVal:

-            return False

+            return

+        self.installDependentRunTimePackages(package,chrootID,destLogPath,listInstalledPackages)

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

         noDeps=False

         if self.mapPackageToCycles.has_key(package):

             noDeps = True

         if package in self.listNodepsPackages:

             noDeps=True

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

-        if not returnVal:

-            self.logger.error("Stop installing package"+package)

-            return False

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

         listInstalledPackages.append(package)

         self.logger.info("Installed the package:"+package)

-        return True

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

-        returnVal,listRunTimeDependentPackages=self.findRunTimeRequiredRPMPackages(package)

-        if not returnVal:

-            return False

+        listRunTimeDependentPackages=self.findRunTimeRequiredRPMPackages(package)

         if len(listRunTimeDependentPackages) != 0:

             for pkg in listRunTimeDependentPackages:

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

                     continue

                 if pkg in listInstalledPackages:

                     continue

-                returnVal = self.installPackage(pkg,chrootID,destLogPath,listInstalledPackages)

-                if not returnVal:

-                    return False

-        return True

+                self.installPackage(pkg,chrootID,destLogPath,listInstalledPackages)

@@ -6,6 +6,7 @@ import time

 from PackageBuilder import PackageBuilder

 import os

 from PackageUtils import PackageUtils

+from ToolChainUtils import ToolChainUtils

 class PackageManager(object):

@@ -28,10 +29,10 @@ class PackageManager(object):

         self.listPackagesToBuild=[]

     def readPackageBuildData(self, listPackages):

-        pkgBuildDataGen = PackageBuildDataGenerator(self.logName,self.logPath)

-        returnVal,self.mapCyclesToPackageList,self.mapPackageToCycle,self.sortedPackageList = pkgBuildDataGen.getPackageBuildData(listPackages)

-        

-        if not returnVal:

+        try:

+            pkgBuildDataGen = PackageBuildDataGenerator(self.logName,self.logPath)

+            self.mapCyclesToPackageList,self.mapPackageToCycle,self.sortedPackageList = pkgBuildDataGen.getPackageBuildData(listPackages)

+        except:

             self.logger.error("unable to get sorted list")

             return False

@@ -162,6 +163,10 @@ class PackageManager(object):

         return returnVal    

     def buildPackages (self, listPackages):

+        

+        tUtils=ToolChainUtils()

+        tUtils.buildToolChain()

+        

         returnVal=self.calculateParams(listPackages)

         if not returnVal:

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

@@ -3,6 +3,7 @@ from Logger import Logger

 import os

 import shutil

 from constants import constants

+import re

 class PackageUtils(object):

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

         self.logPath=logPath

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

         self.runInChrootCommand="./run-in-chroot.sh"

+        self.rpmBinary = "rpm"

+        self.installRPMPackageOptions = "-Uvh"

+        self.nodepsRPMPackageOptions = "--nodeps"

+        self.rpmbuildBinary = "rpmbuild"

+        self.rpmbuildBuildallOption = "-ba"

+        self.rpmbuildNocheckOption = "--nocheck"

+        self.queryRpmPackageOptions = "-qa"

+        self.forceRpmPackageOptions = "--force"

     def getRPMDestDir(self,rpmName,rpmDir):

         arch=""

@@ -24,7 +33,6 @@ class PackageUtils(object):

             arch='x86_64'

         elif rpmName.find("noarch") != -1:

             arch="noarch"

-        #else: Todo throw an exeption

         rpmDestDir=rpmDir+"/"+arch

         return rpmDestDir

@@ -33,52 +41,55 @@ class PackageUtils(object):

         rpmName=os.path.basename(rpmFile)

         rpmDestDir=self.getRPMDestDir(rpmName,destDir)

         if not os.path.isdir(rpmDestDir):

-            cmdUtils.run_command("mkdir -p "+rpmDestDir)

+            cmdUtils.runCommandInShell("mkdir -p "+rpmDestDir)

         rpmDestPath=rpmDestDir+"/"+rpmName

         shutil.copyfile(rpmFile,  rpmDestPath)

         return rpmDestPath

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

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

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

+        

         rpmfile=self.findRPMFileForGivenPackage(package)

         if rpmfile is None:

-            self.logger.error("unexpected error")

-            self.logger.error("Stopping installing package:"+package)

-            return False

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

+            raise Exception("Missing rpm file")

         rpmDestFile = self.copyRPM(rpmfile, chrootID+constants.topDirPath+"/RPMS")

         rpmFile=rpmDestFile.replace(chrootID,"")

         chrootCmd=self.runInChrootCommand+" "+chrootID

         logFile=chrootID+constants.topDirPath+"/LOGS"+"/"+package+".completed"

-

+        

+        rpmInstallcmd=self.rpmBinary+" "+ self.installRPMPackageOptions

+        if noDeps:

+            rpmInstallcmd+=" "+self.nodepsRPMPackageOptions

+        rpmInstallcmd+=" "+rpmFile

+        

         cmdUtils = CommandUtils()

-        returnVal = cmdUtils.installRPM(rpmFile,logFile,chrootCmd,noDeps)

+        returnVal = cmdUtils.runCommandInShell(rpmInstallcmd, logFile, chrootCmd)

         if destLogPath is not None:

             shutil.copy2(logFile, destLogPath)

         if not returnVal:

-            self.logger.error("Installing " + rpmFile+" rpm is failed")

-            return False

-        return True   

+            self.logger.error("Unable to install rpm:"+ rpmFile)

+            raise Exception("RPM installation failed")

     def copySourcesTobuildroot(self,listSourceFiles,package,destDir):

         cmdUtils = CommandUtils()

         for source in listSourceFiles:

-            sourcePath = cmdUtils.find_file(source,constants.sourcePath)

+            sourcePath = cmdUtils.findFile(source,constants.sourcePath)

             if sourcePath is None or len(sourcePath) == 0:

-                sourcePath = cmdUtils.find_file(source,constants.specPath)

+                sourcePath = cmdUtils.findFile(source,constants.specPath)

             if sourcePath is None or len(sourcePath) == 0:

                 self.logger.error("Missing source: "+source+". Cannot find sources for package: "+package)

-                self.logger.error("Stopping building toolchain")

-                return False

+                raise Exception("Missing source")

             if len(sourcePath) > 1:

-                self.logger.error("Multiple sources found: Unable to determine one. ")

-                self.logger.error("Stopping building toolchain")

-                return False

+                self.logger.error("Multiple sources found for source:"+source+"\n"+ ",".join(sourcePath) +"\nUnable to determine one.")

+                raise Exception("Multiple sources found")

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

-            shutil.copyfile(sourcePath[0],  destDir+source)

+            shutil.copy2(sourcePath[0],  destDir)

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

-        self.logger.info("Building package......"+package)

-        #self.adjust_gcc_specs(package)

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

         listSourcesFiles = constants.specData.getSources(package)

         listPatchFiles =  constants.specData.getPatches(package)

@@ -94,48 +105,66 @@ class PackageUtils(object):

         self.copySourcesTobuildroot(listSourcesFiles,package,chrootSourcePath)

         self.copySourcesTobuildroot(listPatchFiles,package,chrootSourcePath)

-        returnVal,listRPMFiles = self.buildRPM(chrootSpecPath+"/"+specName,chrootLogsFilePath, chrootCmd)

+        listRPMFiles = self.buildRPM(chrootSpecPath+"/"+specName,chrootLogsFilePath, chrootCmd)

         if destLogPath is not None:

             shutil.copy2(chrootLogsFilePath, destLogPath)

-        

-        if not returnVal:

-            return False

-        

+

         for rpmFile in listRPMFiles:

             self.copyRPM(chrootID+"/"+rpmFile, constants.rpmPath)

-        return True

     def buildRPM(self,specFile,logFile,chrootCmd):

+        

+        rpmBuildcmd= self.rpmbuildBinary+" "+self.rpmbuildBuildallOption+" "+self.rpmbuildNocheckOption

+        rpmBuildcmd+=" "+specFile

+        

         cmdUtils = CommandUtils()

-        returnVal,listRPMFiles = cmdUtils.buildRPM(specFile,logFile,chrootCmd)

+        returnVal = cmdUtils.runCommandInShell(rpmBuildcmd, logFile, chrootCmd)

         if not returnVal:

             self.logger.error("Building rpm is failed "+specFile)

-            return False,None

-        return True,listRPMFiles    

+            raise Exception("RPM Build failed")

+        

+        #Extracting rpms created from log file

+        logfile=open(logFile,'r')

+        fileContents=logfile.readlines()

+        logfile.close()

+        listRPMFiles=[]

+        for i in range(0,len(fileContents)):

+            if re.search("^Wrote:",fileContents[i]):

+                listcontents=fileContents[i].split()

+                if (len(listcontents) == 2) and listcontents[1].strip()[-4:] == ".rpm" and listcontents[1].find("/RPMS/") != -1:

+                    listRPMFiles.append(listcontents[1])

+