@@ -11,7 +11,7 @@ import docker

 class PackageBuilderBase(object):

     def __init__(self, mapPackageToCycles, listAvailableCyclicPackages,

-                 listBuildOptionPackages, pkgBuildOptionFile, pkgBuildType):

+                 pkgBuildType):

         # will be initialized in buildPackageFunction()

         self.logName = None

         self.logPath = None

@@ -22,8 +22,6 @@ class PackageBuilderBase(object):

         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 buildPackagePrepareFunction(self, package, outputMap, threadName):

@@ -122,13 +120,13 @@ class PackageBuilderBase(object):

                                     listInstalledPackages, listInstalledRPMs)

 class PackageBuilderContainer(object):

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

-                 pkgBuildOptionFile, pkgBuildType):

+    def __init__(self, mapPackageToCycles, listAvailableCyclicPackages,

+                 pkgBuildType):

         self.buildContainerImage = "photon_build_container:latest"

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

         self.base = PackageBuilderBase(mapPackageToCycles, listAvailableCyclicPackages,

-                                       listBuildOptionPackages, pkgBuildOptionFile, pkgBuildType)

+                                       pkgBuildType)

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

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

@@ -269,8 +267,6 @@ class PackageBuilderContainer(object):

             pkgUtils.buildRPMSForGivenPackageInContainer(

                 self.base.package,

                 containerID,

-                self.base.listBuildOptionPackages,

-                self.base.pkgBuildOptionFile,

                 destLogPath)

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

                                   self.base.package)

@@ -293,10 +289,10 @@ class PackageBuilderContainer(object):

             chrUtils.destroyChroot(chrootID)

 class PackageBuilderChroot(object):

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

-                 pkgBuildOptionFile, pkgBuildType):

+    def __init__(self, mapPackageToCycles, listAvailableCyclicPackages,

+                 pkgBuildType):

         self.base = PackageBuilderBase(mapPackageToCycles, listAvailableCyclicPackages,

-                                       listBuildOptionPackages, pkgBuildOptionFile, pkgBuildType)

+                                       pkgBuildType)

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

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

@@ -364,8 +360,6 @@ class PackageBuilderChroot(object):

             pkgUtils.adjustGCCSpecs(self.base.package, chrootID, self.base.logPath)

             pkgUtils.buildRPMSForGivenPackage(self.base.package, chrootID,

-                                              self.base.listBuildOptionPackages,

-                                              self.base.pkgBuildOptionFile,

                                               self.base.logPath)

             self.base.logger.info("Successfully built the package:" + self.base.package)

         except Exception as e:

@@ -30,8 +30,6 @@ class PackageManager(object):

         self.mapOutputThread = {}

         self.mapThreadsLaunchTime = {}

         self.listAvailableCyclicPackages = []

-        self.listBuildOptionPackages = []

-        self.pkgBuildOptionFile = ""

         self.pkgBuildType = pkgBuildType

         if self.pkgBuildType == "container":

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

@@ -130,15 +128,14 @@ class PackageManager(object):

         pkgCount = 0

         try:

             tUtils = ToolChainUtils()

-            pkgCount = tUtils.buildCoreToolChainPackages(self.listBuildOptionPackages,

-                                                         self.pkgBuildOptionFile)

+            pkgCount = tUtils.buildCoreToolChainPackages()

         except Exception as e:

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

             self.logger.error(e)

             raise e

         return pkgCount

-    def buildToolChainPackages(self, listBuildOptionPackages, pkgBuildOptionFile, buildThreads):

+    def buildToolChainPackages(self, buildThreads):

         pkgCount = self.buildToolChain()

         if self.pkgBuildType == "container":

             # Stage 1 build container

@@ -151,31 +148,26 @@ class PackageManager(object):

             #TODO: rebuild container only if anything in listToolChainPackages was built

             self.createBuildContainer()

