def testLocalLabelDeps(self):
csPath = self.workDir + '/foo.ccs'
csPath1 = self.workDir + '/foo1.ccs'
csPath2 = self.workDir + '/foo2.ccs'
self.addComponent('local:runtime',
'local@local:COOK',
changeSetFile=csPath)
self.addComponent('local:debug',
'local@local:COOK',
changeSetFile=csPath1)
pkg = self.addCollection('local=local@local:COOK',
[':runtime', (':debug', False)],
changeSetFile=csPath2)
cs = changeset.ChangeSetFromFile(csPath)
os.unlink(csPath)
cs.merge(changeset.ChangeSetFromFile(csPath1))
cs.merge(changeset.ChangeSetFromFile(csPath2))
cs.setPrimaryTroveList([pkg.getNameVersionFlavor()])
cs.writeToFile(csPath)
self.updatePkg(self.rootDir, csPath)
self.addComponent('foo:runtime=1.0', requires='trove: bar')
self.addCollection('foo=1.0', [':foo'])
self.assertRaises(update.DepResolutionFailure,
self._applyModel, [
'install local=%s' % pkg.getVersion(),
'install foo:runtime=%s' % self.cfg.buildLabel,
],
addSearchLabel=True)
def testVerifyToFile(self):
db = database.Database(self.rootDir, self.cfg.dbPath)
os.chdir(self.workDir)
user, group = self._getUserGroup()
self.addComponent('foo:runtime',
'1.0',
fileContents=[('/foo',
rephelp.RegularFile(owner=user,
group=group))])
self.updatePkg('foo:runtime')
s = verify.verify(['foo:runtime'],
db,
self.cfg,
changesetPath='foo.ccs')
cs = changeset.ChangeSetFromFile('foo.ccs')
assert (list(cs.iterNewTroveList()) == [])
f = open(self.rootDir + '/foo', "a")
f.write("mod")
f.close()
s = self.captureOutput(verify.verify, ['foo:runtime'],
db,
self.cfg,
changesetPath='foo.ccs')
assert (not s[1])
cs = changeset.ChangeSetFromFile('foo.ccs')
assert (list(cs.iterNewTroveList())[0].getName() == 'foo:runtime')
def testTwoChangeSetsWithSameTroveAndDiffConfig(self):
trv = self.addComponent('foo:run=1', [('/etc/config', 'v1\n')])
trv2 = self.addComponent('foo:run=2', [('/etc/config', 'v2\n')])
repos = self.openRepository()
csPath = self.workDir + '/foo.ccs'
csPath2 = self.workDir + '/foo.ccs'
self.changeset(repos, 'foo:run=1--2', csPath)
self.changeset(repos, 'foo:run=1--2', csPath2)
cs1 = changeset.ChangeSetFromFile(csPath)
cs2 = changeset.ChangeSetFromFile(csPath2)
self.updatePkg('foo:run=1')
db = self.openDatabase()
source = ChangesetFilesTroveSource(db)
source.addChangeSets([cs1, cs2], True)
n, v, f = trv.getNameVersionFlavor()
v2, f2 = trv2.getNameVersionFlavor()[1:]
# this used to traceback when there were two changesets that both
# provided the same trove in the same source, (if the changesets
# were relative and involved a config file)
newCs, remainder = source.createChangeSet([(n, (v, f),
(v2, f2), False)],
withFiles=True,
withFileContents=True,
useDatabase=True)
assert (not remainder)
def getChangeSets(self,
repos,
jobList,
withFiles=True,
withFileContents=True,
callback=None):
for job in jobList:
if job[1][0]:
raise CacheError('can only cache install,'
' not update changesets')
if job[3]:
raise CacheError('Cannot cache absolute changesets')
changesets = [None for x in jobList]
needed = []
for idx, job in enumerate(jobList):
csHash = str(
self.hashTrove(job[0], job[2][0], job[2][1], withFiles,
withFileContents))
if self.store.hasFile(csHash):
outFile = self.fileCache.open(self.store.hashToPath(csHash))
#outFile = self.store.openRawFile(csHash)
changesets[idx] = changeset.ChangeSetFromFile(outFile)
else:
needed.append((job, csHash, idx))
total = len(needed)
for idx, (job, csHash, csIndex) in enumerate(needed):
if callback:
callback.setChangesetHunk(idx + 1, total)
cs = repos.createChangeSet([job],
recurse=False,
callback=callback,
withFiles=withFiles,
withFileContents=withFileContents)
if self.readOnly:
changesets[csIndex] = cs
continue
hashPath = self.store.hashToPath(csHash)
self.store.makeDir(hashPath)
dirPath = os.path.dirname(hashPath)
fileName = os.path.basename(hashPath)
tmpFd, tmpName = tempfile.mkstemp(prefix=fileName, dir=dirPath)
os.close(tmpFd)
cs.writeToFile(tmpName)
del cs
# we could use this changeset, but
# cs.reset() is not necessarily reliable,
# so instead we re-read from disk
self.store.addFileFromTemp(csHash, tmpName)
outFile = self.fileCache.open(self.store.hashToPath(csHash))
#outFile = self.store.openRawFile(csHash)
changesets[csIndex] = changeset.ChangeSetFromFile(outFile)
return changesets
def doUpdate(cfg, changeSpecs, **kwargs):
callback = kwargs.get('callback', None)
if not callback:
callback = callbacks.UpdateCallback(trustThreshold=cfg.trustThreshold)
kwargs['callback'] = callback
else:
callback.setTrustThreshold(cfg.trustThreshold)
syncChildren = kwargs.get('syncChildren', False)
syncUpdate = kwargs.pop('syncUpdate', False)
restartInfo = kwargs.get('restartInfo', None)
if syncChildren or syncUpdate:
installMissing = True
else:
installMissing = False
kwargs['installMissing'] = installMissing
fromChangesets = []
for path in kwargs.pop('fromFiles', []):
cs = changeset.ChangeSetFromFile(path)
fromChangesets.append(cs)
kwargs['fromChangesets'] = fromChangesets
# Look for items which look like files in the applyList and convert
# them into fromChangesets w/ the primary sets
for item in changeSpecs[:]:
if os.access(item, os.R_OK):
try:
cs = changeset.ChangeSetFromFile(item)
except:
continue
fromChangesets.append(cs)
changeSpecs.remove(item)
for troveTuple in cs.getPrimaryTroveList():
changeSpecs.append(trovetup.TroveTuple(*troveTuple).asString())
if kwargs.get('restartInfo', None):
# We don't care about applyList, we will set it later
applyList = None
else:
keepExisting = kwargs.get('keepExisting')
updateByDefault = kwargs.get('updateByDefault', True)
applyList = cmdline.parseChangeList(changeSpecs,
keepExisting,
updateByDefault,
allowChangeSets=True)
_updateTroves(cfg, applyList, **kwargs)
# Clean up after ourselves
if restartInfo:
util.rmtree(restartInfo, ignore_errors=True)
def commitChangeSetFile(self, fName, mirror = False, callback = None,
hidden = False):
# this could be more efficient. it rewrites the trove every time,
# but it doesn't seem to be heavily used
cs = changeset.ChangeSetFromFile(fName)
self.commitChangeSet(cs, callback = callback, mirror = mirror,
hidden = hidden)
def testGroupChangeSet(self):
repos = self.openRepository()
os.chdir(self.workDir)
self.addQuickTestComponent('test:runtime',
'1.0',
fileContents=['/usr/run1'])
self.addQuickTestComponent('test:doc',
'1.0',
fileContents=['/usr/doc1'])
self.addQuickTestCollection('test', '1.0',
['test:runtime', 'test:doc'])
self.addQuickTestCollection('group-test', '1.0', ['test'])
self.changeset(repos, ['group-test'], 'group-test.ccs', recurse=False)
cs = changeset.ChangeSetFromFile('group-test.ccs')
rc, res = self.captureOutput(displayChangeSet, None, cs, [], self.cfg)
assert (res == 'group-test=1.0-1-1\n')
rc, res = self.captureOutput(displayChangeSet,
None,
cs, [],
self.cfg,
ls=True,
alwaysDisplayHeaders=True,
recurseRepos=True)
assert (res == '''\
group-test=1.0-1-1
test=1.0-1-1
test:doc=1.0-1-1
/usr/doc1
test:runtime=1.0-1-1
/usr/run1
''')
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 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 testBadChangeset(self):
csFile = self.workDir + '/foo.ccs'
try:
changeset.ChangeSetFromFile(csFile)
except errors.ConaryError, err:
assert (str(err) ==
"Error opening changeset '%s': No such file or directory" %
csFile)
def testBadChangeSet(self):
csPath = self.workDir + '/test.ccs'
open(csPath, "w").write("some junk")
try:
changeset.ChangeSetFromFile(csPath)
except errors.ConaryError, e:
assert(str(e) == 'File %s is not a valid conary changeset.' %
csPath)
def testLocalFactoryWithLocalRecipe(self):
os.chdir(self.workDir)
self.newpkg("foo", factory="test")
os.chdir("foo")
self.writeFile(
"factory-test.recipe", """
class TestFactory(Factory):
name = "factory-test"
version = "1.0"
def getRecipeClass(self):
class TestSubclass(PackageRecipe):
name = "testsubclass"
version = "1.0"
internalAbstractBaseClass = True
clearBuildReqs()
return TestSubclass
""")
self.writeFile(
"foo.recipe", """
# CNY-2813. importing log inside a recipe used to reset the loglevel
from conary.lib import log
class FooRecipe(FactoryRecipeClass):
name = "foo"
version = "1.1"
def setup(self):
self.Create("/etc/foo", "foo")
""")
self.addfile("foo.recipe")
repos = self.openRepository()
cstate = state.ConaryStateFromFile('CONARY')
level = log.getVerbosity()
try:
log.setVerbosity(log.INFO)
klass = logging.getLoggerClass()
self.discardOutput(cook.cookCommand, self.cfg, [cstate], False, {})
self.assertEquals(klass, logging.getLoggerClass())
finally:
log.setVerbosity(level)
ccs = changeset.ChangeSetFromFile(
os.path.join(self.workDir, 'foo', 'foo-1.1.ccs'))
trvs = [trove.Trove(x) for x in ccs.iterNewTroveList()]
trv = [x for x in trvs if x.getName() == 'foo:debuginfo'][0]
files = [x for x in trv.iterFileList() if \
x[1] == '/usr/src/debug/buildlogs/foo-1.1-log.bz2']
fileId, path, pathId, ver = files[0]
fileInfo, fileObj = ccs.getFileContents(fileId, pathId)
decomp = bz2.BZ2Decompressor()
data = decomp.decompress(fileObj.f.read())
self.assertFalse("+ Processing" not in data,
"build log data appears to be incomplete")
def doLocalCommit(db, changeSetFile):
cs = changeset.ChangeSetFromFile(changeSetFile)
if not cs.isLocal():
log.error("repository changesets must be applied with update instead")
else:
db.commitChangeSet(cs,
database.UpdateJob(db),
rollbackPhase=db.ROLLBACK_PHASE_LOCAL,
updateDatabase=False)
def testChangeSetFromFile(self):
# ensure that absolute changesets that are read from disk
# that contain config files write out changesets to a file
# that do not change the file type to a diff.
# set up a file with some contents
cont = self.workDir + '/contents'
f = open(cont, 'w')
f.write('hello, world!\n')
f.close()
pathId = sha1helper.md5FromString('0' * 32)
f = files.FileFromFilesystem(cont, pathId)
f.flags.isConfig(1)
# create an absolute changeset
cs = changeset.ChangeSet()
# add a pkg diff
v = versions.VersionFromString('/localhost@rpl:devel/1.0-1-1',
timeStamps=[1.000])
flavor = deps.parseFlavor('')
t = trove.Trove('test', v, flavor, None)
t.addFile(pathId, '/contents', v, f.fileId())
diff = t.diff(None, absolute=1)[0]
cs.newTrove(diff)
# add the file and file contents
cs.addFile(None, f.fileId(), f.freeze())
cs.addFileContents(pathId, f.fileId(), changeset.ChangedFileTypes.file,
filecontents.FromFilesystem(cont),
f.flags.isConfig())
# write out the changeset
cs.writeToFile(self.workDir + '/foo.ccs')
# read it back in
cs2 = changeset.ChangeSetFromFile(self.workDir + '/foo.ccs')
# write it out again (there was a bug where all config files
# became diffs)
cs2.writeToFile(self.workDir + '/bar.ccs')
# read it again
cs3 = changeset.ChangeSetFromFile(self.workDir + '/bar.ccs')
# verify that the file is a file, not a diff
ctype, contents = cs3.getFileContents(pathId, f.fileId())
assert (ctype == changeset.ChangedFileTypes.file)
def testEraseChangeSet(self):
db = database.Database(self.rootDir, self.cfg.dbPath)
self.repos = self.openRepository()
self.addTestPkg(1, content='r.Create("%(thisdocdir)s/README")')
self.cookTestPkg(1)
os.chdir(self.workDir)
cscmd.ChangeSetCommand(self.cfg, ['test1=1.0--'], 'test.ccs')
cs = changeset.ChangeSetFromFile('test.ccs')
rc, res = self.captureOutput(displayChangeSet, db, cs, ['test1=1.0'],
self.cfg)
assert (res == 'Erase test1=1.0-1-1\n')
def testChangeSetFromFileSetsFilename(self):
repos = self.openRepository()
self.addComponent('foo:run', '1')
self.addCollection('foo', '1', [':run'])
csname = os.path.join(self.workDir, "changeset-lazyFileCache.ccs")
self.changeset(repos, 'foo', csname)
self.assertTrue(os.path.exists(csname))
lfc = util.LazyFileCache()
cs = changeset.ChangeSetFromFile(lfc.open(csname))
self.assertEqual(cs.fileName, csname)
def testPerlReqs(self):
self.openRmakeRepository()
repos = self.openRepository()
trvname = "perl-dummy"
perl = self.addComponent('perl:lib', provides='perl: CGI perl: strict')
trv = self.makeSourceTrove(trvname, testPerlRecipe)
troveTup = repos.findTrove(self.cfg.buildLabel,
(trvname + ':source', None, None), None)[0]
cookFlavor = deps.parseFlavor('readline,ssl,X')
troveTup = (troveTup[0], troveTup[1], cookFlavor)
db = self.openRmakeDatabase()
job = self.newJob(troveTup)
buildTrove = buildtrove.BuildTrove(job.jobId, *troveTup)
buildTrove.setPublisher(job.getPublisher())
logFile = logfile.LogFile(self.workDir + '/chrootlog')
logFile.redirectOutput()
mgr, factory, cfg, client = self._createRoot([perl],
buildTrove,
start=True)
logPath = client.buildTrove(cfg, cfg.getTargetLabel(troveTup[1]),
*troveTup)
result = client.checkResults(wait=20, *troveTup)
client.stop()
logFile.restoreOutput()
assert (result)
assert (result.isBuildSuccess())
cs = changeset.ChangeSetFromFile(result.getChangeSetFile())
trvHash = {}
for trv in cs.iterNewTroveList():
trvHash[trv.getName()] = trv
# this also checks to make sure build logging is turned on
if len(trvHash) < 3:
raise RuntimeError('logging turned off!')
self.failUnless(trvname in trvHash)
self.failUnless(trvname + ':data' in trvHash)
self.failUnless(trvname + ':debuginfo' in trvHash)
trv = trvHash[trvname + ':data']
dps = [(d[0].tagName, d[1].getName())
for d in trv.getRequires().iterDeps()]
dps.sort()
self.failUnlessEqual(dps, [('perl', ('CGI', )),
('perl', ('strict', ))])
def _getChangeSet(path):
try:
cs = changeset.ChangeSetFromFile(path)
except BadContainer, msg:
# ensure that it is obvious that a file is being referenced
if path[0] not in './':
path = './' + path
log.error("'%s' is not a valid conary changeset: %s" % (path, msg))
# XXX sys.exit is gross
import sys
sys.exit(1)
def testUpdateNonRecursedCollectionFromChangeset(self):
self.addQuickTestComponent("test:runtime", '1.0')
self.addQuickTestCollection("test", '1.0', [':runtime'])
repos = self.openRepository()
path = self.workDir + '/test.ccs'
self.changeset(repos, ['test'], path, recurse=False)
cs = changeset.ChangeSetFromFile(path)
self.checkUpdate(['test'],
['test', 'test:runtime'],
fromChangesets=[cs])
def testRedirectToFile(self):
repos = self.openRepository()
os.chdir(self.workDir)
self.addComponent('redirect:runtime', '1.0')
self.addCollection('redirect', '1.0', [':runtime'])
self.addComponent('test:runtime', '1.0')
self.addCollection('test', '1.0', [':runtime'])
self.writeFile('redirect.recipe', redirectRecipe)
built, str = self.captureOutput(self.cookItem, repos, self.cfg,
'redirect.recipe')
cs = changeset.ChangeSetFromFile('redirect-1.0.ccs')
assert (len(cs.getPrimaryTroveList()) == 1)
def testCommitToFile(self):
self.openRepository()
self.openRmakeRepository()
jobId = fixtures.addBuiltJob1(self)
client = self.startRmakeServer()
helper = self.getRmakeHelper(client.uri)
changesetPath = self.workDir + '/commit.ccs'
rc, txt = self.captureOutput(helper.commitJob,
jobId,
writeToFile=changesetPath)
cs = changeset.ChangeSetFromFile(changesetPath)
for trvCs in cs.iterNewTroveList():
assert (trvCs.getNewVersion().getHost() == 'localhost')
def testVerifyAll(self):
os.chdir(self.workDir)
self.addComponent('foo:runtime', '1.0', fileContents=['/bin/b'])
self.addComponent('bar:lib', '1.0', fileContents=['/lib/l'])
self.addCollection('foo', [':runtime'])
self.addCollection('bar', [':lib'])
db = database.Database(self.rootDir, self.cfg.dbPath)
self.updatePkg('foo')
self.updatePkg('bar')
verify.verify([], db, self.cfg, all=True, changesetPath='foo.ccs')
cs = changeset.ChangeSetFromFile('foo.ccs')
assert (sorted([x.getName() for x in cs.iterNewTroveList()
]) == ['bar:lib', 'foo:runtime'])
def _cookPkgs(self,
recipestr,
filename,
pkgname,
builtpkgnames=None,
macros={},
updatePackage=False):
repos = self.openRepository()
recipename = pkgname + '.recipe'
ccsname = pkgname + '.ccs'
if builtpkgnames is None:
builtpkgnames = [pkgname]
origDir = os.getcwd()
try:
os.chdir(self.workDir)
if updatePackage:
self.checkout(pkgname)
else:
self.newpkg(pkgname)
os.chdir(pkgname)
self.writeFile(recipename, recipestr)
if not updatePackage:
self.addfile(recipename)
if isinstance(filename, types.StringType):
filenames = [filename]
else:
filenames = filename
for filename in filenames:
shutil.copyfile(resources.get_archive() + '/' + filename,
filename)
self.addfile(filename)
self.commit()
built, out = self.cookItem(repos, self.cfg, pkgname, macros=macros)
self.changeset(repos, builtpkgnames, ccsname)
cs = changeset.ChangeSetFromFile(ccsname)
finally:
os.chdir(origDir)
return (sorted([x.getName()
for x in cs.iterNewTroveList()]), built, cs)
def testNewFileOwnership(self):
# make sure files found with --new-files get assigned to the right
# troves
user, group = self._getUserGroup()
self.addComponent('foo:bin=0',
fileContents=[('/bin',
rephelp.Directory(
owner=user,
group=group,
))])
self.addComponent('foo:lib=1',
fileContents=[('/lib',
rephelp.Directory(
owner=user,
group=group,
))])
self.updatePkg(['foo:bin', 'foo:lib'])
db = self.openDatabase()
self.writeFile(self.rootDir + '/bin/new', 'newtext\n')
self.writeFile(self.rootDir + '/lib/new', 'newtext\n')
self.writeFile(self.rootDir + '/rootfile', 'newtext\n')
os.chdir(self.workDir)
verify.verify([],
db,
self.cfg,
all=True,
newFiles=True,
changesetPath='foo.ccs')
cs = changeset.ChangeSetFromFile('foo.ccs')
trvCsByName = dict((x.getName(), x) for x in cs.iterNewTroveList())
self.assertEquals(
[x[1] for x in trvCsByName['foo:bin'].getNewFileList()],
['/bin/new'])
self.assertEquals(
[x[1] for x in trvCsByName['foo:lib'].getNewFileList()],
['/lib/new'])
self.assertEquals(
[x[1] for x in trvCsByName['@new:files'].getNewFileList()],
['/rootfile'])
def testPartialChangeSet(self):
db = database.Database(self.rootDir, self.cfg.dbPath)
self.repos = self.openRepository()
self.addTestPkg(1, content='r.Create("%(thisdocdir)s/README")')
self.cookTestPkg(1)
self.cfg.configLine('excludeTroves .*:runtime')
os.chdir(self.workDir)
cscmd.ChangeSetCommand(self.cfg, ['test1'], 'test.ccs')
cs = changeset.ChangeSetFromFile('test.ccs')
rc, res = self.captureOutput(displayChangeSet,
None,
cs, ['test1=1.0-1-1'],
self.cfg,
showTroves=True)
assert (res == '''\
test1=1.0-1-1
test1:runtime=1.0-1-1
''')
def testReset(self):
class UncloseableFile(StringIO.StringIO):
def close(self):
assert(0)
# Make sure writing a changeset doesn't close the filecontent objects
# inside of it.
otherCs = changeset.ChangeSet()
otherCs.addFileContents("0pathId", "0fileId",
changeset.ChangedFileTypes.file,
filecontents.FromFile(UncloseableFile("foo")),
1)
otherCs.addFileContents("1pathId", "1fileId",
changeset.ChangedFileTypes.file,
filecontents.FromFile(UncloseableFile("foo")),
0)
otherCs.writeToFile(self.workDir + "/test1.ccs")
cs = changeset.ReadOnlyChangeSet()
cs.merge(otherCs)
cs.writeToFile(self.workDir + "/test2.ccs")
assert(open(self.workDir + "/test1.ccs").read() ==
(open(self.workDir + "/test2.ccs").read()))
cs.reset()
cs.writeToFile(self.workDir + "/test3.ccs")
assert(open(self.workDir + "/test1.ccs").read() ==
(open(self.workDir + "/test3.ccs").read()))
otherCs = changeset.ChangeSetFromFile(self.workDir + "/test1.ccs")
cs1 = changeset.ReadOnlyChangeSet()
cs1.merge(otherCs)
otherCs.reset()
cs2 = changeset.ReadOnlyChangeSet()
cs2.merge(otherCs)
assert([ x[0] for x in cs1.fileQueue ] ==
[ x[0] for x in cs2.fileQueue ])
assert(cs1.configCache == cs2.configCache)
def testCreateChangeSet(self):
self.addQuickTestComponent('test:runtime', '1.0-1-1')
self.addQuickTestCollection('test', '1.0-1-1', ['test:runtime'])
self.addQuickTestCollection('group-test', '1.0-1-1',
# byDefault = False
[('test', None, None, False)])
repos = self.openRepository()
csPath = self.workDir + '/group-test.ccs'
self.changeset(repos, ['group-test'], csPath)
# make sure x bit isn't set
assert(os.stat(csPath).st_mode & 0111 == 0)
cs = changeset.ChangeSetFromFile(csPath)
# make sure the byDefault False troves are not in the changeset.
assert(set([x.getName() for x in cs.iterNewTroveList()])
== set(['group-test']))
# make sure this changeset is installable
self.updatePkg(self.rootDir, [csPath])
def load(self, path):
assert (not self.cache and not self.depCache)
try:
cs = changeset.ChangeSetFromFile(path)
except filecontainer.BadContainer:
log.warning('trove cache %s was corrupt, ignoring' % path)
return
except (IOError, errors.ConaryError):
return
for trvCs in cs.iterNewTroveList():
trv = trove.Trove(trvCs, skipIntegrityChecks=True)
self.cache[trv.getNameVersionFlavor()] = trv
self._cached(self.cache.keys(), [x[1] for x in self.cache.values()])
try:
# NB: "fileid" and pathid got reversed here by mistake, try not to
# think too hard about it.
contType, depContents = cs.getFileContents(
self._fileId, self._troveCacheVersionPathId)
except KeyError:
self.version = (0, 0)
else:
versionList = depContents.get().read().split(' ')
self.version = (int(versionList[0]), int(versionList[1]))
if self.version[0] > self.VERSION[0]:
# major number is too big for us; we can't load this
return
# Timestamps must come first because some other caches use it to
# construct versions.
self._cs = cs
self._loadTimestamps()
self._loadDeps()
self._loadDepSolutions()
self._loadFileCache()
self._startingSizes = self._getSizeTuple()
self._cs = None
def testHashCheck(self):
# by default, we trust the size/date timestamps
repos = self.openRepository()
db = database.Database(self.rootDir, self.cfg.dbPath)
os.chdir(self.workDir)
user, group = self._getUserGroup()
trv = self.addComponent('foo:runtime',
fileContents=[
('/a',
rephelp.RegularFile(contents='1234',
owner=user,
group=group))
])
fileInfo = trv.iterFileList().next()
self.updatePkg('foo:runtime')
f = open(self.rootDir + '/a', "w")
f.write('abcd')
f.close()
f = repos.getFileVersions([(fileInfo[0], fileInfo[2], fileInfo[3])])[0]
st = os.stat(self.rootDir + '/a')
os.utime(self.rootDir + '/a', (f.inode.mtime(), f.inode.mtime()))
s = self.captureOutput(verify.verify, ['foo:runtime'],
db,
self.cfg,
changesetPath='foo.ccs')
assert (not s[1])
verify.verify(['foo:runtime'],
db,
self.cfg,
forceHashCheck=True,
changesetPath='foo.ccs')
cs = changeset.ChangeSetFromFile('foo.ccs')
assert (cs.files)
def testExactFlavor(self):
self.addComponent('foo:run[~ssl]')
repos = self.openRepository()
csPath = self.workDir + '/foo.ccs'
self.changeset(repos, ['foo:run'], csPath)
cs = changeset.ChangeSetFromFile(csPath)
self.assertRaises(errors.TroveNotFound,
displayChangeSet,
None,
cs, ['foo:run[ssl]'],
self.cfg,
exactFlavors=True)
self.assertRaises(errors.TroveNotFound,
displayChangeSet,
None,
cs, ['foo:run'],
self.cfg,
exactFlavors=True)
self.captureOutput(displayChangeSet,
None,
cs, ['foo:run[~ssl]'],
self.cfg,
exactFlavors=True)
