new file mode 100644

@@ -0,0 +1,3 @@

+{

+    "mesos": "50"

+}

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

+# pylint: disable=invalid-name,missing-docstring

 import os.path

 from Logger import Logger

 from CommandUtils import CommandUtils

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

+# pylint: disable=invalid-name,missing-docstring

 import subprocess

 import os

@@ -30,12 +31,11 @@ class CommandUtils(object):

             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)

-        retval = process.wait()

-        logfile.close()

-        if retval == 0:

-            return True

+        with open(logfilePath, "w") as logfile:

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

+            retval = process.wait()

+            if retval == 0:

+                return True

         return False

     @staticmethod

     def runCommandInShell2(cmd, chrootCmd=None):

@@ -1,11 +1,11 @@

 #!/usr/bin/env python3

-

+# pylint: disable=invalid-name,missing-docstring

 import os

 import json

 import sys

 import traceback

-from Logger import Logger

 from argparse import ArgumentParser

+from Logger import Logger

 from constants import constants

 from CommandUtils import CommandUtils

 from SpecData import SPECS

@@ -15,14 +15,22 @@ from SpecData import SPECS

 def main():

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

     parser = ArgumentParser(usage)

-    parser.add_argument("-s", "--spec-path", dest="specPath", default="../../SPECS")

-    parser.add_argument("-l", "--log-path", dest="logPath", default="../../stage/LOGS")

-    parser.add_argument("-a", "--source-rpm-path", dest="sourceRpmPath", default="../../stage/SRPMS")

-    parser.add_argument("-j", "--output-dir", dest="outputDirPath", default="../../stage/")

-    parser.add_argument("-c", "--pullsources-config", dest="pullsourcesConfig", default="pullsources.conf")

-    parser.add_argument("-f", "--pkg-blacklist-file", dest="pkgBlacklistFile", default=None)

-    parser.add_argument("-p", "--generate-pkg-list", dest="generatePkgList", default=False, action="store_true")

-    parser.add_argument("-y", "--generate-yaml-files", dest="generateYamlFiles", default=False, action="store_true")

+    parser.add_argument("-s", "--spec-path", dest="specPath",

+                        default="../../SPECS")

+    parser.add_argument("-l", "--log-path", dest="logPath",

+                        default="../../stage/LOGS")

+    parser.add_argument("-a", "--source-rpm-path", dest="sourceRpmPath",

+                        default="../../stage/SRPMS")

+    parser.add_argument("-j", "--output-dir", dest="outputDirPath",

+                        default="../../stage/")

+    parser.add_argument("-c", "--pullsources-config", dest="pullsourcesConfig",

+                        default="pullsources.conf")

+    parser.add_argument("-f", "--pkg-blacklist-file", dest="pkgBlacklistFile",

+                        default=None)

+    parser.add_argument("-p", "--generate-pkg-list", dest="generatePkgList",

+                        default=False, action="store_true")

+    parser.add_argument("-y", "--generate-yaml-files", dest="generateYamlFiles",

+                        default=False, action="store_true")

     options = parser.parse_args()

     errorFlag = False

@@ -37,7 +45,8 @@ def main():

             if (options.pkgBlacklistFile is not None and

                     options.pkgBlacklistFile != "" and

                     not os.path.isfile(options.pkgBlacklistFile)):

-                logger.error("Given package blacklist file is not valid:" + options.pkgBlacklistFile)

+                logger.error("Given package blacklist file is not valid:"

+                             + options.pkgBlacklistFile)

                 errorFlag = True

         if not os.path.isdir(options.specPath):

@@ -49,7 +58,8 @@ def main():

             errorFlag = True

         if options.generateYamlFiles and not os.path.isfile(options.pullsourcesConfig):

-            logger.error("Given Source config file is not a valid file:" + options.pullsourcesConfig)

+            logger.error("Given Source config file is not a valid file:"

+                         + options.pullsourcesConfig)

             errorFlag = True

         if errorFlag:

@@ -77,7 +87,7 @@ def main():

             buildSRPMList(options.sourceRpmPath, options.outputDirPath, blackListPkgs, logger)

     except Exception as e:

-        print("Caught Exception: "+str(e))