-    def buildTestPackages(self, listBuildOptionPackages, pkgBuildOptionFile, buildThreads):

+    def buildTestPackages(self, buildThreads):

         self.buildToolChain()

         self.buildGivenPackages(constants.listMakeCheckRPMPkgtoInstall, buildThreads)

-    def buildPackages(self, listPackages, listBuildOptionPackages, pkgBuildOptionFile,

-                      buildThreads, pkgBuildType):

-        self.listBuildOptionPackages = listBuildOptionPackages

-        self.pkgBuildOptionFile = pkgBuildOptionFile

+    def buildPackages(self, listPackages, buildThreads, pkgBuildType):

         self.pkgBuildType = pkgBuildType

         if constants.rpmCheck:

             constants.rpmCheck = False

-            self.buildToolChainPackages(listBuildOptionPackages, pkgBuildOptionFile, buildThreads)

-            self.buildTestPackages(listBuildOptionPackages, pkgBuildOptionFile, buildThreads)

+            self.buildToolChainPackages(buildThreads)

+            self.buildTestPackages(buildThreads)

             constants.rpmCheck = True

             self.buildGivenPackages(listPackages, buildThreads)

         else:

-            self.buildToolChainPackages(listBuildOptionPackages, pkgBuildOptionFile, buildThreads)

+            self.buildToolChainPackages(buildThreads)

             self.buildGivenPackages(listPackages, buildThreads)

     def initializeThreadPool(self, statusEvent):

         ThreadPool.clear()

         ThreadPool.mapPackageToCycle = self.mapPackageToCycle

         ThreadPool.listAvailableCyclicPackages = self.listAvailableCyclicPackages

-        ThreadPool.listBuildOptionPackages = self.listBuildOptionPackages

-        ThreadPool.pkgBuildOptionFile = self.pkgBuildOptionFile

         ThreadPool.logger = self.logger

         ThreadPool.statusEvent = statusEvent

         ThreadPool.pkgBuildType = self.pkgBuildType

@@ -156,34 +156,29 @@ class PackageUtils(object):

     def copyAdditionalBuildFiles(self, listAdditionalFiles, chrootID):

         cmdUtils = CommandUtils()

         for additionalFile in listAdditionalFiles:

-            source = additionalFile["src"].encode('utf-8')

-            destDir = chrootID + additionalFile["dst"].encode('utf-8')

+            source = additionalFile["src"]

+            destDir = chrootID + additionalFile["dst"]

+            self.logger.info("Copying additional Source build files :" + source)

             if os.path.exists(source):

                 if os.path.isfile(source):

                     shutil.copy(source, destDir)

                 else:

                     shutil.copytree(source, destDir)

-    def getAdditionalBuildFiles(self, package, pkgBuildOptionFile):

+    def getAdditionalBuildFiles(self, package):

         listAdditionalFiles = []

         macros = []

-        jsonData = open(pkgBuildOptionFile)

-        pkg_build_option_json = json.load(jsonData, object_pairs_hook=collections.OrderedDict)

-        jsonData.close()

-        pkgs_sorted = pkg_build_option_json.items()

-        for pkg in pkgs_sorted:

-            p = str(pkg[0].encode('utf-8'))

-            if p == package:

-                filelist = pkg[1]["files"]

-                for f in filelist:

-                    listAdditionalFiles.append(f)

-                macrolist = pkg[1]["macros"]

-                for macro in macrolist:

-                    macros.append(str(macro.encode('utf-8')))

+        if package in constants.buildOptions.keys():

+            pkg = constants.buildOptions[package]

+            filelist = pkg["files"]

+            for f in filelist:

+                listAdditionalFiles.append(f)

+            macrolist = pkg["macros"]

+            for macro in macrolist:

+                macros.append(macro)

         return listAdditionalFiles, macros

-    def buildRPMSForGivenPackage(self, package, chrootID, listBuildOptionPackages,

-                                 pkgBuildOptionFile, destLogPath=None):

