@@ -528,7 +528,7 @@ check-docker-service:

 	@docker ps >/dev/null 2>&1 || { echo "Docker service is not running. Aborting." >&2; exit 1; }

 check-docker-py:

-	@python -c "import docker; assert docker.__version__ == '$(PHOTON_DOCKER_PY_VER)'" >/dev/null 2>&1 || { echo "Error: Python package docker-py 2.3.0 not installed.\nPlease use: pip install docker==2.3.0" >&2; exit 1; }

+	@python3 -c "import docker; assert docker.__version__ == '$(PHOTON_DOCKER_PY_VER)'" >/dev/null 2>&1 || { echo "Error: Python3 package docker-py3 2.3.0 not installed.\nPlease use: pip3 install docker==2.3.0" >&2; exit 1; }

 check-bison:

 	@command -v bison >/dev/null 2>&1 || { echo "Package bison not installed. Aborting." >&2; exit 1; }

@@ -1,47 +1,47 @@

+import os.path

 from Logger import Logger

 from CommandUtils import CommandUtils

 from constants import constants

-import os.path

 class ChrootUtils(object):

-    

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

+

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

         if logName is None:

             logName = "ChrootUtils"

         if logPath is None:

             logPath = constants.logPath

-        self.logName=logName

-        self.logPath=logPath

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

-        

-    def createChroot(self,chrootName):

-        chrootID=constants.buildRootPath+"/"+chrootName

+        self.logName = logName

+        self.logPath = logPath

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

+

+    def createChroot(self, chrootName):

+        chrootID = constants.buildRootPath + "/" + chrootName

         if os.path.isdir(chrootID):

             if not self.destroyChroot(chrootID):

-                self.logger.error("Given chroot "+chrootID+" is already exists. unable to destroy it ")

-                return False,None

+                self.logger.error("Given chroot " + chrootID +

+                                  " is already exists. unable to destroy it ")

+                return False, None

         # need to add timeout for this step

         # http://stackoverflow.com/questions/1191374/subprocess-with-timeout

-        cmdUtils=CommandUtils()

-        returnVal=cmdUtils.runCommandInShell("mkdir -p "+chrootID)

+        cmdUtils = CommandUtils()

+        returnVal = cmdUtils.runCommandInShell("mkdir -p " + chrootID)

         if not returnVal:

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

-            return False,None

-        return True,chrootID

-    

-    def destroyChroot(self,chrootID):

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

+            return False, None

+        return True, chrootID

+

+    def destroyChroot(self, chrootID):

         # need to add timeout for this step

         # http://stackoverflow.com/questions/1191374/subprocess-with-timeout

-        cmdUtils=CommandUtils()

-        returnVal=cmdUtils.runCommandInShell("./clean-up-chroot.py "+chrootID)

+        cmdUtils = CommandUtils()

+        returnVal = cmdUtils.runCommandInShell("./clean-up-chroot.py " + chrootID)

         if not returnVal:

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

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

             return False

-        

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

+

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

         if not returnVal:

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

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

             return False

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

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

         return True

-    

@@ -5,9 +5,11 @@ class CommandUtils(object):

     def __init__(self):

         self.findBinary = "find"

-    def findFile (self, filename, sourcePath):

-        process = subprocess.Popen([self.findBinary, "-L", sourcePath, "-name", filename, "-not", "-type", "d"],  stdout=subprocess.PIPE)

-        # We don't check the return val here because find could return 1 but still be able to find

+    def findFile(self, filename, sourcePath):

+        process = subprocess.Popen([self.findBinary, "-L", sourcePath, "-name", filename,

+                                    "-not", "-type", "d"], stdout=subprocess.PIPE)

+        # We don't check the return val here because find could return 1 but still be

+        # able to find

         # the result. We shouldn't blindly return None without even checking the result.

         # The reason we want to suppress this is because for built RPMs, we first copy it to

         # the location with a random name and move it to the real name. find will complain our

@@ -17,30 +19,30 @@ class CommandUtils(object):

         #if returnVal != 0:

         #    return None

-        result=process.communicate()[0]

+        result = process.communicate()[0]

         if result is None:

             return None

-        return result.split()

+        return result.decode().split()

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