+        print("Caught Exception: " + str(e))

         traceback.print_exc()

         sys.exit(1)

@@ -85,26 +95,25 @@ def main():

 def buildPackagesList(csvFilename):

-    csvFile = open(csvFilename, "w")

-    csvFile.write("Package,Version,License,URL,Sources,Patches\n")

-    listPackages = SPECS.getData().getListPackages()

-    listPackages.sort()

-    for package in listPackages:

-        name = package

-        version = SPECS.getData().getVersion(package)

-        license = SPECS.getData().getLicense(package)

-        listPatches = SPECS.getData().getPatches(package)

-        url = SPECS.getData().getURL(package)

-        listSourceNames = SPECS.getData().getSources(package)

-        sources = ""

-        patches = ""

-        if listPatches is not None:

-            patches = " ".join(listPatches)

-        if listSourceNames is not None:

-            sources = " ".join(listSourceNames)

-        csvFile.write(name + "," + version + "," + license + "," + url + "," + sources + "," + patches + "\n")

-    csvFile.close()

-

+    with open(csvFilename, "w") as csvFile:

+        csvFile.write("Package,Version,License,URL,Sources,Patches\n")

+        listPackages = SPECS.getData().getListPackages()

+        listPackages.sort()

+        for package in listPackages:

+            name = package

+            version = SPECS.getData().getVersion(package)

+            packagelicense = SPECS.getData().getLicense(package)

+            listPatches = SPECS.getData().getPatches(package)

+            url = SPECS.getData().getURL(package)

+            listSourceNames = SPECS.getData().getSources(package)

+            sources = ""

+            patches = ""

+            if listPatches is not None:

+                patches = " ".join(listPatches)

+            if listSourceNames is not None:

+                sources = " ".join(listSourceNames)

+            csvFile.write(name + "," + version + "," + packagelicense + "," + url + "," +

+                          sources + "," + patches + "\n")

 def readBlackListPackages(pkgBlackListFile):

     blackListPkgs = []

@@ -133,7 +142,7 @@ def buildSourcesList(yamlDir, blackListPkgs, logger, singleFile=True):

         ossversion = SPECS.getData().getVersion(package)

         modified = False

         listPatches = SPECS.getData().getPatches(package)

-        if listPatches is not None and len(listPatches) > 0:

+        if listPatches:

             modified = True

         url = SPECS.getData().getSourceURL(package)

         if url is None:

@@ -141,7 +150,7 @@ def buildSourcesList(yamlDir, blackListPkgs, logger, singleFile=True):

         sourceName = None

         listSourceNames = SPECS.getData().getSources(package)

-        if len(listSourceNames) > 0:

+        if listSourceNames:

             sourceName = listSourceNames[0]

             sha1 = SPECS.getData().getSHA1(package, sourceName)

             if sha1 is not None:

@@ -185,7 +194,8 @@ def buildSRPMList(srpmPath, yamlDir, blackListPkgs, logger, singleFile=True):

         ossversion = SPECS.getData().getVersion(package)

         ossrelease = SPECS.getData().getRelease(package)