+    def buildRPMSForGivenPackage(self, package, chrootID, destLogPath=None):

         self.logger.info("Building rpm's for package:" + package)

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

@@ -201,11 +196,10 @@ class PackageUtils(object):

         #        if os.geteuid()==0:

         self.copySourcesTobuildroot(listSourcesFiles, package, chrootSourcePath)

         self.copySourcesTobuildroot(listPatchFiles, package, chrootSourcePath)

-

         macros = []

-        if package in listBuildOptionPackages:

-            listAdditionalFiles, macros = self.getAdditionalBuildFiles(package, pkgBuildOptionFile)

-            self.copyAdditionalBuildFiles(listAdditionalFiles, chrootID)

+

+        listAdditionalFiles, macros = self.getAdditionalBuildFiles(package)

+        self.copyAdditionalBuildFiles(listAdditionalFiles, chrootID)

         #Adding rpm macros

         listRPMMacros = constants.userDefinedMacros

@@ -411,18 +405,18 @@ class PackageUtils(object):

         #                  containerID.short_id)

         #self.logger.debug(listAdditionalFiles)

         for additionalFile in listAdditionalFiles:

-            source = additionalFile["src"].encode('utf-8')

-            destDir = additionalFile["dst"].encode('utf-8')

+            source = additionalFile["src"]

+            destDir = additionalFile["dst"]

             destPath = containerID.short_id + ":" + destDir

             #TODO: exit status of exec_run

             containerID.exec_run("mkdir -p " + destDir)

             if os.path.exists(source):

                 copyCmd = "docker cp " + source

                 if os.path.isfile(source):

-                    self.logger.info("Copying addl source file: " + source)

+                    self.logger.info("Copying additional source file: " + source)

                     copyCmd += " " + destPath

                 else:

-                    self.logger.info("Copying addl source file tree: " + source)

+                    self.logger.info("Copying additional source file tree: " + source)

                     copyCmd += "/. " + destPath

                 #TODO: cmd error code

                 cmdUtils.runCommandInShell(copyCmd)

@@ -555,8 +549,7 @@ class PackageUtils(object):

         self.logger.error("Failed while adjusting gcc specs")

         raise Exception("Failed while adjusting gcc specs")

-    def buildRPMSForGivenPackageInContainer(self, package, containerID, listBuildOptionPackages,

-                                            pkgBuildOptionFile, destLogPath=None):

+    def buildRPMSForGivenPackageInContainer(self, package, containerID, destLogPath=None):

         self.logger.info("Building rpm's for package " + package + " in container " +

                          containerID.short_id)

@@ -585,9 +578,8 @@ class PackageUtils(object):

         self.copySourcesToContainer(listSourcesFiles, package, containerID, sourcePath)

         #TODO: mount it in, don't copy

         self.copySourcesToContainer(listPatchFiles, package, containerID, sourcePath)

-        if package in listBuildOptionPackages:

-            listAdditionalFiles, macros = self.getAdditionalBuildFiles(package, pkgBuildOptionFile)

-            self.copyAdditionalBuildFilesToContainer(listAdditionalFiles, containerID)

+        listAdditionalFiles, macros = self.getAdditionalBuildFiles(package)

+        self.copyAdditionalBuildFilesToContainer(listAdditionalFiles, containerID)

         # Add rpm macros

         listRPMMacros = constants.userDefinedMacros

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

     inactiveWorkerThreads = []

     mapPackageToCycle = {}

     listAvailableCyclicPackages = []

-    listBuildOptionPackages = []

-    pkgBuildOptionFile = ""

     pkgBuildType = "chroot"

     logger = None

     statusEvent = None

@@ -36,8 +34,6 @@ class ThreadPool(object):

             ThreadPool.mapPackageToCycle,

             ThreadPool.listAvailableCyclicPackages,

             ThreadPool.logger,

-            ThreadPool.listBuildOptionPackages,

