@@ -7,6 +7,10 @@ from PackageBuilder import PackageBuilder

 import os

 from PackageUtils import PackageUtils

 from ToolChainUtils import ToolChainUtils

+from Scheduler import Scheduler

+from ThreadPool import ThreadPool

+from WorkerThread import WorkerThread

+import subprocess

 class PackageManager(object):

@@ -168,8 +172,84 @@ class PackageManager(object):

             return False

         return True

-        

+    

+    def calculatePossibleNumWorkerThreads(self):

+        process = subprocess.Popen(["df" ,"/mnt"],shell=True,stdout=subprocess.PIPE)

+        retval = process.wait()

+        if retval != 0:

+            self.logger.error("Unable to check free space. Unknown error.")

+            return False

+        output = process.communicate()[0]

+        device, size, used, available, percent, mountpoint = output.split("\n")[1].split()

+        c =  int(available)/600000

+        numChroots=int(c)

+        self.logger.info("Updated number of chroots:"+str(numChroots))

+        return numChroots

+    

     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

+        

+        statusEvent=threading.Event()

+        

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

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

+        Scheduler.setEvent(statusEvent)

+        

+        numWorkerThreads=self.calculatePossibleNumWorkerThreads()

+        if numWorkerThreads == 0:

+            return False

+         

+        ThreadPool.clear()

+        i=0

+        while i < numWorkerThreads:

+            workerName="WorkerThread"+str(i)

+            w = WorkerThread(statusEvent,workerName,self.mapPackageToCycle,self.listAvailableCyclicPackages,self.logger)

+            ThreadPool.addWorkerThread(workerName, w)

+            w.start()

+            i = i + 1

+        

+        statusEvent.wait()

+        

+        Scheduler.stopScheduling=True

+        

+        setFailFlag=False

+        allPackagesBuilt=False

+        if Scheduler.isAnyPackagesFailedToBuild():

+            setFailFlag=True

+        if Scheduler.isAllPackagesBuilt():

+            allPackagesBuilt=True

+        

+        if setFailFlag:

+            self.logger.error("Some of the packages failed:")

+            self.logger.error(Scheduler.listOfFailedPackages)

+        

+        if not setFailFlag:

+            if allPackagesBuilt:

+                self.logger.info("All packages built successfully")

+            else:

+                self.logger.error("Build stopped unexpectedly.Unknown error.")

+        

+        self.logger.info("Waiting for all remaining worker threads")

+        listWorkerObjs=ThreadPool.getAllWorkerObjects()

+        for w in listWorkerObjs:

+            w.join()

+        

+        self.logger.info("Terminated")

+        

+        

+        

+            

+        

+

+    

+    def buildPackages1 (self, listPackages):

         if not self.buildToolChain():

             return False

new file mode 100644

@@ -0,0 +1,127 @@

+from ThreadPool import ThreadPool

+from constants import constants

+from Logger import Logger

+import threading 

+

+class Scheduler(object):

+    

+    lock=threading.Lock()

+    listOfAlreadyBuiltPackages=[]

+    listOfPackagesToBuild=[]

+    listOfPackagesCurrentlyBuilding=[]

+    sortedList=[]

+    listOfPackagesNextToBuild=[]

+    listOfFailedPackages=[]

+    logger=None

+    event=None

+    stopScheduling=False

+    

+    @staticmethod

+    def setEvent(event):

+        Scheduler.event=event

+    

+    @staticmethod

+    def setLog(logName,logPath):

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

+        

+    @staticmethod

+    def setParams(sortedList,listOfAlreadyBuiltPackages):

+        Scheduler.sortedList=sortedList

+        Scheduler.listOfAlreadyBuiltPackages=listOfAlreadyBuiltPackages

+        for x in Scheduler.sortedList:

+            if x not in Scheduler.listOfAlreadyBuiltPackages:

+                Scheduler.listOfPackagesToBuild.append(x)

+        Scheduler.listOfPackagesCurrentlyBuilding=[]

+        Scheduler.listOfPackagesNextToBuild=[]

+        

+    @staticmethod

+    def getRequiredPackages(package):

+        listRequiredRPMPackages=[]

+        listRequiredRPMPackages.extend(constants.specData.getBuildRequiresForPackage(package))

+        listRequiredRPMPackages.extend(constants.specData.getRequiresAllForPackage(package))

+        

+        listRequiredPackages=[]

+        for pkg in listRequiredRPMPackages:

+            basePkg=constants.specData.getSpecName(pkg)

+            if basePkg not in listRequiredPackages:

+                listRequiredPackages.append(basePkg)

+        

+        return listRequiredPackages

+    

+    @staticmethod

+    def __getListNextPackagesReadyToBuild():

+        listOfPackagesNextToBuild=[]

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

+        for pkg in Scheduler.listOfPackagesToBuild:

+            if pkg in Scheduler.listOfPackagesCurrentlyBuilding:

+                continue

+            listRequiredPackages=Scheduler.getRequiredPackages(pkg)

+            canBuild=True

+            Scheduler.logger.info("Required packages for "+ pkg + " are:")

+            Scheduler.logger.info(listRequiredPackages)

+            for reqPkg in listRequiredPackages:

+                if reqPkg not in Scheduler.listOfAlreadyBuiltPackages:

+                    canBuild=False

+                    Scheduler.logger.info(reqPkg+" is not available. So we cannot build "+ pkg +" at this moment.")

+                    break