+    @staticmethod

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

         if chrootCmd is not None:

-            cmd = chrootCmd+" "+cmd

+            cmd = chrootCmd + " " + cmd

         if logfilePath is None:

-            logfilePath=os.devnull

-        logfile=open(logfilePath,"w")

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

+            logfilePath = os.devnull

+        logfile = open(logfilePath, "w")

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

         retval = process.wait()

         logfile.close()

-        if retval==0:

+        if retval == 0:

             return True

         return False

-

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

+    @staticmethod

+    def runCommandInShell2(cmd, chrootCmd=None):

         if chrootCmd is not None:

-            cmd = chrootCmd+" "+cmd

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

+            cmd = chrootCmd + " " + cmd

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

         retval = process.wait()

         if retval != 0:

             return None

         return process.communicate()[0]

-

@@ -1,22 +1,22 @@

-import logging

 import os

+import logging

 class Logger(object):

     @staticmethod

-    def getLogger (mymodule, logpath=None, resetFile=False):

-        logfile=mymodule+".log"

+    def getLogger(mymodule, logpath=None, resetFile=False):

+        logfile = mymodule + ".log"

         if logpath is not None:

             if not os.path.isdir(logpath):

                 os.makedirs(logpath)

-            logfile=logpath+"/"+logfile

+            logfile = logpath + "/" + logfile

         if resetFile:

             open(logfile, 'w').close()

-        logger=logging.getLogger(mymodule)

+        logger = logging.getLogger(mymodule)

         if len(logger.handlers) == 0:

             #creating file handler

-            fhandler=logging.FileHandler(logfile)

+            fhandler = logging.FileHandler(logfile)

             # create console handler

-            ch=logging.StreamHandler()

+            ch = logging.StreamHandler()

             formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

             # add formatter to handler

             fhandler.setFormatter(formatter)

@@ -25,15 +25,15 @@ class Logger(object):

             logger.addHandler(ch)

             logger.addHandler(fhandler)

             logger.setLevel(logging.DEBUG)

-            logger.info("--------------------------------------------------------------------------")

+            logger.info("-" * 75)

             logger.info("Starting Log")

-            logger.info("--------------------------------------------------------------------------")

+            logger.info("-" * 75)

         return logger

 if __name__ == "__main__":

     #Logger.getLogger("my module")

-    t1 =  Logger.getLogger("my module")

+    t1 = Logger.getLogger("my module")

     t1.info("test1")

-    t2  = Logger.getLogger("my module")

+    t2 = Logger.getLogger("my module")

     t2.info("test2")

     t1.info("test3")

@@ -1,36 +1,36 @@

 import os.path

 class MiscUtils(object):

-    

+

     @staticmethod

-    def isOutdated(listInputFiles,listOutputFiles):

-        thresholdTimeStamp=None

+    def isOutdated(listInputFiles, listOutputFiles):

+        thresholdTimeStamp = None

         if len(listInputFiles) == 0:

             return False

         if len(listOutputFiles) == 0:

             return True

         for f in listOutputFiles:

-            t=os.path.getmtime(f)

+            t = os.path.getmtime(f)

             if thresholdTimeStamp is None:

                 thresholdTimeStamp = t

             if t < thresholdTimeStamp:

-                thresholdTimeStamp = t 

+                thresholdTimeStamp = t

         for f in listInputFiles:

-            t=os.path.getmtime(f)

+            t = os.path.getmtime(f)

             if t > thresholdTimeStamp:

                 return True

         return False

-    

+

     @staticmethod

-    def getListSpecFiles(listSpecFiles,path):

+    def getListSpecFiles(listSpecFiles, path):

         for dirEntry in os.listdir(path):

             dirEntryPath = os.path.join(path, dirEntry)

             if os.path.isfile(dirEntryPath) and dirEntryPath.endswith(".spec"):

                 listSpecFiles.append(dirEntryPath)

             elif os.path.isdir(dirEntryPath):

-                MiscUtils.getListSpecFiles(listSpecFiles,dirEntryPath)

-    

-if __name__=="__main__":

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

-    listOutputFiles=["builder.py"]

-    print MiscUtils.isOutdated(listInputFiles, listOutputFiles)