-            ThreadPool.pkgBuildOptionFile,

             ThreadPool.pkgBuildType)

         ThreadPool.mapWorkerThreads[workerThreadName] = workerThread

@@ -74,7 +74,7 @@ class ToolChainUtils(object):

                               "Unable to determine the rpm file for package:" + package)

             return None

-    def buildCoreToolChainPackages(self, listBuildOptionPackages, pkgBuildOptionFile):

+    def buildCoreToolChainPackages(self):

         self.logger.info("Building core toolchain packages.....")

         chrootID = None

         pkgCount = 0

@@ -97,8 +97,7 @@ class ToolChainUtils(object):

                     raise Exception("creating chroot failed")

                 self.installToolChainRPMS(chrootID, package, destLogPath)

                 pkgUtils.adjustGCCSpecs(package, chrootID, destLogPath)

-                pkgUtils.buildRPMSForGivenPackage(package, chrootID, listBuildOptionPackages,

-                                                  pkgBuildOptionFile, destLogPath)

+                pkgUtils.buildRPMSForGivenPackage(package, chrootID, destLogPath)

                 pkgCount += 1

                 chrUtils.destroyChroot(chrootID)

                 chrootID = None

@@ -7,15 +7,13 @@ import ThreadPool

 class WorkerThread(threading.Thread):

     def __init__(self, event, name, mapPackageToCycle, listAvailableCyclicPackages, logger,

-                 listBuildOptionPackages, pkgBuildOptionFile, pkgBuildType):

+                 pkgBuildType):

         threading.Thread.__init__(self)

         self.statusEvent = event

         self.name = name

         self.mapPackageToCycle = mapPackageToCycle

         self.listAvailableCyclicPackages = listAvailableCyclicPackages

         self.logger = logger

-        self.listBuildOptionPackages = listBuildOptionPackages

-        self.pkgBuildOptionFile = pkgBuildOptionFile

         self.pkgBuildType = pkgBuildType

     def run(self):

@@ -31,14 +29,10 @@ class WorkerThread(threading.Thread):

             if self.pkgBuildType == "chroot":

                 pkgBuilder = PackageBuilderChroot(self.mapPackageToCycle,

                                                   self.listAvailableCyclicPackages,

-                                                  self.listBuildOptionPackages,

-                                                  self.pkgBuildOptionFile,

                                                   self.pkgBuildType)

             elif self.pkgBuildType == "container":

                 pkgBuilder = PackageBuilderContainer(self.mapPackageToCycle,

                                                      self.listAvailableCyclicPackages,

-                                                     self.listBuildOptionPackages,

-                                                     self.pkgBuildOptionFile,

                                                      self.pkgBuildType)

             pkgBuilder.buildPackageFunction(pkg, outputMap, pkg)

             if pkg not in outputMap or outputMap[pkg] == False:

@@ -123,7 +123,7 @@ def main():

         cmdUtils.runCommandInShell("mkdir -p "+options.sourceRpmPath)

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

-        cmdUtils.runCommandInShell("mkdir -p "+options.buildRootPath)

+        cmdUtils.runCommandInShell("mkdir -p " + options.buildRootPath)

     logger.info("Source Path :"+options.sourcePath)

     logger.info("Spec Path :" + options.specPath)

@@ -134,9 +134,9 @@ def main():

     logger.info("Publish X RPMS Path :" + options.publishXRPMSPath)

     if options.installPackage:

-        logger.info("Package to build:"+package)

+        logger.info("Package to build:" + package)

-    listBuildOptionPackages = get_packages_with_build_options(options.pkgBuildOptionFile)

+    get_packages_with_build_options(options.pkgBuildOptionFile)

     try:

@@ -170,11 +170,9 @@ def main():

             pkgManager = PackageManager()

             pkgManager.buildToolChainPackages(options.buildThreads)

         elif options.installPackage:

