def __thaw__(class_, d):
self = class_(**d)
self.trove = thaw('BuildTrove', self.trove)
self.buildCfg = thaw('BuildConfiguration', self.buildCfg)
self.builtTroves = thaw('troveTupleList', self.builtTroves)
self.crossTroves = thaw('troveTupleList', self.crossTroves)
return self
def loadPayloadFromDict(self, d):
self._payload.__dict__.update(d)
self.payload.buildCfg = thaw('BuildConfiguration',
self.payload.buildCfg)
self.payload.trove = thaw('BuildTrove', self.payload.trove)
if self.payload.logData == '':
self.payload.logData = None
def testResolveResult(self):
trv = self.addComponent('foo:runtime', '1.0', 'ssl')
tup = trv.getNameVersionFlavor()
job = (tup[0], (None, None), (tup[1], tup[2]), False)
r = resolver.ResolveResult()
r.troveResolved([job], [], [])
r2 = thaw('ResolveResult', freeze('ResolveResult', r))
assert(r2.getBuildReqs() == [ job ])
assert(r2.success)
assert(not r2.inCycle)
r = resolver.ResolveResult(inCycle=True)
r.troveMissingBuildReqs(True, [('foo', None, parseFlavor('ssl'))])
r2 = thaw('ResolveResult', freeze('ResolveResult', r))
assert(not r2.hasMissingDeps())
assert(r2.hasMissingBuildReqs())
assert(r2.getMissingBuildReqs() == [(True, ('foo', '', parseFlavor('ssl')))])
assert(not r2.success)
assert(r2.inCycle)
r = resolver.ResolveResult(inCycle=True)
r.troveMissingDependencies(True, [(trv.getNameVersionFlavor(),
parseDep('trove: foo trove: bar'))])
r2 = thaw('ResolveResult', freeze('ResolveResult', r))
assert(r.getMissingDeps() == r2.getMissingDeps())
assert(r2.hasMissingDeps())
assert(not r2.success)
assert(r2.inCycle)
def __thaw__(class_, d):
self = class_()
self.__dict__.update(d)
self.buildReqs = thaw("installJobList", self.buildReqs)
self.crossReqs = thaw("installJobList", self.crossReqs)
self.bootstrapReqs = thaw("installJobList", self.bootstrapReqs)
self.missingDeps = thaw("dependencyMissingList", self.missingDeps)
self.missingBuildReqs = [(x[0], thaw("troveSpec", x[1])) for x in self.missingBuildReqs]
return self
def _getChroots(self, cu):
chroots = []
for nodeName, path, jobId, name, version, flavor, active in cu:
if jobId:
version = thaw('version', version)
flavor = thaw('flavor', flavor)
troveTuple = (name, version, flavor)
else:
troveTuple = None
c = chroot.Chroot(nodeName, path, jobId, troveTuple, active)
chroots.append(c)
return chroots
def commitSucceeded(self, callData, jobIds, commitMap):
jobIds = self.db.convertToJobIds(jobIds)
# split commitMap and recombine
finalMap = []
for jobId, troveMap in itertools.izip(jobIds, commitMap):
troveMap = dict((thaw('troveContextTuple', x[0]),
thaw('troveTupleList', x[1])) for x in troveMap)
finalMap.append((jobId, troveMap))
jobs = self.db.getJobs(jobIds, withTroves=True)
for (jobId, troveMap), job in itertools.izip(finalMap, jobs):
self._subscribeToJob(job)
job.jobCommitted(troveMap)
def loadPayloadFromDict(self, d):
self._payload.__dict__.update(d)
self.payload.buildCfg = thaw('BuildConfiguration',
self.payload.buildCfg)
self.payload.trove = thaw('BuildTrove', self.payload.trove)
for name in ('buildReqs', 'crossReqs', 'bootstrapReqs'):
tuples = thaw('troveTupleList', getattr(self.payload, name))
jobs = [(x[0], (None, None), x[1:3], False) for x in tuples]
setattr(self.payload, name, jobs)
self.payload.builtTroves = thaw('troveTupleList',
self.payload.builtTroves)
self.payload.targetLabel = thaw('label', self.payload.targetLabel)
if self.payload.logData == '':
self.payload.logData = None
def __thaw__(class_, d):
self = class_(**d)
if self.troveTuple:
self.troveTuple = thaw('troveTuple', self.troveTuple)
else:
self.troveTuple = None
return self
def getResults(results, pid, inF, csFile):
(gotResult, status) = os.waitpid(pid, os.WNOHANG)
if not gotResult:
return None
if os.WIFSIGNALED(status):
results.setExitSignal(os.WTERMSIG(status))
else:
assert(os.WIFEXITED(status))
results.setExitStatus(os.WEXITSTATUS(status))
if results.isBuildSuccess():
results.setChangeSetFile(csFile)
elif results.getExitSignal():
results.setFailureReason(BuildFailed('Build exited with signal %s' % results.getExitSignal()))
else:
errReason = []
buffer = os.read(inF, 1024)
while buffer:
errReason.append(buffer)
buffer = os.read(inF, 1024)
errReason = ''.join(errReason)
errTag, data = errReason.split('\002', 1)
results.setFailureReason(thaw('FailureReason', (errTag, data)))
os.close(inF)
return results
def testJob(self):
db = self.openRmakeDatabase()
trv = self.addComponent('foo:source', '1.0', '!flavor')
job = buildjob.NewBuildJob(db, [trv.getNameVersionFlavor()])
job2 = apiutils.thaw('BuildJob', apiutils.freeze('BuildJob', job))
assert(job2.jobId == job.jobId)
assert(list(job2.iterTroveList()) == list(job.iterTroveList()))
def testFreeze(self):
cfg = buildcfg.BuildConfiguration(readConfigFiles=False)
os.environ['HOME'] = self.workDir
cfg.configLine('policyDirs ~/policy')
newCfg = apiutils.thaw('BuildConfiguration',
apiutils.freeze('BuildConfiguration', cfg))
assert(newCfg.policyDirs[0]._getUnexpanded() == self.workDir + '/policy')
def testFreezeThawException(self):
@api(version=1)
@api_parameters(1, None)
@api_return(1, None)
def testFunc(self, foo):
return 0
sys.exc_clear()
frz = apirpc._freezeException(repoerrors.OpenError('foo'))
self.assertEquals(str(apiutils.thaw(*frz)),
'Exception from server:\n'
'conary.repository.errors.OpenError: foo\n'
'None\n')
# this is rmake's internal error
frz = apirpc._freezeException(errors.OpenError('foo'))
self.assertEquals(str(apiutils.thaw(*frz)), 'foo')
def testTroveSettings(self):
class MyTroveSettings(trovesettings.TroveSettings):
cfgOption = cfgtypes.CfgString
xx = MyTroveSettings()
xx.cfgOption = 'foobar'
yy = apiutils.thaw('TroveSettings', apiutils.freeze('TroveSettings', xx))
assert(yy.cfgOption == 'foobar')
def __thaw__(d):
d = d.copy()
new = CookResults(d.pop('name'),
versions.VersionFromString(d.pop('version')),
[ ThawFlavor(x) for x in d.pop('flavorList')])
new.__dict__.update(d)
new.failureReason = thaw('FailureReason', new.failureReason)
return new
def listNodes(self):
"""
Lists all known nodes
@return: list of (name, slots) for each node.
"""
rv = self.proxy.listNodes()
return [thaw("Node", x) for x in rv]
def listTrovesByState(self, jobId, state=None):
cu = self.db.cursor()
cmd = """SELECT troveName, version, flavor, context, state
FROM BuildTroves
WHERE jobId=?"""
params = [jobId]
if state is not None:
cmd += ' AND state=?'
params.append(state)
results = {}
for (name, version, flavor, context, state) in cu.execute(cmd, params):
version, flavor = thaw('version', version), thaw('flavor', flavor)
if state in results:
results[state].append((name, version, flavor, context))
else:
results[state] = [(name, version, flavor, context)]
return results
def getJobConfig(self, jobId):
cu = self.db.cursor()
d = {}
cu.execute("""SELECT key, value FROM JobConfig
WHERE jobId=? AND context='' ORDER by key, ord""", jobId)
for key, value in cu:
d.setdefault(key, []).append(value)
return thaw('BuildConfiguration', d)
def get(self, subscriberId):
cu = self.db.cursor()
cu.execute('''SELECT data FROM SubscriberData WHERE subscriberId=?''',
subscriberId)
dataList = [ x[0] for x in cu.fetchall()]
if not dataList:
raise KeyError(subscriberId)
return thaw('Subscriber', (subscriberId, dataList))
def listSubscribers(self, jobId):
"""
Return subscribers for jobId
@param jobId: jobId or UUID for job.
@rtype: list of build.subscriber.Subscriber instances.
@raises: JobNotFound if job does not exist.
"""
return [ thaw('Subscriber', x)
for x in self.proxy.listSubscribers(jobId) ]
def getConfig(self, jobId, context):
cu = self.db.cursor()
cu.execute("""SELECT key, value
FROM JobConfig WHERE jobId=? AND context=?
ORDER by key, ord""", jobId, context)
frozenCfg = {}
for key, value in cu:
frozenCfg.setdefault(key, []).append(value)
cfg = thaw('BuildConfiguration', frozenCfg)
return cfg
def startChrootSession(self, nodeName, chrootPath, command, superUser,
buildTrove=None):
nodeId = self.getDispatcher().getNodeByName(nodeName)
passed, results = self.getNode(nodeId).startChrootSession(chrootPath,
command, superUser,
buildTrove=buildTrove)
if passed:
return results
else:
results = thaw('FailureReason', results)
raise errors.ServerError("Could not start session at %s: %s" % (nodeId, results))
def testRegisterFreezableClassmap(self):
class Freezable(object):
def __freeze__(self):
return {}
@classmethod
def __thaw__(class_, d):
return class_()
class Foo(Freezable):
pass
class Bar(Freezable):
pass
apiutils.register_freezable_classmap("mytype", Foo)
apiutils.register_freezable_classmap("mytype", Bar)
assert apiutils.thaw("mytype", apiutils.freeze("mytype", Foo())).__class__ == Foo
assert apiutils.thaw("mytype", apiutils.freeze("mytype", Bar())).__class__ == Bar
def testBuildTrove(self):
trv = self.addComponent('blah:source', '1.0')
bt = buildtrove.BuildTrove(1, trv.getName(), trv.getVersion(),
trv.getFlavor())
f = failure.MissingDependencies([(trv.getNameVersionFlavor(),
deps.parseDep('trove: blam trove:foo'))])
bt.setFailureReason(f)
frz = apiutils.freeze('BuildTrove', bt)
bt2 = apiutils.thaw('BuildTrove', frz)
assert(bt2.getFailureReason() == bt.getFailureReason())
assert(bt2.getFlavor() == bt.getFlavor())
def getJobs(self, jobIds, withTroves=True, withConfigs=False):
"""
Return job instance.
@param jobId: jobId or UUID for job.
@param withTroves: (default True) if True, include trove objects
in job. Otherwise only include pointers.
@rtype: build.buildjob.BuildJob
@raises: JobNotFound if job does not exist.
"""
return [ thaw('BuildJob', x)
for x in self.proxy.getJobs(jobIds, withTroves, withConfigs) ]
def __thaw__(class_, eventList):
apiVer, eventList = eventList
newEventList = []
for ((event, subevent), data) in eventList:
if not isinstance(data[0], int):
data = [(data[0][0], thaw('troveContextTuple', data[0][1]))] + data[1:]
fn = getattr(class_, 'thaw_' + event, None)
if fn is not None:
data = fn(apiVer, data)
newEventList.append(((event, subevent), data))
return apiVer, newEventList
def __thaw__(frzLoaded):
d = {}
stack = [(d, frzLoaded)]
while stack:
loadDict, frozenDict = stack.pop()
for spec, (frzTroveTup, newFrzDict) in frozenDict.iteritems():
subLoadDict = {}
loadDict[spec] = (thaw("troveTuple", frzTroveTup), subLoadDict)
if newFrzDict:
stack.append((subLoadDict, newFrzDict))
return d
def checkResults(self, name, version, flavorList, wait=False):
if not isinstance(flavorList, (list, tuple)):
flavorList = [flavorList]
results = self.proxy.checkResults(name, version, flavorList, wait)
if results == '':
return None
results = thaw(cook.CookResults, results)
if results.csFile:
results.csFile = self.root + results.csFile
return results
def listTrovesByState(self, jobId, state=None):
"""
Lists troves in a job by state.
@param jobId: jobId or uuid for job.
@param state: (optional) state to list troves by. All states if
left blank.
@type state: build.buildtrove.TROVE_STATE_* or None
@return: dict of trove lists by state.
@rtype: {TROVE_STATE_* : [(name, version, flavor)]} dict.
"""
if state is None:
state = ''
results = self.proxy.listTrovesByState(jobId, state)
return dict((x[0], thaw('troveContextTupleList', x[1])) for x in results)
def _returnSubscribers(self, results, subscriberCache = None):
if subscriberCache is None:
subscriberCache = {}
d = {}
for id, data in results:
if id not in d:
d[id] = [data]
else:
d[id].append(data)
toReturn = []
for id, data in d.iteritems():
if id not in subscriberCache:
subscriberCache[id] = thaw('Subscriber', (id, data))
toReturn.append(subscriberCache[id])
return toReturn
def startChrootSession(self, callData, chrootPath, command,
superUser=False, buildTrove=None):
"""
Part of rMake node XMLRPC interface. The rMake
server uses these methods to communicate directly to a
node without going through the dispatcher.
Basically a passthrough
to worker.startSession.
Returns (True, (hostName, port)) if the connection succeeds.
Returns (False, FailureReason) if it fails.
"""
if buildTrove:
buildTrove = thaw('BuildTrove', buildTrove)
passed, results = self.server.startSession('_local_', chrootPath,
command, superUser, buildTrove)
if not passed:
results = freeze('FailureReason', results)
return passed, results
def thaw(class_, d):
self = class_(**d)
self.buildFlavors = [thaw('flavor', x) for x in self.buildFlavors]
self.nodeInfo = thaw('MachineInformation', self.nodeInfo)
return self
def __thaw__(nodeList):
return [thaw('ImageNode', node) for node in nodeList]
def __thaw__(jobList):
return [thaw('ImageJob', job) for job in jobList]