-        listFoundSRPMFiles = cmdUtils.findFile(ossname + "-" + ossversion + "-" + ossrelease + ".src.rpm",

+        listFoundSRPMFiles = cmdUtils.findFile(ossname + "-" + ossversion + "-" + ossrelease

+                                               + ".src.rpm",

                                                srpmPath)

         srpmName = None

         if len(listFoundSRPMFiles) == 1:

@@ -199,7 +209,8 @@ def buildSRPMList(srpmPath, yamlDir, blackListPkgs, logger, singleFile=True):

             logger.error("SRPM file is not found:" + ossname)

         if not singleFile:

-            yamlFile = open(yamlSrpmDir + "/" + ossname + "-" + ossversion + "-" + ossrelease + ".yaml", "w")

+            yamlFile = open(yamlSrpmDir + "/" + ossname + "-" + ossversion + "-"

+                            + ossrelease + ".yaml", "w")

         yamlFile.write("baseos:" + ossname + ":" + ossversion + "-" + ossrelease + ":\n")

         yamlFile.write("  repository: BaseOS\n")

@@ -12,7 +12,7 @@ class Logger(object):

         if resetFile:

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

         logger = logging.getLogger(mymodule)

-        if len(logger.handlers) == 0:

+        if not logger.handlers:

             #creating file handler

             fhandler = logging.FileHandler(logfile)

             # create console handler

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

     @staticmethod

     def isOutdated(listInputFiles, listOutputFiles):

         thresholdTimeStamp = None

-        if len(listInputFiles) == 0:

+        if not listInputFiles:

             return False

-        if len(listOutputFiles) == 0:

+        if not listOutputFiles:

             return True

         for f in listOutputFiles:

             t = os.path.getmtime(f)

@@ -31,6 +31,6 @@ class MiscUtils(object):

                 MiscUtils.getListSpecFiles(listSpecFiles, dirEntryPath)

 if __name__ == "__main__":

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

-    listOutputFiles = ["builder.py"]

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

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

+    outputFiles = ["builder.py"]

+    print(MiscUtils.isOutdated(inputFiles, outputFiles))

@@ -1,13 +1,12 @@

+# pylint: disable=invalid-name,missing-docstring

 import copy

+from collections import OrderedDict

 from Logger import Logger

 from constants import constants

 from SpecData import SPECS

-def removeDuplicateEntriesInList(myList):

-    myListCopy = []

-    for p in myList:

-        if p not in myListCopy:

-            myListCopy.append(p)

+def removeDuplicateEntries(myList):

+    myListCopy = list(OrderedDict.fromkeys(myList))

     return myListCopy

 class PackageBuildDataGenerator(object):

@@ -19,8 +18,6 @@ class PackageBuildDataGenerator(object):

             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 = {}

@@ -30,15 +27,20 @@ class PackageBuildDataGenerator(object):

         self.__sortedBuildDependencyGraph = {}

     def getPackageBuildData(self, listPackages):

-        self.__readDependencyGraphAndCyclesForGivenPackages(listPackages)

-        self.__getSortedBuildOrderListForGivenPackages(listPackages)

+        basePackages = set()

+        for pkg in listPackages:

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

+            basePackages.add(basePackage)

+

+        self._readDependencyGraphAndCyclesForGivenPackages(basePackages)

+        self._getSortedBuildOrderList()

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

     #todo

-    def findCompleteListOfPackagesRequiredToBuildGivenPackages(self, listPackages):

+    def _findAllPackagesToBuild(self):

         return list(self.__buildDependencyGraph.keys())

-    def createSortListForPkg(self, pkg):

+    def _createSortListForPkg(self, pkg):

         runTimeDepPkgList = self.__runTimeDependencyGraph[pkg]

         runTimeDepPkgList.append(pkg)

         sortListForPkg = []

@@ -51,7 +53,7 @@ class PackageBuildDataGenerator(object):

         return sortListForPkg

-    def getCircularDependentPackages(self, pkg):

+    def _getCircularDependentPackages(self, pkg):

         circularDependentPackages = []

         if pkg in self.__mapPackageToCycle:

             circularDependentPackages.extend(

@@ -59,12 +61,11 @@ class PackageBuildDataGenerator(object):

             circularDependentPackages.remove(pkg)

         return circularDependentPackages

-    def __getSortedBuildOrderListForGivenPackages(self, listPackages):

+    def _getSortedBuildOrderList(self):

-        alreadyProcessedPackages = []

+        alreadyProcessedPackages = set()

         sortedList = []

-        completeListPackagesToBuild = self.findCompleteListOfPackagesRequiredToBuildGivenPackages(

-            listPackages)

+        completeListPackagesToBuild = self._findAllPackagesToBuild()

         packageIndexInSortedList = 0

         prevSortListLen = 0

@@ -74,7 +75,7 @@ class PackageBuildDataGenerator(object):

             pkg = None

             index = -1

             lenList = len(sortedList)

-            for  i in range(lenList):

+            for i in range(lenList):

                 if sortedList[i] in alreadyProcessedPackages:

                     continue

                 pkg = sortedList[i]

@@ -86,10 +87,11 @@ class PackageBuildDataGenerator(object):

                 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)

+            #remove any cyclic packages in sortListForPkg if they already

+            #exists in sortedList

+            circularDependentPackages = self._getCircularDependentPackages(pkg)

             for p in circularDependentPackages:

                 if p in sortedList and p in sortListForPkg:

                     sortListForPkg.remove(p)

@@ -104,25 +106,23 @@ class PackageBuildDataGenerator(object):

                     sortedList.insert(index, p)

                     index = index + 1

-            alreadyProcessedPackages.append(p)

+            alreadyProcessedPackages.add(p)

             # Remove duplicate entries in sorted list in intervals

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

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

-                sortedList = removeDuplicateEntriesInList(sortedList)

+                sortedList = removeDuplicateEntries(sortedList)

             else:

                 prevSortListLen = len(sortedList)

         self.logger.info("Removing duplicates in sorted list")

-        sortedList = removeDuplicateEntriesInList(sortedList)

+        sortedList = removeDuplicateEntries(sortedList)

         self.logger.info("Sorted list:")

         self.logger.info(sortedList)

         self.__sortedPackageList = sortedList

-    def __constructBuildAndRunTimeDependencyGraph(self, package):

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

-

+    def _constructBuildAndRunTimeDependencyGraph(self, basePackage):

         addBuildTimeGraph = True

         addRunTimeGraph = True

         if basePackage in self.__buildDependencyGraph:

@@ -130,104 +130,120 @@ class PackageBuildDataGenerator(object):

         if basePackage in self.__runTimeDependencyGraph:

             addRunTimeGraph = False

-        nextPackagesToConstructGraph = []

+        nextPackagesToConstructGraph = set()

         if addBuildTimeGraph:

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

-            listDependentPackages = []

-            for rpmPkg in listDependentRpmPackages:

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

+            dependentPackages = set()

+            for rpmPkg in dependentRpmPackages:

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

-                if basePkg not in listDependentPackages:

-                    listDependentPackages.append(basePkg)

-            self.__buildDependencyGraph[basePackage] = listDependentPackages

-            nextPackagesToConstructGraph.extend(listDependentPackages)

+                dependentPackages.add(basePkg)

+            self.__buildDependencyGraph[basePackage] = dependentPackages

+            nextPackagesToConstructGraph.update(dependentPackages)

         if addRunTimeGraph:

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

-            for rpmPkg in listRpmPackages:

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

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

-                nextPackagesToConstructGraph.extend(listDependentRpmPackages)

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

+            dependentPackages = set()

+            for rpmPkg in rpmPackages:

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

+                self.__runTimeDependencyGraph[rpmPkg] = copy.copy(dependentRpmPackages)

+                for pkg in dependentRpmPackages:

+                    dependentPackages.add(SPECS.getData().getSpecName(pkg))

+            nextPackagesToConstructGraph.update(dependentPackages)

         for pkg in nextPackagesToConstructGraph:

-            self.__constructBuildAndRunTimeDependencyGraph(pkg)

+            self._constructBuildAndRunTimeDependencyGraph(pkg)

-    def __readDependencyGraphAndCyclesForGivenPackages(self, listPackages):

+    def _readDependencyGraphAndCyclesForGivenPackages(self, basePackages):

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

-        for pkg in listPackages:

-            self.__constructBuildAndRunTimeDependencyGraph(pkg)

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

-            sortedPackageList, circularDependentPackages = self.topologicalSortPackages(

+        for pkg in basePackages:

+            self._constructBuildAndRunTimeDependencyGraph(pkg)

+

+        for pkg in self._findAllPackagesToBuild():

+            sortedPackageList, circularDependentPackages = self._topologicalSortPackages(

                 self.__buildDependencyGraph, pkg)

-            if len(circularDependentPackages) > 0:

+            if circularDependentPackages:

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

                 self.logger.error(circularDependentPackages)

                 raise Exception("Build Time Circular Dependency")

             self.__sortedBuildDependencyGraph[pkg] = sortedPackageList

-        sortedPackageList, circularDependentPackages = self.topologicalSortPackages(

+        sortedPackageList, circularDependentPackages = self._topologicalSortPackages(

             self.__runTimeDependencyGraph)

-        if len(circularDependentPackages) > 0:

-            self.__findCircularDependencies(circularDependentPackages)

-

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

-        noDepPackages = set()

-        sortedPackageList = []

-        dependentOfPackage = dict()

+        if circularDependentPackages:

+            self._findCircularDependencies(circularDependentPackages)

+    @staticmethod

+    def _buildDependentPackages(dependencyGraph, package):

         dependentPackages = {}

         if package is None:

             dependentPackages = copy.deepcopy(dependencyGraph)

         else:

-            listDepPkgs = set()

-            listDepPkgs.add(package)

-            while listDepPkgs:

-                pkg = listDepPkgs.pop()

+            depPkgs = set()

+            depPkgs.add(package)

+            while depPkgs:

+                pkg = depPkgs.pop()

                 if pkg in dependentPackages:

                     continue

-                dependentPackages[pkg] = dependencyGraph[pkg][:]

+                dependentPackages[pkg] = copy.copy(dependencyGraph[pkg])

                 for depPkg in dependencyGraph[pkg]:

-                    listDepPkgs.add(depPkg)

+                    depPkgs.add(depPkg)

+        return dependentPackages

-        #Find packages with no dependencies and generate dependentof_package edge list

+    @staticmethod

+    def _buildDependentOfPackages(dependentPackages):

+        dependentOfPackage = dict()

         for pkg in dependentPackages:

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

-                noDepPackages.add(pkg)

-            else:

+            if dependentPackages[pkg]:

                 for depPkg in dependentPackages[pkg]:

                     if depPkg not in dependentOfPackage:

-                        dependentOfPackage[depPkg] = [pkg]

+                        dependentOfPackage[depPkg] = {pkg}

                     else:

-                        if pkg not in dependentOfPackage[depPkg]:

-                            dependentOfPackage[depPkg].append(pkg)

+                        dependentOfPackage[depPkg].add(pkg)

+        return dependentOfPackage

+

+    @staticmethod

+    def _topologicalSortPackages(dependencyGraph, package=None):

+        sortedPackageList = []

+        noDepPackages = set()

+

+        dependentPackages = PackageBuildDataGenerator._buildDependentPackages(

+            dependencyGraph, package)

+        dependentOfPackage = PackageBuildDataGenerator._buildDependentOfPackages(

+            dependentPackages)

+

+        #Find packages with no dependencies and generate dependentof_package edge list

+        for pkg in dependentPackages:

+            if not dependentPackages[pkg]:

+                noDepPackages.add(pkg)

         while noDepPackages:

             pkg = noDepPackages.pop()

             sortedPackageList.append(pkg)

-            if dependentOfPackage.get(pkg) is not None:

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

-                    dependentOfPackage.get(pkg).remove(childPkg)

+            if pkg in dependentOfPackage:

+                for childPkg in list(dependentOfPackage[pkg]):

+                    dependentOfPackage[pkg].remove(childPkg)

                     dependentPackages[childPkg].remove(pkg)

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

+                    if not dependentPackages[childPkg]:

                         noDepPackages.add(childPkg)

         # creating circular dependency graph for given dependency graph

         circularDependencyGraph = {}

         for pkg in dependentPackages.keys():

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

+            if dependentPackages[pkg]:

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

+    def _constructDependencyMap(self, cyclicDependencyGraph):

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

         constructDependencyMap = {}

         for node in cyclicDependencyGraph.keys():

-            tmpDepNodeList = []

-            tmpDepNodeList.append(node)

+            tmpDepNodeList = set()

+            tmpDepNodeList.add(node)

             depNodeList = []

-            while len(tmpDepNodeList) != 0:

+            while tmpDepNodeList:

                 currentNode = tmpDepNodeList.pop()

                 addDepNodeList = cyclicDependencyGraph[currentNode]

                 depNodeList.append(currentNode)

@@ -236,19 +252,19 @@ class PackageBuildDataGenerator(object):

                         continue

                     else:

                         if depNode not in tmpDepNodeList:

-                            tmpDepNodeList.append(depNode)

+                            tmpDepNodeList.add(depNode)

             depNodeList.remove(node)

             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:

+        if not cyclicDependencyGraph:

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

@@ -262,7 +278,7 @@ class PackageBuildDataGenerator(object):

                     if node in x:

                         cycPkgs.append(depPkg)

-                if len(cycPkgs) != 0:

+                if cycPkgs:

                     cycPkgs.append(node)

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

                     PackageBuildDataGenerator.cycleCount += 1

@@ -10,21 +10,28 @@ from SpecData import SPECS

 import docker

 class PackageBuilderBase(object):

-    def __init__(self, mapPackageToCycles, listAvailableCyclicPackages,

-                 pkgBuildType):

+    def __init__(self, mapPackageToCycles, pkgBuildType):

         # will be initialized in buildPackageFunction()

         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.pkgBuildType = pkgBuildType

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

+    def buildPackageFunction(self, package):

+        self._buildPackagePrepareFunction(package)

+        try:

+            self._buildPackage()

+        except Exception as e:

+            # TODO: self.logger might be None

+            self.logger.exception(e)

+            raise e

+

+    def _buildPackagePrepareFunction(self, package):

         self.package = package

         self.logName = "build-" + package

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

@@ -33,7 +40,7 @@ class PackageBuilderBase(object):

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

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

-    def findPackageNameFromRPMFile(self, rpmfile):

+    def _findPackageNameFromRPMFile(self, rpmfile):

         rpmfile = os.path.basename(rpmfile)

         releaseindex = rpmfile.rfind("-")

         if releaseindex == -1:

@@ -46,7 +53,7 @@ class PackageBuilderBase(object):

         packageName = rpmfile[0:versionindex]

         return packageName

-    def findInstalledPackages(self, instanceID):

+    def _findInstalledPackages(self, instanceID):

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

         if self.pkgBuildType == "chroot":

             listInstalledRPMs = pkgUtils.findInstalledRPMPackages(instanceID)

@@ -54,12 +61,12 @@ class PackageBuilderBase(object):

             listInstalledRPMs = pkgUtils.findInstalledRPMPackagesInContainer(instanceID)

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

+    def _checkIfPackageIsAlreadyBuilt(self):

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

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

         packageIsAlreadyBuilt = True

@@ -70,20 +77,17 @@ class PackageBuilderBase(object):

                 break

         return packageIsAlreadyBuilt

-    def findRunTimeRequiredRPMPackages(self, rpmPackage):

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

-        return listRequiredPackages

+    def _findRunTimeRequiredRPMPackages(self, rpmPackage):

+        return SPECS.getData().getRequiresForPackage(rpmPackage)

-    def findBuildTimeRequiredPackages(self):

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

-        return listRequiredPackages

+    def _findBuildTimeRequiredPackages(self):

+        return SPECS.getData().getBuildRequiresForPackage(self.package)

-    def findBuildTimeCheckRequiredPackages(self):

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

-        return listRequiredPackages

+    def _findBuildTimeCheckRequiredPackages(self):

+        return SPECS.getData().getCheckBuildRequiresForPackage(self.package)

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

-                       listInstalledPackages, listInstalledRPMs):

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

@@ -91,60 +95,59 @@ class PackageBuilderBase(object):

         # mark it as installed -  to avoid cyclic recursion

         listInstalledPackages.append(package)

         listInstalledRPMs.append(latestRPM)

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

-                                             listInstalledPackages, listInstalledRPMs)

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

+                                              listInstalledPackages, listInstalledRPMs)

         noDeps = False

