@@ -113,8 +113,13 @@ class ChrootUtils(object):

             return False

         cmdUtils=CommandUtils()

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

-        ChrootUtils.lockForTrackingChroots.acquire()

-        ChrootUtils.lockForTrackingChroots.release()

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

         return True

-

+    

+    def cleanUpActiveChroots(self):

+        ChrootUtils.lockForTrackingChroots.acquire()

+        listChroots=self.activeChroots[:]

+        ChrootUtils.lockForTrackingChroots.release()

+        for chrootID in listChroots:

+            self.destroyChroot(chrootID)

+        self.logger.info("Successfully destroyed all active chroots")

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

         except:

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

             return False

-        

         return True

     def getRequiredPackages(self,package):

@@ -101,16 +100,17 @@ class PackageManager(object):

         readyToLaunchMoreThreads = False

         listThreadsObjToRemove=[]

         for t in self.listThreads:

-            self.logger.info("Checking thread "+t)

+            self.logger.debug("Checking thread "+t +", whether it is completed or not")

             #check if any thread is completed. If completed, we can start more threads.

             if self.mapOutputThread.has_key(t):

                 output = self.mapOutputThread[t]

                 self.logger.info("Output of thread "+t+" "+str(output))

                 if not output:

                     self.logger.error("Thread "+ t+" is failed ")

-                    #kill remaining Threads

-                    return False,False

+                    self.logger.error("Unable to build package "+t)

+                    raise Exception("Package builder failed")

                 else:

+                    self.logger.debug("Still running, not completed yet")

                     readyToLaunchMoreThreads=True

                     self.listPackagesToBuild.remove(t)

                     self.listOfPackagesAlreadyBuilt.append(t)

@@ -119,93 +119,106 @@ class PackageManager(object):

                         self.listAvailableCyclicPackages.append(t)

         if not readyToLaunchMoreThreads:

-            return True,False

+            return False

         for k in listThreadsObjToRemove:

-            self.listThreads.pop(k)

-        

-        return True,True

+            tObj=self.listThreads.pop(k)

+            if tObj.isAlive():

+                self.logger.info("Thread is alive")

+            else:

+                self.logger.info("Thread is dead")

+            self.logger.info(tObj.isAlive())

+

+        return True

     def checkIfAnyThreadsAreHanged(self):

         currentTime = time.time()

         listThreadsHanged=[]

         for t in self.listThreads:

-            self.logger.info("Checking thread "+t)

+            self.logger.debug("Checking thread "+t +", whether it is hanged or not")

             if not self.mapOutputThread.has_key(t):

-                self.logger.info("Calculating running time for thread "+t)

+                self.logger.debug("Calculating running time for thread "+t)

                 launchTime = self.mapThreadsLaunchTime[t]

                 if (currentTime - launchTime) > 3600.0:

                     listThreadsHanged.append(t)

         if len(listThreadsHanged) > 0:

-            self.logger.info("Looks like following threads are hanged")

+            self.logger.info("Following threads are hanged")

             self.logger.info(listThreadsHanged)

-            #kill all threads

-            return False

-        

-        return True

+            raise Exception("Threads are hanged")

     def waitTillNewThreadsCanBeSpawned(self):

         if len(self.listThreads) == 0:

-            return True

-        returnVal = False

+            return

         while True:

-            sucess,Tfail = self.checkIfAnyThreadsAreCompleted()

-            if not sucess:

-                break

-            if sucess and Tfail:

-                returnVal = True

-                break

-            if not self.checkIfAnyThreadsAreHanged():

+            if self.checkIfAnyThreadsAreCompleted():

                 break

+            self.checkIfAnyThreadsAreHanged()

             self.logger.info("Sleeping for 30 seconds")

             time.sleep(30)

-        return returnVal    

+    

+    def buildToolChain(self):

+        try:

+            tUtils=ToolChainUtils()

+            tUtils.buildToolChain()

+        except Exception as e:

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

+            self.logger.error(e)

+            return False

-    def buildPackages (self, listPackages):

+        return True

-        tUtils=ToolChainUtils()

-        tUtils.buildToolChain()

+    def buildPackages (self, listPackages):

+        if not self.buildToolChain():

+            return False

+

         returnVal=self.calculateParams(listPackages)

         if not returnVal:

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

             return False

-        returnVal = True

-        while len(self.listPackagesToBuild) > 0:

-            #Free some threads to launch next threads

-            if not self.waitTillNewThreadsCanBeSpawned():

-                returnVal = False

-                break

-            

-            listOfPackagesCanBeBuild=self.findNextPackageToBuild()

-            if len(listOfPackagesCanBeBuild) == 0 and len(self.listPackagesToBuild) != 0:

-                self.logger.info("Waiting for current threads to complete to launch building new packages")

-            

-            for pkg in listOfPackagesCanBeBuild:

-                currentTime = time.time()

-                pkgBuilder = PackageBuilder(self.mapPackageToCycle,self.listAvailableCyclicPackages,"build-"+pkg,constants.logPath)

-                t = threading.Thread(target=pkgBuilder.buildPackageThreadAPI,args=(pkg,self.mapOutputThread,pkg))

-                self.listThreads[pkg]=t

-                self.mapThreadsLaunchTime[pkg]=currentTime

-                self.logger.info("Launching thread for package:"+pkg)

-                t.start()

-                self.logger.info("Started the thread for "+pkg)

-            

-            if len(self.listThreads) == 0 and len(self.listPackagesToBuild) != 0:

-                self.logger.error("Following packages are waiting for unknown package")