\ No newline at end of file

+                MiscUtils.getListSpecFiles(listSpecFiles, dirEntryPath)

+

+if __name__ == "__main__":

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

+    listOutputFiles = ["builder.py"]

+    print(MiscUtils.isOutdated(listInputFiles, listOutputFiles))

@@ -1,204 +1,205 @@

+import copy

 from Logger import Logger

 from constants import constants

-from sets import Set

-import copy

 from SpecData import SPECS

-

-

 def removeDuplicateEntriesInList(myList):

-    myListCopy=[]

+    myListCopy = []

     for p in myList:

         if p not in myListCopy:

             myListCopy.append(p)

     return myListCopy

-      

+

 class PackageBuildDataGenerator(object):

-    

-    cycleCount=0

-    

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

+

+    cycleCount = 0

+

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

         if logName is None:

             logName = "PackageBuildDataGenerator"

         if logPath is None:

             logPath = constants.logPath

-        self.logName=logName

-        self.logPath=logPath

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

-        self.__mapCyclesToPackageList={}

-        self.__mapPackageToCycle={}

-        self.__buildDependencyGraph={}

-        self.__runTimeDependencyGraph={}

-        self.__sortedPackageList=[]

-        self.__sortedBuildDependencyGraph={}

-    

-    def getPackageBuildData(self,listPackages):

+        self.logName = logName

+        self.logPath = logPath

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

+        self.__mapCyclesToPackageList = {}

+        self.__mapPackageToCycle = {}

+        self.__buildDependencyGraph = {}

+        self.__runTimeDependencyGraph = {}

+        self.__sortedPackageList = []

+        self.__sortedBuildDependencyGraph = {}

+

+    def getPackageBuildData(self, listPackages):

         self.__readDependencyGraphAndCyclesForGivenPackages(listPackages)

         self.__getSortedBuildOrderListForGivenPackages(listPackages)

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

-    #todo    

-    def findCompleteListOfPackagesRequiredToBuildGivenPackages(self,listPackages):

-        return self.__buildDependencyGraph.keys()    

- 

-    def createSortListForPkg(self,pkg):

-        runTimeDepPkgList=self.__runTimeDependencyGraph[pkg]

+    #todo

+    def findCompleteListOfPackagesRequiredToBuildGivenPackages(self, listPackages):

+        return list(self.__buildDependencyGraph.keys())

+

+    def createSortListForPkg(self, pkg):

+        runTimeDepPkgList = self.__runTimeDependencyGraph[pkg]

         runTimeDepPkgList.append(pkg)

-        sortListForPkg=[]

-        

+        sortListForPkg = []

+

         for p in runTimeDepPkgList:

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

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

+

+    def getCircularDependentPackages(self, pkg):

+        circularDependentPackages = []

+        if pkg in self.__mapPackageToCycle:

+            circularDependentPackages.extend(

+                self.__mapCyclesToPackageList[self.__mapPackageToCycle[pkg]])

             circularDependentPackages.remove(pkg)

         return circularDependentPackages

-    

-    def __getSortedBuildOrderListForGivenPackages(self,listPackages):

-        

-        alreadyProcessedPackages=[]

-        sortedList=[]

-        completeListPackagesToBuild=self.findCompleteListOfPackagesRequiredToBuildGivenPackages(listPackages)

+

+    def __getSortedBuildOrderListForGivenPackages(self, listPackages):

+

+        alreadyProcessedPackages = []

+        sortedList = []

+        completeListPackagesToBuild = self.findCompleteListOfPackagesRequiredToBuildGivenPackages(

+            listPackages)

         packageIndexInSortedList = 0

-        prevSortListLen=0

-        

+        prevSortListLen = 0

+

         while completeListPackagesToBuild:

-            

+

             # find next package to process

-            pkg=None

-            index=-1

-            lenList=len(sortedList)

+            pkg = None

+            index = -1

+            lenList = len(sortedList)

             for  i in range(lenList):

                 if sortedList[i] in alreadyProcessedPackages:

                     continue

                 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)

-            

+            sortListForPkg = self.createSortListForPkg(pkg)

+

             #remove any cyclic packages in sortListForPkg if they already exists in sortedList