-        if package in self.mapPackageToCycles:

-            noDeps = True

-        if package in self.listNodepsPackages:

-            noDeps = True

-        if package in constants.noDepsPackageList:

+        if (package in self.mapPackageToCycles or

+                package in self.listNodepsPackages or

+                package in constants.noDepsPackageList):

             noDeps = True

         if self.pkgBuildType == "chroot":

             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)

-        if len(listRunTimeDependentPackages) != 0:

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

+                                         listInstalledPackages, listInstalledRPMs):

+        listRunTimeDependentPackages = self._findRunTimeRequiredRPMPackages(package)

+        if listRunTimeDependentPackages:

             for pkg in listRunTimeDependentPackages:

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

+                if pkg in self.mapPackageToCycles:

                     continue

                 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)

-

-class PackageBuilderContainer(object):

-    def __init__(self, mapPackageToCycles, listAvailableCyclicPackages,

-                 pkgBuildType):

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

+                                     listInstalledPackages, listInstalledRPMs)

+

+    def _findDependentPackagesAndInstalledRPM(self, instanceID):

+        listInstalledPackages, listInstalledRPMs = self._findInstalledPackages(instanceID)

+        self.logger.info(listInstalledPackages)

+        listDependentPackages = self._findBuildTimeRequiredPackages()