+            if canBuild:

+                listOfPackagesNextToBuild.append(pkg)

+        return listOfPackagesNextToBuild

+    

+    @staticmethod

+    def getNextPackageToBuild():

+        Scheduler.lock.acquire()

+        

+        if Scheduler.stopScheduling:

+            Scheduler.lock.release()

+            return None

+        

+        if len(Scheduler.listOfPackagesToBuild) == 0:

+            if Scheduler.event is not None:

+                Scheduler.event.set()

+            

+        if len(Scheduler.listOfPackagesNextToBuild) == 0:

+            listOfPackagesNextToBuild=Scheduler.__getListNextPackagesReadyToBuild()

+            Scheduler.listOfPackagesNextToBuild=listOfPackagesNextToBuild

+            

+        if len(Scheduler.listOfPackagesNextToBuild) == 0:

+            Scheduler.lock.release()

+            return None

+        

+        package=Scheduler.listOfPackagesNextToBuild.pop(0)

+        

+        if len(Scheduler.listOfPackagesNextToBuild) > 0:

+            ThreadPool.activateWorkerThreads(len(Scheduler.listOfPackagesNextToBuild))

+        Scheduler.lock.release()

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

+            return True

+        return False

+        

+        

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,55 @@

+

+class ThreadPool(object):

+    

+    mapWorkerThreads={}

+    activeWorkerThreads=[]

+    inactiveWorkerThreads=[]

+    

+    @staticmethod

+    def clear():

+        ThreadPool.mapWorkerThreads.clear()

+        ThreadPool.activeWorkerThreads=[]

+        ThreadPool.inactiveWorkerThreads=[]

+    

+    @staticmethod

+    def getAllWorkerObjects():

+        listWorkerObjs=[]

+        listWorkerKeys = ThreadPool.mapWorkerThreads.keys()

+        for x in listWorkerKeys:

+            xobj=ThreadPool.mapWorkerThreads[x]

+            listWorkerObjs.append(xobj)

+        return listWorkerObjs

+        

+    @staticmethod

+    def addWorkerThread(workerThreadName,workerThread):

+        ThreadPool.mapWorkerThreads[workerThreadName]=workerThread

+   

+    @staticmethod

+    def makeWorkerThreadActive(threadName):

+        if threadName in ThreadPool.inactiveWorkerThreads:

+            ThreadPool.inactiveWorkerThreads.remove(threadName)

+        ThreadPool.activeWorkerThreads.append(threadName)

+        

+    @staticmethod

+    def makeWorkerThreadInActive(threadName):

+        if threadName in ThreadPool.activeWorkerThreads:

+            ThreadPool.activeWorkerThreads.remove(threadName)

+        ThreadPool.inactiveWorkerThreads.append(threadName)

+    

+    @staticmethod

+    def startWorkerThread(threadName):

+        ThreadPool.mapWorkerThreads[threadName].start()

+    

+    @staticmethod

+    def getListInactiveWorkerThreads():

+        return ThreadPool.inactiveWorkerThreads

+    

+    @staticmethod

+    def activateWorkerThreads(numOfThreadsToActivate):

+        while len(ThreadPool.inactiveWorkerThreads) > 0 and numOfThreadsToActivate > 0:

+            threadName=ThreadPool.inactiveWorkerThreads.pop()

+            ThreadPool.startWorkerThread(threadName)

+            ThreadPool.makeWorkerThreadActive(threadName)

+            numOfThreadsToActivate = numOfThreadsToActivate -1

+

+            

new file mode 100644

@@ -0,0 +1,56 @@

+from PackageBuilder import PackageBuilder

+import threading

+from Scheduler import Scheduler

+from constants import constants

+from ThreadPool import ThreadPool

+ 

+class WorkerThread(threading.Thread):

+    

+    def __init__(self,event,name,mapPackageToCycle,listAvailableCyclicPackages,logger):

+        threading.Thread.__init__(self)

+        self.statusEvent=event

+        self.name=name

+        self.mapPackageToCycle=mapPackageToCycle

+        self.listAvailableCyclicPackages=listAvailableCyclicPackages

+        self.logger=logger

+    

+    

+    def run(self):

+        buildThreadFailed=False

+        ThreadPool.makeWorkerThreadActive(self.name)

+        self.logger.info("Thread "+self.name +" is starting now")

+        while True:

+            outputMap={}

+            pkg = Scheduler.getNextPackageToBuild()

+            if pkg is None:

+                break

+            self.logger.info("Thread "+self.name+" is building package:"+ pkg)

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

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

+            t.start()

+            t.join()

+            if outputMap.has_key(pkg):

+                if outputMap[pkg] == False:

+                    buildThreadFailed = True

+                    Scheduler.notifyPackageBuildFailed(pkg)

+                    self.logger.info("Thread "+self.name +" stopped building the "+pkg +" package")

+                    break

+            else:

+                buildThreadFailed = True

+                Scheduler.notifyPackageBuildFailed(pkg)

+                self.logger.info("Thread "+self.name +" stopped building the "+pkg +" package")

+                break

+            

+            Scheduler.notifyPackageBuildCompleted(pkg)

+        

+        if buildThreadFailed:

+            self.statusEvent.set()

+        

+        ThreadPool.makeWorkerThreadInActive(self.name)

+        self.logger.info("Thread "+self.name +" is going to rest")

+        

+

+

+                    

+                

+        

\ No newline at end of file