@@ -207,12 +207,15 @@ class PackageManager(object):

             return False

         ThreadPool.clear()

+        ThreadPool.mapPackageToCycle=self.mapPackageToCycle

+        ThreadPool.listAvailableCyclicPackages=self.listAvailableCyclicPackages

+        ThreadPool.logger=self.logger

+        ThreadPool.statusEvent=statusEvent

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

+            ThreadPool.addWorkerThread(workerName)

+            ThreadPool.startWorkerThread(workerName)

             i = i + 1

         statusEvent.wait()

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

-from ThreadPool import ThreadPool

+import ThreadPool

 from constants import constants

 from Logger import Logger

 import threading 

@@ -94,7 +94,7 @@ class Scheduler(object):

         package=Scheduler.listOfPackagesNextToBuild.pop(0)

         if len(Scheduler.listOfPackagesNextToBuild) > 0:

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

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

         Scheduler.logger.info("Released scheduler lock")

         Scheduler.lock.release()

         Scheduler.listOfPackagesCurrentlyBuilding.append(package)

@@ -1,9 +1,14 @@

+import WorkerThread

 class ThreadPool(object):

     mapWorkerThreads={}

     activeWorkerThreads=[]

     inactiveWorkerThreads=[]

+    mapPackageToCycle={}

+    listAvailableCyclicPackages=[]

+    logger=None

+    statusEvent=None

     @staticmethod

     def clear():

@@ -21,7 +26,8 @@ class ThreadPool(object):

         return listWorkerObjs

     @staticmethod

-    def addWorkerThread(workerThreadName,workerThread):

+    def addWorkerThread(workerThreadName):

+        workerThread = WorkerThread.WorkerThread(ThreadPool.statusEvent,workerThreadName,ThreadPool.mapPackageToCycle,ThreadPool.listAvailableCyclicPackages,ThreadPool.logger)

         ThreadPool.mapWorkerThreads[workerThreadName]=workerThread

     @staticmethod

@@ -48,6 +54,7 @@ class ThreadPool(object):

     def activateWorkerThreads(numOfThreadsToActivate):

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

             threadName=ThreadPool.inactiveWorkerThreads.pop()

+            ThreadPool.addWorkerThread(threadName)

             ThreadPool.startWorkerThread(threadName)

             ThreadPool.makeWorkerThreadActive(threadName)

             numOfThreadsToActivate = numOfThreadsToActivate -1

@@ -1,8 +1,8 @@

 from PackageBuilder import PackageBuilder

 import threading

-from Scheduler import Scheduler

+import Scheduler

 from constants import constants

-from ThreadPool import ThreadPool

+import ThreadPool

 class WorkerThread(threading.Thread):

@@ -17,11 +17,11 @@ class WorkerThread(threading.Thread):

     def run(self):

         buildThreadFailed=False

-        ThreadPool.makeWorkerThreadActive(self.name)

+        ThreadPool.ThreadPool.makeWorkerThreadActive(self.name)

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

         while True:

             outputMap={}

-            pkg = Scheduler.getNextPackageToBuild()

+            pkg = Scheduler.Scheduler.getNextPackageToBuild()

             if pkg is None:

                 break

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

@@ -32,21 +32,21 @@ class WorkerThread(threading.Thread):

             if outputMap.has_key(pkg):

                 if outputMap[pkg] == False:

                     buildThreadFailed = True

-                    Scheduler.notifyPackageBuildFailed(pkg)

+                    Scheduler.Scheduler.notifyPackageBuildFailed(pkg)

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

                     break

             else:

                 buildThreadFailed = True

-                Scheduler.notifyPackageBuildFailed(pkg)

+                Scheduler.Scheduler.notifyPackageBuildFailed(pkg)

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

                 break

-            Scheduler.notifyPackageBuildCompleted(pkg)

+            Scheduler.Scheduler.notifyPackageBuildCompleted(pkg)

         if buildThreadFailed:

             self.statusEvent.set()

-        ThreadPool.makeWorkerThreadInActive(self.name)

+        ThreadPool.ThreadPool.makeWorkerThreadInActive(self.name)

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