+        if constants.rpmCheck and self.package in constants.testForceRPMS:

+            listDependentPackages.extend(self._findBuildTimeCheckRequiredPackages())

+            testPackages = (set(constants.listMakeCheckRPMPkgtoInstall) -

+                            set(listInstalledPackages) -

+                            set([self.package]))

+            listDependentPackages.extend(testPackages)

+            listDependentPackages = list(set(listDependentPackages))

+        return listDependentPackages, listInstalledPackages, listInstalledRPMs

+

+

+class PackageBuilderContainer(PackageBuilderBase):

+    def __init__(self, mapPackageToCycles, pkgBuildType):

         self.buildContainerImage = "photon_build_container:latest"

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

-        self.base = PackageBuilderBase(mapPackageToCycles, listAvailableCyclicPackages,

-                                       pkgBuildType)

+        PackageBuilderBase.__init__(self, mapPackageToCycles, pkgBuildType)

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

-        self.base.buildPackagePrepareFunction(package, outputMap, threadName)

-        try:

-            self.buildPackage()

-            outputMap[threadName] = True

-        except Exception as e:

-            # TODO: self.logger might be None

-            self.base.logger.exception(e)

-            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

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

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

         returnVal, chrootID = chrUtils.createChroot(chrootName)

         if not returnVal:

             raise Exception("Unable to prepare build root")

