def _convertLabelOrBranch(lblStr, template):
try:
if not lblStr:
return None
if lblStr[0] == '/':
v = versions.VersionFromString(lblStr)
if isinstance(v, versions.Branch):
return v
# Some day we could lift this restriction if its useful.
raise errors.ParseError('Cannot specify version to promote'
' - must specify branch or label')
if not template:
return versions.Label(lblStr)
hostName = template.getHost()
nameSpace = template.getNamespace()
tag = template.branch
if lblStr[0] == ':':
lblStr = '%s@%s%s' % (hostName, nameSpace, lblStr)
elif lblStr[0] == '@':
lblStr = '%s%s' % (hostName, lblStr)
elif lblStr[-1] == '@':
lblStr = '%s%s:%s' % (lblStr, nameSpace, tag)
return versions.Label(lblStr)
except Exception, msg:
raise errors.ParseError('Error parsing %r: %s' % (lblStr, msg))
def testFindTrovesPrefersBuiltTroves(self):
self.openRmakeRepository()
depStr = 'soname: ELF32/foo.so.1(SysV)'
builtFooRun = self.addComponent('foo:runtime',
'/localhost@rpl:linux//branch//rmakehost@rpl:branch/1.0',
'is:x86')
fooRun = self.addComponent('foo:runtime', '1.0', 'is:x86')
trv = self.addComponent('bam:source')
bt = self.newBuildTrove(1, *trv.getNameVersionFlavor())
bt.setBuildRequirements(['foo:runtime'])
self.buildCfg.installLabelPath = [
versions.Label('localhost@rpl:branch'),
versions.Label('localhost@rpl:linux') ]
builtTroves = [builtFooRun.getNameVersionFlavor()]
resolveTroves = [ fooRun.getNameVersionFlavor()]
resolveJob = dephandler.ResolveJob(bt, self.buildCfg, builtTroves)
self.logFilter.add()
res = resolver.DependencyResolver(log, self.openRepository())
self.buildCfg.resolveTroveTups = [resolveTroves]
self.buildCfg.resolveTrovesOnly = False
result = res.resolve(resolveJob)
assert(result.success)
buildReq, = result.getBuildReqs()
assert(str(buildReq[2][0].trailingLabel()) == 'rmakehost@rpl:branch')
def testChangedRecipeCook(self):
repos = self.openRepository()
self.openRmakeRepository()
trv = self.addComponent(
'test1:source=/localhost@rpl:linux//rmakehost@LOCAL:linux/1.2-0.1',
[('test1.recipe', test1Recipe)])
cookFlavor = deps.parseFlavor('readline,ssl,X')
troveTup = trv.getNameVersionFlavor()
troveTup = (troveTup[0], troveTup[1], cookFlavor)
targetLabel = versions.Label('rmakehost@LOCAL:linux')
newTargetLabel = versions.Label('rmakehost@LOCAL:linux')
# adding an unknown flavor shouldn't matter with latest conary.
self.cfg.buildFlavor = deps.overrideFlavor(self.cfg.buildFlavor,
deps.parseFlavor('foobar'))
logger_ = logger.Logger()
logPath, pid, buildInfo = self.discardOutput(cook.cookTrove,
self.cfg,
repos,
logger_,
targetLabel=targetLabel,
*troveTup)
result = self._wait(buildInfo)
assert (result.isBuildSuccess())
def testCook(self):
repos = self.openRepository()
self.makeSourceTrove('test1', test1Recipe)
cookFlavor = deps.parseFlavor('readline,ssl,X')
troveTup = repos.findTrove(self.cfg.buildLabel,
('test1:source', None, None), None)[0]
troveTup = (troveTup[0], troveTup[1], cookFlavor)
targetLabel = versions.Label('localhost@LOCAL:linux')
newTargetLabel = versions.Label('localhost@LOCAL:linux')
# adding an unknown flavor shouldn't matter with latest conary.
self.cfg.buildFlavor = deps.overrideFlavor(self.cfg.buildFlavor,
deps.parseFlavor('foobar'))
logger_ = logger.Logger()
logPath, pid, buildInfo = self.discardOutput(cook.cookTrove,
self.cfg,
repos,
logger_,
targetLabel=targetLabel,
*troveTup)
result = self._wait(buildInfo)
assert (result.isBuildSuccess())
repos.commitChangeSetFile(result.getChangeSetFile())
troveTup = repos.findTrove(
newTargetLabel, ('test1', None, deps.parseFlavor('readline,ssl')),
None)[0]
assert (troveTup[1].branch().label() == newTargetLabel)
assert (str(troveTup[2]) == 'readline,ssl')
self.updatePkg('test1=%s[readline,ssl]' % newTargetLabel,
raiseError=True)
self.verifyFile(self.rootDir + '/foo/bar',
str(self.cfg.buildLabel) + '\n')
def testLoadedTroves(self):
# we don't check the output of this test.
self.logFilter.add()
repos = self.openRepository()
header = '''
if Use.%s:
foo = '1.0-readline'
else:
foo = '1.0-noreadline'
'''
self.addTestPkg(1, version='1.0', header=header % 'readline')
self.addTestPkg(2, header='loadRecipe("test1")' + header % 'ssl')
test3Recipe = self.addTestPkg(3,
header='loadRecipe("test2")' +
header % 'bootstrap')
use.track()
rldep = deps.parseFlavor('readline')
ssldep = deps.parseFlavor('ssl')
nobsdep = deps.parseFlavor('~!bootstrap')
v1 = versions.VersionFromString('/localhost@rpl:linux/1.0-1')
loader = self._testSubload(repos, "loadInstalled('test3')")
FooLoaded = loader.getLoadedSpecs()
assert (FooLoaded['test3'][0] == ('test3:source', v1, nobsdep))
Test3Loaded = FooLoaded['test3'][1]
assert (Test3Loaded['test2'][0] == ('test2:source', v1, ssldep))
Test2Loaded = Test3Loaded['test2'][1]
assert (Test2Loaded['test1'][0] == ('test1:source', v1, rldep))
Test1Loaded = Test2Loaded['test1'][1]
assert (Test1Loaded == {})
loadedTroves = loader.getLoadedTroves()
assert (len(loadedTroves) == 3)
assert (loadedTroves[0] == ('test1:source', v1, rldep))
assert (loadedTroves[1] == ('test2:source', v1, ssldep))
assert (loadedTroves[2] == ('test3:source', v1, nobsdep))
# 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)
cfg.installLabelPath = [versions.Label('localhost@rpl:foo')]
cfg.buildLabel = versions.Label('localhost@rpl:foo')
self.overrideBuildFlavor('!readline, !ssl')
overrides = oldLoadedSpecs
loader = self._testSubload(repos,
"loadInstalled('test3')",
cfg=cfg,
overrides=overrides)
assert (loadedTroves[0] == ('test1:source', v1, rldep))
assert (loadedTroves[1] == ('test2:source', v1, ssldep))
assert (loadedTroves[2] == ('test3:source', v1, nobsdep))
def testIncludeConfigFileNoLoop(self):
# CNY-914: including the same file in two contexts
fd, configfile = tempfile.mkstemp()
fd1, configfile1 = tempfile.mkstemp()
fd2, configfile2 = tempfile.mkstemp()
fd3, configfile3 = tempfile.mkstemp()
f = os.fdopen(fd, "w+")
f1 = os.fdopen(fd1, "w+")
f2 = os.fdopen(fd2, "w+")
f3 = os.fdopen(fd3, "w+")
f.write("includeConfigFile %s\n" % configfile1)
f.write("includeConfigFile %s\n" % configfile2)
f1.write("[sect1]\n")
f1.write("buildLabel c.example.com@foo:1\n")
f1.write("includeConfigFile %s\n" % configfile3)
f2.write("[sect2]\n")
f2.write("buildLabel c.example.com@foo:2\n")
f2.write("includeConfigFile %s\n" % configfile3)
f3.write("lookaside /tmp/foobar\n")
for fobj in (f, f1, f2, f3):
fobj.close()
cfg = conarycfg.ConaryConfiguration(readConfigFiles=False)
cfg.read(configfile)
expected = {
'sect1': {
'buildLabel': versions.Label('c.example.com@foo:1'),
'lookaside': '/tmp/foobar',
},
'sect2': {
'buildLabel': versions.Label('c.example.com@foo:2'),
'lookaside': '/tmp/foobar',
}
}
for sectName in cfg.iterSectionNames():
self.assertTrue(sectName in expected)
sect = cfg.getSection(sectName)
expSect = expected[sectName]
for k in ['buildLabel', 'lookaside']:
self.assertEqual(sect[k], expSect[k])
del expected[sectName]
# More sections?
self.assertFalse(expected)
for cf in [configfile, configfile1, configfile2, configfile3]:
os.unlink(cf)
def _convertLabelPath(self, name, labelPath, versionStr):
"""
Given a label path and a versionString that modifies it,
return the modified labelPath.
"""
newLabelPath = []
if '/' in versionStr:
labelPart, remainder = versionStr.split('/', 1)
else:
labelPart, remainder = versionStr, ''
firstChar = labelPart[0]
repoInfo = [(x.getHost(), x.getNamespace(), x.getLabel())
for x in labelPath]
if firstChar == ':':
for serverName, namespace, tag in repoInfo:
newLabelPath.append(
versions.Label("%s@%s%s" %
(serverName, namespace, labelPart)))
elif firstChar == '@':
for serverName, namespace, tag in repoInfo:
newLabelPath.append(
versions.Label("%s%s" % (serverName, labelPart)))
elif labelPart[-1] == '@':
for serverName, namespace, tag in repoInfo:
newLabelPath.append(
versions.Label("%s%s:%s" % (labelPart, namespace, tag)))
elif '@' in labelPart:
try:
label = versions.Label(labelPart)
newLabelPath = [label]
except errors.ParseError:
raise errors.TroveNotFound, \
"invalid version %s" % versionStr
else:
# no labelPath parts in versionStr, use the old one.
newLabelPath = labelPath
remainder = versionStr
if not newLabelPath and not self.queryOptions.allowNoLabel and not self.queryOptions.allowMissing:
raise errors.LabelPathNeeded(
"No search label path given and no label specified for trove %s=%s - set the installLabelPath"
% (name, versionStr))
if not newLabelPath and not self.queryOptions.allowNoLabel and not self.queryOptions.allowMissing:
raise errors.LabelPathNeeded(
"No search label path given and partial label specified for trove %s=%s - set the installLabelPath"
% (name, versionStr))
if isinstance(labelPath, set):
newLabelPath = set(newLabelPath)
if '-' in remainder:
# attempt to parse the versionStr
try:
versions.Revision(remainder)
except errors.ParseError, err:
raise errors.TroveNotFound(str(err))
def testGetTrovesLeavesMultiRepos(self):
v1 = self.addComponent('foo:foo', '1.0').getVersion()
v2 = self.addComponent('foo:foo', ':branch/1.0').getVersion()
installLabelPath = conarycfg.CfgLabelList(
[versions.Label('localhost@rpl:branch'), self.cfg.buildLabel])
repos = self.openRepository()
tups = queryrep.getTrovesToDisplay(repos, [], [], [],
VERSION_FILTER_LEAVES,
FLAVOR_FILTER_ALL,
installLabelPath,
self.cfg.flavor,
affinityDb=None)
assert (set([x[1] for x in tups]) == set((v1, v2)))
tups = queryrep.getTrovesToDisplay(repos, ['foo:foo'], [], [],
VERSION_FILTER_LEAVES,
FLAVOR_FILTER_ALL,
installLabelPath,
self.cfg.flavor,
affinityDb=None)
assert (set([x[1] for x in tups]) == set((v1, v2)))
tups = queryrep.getTrovesToDisplay(repos, ['foo:foo'], [], [],
VERSION_FILTER_LATEST,
FLAVOR_FILTER_ALL,
installLabelPath,
self.cfg.flavor,
affinityDb=None)
assert (set([x[1] for x in tups]) == set((v1, v2)))
tups = queryrep.getTrovesToDisplay(repos, [], [], [],
VERSION_FILTER_LATEST,
FLAVOR_FILTER_ALL,
installLabelPath,
self.cfg.flavor,
affinityDb=None)
assert (set([x[1] for x in tups]) == set((v1, v2)))
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 testNetworkSearchSource(self):
repos = self.openRepository()
trv1 = self.addComponent('foo:runtime', '1', 'ssl')
trv2 = self.addComponent('foo:runtime', '2', '!ssl')
s = searchsource.NetworkSearchSource(repos, self.cfg.installLabelPath,
parseFlavor('ssl'))
tup = s.findTrove(('foo:runtime', None, None))[0]
assert(tup == trv1.getNameVersionFlavor())
tup = s.findTrove(('foo:runtime', None, parseFlavor('!ssl')))[0]
assert(tup == trv2.getNameVersionFlavor())
trv = s.getTrove(*tup)
assert(trv == trv2)
cs = s.createChangeSet([(tup[0], (None, None), (tup[1], tup[2]), True)])
trvCs = cs.getNewTroveVersion(*trv.getNameVersionFlavor())
trv = trove.Trove(trvCs)
assert(trv == trv2)
assert(list(s.iterFilesInTrove(*trv.getNameVersionFlavor()))
== list(repos.iterFilesInTrove(*trv.getNameVersionFlavor())))
# test dep resolution - the resolve source for this should check
# the right branch.
self.cfg.installLabelPath = [versions.Label('localhost@rpl:branch')]
self.addComponent('bar:runtime', ':branch/1', filePrimer=1,
requires='trove:foo:runtime')
self.checkUpdate('bar:runtime', ['bar:runtime', 'foo:runtime=1'],
resolveSource=s.getResolveMethod(), resolve=True)
def testFakeChroot(self):
groupRecipe = """
class SimpleGroup(GroupRecipe):
name = 'group-foo'
version = '1'
clearBuildReqs()
def setup(r):
r.add('foo:lib')
"""
trv = self.addComponent('group-foo:source=1',
[('group-foo.recipe', groupRecipe)])
self.addComponent('foo:lib')
mgr = rootmanager.ChrootManager(self.rmakeCfg)
trv = self.newBuildTrove(1, *trv.getNameVersionFlavor())
factory = mgr.getRootFactory(self.buildCfg, [], [], [], trv)
factory.create()
logFile = logfile.LogFile(self.workDir + '/rmake.out')
logFile.redirectOutput()
chroot = factory.start()
try:
chroot.buildTrove(self.buildCfg, versions.Label('localhost@rpl:branch'),
*trv.getNameVersionFlavor())
results = chroot.checkResults(wait=30, *trv.getNameVersionFlavor())
assert(results.isBuildSuccess())
finally:
chroot.stop()
factory.clean()
assert(factory.root != '/tmp/rmake')
assert(not os.path.exists('/tmp/rmake/builds/group-foo'))
def testCookTwoGroups(self):
self.addComponent('test:run', '1', '!ssl,~test.foo')
self.addComponent('test:run', '1', 'ssl,~test.foo')
trv = self.addComponent('group-foo:source', '1', '',
[('group-foo.recipe', groupRecipeWithFlags)])
flavorList = [deps.parseFlavor('!ssl'), deps.parseFlavor('ssl')]
repos = self.openRepository()
logger_ = logger.Logger()
targetLabel = versions.Label('localhost@rpl:TARGET')
self.cfg.shortenGroupFlavors = True
logPath, pid, buildInfo = self.discardOutput(cook.cookTrove,
self.cfg,
repos,
logger_,
trv.getName(),
trv.getVersion(),
flavorList,
targetLabel=targetLabel)
result = self._wait(buildInfo)
assert (result.isBuildSuccess())
cs = changeset.ChangeSetFromFile(result.getChangeSetFile())
newTroves = [
x.getNewNameVersionFlavor() for x in cs.iterNewTroveList()
]
assert (len(set([x[1] for x in newTroves])))
flavorList = set([x[2] for x in newTroves])
self.assertEquals(sorted(str(x) for x in flavorList),
['readline,!ssl', 'ssl'])
def testDefaultBuildReqs(self):
# add a defautl build req on foo:run and make sure that it shows
# up in the build requirements for the finishehd trove.
repos = self.openRepository()
self.cfg.defaultBuildReqs = ['foo:run']
foo = self.addComponent('foo:run', '1')
self.updatePkg('foo:run')
test1 = self.addComponent('test1:source', '1',
[('test1.recipe', test1Recipe)])
troveTup = test1.getNameVersionFlavor()
targetLabel = versions.Label('localhost@LOCAL:linux')
logger_ = logger.Logger()
logPath, pid, buildInfo = self.discardOutput(
cook.cookTrove,
self.cfg,
repos,
logger_,
targetLabel=self.cfg.buildLabel,
*troveTup)
result = self._wait(buildInfo)
assert (result.isBuildSuccess())
repos = self.openRepository()
repos.commitChangeSetFile(result.getChangeSetFile())
troveTup = repos.findTrove(self.cfg.buildLabel, ('test1', None, None),
None)[0]
test1 = repos.getTrove(*troveTup)
assert (test1.getBuildRequirements() == [foo.getNameVersionFlavor()])
def testDuplicateFileIds(self):
# make sure that streams get filled in on branches when they were
# originally None
os.chdir(self.workDir)
self.newpkg('branchedFileId')
os.chdir('branchedFileId')
self.writeFile('branchedFileId.recipe', recipes.branchedFileIdTest1)
self.addfile('branchedFileId.recipe')
self.commit()
os.chdir("..")
shutil.rmtree('branchedFileId')
repos0 = self.openRepository(0)
repos1 = self.openRepository(1)
self.cookItem(repos0, self.cfg, 'branchedFileId')
self.mkbranch("1.0-1-1", "localhost1@rpl:shadow",
"branchedFileId", shadow = True)
self.checkout("branchedFileId", "localhost1@rpl:shadow")
os.chdir('branchedFileId')
self.writeFile('branchedFileId.recipe', recipes.branchedFileIdTest2)
self.commit()
self.cfg.buildLabel = versions.Label("localhost1@rpl:shadow")
self.cookItem(repos1, self.cfg, 'branchedFileId')
self.updatePkg(self.cfg.root,
'branchedFileId', 'localhost1@rpl:shadow')
def testUseOwnDb(self):
# We can pass our own database to loadInstalled to cause its behavior
# to differ from the original expected behavior a bit.
# rMake uses this to fiddle w/ the troves that match a hostname/label
# request.
repos = self.openRepository()
cfg = copy.copy(self.cfg)
branch = versions.VersionFromString('/localhost@rpl:devel//shadow/')
db = trovesource.SimpleTroveSource()
self.addTestPkg(1, version='1.0')
test2Recipe = recipes.createRecipe(2,
version='1.0',
header='loadInstalled("test1")')
cfg.buildLabel = versions.Label('localhost@rpl:branch')
cfg.installLabelPath = [cfg.buildLabel]
self.addComponent('test2:source', '/localhost@rpl:branch/1.0',
[('test2.recipe', test2Recipe)])
try:
loader = self._testSubload(repos,
"loadSuperClass('test2')",
cfg=cfg,
branch=branch)
assert (0)
except Exception, err:
assert (str(err).find('cannot find source component test1:source:')
!= -1)
pass
def testFollowBranch(self):
troveVersion = self.repo.findTrove(self.cfg.buildLabel,
("testcase:source", None, None),
self.cfg.flavor)[0][1]
branch = troveVersion.branch()
self.mkbranch(self.cfg.buildLabel, "@rpl:branch1", "testcase:source")
self.repo.updateMetadataFromXML('testcase:source', branch, testXML)
newLabel = versions.Label("localhost@rpl:branch1")
troveVersion = self.repo.findTrove(newLabel,
("testcase:source", None, None),
self.cfg.flavor)[0][1]
branch1 = troveVersion.branch()
metadata = self.repo.getMetadata(["testcase:source", branch1],
newLabel)
metadata = metadata["testcase:source"]
assert (metadata.getShortDesc() == "A metadata testcase.")
assert (metadata.getLongDesc() == "Just a testcase for the metadata.")
assert (metadata.getSource() == "testsource")
assert (metadata.getLanguage() == "C")
assert (metadata.getUrls() == ["http://url1/"])
assert (metadata.getLicenses() == ["GPL"])
assert (metadata.getCategories() == [
"Test Category", "Test Category 2"
])
def testConfigLabelList(self):
defaultLabel = versions.Label('conary.rpath.com@rpl:devel')
localLabel = versions.Label('localhost@rpl:devel')
class TestCfgFile(ConfigFile):
foo = (CfgList(CfgLabel), [defaultLabel])
cfg = TestCfgFile()
assert(cfg.foo == [defaultLabel])
cfg.configLine('foo localhost@rpl:devel')
assert(cfg.foo == [localLabel])
cfg.configLine('foo conary.rpath.com@rpl:devel')
assert(cfg.foo == [localLabel, defaultLabel])
lines = self._getDisplayLines(cfg)
assert(lines == ['foo localhost@rpl:devel',
'foo conary.rpath.com@rpl:devel'])
def testRedirectSwitchesBranchNotName(self):
# when a redirect switches branches but not name, we don't
# need to remove it from the job as an erase
self.addComponent('redirect:runtime', '1.0') # target of redirect
self.addCollection('redirect', '1.0', [':runtime'])
# target of redirect
# source of redirect
redirectBranch = '/localhost@rpl:branch' % self.cfg.buildLabel
self.addComponent('redirect:runtime', '%s/1.0' % redirectBranch)
self.addCollection('redirect', '%s/1.0' % redirectBranch, [':runtime'])
# actual redirect = redirect=:branch -> redirect=:linux
oldBuildLabel = self.cfg.buildLabel
self.cfg.buildLabel = versions.Label('localhost@rpl:branch')
tst = self.buildRecipe(redirectBranchRecipe, "testRedirect")
self.cfg.buildLabel = oldBuildLabel
self.updatePkg('redirect=:branch/1.0')
self.checkUpdate(
['redirect'],
['redirect=:branch--:linux', 'redirect:runtime=:branch--:linux'])
self.addCollection('group-redirect', '1.0', ['redirect'])
self.updatePkg('group-redirect', recurse=False)
self.checkUpdate(
['redirect'],
['redirect=:branch--:linux', 'redirect:runtime=:branch--:linux'])
def testLoadInstalledInRoot(self):
# make sure that we find this autoconf213 trove even though it's
# been built. (RMK-371)
self.openRepository()
repos = self.openRmakeRepository()
sourceV = VFS('/localhost@rpl:1//autoconf213/2.13-1.1')
binV = sourceV.createShadow(versions.Label('rmakehost@rpl:1'))
binV.incrementBuildCount()
loadInstalledRecipe = fixtures.loadInstalledRecipe.replace(
"loadInstalled('loaded')",
"loadInstalled('loaded=:autoconf213')")
self.addComponent('loaded:runtime', str(binV))
trv = self.addCollection('loaded', str(binV), [':runtime'])
self.updatePkg('loaded=rmakehost@rpl:1')
self.addComponent('loaded:source', str(sourceV),
[('loaded.recipe',
fixtures.loadedRecipe.replace('@@', '2.13'))])
trv = self.addComponent('loadinstalled:source', '1',
[('loadinstalled.recipe', loadInstalledRecipe)])
n,v,f = trv.getNameVersionFlavor()
db = self.openDatabase()
source = recipeutil.RemoveHostSource(db, 'rmakehost')
(loader, recipeClass, localFlags, usedFlags) = \
recipeutil.loadRecipeClass(repos, n, v, f,
ignoreInstalled=False,
root=self.cfg.root,
loadInstalledSource=source)
assert(recipeClass.loadedVersion == '2.13')
def doCommit(cfg, changeSetFile, targetLabel):
client = conaryclient.ConaryClient(cfg)
repos = client.getRepos()
callback = CheckinCallback()
try:
cs = changeset.ChangeSetFromFile(changeSetFile)
except filecontainer.BadContainer:
log.error("invalid changeset %s", changeSetFile)
return 1
if cs.isLocal():
if not targetLabel:
log.error("committing local changesets requires a targetLabel")
label = versions.Label(targetLabel)
cs.setTargetShadow(repos, label)
commitCs = cs.makeAbsolute(repos)
(fd, changeSetFile) = tempfile.mkstemp()
os.close(fd)
commitCs.writeToFile(changeSetFile)
try:
# hopefully the file hasn't changed underneath us since we
# did the check at the top of doCommit(). We should probably
# add commitChangeSet method that takes a fd.
try:
repos.commitChangeSetFile(changeSetFile, callback=callback)
except errors.CommitError, e:
print e
finally:
if targetLabel:
os.unlink(changeSetFile)
def testRedirectFromTrove(self):
self.addComponent('test:runtime', '1.0')
self.addComponent('test-foo:runtime', '1.0')
self.addCollection('test', '1.0', [':runtime'])
self.addCollection('test-foo', '1.0', [':runtime'])
redirectBranch = '/%s//branch' % self.cfg.buildLabel
self.addComponent('redirect:runtime', '%s/0.1' % redirectBranch)
self.addComponent('redirect-foo:runtime', '%s/0.1' % redirectBranch)
self.addCollection('redirect', '%s/0.1' % redirectBranch, [':runtime'])
self.addCollection('redirect-foo', '%s/0.1' % redirectBranch,
[':runtime'])
v1 = versions.VersionFromString('/%s//branch/1.0-1' %
self.cfg.buildLabel)
built, d = self.buildRecipe(redirectWithPkgRecipe,
"testRedirectWithPkg",
sourceVersion=v1)
self.checkUpdate(['redirect=:branch', 'redirect-foo=:branch'], [
'test=--1.0', 'test:runtime=--1.0', 'test-foo=--1.0',
'test-foo:runtime=--1.0'
])
# make sure you can't shadow a redirect
try:
self.mkbranch("/localhost@rpl:linux//branch/1.0-1-0.1",
versions.Label("localhost@foo:bar"),
"redirect",
shadow=True)
except conary.errors.ShadowRedirect, e:
assert (
str(e) ==
'cannot create a shadow of redirect=/localhost@rpl:linux//branch/1.0-1-0.1[] because it is a redirect'
)
def __init__(self, cfg):
self.name = 'group-dummy'
self.version = '1.0'
repos = DummyRepos()
grouprecipe.GroupRecipe.__init__(self, repos, cfg,
versions.Label('a@b:c'), None, None)
self.loadPolicy()
def getPackagesFromLabel(cfg, cli, label):
'''
Return a set of (name, version, flavor) triples representing each
package on the specified I{label}.
'''
repos = cli.getRepos()
label = versions.Label(label)
#searchFlavor = (CfgFlavor, deps.parseFlavor('is: x86(~i486,~i586,~i686,~sse,~sse2)'))
searchFlavor = deps.parseFlavor('is: x86(~i486,~i586,~i686,~sse,~sse2)')
mapping = repos.getTroveLatestByLabel({'': {label: None}})
# Get a list of troves on that label
# {name: {version: [flavor, ...], ...}, ...}
ret = set()
for name, trove_versions in mapping.iteritems():
if ':' in name:
# Skip components
continue
latestVersion = max(trove_versions.iterkeys())
flavors = trove_versions[latestVersion]
for flavor in flavors:
#if flavor.satisfies(searchFlavor):
ret.add((name, latestVersion, flavor))
break
return ret
def __init__(self, cfg):
self.name = 'fileset'
self.version = '1.0'
repos = DummyRepos()
filesetrecipe.FilesetRecipe.__init__(self, repos, cfg,
versions.Label('a@b:c'), None, {})
self._policyMap = {}
def findAvailableTargetFlavors(self, repos):
if self.branchStr is None:
# redirect to nothing
return set()
if self.branchStr[0] == '/':
branch = versions.VersionFromString(self.branchStr)
if not isinstance(branch, versions.Branch):
raise builderrors.RecipeFileError, \
"Redirects must specify branches or labels, " \
"not versions"
log.info('redirecting to branches is deprecated; redirects must '
'be to labels')
matches = repos.getTroveLeavesByBranch(
{self.destName: {
branch: None
}})
else:
label = versions.Label(self.branchStr)
matches = repos.getTroveLatestByLabel(
{self.destName: {
label: None
}})
targetFlavors = set()
# Get the flavors and branch available on the target
for version, flavorList in matches.get(self.destName, {}).iteritems():
targetFlavors.update((version, x) for x in flavorList)
return targetFlavors
def createMirrorUser(self, repos, serverName="localhost"):
label = versions.Label("%s@foo:bar" % serverName)
self.addUserAndRole(repos, label, "mirror", "mirror")
repos.addAcl(label, "mirror", None, None, write=True, remove=True)
repos.setRoleIsAdmin(label, "mirror", True)
repos.setRoleCanMirror(label, "mirror", True)
# add a user without mirroring or admin access
self.addUserAndRole(repos, label, "nomirror", "nomirror")
repos.addAcl(label, "nomirror", None, None, write=True)
def _openRepository(self, idx, serverName="localhost"):
# this could be left open from a previoius testsuite running
label = versions.Label("%s@foo:bar" % serverName)
self.servers.stopServer(idx)
repo = self.openRepository(idx, serverName=[serverName])
self.resetRepository(idx)
self.addUserAndRole(repo, label, "user", "pass")
repo.addAcl(label, "user", None, None, write=True, remove=True)
return repo
def addTestCase2(self):
trv = self.addComponent('testcase2:source', '1', '',
[('testcase2.recipe', workingRecipe2 % {
'name': 'testcase2'
})])
v = trv.getVersion().copy()
v = v.createShadow(versions.Label('rmakehost@local:linux'))
v.incrementBuildCount()
builtComp = self.addComponent('testcase2:runtime', v, filePrimer=3)
builtColl = self.addCollection('testcase2', v, [':runtime'])
return trv, builtComp, builtColl
def testDerivePackage(self):
self.addComponent('simple:source=1-1',
[('simple.recipe', recipes.simpleRecipe)])
self.addComponent('simple:runtime=1-1-1', [('/foo', 'contents\n')])
self.addCollection('simple=1-1-1', [':runtime'])
self.addComponent('simple:source=1-2',
[('simple.recipe', recipes.simpleRecipe + '\n')])
derive.derive(self.openRepository(),
self.cfg,
versions.Label('localhost@rpl:branch'),
'simple=localhost@rpl:linux',
checkoutDir=self.workDir + '/foo',
extract=True)
recipe = open(self.workDir + '/foo/simple.recipe').read()
self.assertEquals(
recipe, """
class SimpleRecipe(DerivedPackageRecipe):
name = 'simple'
version = '1'
def setup(r):
'''
In this recipe, you can make modifications to the package.
Examples:
# This appliance has high-memory-use PHP scripts
r.Replace('memory_limit = 8M', 'memory_limit = 32M', '/etc/php.ini')
# This appliance uses PHP as a command interpreter but does
# not include a web server, so remove the file that creates
# a dependency on the web server
r.Remove('/etc/httpd/conf.d/php.conf')
# This appliance requires that a few binaries be replaced
# with binaries built from a custom archive that includes
# a Makefile that honors the DESTDIR variable for its
# install target.
r.addArchive('foo.tar.gz')
r.Make()
r.MakeInstall()
# This appliance requires an extra configuration file
r.Create('/etc/myconfigfile', contents='some data')
'''
""")
self.verifyFile(self.workDir + '/foo/_ROOT_/foo', 'contents\n')
self.verifyFile(self.workDir + '/foo/_OLD_ROOT_/foo', 'contents\n')
self.assertEquals(
sorted(os.listdir(os.path.join(self.workDir, 'foo'))),
sorted(['CONARY', '_ROOT_', 'simple.recipe', '_OLD_ROOT_']))
def testGetLabel(self):
_, facade = self.prep()
labelString = 'a@b:c'
labelObject = versions.Label(labelString)
assert facade._getLabel(labelString) == labelObject
assert facade._getLabel(labelObject) == labelObject
v1 = '/a@b:c'
v2 = '/b@c:d/%s' % v1
v3 = '%s/1.2.3-1-1' % v1
assert facade._getLabel(v1) == labelObject
assert facade._getLabel(v2) == labelObject
assert facade._getLabel(v3) == labelObject