-            circularDependentPackages=self.getCircularDependentPackages(pkg)

+            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=[]

+            index = packageIndexInSortedList

+            subList = []

             if packageIndexInSortedList > 0:

-                subList=sortedList[:packageIndexInSortedList]

+                subList = sortedList[:packageIndexInSortedList]

             for p in sortListForPkg:

                 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 :

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

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

                 sortedList = removeDuplicateEntriesInList(sortedList)

             else:

-                prevSortListLen=len(sortedList)

-                

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

-

-        addBuildTimeGraph=True

-        addRunTimeGraph=True

-        if self.__buildDependencyGraph.has_key(basePackage):

+        self.__sortedPackageList = sortedList

+

+    def __constructBuildAndRunTimeDependencyGraph(self, package):

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

+

+        addBuildTimeGraph = True

+        addRunTimeGraph = True

+        if basePackage in self.__buildDependencyGraph:

             addBuildTimeGraph = False

-        if self.__runTimeDependencyGraph.has_key(basePackage):

-            addRunTimeGraph=False

-        

-        nextPackagesToConstructGraph=[]

+        if basePackage in self.__runTimeDependencyGraph:

+            addRunTimeGraph = False

+

+        nextPackagesToConstructGraph = []

         if addBuildTimeGraph:

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

-            listDependentPackages=[]

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

+            listDependentPackages = []

             for rpmPkg in listDependentRpmPackages:

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

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

                 if basePkg not in listDependentPackages:

                     listDependentPackages.append(basePkg)

-            self.__buildDependencyGraph[basePackage]=listDependentPackages

+            self.__buildDependencyGraph[basePackage] = listDependentPackages

             nextPackagesToConstructGraph.extend(listDependentPackages)

-        

+

         if addRunTimeGraph:

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

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

             for rpmPkg in listRpmPackages:

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

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

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

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

                 nextPackagesToConstructGraph.extend(listDependentRpmPackages)

         for pkg in nextPackagesToConstructGraph:

             self.__constructBuildAndRunTimeDependencyGraph(pkg)

-    

-    def __readDependencyGraphAndCyclesForGivenPackages(self,listPackages):

+

+    def __readDependencyGraphAndCyclesForGivenPackages(self, listPackages):

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

         for pkg in listPackages:

             self.__constructBuildAndRunTimeDependencyGraph(pkg)

-        packagesToBUild=self.__buildDependencyGraph.keys()

-        for pkg in packagesToBUild:

-            sortedPackageList,circularDependentPackages = self.topologicalSortPackages(self.__buildDependencyGraph,pkg)

-            if len(circularDependentPackages) > 0 :

+

+        for pkg in self.__buildDependencyGraph.keys():

+            sortedPackageList, circularDependentPackages = self.topologicalSortPackages(

+                self.__buildDependencyGraph, pkg)

+            if len(circularDependentPackages) > 0:

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

                 self.logger.error(circularDependentPackages)

                 raise Exception("Build Time Circular Dependency")

-            self.__sortedBuildDependencyGraph[pkg]=sortedPackageList

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

-        if len(circularDependentPackages) > 0 :

+            self.__sortedBuildDependencyGraph[pkg] = sortedPackageList

+        sortedPackageList, circularDependentPackages = self.topologicalSortPackages(

+            self.__runTimeDependencyGraph)

+        if len(circularDependentPackages) > 0:

             self.__findCircularDependencies(circularDependentPackages)

-    

+

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

-        noDepPackages = Set()

+        noDepPackages = set()

         sortedPackageList = []

         dependentOfPackage = dict()

-        

-        dependentPackages={}

+

+        dependentPackages = {}

         if package is None:

-            dependentPackages=copy.deepcopy(dependencyGraph)

+            dependentPackages = copy.deepcopy(dependencyGraph)

         else:

-            listDepPkgs= Set()

+            listDepPkgs = set()

             listDepPkgs.add(package)

             while listDepPkgs:

                 pkg = listDepPkgs.pop()

-                if dependentPackages.has_key(pkg):

+                if pkg in dependentPackages:

                     continue