@@ -159,8 +162,8 @@ class PackageBuilderContainer(object):

             constants.tmpDirPath: {'bind': '/tmp', 'mode': 'rw'},

             constants.rpmPath: {'bind': constants.topDirPath + "/RPMS", 'mode': 'rw'},

             constants.sourceRpmPath: {'bind': constants.topDirPath + "/SRPMS", 'mode': 'rw'},

-            constants.logPath + "/" + self.base.logName: {'bind': constants.topDirPath + "/LOGS",

-                                                          'mode': 'rw'},

+            constants.logPath + "/" + self.logName: {'bind': constants.topDirPath + "/LOGS",

+                                                     'mode': 'rw'},

             chrootID + constants.topDirPath + "/BUILD": {'bind': constants.topDirPath + "/BUILD",

                                                          'mode': 'rw'},

             constants.dockerUnixSocket: {'bind': constants.dockerUnixSocket, 'mode': 'rw'}

@@ -179,8 +182,8 @@ class PackageBuilderContainer(object):

                 pass

         try:

-            self.base.logger.info("BuildContainer-prepareBuildContainer: " +

-                                  "Starting build container: " + containerName)

+            self.logger.info("BuildContainer-prepareBuildContainer: " +

+                             "Starting build container: " + containerName)

             #TODO: Is init=True equivalent of --sig-proxy?

             privilegedDocker = False

             cap_list = ['SYS_PTRACE']