-            buildAPackage(package, listBuildOptionPackages, options.pkgBuildOptionFile,

-                          options.buildThreads, options.pkgBuildType)

+            buildAPackage(package, options.buildThreads, options.pkgBuildType)

         else:

-            buildPackagesForAllSpecs(listBuildOptionPackages, options.pkgBuildOptionFile,

-                                     logger, options.buildThreads, pkgInfoJsonFile,

+            buildPackagesForAllSpecs(logger, options.buildThreads, pkgInfoJsonFile,

                                      options.pkgBuildType)

     except Exception as e:

         logger.error("Caught an exception")

@@ -185,18 +183,15 @@ def main():

     sys.exit(0)

-def buildAPackage(package, listBuildOptionPackages, pkgBuildOptionFile,

-                  buildThreads, pkgBuildType):

+def buildAPackage(package, buildThreads, pkgBuildType):

     listPackages = [package]

     pkgManager = PackageManager(pkgBuildType=pkgBuildType)

     if constants.rpmCheck:

         constants.setTestForceRPMS(listPackages[:])

-    pkgManager.buildPackages(listPackages, listBuildOptionPackages, pkgBuildOptionFile,

-                             buildThreads, pkgBuildType)

+    pkgManager.buildPackages(listPackages, buildThreads, pkgBuildType)

-def buildPackagesForAllSpecs(listBuildOptionPackages, pkgBuildOptionFile, logger,

-                             buildThreads, pkgInfoJsonFile, pkgBuildType):

+def buildPackagesForAllSpecs(logger, buildThreads, pkgInfoJsonFile, pkgBuildType):

     listPackages = SPECS.getData().getListPackages()

     logger.info("List of packages to build:")

@@ -204,29 +199,20 @@ def buildPackagesForAllSpecs(listBuildOptionPackages, pkgBuildOptionFile, logger

     if constants.rpmCheck:

         constants.setTestForceRPMS(listPackages[:])

     pkgManager = PackageManager(pkgBuildType=pkgBuildType)

-    pkgManager.buildPackages(listPackages, listBuildOptionPackages, pkgBuildOptionFile,

-                             buildThreads, pkgBuildType)

+    pkgManager.buildPackages(listPackages, buildThreads, pkgBuildType)

     # Generating package info file which is required by installer

-    logger.info("Writing Package info to the file:"+pkgInfoJsonFile)

+    logger.info("Writing Package info to the file:" + pkgInfoJsonFile)

     pkgInfo = PackageInfo()

     pkgInfo.loadPackagesData()

     pkgInfo.writePkgListToFile(pkgInfoJsonFile)

 def get_packages_with_build_options(pkg_build_options_file):

-    packages = []

     if os.path.exists(pkg_build_options_file):

-        jsonData = open(pkg_build_options_file)

-        pkg_build_option_json = json.load(jsonData, object_pairs_hook=collections.OrderedDict)

-        jsonData.close()

-        pkgs_sorted = pkg_build_option_json.items()

-        for pkg in pkgs_sorted:

-            p = pkg[0].encode('utf-8')

-            packages.append(str(p))

-

-    return packages

-

+        with open(pkg_build_options_file) as jsonData:

+            pkg_build_option_json = json.load(jsonData, object_pairs_hook=collections.OrderedDict)

+            constants.setBuidOptions(pkg_build_option_json)

 def get_all_package_names(build_install_option):

     base_path = os.path.dirname(build_install_option)

@@ -24,6 +24,7 @@ class constants(object):

     katBuild = None

     testForceRPMS = []

     tmpDirPath = "/dev/shm"

+    buildOptions = {}

     noDepsPackageList = [

         "texinfo",

@@ -532,3 +533,7 @@ class constants(object):

     @staticmethod

     def addMacro(macroName, macroValue):

         constants.userDefinedMacros[macroName] = macroValue

+

+    @staticmethod

+    def setBuidOptions(options):

+        constants.buildOptions = options