-                dependentPackages[pkg]=dependencyGraph[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:

                 noDepPackages.add(pkg)

             else:

                 for depPkg in dependentPackages[pkg]:

-                    if not dependentOfPackage.has_key(depPkg):

-                        dependentOfPackage[depPkg]=[pkg]

+                    if depPkg not in dependentOfPackage:

+                        dependentOfPackage[depPkg] = [pkg]

                     else:

                         if pkg not in dependentOfPackage[depPkg]:

                             dependentOfPackage[depPkg].append(pkg)

-        

+

         while noDepPackages:

             pkg = noDepPackages.pop()

             sortedPackageList.append(pkg)

@@ -206,29 +207,27 @@ class PackageBuildDataGenerator(object):

                 for childPkg in list(dependentOfPackage.get(pkg)):

                     dependentOfPackage.get(pkg).remove(childPkg)

                     dependentPackages[childPkg].remove(pkg)

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

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

                         noDepPackages.add(childPkg)

-        

+

         # creating circular dependency graph for given dependency graph

-        circularDependencyGraph={}

-        listCircularPkg = dependentPackages.keys()

-        for pkg in listCircularPkg:

+        circularDependencyGraph = {}

+        for pkg in dependentPackages.keys():

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

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

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

-        constructDependencyMap={}

-        listNodes=cyclicDependencyGraph.keys()

-        for node in listNodes:

-            tmpDepNodeList=[]

+        constructDependencyMap = {}

+        for node in cyclicDependencyGraph.keys():

+            tmpDepNodeList = []

             tmpDepNodeList.append(node)

-            depNodeList=[]

-            while len(tmpDepNodeList)!=0:

+            depNodeList = []

+            while len(tmpDepNodeList) != 0:

                 currentNode = tmpDepNodeList.pop()

                 addDepNodeList = cyclicDependencyGraph[currentNode]

                 depNodeList.append(currentNode)

@@ -239,50 +238,43 @@ class PackageBuildDataGenerator(object):

                         if depNode not in tmpDepNodeList:

                             tmpDepNodeList.append(depNode)

             depNodeList.remove(node)

-            constructDependencyMap[node]=depNodeList

+            constructDependencyMap[node] = depNodeList

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

         self.logger.info(constructDependencyMap)

         return constructDependencyMap

-        

-        

-    def __findCircularDependencies(self,cyclicDependencyGraph):

+

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

-        

+        constructDependencyMap = self.__constructDependencyMap(cyclicDependencyGraph)

+

         #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=[]

-            if not self.__mapPackageToCycle.has_key(node):

+        cycleCount = 0

+        for node in cyclicDependencyGraph.keys():

+            listDepPkg = constructDependencyMap[node]

+            cycPkgs = []

+            if node not in self.__mapPackageToCycle:

                 for depPkg in listDepPkg:

                     x = constructDependencyMap[depPkg]

                     if node in x:

                         cycPkgs.append(depPkg)

-                

+

                 if len(cycPkgs) != 0:

                     cycPkgs.append(node)

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

-                    PackageBuildDataGenerator.cycleCount=PackageBuildDataGenerator.cycleCount+1

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

+                    PackageBuildDataGenerator.cycleCount += 1

                     for x in cycPkgs:

-                        self.__mapPackageToCycle[x]=cycleName

-                    self.__mapCyclesToPackageList[cycleName]=cycPkgs

+                        self.__mapPackageToCycle[x] = cycleName

+                    self.__mapCyclesToPackageList[cycleName] = cycPkgs

                     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(cycleName + " " + ",".join(cycPkgs))

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

-        

-    

-

-    

-    

@@ -1,49 +1,51 @@

+import sys

+import os.path

 from PackageUtils import PackageUtils

 from Logger import Logger

 from ChrootUtils import ChrootUtils

 from ToolChainUtils import ToolChainUtils

 from CommandUtils import CommandUtils

-import os.path

 from constants import constants

-import shutil

 from SpecData import SPECS

 import docker

-import sys

 class PackageBuilderBase(object):

-    def __init__(self,mapPackageToCycles,listAvailableCyclicPackages,listBuildOptionPackages,pkgBuildOptionFile, pkgBuildType):

+    def __init__(self, mapPackageToCycles, listAvailableCyclicPackages,

+                 listBuildOptionPackages, pkgBuildOptionFile, pkgBuildType):

         # will be initialized in buildPackageThreadAPI()

-        self.logName=None

-        self.logPath=None

-        self.logger=None

-        self.package=None

+        self.logName = None

+        self.logPath = None

+        self.logger = None

+        self.package = None

         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"]

-        self.listBuildOptionPackages=listBuildOptionPackages

-        self.pkgBuildOptionFile=pkgBuildOptionFile

+        self.listNodepsPackages = ["glibc", "gmp", "zlib", "file", "binutils", "mpfr",

+                                   "mpc", "gcc", "ncurses", "util-linux", "groff", "perl",

+                                   "texinfo", "rpm", "openssl", "go"]

+        self.listBuildOptionPackages = listBuildOptionPackages

+        self.pkgBuildOptionFile = pkgBuildOptionFile

         self.pkgBuildType = pkgBuildType

-    def buildPackageThreadAPIPrepare(self,package,outputMap, threadName):

-        self.package=package

-        self.logName="build-"+package

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

+    def buildPackageThreadAPIPrepare(self, package, outputMap, threadName):

+        self.package = package

+        self.logName = "build-" + package

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

         if not os.path.isdir(self.logPath):

             cmdUtils = CommandUtils()

-            cmdUtils.runCommandInShell("mkdir -p "+self.logPath)

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

+            cmdUtils.runCommandInShell("mkdir -p " + self.logPath)

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

-    def findPackageNameFromRPMFile(self,rpmfile):

-        rpmfile=os.path.basename(rpmfile)

-        releaseindex=rpmfile.rfind("-")

+    def findPackageNameFromRPMFile(self, rpmfile):

+        rpmfile = os.path.basename(rpmfile)

+        releaseindex = rpmfile.rfind("-")

         if releaseindex == -1:

-            self.logger.error("Invalid rpm file:"+rpmfile)

+            self.logger.error("Invalid rpm file:" + rpmfile)

             return None

-        versionindex=rpmfile[0:releaseindex].rfind("-")

+        versionindex = rpmfile[0:releaseindex].rfind("-")

         if versionindex == -1:

-            self.logger.error("Invalid rpm file:"+rpmfile)

+            self.logger.error("Invalid rpm file:" + rpmfile)

             return None

-        packageName=rpmfile[0:versionindex]

+        packageName = rpmfile[0:versionindex]

         return packageName

     def findInstalledPackages(self, instanceID):

@@ -52,69 +54,76 @@ class PackageBuilderBase(object):

             listInstalledRPMs = pkgUtils.findInstalledRPMPackages(instanceID)

         elif self.pkgBuildType == "container":

             listInstalledRPMs = pkgUtils.findInstalledRPMPackagesInContainer(instanceID)

-        listInstalledPackages=[]

+        listInstalledPackages = []

         for installedRPM in listInstalledRPMs:

-            packageName=self.findPackageNameFromRPMFile(installedRPM)

+            packageName = self.findPackageNameFromRPMFile(installedRPM)

             if packageName is not None:

                 listInstalledPackages.append(packageName)

         return listInstalledPackages, listInstalledRPMs

     def checkIfPackageIsAlreadyBuilt(self):

-        basePkg=SPECS.getData().getSpecName(self.package)

-        listRPMPackages=SPECS.getData().getRPMPackages(basePkg)

-        packageIsAlreadyBuilt=True

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

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

+        listRPMPackages = SPECS.getData().getRPMPackages(basePkg)

+        packageIsAlreadyBuilt = True

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

         for pkg in listRPMPackages:

             if pkgUtils.findRPMFileForGivenPackage(pkg) is None:

-                packageIsAlreadyBuilt=False

+                packageIsAlreadyBuilt = False

                 break

         return packageIsAlreadyBuilt

-    def findRunTimeRequiredRPMPackages(self,rpmPackage):

-        listRequiredPackages=SPECS.getData().getRequiresForPackage(rpmPackage)

+    def findRunTimeRequiredRPMPackages(self, rpmPackage):

+        listRequiredPackages = SPECS.getData().getRequiresForPackage(rpmPackage)

         return listRequiredPackages

     def findBuildTimeRequiredPackages(self):

-        listRequiredPackages=SPECS.getData().getBuildRequiresForPackage(self.package)

+        listRequiredPackages = SPECS.getData().getBuildRequiresForPackage(self.package)

         return listRequiredPackages

     def findBuildTimeCheckRequiredPackages(self):

-        listRequiredPackages=SPECS.getData().getCheckBuildRequiresForPackage(self.package)

+        listRequiredPackages = SPECS.getData().getCheckBuildRequiresForPackage(self.package)

         return listRequiredPackages

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

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

+    def installPackage(self, pkgUtils, package, instanceID, destLogPath,

+                       listInstalledPackages, listInstalledRPMs):

+        latestRPM = os.path.basename(

+            pkgUtils.findRPMFileForGivenPackage(package)).replace(".rpm", "")

         if package in listInstalledPackages and latestRPM in listInstalledRPMs:

             return

         # mark it as installed -  to avoid cyclic recursion

         listInstalledPackages.append(package)

         listInstalledRPMs.append(latestRPM)

-        self.installDependentRunTimePackages(pkgUtils,package,instanceID,destLogPath,listInstalledPackages, listInstalledRPMs)

-        noDeps=False

-        if self.mapPackageToCycles.has_key(package):

+        self.installDependentRunTimePackages(pkgUtils, package, instanceID, destLogPath,

+                                             listInstalledPackages, listInstalledRPMs)

+        noDeps = False

+        if package in self.mapPackageToCycles:

             noDeps = True

         if package in self.listNodepsPackages:

-            noDeps=True

+            noDeps = True

         if package in constants.noDepsPackageList:

-            noDeps=True

+            noDeps = True

         if self.pkgBuildType == "chroot":

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

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

         elif self.pkgBuildType == "container":

             pkgUtils.prepRPMforInstallInContainer(package, instanceID, noDeps, destLogPath)

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

-        listRunTimeDependentPackages=self.findRunTimeRequiredRPMPackages(package)

+    def installDependentRunTimePackages(self, pkgUtils, package, instanceID, destLogPath,

+                                        listInstalledPackages, listInstalledRPMs):

+        listRunTimeDependentPackages = self.findRunTimeRequiredRPMPackages(package)

         if len(listRunTimeDependentPackages) != 0:

             for pkg in listRunTimeDependentPackages:

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

+                if pkg in self.mapPackageToCycles and pkg not in self.listAvailableCyclicPackages:

                     continue

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

+                latestPkgRPM = os.path.basename(

+                    pkgUtils.findRPMFileForGivenPackage(pkg)).replace(".rpm", "")

                 if pkg in listInstalledPackages and latestPkgRPM in listInstalledRPMs:

                     continue

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

+                self.installPackage(pkgUtils, pkg, instanceID, destLogPath,

+                                    listInstalledPackages, listInstalledRPMs)

 class PackageBuilderContainer(object):

-    def __init__(self, mapPackageToCycles, listAvailableCyclicPackages, listBuildOptionPackages, pkgBuildOptionFile, pkgBuildType):

+    def __init__(self, mapPackageToCycles, listAvailableCyclicPackages, listBuildOptionPackages,

+                 pkgBuildOptionFile, pkgBuildType):

         self.buildContainerImage = "photon_build_container:latest"

         self.dockerClient = docker.from_env(version="auto")

@@ -125,19 +134,20 @@ class PackageBuilderContainer(object):

         self.base.buildPackageThreadAPIPrepare(package, outputMap, threadName)

         try:

             self.buildPackage()

-            outputMap[threadName]=True

+            outputMap[threadName] = True

         except Exception as e:

             # TODO: self.logger might be None

             self.base.logger.exception(e)

-            outputMap[threadName]=False

+            outputMap[threadName] = False

             raise e

-    def prepareBuildContainer(self, containerTaskName, packageName, isToolChainPackage=False):

+    def prepareBuildContainer(self, containerTaskName, packageName,

+                              isToolChainPackage=False):

         # Prepare an empty chroot environment to let docker use the BUILD folder.

         # This avoids docker using overlayFS which will cause make check failure.

-        chrootName="build-"+packageName

+        chrootName = "build-" + packageName