@@ -196,88 +199,80 @@ class PackageBuilderContainer(object):

                                                            volumes=mountVols,

                                                            command="/bin/bash -l -c /wait.sh")

-            self.base.logger.debug("Started Photon build container for task " + containerTaskName +

-                                   " ID: " + containerID.short_id)

+            self.logger.debug("Started Photon build container for task " + containerTaskName +

+                              " ID: " + containerID.short_id)

             if not containerID:

                 raise Exception("Unable to start Photon build container for task " +

                                 containerTaskName)

         except Exception as e:

-            self.base.logger.debug("Unable to start Photon build container for task " +

-                                   containerTaskName)

+            self.logger.debug("Unable to start Photon build container for task " +

+                              containerTaskName)

             raise e

         return containerID, chrootID

-    def buildPackage(self):

+    def _buildPackage(self):

         #do not build if RPM is already built

         #test only if the package is in the testForceRPMS with rpmCheck

         #build only if the package is not in the testForceRPMS with rpmCheck

-        if self.base.checkIfPackageIsAlreadyBuilt():

+        if self._checkIfPackageIsAlreadyBuilt():

             if not constants.rpmCheck:

-                self.base.logger.info("Skipping building the package:" + self.base.package)

+                self.logger.info("Skipping building the package:" + self.package)

                 return

