class ImageTroveSettings(trovesettings.TroveSettings):
urls = CfgList(CfgString)
imageType = CfgString
imageOptions = CfgDict(CfgString)
imageBuildId = CfgInt
productName = CfgString
buildName = CfgString
def updateFromString(self, val, str):
suppProtocols = ['http', 'https']
vlist = str.split()
if len(vlist) > 2:
raise ParseError("Too many arguments for proxy configuration '%s'"
% str)
if not vlist:
raise ParseError("Arguments required for proxy configuration")
if len(vlist) == 2:
if vlist[0] not in suppProtocols:
raise ParseError('Unknown proxy procotol %s' % vlist[0])
if vlist[1] == "None":
# Special value to turn proxy values off
if vlist[0] in val:
del val[vlist[0]]
return val
return CfgDict.updateFromString(self, val, str)
# At this point, len(vlist) == 1
# Fix it up
try:
protocol, rest = str.split(':', 1)
except ValueError:
# : not in the value
if str == "None":
# Special value that turns off the proxy
for protocol in suppProtocols:
if protocol in val:
del val[protocol]
return val
raise ParseError("Invalid proxy configuration value %s" % str)
# This next test duplicates the work done by ProxyEntry.parseString,
# but it's pretty cheap to do here since we already have the protocol
# parsed out
if protocol not in suppProtocols:
raise ParseError('Unknown proxy procotol %s' % protocol)
CfgDict.updateFromString(self, val, 'http http:' + rest)
CfgDict.updateFromString(self, val, 'https https:' + rest)
return val
def updateFromString(self, val, str):
suppProtocols = ['http', 'https']
vlist = str.split()
if len(vlist) > 2:
raise ParseError(
"Too many arguments for proxy configuration '%s'" % str)
if not vlist:
raise ParseError("Arguments required for proxy configuration")
if len(vlist) == 2:
if vlist[0] not in suppProtocols:
raise ParseError('Unknown proxy procotol %s' % vlist[0])
if vlist[1] == "None":
# Special value to turn proxy values off
if vlist[0] in val:
del val[vlist[0]]
return val
return CfgDict.updateFromString(self, val, str)
# At this point, len(vlist) == 1
# Fix it up
try:
protocol, rest = str.split(':', 1)
except ValueError:
# : not in the value
if str == "None":
# Special value that turns off the proxy
for protocol in suppProtocols:
if protocol in val:
del val[protocol]
return val
raise ParseError("Invalid proxy configuration value %s" % str)
# This next test duplicates the work done by ProxyEntry.parseString,
# but it's pretty cheap to do here since we already have the protocol
# parsed out
if protocol not in suppProtocols:
raise ParseError('Unknown proxy procotol %s' % protocol)
CfgDict.updateFromString(self, val, 'http http:' + rest)
CfgDict.updateFromString(self, val, 'https https:' + rest)
return val
class RmakeBuildContext(cfg.ConfigSection):
_cfg_bases = [conarycfg.ConaryContext]
bootstrapTroves = (
CfgList(CfgTroveSpec), [],
"INTERNAL USE ONLY: Troves to be installed before the remaining "
"chroot contents.")
copyInConary = (CfgBool, False)
copyInConfig = (CfgBool, False) # RMK-1052
rbuilderUrl = (cfgtypes.CfgString, 'https://localhost/')
rmakeUser = (CfgUser, None)
if not compat.ConaryVersion().supportsDefaultBuildReqs():
defaultBuildReqs = (CfgList(CfgString), [
'bash:runtime',
'coreutils:runtime',
'filesystem',
'conary:runtime',
'conary-build:runtime',
'dev:runtime',
'grep:runtime',
'sed:runtime',
'findutils:runtime',
'gawk:runtime',
])
else:
defaultBuildReqs = (CfgList(CfgString), [])
resolveTroves = (CfgList(CfgQuotedLineList(CfgTroveSpec)),
[[('group-dist', None, None)]])
matchTroveRule = (CfgList(CfgString), [])
resolveTrovesOnly = (CfgBool, False)
reuseRoots = (CfgBool, False)
rpmRequirements = (
CfgList(CfgDependency), [],
"INTERNAL USE ONLY: Dep provided by the RPM to be used for "
"installation of the chroot.")
strictMode = (CfgBool, False)
targetLabel = (CfgLabel, versions.Label('NONE@local:NONE'))
uuid = (CfgUUID, '')
# DEPRECATED
subscribe = CfgDict(CfgString)
def __init__(self, parent, doc=None):
cfg.ConfigSection.__init__(self, parent, doc=None)
if hasattr(self, 'addConfigOption'):
# Conary < 2.5
for info in conarycfg.ConaryContext._getConfigOptions():
if info[0] not in self:
self.addConfigOption(*info)
class BobTargetSection(cfg.ConfigSection):
'''
Target trove configuration:
[target:tmpwatch]
flavor_set plain
'''
scm = CfgString
after = CfgList(CfgString)
classVar = CfgDict(CfgString)
flavor_mask = CfgFlavor
flavor_set = CfgString
flavor = CfgList(CfgString)
macros = CfgDict(CfgString)
version = CfgString # macros supported
sourceTree = CfgString
serializeFlavors = CfgBool
noBuild = CfgBool
factory = (CfgString, '')
_cfg_aliases = [
('hg', 'scm'),
('git', 'scm'),
]
class rMakeBuilderConfiguration(daemon.DaemonConfig):
buildDir = (CfgPath, '/var/rmake')
helperDir = (CfgPath, "/usr/libexec/rmake")
slots = (CfgInt, 1)
useCache = (CfgBool, False)
useTmpfs = (CfgBool, False)
pluginDirs = (CfgPathList, ['/usr/share/rmake/plugins'])
usePlugins = (CfgBool, True)
usePlugin = CfgDict(CfgBool)
chrootLimit = (CfgInt, 4)
chrootCache = CfgChrootCache
chrootCaps = (CfgBool, False,
"Set capability masks as directed by chroot contents. "
"This has the potential to be unsafe.")
chrootServerPorts = (CfgPortRange, (63000, 64000),
"Port range to be used for 'rmake chroot' sessions.")
hostName = (CfgString, 'localhost')
verbose = False
def getAuthUrl(self):
return None
def getCommandSocketDir(self):
return self.buildDir + '/tmp/'
def getName(self):
return '_local_'
def getCacheDir(self):
return self.buildDir + '/cscache'
def getChrootDir(self):
return self.buildDir + '/chroots'
def getChrootArchiveDir(self):
return self.buildDir + '/archive'
def getBuildLogDir(self, jobId=None):
if jobId:
return self.logDir + '/buildlogs/%d/' % jobId
return self.logDir + '/buildlogs/'
def getBuildLogPath(self, jobId):
return self.logDir + '/buildlogs/%d.log' % jobId
def getChrootHelper(self):
return self.helperDir + '/chroothelper'
def getChrootCache(self):
if not self.chrootCache:
return None
elif self.chrootCache[0] == 'local':
return chrootcache.LocalChrootCache(self.chrootCache[1])
else:
raise errors.RmakeError(
'unknown chroot cache type of "%s" specified' %
self.chrootCache[0])
def _getChrootCacheDir(self):
if not self.chrootCache:
return None
elif self.chrootCache[0] == 'local':
return self.chrootCache[1]
return None
def _checkDir(self, name, path, requiredOwner=None, requiredMode=None):
if not os.path.exists(path):
raise errors.RmakeError(
'%s does not exist, expected at %s - cannot start server' %
(name, path))
sys.exit(1)
if not (requiredOwner or requiredMode):
return
statInfo = os.stat(path)
if requiredMode and statInfo.st_mode & 0777 != requiredMode:
raise errors.RmakeError('%s (%s) must have mode %o' %
(path, name, requiredMode))
if requiredOwner:
ownerName = pwd.getpwuid(statInfo.st_uid).pw_name
if ownerName != requiredOwner:
raise errors.RmakeError('%s (%s) must have owner %s' %
(path, name, requiredOwner))
def __init__(self, default={}):
CfgDict.__init__(self, ProxyEntry, default=default)
class UpdateBotConfigSection(cfg.ConfigSection):
"""
Config class for updatebot.
"""
# R0904 - to many public methods
# pylint: disable=R0904
# Mode that updatebot is running in. (possible values ar
# 'ordered' and 'latest'.
updateMode = CfgString
# name of the product to use in advisories
productName = CfgString
# platform short name
platformName = CfgString
# upstream product version
upstreamProductVersion = CfgString
# disables checks for update completeness, this should only be enabled if
# you know what you are doing and have a good reason.
disableUpdateSanity = CfgBool
# path to configuration files relative to updatebotrc (conaryrc, rmakerc)
configPath = (CfgString, './')
# type of upstream repostory to pull packages from, supported are apt
# and yum.
repositoryFormat = (CfgString, 'yum')
# Default commit message to use when committing to the repository.
commitMessage = (CfgString, 'Automated commit by updateBot')
# Url to the yum repository
repositoryUrl = CfgString
# Paths based off of the repositoryUrl to get to individual repositories.
repositoryPaths = (CfgList(CfgString), ['/'])
# Treat any path matching this spec as "base" (ISO) content.
# In other words, these packages are the golden bits, not errata.
repositoryBasePaths = (CfgList(CfgRegExp), [])
# Arch strings for each repository to signify what base architecture each
# repository is meant for.
# repositoryName archString
repositoryArch = (CfgDict(CfgString), {})
# Add a package to a particular repository. This is useful for adding x86
# packages to an x86_64 group. Normally in the form: pkgName conaryVersion
# archStr repositoryArch
repositoryPackage = (CfgList(CfgStringFourTuple), [])
# Associate binaries generated from a nosrc package with a source package
# name if the nosrc package matches a given regular expression.
nosrcFilter = (CfgList(CfgStringFilter), [])
# Ignore packages with "32bit" in the name. This is intened for use with
# SLES based platforms.
ignore32bitPackages = (CfgBool, False)
# Data source for determining platform version information, only used for
# group versioning.
versionSources = (CfgDict(CfgString), {})
# The top level binary group, this may be the same as topSourceGroup.
topGroup = CfgTroveSpec
# The top level source group.
topSourceGroup = CfgTroveSpec
# Parent top level source group
topParentSourceGroup = CfgTroveSpec
# Path to search for packages to be included in the platform.
platformSearchPath = (CfgQuotedLineList(CfgLabel), [])
# Group contents info.
groupContents = (CfgDict(CfgDict(CfgString)), {})
# Other labels that are referenced in the group that need to be flattend
# onto the targetLabel.
sourceLabel = (CfgList(CfgBranch), [])
# Label to promote to
targetLabel = CfgBranch
# Packages other than the topGroup that need to be promoted.
extraPromoteTroves = (CfgList(CfgTroveSpec), [])
# Extra packages that are expected to be in the promote result set at a
# given bucketId. These are normally packages that for some reason or
# another, usually deps, we had to rebuild.
extraExpectedPromoteTroves = (CfgIntDict(CfgList(CfgTroveSpec)), {})
# List of source packages for which we expect manifest differences
# between parent and child platform. When differences are found,
# create a new package on the child label, overriding the
# parent-platform package/manifest.
expectParentManifestDifferences = (CfgList(CfgString), [])
# For debugging the above--use with caution!
ignoreAllParentManifestDifferences = (CfgBool, False)
# Packages to import
package = (CfgList(CfgString), [])
# Include all packages, if this is set to true packages becomes an
# exclude list.
packageAll = (CfgBool, False)
# Factory to use for importing
newPackageFactory = (CfgString, None)
# Package to exclude from all updates, these are normally packages that
# are not managed as part of this distro (ie. in sles we pull some
# packages from rpl:1).
excludePackages = (CfgList(CfgString), [])
# Exclude these archs from the rpm source.
excludeArch = (CfgList(CfgString), [])
# Disable advisories all together.
disableAdvisories = (CfgBool, False)
# Packages for which there might not reasonably be advisories. Define a
# default advisory message to send with these packages.
advisoryException = (CfgList(CfgList(CfgString)), [])
# Filter out patches with matching descriptions or summaries.
patchFilter = (CfgList(CfgRegExp), [])
# url to base archive searchs off of
listArchiveBaseUrl = CfgString
# date to start querying archives
listArchiveStartDate = CfgString
# list of contexts that all packages are built in.
archContexts = CfgList(CfgStringFilter)
# flavors to build the source group.
groupFlavors = (CfgList(CfgFlavor), [])
# flavors to build kernels.
kernelFlavors = (CfgList(CfgStringFlavor), [])
# packages other than "kernel" to be built in kernelFlavers
kernelModules = (CfgList(CfgString), [])
# flavors to build packages in for packages that need specific flavoring.
packageFlavors = (CfgDict(CfgList(CfgStringFlavor)), {})
# 3-tuple of (context, flavor, regex) of arch-specific package
# flavors to omit unless the regex matches a binary package in the
# manifest. Useful for omitting built of otherwise-expected flavors
# when a package is missing from the repository.
packageFlavorsMissing = (CfgDict(CfgList(CfgFlavorFilter)), {})
# After committing a rMake job to the repository pull the changeset back out
# to make sure all of the contents made it into the repository.
sanityCheckCommits = (CfgBool, False)
# Check the changeset for any rpm capsules and validate that the changeset
# contents match the rpm header. Implies saveChangeSets.
sanityCheckChangesets = (CfgBool, False)
# Save all binary changesets to disk before committing them.
saveChangeSets = (CfgBool, False)
# Always build this list of package names in one job rather than splitting
# them up in the case that you are using a builder that splits by default.
combinePackages = (CfgList(CfgQuotedLineList(CfgString)), [])
# email information for sending advisories
emailFromName = CfgString
emailFrom = CfgString
emailTo = (CfgList(CfgString), [])
emailBcc = (CfgList(CfgString), [])
smtpServer = CfgString
# Jira Info
jiraUser = CfgString
jiraPassword = CfgString
jiraUrl = CfgString
jiraSecurityGroup = CfgString
# Satis Info
satisUrl = CfgString
# Try to build from source rpms
buildFromSource = (CfgBool, False)
# Write package metadata to the source trove no matter the source
# package format.
writePackageMetadata = (CfgBool, False)
# Write version information to the source trove, generated from the source
# version and revision.
writePackageVersion = (CfgBool, False)
# If sources are not available pkgSource will attempt to build artificial
# source information if this is set to True.
synthesizeSources = (CfgBool, False)
# Number of troves at which to switch to a splitarch build. This is mostly
# a magic number, but at least it is configurable?
maxBuildSize = (CfgInt, 10)
# Map of updateIds to upstream versions to use if you don't want to use the
# normal versioning scheme.
upstreamVersionMap = (CfgIntDict(CfgString), {})
# List of errata timestamps to merge together. This is used when one errata
# leaves the platform in a non dependency closed state and a later update
# should solve the dependency problem. All updates are folded into the first
# bucket listed.
mergeUpdates = (CfgList(CfgQuotedLineList(CfgInt)), [])
# Sometimes, we synthesize a source for a nosrc rpm, because we
# really don't know any better. When we find out that, in fact,
# the nosrc rpm belongs to a src rpm with a _different_ version,
# the only way to resolve it is by an explicit merging of the two
# source packages.
mergeSources = (CfgList(CfgNevraTuple), [])
# Timestamp of first erratum. This is used as a baseline for
# determining if any update packages are missing errata. It should
# auto-detect correctly, but in some cases--for instance, when a
# distribution releases the same package as a baseline package on
# one channel and an update on a parallel channel--this will require
# manual specification.
firstErrata = CfgInt
# Timestamp of last erratum. This is used to stop errata processing
# at a specified timestamp, which is useful if recent errata are
# broken and some sort of catch-up run is being done.
lastErrata = CfgInt
# Timestamp after which errata promotions begin. This is useful in
# cases where the baseline distribution must be split across
# multiple updateId's in order to de-dupe the package list.
errataPromoteAfter = (CfgInt, 0)
# Errata timestamp pairs for rescheduling when updates are applied. The
# first element is the current timestamp of the update. The second element
# is the new timestamp. You may need to use this option if it appears that
# the upstream provider has somehow managed to release updates out of order
# and has caused dependency closure problems. Note that you will need to
# mark remove anything that has been committed past the destination
# timestamp to get mirrorball to go back and apply this update.
reorderUpdates = (CfgList(CfgQuotedLineList(CfgInt)), [])
# fromUpdateId toUpdateId advisory
# Sometimes advisories are released out of order, but it is inconvienent to
# move the entire update bucket.
reorderAdvisory = (CfgList(CfgAdvisoryOrder), [])
# advisory trovespec
extendAdvisory = (CfgDict(CfgList(CfgTroveSpec)), {})
# fromUpdateId toUpdateId sourceNevra
# Sometimes multiple versions of the same package are released as part of a
# single advisory. This does not fit the conary model of doing things, so we
# have to reschedule one or more of these sources to another time so that
# they end up in a binary group and get updated in the correct order.
reorderSource = (CfgList(CfgSourceOrder), [])
# reuse old revisions as used in SLES, where if on a rebuild with the
# same version but different revision a subpackage does not change
# content, the new build is not used
reuseOldRevisions = (CfgBool, False)
# updateId binaryPackageName
# Dictionary of bucketIds and packages that are expected to be removed.
updateRemovesPackages = (CfgIntDict(CfgList(CfgString)), {})
# updateId binaryPackageName
# Dictionary of bucketIds and packages that are expected to be moved
# between sources.
updateReplacesPackages = (CfgIntDict(CfgList(CfgString)), {})
# updateId sourceNevra
# As of updateId, remove source package specified by sourceNevra
# from the package model
removeSource = (CfgIntDict(CfgList(CfgNevra)), {})
# updateId sourceNevra
# As of updateId, remove resulting binaries from source package
# specified by sourceNevra used when new pkg exists but has different
# srpm than older pkg
removeObsoletedSource = (CfgIntDict(CfgList(CfgNevra)), {})
# updateId sourceNevra
# At updateId, ignore the source package update specified by
# sourceNevra and continue to use whatever previous version was in
# the model.
ignoreSourceUpdate = (CfgIntDict(CfgList(CfgNevra)), {})
# updateId sourceNevra
# At updateId, allow the source package (and any related binary
# packages) specified by sourceNevra to be missing from the
# repository. Useful for working around selected gaps uncovered by
# OrderedBot._checkMissingPackages() during updates or promotes.
allowMissingPackage = (CfgIntDict(CfgList(CfgNevra)), {})
# updateId binaryNevra
# As of updateId, I expect the code to think this nevra should be removed,
# but I want to keep it.
keepRemoved = (CfgIntDict(CfgList(CfgNevra)), {})
# updateId sourceNevra
# As of updateId, the specified src is fully obsoleted, but
# should be retained in groups
keepObsoleteSource = (CfgList(CfgNevraTuple), [])
# Some obsoletes are merely conceptual preferences, and should not
# turn into removals.
# We would prefer CfgSet(CfgTuple(CfgNevra, CfgNevra), set())
# but CfgSet and CfgTuple do not exist at this point;
# maybe we can add them later.
# keepObsolete <obsoleting nevra> <obsoleted nevra>
keepObsolete = (CfgList(CfgNevraTuple), [])
# updateId packageName [packageName ...]
# remove obsoleted packages when other subpackages of the same
# srpm are not obsoleted, so we cannot use removeSource
removeObsoleted = (CfgIntDict(CfgList(CfgString)), {})
# List of broken errata that have been researched and should be ignored
# when reporting errors.
brokenErrata = (CfgDict(CfgList(CfgNevra)), {})
# Dictionary of updateId to list of trove specs. When the bucketId has been
# reached, update to the version specified in the trovespec rather than the
# latest that matches the current rpm version.
useOldVersion = (CfgIntDict(CfgList(CfgTroveSpec)), {})
# Add a package to a specific group
addPackage = (CfgIntDict(CfgDict(CfgList(CfgStringFlavorUse))), {})
# Remove a package from a specific group
removePackage = (CfgIntDict(CfgDict(CfgList(CfgStringFlavorUse))), {})
# Group name for group that contains all packages in a platform.
packageGroupName = (CfgString, 'group-packages')
# Allow updates for a given nevra to be published without matching errata.
allowMissingErrata = (CfgList(CfgNevra), [])
# Allow updates to have versions that go backwards.
# updateId: [ (from srcTrvSpec, to srcTrvSpec), ... ]
allowPackageDowngrades = (CfgIntDict(CfgList(CfgNevraTuple)), {})
# Allow updates which don't include all binary packages corresponding
# to a given source.
allowRemovedPackages = (CfgBool, False)
# Add a source to a specific updateId. This is used to move updates forward
# after allowing an update to downgrade the version.
addSource = (CfgIntDict(CfgList(CfgNevra)), {})
# recreate any previously built packages. The default "false" will not attempt
# to import the same package version more than once.
recreate = (CfgBool, False)
# uri to a pkgcache server
pkgcacheUri = CfgString
# Set the number of troves to send to rmake at the same time in current mode
# It was hardwired to 1 now it is configurable. Be careful.
# If you don't know then don't change it
chunkSize = (CfgInt, 1)
# Disable OldVersion check for repos that only move forward.
# Added to support epel
disableOldVersionCheck = (CfgBool, False)
# Gem Factory to use for importing
gemPackageFactory = (CfgString, None)
# Gem Packages to import
gemPackage = (CfgList(CfgString), [])
# Gem Package Prefix to use for packages
# because we need to know what the gem name is
# without checking out the manifest
# so we will strip off the prefix
gemPrefix = (CfgString, None)
# user config for artifactory api
artifactoryUser = CfgUserInfo
# allow rmake to commit outdated sources
commitOutdatedSources = (CfgBool, False)
# pom exclusion
excludePoms = (CfgMavenCoordinateList, [])
# pom relocation
relocatePoms = (CfgRelocatePomList, [])
def toStrings(self, value, displayOptions):
value = dict([(str(x), y) for x, y in value.iteritems()])
return CfgDict.toStrings(self, value, displayOptions)
class ConaryContext(ConfigSection):
""" Conary uses context to let the value of particular config parameters
be set based on a keyword that can be set at the command line.
Configuartion values that are set in a context are overridden
by the values in the context that have been set. Values that are
unset in the context do not override the default config values.
"""
archDirs = (CfgPathList, ('/etc/conary/arch', '/etc/conary/distro/arch',
'~/.conary/arch'))
autoLoadRecipes = CfgList(CfgString)
autoResolve = (CfgBool, False)
autoResolvePackages = (CfgBool, True)
buildFlavor = CfgFlavor
buildLabel = CfgLabel
buildPath = (CfgPath, '~/conary/builds')
cleanAfterCook = (CfgBool, True)
commitRelativeChangeset = (CfgBool, False)
componentDirs = (CfgPathList,
('/etc/conary/components',
'/etc/conary/distro/components', '~/.conary/components'))
configComponent = (CfgBool, True)
contact = None
context = None
dbPath = '/var/lib/conarydb'
debugExceptions = (CfgBool, False)
debugRecipeExceptions = (CfgBool, False)
defaultMacros = (CfgPathList,
('/etc/conary/macros', '/etc/conary/macros.d/*',
'~/.conary/macros'))
emergeUser = (CfgString, 'emerge')
enableRPMVersionDeps = (CfgBool, True)
enforceManagedPolicy = (CfgBool, True)
entitlement = CfgEntitlement
entitlementDirectory = (CfgPath, '/etc/conary/entitlements')
environment = CfgDict(CfgString)
excludeTroves = CfgRegExpList
flavor = CfgList(CfgFlavor)
flavorPreferences = CfgList(CfgFlavor)
fullVersions = CfgBool
fullFlavors = CfgBool
localRollbacks = CfgBool
keepRequired = CfgBool
ignoreDependencies = (CfgDependencyClassList,
[deps.AbiDependency, deps.RpmLibDependencies])
installLabelPath = CfgInstallLabelPath
interactive = (CfgBool, False)
logFile = (CfgPathList, (
'/var/log/conary',
'~/.conary/log',
))
lookaside = (CfgPath, '~/conary/cache')
macros = CfgDict(CfgString)
mirrorDirs = (CfgPathList, (
'~/.conary/mirrors',
'/etc/conary/distro/mirrors',
'/etc/conary/mirrors',
))
modelPath = '/etc/conary/system-model'
name = None
quiet = CfgBool
pinTroves = CfgRegExpList
policyDirs = (CfgPathList,
('/usr/lib/conary/policy', '/usr/lib/conary/distro/policy',
'/etc/conary/policy', '~/.conary/policy'))
shortenGroupFlavors = CfgBool
syncCapsuleDatabase = (CfgCapsuleSync, 'update')
# Upstream Conary proxy
conaryProxy = CfgProxy
# HTTP proxy
proxy = CfgProxy
proxyMap = CfgProxyMap
connectAttempts = (CfgInt, 3, "Number of connection attempts to make "
"for outbound HTTP requests.")
downloadAttempts = (CfgInt, 3, "Number of attempts to restart an "
"interrupted download")
downloadRetryThreshold = (
CfgBytes('M'), 10000000,
"Reset the download attempt count if at least this many megabytes "
"have been transferred since the last failure")
downloadRetryTrim = (
CfgBytes('k'), 1000000,
"If a download is reattempted, trim this many kilobytes off the "
"end of what was previously downloaded. 0 disables this feature.")
# The first keyring in the list is writable, and is used for storing the
# keys that are not present on the system-wide keyring. Always expect
# Conary to write to the first keyring.
pubRing = (CfgPathList, _getDefaultPublicKeyrings())
uploadRateLimit = (CfgBytes(perSecond=True), 0,
"Upload rate limit, in bytes per second")
downloadRateLimit = (CfgBytes(perSecond=True), 0,
"Download rate limit, in bytes per second")
recipeTemplate = None
repositoryMap = CfgRepoMap
resolveLevel = (CfgInt, 2)
root = (CfgPath, '/')
recipeTemplateDirs = (CfgPathList, ('~/.conary/recipeTemplates',
'/etc/conary/recipeTemplates'))
showLabels = CfgBool
showComponents = CfgBool
searchPath = CfgSearchPath
signatureKey = CfgFingerPrint
signatureKeyMap = CfgFingerPrintMap
siteConfigPath = (CfgPathList,
('/etc/conary/site', '/etc/conary/distro/site',
'~/.conary/site'))
sourceSearchDir = (CfgPath, '.')
threaded = (CfgBool, True)
downloadFirst = (CfgBool, False)
tmpDir = (CfgPath, _getDefaultTempDir())
trustThreshold = (CfgInt, 0)
trustedCerts = (
CfgPathList, (),
'List of CA certificates which are trusted to identify a remote '
'repository using SSL. Entries may be files, dirs, or globs.')
trustedKeys = (CfgList(CfgString), [])
updateThreshold = (CfgInt, 15)
useDirs = (CfgPathList, ('/etc/conary/use', '/etc/conary/distro/use',
'~/.conary/use'))
user = CfgUserInfo
baseClassDir = (CfgPath, '/usr/share/conary/baseclasses')
verifyDirsNoNewFiles = (CfgPathList,
('/proc', '/sys', '/home', '/dev', '/mnt', '/tmp',
'/var', '/media', '/initrd'))
windowsBuildService = CfgString
systemIdScript = CfgPath
def _resetSigMap(self):
self.resetToDefault('signatureKeyMap')
def __init__(self, *args, **kw):
ConfigSection.__init__(self, *args, **kw)
self.addListener('signatureKey', lambda *args: self._resetSigMap())
def _writeKey(self, out, cfgItem, value, options):
# Suppress all default values, as opposed to the default behavior which
# only suppresses defaults that are None
name = cfgItem.name
if name not in self._values or self._values[name].isDefault():
return
ConfigSection._writeKey(self, out, cfgItem, value, options)
def __init__(self, default={}):
CfgDict.__init__(self, ProxyEntry, default=default)
class BobConfig(cfg.SectionedConfigFile):
targetLabel = CfgString # macros supported
# source
sourceLabel = CfgString # DEPRECATED (ignored)
macros = CfgDict(CfgString)
override = CfgDict(CfgString)
resolveTroves = CfgList(CfgQuotedLineList(
CfgString)) # macros supported
resolveTrovesOnly = (CfgBool, True)
ephemeral = (CfgBool, False)
ephemeralSourceDir = CfgPath
autoLoadRecipes = (CfgList(CfgString), [])
scm = CfgDict(CfgString) # macros supported
refreshSources = (CfgBool, False)
wmsBase = CfgString
# build
installLabelPath = CfgQuotedLineList(
CfgString) # macros supported
needWmsToken = CfgBool
noClean = (CfgBool, False,
"Don't clean the rMake chroot immediately "
"after a successful build.")
shortenGroupFlavors = (CfgBool, True)
target = CfgList(CfgString)
showBuildLogs = (CfgBool, False)
defaultBuildReqs = CfgList(CfgString)
rpmRequirements = CfgList(CfgDependency)
# misc
commitMessage = (CfgString, 'Automated clone by bob')
skipMacros = (CfgList(CfgString), ['version'])
# debugging
dumpRecipes = CfgBool
depMode = CfgBool
recipeDir = CfgPath
# custom handling of sections
_sectionMap = {'target': BobTargetSection}
def __init__(self):
cfg.SectionedConfigFile.__init__(self)
self.scmPins = {}
self._macros = None
def read(self, path, **kwargs):
if path.startswith('http://') or path.startswith('https://'):
return cfg.SectionedConfigFile.readUrl(self, path, **kwargs)
else:
return cfg.SectionedConfigFile.read(self, path, **kwargs)
def setSection(self, sectionName):
if not self.hasSection(sectionName):
found = False
for name, cls in self._sectionMap.iteritems():
if sectionName == name or sectionName.startswith(name + ':'):
found = True
self._addSection(sectionName, cls(self))
if not found:
raise ParseError('Unknown section "%s"' % sectionName)
self._sectionName = sectionName
return self._sections[sectionName]
def setPins(self, scmPins):
self.scmPins = scmPins
def getMacros(self):
if self._macros is None:
macros = Macros(self.macros)
macros.update(self.override)
macros['start_time'] = time.strftime('%Y%m%d_%H%M%S')
macros['target_label'] = self.targetLabel % macros
self._macros = macros
return self._macros
def getRepositories(self, macros=None):
"""
Get a mapping of SCM repository aliases to the repository
objects (which specify kind, hostname, path, and pinned
revision).
"""
if self.scmPins:
# Someone already went to the trouble of determining what
# we have (e.g. they "pinned" the repositories)
return self.scmPins
if not macros:
macros = self.getMacros()
out = {}
for name, value in self.scm.iteritems():
if ' ' not in value:
raise ValueError("Invalid scm directive %r -- must take the "
"form 'scm <hg|git> <uri> [rev]" % (value,))
kind, uri = value.split(' ', 1)
name %= macros
if ' ' in uri:
uri, revision = uri.split(' ', 1)
uri %= macros
revision %= macros
else:
uri %= macros
revision = None
out[name] = (kind, uri, revision)
return out
def getTargetLabel(self):
return Label(self.targetLabel % self.getMacros())
@cfg.directive
def hg(self, value):
key, value = value.split(' ', 1)
self.configLine('scm %s hg %s' % (key, value))
def toStrings(self, value, displayOptions):
value = dict([ (str(x), y) for x, y in value.iteritems() ])
return CfgDict.toStrings(self, value, displayOptions)
class BuildConfiguration(conarycfg.ConaryConfiguration, FreezableConfigMixin):
_cfg_bases = [RmakeBuildContext]
buildTroveSpecs = CfgList(CfgTroveSpec)
isolateTroves = (
CfgBool, False, "Ignore the results of other "
"troves in the same job when searching for build requirements.")
resolveTroveTups = CfgList(CfgQuotedLineList(CfgTroveTuple))
recurseGroups = (CfgInt, 0)
prepOnly = (CfgBool, False)
pluginDirs = (CfgPathList,
['/usr/share/rmake/plugins', '~/.rmake/plugins.d'])
usePlugin = CfgDict(CfgBool)
usePlugins = (CfgBool, True)
jobContext = CfgList(CfgInt)
recursedGroupTroves = CfgList(CfgTroveTuple)
reposName = (CfgString, None)
prebuiltBinaries = CfgList(CfgTroveTuple)
ignoreExternalRebuildDeps = (CfgBool, False)
ignoreAllRebuildDeps = (CfgBool, False)
primaryTroves = CfgList(CfgTroveTupleWithContext)
# Here are options that are not visible from the command-line
# and should not be displayed. They are job-specific. However,
# they must be stored with the job, parsed with the job, etc.
_cfg_hidden = [
'buildTroveSpecs',
'resolveTroveTups',
'jobContext',
'recurseGroups',
'recursedGroupTroves',
'prebuiltBinaries',
'ignoreExternalRebuildDeps',
'ignoreAllRebuildDeps',
'primaryTroves',
'reposName',
]
_strictOptions = [
'buildFlavor', 'buildLabel', 'cleanAfterCook', 'flavor',
'installLabelPath', 'repositoryMap', 'root', 'user', 'name', 'contact',
'signatureKey', 'dbPath', 'proxy', 'conaryProxy', 'lookaside',
'entitlement', 'autoLoadRecipes', 'proxyMap'
]
_dirsToCopy = [
'archDirs', 'mirrorDirs', 'siteConfigPath', 'useDirs', 'componentDirs'
]
_pathsToCopy = ['defaultMacros']
_defaultSectionType = RmakeBuildContext
def __init__(self,
readConfigFiles=False,
root='',
conaryConfig=None,
serverConfig=None,
ignoreErrors=False,
log=None,
strictMode=None):
# we default the value of these items to whatever they
# are set to on the local system's conaryrc.
if log is None:
log = logger.Logger('buildcfg')
conarycfg.ConaryConfiguration.__init__(self, readConfigFiles=False)
if hasattr(self, 'setIgnoreErrors'):
self.setIgnoreErrors(ignoreErrors)
if hasattr(self, 'addConfigOption'):
# Conary < 2.5
for info in RmakeBuildContext._getConfigOptions():
if info[0] not in self:
self.addConfigOption(*info)
if strictMode is not None:
self.strictMode = strictMode
if not hasattr(self, 'rmakeUrl'):
self.rmakeUrl = None
if not hasattr(self, 'clientCert'):
self.clientCert = None
if readConfigFiles:
if os.path.exists(root + '/etc/rmake/clientrc'):
log.warning(root + '/etc/rmake/clientrc should be renamed'
' to /etc/rmake/rmakerc')
self.read(root + '/etc/rmake/clientrc', exception=False)
self.read(root + '/etc/rmake/rmakerc', exception=False)
if os.environ.has_key("HOME"):
self.read(root + os.environ["HOME"] + "/" + ".rmakerc",
exception=False)
self.read('rmakerc', exception=False)
if self.strictMode:
self.enforceManagedPolicy = True
self.copyInConary = False
self.copyInConfig = False
# these values are not set based on
# config file values - we don't want to touch the system database,
# and we don't want to use conary's logging mechanism.
self.root = ':memory:'
self.dbPath = ':memory:'
self.logFile = []
if hasattr(self, '_lowerCaseMap'):
# Conary < 2.5
for option in self._cfg_hidden:
del self._lowerCaseMap[option.lower()]
self.useConaryConfig(conaryConfig)
if serverConfig:
self.reposName = serverConfig.reposName
self.repositoryMap.update(serverConfig.getRepositoryMap())
self.user.extend(serverConfig.reposUser)
def useConaryConfig(self, conaryConfig):
def _shouldOverwrite(key, current, new):
if key not in new:
return False
if (current.isDefault(key)
and current[key] == current.getDefaultValue(key)
and (not new.isDefault(key)
or new[key] != new.getDefaultValue(key))):
return True
return False
if self.strictMode:
if not conaryConfig:
conaryConfig = conarycfg.ConaryConfiguration(False)
for key in self.iterkeys():
if key not in self._strictOptions and key in conaryConfig:
self.resetToDefault(key)
if not conaryConfig:
return
# copy in conary config values that we haven't
# overrided from the rmake config
for key in self.iterkeys():
if self.strictMode and key not in self._strictOptions:
continue
if _shouldOverwrite(key, self, conaryConfig):
self[key] = conaryConfig[key]
for sectionName in conaryConfig.iterSectionNames():
conarySection = conaryConfig.getSection(sectionName)
if not self.hasSection(sectionName):
self._addSection(sectionName, self._defaultSectionType(self))
mySection = self.getSection(sectionName)
for key in mySection.iterkeys():
if self.strictMode and key not in self._strictOptions:
continue
if _shouldOverwrite(key, mySection, conarySection):
mySection[key] = conarySection[key]
if self.strictMode:
self.enforceManagedPolicy = True
self.copyInConary = False
self.copyInConfig = False
if not self.copyInConfig:
for option in self._dirsToCopy + self._pathsToCopy:
self.resetToDefault(option)
def getServerUri(self):
if self.rmakeUrl:
return self.rmakeUrl
return 'unix:///var/lib/rmake/socket'
def limitToHosts(self, hosts):
if isinstance(hosts, str):
hosts = [hosts]
for host in hosts:
if '@' in host or '=' in host:
raise ParseError('Invalid host "%s"' % host)
self.addMatchRule('=%s@' % host)
def limitToLabels(self, labels):
if isinstance(labels, str):
labels = [labels]
for label in labels:
label = versions.Label(label)
self.addMatchRule('=%s' % label)
def addMatchRule(self, matchRule):
self.configLine('matchTroveRule %s' % matchRule)
def clearMatchRules(self):
self.matchTroveRule = []
for section in self.iterSections():
section.matchTroveRule = []
def getTargetLabel(self, versionOrLabel):
if isinstance(versionOrLabel, versions.Label):
cookLabel = versionOrLabel
elif isinstance(versionOrLabel, versions.Branch):
cookLabel = versionOrLabel.label()
else:
cookLabel = versionOrLabel.trailingLabel()
targetLabel = self.targetLabel
if targetLabel:
# we treat NONE in the label as being a special target,
# if your targetLabel is localhost@rpl:NONE, we build
# onto localhost@rpl:<branch> where branch is the branch
# of the source version.
needNewLabel = False
if targetLabel.getHost().lower() == 'none':
needNewLabel = True
host = self.reposName
else:
host = targetLabel.getHost()
if targetLabel.getNamespace().lower() == 'none':
needNewLabel = True
nameSpace = cookLabel.getNamespace()
else:
nameSpace = targetLabel.getNamespace()
if targetLabel.branch.lower() == 'none':
needNewLabel = True
branch = cookLabel.branch
else:
branch = targetLabel.branch
if needNewLabel:
targetLabel = '%s@%s:%s' % (host, nameSpace, branch)
targetLabel = versions.Label(targetLabel)
return targetLabel
else:
return cookLabel
def dropContexts(self):
self._sections = {}
def storeConaryCfg(self, out):
conaryCfg = conarycfg.ConaryConfiguration(False)
for key, value in self.iteritems():
if self.isDefault(key):
continue
if key in conaryCfg:
if key == 'macros':
# multi-line macros break conary config files (RMK-996)
continue
if key == 'context':
# we're not writing out contexts!
continue
conaryCfg[key] = value
conaryCfg.store(out, includeDocs=False)
def getMacros(self):
# multi-line macros break conary config files, so provide
# any macros separately (RMK-996)
if 'macros' in self:
macros = sorted(x for x in self.macros.iteritems())
if macros:
return '\n'.join('%s = %r' % x for x in macros) + '\n'
return ''
def _writeKey(self, out, cfgItem, value, options):
if cfgItem.name in self._cfg_hidden:
if not options.get('displayHidden', False):
return
conarycfg.ConaryConfiguration._writeKey(self, out, cfgItem,
self[cfgItem.name], options)