-                self.logger.error(self.listPackagesToBuild)

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

-                returnVal = False

-                break

-        

-        if not returnVal:

-            self.logger.error("Failed and exited gracefully")

-            return False

-        self.logger.info( "Successfully built all the packages")

-        return True            

+        returnVal = True

+        try:

+            while len(self.listPackagesToBuild) > 0:

+                #Free some threads to launch next threads

+                self.waitTillNewThreadsCanBeSpawned()

+                

+                listOfPackagesCanBeBuild=self.findNextPackageToBuild()

+                if len(listOfPackagesCanBeBuild) == 0 and len(self.listPackagesToBuild) != 0:

+                    self.logger.info("Waiting for current threads to complete to launch building new packages")

+                

+                for pkg in listOfPackagesCanBeBuild:

+                    currentTime = time.time()

+                    pkgBuilder = PackageBuilder(self.mapPackageToCycle,self.listAvailableCyclicPackages,"build-"+pkg,constants.logPath)

+                    t = threading.Thread(target=pkgBuilder.buildPackageThreadAPI,args=(pkg,self.mapOutputThread,pkg))

+                    self.listThreads[pkg]=t

+                    self.mapThreadsLaunchTime[pkg]=currentTime

+                    self.logger.info("Launching thread for package:"+pkg)

+                    t.start()

+                    self.logger.info("Started the thread for "+pkg)

+                if len(self.listThreads) == 0 and len(self.listPackagesToBuild) != 0:

+                    self.logger.error("Following packages are waiting for unknown package")

+                    self.logger.error(self.listPackagesToBuild)

+                    raise Exception("Invalid Schedule order")

+                    

+            self.logger.info( "Successfully built all the packages")

+

+        except Exception as e:

+            self.logger.error(str(e))

+            self.logger.error("Caught exception.")

+            self.logger.error("Failed and exited gracefully")

+            returnVal = False

+        finally:

+            if len(self.listThreads) > 0:

+                self.killAllThreads()

+        return returnVal

+    

+    def killAllThreads(self):

+        self.logger.info("Killing all remaining threads")

+        return

+    

     def findNextPackageToBuild(self):

         listOfPackagesNextToBuild=[]

         self.logger.info("Checking for next possible packages to build")

@@ -84,15 +84,13 @@ class ToolChainUtils(object):

             if chrootID is not None:

                 chrUtils.destroyChroot(chrootID)

-    #tool chain should be updated before calling this method

+    #Tool chain should be built before calling this method

     def installToolChain(self,chrootID):

         self.logger.info("Installing toolchain.....")

         self.prepareChroot(chrootID,"minimal")

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

         for package in self.listPkgsToInstallToolChain:

             pkgUtils.installRPM(package, chrootID, True)

-            if package == "glibc":

-                self.adjustToolChain(chrootID)

         cmdUtils=CommandUtils()

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

         cmdUtils.runCommandInShell("rm "+ chrootID+"/"+constants.topDirPath+"/RPMS/x86_64/*")

@@ -4,15 +4,9 @@ from optparse import OptionParser

 import os.path

 from CommandUtils import CommandUtils

 from Logger import Logger

-from SpecData import SerializableSpecObjectsUtils

-from ChrootUtils import ChrootUtils

-from PackageUtils import PackageUtils

-from ToolChainUtils import ToolChainUtils

 from constants import constants

-from PackageBuildDataGenerator import PackageBuildDataGenerator

 from PackageManager import PackageManager 

-

 def main():

     usage = "Usage: %prog [options] <package name>"

     parser = OptionParser(usage)

@@ -72,61 +66,9 @@ def main():

     constants.initialize(options)

     listPackages1=["nano","swig","wget"]

-    

-    #tUtils = ToolChainUtils()

-    #tUtils.buildToolChain()

+

     pkgManager = PackageManager()

     pkgManager.buildPackages(listPackages)

-    

-    '''

-    chrUtils=ChrootUtils(options)

-    returnVal,chrootID1=chrUtils.createChroot()

-    logger.info("Obtained chroot"+ chrootID1)

-    if not returnVal:

-        return False

-    chrUtils.prepareChroot(chrootID1)

-    chrUtils.destroyChroot(chrootID1)

-    

-    

-    chrUtils1=ChrootUtils(options)

-    returnVal,chrootID=chrUtils1.createChroot()

-    logger.info("Obtained chroot"+ chrootID)

-    if not returnVal:

-        return False

-    chrUtils1.prepareChroot(chrootID)

-    

-    tUtils.installToolChain(chrootID)

-    #chrUtils1.destroyChroot(chrootID)

-    '''

-    

-    #tUtils=ToolChainUtils()

-    #tUtils.buildToolChain()

-    

-    #pkgUtils=PackageUtils()

-    #pkgUtils.buildPackage("nano")

-    

-    

-    

-    

-

-

-'''

-    package_builder = BuildSystem(options.source_path,  options.spec_path,  options.rpm_path,  options.build_root, options.tools_path, options.log_path)

-

-    returnVal = True

-    if options.clean_build:

-        returnVal=package_builder.doCleanBuild()

-    elif options.build_all:

-        returnVal=package_builder.buildAllPackages()

-    elif options.install_tool_chain:

-        returnVal=package_builder.installToolchain()

-    elif options.install_package:

-        if (len(args)) != 1:

-            parser.error("Incorrect number of arguments")

-            returnVal=False

-        else:

-            returnVal=package_builder.installPackage(args[0],options.force_build)

-    return returnVal

-'''

+ 

 if __name__=="__main__":

     main()

\ No newline at end of file