def testShadowed(self):
self.repos = self.openRepository()
self.addTestPkg(1,
content='''r.Create("/etc/foo",
contents="old contents\\n")''')
self.mkbranch(self.cfg.buildLabel, "@rpl:branch", "test1:source",
shadow=True)
self.cfg.buildLabel = versions.Label('localhost@rpl:branch')
self.cfg.installLabelPath = \
conarycfg.CfgLabelList([self.cfg.buildLabel])
# modify the trove on the shadow
self.addTestPkg(1, content='''r.Create("/etc/foo",
contents="new contents\\n")''')
self.cookTestPkg(1)
self.updatePkg(self.rootDir, 'test1', depCheck=False)
self.writeFile(self.rootDir + "/etc/foo", 'newer contents\\n')
(fd, path) = tempfile.mkstemp()
os.close(fd)
self.localChangeset(self.rootDir, 'test1', path)
commit.doCommit(self.cfg, path,
'localhost@commit:branch')
assert(self.repos.hasTrove('test1', versions.VersionFromString(
'/localhost@rpl:linux//branch//commit:branch/1.0-1.1-1.0.1'),
deps.Flavor()))
# commit it again to make sure the version gets incremented
commit.doCommit(self.cfg, path,
'localhost@commit:branch')
assert(self.repos.hasTrove('test1', versions.VersionFromString(
'/localhost@rpl:linux//branch//commit:branch/1.0-1.1-1.0.2'),
deps.Flavor()))
os.remove(path)
def _logDifferenceInPrebuiltReqs(self, trv, buildReqTups, preBuiltReqs):
existsTrv = trove.Trove('@update',
versions.NewVersion(),
deps.Flavor(), None)
availableTrv = trove.Trove('@update',
versions.NewVersion(),
deps.Flavor(), None)
for troveNVF in preBuiltReqs:
existsTrv.addTrove(*troveNVF)
for troveNVF in buildReqTups:
availableTrv.addTrove(*troveNVF)
jobs = availableTrv.diff(existsTrv)[2]
formatter = display.JobTupFormatter(affinityDb=None)
formatter.dcfg.setTroveDisplay(fullVersions=True,
fullFlavors=True,
showComponents=True)
formatter.dcfg.setJobDisplay(compressJobs=True)
formatter.prepareJobLists([jobs])
self.logger.info('Could count %s=%s[%s]{%s} as prebuilt - the'
' following changes have been made in its'
' buildreqs:' % trv.getNameVersionFlavor(
withContext=True))
for line in formatter.formatJobTups(jobs):
self.logger.info(line)
self.logger.info('...Rebuilding')
def testTroveMultiFlavor(self):
# create a package with 3 components, each use a different use
# flag. add the package before the components. the goal is
# to make the trovestore create more than one flavor
flags = ('foo', 'bar', 'baz')
flavors = []
for flag in flags:
flavor = deps.Flavor()
flavor.addDep(
deps.UseDependency,
deps.Dependency('use', [(flag, deps.FLAG_SENSE_REQUIRED)]))
flavor.addDep(deps.InstructionSetDependency,
deps.Dependency('x86', []))
flavors.append(flavor)
v10 = ThawVersion("/conary.rpath.com@test:trunk/10:1.2-10")
store = self._connect()
# create components to add to the package
troves = []
for flag, flavor in zip(flags, flavors):
trv = trove.Trove('test:%s' % flag, v10, flavor, None)
trv.computeDigests()
troves.append(trv)
# add the package
union = deps.Flavor()
for flavor in flavors:
union.union(flavor)
trv2 = trove.Trove("test", v10, union, None)
for trv in troves:
trv2.addTrove(trv.getName(), v10, trv2.getFlavor())
trv2.computeDigests()
store.addTroveSetStart([], [], [])
troveInfo = store.addTrove(trv2, trv2.diff(None)[0])
store.addTroveDone(troveInfo)
store.addTroveSetDone()
# add the troves
store.addTroveSetStart([], [], [])
for trv in troves:
troveInfo = store.addTrove(trv, trv.diff(None)[0])
store.addTroveDone(troveInfo)
store.addTroveSetDone()
for trv in troves:
self.assertEqual(
trv,
store.getTrove(trv.getName(), trv.getVersion(),
trv.getFlavor()))
troveFlavors = store.getTroveFlavors({'test': [v10]})
self.assertEqual(troveFlavors['test'][v10], [union.freeze()])
def testNextVersions(self):
trv = self.addComponent('foo:source', '1')
self.addComponent('foo:run', '1')
self.addCollection('foo', '1', [':run'])
localVersion = VFS('/local@local:COOK/1.0-1')
sourceList = [(trv.getVersion(), ['foo'], deps.Flavor()),
(localVersion, ['bar'], deps.Flavor())]
repos = self.openRepository()
nextVersions = nextversion.nextVersions(repos, self.openDatabase(),
sourceList)
assert(nextVersions == [VFS('/localhost@rpl:linux/1-1-2'),
VFS('/local@local:COOK/1.0-1-1')])
def testDistributedRedirect(self):
store = self._connect()
cu = store.db.cursor()
flavor = deps.Flavor()
localVer1 = ThawVersion("/localhost@test:trunk/10:1.1-10")
localVer2 = ThawVersion("/localhost@test:trunk/20:1.2-20")
remoteVer = ThawVersion("/localhost1@test:trunk/10:1.2-10")
# this places /localhost1@test:trunk into the branch table, but not
# the labels table
trv = trove.Trove("group-foo",
localVer1,
flavor,
None,
type=trove.TROVE_TYPE_REDIRECT)
trv.addRedirect("target", remoteVer.branch(), flavor)
trv.computeDigests()
store.addTroveSetStart([], [], [])
ti = store.addTrove(trv, trv.diff(None)[0], hidden=True)
store.addTroveDone(ti)
# and this needs the label to exist
trv = trove.Trove("group-foo", localVer2, flavor, None)
trv.addTrove("target", remoteVer, flavor)
trv.computeDigests()
ti = store.addTrove(trv, trv.diff(None)[0], hidden=True)
store.addTroveDone(ti)
def createFlavor(recipeName, *flagIterables, **kw):
""" create a dependency set consisting of all of the flags in the
given flagIterables. Note that is a broad category that includes
lists, iterators, etc. RecipeName is the recipe which local flags
should be relative to, can be set to None if there are definitely
no local flags in the flagIterables.
"""
targetDep = kw.pop('targetDep', False)
if targetDep:
depType = deps.TargetInstructionSetDependency
else:
depType = deps.InstructionSetDependency
majArch = None
archFlags = {}
subsumed = {}
useFlags = []
set = deps.Flavor()
for flag in itertools.chain(*flagIterables):
flagType = type(flag)
if flagType == MajorArch:
if not flag._get():
continue
set.union(flag._toDependency(depType=depType))
elif flagType == SubArch:
set.union(flag._toDependency(depType=depType))
elif flagType == UseFlag:
set.union(flag._toDependency())
elif flagType == LocalFlag:
assert(recipeName)
set.union(flag._toDependency(recipeName))
elif flagType == PackageFlag:
set.union(flag._toDependency(flag._parent._name))
return set
def _toDependency(self, recipeName):
depFlags = [('.'.join((recipeName, self._name)),
self._getDepSense())]
set = deps.Flavor()
dep = deps.Dependency('use', depFlags)
set.addDep(deps.UseDependency, dep)
return set
def _toDependency(self):
set = deps.Flavor()
sense = self._getDepSense()
depFlags = [ (self._name, sense) ]
dep = deps.Dependency('use', depFlags)
set.addDep(deps.UseDependency, dep)
return set
def getCheckoutLog(self, targetDir, newerOnly=False, versionList=None):
"""
Returns list of lines of log messages relative to the specified
targetDirectory.
@param targetDir: name of directory for which to fetch status.
@type targetDir: string
@param newerOnly: (C{False}) whether to return only log messages
newer than the current contents of the checkout.
@type newerOnly: bool
@param versionList: (C{None}) if set, a list of versions for
which to return log messages. If C{None}, return all log
messages.
@type versionList: list of strings or (opaque) conary version objects
@return: list of strings
"""
repos, sourceState = self._getRepositoryStateFromDirectory(targetDir)
troveName = sourceState.getName()
if versionList is None:
if newerOnly:
versionList = self._getNewerRepositoryVersions(targetDir)
else:
versionList = self._getRepositoryVersions(targetDir)
else:
versionList = [self._getVersion(x) for x in versionList]
emptyFlavor = deps.Flavor()
nvfList = [(troveName, v, emptyFlavor) for v in versionList]
troves = repos.getTroves(nvfList)
return [message for message in checkin.iterLogMessages(troves)]
def testOne(dir, flagList, emptyPreferred=True):
files = os.listdir(dir)
for fileName in files:
os.unlink(os.path.join(dir, fileName))
for (flag, sense) in flagList:
f = open(os.path.join(dir, flag), "w")
if sense == deps.FLAG_SENSE_PREFERRED:
if not emptyPreferred:
f.write('sense preferred\n')
elif sense == deps.FLAG_SENSE_PREFERNOT:
f.write('sense prefernot\n')
elif sense == deps.FLAG_SENSE_DISALLOWED:
f.write('sense disallowed\n')
elif sense == deps.FLAG_SENSE_REQUIRED:
f.write('sense required\n')
else:
assert (0)
f.close()
use = flavorcfg.FlavorConfig(dir, '')
cmp = deps.Flavor()
cmp.addDep(deps.UseDependency, deps.Dependency('use', flagList))
assert (use.toDependency() == cmp)
def testRoleFilters(self):
db = self._setupDB()
na = netauth.NetworkAuthorization(db, "conary.rpath.com")
self._addUserRole(na, "testuser", "testpass")
roleId = na._getRoleIdByName('testuser')
geoip = {
'1.2.3.4': deps.parseFlavor('country.XC'),
'5.6.7.8': deps.parseFlavor('country.XB'),
}
na.geoIp.getFlags = lambda x: geoip[x]
na.setRoleFilters({'testuser': (
deps.parseFlavor('!country.XA,!country.XB'), None)})
self.assertEqual(na.getRoleFilters(['testuser']),
{'testuser': (
deps.parseFlavor('!country.XA,!country.XB'), deps.Flavor())})
token = AuthToken('testuser', 'testpass', remote_ip='1.2.3.4')
self.assertEqual(
na.getAuthRoles(db.cursor(), token), set([roleId]))
token = AuthToken('testuser', 'testpass', remote_ip='5.6.7.8')
level = netauth.log.level
netauth.log.setLevel(100)
try:
self.assertRaises(errors.InsufficientPermission,
na.getAuthRoles, db.cursor(), token)
finally:
netauth.log.setLevel(level)
def reduce_flavors(package, target_cfg, flavors_in):
'''
Reduce the set of flavors to be built for a given trove to specify
only:
* The instruction set
* Package use flags (for this package only)
* Flavors specified in a "use" config item for the package
'''
flavors_out = set()
if target_cfg and (target_cfg.flavor or target_cfg.flavor_set):
# An explicit set of flavors was provided. They should be used instead
# of whatever we were given.
flavors_out = expand_targets(target_cfg)
elif target_cfg and target_cfg.flavor_mask != deps.Flavor():
# A flavor mask was provided. Use this to select which flavors are
# unique, and build only variations on them.
flavors_out = set()
for flavor in flavors_in:
flavors_out.add(mask_flavor(flavor, target_cfg.flavor_mask))
elif package.startswith('group-'):
# With groups it's impossible to guess which flavors are useful; and
# usually we want them all anyway since groups are where the set of
# flavors to be built originate.
flavors_out = flavors_in
else:
# No rules were specified. Keep instruction set and package flags
# for this package only.
flavors_out = set()
for flavor in flavors_in:
flavors_out.add(fragment_flavor(package, flavor))
return flavors_out
def testHidden(self):
store = self._connect()
cu = store.db.cursor()
flavor = deps.Flavor()
version = ThawVersion("/conary.rpath.com@test:trunk/10:1.2-10")
f = files.FileFromFilesystem("/etc/passwd", self.id)
trv = trove.Trove("junk:data", version, flavor, None)
trv.computeDigests()
store.addTroveSetStart([], set(['/etc']), set(['passwd']))
ti = store.addTrove(trv, trv.diff(None)[0], hidden=True)
store.addTroveDone(ti)
store.addTroveSetDone()
assert (cu.execute("select count(*) from latestcache").fetchall()[0][0]
== 0)
assert (cu.execute("select isPresent from instances").fetchall()[0][0]
== instances.INSTANCE_PRESENT_HIDDEN)
store.presentHiddenTroves()
assert (cu.execute("select count(*) from latestcache").fetchall()[0][0]
== 3)
assert (cu.execute("select isPresent from instances").fetchall()[0][0]
== instances.INSTANCE_PRESENT_NORMAL)
def testCommonFiles(self):
# this test simulates a trove having the ame file in different
# path locations with only changed mtimes.
store = self._connect()
flavor = deps.Flavor()
version = ThawVersion("/conary.rpath.com@test:trunk/10:1.2-10")
baseNames = set(['file'])
dirNames = set(['/junk1', '/junk2'])
f = files.FileFromFilesystem("/etc/passwd", self.id)
trv = trove.Trove("junk:data", version, flavor, None)
trv.addFile(self.id1, "/junk1/file", version, f.fileId())
trv.addFile(self.id2, "/junk2/file", version, f.fileId())
trv.computeDigests()
store.db.transaction()
store.addTroveSetStart([], dirNames, baseNames)
ti = store.addTrove(trv, trv.diff(None)[0])
f.inode.mtime.set(1)
ti.addFile(self.id1,
"/junk1/file",
f.fileId(),
version,
fileStream=f.freeze())
f.inode.mtime.set(2)
ti.addFile(self.id2,
"/junk2/file",
f.fileId(),
version,
fileStream=f.freeze())
store.addTroveDone(ti)
store.commit()
def testNextVersionMultipleBranchesWithDepth2(self):
self.addCollection('foo=/localhost@rpl:1//2//3/2:1-2-0.1', [':run'])
repos = self.openRepository()
sourceList = [(VFS('/localhost@rpl:2//3/1-2'), ['foo'], deps.Flavor())]
nextVersions = nextversion.nextVersions(repos, self.openDatabase(),
sourceList)
assert(nextVersions == [VFS('/localhost@rpl:2//3/1-2-0.2')])
def testLoadedTrovesWithAutoLoad(self):
self.logFilter.add()
repos = self.openRepository()
if 'x86_64' not in str(self.cfg.buildFlavor):
raise testhelp.SkipTestException('Skip test on x86 arch')
self.cfg.autoLoadRecipes.append('other')
self.overrideBuildFlavor('is: x86 x86_64')
header = '''
if Arch.x86: pass
'''
self.addComponent(
'other:recipe=2.0[is:x86 x86_64]',
[('simplesuper.recipe', simpleSuperRecipe.replace('1.0', '2.0'))])
self.addCollection('other=2.0[is:x86 x86_64]', [':recipe'])
self.addTestPkg(1, version='1.0', header=header)
self.addTestPkg(2, header='loadRecipe("test1")')
use.track()
rldep = deps.parseFlavor('readline')
ssldep = deps.parseFlavor('ssl')
nobsdep = deps.parseFlavor('~!bootstrap')
emptydep = deps.Flavor()
x64dep = deps.parseFlavor('is:x86_64')
v1 = versions.VersionFromString('/localhost@rpl:linux/1.0-1')
loader = self._testSubload(repos, "loadInstalled('test2')")
FooLoaded = loader.getLoadedSpecs()
assertEq = self.assertEqual
assertEq(FooLoaded['test2'][0], ('test2:source', v1, emptydep))
Test2Loaded = FooLoaded['test2'][1]
assertEq(Test2Loaded['test1'][0], ('test1:source', v1, x64dep))
Test1Loaded = Test2Loaded['test1'][1]
assertEq(Test1Loaded, {})
loadedTroves = loader.getLoadedTroves()
assertEq(len(loadedTroves), 2)
assertEq(loadedTroves[0], ('test1:source', v1, x64dep))
assertEq(loadedTroves[1], ('test2:source', v1, emptydep))
# Now reset and load again w/ overrides specified
branch = versions.VersionFromString('/localhost@rpl:foo/')
oldLoadedSpecs = loader.getLoadedSpecs()
# move ILP and buildLabel over to another branch, and use overrides
# to load exactly what we want anyway.
cfg = copy.copy(self.cfg)
self.overrideBuildFlavor('!readline, !ssl')
overrides = oldLoadedSpecs
loader = self._testSubload(repos,
"loadInstalled('test2')",
cfg=cfg,
overrides=overrides)
assert (loadedTroves[0] == ('test1:source', v1, x64dep))
assert (loadedTroves[1] == ('test2:source', v1, emptydep))
def __init__(self):
self.flavor = deps.Flavor()
self.recipeType = None
self.loadedSpecsList = []
self.loadedTroves = []
self.packages = set()
self.delayedRequirements = set()
self.buildRequirements = set()
self.crossRequirements = set()
def initializeFlavors(self):
"""
Initialize flavor preferences based on files typically
found in /etc/conary/arch (archDirs) and /etc/conary/use
@raises RuntimeError: Raised if use flags conflict in
a way which cannot be reconciled
(see L{deps.DependencyClass.MergeFlags})
"""
self.flavorConfig = flavorcfg.FlavorConfig(self.useDirs, self.archDirs)
if self.flavor == []:
self.flavor = [deps.Flavor()]
self.flavor = self.flavorConfig.toDependency(override=self.flavor)
newFlavors = []
hasIns = False
# if any flavor has an instruction set, don't merge
for flavor in self.flavor:
if deps.DEP_CLASS_IS in flavor.getDepClasses():
hasIns = True
break
if not hasIns:
# use all the flavors for the main arch first
for depList in arch.currentArch:
for flavor in self.flavor:
insSet = deps.Flavor()
for dep in depList:
insSet.addDep(deps.InstructionSetDependency, dep)
newFlavor = flavor.copy()
newFlavor.union(insSet)
newFlavors.append(newFlavor)
self.flavor = newFlavors
# buildFlavor is installFlavor + overrides
self.buildFlavor = deps.overrideFlavor(self.flavor[0],
self.buildFlavor)
if self.isDefault('flavorPreferences'):
self.flavorPreferences = arch.getFlavorPreferencesFromFlavor(
self.flavor[0])
self.flavorConfig.populateBuildFlags()
def testNextVersionLatestDevelOnThisBranch(self):
# depth 3
self.addCollection('foo=/localhost@rpl:1//2//3/1:1-2-0.0.1', [':run'])
# depth 2 and latest
self.addCollection('foo=/localhost@rpl:1//3/2:1-2-0.1[is:x86]',
[':run'])
sourceList = [(VFS('/localhost@rpl:1//3/1-2'), ['foo'], deps.Flavor())]
nextVersions = nextversion.nextVersions(self.openRepository(),
self.openDatabase(), sourceList)
assert(nextVersions == [VFS('/localhost@rpl:1//3/1-2-0.1')])
def _getFlags(self, authToken):
flags = deps.Flavor()
for addr in authToken.getAllIps():
if not addr:
continue
try:
flags.union(self.geoIp.getFlags(addr))
except:
continue
return flags
def testGetProductStoreByLabel(self):
from rbuild_plugins import init
co = init.Init('init', None, None)
co.setHandle(mock.MockObject())
returnTuple = ('product-definition:source',
VFS('/foo.rpath.org@rpl:proddef-1/1.0-1'), deps.Flavor())
co.handle.facade.conary._findTrove._mock.setReturn(returnTuple,
'product-definition:source',
'foo.rpath.org@rpl:proddef-1')
assert(co.getProductVersionByLabel('foo.rpath.org@rpl:proddef-1')
== '/foo.rpath.org@rpl:proddef-1/1.0-1')
def getCrossCompileSettings(flavor):
flavorTargetSet = flavor.getDepClasses().get(deps.DEP_CLASS_TARGET_IS,
None)
if flavorTargetSet is None:
return None
targetFlavor = deps.Flavor()
for insSet in flavorTargetSet.getDeps():
targetFlavor.addDep(deps.InstructionSetDependency, insSet)
isCrossTool = flavor.stronglySatisfies(crossFlavor)
return None, targetFlavor, isCrossTool
def getBuiltFlavor(flavor):
if not hasTarget(flavor):
majorArch = getTargetArch(flavor)[1]
if majorArch:
f = deps.Flavor()
f.addDep(deps.InstructionSetDependency, deps.Dependency(majorArch))
flavor = deps.overrideFlavor(flavor, f)
return flavor
if flavor.stronglySatisfies(crossFlavor):
return flavor
return setISFromTargetFlavor(flavor)
def testNextVersionMultipleBranchesWithDepth(self):
# this has depth 3, but the trove we're building has depth 2.
# so we can't consider it the "latest" and just increment its source
# count.
self.addCollection('foo=/localhost@rpl:1//2//3/2:1-2-0.0.1', [':run'])
repos = self.openRepository()
sourceList = [(VFS('/localhost@rpl:2//3/1-2'), ['foo'], deps.Flavor())]
nextVersions = nextversion.nextVersions(repos, self.openDatabase(),
sourceList)
assert(nextVersions == [VFS('/localhost@rpl:2//3/1-2-0.1')])
def getId(self, flavorId):
if flavorId == 0:
return deps.Flavor()
cu = self.db.cursor()
cu.execute("SELECT flavor FROM Flavors WHERE flavorId = ?",
flavorId)
try:
return deps.ThawFlavor(cu.next()[0])
except StopIteration:
raise KeyError, flavorId
def createSourceTrove(self,
name,
label,
upstreamVersion,
pathDict,
changeLog,
factory=None,
pkgCreatorData=None,
metadata=None):
"""
Create a source trove.
@param name: trove name of source components.
@type name: str
@param label: trove label
@type label: str
@param upstreamVersion: upstream version of source component
@type upstreamVersion: str
@param pathDict: Dictionary mapping path strings to
conaryclient.filetypes._File objects, which represent the contents
of each file
@type pathDict: dict(str: conaryclient.filetypes._File)
@param changeLog: Change log associated with this source trove.
@type changeLog: changelog.ChangeLog
@param factory: designate a factory associated with this source
trove.
@type factory: str
@param pkgCreatorData: arbitrary string set in
_TROVEINFO_TAG_PKGCREATORDATA
@type pkgCreatorData: str
@param metadata: additional metadata to be attached to the source
trove
@type metadata: dict
"""
if not name.endswith(':source'):
raise RuntimeError('Only source components allowed')
versionStr = '/%s/%s-1' % (label, upstreamVersion)
version = versions.VersionFromString(versionStr).copy()
version.resetTimeStamps()
troveObj = trove.Trove(name,
version,
deps.Flavor(),
changeLog=changeLog)
troveObj.setFactory(factory)
if pkgCreatorData:
troveObj.troveInfo.pkgCreatorData.set(pkgCreatorData)
if metadata:
mi = trove.MetadataItem()
for k, v in metadata.iteritems():
mi.keyValue[k] = v
troveObj.troveInfo.metadata.addItem(mi)
return self._createTroves([(troveObj, pathDict)])
def getAlternateFlavorMessage(query):
"""
Returns a message that describes any available alternate flavors
that could be passed in to return a query result.
"""
minimalMatches = []
archMinimalMatches = []
archPartialMatches = []
for searchQueue, alternateList in query.iterAlternatesByQueue():
if not alternateList:
continue
flavors = set([x[2] for x in itertools.chain(*searchQueue)])
for flavor in flavors:
if flavor is None:
flavor = deps.Flavor()
ISD = deps.InstructionSetDependency
archNames = set(x.name for x in flavor.iterDepsByClass(ISD))
for toMatchFlavor in alternateList:
minimalMatch = deps.getMinimalCompatibleChanges(flavor,
toMatchFlavor,
keepArch=True)
minimalMatches.append(minimalMatch)
matchArchNames = set(
x.name for x in toMatchFlavor.iterDepsByClass(ISD))
if not matchArchNames - archNames:
# if we don't have to change architectures to match
# this flavor, that's much better than the alternative.
archMinimalMatches.append(minimalMatch)
if matchArchNames & archNames:
archPartialMatches.append(minimalMatch)
if archMinimalMatches:
minimalMatches = archMinimalMatches
elif archPartialMatches:
minimalMatches = archPartialMatches
if minimalMatches:
minimalMatches = set(minimalMatches)
matchesByLength = sorted(
((_getFlavorLength(x), x) for x in minimalMatches),
key=lambda x: x[0])
shortestMatchLength = matchesByLength[0][0]
# only return the flavors that require the least amount of change
# to our current query.
minimalMatches = [
x[1] for x in matchesByLength if x[0] == shortestMatchLength
]
flavorStrs = '], ['.join([str(x) for x in sorted(minimalMatches)])
return ' (Closest alternate flavors found: [%s])' % flavorStrs
return ''
def testBreakOnUpdate(self):
# create a package which provides a file, then update that package to
# a version which does not provide that library while installing a
# package which requires that file. it should cause a dep failure.
self.resetRepository()
self.resetRoot()
(built, d) = self.buildRecipe(recipes.bashRecipe, "Bash")
bashVersion = built[0][1]
(built, d) = self.buildRecipe(recipes.bashMissingRecipe, "Bash")
noBashVersion = built[0][1]
(built, d) = self.buildRecipe(recipes.bashUserRecipe, "BashUser")
userVersion = built[0][1]
repos = self.openRepository()
# this changeset updates bash to a trove which removed /bin/bash
# and installs bashuser, which requies /bin/bash
cs = repos.createChangeSet([("bash",
(VersionFromString(bashVersion), deps.parseFlavor('ssl')),
(VersionFromString(noBashVersion), deps.parseFlavor('ssl')),
0),
("bashuser", (None, None),
(VersionFromString(userVersion),
deps.Flavor()),
0)
])
(fd, fileName) = tempfile.mkstemp()
os.close(fd)
cs.writeToFile(fileName)
try:
self.updatePkg(self.rootDir, 'bash', version = bashVersion)
(rc, s) = self.captureOutput(self.updatePkg, self.rootDir, fileName)
finally:
os.unlink(fileName)
expectedStr = """\
The following dependencies would not be met after this update:
bashuser:runtime=0-1-1 (Would be newly installed) requires:
file: /bin/bash
which is provided by:
bash:runtime=0-1-1 (Would be updated to 1-1-1)
"""
assert(s == expectedStr)
# since /bin/bash is still installed, this should work fine
self.updatePkg(self.rootDir, 'bashuser', version = bashVersion)
class CfgFlavor(CfgType):
default = deps.Flavor()
def copy(self, val):
return val.copy()
def parseString(self, val):
try:
f = deps.parseFlavor(val)
except Exception, e:
raise ParseError, e
if f is None:
raise ParseError, 'Invalid flavor %s' % val
return f
def _addUnownedNewFiles(self, newFileList):
if not newFileList: return
cs = changeset.ChangeSet()
ver = versions.VersionFromString(
'/localhost@local:LOCAL/1.0-1-1').copy()
ver.resetTimeStamps()
trv = trove.Trove("@new:files", ver, deps.Flavor())
for path in newFileList:
self._addFile(cs, trv, path)
trvDiff = trv.diff(None, absolute=False)[0]
cs.newTrove(trvDiff)
self._handleChangeSet([trv.getNameVersionFlavor()], cs)