def buildAPackage(package, listBuildOptionPackages, pkgBuildOptionFile, buildThreads):
listPackages=[]
listPackages.append(package)
pkgManager = PackageManager()
if constants.rpmCheck:
constants.setTestForceRPMS(listPackages[:])
pkgManager.buildPackages(listPackages, listBuildOptionPackages, pkgBuildOptionFile, buildThreads)
def buildAPackage(package, listBuildOptionPackages, pkgBuildOptionFile,
buildThreads):
listPackages = []
listPackages.append(package)
pkgManager = PackageManager()
pkgManager.buildPackages(listPackages, listBuildOptionPackages,
pkgBuildOptionFile, buildThreads)
def buildAPackage(package, listBuildOptionPackages, pkgBuildOptionFile, buildThreads):
listPackages=[]
listPackages.append(package)
pkgManager = PackageManager()
if constants.rpmCheck:
constants.setTestForceRPMS(listPackages[:])
pkgManager.buildPackages(listPackages, listBuildOptionPackages, pkgBuildOptionFile, buildThreads)
def __main__(**kwargs):
from PackageManager import PackageManager
package_install = PackageManager(verbose=True)
# p = package_install.search('vlc')
# print(p)
# package_install.update_repository()
package_install.install(['vlc', 'amarok'])
def buildPackagesFromGivenJSONFile(inputJSONFile,buildOption,logger, buildThreads):
listPackages = get_all_package_names(inputJSONFile)
listPackagesToBuild=[]
for pkg in listPackages:
p = pkg.encode('utf-8')
listPackagesToBuild.append(str(p))
logger.info("List of packages to build:")
logger.info(listPackagesToBuild)
pkgManager = PackageManager()
pkgManager.buildPackages(listPackagesToBuild, buildThreads)
def buildPackagesFromGivenJSONFile(inputJSONFile, buildOption, listBuildOptionPackages, pkgBuildOptionFile, logger, buildThreads):
listPackages = get_all_package_names(inputJSONFile)
listPackagesToBuild=[]
for pkg in listPackages:
p = pkg.encode('utf-8')
listPackagesToBuild.append(str(p))
logger.info("List of packages to build:")
logger.info(listPackagesToBuild)
pkgManager = PackageManager()
pkgManager.buildPackages(listPackagesToBuild, listBuildOptionPackages, pkgBuildOptionFile, buildThreads)
def buildPackagesForAllSpecs(logger, buildThreads, pkgInfoJsonFile, pkgBuildType):
listPackages = SPECS.getData().getListPackages()
if constants.rpmCheck:
constants.setTestForceRPMS(copy.copy(listPackages))
pkgManager = PackageManager(pkgBuildType=pkgBuildType)
pkgManager.buildPackages(listPackages, buildThreads, pkgBuildType)
# Generating package info file which is required by installer
logger.debug("Writing Package info to the file:" + pkgInfoJsonFile)
pkgInfo = PackageInfo()
pkgInfo.loadPackagesData()
pkgInfo.writePkgListToFile(pkgInfoJsonFile)
def buildSpecifiedPackages(listPackages, buildThreads, pkgBuildType, pkgInfoJsonFile=None, logger=None):
if constants.rpmCheck:
constants.setTestForceRPMS(copy.copy(listPackages))
pkgManager = PackageManager(pkgBuildType=pkgBuildType)
pkgManager.buildPackages(listPackages, buildThreads)
if pkgInfoJsonFile is not None:
# Generating package info file which is required by installer
if logger is not None:
logger.debug("Writing Package info to the file:" + pkgInfoJsonFile)
pkgInfo = PackageInfo()
pkgInfo.loadPackagesData()
pkgInfo.writePkgListToFile(pkgInfoJsonFile)
def buildPackagesFromGivenJSONFile(inputJSONFile, buildOption, listBuildOptionPackages, pkgBuildOptionFile, logger, buildThreads):
listPackages = get_all_package_names(inputJSONFile)
listPackagesToBuild=[]
for pkg in listPackages:
p = pkg.encode('utf-8')
listPackagesToBuild.append(str(p))
logger.info("List of packages to build:")
logger.info(listPackagesToBuild)
if constants.rpmCheck:
constants.setTestForceRPMS(listPackagesToBuild[:])
pkgManager = PackageManager()
pkgManager.buildPackages(listPackagesToBuild, listBuildOptionPackages, pkgBuildOptionFile, buildThreads)
def buildSpecifiedPackages(listPackages, buildThreads, pkgBuildType, pkgInfoJsonFile=None, logger=None):
if constants.rpmCheck:
constants.setTestForceRPMS(copy.copy(listPackages))
pkgManager = PackageManager(pkgBuildType=pkgBuildType)
pkgManager.buildPackages(listPackages, buildThreads)
if pkgInfoJsonFile is not None:
# Generating package info file which is required by installer
if logger is not None:
logger.debug("Writing Package info to the file:" + pkgInfoJsonFile)
pkgInfo = PackageInfo()
pkgInfo.loadPackagesData()
pkgInfo.writePkgListToFile(pkgInfoJsonFile)
def buildPackagesFromGivenJSONFile(inputJSONFile,buildOption,logger):
jsonData=open(inputJSONFile)
jsonObj = json.load(jsonData)
jsonData.close()
listPackages=jsonObj[buildOption]
listPackagesToBuild=[]
for pkg in listPackages:
p = pkg.encode('utf-8')
listPackagesToBuild.append(str(p))
logger.info("List of packages to build:")
logger.info(listPackagesToBuild)
pkgManager = PackageManager()
pkgManager.buildPackages(listPackagesToBuild)
def buildPackagesForAllSpecs(listBuildOptionPackages, pkgBuildOptionFile, logger, buildThreads, pkgInfoJsonFile):
listPackages = constants.specData.getListPackages()
logger.info("List of packages to build:")
logger.info(listPackages)
if constants.rpmCheck:
constants.setTestForceRPMS(listPackages[:])
pkgManager = PackageManager()
pkgManager.buildPackages(listPackages, listBuildOptionPackages, pkgBuildOptionFile, buildThreads)
#Generating package info file which is required by installer
logger.info("Writing Package info to the file:"+pkgInfoJsonFile)
pkgInfo = PackageInfo()
pkgInfo.loadPackagesData()
pkgInfo.writePkgListToFile(pkgInfoJsonFile)
def buildPackagesInJson(logger, buildThreads, pkgInfoJsonFile, pkgJsonInput, pkgBuildType):
listPackages = []
with open(pkgJsonInput) as jsonData:
pkg_list_json = json.load(jsonData)
listPackages = pkg_list_json["packages"]
if constants.rpmCheck:
constants.setTestForceRPMS(copy.copy(listPackages))
pkgManager = PackageManager(pkgBuildType=pkgBuildType)
pkgManager.buildPackages(listPackages, buildThreads, pkgBuildType)
# Generating package info file which is required by installer
logger.debug("Writing Package info to the file:" + pkgInfoJsonFile)
pkgInfo = PackageInfo()
pkgInfo.loadPackagesData()
pkgInfo.writePkgListToFile(pkgInfoJsonFile)
def buildPackagesForAllSpecs(listBuildOptionPackages, pkgBuildOptionFile, logger, buildThreads, pkgInfoJsonFile):
listPackages = constants.specData.getListPackages()
logger.info("List of packages to build:")
logger.info(listPackages)
if constants.rpmCheck:
constants.setTestForceRPMS(listPackages[:])
pkgManager = PackageManager()
pkgManager.buildPackages(listPackages, listBuildOptionPackages, pkgBuildOptionFile, buildThreads)
#Generating package info file which is required by installer
logger.info("Writing Package info to the file:"+pkgInfoJsonFile)
pkgInfo = PackageInfo()
pkgInfo.loadPackagesData()
pkgInfo.writePkgListToFile(pkgInfoJsonFile)
def __init__(self, gui):
"""
Initialize the ObsProjectsManager.
`gui` must be a reference to the main `Gui` instance.
"""
ObsLightGuiObject.__init__(self, gui)
ProjectsManagerBase.__init__(self,
self.mainWindow.obsProjectsListWidget,
self.manager.getLocalProjectList)
self.__projectConfigManager = None
self.__repoConfigManager = None
self.loadProjectList()
self.projectListWidget.currentTextChanged.connect(
self.on_projectSelected)
self.__packageManager = PackageManager(self.gui)
self.__connectButtons()
def buildToolChain(buildThreads):
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(buildThreads)
def buildAPackage(package, buildThreads, pkgBuildType):
listPackages = [package]
pkgManager = PackageManager(pkgBuildType=pkgBuildType)
if constants.rpmCheck:
constants.setTestForceRPMS(copy.copy(listPackages))
pkgManager.buildPackages(listPackages, buildThreads, pkgBuildType)
def main():
usage = "Usage: %prog [options] <package name>"
parser = ArgumentParser(usage)
parser.add_argument("-s", "--spec-path", dest="specPath", default="../../SPECS")
parser.add_argument("-x", "--source-path", dest="sourcePath", default="../../stage/SOURCES")
parser.add_argument("-r", "--rpm-path", dest="rpmPath", default="../../stage/RPMS")
parser.add_argument("-i", "--install-package", dest="installPackage", default=False, action ="store_true")
parser.add_argument("-p", "--publish-RPMS-path", dest="publishRPMSPath", default="../../stage/PUBLISHRPMS")
parser.add_argument("-e", "--publish-XRPMS-path", dest="publishXRPMSPath", default="../../stage/PUBLISHXRPMS")
parser.add_argument("-l", "--log-path", dest="logPath", default="../../stage/LOGS")
parser.add_argument("-z", "--top-dir-path", dest="topDirPath", default="/usr/src/photon")
parser.add_argument("-b", "--build-root-path", dest="buildRootPath", default="/mnt")
parser.add_argument("-t", "--threads", dest="buildThreads", default=1, type=int, help="Number of working threads")
parser.add_argument("-m", "--tool-chain-stage", dest="toolChainStage", default="None")
parser.add_argument("-c", "--pullsources-config", dest="pullsourcesConfig", default="pullsources.conf")
parser.add_argument("-d", "--dist", dest="dist", default="")
parser.add_argument("-k", "--input-RPMS-path", dest="inputRPMSPath", default=None)
parser.add_argument("-n", "--build-number", dest="buildNumber", default="0000000")
parser.add_argument("-v", "--release-version", dest="releaseVersion", default="NNNnNNN")
parser.add_argument("-u", "--enable-rpmcheck", dest="rpmCheck", default=False, action ="store_true")
parser.add_argument("-a", "--source-rpm-path", dest="sourceRpmPath", default="../../stage/SRPMS")
parser.add_argument("-w", "--pkginfo-file", dest="pkgInfoFile", default="../../stage/pkg_info.json")
parser.add_argument("-g", "--pkg-build-option-file", dest="pkgBuildOptionFile", default="../../common/data/pkg_build_options.json")
parser.add_argument("-q", "--rpmcheck-stop-on-error", dest="rpmCheckStopOnError", default=False, action ="store_true")
parser.add_argument("PackageName", nargs='?')
options = parser.parse_args()
cmdUtils=CommandUtils()
if not os.path.isdir(options.logPath):
cmdUtils.runCommandInShell("mkdir -p "+options.logPath)
logger=Logger.getLogger(options.logPath+"/Main")
errorFlag=False
package = None
pkgInfoJsonFile = options.pkgInfoFile
if not os.path.isdir(options.sourcePath):
logger.error("Given Sources Path is not a directory:"+options.sourcePath)
errorFlag = True
if not os.path.isdir(options.specPath):
logger.error("Given Specs Path is not a directory:"+options.specPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath):
logger.error("Given RPMS Path is not a directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath):
logger.error("Given X RPMS Path is not a directory:"+options.publishXRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath+"/x86_64"):
logger.error("Given RPMS Path is missing x86_64 sub-directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath+"/x86_64"):
logger.error("Given X RPMS Path is missing x86_64 sub-directory:"+options.publishXRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath+"/noarch"):
logger.error("Given RPMS Path is missing noarch sub-directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath+"/noarch"):
logger.error("Given X RPMS Path is missing noarch sub-directory:"+options.publishXRPMSPath)
errorFlag = True
if not os.path.isfile(options.pkgBuildOptionFile):
logger.warning("Given JSON File is not a file:"+options.pkgBuildOptionFile)
if options.inputRPMSPath is not None and not os.path.isdir(options.inputRPMSPath):
logger.error("Given input RPMS Path is not a directory:"+options.inputRPMSPath)
errorFlag = True
if options.installPackage :
if not options.PackageName:
logger.error("Please provide package name")
errorFlag = True
else:
package=options.PackageName
if errorFlag:
logger.error("Found some errors. Please fix input options and re-run it.")
return False
if not os.path.isdir(options.rpmPath):
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/x86_64")
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/noarch")
if not os.path.isdir(options.sourceRpmPath):
cmdUtils.runCommandInShell("mkdir -p "+options.sourceRpmPath)
if not os.path.isdir(options.buildRootPath):
cmdUtils.runCommandInShell("mkdir -p "+options.buildRootPath)
logger.info("Source Path :"+options.sourcePath)
logger.info("Spec Path :" + options.specPath)
logger.info("Rpm Path :" + options.rpmPath)
logger.info("Log Path :" + options.logPath)
logger.info("Top Dir Path :" + options.topDirPath)
logger.info("Publish RPMS Path :" + options.publishRPMSPath)
logger.info("Publish X RPMS Path :" + options.publishXRPMSPath)
if options.installPackage:
logger.info("Package to build:"+package)
listBuildOptionPackages = get_packages_with_build_options(options.pkgBuildOptionFile)
try:
constants.initialize(options)
if package == "packages_list":
buildPackagesList(options.buildRootPath+"/../packages_list.csv")
elif package == "sources_list":
if not os.path.isdir("../../stage/yaml_sources"):
cmdUtils.runCommandInShell("mkdir -p ../../stage/yaml_sources")
buildSourcesList('../../stage/yaml_sources',logger)
elif package == "srpms_list":
if not os.path.isdir("../../stage/yaml_srpms"):
cmdUtils.runCommandInShell("mkdir -p ../../stage/yaml_srpms")
buildSRPMList(options.sourceRpmPath,"../../stage/yaml_srpms",logger)
elif options.toolChainStage == "stage1":
pkgManager = PackageManager()
pkgManager.buildToolChain()
elif options.toolChainStage == "stage2":
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(options.buildThreads)
elif options.installPackage:
buildAPackage(package, listBuildOptionPackages, options.pkgBuildOptionFile, options.buildThreads)
else:
buildPackagesForAllSpecs(listBuildOptionPackages, options.pkgBuildOptionFile, logger, options.buildThreads, pkgInfoJsonFile)
except Exception as e:
logger.error("Caught an exception")
logger.error(str(e))
# print stacktrace
traceback.print_exc()
sys.exit(1)
sys.exit(0)
class ObsProjectsManager(ObsLightGuiObject, ProjectsManagerBase):
'''
Manages the local project list widget and project-related buttons
of the main window.
'''
def __init__(self, gui):
"""
Initialize the ObsProjectsManager.
`gui` must be a reference to the main `Gui` instance.
"""
ObsLightGuiObject.__init__(self, gui)
ProjectsManagerBase.__init__(self,
self.mainWindow.obsProjectsListWidget,
self.manager.getLocalProjectList)
self.__projectConfigManager = None
self.__repoConfigManager = None
self.loadProjectList()
self.projectListWidget.currentTextChanged.connect(
self.on_projectSelected)
self.__packageManager = PackageManager(self.gui)
self.__connectButtons()
def __connectButtons(self):
"""
Connect project-related, chroot-related and repository-related
buttons of the OBS project tab to the appropriate methods.
"""
mw = self.mainWindow
mw.newObsProjectButton.clicked.connect(self.gui.runWizard)
# mw.modifyObsProjectButton.clicked.connect(self.on_modifyObsProjectButton_clicked)
mw.deleteObsProjectButton.clicked.connect(
self.on_deleteObsProjectButton_clicked)
# mw.loadObsProjectButton.clicked.connect(self.on_importObsProjectButton_clicked)
# mw.saveObsProjectButton.clicked.connect(self.on_exportObsProjectButton_clicked)
mw.newChrootButton.clicked.connect(self.on_newChrootButton_clicked)
mw.openChrootButton.clicked.connect(self.on_openChrootButton_clicked)
mw.deleteChrootButton.clicked.connect(
self.on_deleteChrootButton_clicked)
# @popupOnException
# def on_modifyObsProjectButton_clicked(self):
# projectName = self.currentProject
# if projectName is None:
# return
# self.__projectConfigManager = ProjectConfigManager(self.gui, projectName)
# self.__projectConfigManager.finished.connect(self.on_projectConfigManager_finished)
@popupOnException
def on_deleteObsProjectButton_clicked(self):
projectName = self.currentProject
if projectName is None:
return
result = QMessageBox.question(
self.mainWindow,
"Are you sure ?",
"Are you sure you want to delete %s project ?" % projectName,
buttons=QMessageBox.Yes | QMessageBox.No,
defaultButton=QMessageBox.Yes)
if result == QMessageBox.No:
return
progress = self.gui.getInfiniteProgressDialog()
runnable = ProgressRunnable2(progress)
runnable.setDialogMessage(u"Deleting project...")
runnable.setRunMethod(self.manager.removeProject, projectName)
runnable.finished.connect(self.refresh)
runnable.caughtException.connect(self.gui.popupErrorCallback)
runnable.runOnGlobalInstance()
# @popupOnException
# def on_importObsProjectButton_clicked(self):
# filePath, _filter = QFileDialog.getOpenFileName(self.mainWindow,
# u"Select project to import")
# if len(filePath) < 1:
# return
# progress = self.gui.getInfiniteProgressDialog()
# runnable = ProgressRunnable2(progress)
# runnable.setDialogMessage(u"Importing project...")
# runnable.setRunMethod(self.manager.importProject, filePath)
# runnable.caughtException.connect(self.gui.popupErrorCallback)
# runnable.finished.connect(self.refresh)
# runnable.runOnGlobalInstance()
# @popupOnException
# def on_exportObsProjectButton_clicked(self):
# project = self.currentProject
# if project is None:
# return
# filePath, _filter = QFileDialog.getSaveFileName(self.mainWindow,
# u"Select file to export")
# if len(filePath) < 1:
# return
# progress = self.gui.getInfiniteProgressDialog()
# runnable = ProgressRunnable2(progress)
# runnable.setDialogMessage(u"Exporting project...")
# runnable.setRunMethod(self.manager.exportProject, project, filePath)
# runnable.caughtException.connect(self.gui.popupErrorCallback)
# runnable.finished.connect(self.refresh)
# runnable.runOnGlobalInstance()
@popupOnException
def on_projectConfigManager_finished(self, success):
if success:
self.loadProjectList()
self.on_projectSelected(None)
@popupOnException
def on_newChrootButton_clicked(self):
projectName = self.currentProject
if projectName is None or self.manager.isChRootInit(projectName):
return
runnable = ProgressRunnable2(self.gui.getInfiniteProgressDialog())
runnable.setDialogMessage(u"Creating project file system...")
runnable.setRunMethod(self.manager.createChRoot, projectName)
runnable.caughtException.connect(self.gui.popupErrorCallback)
runnable.finished.connect(self.refreshProject)
runnable.runOnGlobalInstance()
@popupOnException
def on_openChrootButton_clicked(self):
projectName = self.currentProject
if projectName is None or not self.manager.isChRootInit(projectName):
return
currentPackage = self.__packageManager.currentPackage()
runnable = ProgressRunnable2()
useRootId = self.mainWindow.checkUserRootForChroot.isChecked()
if useRootId:
self.mainWindow.checkUserRootForChroot.setCheckState(
Qt.CheckState(False))
if currentPackage is None:
runnable.setRunMethod(self.manager.goToChRoot,
projectName,
useRootId=useRootId,
detach=True)
else:
runnable.setRunMethod(self.manager.goToChRoot,
projectName,
currentPackage,
useRootId=useRootId,
detach=True)
runnable.caughtException.connect(self.gui.popupErrorCallback)
runnable.finished.connect(self.refreshProject)
runnable.runOnGlobalInstance()
@popupOnException
def on_deleteChrootButton_clicked(self):
projectName = self.currentProject
if projectName is not None:
result = QMessageBox.question(
self.mainWindow,
"Are you sure ?",
"Are you sure you want to delete %s's file system ?" %
projectName,
buttons=QMessageBox.Yes | QMessageBox.No,
defaultButton=QMessageBox.Yes)
if result == QMessageBox.No:
return
progress = self.gui.getInfiniteProgressDialog()
runnable = ProgressRunnable2(progress)
runnable.setDialogMessage(u"Deleting file system")
runnable.setRunMethod(self.manager.removeChRoot, projectName)
runnable.finished.connect(self.refreshProject)
runnable.caughtException.connect(self.gui.popupErrorCallback)
runnable.runOnGlobalInstance()
def on_projectSelected(self, _project):
self.refreshProject()
def refreshProject(self):
"""
Refresh the project, package and chroot views.
"""
project = self.currentProject
self.__packageManager.setCurrentProject(project)
self.updateProjectLabels()
self.updateChrootPathAndButtons()
@popupOnException
def updateProjectLabels(self):
'''
Update the different labels according to project parameters.
'''
project = self.currentProject
if project is not None:
projectLink = self.manager.getProjectWebPage(project)
projectObsName = self.manager.getProjectParameter(
project, "projectObsName")
target = self.manager.getProjectParameter(project, "projectTarget")
obsRepoLink = self.manager.getProjectRepository(project)
localRepoLink = self.manager.getLocalRepository(project)
projectTitle = self.manager.getProjectParameter(project, "title")
projectDescription = self.manager.getProjectParameter(
project, "description")
self.mainWindow.projectLabelValue.setText(project)
self.mainWindow.projectTitleLabel.setText(projectTitle)
self.mainWindow.projectDescriptionLabel.setText(projectDescription)
self.mainWindow.projectPageLinkLabel.setText(
u'<a href="%s">%s</a>' % (projectLink, projectObsName))
repoObsLink = u'<a href="%s">%s</a>' % (obsRepoLink, target)
repoLocalLink = u'<a href="%s">%s</a>' % (localRepoLink, project)
self.mainWindow.projectObsRepoPageLinkLabel.setText(repoObsLink)
self.mainWindow.projectLocalRepoPageLinkLabel.setText(
repoLocalLink)
# self.mainWindow.saveObsProjectButton.setEnabled(True)
# else:
# self.mainWindow.saveObsProjectButton.setEnabled(False)
@popupOnException
def updateChrootPathAndButtons(self):
'''
Update the chroot path displayed in the main window
with the one of the currently selected project.
Enable/disable some buttons according to the state
of the chroot.
'''
project = self.currentProject
if project is not None:
isChrootInit = self.manager.isChRootInit(project)
if isChrootInit:
chrootPath = self.manager.getChRootPath(project)
self.mainWindow.chrootPathLineEdit.setText(chrootPath)
self.mainWindow.newChrootButton.setEnabled(False)
self.mainWindow.openChrootButton.setEnabled(True)
else:
self.mainWindow.newChrootButton.setEnabled(True)
self.mainWindow.openChrootButton.setEnabled(False)
self.mainWindow.chrootPathLineEdit.setText("")
self.mainWindow.deleteChrootButton.setEnabled(isChrootInit)
def buildAPackage(package, listBuildOptionPackages, pkgBuildOptionFile, buildThreads):
listPackages=[]
listPackages.append(package)
pkgManager = PackageManager()
pkgManager.buildPackages(listPackages, listBuildOptionPackages, pkgBuildOptionFile, buildThreads)
def buildAPackage(package, buildThreads):
listPackages = []
listPackages.append(package)
pkgManager = PackageManager()
pkgManager.buildPackages(listPackages, buildThreads)
def buildToolChain(buildThreads):
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(buildThreads)
def main():
usage = "Usage: %prog [options] <package name>"
parser = OptionParser(usage)
parser.add_option("-s",
"--spec-path",
dest="specPath",
default="../../SPECS")
parser.add_option("-x",
"--source-path",
dest="sourcePath",
default="../../stage/SOURCES")
parser.add_option("-r",
"--rpm-path",
dest="rpmPath",
default="../../stage/RPMS")
parser.add_option("-i",
"--install-package",
dest="installPackage",
default=False,
action="store_true")
parser.add_option("-p",
"--publish-RPMS-path",
dest="publishRPMSPath",
default="../../stage/PUBLISHRPMS")
parser.add_option("-l",
"--log-path",
dest="logPath",
default="../../stage/LOGS")
parser.add_option("-o",
"--build-option",
dest="buildOption",
default="full")
parser.add_option("-z",
"--top-dir-path",
dest="topDirPath",
default="/usr/src/photon")
parser.add_option(
"-j",
"--json-file",
dest="inputJSONFile",
default="../../common/data/build_install_options_all.json")
parser.add_option("-b",
"--build-root-path",
dest="buildRootPath",
default="/mnt")
parser.add_option("-t",
"--threads",
dest="buildThreads",
default=1,
type="int",
help="Numbeer of working threads")
parser.add_option("-m",
"--tool-chain-stage",
dest="toolChainStage",
default="None")
parser.add_option("-c",
"--pullsources-config",
dest="pullsourcesConfig",
default="pullsources.conf")
parser.add_option("-d", "--dist", dest="dist", default="")
parser.add_option("-k",
"--input-RPMS-path",
dest="inputRPMSPath",
default=None)
parser.add_option("-n",
"--build-number",
dest="buildNumber",
default="0000000")
parser.add_option("-v",
"--release-version",
dest="releaseVersion",
default="NNNnNNN")
parser.add_option("-u",
"--enable-rpmcheck",
dest="rpmCheck",
default=False,
action="store_true")
parser.add_option("-a",
"--source-rpm-path",
dest="sourceRpmPath",
default="../../stage/SRPMS")
(options, args) = parser.parse_args()
cmdUtils = CommandUtils()
if not os.path.isdir(options.logPath):
cmdUtils.runCommandInShell("mkdir -p " + options.logPath)
logger = Logger.getLogger(options.logPath + "/Main")
errorFlag = False
package = None
if not os.path.isdir(options.sourcePath):
logger.error("Given Sources Path is not a directory:" +
options.sourcePath)
errorFlag = True
if not os.path.isdir(options.specPath):
logger.error("Given Specs Path is not a directory:" + options.specPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath):
logger.error("Given RPMS Path is not a directory:" +
options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath + "/x86_64"):
logger.error("Given RPMS Path is missing x86_64 sub-directory:" +
options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath + "/noarch"):
logger.error("Given RPMS Path is missing noarch sub-directory:" +
options.publishRPMSPath)
errorFlag = True
if not os.path.isfile(
options.inputJSONFile) and not options.installPackage:
logger.error("Given JSON File is not a file:" + options.inputJSONFile)
errorFlag = True
if options.inputRPMSPath is not None and not os.path.isdir(
options.inputRPMSPath):
logger.error("Given input RPMS Path is not a directory:" +
options.publishRPMSPath)
errorFlag = True
if options.installPackage:
if len(args) != 1:
logger.error("Please provide package name")
errorFlag = True
else:
package = args[0]
if errorFlag:
logger.error(
"Found some errors. Please fix input options and re-run it.")
return False
if not os.path.isdir(options.rpmPath):
cmdUtils.runCommandInShell("mkdir -p " + options.rpmPath + "/x86_64")
cmdUtils.runCommandInShell("mkdir -p " + options.rpmPath + "/noarch")
if not os.path.isdir(options.sourceRpmPath):
cmdUtils.runCommandInShell("mkdir -p " + options.sourceRpmPath)
if not os.path.isdir(options.buildRootPath):
cmdUtils.runCommandInShell("mkdir -p " + options.buildRootPath)
logger.info("Source Path :" + options.sourcePath)
logger.info("Spec Path :" + options.specPath)
logger.info("Rpm Path :" + options.rpmPath)
logger.info("Log Path :" + options.logPath)
logger.info("Top Dir Path :" + options.topDirPath)
logger.info("Publish RPMS Path :" + options.publishRPMSPath)
if not options.installPackage:
logger.info("JSON File :" + options.inputJSONFile)
else:
logger.info("Package to build:" + package)
'''
listPackages=["acl","attr","autoconf","automake","bash","bc","bindutils","binutils","bison","boost","btrfs-progs","bzip2","ca-certificates","cdrkit","check",
"cloud-init","cmake","coreutils","cpio","cracklib","createrepo","curl","cyrus-sasl","db","dbus","deltarpm","diffutils","docbook-xml","docbook-xsl",
"docker","dracut","e2fsprogs","elfutils","etcd","expat","file","filesystem","findutils","flex","gawk","gcc","gdb","gdbm","gettext","git",
"glib","glibc","glibmm","gmp","go","gobject-introspection","google-daemon","google-startup-scripts","gperf","gpgme","gptfdisk","grep","groff",
"grub","gtk-doc","gzip","haveged","hawkey","iana-etc","inetutils","intltool","iproute2","iptables","itstool","json-glib","kbd","kmod","krb5",
"kubernetes","less","libaio","libassuan","libcap","libdnet","libffi","libgpg-error","libgsystem","libhif","libmspack","libpcap","libpipeline",
"librepo","libselinux","libsepol","libsigc++","libsolv","libtool","libxml2","libxslt","libyaml","linux","linux-api-headers","Linux-PAM","lua",
"lvm2","lzo","m4","make","man-db","man-pages","mercurial","mpc","mpfr","nano","ncurses","nspr","nss","ntp","openldap","openssh","openssl",
"open-vm-tools","ostree","parted","patch","pcre","perl","perl-common-sense","perl-Config-IniFiles","perl-DBD-SQLite","perl-DBI","perl-DBIx-Simple",
"perl-Exporter-Tiny","perl-JSON-XS","perl-libintl","perl-List-MoreUtils","perl-Module-Install","perl-Module-ScanDeps","perl-Types-Serialiser",
"perl-WWW-Curl","perl-YAML","perl-YAML-Tiny","photon-release","pkg-config","popt","procps-ng","psmisc","pycurl","pygobject","python2",
"python-configobj","python-iniparse","python-jsonpatch","python-jsonpointer","python-prettytable","python-requests","python-setuptools",
"python-six","PyYAML","readline","rocket","rpm","rpm-ostree","rpm-ostree-toolbox","ruby","sed","shadow","sqlite-autoconf","strace","sudo",
"swig","systemd","tar","tcpdump","tcsh","tdnf","texinfo","thin-provisioning-tools","tzdata","unzip","urlgrabber","util-linux","vim","wget",
"which","xerces-c","XML-Parser","xml-security-c","xz","yum","yum-metadata-parser","zlib"]
'''
try:
constants.initialize(options)
if package == "packages_list":
buildPackagesList(options.specPath,
options.buildRootPath + "/../packages_list.csv")
elif package == "sources_list":
buildSourcesList(options.specPath, options.buildRootPath + "/../")
elif options.toolChainStage == "stage1":
pkgManager = PackageManager()
pkgManager.buildToolChain()
elif options.toolChainStage == "stage2":
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(options.buildThreads)
elif options.installPackage:
buildAPackage(package, options.buildThreads)
else:
buildPackagesFromGivenJSONFile(options.inputJSONFile,
options.buildOption, logger,
options.buildThreads)
except Exception as e:
logger.error("Caught an exception")
logger.error(str(e))
# print stacktrace
traceback.print_exc()
sys.exit(1)
sys.exit(0)
def main():
usage = "Usage: %prog [options] <package name>"
parser = ArgumentParser(usage)
parser.add_argument("-s",
"--spec-path",
dest="specPath",
default="../../SPECS")
parser.add_argument("-x",
"--source-path",
dest="sourcePath",
default="../../stage/SOURCES")
parser.add_argument("-r",
"--rpm-path",
dest="rpmPath",
default="../../stage/RPMS")
parser.add_argument("-i",
"--install-package",
dest="installPackage",
default=False,
action="store_true")
parser.add_argument("-p",
"--publish-RPMS-path",
dest="publishRPMSPath",
default="../../stage/PUBLISHRPMS")
parser.add_argument("-e",
"--publish-XRPMS-path",
dest="publishXRPMSPath",
default="../../stage/PUBLISHXRPMS")
parser.add_argument("-l",
"--log-path",
dest="logPath",
default="../../stage/LOGS")
parser.add_argument("-y", "--log-level", dest="logLevel", default="error")
parser.add_argument("-z",
"--top-dir-path",
dest="topDirPath",
default="/usr/src/photon")
parser.add_argument("-b",
"--build-root-path",
dest="buildRootPath",
default="/mnt")
parser.add_argument("-t",
"--threads",
dest="buildThreads",
default=1,
type=int,
help="Number of working threads")
parser.add_argument("-m",
"--tool-chain-stage",
dest="toolChainStage",
default="None")
parser.add_argument("-c",
"--pullsources-config",
dest="pullsourcesConfig",
default="pullsources.conf")
parser.add_argument("-d", "--dist-tag", dest="dist", default="")
parser.add_argument("-k",
"--input-RPMS-path",
dest="inputRPMSPath",
default=None)
parser.add_argument("-n",
"--build-number",
dest="buildNumber",
default="0000000")
parser.add_argument("-v",
"--release-version",
dest="releaseVersion",
default="NNNnNNN")
parser.add_argument("-u",
"--enable-rpmcheck",
dest="rpmCheck",
default=False,
action="store_true")
parser.add_argument("-a",
"--source-rpm-path",
dest="sourceRpmPath",
default="../../stage/SRPMS")
parser.add_argument("-w",
"--pkginfo-file",
dest="pkgInfoFile",
default="../../stage/pkg_info.json")
parser.add_argument("-g",
"--pkg-build-option-file",
dest="pkgBuildOptionFile",
default="../../common/data/pkg_build_options.json")
parser.add_argument("-q",
"--rpmcheck-stop-on-error",
dest="rpmCheckStopOnError",
default=False,
action="store_true")
parser.add_argument("-bd",
"--publish-build-dependencies",
dest="publishBuildDependencies",
default=False)
parser.add_argument("-pw",
"--package-weights-path",
dest="packageWeightsPath",
default=None)
parser.add_argument("-bt",
"--build-type",
dest="pkgBuildType",
default="chroot")
parser.add_argument("-F", "--kat-build", dest="katBuild", default=None)
parser.add_argument("-pj",
"--packages-json-input",
dest="pkgJsonInput",
default=None)
parser.add_argument("PackageName", nargs='?')
options = parser.parse_args()
cmdUtils = CommandUtils()
if not os.path.isdir(options.logPath):
cmdUtils.runCommandInShell("mkdir -p " + options.logPath)
logger = Logger.getLogger("Main", options.logPath, options.logLevel)
errorFlag = False
package = None
pkgInfoJsonFile = options.pkgInfoFile
if not os.path.isdir(options.sourcePath):
logger.error("Given Sources Path is not a directory:" +
options.sourcePath)
errorFlag = True
if not os.path.isdir(options.specPath):
logger.error("Given Specs Path is not a directory:" + options.specPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath):
logger.error("Given RPMS Path is not a directory:" +
options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath):
logger.error("Given X RPMS Path is not a directory:" +
options.publishXRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath + "/" + platform.machine()):
logger.error("Given RPMS Path is missing " + platform.machine() +
" sub-directory:" + options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath + "/" + platform.machine()):
logger.error("Given X RPMS Path is missing " + platform.machine() +
" sub-directory:" + options.publishXRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath + "/noarch"):
logger.error("Given RPMS Path is missing noarch sub-directory:" +
options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath + "/noarch"):
logger.error("Given X RPMS Path is missing noarch sub-directory:" +
options.publishXRPMSPath)
errorFlag = True
if not os.path.isfile(options.pkgBuildOptionFile):
logger.warning("Given JSON File is not a file:" +
options.pkgBuildOptionFile)
if options.inputRPMSPath is not None and not os.path.isdir(
options.inputRPMSPath):
logger.error("Given input RPMS Path is not a directory:" +
options.inputRPMSPath)
errorFlag = True
if options.packageWeightsPath is not None and not os.path.isfile(
options.packageWeightsPath):
logger.error("Given input Weights file is not a file:" +
options.packageWeightsPath)
errorFlag = True
if options.pkgJsonInput is not None and not os.path.isfile(
options.pkgJsonInput):
logger.error("Given input packages file is not a file:" +
options.pkgJsonInput)
errorFlag = True
if options.installPackage:
if not options.PackageName:
logger.error("Please provide package name")
errorFlag = True
else:
package = options.PackageName
if errorFlag:
logger.error(
"Found some errors. Please fix input options and re-run it.")
return False
if not os.path.isdir(options.rpmPath):
cmdUtils.runCommandInShell("mkdir -p " + options.rpmPath + "/" +
platform.machine())
cmdUtils.runCommandInShell("mkdir -p " + options.rpmPath + "/noarch")
if not os.path.isdir(options.sourceRpmPath):
cmdUtils.runCommandInShell("mkdir -p " + options.sourceRpmPath)
if not os.path.isdir(options.buildRootPath):
cmdUtils.runCommandInShell("mkdir -p " + options.buildRootPath)
logger.debug("Source Path :" + options.sourcePath)
logger.debug("Spec Path :" + options.specPath)
logger.debug("Rpm Path :" + options.rpmPath)
logger.debug("Log Path :" + options.logPath)
logger.debug("Log Level :" + options.logLevel)
logger.debug("Top Dir Path :" + options.topDirPath)
logger.debug("Publish RPMS Path :" + options.publishRPMSPath)
logger.debug("Publish X RPMS Path :" + options.publishXRPMSPath)
if options.installPackage:
logger.debug("Package to build:" + package)
get_packages_with_build_options(options.pkgBuildOptionFile)
try:
constants.setSpecPath(options.specPath)
constants.setSourcePath(options.sourcePath)
constants.setRpmPath(options.rpmPath)
constants.setSourceRpmPath(options.sourceRpmPath)
constants.setTopDirPath(options.topDirPath)
constants.setLogPath(options.logPath)
constants.setLogLevel(options.logLevel)
constants.setDist(options.dist)
constants.setBuildNumber(options.buildNumber)
constants.setReleaseVersion(options.releaseVersion)
constants.setPrevPublishRPMRepo(options.publishRPMSPath)
constants.setPrevPublishXRPMRepo(options.publishXRPMSPath)
constants.setBuildRootPath(options.buildRootPath)
constants.setPullSourcesURL(get_baseurl(options.pullsourcesConfig))
constants.setInputRPMSPath(options.inputRPMSPath)
constants.setRPMCheck(options.rpmCheck)
constants.setRpmCheckStopOnError(options.rpmCheckStopOnError)
constants.setPublishBuildDependencies(options.publishBuildDependencies)
constants.setPackageWeightsPath(options.packageWeightsPath)
constants.setKatBuild(options.katBuild)
constants.initialize()
# parse SPECS folder
SPECS()
if options.toolChainStage == "stage1":
pkgManager = PackageManager()
pkgManager.buildToolChain()
elif options.toolChainStage == "stage2":
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(options.buildThreads)
elif options.installPackage:
buildSpecifiedPackages([package], options.buildThreads,
options.pkgBuildType)
elif options.pkgJsonInput:
buildPackagesInJson(options.pkgJsonInput, options.buildThreads,
options.pkgBuildType, pkgInfoJsonFile, logger)
else:
buildPackagesForAllSpecs(options.buildThreads,
options.pkgBuildType, pkgInfoJsonFile,
logger)
except Exception as e:
logger.error("Caught an exception")
logger.error(str(e))
# print stacktrace
traceback.print_exc()
sys.exit(1)
sys.exit(0)
def main():
usage = "Usage: %prog [options] <package name>"
parser = OptionParser(usage)
parser.add_option("-s", "--spec-path", dest="specPath", default="../../SPECS")
parser.add_option("-x", "--source-path", dest="sourcePath", default="../../stage/SOURCES")
parser.add_option("-r", "--rpm-path", dest="rpmPath", default="../../stage/RPMS")
parser.add_option("-i", "--install-package", dest="installPackage", default=False, action ="store_true")
parser.add_option("-p", "--publish-RPMS-path", dest="publishRPMSPath", default="../../stage/PUBLISHRPMS")
parser.add_option("-l", "--log-path", dest="logPath", default="../../stage/LOGS")
parser.add_option("-o", "--build-option", dest="buildOption", default="full")
parser.add_option("-z", "--top-dir-path", dest="topDirPath", default="/usr/src/photon")
parser.add_option("-j", "--json-file", dest="inputJSONFile", default="../../common/data/build_install_options_all.json")
parser.add_option("-b", "--build-root-path", dest="buildRootPath", default="/mnt")
parser.add_option("-t", "--threads", dest="buildThreads", default=1, type="int", help="Number of working threads")
parser.add_option("-m", "--tool-chain-stage", dest="toolChainStage", default="None")
parser.add_option("-c", "--pullsources-config", dest="pullsourcesConfig", default="pullsources.conf")
parser.add_option("-d", "--dist", dest="dist", default="")
parser.add_option("-k", "--input-RPMS-path", dest="inputRPMSPath", default=None)
parser.add_option("-n", "--build-number", dest="buildNumber", default="0000000")
parser.add_option("-v", "--release-version", dest="releaseVersion", default="NNNnNNN")
parser.add_option("-u", "--enable-rpmcheck", dest="rpmCheck", default=False, action ="store_true")
parser.add_option("-a", "--source-rpm-path", dest="sourceRpmPath", default="../../stage/SRPMS")
parser.add_option("-w", "--pkginfo-file", dest="pkgInfoFile", default="../../common/data/pkg_info.json")
parser.add_option("-g", "--pkg-build-option-file", dest="pkgBuildOptionFile", default="../../common/data/pkg_build_options.json")
parser.add_option("-q", "--rpmcheck-stop-on-error", dest="rpmCheckStopOnError", default=False, action ="store_true")
(options, args) = parser.parse_args()
cmdUtils=CommandUtils()
if not os.path.isdir(options.logPath):
cmdUtils.runCommandInShell("mkdir -p "+options.logPath)
logger=Logger.getLogger(options.logPath+"/Main")
errorFlag=False
package = None
pkgInfoJsonFile=options.pkgInfoFile
if not os.path.isdir(options.sourcePath):
logger.error("Given Sources Path is not a directory:"+options.sourcePath)
errorFlag = True
if not os.path.isdir(options.specPath):
logger.error("Given Specs Path is not a directory:"+options.specPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath):
logger.error("Given RPMS Path is not a directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath+"/x86_64"):
logger.error("Given RPMS Path is missing x86_64 sub-directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath+"/noarch"):
logger.error("Given RPMS Path is missing noarch sub-directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isfile(options.inputJSONFile) and not options.installPackage:
logger.error("Given JSON File is not a file:"+options.inputJSONFile)
errorFlag = True
if not os.path.isfile(options.pkgBuildOptionFile):
logger.warning("Given JSON File is not a file:"+options.pkgBuildOptionFile)
if options.inputRPMSPath is not None and not os.path.isdir(options.inputRPMSPath):
logger.error("Given input RPMS Path is not a directory:"+options.publishRPMSPath)
errorFlag = True
if options.installPackage :
if len(args) != 1:
logger.error("Please provide package name")
errorFlag = True
else:
package=args[0]
if errorFlag:
logger.error("Found some errors. Please fix input options and re-run it.")
return False
if not os.path.isdir(options.rpmPath):
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/x86_64")
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/noarch")
if not os.path.isdir(options.sourceRpmPath):
cmdUtils.runCommandInShell("mkdir -p "+options.sourceRpmPath)
if not os.path.isdir(options.buildRootPath):
cmdUtils.runCommandInShell("mkdir -p "+options.buildRootPath)
logger.info("Source Path :"+options.sourcePath)
logger.info("Spec Path :" + options.specPath)
logger.info("Rpm Path :" + options.rpmPath)
logger.info("Log Path :" + options.logPath)
logger.info("Top Dir Path :" + options.topDirPath)
logger.info("Publish RPMS Path :" + options.publishRPMSPath)
if not options.installPackage:
logger.info("JSON File :" + options.inputJSONFile)
else:
logger.info("Package to build:"+package)
listBuildOptionPackages = get_packages_with_build_options(options.pkgBuildOptionFile)
try:
constants.initialize(options)
SourcePackageInfo.setLogging()
SourcePackageInfo.loadPkgInfoFromFile(pkgInfoJsonFile)
if package == "packages_list":
buildPackagesList(options.specPath, options.buildRootPath+"/../packages_list.csv")
elif package == "sources_list":
if not os.path.isdir("../../stage/yaml_sources"):
cmdUtils.runCommandInShell("mkdir -p ../../stage/yaml_sources")
buildSourcesList(options.specPath,"../../stage/yaml_sources", options.buildRootPath+"/../",logger)
elif package == "srpms_list":
if not os.path.isdir("../../stage/yaml_srpms"):
cmdUtils.runCommandInShell("mkdir -p ../../stage/yaml_srpms")
buildSRPMList(options.specPath,options.sourceRpmPath,"../../stage/yaml_srpms",logger)
elif options.toolChainStage == "stage1":
pkgManager = PackageManager()
pkgManager.buildToolChain()
elif options.toolChainStage == "stage2":
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(options.buildThreads)
elif options.installPackage:
buildAPackage(package, listBuildOptionPackages, options.pkgBuildOptionFile, options.buildThreads)
else:
buildPackagesFromGivenJSONFile(options.inputJSONFile, options.buildOption, listBuildOptionPackages, options.pkgBuildOptionFile, logger, options.buildThreads)
except Exception as e:
logger.error("Caught an exception")
logger.error(str(e))
# print stacktrace
traceback.print_exc()
sys.exit(1)
logger.info("Writing Package info to the file:"+pkgInfoJsonFile)
SourcePackageInfo.writePkgListToFile(pkgInfoJsonFile)
sys.exit(0)
def main():
parser = ArgumentParser()
parser.add_argument("-s", "--spec-path", dest="specPath", default="../../SPECS")
parser.add_argument("-x", "--source-path", dest="sourcePath",
default="../../stage/SOURCES")
parser.add_argument("-r", "--rpm-path", dest="rpmPath",
default="../../stage/RPMS")
parser.add_argument("-i", "--install-package", dest="installPackage",
default=False, action="store_true")
parser.add_argument("-p", "--publish-RPMS-path", dest="publishRPMSPath",
default="../../stage/PUBLISHRPMS")
parser.add_argument("-e", "--publish-XRPMS-path", dest="publishXRPMSPath",
default="../../stage/PUBLISHXRPMS")
parser.add_argument("-l", "--log-path", dest="logPath", default="../../stage/LOGS")
parser.add_argument("-y", "--log-level", dest="logLevel", default="error")
parser.add_argument("-z", "--top-dir-path", dest="topDirPath", default="/usr/src/photon")
parser.add_argument("-b", "--build-root-path", dest="buildRootPath", default="/mnt")
parser.add_argument("-t", "--threads", dest="buildThreads",
default=1, type=int, help="Number of working threads")
parser.add_argument("-m", "--tool-chain-stage", dest="toolChainStage", default="None")
parser.add_argument("-c", "--pullsources-config", dest="pullsourcesConfig",
default="pullsources.conf")
parser.add_argument("-d", "--dist-tag", dest="dist", default="")
parser.add_argument("-k", "--input-RPMS-path", dest="inputRPMSPath", default=None)
parser.add_argument("-n", "--build-number", dest="buildNumber", default="0000000")
parser.add_argument("-v", "--release-version", dest="releaseVersion", default="NNNnNNN")
parser.add_argument("-u", "--enable-rpmcheck", dest="rpmCheck",
default=False, action="store_true")
parser.add_argument("-a", "--source-rpm-path", dest="sourceRpmPath",
default="../../stage/SRPMS")
parser.add_argument("-w", "--pkginfo-file", dest="pkgInfoFile",
default="../../stage/pkg_info.json")
parser.add_argument("-g", "--pkg-build-option-file", dest="pkgBuildOptionFile",
default="../../common/data/pkg_build_options.json")
parser.add_argument("-q", "--rpmcheck-stop-on-error", dest="rpmCheckStopOnError",
default=False, action="store_true")
parser.add_argument("-bd", "--publish-build-dependencies", dest="publishBuildDependencies",
default=False)
parser.add_argument("-pw", "--package-weights-path", dest="packageWeightsPath",
default="../../common/data/packageWeights.json")
parser.add_argument("-bt", "--build-type", dest="pkgBuildType", choices=['chroot', 'container'], default="chroot")
parser.add_argument("-F", "--kat-build", dest="katBuild", default=None)
parser.add_argument("-pj", "--packages-json-input", dest="pkgJsonInput", default=None)
parser.add_argument("PackageName", nargs='?')
options = parser.parse_args()
cmdUtils = CommandUtils()
if not os.path.isdir(options.logPath):
cmdUtils.runCommandInShell("mkdir -p " + options.logPath)
logger = Logger.getLogger("Main", options.logPath, options.logLevel)
errorFlag = False
package = None
pkgInfoJsonFile = options.pkgInfoFile
if not os.path.isdir(options.sourcePath):
logger.error("Given Sources Path is not a directory:" + options.sourcePath)
errorFlag = True
if not os.path.isdir(options.specPath):
logger.error("Given Specs Path is not a directory:" + options.specPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath):
logger.error("Given RPMS Path is not a directory:" + options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath):
logger.error("Given X RPMS Path is not a directory:" + options.publishXRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath + "/" + platform.machine()):
logger.error("Given RPMS Path is missing " + platform.machine()+
" sub-directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath+"/" + platform.machine()):
logger.error("Given X RPMS Path is missing "+platform.machine()+
" sub-directory:"+options.publishXRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath+"/noarch"):
logger.error("Given RPMS Path is missing noarch sub-directory:"+
options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishXRPMSPath+"/noarch"):
logger.error("Given X RPMS Path is missing noarch sub-directory:"+
options.publishXRPMSPath)
errorFlag = True
if options.inputRPMSPath is not None and not os.path.isdir(options.inputRPMSPath):
logger.error("Given input RPMS Path is not a directory:"+options.inputRPMSPath)
errorFlag = True
if options.packageWeightsPath is not None and not os.path.isfile(options.packageWeightsPath):
logger.error("Given input Weights file is not a file:"+options.packageWeightsPath)
errorFlag = True
if options.pkgJsonInput is not None and not os.path.isfile(options.pkgJsonInput):
logger.error("Given input packages file is not a file:"+options.pkgJsonInput)
errorFlag = True
if options.installPackage:
if not options.PackageName:
logger.error("Please provide package name")
errorFlag = True
else:
package = options.PackageName
if errorFlag:
logger.error("Found some errors. Please fix input options and re-run it.")
return False
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/"+platform.machine())
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/noarch")
if not os.path.isdir(options.sourceRpmPath):
cmdUtils.runCommandInShell("mkdir -p "+options.sourceRpmPath)
if not os.path.isdir(options.buildRootPath):
cmdUtils.runCommandInShell("mkdir -p " + options.buildRootPath)
logger.debug("Source Path :"+options.sourcePath)
logger.debug("Spec Path :" + options.specPath)
logger.debug("Rpm Path :" + options.rpmPath)
logger.debug("Log Path :" + options.logPath)
logger.debug("Log Level :" + options.logLevel)
logger.debug("Top Dir Path :" + options.topDirPath)
logger.debug("Publish RPMS Path :" + options.publishRPMSPath)
logger.debug("Publish X RPMS Path :" + options.publishXRPMSPath)
if options.installPackage:
logger.debug("Package to build:" + package)
get_packages_with_build_options(options.pkgBuildOptionFile)
try:
constants.setSpecPath(options.specPath)
constants.setSourcePath(options.sourcePath)
constants.setRpmPath(options.rpmPath)
constants.setSourceRpmPath(options.sourceRpmPath)
constants.setTopDirPath(options.topDirPath)
constants.setLogPath(options.logPath)
constants.setLogLevel(options.logLevel)
constants.setDist(options.dist)
constants.setBuildNumber(options.buildNumber)
constants.setReleaseVersion(options.releaseVersion)
constants.setPrevPublishRPMRepo(options.publishRPMSPath)
constants.setPrevPublishXRPMRepo(options.publishXRPMSPath)
constants.setBuildRootPath(options.buildRootPath)
constants.setPullSourcesURL(get_baseurl(options.pullsourcesConfig))
constants.setInputRPMSPath(options.inputRPMSPath)
constants.setRPMCheck(options.rpmCheck)
constants.setRpmCheckStopOnError(options.rpmCheckStopOnError)
constants.setPublishBuildDependencies(options.publishBuildDependencies)
constants.setPackageWeightsPath(options.packageWeightsPath)
constants.setKatBuild(options.katBuild)
constants.initialize()
# parse SPECS folder
SPECS()
if options.toolChainStage == "stage1":
pkgManager = PackageManager()
pkgManager.buildToolChain()
elif options.toolChainStage == "stage2":
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(options.buildThreads)
elif options.installPackage:
buildSpecifiedPackages([package], options.buildThreads, options.pkgBuildType)
elif options.pkgJsonInput:
buildPackagesInJson(options.pkgJsonInput, options.buildThreads,
options.pkgBuildType, pkgInfoJsonFile, logger)
else:
buildPackagesForAllSpecs(options.buildThreads, options.pkgBuildType,
pkgInfoJsonFile, logger)
except Exception as e:
logger.error("Caught an exception")
logger.error(str(e))
# print stacktrace
traceback.print_exc()
sys.exit(1)
sys.exit(0)
def main():
usage = "Usage: %prog [options] <package name>"
parser = OptionParser(usage)
parser.add_option("-s", "--spec-path", dest="specPath", default="../../SPECS")
parser.add_option("-x", "--source-path", dest="sourcePath", default="../../stage/SOURCES")
parser.add_option("-r", "--rpm-path", dest="rpmPath", default="../../stage/RPMS")
parser.add_option("-i", "--install-package", dest="installPackage", default=False, action ="store_true")
parser.add_option("-p", "--publish-RPMS-path", dest="publishRPMSPath", default="../../stage/PUBLISHRPMS")
parser.add_option("-l", "--log-path", dest="logPath", default="../../stage/LOGS")
parser.add_option("-o", "--build-option", dest="buildOption", default="full")
parser.add_option("-z", "--top-dir-path", dest="topDirPath", default="/usr/src/photon")
parser.add_option("-j", "--json-file", dest="inputJSONFile", default="../../common/data/build_install_options_all.json")
parser.add_option("-b", "--build-root-path", dest="buildRootPath", default="/mnt")
parser.add_option("-t", "--threads", dest="buildThreads", default=1, type="int", help="Numbeer of working threads")
parser.add_option("-m", "--tool-chain-stage", dest="toolChainStage", default="None")
parser.add_option("-c", "--pullsources-config", dest="pullsourcesConfig", default="pullsources.conf")
parser.add_option("-d", "--dist", dest="dist", default="")
(options, args) = parser.parse_args()
cmdUtils=CommandUtils()
if not os.path.isdir(options.logPath):
cmdUtils.runCommandInShell("mkdir -p "+options.logPath)
logger=Logger.getLogger(options.logPath+"/Main")
errorFlag=False
package = None
if not os.path.isdir(options.sourcePath):
logger.error("Given Sources Path is not a directory:"+options.sourcePath)
errorFlag = True
if not os.path.isdir(options.specPath):
logger.error("Given Specs Path is not a directory:"+options.specPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath):
logger.error("Given RPMS Path is not a directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath+"/x86_64"):
logger.error("Given RPMS Path is missing x86_64 sub-directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isdir(options.publishRPMSPath+"/noarch"):
logger.error("Given RPMS Path is missing noarch sub-directory:"+options.publishRPMSPath)
errorFlag = True
if not os.path.isfile(options.inputJSONFile) and not options.installPackage:
logger.error("Given JSON File is not a file:"+options.inputJSONFile)
errorFlag = True
if options.installPackage :
if len(args) != 1:
logger.error("Please provide package name")
errorFlag = True
else:
package=args[0]
if errorFlag:
logger.error("Found some errors. Please fix input options and re-run it.")
return False
if not os.path.isdir(options.rpmPath):
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/x86_64")
cmdUtils.runCommandInShell("mkdir -p "+options.rpmPath+"/noarch")
if not os.path.isdir(options.buildRootPath):
cmdUtils.runCommandInShell("mkdir -p "+options.buildRootPath)
logger.info("Source Path :"+options.sourcePath)
logger.info("Spec Path :" + options.specPath)
logger.info("Rpm Path :" + options.rpmPath)
logger.info("Log Path :" + options.logPath)
logger.info("Top Dir Path :" + options.topDirPath)
logger.info("Publish RPMS Path :" + options.publishRPMSPath)
if not options.installPackage:
logger.info("JSON File :" + options.inputJSONFile)
else:
logger.info("Package to build:"+package)
'''
listPackages=["acl","attr","autoconf","automake","bash","bc","bindutils","binutils","bison","boost","btrfs-progs","bzip2","ca-certificates","cdrkit","check",
"cloud-init","cmake","coreutils","cpio","cracklib","createrepo","curl","cyrus-sasl","db","dbus","deltarpm","diffutils","docbook-xml","docbook-xsl",
"docker","dracut","e2fsprogs","elfutils","etcd","expat","file","filesystem","findutils","flex","gawk","gcc","gdb","gdbm","gettext","git",
"glib","glibc","glibmm","gmp","go","gobject-introspection","google-daemon","google-startup-scripts","gperf","gpgme","gptfdisk","grep","groff",
"grub","gtk-doc","gzip","haveged","hawkey","iana-etc","inetutils","intltool","iproute2","iptables","itstool","json-glib","kbd","kmod","krb5",
"kubernetes","less","libaio","libassuan","libcap","libdnet","libffi","libgpg-error","libgsystem","libhif","libmspack","libpcap","libpipeline",
"librepo","libselinux","libsepol","libsigc++","libsolv","libtool","libxml2","libxslt","libyaml","linux","linux-api-headers","Linux-PAM","lua",
"lvm2","lzo","m4","make","man-db","man-pages","mercurial","mpc","mpfr","nano","ncurses","nspr","nss","ntp","openldap","openssh","openssl",
"open-vm-tools","ostree","parted","patch","pcre","perl","perl-common-sense","perl-Config-IniFiles","perl-DBD-SQLite","perl-DBI","perl-DBIx-Simple",
"perl-Exporter-Tiny","perl-JSON-XS","perl-libintl","perl-List-MoreUtils","perl-Module-Install","perl-Module-ScanDeps","perl-Types-Serialiser",
"perl-WWW-Curl","perl-YAML","perl-YAML-Tiny","photon-release","pkg-config","popt","procps-ng","psmisc","pycurl","pygobject","python2",
"python-configobj","python-iniparse","python-jsonpatch","python-jsonpointer","python-prettytable","python-requests","python-setuptools",
"python-six","PyYAML","readline","rocket","rpm","rpm-ostree","rpm-ostree-toolbox","ruby","sed","shadow","sqlite-autoconf","strace","sudo",
"swig","systemd","tar","tcpdump","tcsh","tdnf","texinfo","thin-provisioning-tools","tzdata","unzip","urlgrabber","util-linux","vim","wget",
"which","xerces-c","XML-Parser","xml-security-c","xz","yum","yum-metadata-parser","zlib"]
'''
try:
constants.initialize(options)
if package == "packages_list":
buildPackagesList(options.specPath, options.buildRootPath+"/../packages_list.csv")
elif package == "sources_list":
buildSourcesList(options.specPath, options.buildRootPath+"/../")
elif options.toolChainStage == "stage1":
pkgManager = PackageManager()
pkgManager.buildToolChain()
elif options.toolChainStage == "stage2":
pkgManager = PackageManager()
pkgManager.buildToolChainPackages(options.buildThreads)
elif options.installPackage:
buildAPackage(package, options.buildThreads)
else:
buildPackagesFromGivenJSONFile(options.inputJSONFile, options.buildOption,logger, options.buildThreads)
except Exception as e:
logger.error("Caught an exception")
logger.error(str(e))
# print stacktrace
traceback.print_exc()
sys.exit(1)
sys.exit(0)
def buildAPackage(package, buildThreads):
listPackages=[]
listPackages.append(package)
pkgManager = PackageManager()
pkgManager.buildPackages(listPackages, buildThreads)