def buildCoreToolChainPackages(self):
self.logger.info("Building core tool chain packages.....")
chrootID = None
try:
pkgUtils = PackageUtils(self.logName, self.logPath)
for package in constants.listCoreToolChainRPMPackages:
rpmPkg = pkgUtils.findRPMFileForGivenPackage(package)
if rpmPkg is not None:
continue
chrUtils = ChrootUtils(self.logName, self.logPath)
chrootName = "build-core-toolchain"
destLogPath = constants.logPath + "/build-" + package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p " + destLogPath)
returnVal, chrootID = chrUtils.createChroot(chrootName)
if not returnVal:
self.logger.error("Creating chroot failed")
raise Exception("creating chroot failed")
self.installToolChainRPMS(chrootID)
pkgUtils.buildRPMSForGivenPackage(package, chrootID,
destLogPath)
chrUtils.destroyChroot(chrootID)
chrootID = None
self.logger.info("Successfully built toolchain")
except Exception as e:
self.logger.error("Unable to build tool chain.")
raise e
finally:
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
def buildCoreToolChainPackages(self):
self.logger.info("Building core tool chain packages.....")
chrootID=None
try:
pkgUtils=PackageUtils(self.logName,self.logPath)
for package in constants.listCoreToolChainRPMPackages:
rpmPkg=pkgUtils.findRPMFileForGivenPackage(package)
if rpmPkg is not None:
continue
chrUtils = ChrootUtils(self.logName,self.logPath)
chrootName="build-core-toolchain"
destLogPath=constants.logPath+"/build-"+package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p "+destLogPath)
returnVal,chrootID = chrUtils.createChroot(chrootName)
if not returnVal:
self.logger.error("Creating chroot failed")
raise Exception("creating chroot failed")
self.installToolChainRPMS(chrootID)
pkgUtils.adjustGCCSpecs(package, chrootID, destLogPath)
pkgUtils.buildRPMSForGivenPackage(package, chrootID,destLogPath)
chrUtils.destroyChroot(chrootID)
chrootID=None
self.logger.info("Successfully built toolchain")
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
except Exception as e:
self.logger.error("Unable to build tool chain.")
# print stacktrace
traceback.print_exc()
raise e
def _buildPackage(self):
try:
self.sandbox.create(self.package + "-" + self.version)
tUtils = ToolChainUtils(self.logName, self.logPath)
if self.sandbox.hasToolchain():
tUtils.installExtraToolchainRPMS(self.sandbox, self.package,
self.version)
else:
tUtils.installToolchainRPMS(self.sandbox,
self.package,
self.version,
availablePackages=self.doneList)
self._installDependencies(constants.buildArch)
if constants.crossCompiling:
self._installDependencies(constants.targetArch)
pkgUtils = PackageUtils(self.logName, self.logPath)
pkgUtils.adjustGCCSpecs(self.sandbox, self.package, self.version)
pkgUtils.buildRPMSForGivenPackage(self.sandbox, self.package,
self.version, self.logPath)
self.logger.debug("Successfully built the package: " +
self.package)
except Exception as e:
self.logger.error("Failed while building package: " + self.package)
self.logger.debug("Sandbox: " + self.sandbox.getID() +
" not deleted for debugging.")
logFileName = os.path.join(self.logPath, self.package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.logger.info(fileLog)
raise e
if self.sandbox:
self.sandbox.destroy()
def _buildPackage(self):
chroot = None
try:
chroot = Chroot(self.logger)
chroot.create(self.package + "-" + self.version)
tUtils = ToolChainUtils(self.logName, self.logPath)
tUtils.installToolChainRPMS(chroot, self.package, self.version,
self.logPath)
listDependentPackages, listTestPackages, listInstalledPackages, listInstalledRPMs = (
self._findDependentPackagesAndInstalledRPM(chroot))
pkgUtils = PackageUtils(self.logName, self.logPath)
if listDependentPackages:
self.logger.debug(
"Installing the build time dependent packages......")
for pkg in listDependentPackages:
packageName, packageVersion = StringUtils.splitPackageNameAndVersion(
pkg)
self._installPackage(pkgUtils, packageName, packageVersion,
chroot, self.logPath,
listInstalledPackages,
listInstalledRPMs)
for pkg in listTestPackages:
flag = False
packageName, packageVersion = StringUtils.splitPackageNameAndVersion(
pkg)
for depPkg in listDependentPackages:
depPackageName, depPackageVersion = StringUtils.splitPackageNameAndVersion(
depPkg)
if depPackageName == packageName:
flag = True
break
if flag == False:
self._installPackage(pkgUtils, packageName,
packageVersion, chroot,
self.logPath,
listInstalledPackages,
listInstalledRPMs)
pkgUtils.installRPMSInOneShot(chroot)
self.logger.debug(
"Finished installing the build time dependent packages...."
)
pkgUtils.adjustGCCSpecs(chroot, self.package, self.version)
pkgUtils.buildRPMSForGivenPackage(chroot, self.package,
self.version, self.logPath)
self.logger.debug("Successfully built the package:" + self.package)
except Exception as e:
self.logger.error("Failed while building package:" + self.package)
self.logger.debug("Chroot: " + chroot.getPath() +
" not deleted for debugging.")
logFileName = os.path.join(self.logPath, self.package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.logger.info(fileLog)
raise e
if chroot:
chroot.destroy()
def buildPackage(self,package):
#should initialize a logger based on package name
chrUtils = ChrootUtils(self.logName,self.logPath)
chrootName="build-"+package
chrootID=None
isToolChainPackage=False
if package in constants.listToolChainPackages:
isToolChainPackage=True
try:
chrootID = self.prepareBuildRoot(chrootName,isToolChainPackage)
destLogPath=constants.logPath+"/build-"+package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p "+destLogPath)
listInstalledPackages=self.findInstalledPackages(chrootID)
self.logger.info("List of installed packages")
self.logger.info(listInstalledPackages)
listDependentPackages=self.findBuildTimeRequiredPackages(package)
if len(listDependentPackages) != 0:
self.logger.info("Installing the build time dependent packages......")
for pkg in listDependentPackages:
self.installPackage(pkg,chrootID,destLogPath,listInstalledPackages)
self.logger.info("Finished installing the build time dependent packages......")
self.adjustGCCSpecs(package, chrootID, destLogPath)
pkgUtils = PackageUtils(self.logName,self.logPath)
pkgUtils.buildRPMSForGivenPackage(package,chrootID,destLogPath)
self.logger.info("Successfully built the package:"+package)
except Exception as e:
self.logger.error("Failed while building package:" + package)
self.logger.debug("Chroot with ID: " + chrootID + " not deleted for debugging.")
raise e
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
def buildPackage(self, package):
#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.checkIfPackageIsAlreadyBuilt(package):
if not constants.rpmCheck:
self.logger.info("Skipping building the package:" + package)
return
elif constants.rpmCheck and package not in constants.testForceRPMS:
self.logger.info("Skipping testing the package:" + package)
return
#should initialize a logger based on package name
chrUtils = ChrootUtils(self.logName, self.logPath)
chrootName = "build-" + package
chrootID = None
try:
chrootID = self.prepareBuildRoot(chrootName, package)
destLogPath = constants.logPath + "/build-" + package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p " + destLogPath)
listInstalledPackages = self.findInstalledPackages(chrootID)
listDependentPackages = self.findBuildTimeRequiredPackages(package)
if constants.rpmCheck and package in constants.testForceRPMS:
testPackages = set(
constants.listMakeCheckRPMPkgtoInstall) - set(
listInstalledPackages) - set([package])
listDependentPackages.extend(testPackages)
pkgUtils = PackageUtils(self.logName, self.logPath)
if len(listDependentPackages) != 0:
self.logger.info(
"Installing the build time dependent packages......")
for pkg in listDependentPackages:
self.installPackage(pkgUtils, pkg, chrootID, destLogPath,
listInstalledPackages)
pkgUtils.installRPMSInAOneShot(chrootID, destLogPath)
self.logger.info(
"Finished installing the build time dependent packages......"
)
pkgUtils.adjustGCCSpecs(package, chrootID, destLogPath)
pkgUtils.buildRPMSForGivenPackage(package, chrootID,
self.listBuildOptionPackages,
self.pkgBuildOptionFile,
destLogPath)
self.logger.info("Successfully built the package:" + package)
except Exception as e:
self.logger.error("Failed while building package:" + package)
self.logger.debug("Chroot with ID: " + chrootID +
" not deleted for debugging.")
logFileName = os.path.join(destLogPath, package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.logger.debug(fileLog)
raise e
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
def buildCoreToolChainPackages(self):
self.logger.info("Step 1 : Building the core toolchain packages.....")
self.logger.info(constants.listCoreToolChainPackages)
self.logger.info("")
chrootID = None
pkgCount = 0
try:
pkgUtils = PackageUtils(self.logName, self.logPath)
coreToolChainYetToBuild = []
for package in constants.listCoreToolChainPackages:
version = SPECS.getData().getHighestVersion(package)
rpmPkg = pkgUtils.findRPMFileForGivenPackage(package, version)
if rpmPkg is not None:
continue
else:
coreToolChainYetToBuild.append(package)
if coreToolChainYetToBuild:
self.logger.info(
"The following core toolchain packages need to be built :")
self.logger.info(coreToolChainYetToBuild)
else:
self.logger.info(
"Core toolchain packages are already available")
for package in coreToolChainYetToBuild:
version = SPECS.getData().getHighestVersion(package)
self.logger.debug("Building core toolchain package : " +
package)
chrUtils = ChrootUtils(self.logName, self.logPath)
chrootName = "build-" + package
destLogPath = constants.logPath + "/build-" + package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p " + destLogPath)
returnVal, chrootID = chrUtils.createChroot(chrootName)
if not returnVal:
self.logger.error("Creating chroot failed")
raise Exception("creating chroot failed")
self.installToolChainRPMS(package, version, chrootID,
destLogPath)
pkgUtils.adjustGCCSpecs(package, version, chrootID,
destLogPath)
pkgUtils.buildRPMSForGivenPackage(package, version, chrootID,
destLogPath)
pkgCount += 1
chrUtils.destroyChroot(chrootID)
chrootID = None
self.logger.debug("Successfully built toolchain")
self.logger.info("-" * 45 + "\n")
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
except Exception as e:
self.logger.error("Unable to build tool chain.")
# print stacktrace
traceback.print_exc()
raise e
return pkgCount
def buildPackage(self,package):
#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.checkIfPackageIsAlreadyBuilt(package):
if not constants.rpmCheck:
self.logger.info("Skipping building the package:"+package)
return
elif constants.rpmCheck and package not in constants.testForceRPMS:
self.logger.info("Skipping testing the package:"+package)
return
#should initialize a logger based on package name
chrUtils = ChrootUtils(self.logName,self.logPath)
chrootName="build-"+package
chrootID=None
isToolChainPackage=False
if package in constants.listToolChainPackages:
isToolChainPackage=True
try:
chrootID = self.prepareBuildRoot(chrootName,isToolChainPackage)
destLogPath=constants.logPath+"/build-"+package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p "+destLogPath)
listInstalledPackages=self.findInstalledPackages(chrootID)
listDependentPackages=self.findBuildTimeRequiredPackages(package)
if constants.rpmCheck and package in constants.testForceRPMS:
testPackages=set(constants.listMakeCheckRPMPkgtoInstall)-set(listInstalledPackages)-set([package])
listDependentPackages.extend(testPackages)
pkgUtils = PackageUtils(self.logName,self.logPath)
if len(listDependentPackages) != 0:
self.logger.info("Installing the build time dependent packages......")
for pkg in listDependentPackages:
self.installPackage(pkgUtils, pkg,chrootID,destLogPath,listInstalledPackages)
pkgUtils.installRPMSInAOneShot(chrootID,destLogPath)
self.logger.info("Finished installing the build time dependent packages......")
pkgUtils.adjustGCCSpecs(package, chrootID, destLogPath)
pkgUtils.buildRPMSForGivenPackage(package,chrootID,self.listBuildOptionPackages,self.pkgBuildOptionFile,destLogPath)
self.logger.info("Successfully built the package:"+package)
except Exception as e:
self.logger.error("Failed while building package:" + package)
self.logger.debug("Chroot with ID: " + chrootID + " not deleted for debugging.")
logFileName = os.path.join(destLogPath, package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.logger.debug(fileLog)
raise e
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
def buildCoreToolChainPackages(self):
self.logger.info("Step 1 : Building the core toolchain packages for " + constants.currentArch)
self.logger.info(constants.listCoreToolChainPackages)
self.logger.info("")
chroot = None
pkgCount = 0
try:
pkgUtils = PackageUtils(self.logName, self.logPath)
coreToolChainYetToBuild = []
doneList = []
#self.logger.debug(">>>> Looking for available packages...")
for package in constants.listCoreToolChainPackages:
version = SPECS.getData().getHighestVersion(package)
rpmPkg = pkgUtils.findRPMFile(package, version)
#rpmPkg = pkgUtils.findRPMFile(package, version, constants.buildArch)
if rpmPkg is not None:
doneList.append(package+'-'+version)
#self.logger.debug(">>>>>> %s", package+'-'+version)
continue
else:
coreToolChainYetToBuild.append(package)
if coreToolChainYetToBuild:
self.logger.info("The following core toolchain packages need to be built :")
self.logger.info(coreToolChainYetToBuild)
else:
self.logger.info("Core toolchain packages are already available")
for package in coreToolChainYetToBuild:
self.logger.debug("Building core toolchain package : " + package)
version = SPECS.getData().getHighestVersion(package)
destLogPath = constants.logPath + "/" + package + "-" + version + "." + constants.currentArch
if not os.path.isdir(destLogPath):
CommandUtils.runCommandInShell("mkdir -p " + destLogPath)
chroot = Chroot(self.logger)
chroot.create(package + "-" + version)
#self.logger.debug(">>>>> Done List:")
#self.logger.info(doneList)
self.installToolchainRPMS(chroot, package, version, availablePackages=doneList)
pkgUtils.adjustGCCSpecs(chroot, package, version)
pkgUtils.buildRPMSForGivenPackage(chroot, package, version, destLogPath)
pkgCount += 1
chroot.destroy()
doneList.append(package+'-'+version)
self.logger.debug("Successfully built toolchain")
self.logger.info("-" * 45 + "\n")
except Exception as e:
self.logger.error("Unable to build toolchain.")
# print stacktrace
traceback.print_exc()
raise e
return pkgCount
def _buildPackage(self, index=0):
#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._checkIfPackageIsAlreadyBuilt(index):
if not constants.rpmCheck:
self.logger.info("Skipping building the package:" +
self.package)
return
elif constants.rpmCheck and self.package not in constants.testForceRPMS:
self.logger.info("Skipping testing the package:" +
self.package)
return
chrUtils = ChrootUtils(self.logName, self.logPath)
chrootID = None
try:
chrootID = self._prepareBuildRoot()
listDependentPackages, listInstalledPackages, listInstalledRPMs = (
self._findDependentPackagesAndInstalledRPM(chrootID, index))
pkgUtils = PackageUtils(self.logName, self.logPath)
if listDependentPackages:
self.logger.info(
"Installing the build time dependent packages......")
for pkg in listDependentPackages:
self._installPackage(pkgUtils, pkg, chrootID, self.logPath,
listInstalledPackages,
listInstalledRPMs)
pkgUtils.installRPMSInAOneShot(chrootID, self.logPath)
self.logger.info(
"Finished installing the build time dependent packages...."
)
pkgUtils.adjustGCCSpecs(self.package, chrootID, self.logPath,
index)
pkgUtils.buildRPMSForGivenPackage(self.package, chrootID,
self.logPath, index)
self.logger.info("Successfully built the package:" + self.package)
except Exception as e:
self.logger.error("Failed while building package:" + self.package)
self.logger.debug("Chroot with ID: " + chrootID +
" not deleted for debugging.")
logFileName = os.path.join(self.logPath, self.package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.logger.debug(fileLog)
raise e
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
def _buildPackage(self):
try:
self.sandbox.create(self.package + "-" + self.version)
tUtils = ToolChainUtils(self.logName, self.logPath)
if self.sandbox.hasToolchain():
tUtils.installExtraToolchainRPMS(self.sandbox, self.package, self.version)
else:
tUtils.installToolchainRPMS(self.sandbox, self.package, self.version, availablePackages=self.doneList)
listDependentPackages, listTestPackages, listInstalledPackages, listInstalledRPMs = (
self._findDependentPackagesAndInstalledRPM(self.sandbox))
pkgUtils = PackageUtils(self.logName, self.logPath)
if listDependentPackages:
self.logger.debug("Installing the build time dependent packages......")
for pkg in listDependentPackages:
packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)
self._installPackage(pkgUtils, packageName, packageVersion, self.sandbox, self.logPath,listInstalledPackages, listInstalledRPMs)
for pkg in listTestPackages:
flag = False
packageName, packageVersion = StringUtils.splitPackageNameAndVersion(pkg)
for depPkg in listDependentPackages:
depPackageName, depPackageVersion = StringUtils.splitPackageNameAndVersion(depPkg)
if depPackageName == packageName:
flag = True
break;
if flag == False:
self._installPackage(pkgUtils, packageName,packageVersion, self.sandbox, self.logPath,listInstalledPackages, listInstalledRPMs)
pkgUtils.installRPMSInOneShot(self.sandbox)
self.logger.debug("Finished installing the build time dependent packages....")
pkgUtils.adjustGCCSpecs(self.sandbox, self.package, self.version)
pkgUtils.buildRPMSForGivenPackage(self.sandbox, self.package, self.version,
self.logPath)
self.logger.debug("Successfully built the package: " + self.package)
except Exception as e:
self.logger.error("Failed while building package: " + self.package)
self.logger.debug("Sandbox: " + self.sandbox.getID() +
" not deleted for debugging.")
logFileName = os.path.join(self.logPath, self.package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.logger.info(fileLog)
raise e
if self.sandbox:
self.sandbox.destroy()
def buildPackage(self, package):
#should initialize a logger based on package name
chrUtils = ChrootUtils(self.logName, self.logPath)
chrootName = "build-" + package
chrootID = None
isToolChainPackage = False
if package in constants.listToolChainPackages:
isToolChainPackage = True
try:
chrootID = self.prepareBuildRoot(chrootName, isToolChainPackage)
destLogPath = constants.logPath + "/build-" + package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p " + destLogPath)
listInstalledPackages = self.findInstalledPackages(chrootID)
self.logger.info("List of installed packages")
self.logger.info(listInstalledPackages)
listDependentPackages = self.findBuildTimeRequiredPackages(package)
pkgUtils = PackageUtils(self.logName, self.logPath)
if len(listDependentPackages) != 0:
self.logger.info(
"Installing the build time dependent packages......")
for pkg in listDependentPackages:
self.installPackage(pkgUtils, pkg, chrootID, destLogPath,
listInstalledPackages)
pkgUtils.installRPMSInAOneShot(chrootID, destLogPath)
self.logger.info(
"Finished installing the build time dependent packages......"
)
pkgUtils.adjustGCCSpecs(package, chrootID, destLogPath)
pkgUtils.buildRPMSForGivenPackage(package, chrootID, destLogPath)
self.logger.info("Successfully built the package:" + package)
except Exception as e:
self.logger.error("Failed while building package:" + package)
self.logger.debug("Chroot with ID: " + chrootID +
" not deleted for debugging.")
logFileName = os.path.join(destLogPath, package + ".log")
fileLog = os.popen('tail -n 20 ' + logFileName).read()
self.logger.debug(fileLog)
raise e
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
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._checkIfPackageIsAlreadyBuilt():
if not constants.rpmCheck:
self.logger.info("Skipping building the package:" + self.package)
return
elif constants.rpmCheck and self.package not in constants.testForceRPMS:
self.logger.info("Skipping testing the package:" + self.package)
return
chrUtils = ChrootUtils(self.logName, self.logPath)
chrootID = None
try:
chrootID = self._prepareBuildRoot()
listDependentPackages, listInstalledPackages, listInstalledRPMs = (
self._findDependentPackagesAndInstalledRPM(chrootID))
pkgUtils = PackageUtils(self.logName, self.logPath)
if listDependentPackages:
self.logger.info("Installing the build time dependent packages......")
for pkg in listDependentPackages:
self._installPackage(pkgUtils, pkg, chrootID, self.logPath,
listInstalledPackages, listInstalledRPMs)
pkgUtils.installRPMSInAOneShot(chrootID, self.logPath)
self.logger.info("Finished installing the build time dependent packages....")
pkgUtils.adjustGCCSpecs(self.package, chrootID, self.logPath)
pkgUtils.buildRPMSForGivenPackage(self.package, chrootID,
self.logPath)
self.logger.info("Successfully built the package:" + self.package)
except Exception as e:
self.logger.error("Failed while building package:" + self.package)
self.logger.debug("Chroot with ID: " + chrootID +
" not deleted for debugging.")
logFileName = os.path.join(self.logPath, self.package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.logger.debug(fileLog)
raise e
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
def buildCoreToolChainPackages(self, listBuildOptionPackages,
pkgBuildOptionFile):
self.logger.info("Building core toolchain packages.....")
chrootID = None
pkgCount = 0
try:
pkgUtils = PackageUtils(self.logName, self.logPath)
for package in constants.listCoreToolChainPackages:
rpmPkg = pkgUtils.findRPMFileForGivenPackage(package)
if rpmPkg is not None:
continue
self.logger.info("Building core toolchain package: " + package)
chrUtils = ChrootUtils(self.logName, self.logPath)
chrootName = "build-" + package
destLogPath = constants.logPath + "/build-" + package
if not os.path.isdir(destLogPath):
cmdUtils = CommandUtils()
cmdUtils.runCommandInShell("mkdir -p " + destLogPath)
returnVal, chrootID = chrUtils.createChroot(chrootName)
if not returnVal:
self.logger.error("Creating chroot failed")
raise Exception("creating chroot failed")
self.installToolChainRPMS(chrootID, package, destLogPath)
pkgUtils.adjustGCCSpecs(package, chrootID, destLogPath)
pkgUtils.buildRPMSForGivenPackage(package, chrootID,
listBuildOptionPackages,
pkgBuildOptionFile,
destLogPath)
pkgCount += 1
chrUtils.destroyChroot(chrootID)
chrootID = None
self.logger.info("Successfully built toolchain")
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
except Exception as e:
self.logger.error("Unable to build tool chain.")
# print stacktrace
traceback.print_exc()
raise e
return pkgCount
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 not constants.rpmCheck:
self.base.logger.info("Skipping building the package:" +
self.base.package)
return
elif constants.rpmCheck and self.base.package not in constants.testForceRPMS:
self.base.logger.info("Skipping testing the package:" +
self.base.package)
return
chrUtils = ChrootUtils(self.base.logName, self.base.logPath)
chrootID = None
try:
chrootID = self.prepareBuildRoot()
listInstalledPackages, listInstalledRPMs = self.base.findInstalledPackages(
chrootID)
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(
"Installing the build time dependent packages......")
for pkg in listDependentPackages:
self.base.installPackage(pkgUtils, pkg, chrootID,
self.base.logPath,
listInstalledPackages,
listInstalledRPMs)
pkgUtils.installRPMSInAOneShot(chrootID, self.base.logPath)
self.base.logger.info(
"Finished installing the build time dependent packages......"
)
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:
self.base.logger.error("Failed while building package:" +
self.base.package)
self.base.logger.debug("Chroot with ID: " + chrootID +
" not deleted for debugging.")
logFileName = os.path.join(self.base.logPath,
self.base.package + ".log")
fileLog = os.popen('tail -n 100 ' + logFileName).read()
self.base.logger.debug(fileLog)
raise e
if chrootID is not None:
chrUtils.destroyChroot(chrootID)
def _buildPackage(self):
#should initialize a logger based on package name
containerTaskName = "build-" + self.package + "-" + self.version
container = None
try:
container = Container(self.logger)
container.create(containerTaskName)
tcUtils = ToolChainUtils(self.logName, self.logPath)
tcUtils.installCustomToolChainRPMS(container, self.package,
self.version)
listDependentPackages, listTestPackages, listInstalledPackages, listInstalledRPMs = (
self._findDependentPackagesAndInstalledRPM(container))
pkgUtils = PackageUtils(self.logName, self.logPath)
if listDependentPackages:
self.logger.debug(
"Installing the build time dependent packages......")
for pkg in listDependentPackages:
packageName, packageVersion = StringUtils.splitPackageNameAndVersion(
pkg)
self._installPackage(pkgUtils, packageName, packageVersion,
container, self.logPath,
listInstalledPackages,
listInstalledRPMs)
for pkg in listTestPackages:
flag = False
packageName, packageVersion = StringUtils.splitPackageNameAndVersion(
pkg)
for depPkg in listDependentPackages:
depPackageName, depPackageVersion = StringUtils.splitPackageNameAndVersion(
depPkg)
if depPackageName == packageName:
flag = True
break
if flag == False:
self._installPackage(pkgUtils, packageName,
packageVersion, container,
self.logPath,
listInstalledPackages,
listInstalledRPMs)
pkgUtils.installRPMSInOneShot(container)
self.logger.debug(
"Finished installing the build time dependent packages...."
)
self.logger.debug(
"BuildContainer-buildPackage: Start building the package: " +
self.package)
pkgUtils.adjustGCCSpecs(container, self.package, self.version)
pkgUtils.buildRPMSForGivenPackage(container, self.package,
self.version, self.logPath)
self.logger.debug(
"BuildContainer-buildPackage: Successfully built the package: "
+ self.package)
except Exception as e:
self.logger.error("Failed while building package:" + self.package)
if container is not None:
self.logger.debug("Container " + container.getID() +
" retained for debugging.")
logFileName = os.path.join(self.logPath, self.package + ".log")
fileLog = os.popen('tail -n 20 ' + logFileName).read()
self.logger.debug(fileLog)
raise e
# Remove the container
if container:
container.destroy()