rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
elif userInfo is None: | if userInfo is None: | def _cleanseUrl(protocol, url): if url.find('@') != -1: return protocol + '://<user>:<pwd>@' + url.rsplit('@', 1)[1] return url |
@param weakRef: is this a weak references? @type weakRef: boolean | @param weakRefs: True if we are switching a weakRef @type weakRefs: boolean | def updateChangedTrove(self, name, flavor, old, new, weakRef = False): |
if weakRefs: | if weakRef: | def updateChangedTrove(self, name, flavor, old, new, weakRef = False): |
for (theName, l) in self.chgGroup.iteritems(): | for (theName, l) in chgGroup.iteritems(): | def updateChangedTrove(self, name, flavor, old, new, weakRef = False): |
@param weakRef: is this a weak references? | @param weakRef: is this a weak reference? | def oldTroveVersion(self, name, version, flavor, weakRef = False): |
@param weakRef: is this a weak references? | @param weakRef: is this a weak reference? | def changedTrove(self, name, version, flavor, byDefault, weakRef = False): |
raise KeyError, troveName, branch | raise KeyError, (troveName, branch) | def troveLatestVersion(self, troveName, branch): |
return ent[0][0],, user[0][0] | return ent[0][0], user[0][0] | def _getIds(self, cu, entGroup, userGroup): cu.execute("SELECT entGroupId FROM entitlementGroups " "WHERE entGroup = ?", entGroup) ent = cu.fetchall() if not len(ret): raise errors.UnknownEntitlementGroup |
if hash and withFiles: | if withFiles and (hash or (oldFile and newFile.flags.isConfig() and not oldFile.flags.isConfig())): | def createChangeSet(self, troveList, recurse = True, withFiles = True): |
reposChangeSetList = [ x[1] for x in | reposChangeSetList = set([ x[1] for x in | # def _updateChangeSet -- body starts here |
if x[0] is not True ] | if x[0] is not True ]) | # def _updateChangeSet -- body starts here |
"File %s is not a valid conary changeset: %s" % fileName) | "File %s is not a valid conary changeset: %s" % (fileName, err)) | def __init__(self, fileName, skipValidate = 1): try: if type(fileName) is str: try: f = open(fileName, "r") except IOError, err: raise errors.ConaryError( "Error opening changeset '%s': %s" % (fileName, err.strerror)) try: csf = filecontainer.FileContainer(f) except IOError, err: raise filecontainer.BadContainer( "File... |
flavorStr = deps.DependencySet() | flavorStr = deps.deps.DependencySet() | def findUnreferencedTroves(self): cu = self.db.cursor() cu.execute(""" SELECT troveName, version, flavor FROM DBInstances LEFT OUTER JOIN TroveTroves ON DBInstances.instanceId = TroveTroves.includedId JOIN Versions ON DBInstances.versionId = Versions.versionId JOIN DBFlavors ON DBInstances.flavorId = DBFlavors.flavorId... |
if (respectBranchAffinity and replacedInfo in localUpdatesByPresent): localUpdateBranch = replacedInfo[1].branch() notInstalledBranch = \ | if replaced[0] and respectBranchAffinity: newBranch = newInfo[1].branch() installedBranch = replacedInfo[1].branch() if replacedInfo in localUpdatesByPresent: notInstalledBranch = \ | # def _mergeGroupChanges -- main body begins here |
newBranch = newInfo[1].branch() | alreadyBranchSwitch = True else: notInstalledBranch = None alreadyBranchSwitch = False | # def _mergeGroupChanges -- main body begins here |
if (notInstalledBranch != localUpdateBranch and localUpdateBranch != newBranch): if (localUpdateBranch, newBranch) == branchHint: | if (notInstalledBranch == installedBranch or installedBranch == newBranch): pass else: if isPrimary: if alreadyBranchSwitch: respectBranchAffinity = False pass elif (installedBranch, newBranch) == branchHint: | # def _mergeGroupChanges -- main body begins here |
elif not respectBranchAffinity or isPrimary: respectBranchAffinity = False | elif (replacedInfo in installedAndReferenced and not alreadyBranchSwitch): pass | # def _mergeGroupChanges -- main body begins here |
raise sqlerrorrs.CursorError(e.args[1], ("ProgrammingError",) + tuple(e.args)) | raise sqlerrors.CursorError(e.args[1], ("ProgrammingError",) + tuple(e.args)) | def execute(self, sql, *params, **kw): if kw.has_key("start_transaction"): del kw["start_transaction"] try: BindlessCursor.execute(self, sql, *params, **kw) except mysql.IntegrityError, e: if e[0] in (1062,): raise sqlerrors.ColumnNotUnique(e) raise errors.CursorError(e.args[1], ("IntegrityError",) + tuple(e.args)) exc... |
%(tmpName)s.class == Dependencies.class AND %(tmpName)s.name == Dependencies.name AND %(tmpName)s.flag == Dependencies.flag | %(tmpName)s.class = Dependencies.class AND %(tmpName)s.name = Dependencies.name AND %(tmpName)s.flag = Dependencies.flag | def _mergeTmpTable(self, cu, tmpName, depTable, reqTable, provTable, dependencyTables, multiplier = 1): substDict = { 'tmpName' : tmpName, 'depTable' : depTable, 'reqTable' : reqTable, 'provTable' : provTable } |
%(tmpName)s.class == %(depTable)s.class AND %(tmpName)s.name == %(depTable)s.name AND %(tmpName)s.flag == %(depTable)s.flag | %(tmpName)s.class = %(depTable)s.class AND %(tmpName)s.name = %(depTable)s.name AND %(tmpName)s.flag = %(depTable)s.flag | def _mergeTmpTable(self, cu, tmpName, depTable, reqTable, provTable, dependencyTables, multiplier = 1): substDict = { 'tmpName' : tmpName, 'depTable' : depTable, 'reqTable' : reqTable, 'provTable' : provTable } |
%(tmpName)s.isProvides == 0""" % substDict | %(tmpName)s.isProvides = 0""" % substDict | def _mergeTmpTable(self, cu, tmpName, depTable, reqTable, provTable, dependencyTables, multiplier = 1): substDict = { 'tmpName' : tmpName, 'depTable' : depTable, 'reqTable' : reqTable, 'provTable' : provTable } |
%(tmpName)s.isProvides == 1""" % substDict | %(tmpName)s.isProvides = 1""" % substDict | def _mergeTmpTable(self, cu, tmpName, depTable, reqTable, provTable, dependencyTables, multiplier = 1): substDict = { 'tmpName' : tmpName, 'depTable' : depTable, 'reqTable' : reqTable, 'provTable' : provTable } |
substTable = { 'requires' : "%-15s" % requiresTable, 'deptable' : "%-15s" % depTable } | substTable = { 'requires' : requiresTable, 'deptable' : depTable } | def _resolveStmt(self, requiresTable, providesTableList, depTableList, restrictBy = None, restrictor=None): subselect = "" |
substTable = { 'provides' : "%-15s" % provTable, 'requires' : "%-15s" % requiresTable, | substTable = { 'provides' : provTable, 'requires' : requiresTable, | def _resolveStmt(self, requiresTable, providesTableList, depTableList, restrictBy = None, restrictor=None): subselect = "" |
Matched.provInstId as provInstanceId FROM ( %s ) AS Matched | Matched.provInstId as provInstanceId, DepCheck.flagCount as flagCount FROM ( %s ) AS Matched | def _resolveStmt(self, requiresTable, providesTableList, depTableList, restrictBy = None, restrictor=None): subselect = "" |
Matched.reqInstId == DepCheck.troveId AND Matched.class == DepCheck.class AND Matched.name == DepCheck.name AND Matched.flag == DepCheck.flag | Matched.reqInstId = DepCheck.troveId AND Matched.class = DepCheck.class AND Matched.name = DepCheck.name AND Matched.flag = DepCheck.flag | def _resolveStmt(self, requiresTable, providesTableList, depTableList, restrictBy = None, restrictor=None): subselect = "" |
COUNT(DepCheck.troveId) == DepCheck.flagCount | COUNT(DepCheck.troveId) = DepCheck.flagCount | def _resolveStmt(self, requiresTable, providesTableList, depTableList, restrictBy = None, restrictor=None): subselect = "" |
try: cu.execute("DROP TABLE BrokenDeps") except: pass | def _brokenItemsToSet(cu, depIdSet, wasIn): # this only works for databases (not repositories) if not depIdSet: return [] | |
RemovedTroveIds.troveId == Provides.instanceId | RemovedTroveIds.troveId = Provides.instanceId | def _orderComponents(compGraph): |
Dependencies.depId == Requires.depId | Dependencies.depId = Requires.depId | def _orderComponents(compGraph): |
(%s) | (%s) AS Resolved | def _orderComponents(compGraph): |
reqInstanceId == Required.troveId | reqInstanceId = Required.troveId | def _orderComponents(compGraph): |
provInstanceId == Provided.troveId | provInstanceId = Provided.troveId | def _orderComponents(compGraph): |
cu.execute(full,start_transaction = False) | cu.execute(full).fetchall() cu.execute(full, start_transaction = False) | def _resolve(self, depSetList, selectTemplate, restrictor=None, restrictBy=None): |
(%s) | (%s) as DepsSelect | def resolve(self, label, depSetList): """ Determine troves that provide the given dependencies, restricting by label and limiting to latest version for each (name, flavor) pair. """ selectTemplate = """SELECT depNum, Items.item, Versions.version, Nodes.timeStamps, flavor FROM (%s) INNER JOIN Instances ON provInstanceId... |
provInstanceId == Instances.instanceId | provInstanceId = Instances.instanceId | def resolve(self, label, depSetList): """ Determine troves that provide the given dependencies, restricting by label and limiting to latest version for each (name, flavor) pair. """ selectTemplate = """SELECT depNum, Items.item, Versions.version, Nodes.timeStamps, flavor FROM (%s) INNER JOIN Instances ON provInstanceId... |
Instances.itemId == Items.itemId | Instances.itemId = Items.itemId | def resolve(self, label, depSetList): """ Determine troves that provide the given dependencies, restricting by label and limiting to latest version for each (name, flavor) pair. """ selectTemplate = """SELECT depNum, Items.item, Versions.version, Nodes.timeStamps, flavor FROM (%s) INNER JOIN Instances ON provInstanceId... |
Instances.versionId == Versions.versionId | Instances.versionId = Versions.versionId | def resolve(self, label, depSetList): """ Determine troves that provide the given dependencies, restricting by label and limiting to latest version for each (name, flavor) pair. """ selectTemplate = """SELECT depNum, Items.item, Versions.version, Nodes.timeStamps, flavor FROM (%s) INNER JOIN Instances ON provInstanceId... |
Instances.flavorId == Flavors.flavorId | Instances.flavorId = Flavors.flavorId | def resolve(self, label, depSetList): """ Determine troves that provide the given dependencies, restricting by label and limiting to latest version for each (name, flavor) pair. """ selectTemplate = """SELECT depNum, Items.item, Versions.version, Nodes.timeStamps, flavor FROM (%s) INNER JOIN Instances ON provInstanceId... |
Instances.itemId == Nodes.itemId AND Instances.versionId == Nodes.versionId | Instances.itemId = Nodes.itemId AND Instances.versionId = Nodes.versionId | def resolve(self, label, depSetList): """ Determine troves that provide the given dependencies, restricting by label and limiting to latest version for each (name, flavor) pair. """ selectTemplate = """SELECT depNum, Items.item, Versions.version, Nodes.timeStamps, flavor FROM (%s) INNER JOIN Instances ON provInstanceId... |
(%s) | (%s) as Resolved | def getLocalProvides(self, depSetList): cu = self.db.cursor() |
provInstanceId == Instances.instanceId | provInstanceId = Instances.instanceId | def getLocalProvides(self, depSetList): cu = self.db.cursor() |
ON (Instances.flavorId == Flavors.flavorId) | ON (Instances.flavorId = Flavors.flavorId) | def getLocalProvides(self, depSetList): cu = self.db.cursor() |
def stack(source1, source2): | def stack(*sources): | def stack(source1, source2): """ create a trove source that will search first source1, then source2 """ if source1 is source2: return source1 if isinstance(source1, TroveSourceStack): if source1.hasSource(source2): return source1 source1.copy().addSource(source2) return source1 return TroveSourceStack(source1, sourc... |
source1.copy().addSource(source2) | source1 = source1.copy() source1.addSource(source2) | def stack(source1, source2): """ create a trove source that will search first source1, then source2 """ if source1 is source2: return source1 if isinstance(source1, TroveSourceStack): if source1.hasSource(source2): return source1 source1.copy().addSource(source2) return source1 return TroveSourceStack(source1, sourc... |
return TroveSourceStack(source1, source2) | elif isinstance(source2, TroveSourceStack): if source2.hasSource(source1): return source2 source2 = source2.copy() source2.insertSource(source1) return source2 return TroveSourceStack(*sources) | def stack(source1, source2): """ create a trove source that will search first source1, then source2 """ if source1 is source2: return source1 if isinstance(source1, TroveSourceStack): if source1.hasSource(source2): return source1 source1.copy().addSource(source2) return source1 return TroveSourceStack(source1, sourc... |
self.addMissing(name) | self.addMissing(missing, name) | def findAll(self, repos, missing, finalMap): res = repos.getTroveVersionsByBranch(self.query, bestFlavor=True) for name in self.query: versionStr = self.map[name][1] try: verRel = versions.Revision(versionStr) except versions.ParseError, e: verRel = None found = False for version in reversed(sorted(res[name].iterkeys()... |
% (versionStr, name, branch) | % (versionStr, name, branch.asString()) | def missingMsg(self, name): branch = self.query[name].keys()[0] versionStr = self.map[name][1] return "revision %s of %s was found on branch %s" \ % (versionStr, name, branch) |
f = self._findSource() | f = self.doDownload() | def do(self): |
filesNeeded += _cvtFileList(extraFileList) | filesNeeded.update(_cvtFileList(extraFileList)) | def _getCsFromRepos(target, cs, server, job, recurse, withFiles, withFileContents, excludeAutoSource, filesNeeded, chgSetList, removedList): abortCheck = None if callback: callback.requestingChangeSet() server.setAbortCheck(abortCheck) l = server.getChangeSet(job, recurse, withFiles, withFileContents, excludeAutoSource... |
filesNeeded = [] | filesNeeded = set() | def _getCsFromShim(target, cs, server, job, recurse, withFiles, withFileContents, excludeAutoSource, filesNeeded, chgSetList, removedList): (newCs, extraTroveList, extraFileList, removedList) = \ server.getChangeSetObj(job, recurse, withFiles, withFileContents, excludeAutoSource) if not cs: cs = newCs else: cs.merge(ne... |
filesNeeded += extraFileList | filesNeeded.update(extraFileList) | def _getCsFromShim(target, cs, server, job, recurse, withFiles, withFileContents, excludeAutoSource, filesNeeded, chgSetList, removedList): (newCs, extraTroveList, extraFileList, removedList) = \ server.getChangeSetObj(job, recurse, withFiles, withFileContents, excludeAutoSource) if not cs: cs = newCs else: cs.merge(ne... |
filesNeeded += [ (x[0], troveName, | filesNeeded.update( ( (x[0], troveName, | def _getCsFromShim(target, cs, server, job, recurse, withFiles, withFileContents, excludeAutoSource, filesNeeded, chgSetList, removedList): (newCs, extraTroveList, extraFileList, removedList) = \ server.getChangeSetObj(job, recurse, withFiles, withFileContents, excludeAutoSource) if not cs: cs = newCs else: cs.merge(ne... |
(newVersion, newFlavor, x[3], x[4])) for x in newFilesNeeded ] | (newVersion, newFlavor, x[3], x[4])) for x in newFilesNeeded ) ) | def _getCsFromShim(target, cs, server, job, recurse, withFiles, withFileContents, excludeAutoSource, filesNeeded, chgSetList, removedList): (newCs, extraTroveList, extraFileList, removedList) = \ server.getChangeSetObj(job, recurse, withFiles, withFileContents, excludeAutoSource) if not cs: cs = newCs else: cs.merge(ne... |
def _mergeGroupChanges(self, cs, uJob, redirectHack, keepExisting, recurse): | def _mergeGroupChanges(self, cs, uJob, redirectHack, keepExisting, recurse, ineligible): | def _mergeGroupChanges(self, cs, uJob, redirectHack, keepExisting, recurse): |
ineligible = removeSet) | ineligible = removeSet | ineligible) | def _findErasures(primaryErases, newJob, referencedTroves, recurse): # each node is a ((name, version, flavor), state, edgeList # fromUpdate) # state is ERASE, KEEP, or UNKNOWN # fromUpdate is True if erasing this node was suggested by # a trvCs in the newJob (an update, not an erase). We need # to track this t... |
newItems = [ item for item, present | oldItems = [ item for item, isPresent | def _updateChangeSet(self, itemList, uJob, keepExisting = None, recurse = True, updateMode = True): """ Updates a trove on the local system to the latest version in the respository that the trove was initially installed from. |
if not present ] | if isPresent ] newItems = [ item for item, isPresent in itertools.izip(newItems, present) if not isPresent ] | def _updateChangeSet(self, itemList, uJob, keepExisting = None, recurse = True, updateMode = True): """ Updates a trove on the local system to the latest version in the respository that the trove was initially installed from. |
outdated, eraseList = self.db.outdatedTroves(newItems) | outdated, eraseList = self.db.outdatedTroves(newItems, oldItems) | def _updateChangeSet(self, itemList, uJob, keepExisting = None, recurse = True, updateMode = True): """ Updates a trove on the local system to the latest version in the respository that the trove was initially installed from. |
keepExisting, recurse) | keepExisting, recurse, oldItems) | def _updateChangeSet(self, itemList, uJob, keepExisting = None, recurse = True, updateMode = True): """ Updates a trove on the local system to the latest version in the respository that the trove was initially installed from. |
return '%s %s <password>' % (serverGlob, user, password) | return '%s %s %s' % (serverGlob, user, password) | def format(self, val, displayOptions=None): serverGlob, user, password = val if password is None: return '%s %s' % (serverGlob, user) elif displayOptions.get('hidePasswords'): return '%s %s <password>' % (serverGlob, user) else: return '%s %s <password>' % (serverGlob, user, password) |
ret = cookFilesetObject(repos, db, cfg, recipeClasses, | ret = cookFilesetObject(repos, db, cfg, recipeClass, | def cookObject(repos, cfg, recipeClass, sourceVersion, changeSetFile = None, prep=True, macros={}, targetLabel = None, resume = None, alwaysBumpCount = False, allowUnknownFlags = False, allowMissingSource = False, ignoreDeps = False, logBuild = False, crossCompile = None, callback = None, requireCleanSources = False, d... |
if data is None: return self.http_error(url, fp, errcode, errmsg, headers) else: return self.http_error(url, fp, errcode, errmsg, headers, data) | raise xmlrpclib.ProtocolError(url, errcode, errmsg, headers) | def open_http(self, url, data=None): """override this WHOLE FUNCTION to change |
if 'import setuptools' in file('%s/%s' %(rundir, macros.setup)).read(): | if re.compile('(import setuptools|from setuptools import)').search(file('%s/%s' %(rundir, macros.setup)).read()): | def do(self, macros): |
if provision.startswith("abi:"): | elif provision.startswith("abi:"): | def _markProvides(self, path, fullpath, provision, pkg, macros, m, f): if provision.startswith("file"): # can't actually specify what to provide, just that it provides... f.flags.isPathDependencyTarget(True) |
if provision.startswith("soname:"): | elif provision.startswith("soname:"): | def _markProvides(self, path, fullpath, provision, pkg, macros, m, f): if provision.startswith("file"): # can't actually specify what to provide, just that it provides... f.flags.isPathDependencyTarget(True) |
if info in pathMap and info not in componentMap[info].providesMap: | if (info in pathMap and not componentMap[info][info][1].flags.isPathDependencyTarget()): | def _addRequirement(self, path, info, flags, pkg, depClass): if depClass == deps.FileDependencies: pathMap = self.recipe.autopkg.pathMap componentMap = self.recipe.autopkg.componentMap if info in pathMap and info not in componentMap[info].providesMap: # if a package requires a file, includes that file, # and does not p... |
BC{{r.addNewGroup()}} - Adds one newly created group to another newly | B{C{r.addNewGroup()}} - Adds one newly created group to another newly | def getPrimaryGroupNames(self): """ Return the list of groups in this GroupRecipe that are not included in any other groups. """ unseen = set(self.getGroupNames()) |
if '~' not in str: | if '~' not in str and '$' not in str: | def Path(str): if str not in _pathCache: if '~' not in str: p = _Path(str) else: p = _ExpandedPath(str) _pathCache[str] = p return p else: return _pathCache[str] |
else: return _pathCache[str] | elif '~' in str or '$' in str: p = _ExpandedPath(str) if p != _pathCache[str]: _pathCache[str] = p return _pathCache[str] | def Path(str): if str not in _pathCache: if '~' not in str: p = _Path(str) else: p = _ExpandedPath(str) _pathCache[str] = p return p else: return _pathCache[str] |
def _resolveDependencies(self, uJob, jobSet, split = False): | def _resolveDependencies(self, uJob, jobSet, split = False, resolveDeps = True): | def _resolveDependencies(self, uJob, jobSet, split = False): |
and erase operations. | and erase operations. If self.cfg.autoResolve is set, dependencies within the job are automatically closed. | def updateChangeSet(self, itemList, keepExisting = False, recurse = True, resolveDeps = True, test = False, updateByDefault = True, callback = UpdateCallback(), split = False, sync = False, fromChangesets = []): """ Creates a changeset to update the system based on a set of trove update and erase operations. |
@param resolveDeps: Install troves needed to resolve dependencies. | @param resolveDeps: Should dependencies error be flagged or silently ignored? | def updateChangeSet(self, itemList, keepExisting = False, recurse = True, resolveDeps = True, test = False, updateByDefault = True, callback = UpdateCallback(), split = False, sync = False, fromChangesets = []): """ Creates a changeset to update the system based on a set of trove update and erase operations. |
self._resolveDependencies(uJob, jobSet, split = split) | self._resolveDependencies(uJob, jobSet, split = split, resolveDeps = resolveDeps) | def updateChangeSet(self, itemList, keepExisting = False, recurse = True, resolveDeps = True, test = False, updateByDefault = True, callback = UpdateCallback(), split = False, sync = False, fromChangesets = []): """ Creates a changeset to update the system based on a set of trove update and erase operations. |
newJob.add((name, (oldVersion, oldFlavor), (None, None), False)) | job = (name, (oldVersion, oldFlavor), (None, None), False) newJob.add(job) keepList.append(job) | # def _mergeGroupChanges -- main body begins here |
except ParseError, msg: | except versions.ParseError, msg: | def _getVersionType(self, troveTup): """ Return a string that describes this troveTup's versionStr The string returned corresponds to a function name for sorting on that versionStr type. """ name = troveTup[0] versionStr = troveTup[1] if not versionStr: return VERSION_STR_NONE firstChar = versionStr[0] if firstChar == ... |
isRedirect = trv.isRedirect() | def cacheTroves(self, troveTupList): troveTupList = [x for x in troveTupList if x not in self] if not troveTupList: return troves = self.repos.getTroves(troveTupList, withFiles=False) | |
checkForRedirects(group, repos, cache) | checkForRedirects(group, repos, cache, cfg.buildFlavor) | def _sortGroups(groupList): """ Sorts groupList so that if group a includes group b, group b is before a in the returned list. Also checks for cyclic group inclusion. """ g = graph.DirectedGraph() |
def checkForRedirects(group, repos, troveCache): | def checkForRedirects(group, repos, troveCache, buildFlavor): | def checkForRedirects(group, repos, troveCache): redirectTups = [] for troveTup in group.iterTroveList(strongRefs=True, weakRefs=False): if troveCache.isRedirect(troveTup): redirectTups.append(troveTup) if not redirectTups: return redirectTroves = repos.getTroves(redirectTups) missingTargets = {} for trv in redirectT... |
name = trv.getName() for (subName, subVersion, subFlavor) in trv.iterTroveList( strongRefs=True): if (":" not in subName and ":" not in name) or \ (":" in subName and ":" in name): targets.append((subName, subVersion, subFlavor)) | allTargets = [ (x[0], str(x[1]), x[2]) for x in trv.iterRedirects() ] matches = repos.findTroves([], allTargets, buildFlavor) for troveList in matches.values(): targets += troveList | def checkForRedirects(group, repos, troveCache): redirectTups = [] for troveTup in group.iterTroveList(strongRefs=True, weakRefs=False): if troveCache.isRedirect(troveTup): redirectTups.append(troveTup) if not redirectTups: return redirectTroves = repos.getTroves(redirectTups) missingTargets = {} for trv in redirectT... |
entGroupInfo = [ (x, None) for x in entGroupList ] | entGroupInfo = [ (x, None, None) for x in entGroupList ] | def manageEntitlements(self, auth): entGroupList = self.repServer.listEntitlementGroups(auth, 0) |
if option.help_level == VERBOSE_HELP and log.getVerbosity() > log.DEBUG: | if option.help_level == VERBOSE_HELP and log.getVerbosity() > log.INFO: | def format_option(self, option): if option.help_level == VERBOSE_HELP and log.getVerbosity() > log.DEBUG: return '' return optparse.IndentedHelpFormatter.format_option(self, option) |
commonParams=None, useHelp=False, defaultGroup=None, interspersedArgs=True, hobbleShortOpts=False, addDebugOptions=True, addConfigOptions=True, description=None): | commonParams=None, useHelp=False, defaultGroup=None, interspersedArgs=True, hobbleShortOpts=False, addDebugOptions=True, addConfigOptions=True, addVerboseOptions=True, description=None): | def _processArgs(params, cfgMap, cfg, usage, argv=sys.argv, version=None, commonParams=None, useHelp=False, defaultGroup=None, interspersedArgs=True, hobbleShortOpts=False, addDebugOptions=True, addConfigOptions=True, description=None): argSet = {} # don't mangle the command line argv = argv[:] parser = _getParser(par... |
log.setVerbosity(log.WARNING) | if log.getVerbosity() > log.WARNING: log.setVerbosity(log.WARNING) | def _processArgs(params, cfgMap, cfg, usage, argv=sys.argv, version=None, commonParams=None, useHelp=False, defaultGroup=None, interspersedArgs=True, hobbleShortOpts=False, addDebugOptions=True, addConfigOptions=True, description=None): argSet = {} # don't mangle the command line argv = argv[:] parser = _getParser(par... |
if log.getVerbosity() > log.DEBUG: | if log.getVerbosity() > log.INFO: | def usage(self, errNo=1): if not self.parser: self.setParser(self.mainHandler.getParser(self.commands[0])) self.parser.print_help() if log.getVerbosity() > log.DEBUG: print print '(Use --debug to get a full option listing)' return errNo |
print '(Use --debug to get a full option listing)' | print '(Use --verbose to get a full option listing)' | def usage(self, errNo=1): if not self.parser: self.setParser(self.mainHandler.getParser(self.commands[0])) self.parser.print_help() if log.getVerbosity() > log.DEBUG: print print '(Use --debug to get a full option listing)' return errNo |
if flags & MISSINGFILESOKAY: newPkg.removeFile(fileId) continue else: log.error("%s is missing (use remove if this is intentional)" | if (flags & MISSINGFILESOKAY) == 0: log.warning("%s is missing (use remove if this is intentional)" | def _localChanges(repos, changeSet, curPkg, srcPkg, newVersion, root, flags): """ Populates a change set against the files in the filesystem and builds a package object which describes the files installed. The return is a tuple with a boolean saying if anything changed and a package reflecting what's in the filesystem... |
return None | newPkg.removeFile(fileId) continue | def _localChanges(repos, changeSet, curPkg, srcPkg, newVersion, root, flags): """ Populates a change set against the files in the filesystem and builds a package object which describes the files installed. The return is a tuple with a boolean saying if anything changed and a package reflecting what's in the filesystem... |
crossCompile=crossCompile) | crossCompile=crossCompile, enforceManagedPolicy=enforceManagedPolicy) | def cookPackageObject(repos, db, cfg, recipeClass, sourceVersion, prep=True, macros={}, targetLabel = None, resume = None, alwaysBumpCount=False, ignoreDeps=False, logBuild=False, crossCompile = None): """ Turns a package recipe object into a change set. Returns the absolute changeset created, a list of the names of th... |
logBuild=False, crossCompile=None): | logBuild=False, crossCompile=None, enforceManagedPolicy=False): | def _cookPackageObject(repos, cfg, recipeClass, sourceVersion, prep=True, macros={}, resume = None, ignoreDeps=False, logBuild=False, crossCompile=None): """Builds the package for cookPackageObject. Parameter meanings are described there. """ fullName = recipeClass.name lcache = lookaside.RepositoryCache(repos) srcd... |
if not macros['buildlabel'].startswith('local@local:'): unmanagedPolicyFiles.append(policyPath) | unmanagedPolicyFiles.append(policyPath) | def _cookPackageObject(repos, cfg, recipeClass, sourceVersion, prep=True, macros={}, resume = None, ignoreDeps=False, logBuild=False, crossCompile=None): """Builds the package for cookPackageObject. Parameter meanings are described there. """ fullName = recipeClass.name lcache = lookaside.RepositoryCache(repos) srcd... |
if unmanagedPolicyFiles and cfg.enforceManagedPolicy: | if unmanagedPolicyFiles and enforceManagedPolicy: | def _cookPackageObject(repos, cfg, recipeClass, sourceVersion, prep=True, macros={}, resume = None, ignoreDeps=False, logBuild=False, crossCompile=None): """Builds the package for cookPackageObject. Parameter meanings are described there. """ fullName = recipeClass.name lcache = lookaside.RepositoryCache(repos) srcd... |
'cd %%(builddir)s; ' '%%(cdSubDir)s ' | 'cd %%(builddir)s/%%(subDir)s; ' | def do(self, macros): |
macros['configure'] = '../configure' | macros['configure'] = '../%s' % self.configureName | def do(self, macros): |
macros['configure'] = './configure' | macros['configure'] = './%s' % self.configureName | def do(self, macros): |
macros['cdSubDir'] = 'cd %s;' %self.subDir | macros['subDir'] = self.subDir | def do(self, macros): |
template = ('cd %%(builddir)s/%(subDir)s; ' | template = ('cd %%(builddir)s/%%(subDir)s; ' | def do(self, macros): |
updJob = _updateTroves(cfg, applyList, replaceFiles = replaceFiles, tagScript = tagScript, keepExisting = keepExisting, depCheck = depCheck, depsRecurse = depsRecurse, test = test, justDatabase = justDatabase, recurse = recurse, info = info, updateByDefault = updateByDefault, callback = callback) if info: callback.done... | _updateTroves(cfg, applyList, replaceFiles = replaceFiles, tagScript = tagScript, keepExisting = keepExisting, depCheck = depCheck, depsRecurse = depsRecurse, test = test, justDatabase = justDatabase, recurse = recurse, info = info, updateByDefault = updateByDefault, callback = callback) | def doUpdate(cfg, pkgList, replaceFiles = False, tagScript = None, keepExisting = False, depCheck = True, depsRecurse = True, test = False, justDatabase = False, recurse = True, info = False, updateByDefault = True, callback = None): if not callback: callback = callbacks.UpdateCallback() applyList = [] if type(pkgLis... |
True, {}, False, False, False, None, | True, {}, False, False, False, False, None, | # def _mergeGroupChanges -- main body begins here |
(newInfo, isPrimary, byDefaultDict, parentInstalled, parentUpdated, primaryInstalled, branchHint, respectBranchAffinity, respectFlavorAffinity, installRedirects, followLocalChanges, updateOnly) = newTroves.pop(0) | (newInfo, isPrimary, byDefaultDict, parentInstalled, parentReplacedWasPinned, parentUpdated, primaryInstalled, branchHint, respectBranchAffinity, respectFlavorAffinity, installRedirects, followLocalChanges, updateOnly) = newTroves.pop(0) | # def _mergeGroupChanges -- main body begins here |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.