-            elif constants.rpmCheck and self.base.package not in constants.testForceRPMS:

-                self.base.logger.info("Skipping testing the package:" + self.base.package)

+            elif constants.rpmCheck and self.package not in constants.testForceRPMS:

+                self.logger.info("Skipping testing the package:" + self.package)

                 return

         #should initialize a logger based on package name

-        containerTaskName = "build-" + self.base.package

+        containerTaskName = "build-" + self.package

         containerID = None

         chrootID = None

         isToolChainPackage = False

-        if self.base.package in constants.listToolChainPackages:

+        if self.package in constants.listToolChainPackages:

             isToolChainPackage = True

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

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

         try:

-            containerID, chrootID = self.prepareBuildContainer(

-                containerTaskName, self.base.package, isToolChainPackage)

+            containerID, chrootID = self._prepareBuildContainer(

+                containerTaskName, self.package, isToolChainPackage)

-            tcUtils = ToolChainUtils(self.base.logName, self.base.logPath)

-            if self.base.package in constants.perPackageToolChain:

-                self.base.logger.debug(constants.perPackageToolChain[self.base.package])

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

+            if self.package in constants.perPackageToolChain:

+                self.logger.debug(constants.perPackageToolChain[self.package])

                 tcUtils.installCustomToolChainRPMSinContainer(

                     containerID,

-                    constants.perPackageToolChain[self.base.package],

-                    self.base.package)

-

-            listInstalledPackages, listInstalledRPMs = self.base.findInstalledPackages(containerID)

-            self.base.logger.info(listInstalledPackages)

-            listDependentPackages = self.base.findBuildTimeRequiredPackages()

-            if constants.rpmCheck and self.base.package in constants.testForceRPMS:

-                listDependentPackages.extend(self.base.findBuildTimeCheckRequiredPackages())

-                testPackages = (set(constants.listMakeCheckRPMPkgtoInstall) -

-                                set(listInstalledPackages) -

-                                set([self.base.package]))

-                listDependentPackages.extend(testPackages)

-                listDependentPackages = list(set(listDependentPackages))

-

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

-            if len(listDependentPackages) != 0:

-                self.base.logger.info("BuildContainer-buildPackage: " +

-                                      "Installing dependent packages..")

-                self.base.logger.info(listDependentPackages)

+                    constants.perPackageToolChain[self.package],

+                    self.package)

+

+            listDependentPackages, listInstalledPackages, listInstalledRPMs = (

+                self._findDependentPackagesAndInstalledRPM(containerID))

+

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

+            if listDependentPackages:

+                self.logger.info("BuildContainer-buildPackage: " +

+                                 "Installing dependent packages..")

+                self.logger.info(listDependentPackages)

                 for pkg in listDependentPackages:

-                    self.base.installPackage(pkgUtils, pkg, containerID, destLogPath,

-                                             listInstalledPackages, listInstalledRPMs)

+                    self._installPackage(pkgUtils, pkg, containerID, destLogPath,

+                                         listInstalledPackages, listInstalledRPMs)

                 pkgUtils.installRPMSInAOneShotInContainer(containerID, destLogPath)

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

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

-            self.base.logger.info("BuildContainer-buildPackage: Start building the package: " +

-                                  self.base.package)

-            pkgUtils.adjustGCCSpecsInContainer(self.base.package, containerID, destLogPath)

+            self.logger.info("BuildContainer-buildPackage: Start building the package: " +

+                             self.package)

+            pkgUtils.adjustGCCSpecsInContainer(self.package, containerID, destLogPath)

             pkgUtils.buildRPMSForGivenPackageInContainer(

-                self.base.package,

+                self.package,

                 containerID,

                 destLogPath)

-            self.base.logger.info("BuildContainer-buildPackage: Successfully built the package: " +

-                                  self.base.package)