rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
if path not in pkg.isnsetMap: | f = pkg.getFile(path) if path in pkg.isnsetMap: isnset = pkg.isnsetMap[path] elif self.hasLib(path) and f.hasContents: isnset = self.baseIsnset else: | def doFile(self, path): |
f = pkg.getFile(path) | def doFile(self, path): | |
isnset = pkg.isnsetMap[path] | def doFile(self, path): | |
if len(installedDict[name]) == 1: | branch = version.branch() verInfo = installedDict[name][branch] if len(installedDict[name]) == 1 and len(verInfo) == 1: | def updateAll(cfg, info = False, depCheck = True, replaceFiles = False, depsRecurse = True, recurse = True, test = False): client = conaryclient.ConaryClient(cfg) items = client.db.findUnreferencedTroves() installed = client.db.findByNames([ x[0] for x in items ]) installedDict = {} for (name, version, release) in in... |
branch = version.branch() verInfo = installedDict[name][branch] if len(verInfo) == 1: | elif len(verInfo) == 1: | def updateAll(cfg, info = False, depCheck = True, replaceFiles = False, depsRecurse = True, recurse = True, test = False): client = conaryclient.ConaryClient(cfg) items = client.db.findUnreferencedTroves() installed = client.db.findByNames([ x[0] for x in items ]) installedDict = {} for (name, version, release) in in... |
print updateItems | print "\n".join([str((x[0], x[1].asString(), deps.formatFlavor(x[2]))) for x in updateItems ]) | def updateAll(cfg, info = False, depCheck = True, replaceFiles = False, depsRecurse = True, recurse = True, test = False): client = conaryclient.ConaryClient(cfg) items = client.db.findUnreferencedTroves() installed = client.db.findByNames([ x[0] for x in items ]) installedDict = {} for (name, version, release) in in... |
doWork(repos, cfg, commitList, srcMap, pkgMap, grpMap, sourceuser, binaryuser, fromaddr, argSet) | doWork(repos, cfg, srcMap, pkgMap, grpMap, sourceuser, binaryuser, fromaddr, argSet) | def process(repos, cfg, commitList, srcMap, pkgMap, grpMap, argv, otherArgs): if not len(argv) and not len(otherArgs): return usage() argDef = { 'user': options.ONE_PARAM, 'sourceuser': options.ONE_PARAM, 'binaryuser': options.ONE_PARAM, 'from': options.ONE_PARAM, 'email': options.MULT_PARAM, } # create an argv[0] fo... |
sys.stderr.write("changemail failed with code %d" % status) else: sys.stdout.write("changemail completed successfully") | fail(status, srcMap, pkgMap, grpMap, argv) | def process(repos, cfg, commitList, srcMap, pkgMap, grpMap, argv, otherArgs): if not len(argv) and not len(otherArgs): return usage() argDef = { 'user': options.ONE_PARAM, 'sourceuser': options.ONE_PARAM, 'binaryuser': options.ONE_PARAM, 'from': options.ONE_PARAM, 'email': options.MULT_PARAM, } # create an argv[0] fo... |
def doWork(repos, cfg, commitList, srcMap, pkgMap, grpMap, sourceuser, binaryuser, fromaddr, argSet): | def doWork(repos, cfg, srcMap, pkgMap, grpMap, sourceuser, binaryuser, fromaddr, argSet): | def doWork(repos, cfg, commitList, srcMap, pkgMap, grpMap, sourceuser, binaryuser, fromaddr, argSet): tmpfd, tmppath = tempfile.mkstemp('', 'changemail-') os.unlink(tmppath) tmpfile = os.fdopen(tmpfd) sys.stdout.flush() oldStdOut = os.dup(sys.stdout.fileno()) os.dup2(tmpfd, 1) if srcMap: sources = sorted(srcMap.keys()... |
action.RecipeAction.__init__(self, recipe, [], **keywords) | BuildAction.__init__(self, recipe, [], **keywords) | def __init__(self, recipe, *args, **keywords): |
baseFileList, itertools.repeat(None)) | baseFileList, repeat(None), repeat(None)) | def _singleTrove(self, repos, troveCs, changeSet, baseTrove, fsTrove, root, removalHints, filePriorityPath, pathsMoved, flags): |
for (pathId, headPath, headFileId, headFileVersion), \ baseFile, headChanges in itertools.chain(changedHere, changedOther): | for ((pathId, headPath, headFileId, headFileVersion), baseFile, headChanges, fileOnSystem) \ in itertools.chain(changedHere, changedOther): | def _singleTrove(self, repos, troveCs, changeSet, baseTrove, fsTrove, root, removalHints, filePriorityPath, pathsMoved, flags): |
if not headChanges and not fsTrove.hasFile(pathId): | if not headChanges: fileOnSystem = fsTrove.hasFile(pathId) if not fileOnSystem: | def _singleTrove(self, repos, troveCs, changeSet, baseTrove, fsTrove, root, removalHints, filePriorityPath, pathsMoved, flags): |
def _findMovedPaths(self, db, changeSet): | def _findMovedPaths(self, db, changeSet, fsTroveDict): | def _findMovedPaths(self, db, changeSet): # Lookup paths which have swithed troves. These look like a # remove and add of the same path; we build an dict which lets # us treat these events as file updates rather than a remove/add # sequence, allowing us to preserve state. pathsMoved = {} |
removedFiles[path] = ((pathId, version, fileId), oldTroveInfo) | removedFiles[path] = ((pathId, version, fileId), oldTroveInfo, True) | def _findMovedPaths(self, db, changeSet): # Lookup paths which have swithed troves. These look like a # remove and add of the same path; we build an dict which lets # us treat these events as file updates rather than a remove/add # sequence, allowing us to preserve state. pathsMoved = {} |
removedFiles[path] = ((pathId, version, fileId), oldTroveInfo) | removedFiles[path] = ((pathId, version, fileId), oldTroveInfo, False) | def _findMovedPaths(self, db, changeSet): # Lookup paths which have swithed troves. These look like a # remove and add of the same path; we build an dict which lets # us treat these events as file updates rather than a remove/add # sequence, allowing us to preserve state. pathsMoved = {} |
((oldPathId, oldVersion, oldFileId), oldTroveInfo) = \ | ((oldPathId, oldVersion, oldFileId), oldTroveInfo, isErase) = \ | def _findMovedPaths(self, db, changeSet): # Lookup paths which have swithed troves. These look like a # remove and add of the same path; we build an dict which lets # us treat these events as file updates rather than a remove/add # sequence, allowing us to preserve state. pathsMoved = {} |
oldFile, diff ) | oldFile, diff, fileExists ) | def _findMovedPaths(self, db, changeSet): # Lookup paths which have swithed troves. These look like a # remove and add of the same path; we build an dict which lets # us treat these events as file updates rather than a remove/add # sequence, allowing us to preserve state. pathsMoved = {} |
pathsMoved = self._findMovedPaths(db, changeSet) | pathsMoved = self._findMovedPaths(db, changeSet, fsTroveDict) | def __init__(self, db, changeSet, fsTroveDict, root, filePriorityPath, callback = None, flags = MERGE, removeHints = {}): |
if os.path.exists(recipeFile) | if os.path.exists(recipeFile): | def newTrove(repos, cfg, name, dir = None): parts = name.split('=', 1) if len(parts) == 1: label = cfg.buildLabel else: versionStr = parts[1] name = parts[0] try: label = versions.Label(versionStr) except versions.ParseError: log.error("%s is not a valid label" % versionStr) return component = "%s:source" % name # XXX... |
if flavor is not None: | if flavor is None: | def findTrove(self, labelPath, name, defaultFlavor, versionStr = None, acrossRepositories = False, withFiles = True, affinityDatabase = None, flavor = None): |
def error(msg, *args): | def error(*args): | def error(msg, *args): "Log an error" m = "error: " + msg logger.error(m, *args) hdlr.error = True |
m = "error: " + msg logger.error(m, *args) | logger.error(*args) | def error(msg, *args): "Log an error" m = "error: " + msg logger.error(m, *args) hdlr.error = True |
def warning(msg, *args): "Log a warning" m = "warning: " + msg logger.warning(m, *args) | def warning(*args): "Log a warning" logger.warning(*args) | def warning(msg, *args): "Log a warning" m = "warning: " + msg logger.warning(m, *args) |
def info(msg, *args): | def info(*args): | def info(msg, *args): "Log an informative message" m = "+ " + msg logger.info(m, *args) |
m = "+ " + msg logger.info(m, *args) | logger.info(*args) | def info(msg, *args): "Log an informative message" m = "+ " + msg logger.info(m, *args) |
def debug(msg, *args): | def debug(*args): | def debug(msg, *args): "Log a debugging message" m = "+ " + msg logger.debug(m, *args) |
m = "+ " + msg logger.debug(m, *args) | logger.debug(*args) | def debug(msg, *args): "Log a debugging message" m = "+ " + msg logger.debug(m, *args) |
logger = logging.getLogger(LOGGER_CONARY) | logging.addLevelName(logging.WARNING, "warning:") logging.addLevelName(logging.ERROR, "error:") logging.addLevelName(logging.INFO, "+") logging.addLevelName(logging.DEBUG, "+") logger = logging.getLogger('conary') | def emit(self, record): logging.StreamHandler.emit(self, record) |
formatter = logging.Formatter('%(message)s') | formatter = logging.Formatter('%(levelname)s %(message)s') | def emit(self, record): logging.StreamHandler.emit(self, record) |
'%(libdir)s/python.*/site-packages/.*.a$' | r'%(libdir)s/python.*/site-packages/.*\.a$' | def doFile(self, path): |
def __init__(self, fileId, info = None): if (info): | def __init__(self, fileId, line = None): if (line): | def __init__(self, fileId, info = None): |
File.__init__(self, fileId, info, infoTag = "l") | File.__init__(self, fileId, line, infoTag = "l") | def __init__(self, fileId, info = None): |
except e, value: | except: | def commitChangeSet(self, cs): |
def _rename(self, oldPath, newPath): self.renames.append((oldPath, newPath)) def _restore(self, fileObj, target, contents): self.restores.append((fileObj, target, contents)) def _remove(self, fileObj, target): self.removes.append((fileObj, target)) | def _rename(self, oldPath, newPath, msg): self.renames.append((oldPath, newPath, msg)) def _restore(self, fileObj, target, contents, msg): self.restores.append((fileObj, target, contents, msg)) def _remove(self, fileObj, target, msg): self.removes.append((fileObj, target, msg)) def _createFile(self, target, str, msg... | def _rename(self, oldPath, newPath): |
for (oldPath, newPath) in self.renames: | for (oldPath, newPath, msg) in self.renames: | def apply(self): |
for (fileObj, target, contents) in self.restores: | log.debug(msg) for (fileObj, target, contents, msg) in self.restores: | def apply(self): |
for (fileObj, target) in self.removes: | log.debug(msg) for (fileObj, target, msg) in self.removes: | def apply(self): |
log.error("%s is in the way of a newly created file" % headRealPath) | self.errors.append("%s is in the way of a newly " + "created file" % headRealPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.debug("creating %s" % headRealPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): | |
self._restore(headFile, headRealPath, headFileContents) | self._restore(headFile, headRealPath, headFileContents, "creating %s" % headRealPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.error("%s has changed but has been removed on head" % path) | self.errors.append("%s has changed but has been removed " + "on head" % path) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.debug("removing %s" % path) self._remove(oldFile, realPath) | self._remove(oldFile, realPath, "removing %s" % path) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.debug("renaming %s to %s" % (fsPath, headPath)) self._rename(rootFixup + fsPath, rootFixup + headPath) | self._rename(rootFixup + fsPath, rootFixup + headPath, "renaming %s to %s" % (fsPath, headPath)) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.error("path conflict for %s (%s on head)" % | self.errors.append("path conflict for %s (%s on head)" % | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.error("new file %s conflicts with file on head of branch" % realPath) | self.errors.append("new file %s conflicts with file on " + "head of branch" % realPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.debug("replacing %s with contents from repository" % realPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): | |
self._restore(headFile, realPath, headFileContents) | self._restore(headFile, realPath, headFileContents, "replacing %s with contents from repository" % realPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.error("contents conflict for %s" % realPath) | self.errors.append("unexpected content type for %s" % realPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.debug("merging changes from repository into %s" % realPath) | cur = open(realPath, "r").readlines() | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
cur = open(realPath, "r").readlines() | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): | |
f = open(realPath, "w") f.write("".join(newLines)) | self._createFile(realPath, "".join(newLines), "merging changes from repository into %s" % realPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.warning("conflicts from merging changes from " + "head into %s saved as %s.conflicts" % (realPath, realPath)) failedHunks.write(realPath + ".conflicts", "current", "head") | self._createFile(realPath + ".conflicts", failedHunks.asString(), "conflicts from merging changes from " + "head into %s saved as %s.conflicts" % (realPath, realPath)) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
log.error("files conflict for %s" % realPath) | self.errors.append("files conflict for %s" % realPath) | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): |
def getNewPackageList(self): return self.newPackages | def _singlePackage(self, repos, pkgCs, changeSet, basePkg, fsPkg, root): | |
self.absolute = 1 | self.absolute = True | def newPackage(self, csPkg): |
self.absolute = 0 | self.absolute = False | def __init__(self, data = None): |
job = RootChangeSetJob(db, self) | def rootChangeSet(self, db, keepExisting): | |
self.primaryTroveList = [] self.files = {} self.oldPackages = [] items = [] for newPkg in job.newPackageList(): items.append((newPkg.getName(), newPkg.getVersion(), newPkg.getFlavor())) | newFiles = [] newPackages = [] items = [ (x.getName(), x.getNewVersion(), x.getNewFlavor() ) for x in self.iterNewPackageList() ] | def rootChangeSet(self, db, keepExisting): |
for newPkg in job.newPackageList(): pkgName = newPkg.getName() newVersion = newPkg.getVersion() newFlavor = newPkg.getFlavor() key = (pkgName, newVersion, newFlavor) | for troveCs in self.iterNewPackageList(): troveName = troveCs.getName() newVersion = troveCs.getNewVersion() newFlavor = troveCs.getNewFlavor() assert(not troveCs.getOldVersion()) key = (troveName, newVersion, newFlavor) | def rootChangeSet(self, db, keepExisting): |
pkgName, newVersion.asString()) | troveName, newVersion.asString()) | def rootChangeSet(self, db, keepExisting): |
old = db.getTrove(pkgName, oldVersion, oldFlavor, | old = db.getTrove(troveName, oldVersion, oldFlavor, | def rootChangeSet(self, db, keepExisting): |
self.newPackage(pkgChgSet) | newPackages.append(pkgChgSet) | def rootChangeSet(self, db, keepExisting): |
(fileObj, fileVersion) = job.getFile(fileId) assert(newVersion == fileVersion) | (foldVersion, fNewVersion, filecs) = self.getFile(fileId) assert(not foldVersion) assert(newVersion == fNewVersion) fileObj = files.ThawFile(filecs, fileId) | def rootChangeSet(self, db, keepExisting): |
self.addFile(fileId, oldVersion, newVersion, filecs) | newFiles.append((fileId, oldVersion, newVersion, filecs)) | def rootChangeSet(self, db, keepExisting): |
if trvCs.isAbsolute(): self.absolute = 1 | if not trvCs.isAbsolute(): self.absolute = False empty = False | def __init__(self, fileName, skipValidate = 1): if type(fileName) is str: f = open(fileName, "r") csf = filecontainer.FileContainer(f) else: csf = filecontainer.FileContainer(fileName) |
class RootChangeSetJob(repository.ChangeSetJob): storeOnlyConfigFiles = True def addPackage(self, pkg): self.packages.append(pkg) def newPackageList(self): return self.packages def oldPackage(self, pkg): self.oldPackages.append(pkg) def oldPackageList(self): return self.oldPackages def oldFile(self, fileId, fileV... | def CreateFromFilesystem(pkgList): cs = ChangeSet() for (pkg, fileMap) in pkgList: (pkgChgSet, filesNeeded, pkgsNeeded) = pkg.diff(None, absolute = 1) cs.newPackage(pkgChgSet) for (fileId, oldVersion, newVersion) in filesNeeded: (file, realPath, filePath) = fileMap[fileId] (filecs, hash) = fileChangeSet(fileId, None,... | |
if m | if m: | def doFile(self, file): m = self.recipe.magic[file] |
if os.path.exists(scandeps): | if (os.path.exists(scandeps) and os.path.exists('%s/scripts/perlreqs.pl' % basedir)): | def _getPerlReqs(self, path, fullpath): if self.perlReqs is None: self._fetchPerl() if not self.perlPath: # no perl == bootstrap, but print warning self.info('Unable to find perl interpreter,' ' disabling perl: requirements') self.perlReqs = False return [] # get the base directory where conary lives. In a checked # o... |
keywords = {'level': '1', | keywords = {'level': None, | def do(self): |
@keyword level: By default, one level of initial subdirectory names is stripped out prior to applying the patch. The C{level} keyword allows specification of additional initial subdirectory levels to be removed. | @keyword level: Deprecated! By default, conary attempts to patch the source using 1,0,2,3 resolve levels. The C{level} keyword allows manual specification of the number of initial subdirectory levels to be removed, but is preserved only so that older recipes can be cooked without modification. | def __init__(self, recipe, *args, **keywords): |
if self.backup: self.backup = '-b -z %s' % self.backup | def do(self): | |
log.info('applying macros to patch %s' %f) pin = util.popen("%s '%s'" %(provides, f)) log.info('patch -d %s -p%s %s %s' %(destDir, self.level, self.backup, self.extraArgs)) pout = util.popen('patch -d %s -p%s %s %s' %(destDir, self.level, self.backup, self.extraArgs), 'w') pout.write(pin.read()%self.recipe.macros) pin.... | patch = os.fdopen(slurppatch[0]).read() % self.recipe.macros | def do(self): |
util.execute("%s '%s' | patch -d %s -p%s %s %s" %(provides, f, destDir, self.level, self.backup, self.extraArgs)) | patch = os.fdopen(slurppatch[0]).read() self.patchme(patch, f, destDir, leveltuple) | def do(self): |
print troveName, branch, version, language | def getMetadata(self, authToken, clientVersion, troveList, language): metadata = {} # XXX optimize this to one SQL query downstream for troveName, branch, version in troveList: branch = self.toBranch(branch) if version: version = self.toVersion(version) else: version = None print troveName, branch, version, language m... | |
print md | def getMetadata(self, authToken, clientVersion, troveList, language): metadata = {} # XXX optimize this to one SQL query downstream for troveName, branch, version in troveList: branch = self.toBranch(branch) if version: version = self.toVersion(version) else: version = None print troveName, branch, version, language m... | |
def formatToFile(self, changeSet, cfg, f): | def formatToFile(self, changeSet, f): | def formatToFile(self, changeSet, cfg, f): |
f.write("from %s to " % self.oldVersion.asString(cfg.defaultbranch)) | f.write("from %s to " % self.oldVersion.asString()) | def formatToFile(self, changeSet, cfg, f): |
f.write("%s\n" % self.newVersion.asString(cfg.defaultbranch)) | f.write("%s\n" % self.newVersion.asString()) | def formatToFile(self, changeSet, cfg, f): |
list = [ x[0] + x[1].asString(cfg.defaultbranch) for x in self.packages[name] ] | list = [ x[0] + x[1].asString() for x in self.packages[name] ] | def depformat(name, dep, f): f.write('\t%s: %s\n' %(name, str(dep).replace('\n', '\n\t%s' %(' '* (len(name)+2))))) |
self.keywords['PRIMARYKEY'] = 'INTEGER PRIMARY KEY AUTOINCREMENT' | from conary.dbstore import sqlite_drv self.keywords = sqlite_drv.KeywordDict() | def __init__(self, showTables = True, driver="sqlite"): self.tables = self.views = self.sequences = [] self.tempTables = [] self.version = 0 self.showTables = showTables self.statements = [] self.driver = driver if self.driver == "sqlite": self.keywords['PRIMARYKEY'] = 'INTEGER PRIMARY KEY AUTOINCREMENT' elif driver ==... |
self.keywords['PRIMARYKEY'] = 'INTEGER PRIMARY KEY AUTO_INCREMENT' | from conary.dbstore import mysql_drv self.keywords = mysql_drv.KeywordDict() | def __init__(self, showTables = True, driver="sqlite"): self.tables = self.views = self.sequences = [] self.tempTables = [] self.version = 0 self.showTables = showTables self.statements = [] self.driver = driver if self.driver == "sqlite": self.keywords['PRIMARYKEY'] = 'INTEGER PRIMARY KEY AUTOINCREMENT' elif driver ==... |
self.keywords['BINARY'] = 'VARCHAR' self.keywords['BLOB'] = 'BYTEA' self.keywords['MEDIUMBLOB'] = 'BYTEA' self.keywords['PRIMARYKEY'] = 'SERIAL PRIMARY KEY' | from conary.dbstore import postgresql_drv self.keywords = postgresql_drv.KeywordDict() | def __init__(self, showTables = True, driver="sqlite"): self.tables = self.views = self.sequences = [] self.tempTables = [] self.version = 0 self.showTables = showTables self.statements = [] self.driver = driver if self.driver == "sqlite": self.keywords['PRIMARYKEY'] = 'INTEGER PRIMARY KEY AUTOINCREMENT' elif driver ==... |
if f.endswith(".tar"): tarflags = "-xf" elif (isinstance(m, magic.bzip) or f.endswith(".bz2") or f.endswith(".tbz2")): tarflags = "-jxf" elif (isinstance(m, magic.gzip) or f.endswith(".gz") or f.endswith(".tgz") or f.endswith(".Z")): tarflags = "-zxf" | _uncompress = "cat" _tarSuffix = ["tar", "tgz", "tbz2", "taZ", "tar.gz", "tar.bz2", "tar.Z"] _cpioSuffix = ["cpio", "cpio.gz", "cpio.bz2"] if True in [f.endswith(x) for x in _tarSuffix]: _unpack = "tar -C %s -xf -" % (destDir,) elif True in [f.endswith(x) for x in _cpioSuffix]: _unpack = "( cd %s ; cpio -imd )" % (... | def do(self): |
raise SourceError, "unknown archive compression" util.execute("tar -C %s %s %s" % (destDir, tarflags, f)) | raise SourceError, "unknown archive compression: " + f if isinstance(m, magic.bzip) or f.endswith("bz2"): _uncompress = "bzip2 -d -c" if isinstance(m, magic.gzip) or f.endswith("gz") \ or f.endswith(".Z"): _uncompress = "gzip -d -c" util.execute("%s < %s | %s" % (_uncompress, f, _unpack)) | def do(self): |
return (True, ("RepositoryClosed", self.cfg.closedMessage)) | return (True, ("RepositoryClosed", self.cfg.closed)) | def callWrapper(self, *args): return (True, ("RepositoryClosed", self.cfg.closedMessage)) |
def __init__(self): | def __init__(self, path="serverrc"): | def __init__(self): |
self.read("serverrc") | self.read(path) | def __init__(self): |
print "usage message goes here" | print "usage: %s repospath authdb reposname [config file]" %sys.argv[0] | def usage(): print "usage message goes here" sys.exit(1) |
cfg = ServerConfig() | def usage(): print "usage message goes here" sys.exit(1) | |
print "needs path to the repository, and authorization database, and the name of this repository" sys.exit(1) | usage() | def usage(): print "usage message goes here" sys.exit(1) |
cs.merge(how) | cs.merge(what) | def applyUpdate(self, theCs, replaceFiles = False, tagScript = None, keepExisting = None): assert(isinstance(theCs, changeset.MergeableChangeSet)) cs = changeset.MergeableChangeSet() for (how, what) in theCs.contents: if how == self.repos.createChangeSet: newCs = self.repos.createChangeSet(what) cs.merge(newCs) else: a... |
if os.path.exists and not os.path.isdir(path) \ | if os.path.exists(path) and not os.path.isdir(path) \ | def _sosymlink(self, dirname, names): |
def countConflicts(self, src, srcLine): | def countConflicts(self, src, origSrcLine): | def countConflicts(self, src, srcLine): |
devnull = open('/dev/null', 'w') | def patchme(self, patch, f, destDir, patchlevels): devnull = open('/dev/null', 'w') for patchlevel in patchlevels: patchArgs = [ 'nohup', 'patch', '-d', destDir, '-p%s'%patchlevel, ] if self.backup: patchArgs.extend(['-b', '-z', self.backup]) if self.extraArgs: patchArgs.extend(self.extraArgs) | |
patchArgs = [ 'nohup', 'patch', '-d', destDir, '-p%s'%patchlevel, ] | patchArgs = [ 'patch', '-d', destDir, '-p%s'%patchlevel, ] | def patchme(self, patch, f, destDir, patchlevels): devnull = open('/dev/null', 'w') for patchlevel in patchlevels: patchArgs = [ 'nohup', 'patch', '-d', destDir, '-p%s'%patchlevel, ] if self.backup: patchArgs.extend(['-b', '-z', self.backup]) if self.extraArgs: patchArgs.extend(self.extraArgs) |
pipe = os.pipe() fcntl.fcntl(pipe[1], fcntl.F_SETFD, 1) p2 = subprocess.Popen(patchArgs, stdin=pipe[0], stderr=devnull, shell=False) os.close(pipe[0]) | fd, path = tempfile.mkstemp() os.unlink(path) logFile = os.fdopen(fd, 'w+') inFd, outFd = os.pipe() p2 = subprocess.Popen(patchArgs, stdin=inFd, stderr=logFile, shell=False, stdout=logFile, close_fds=True) os.close(inFd) | def patchme(self, patch, f, destDir, patchlevels): devnull = open('/dev/null', 'w') for patchlevel in patchlevels: patchArgs = [ 'nohup', 'patch', '-d', destDir, '-p%s'%patchlevel, ] if self.backup: patchArgs.extend(['-b', '-z', self.backup]) if self.extraArgs: patchArgs.extend(self.extraArgs) |
offset += os.write(pipe[1], patch[offset:]) os.close(pipe[1]) | offset += os.write(outFd, patch[offset:]) os.close(outFd) failed = p2.wait() | def patchme(self, patch, f, destDir, patchlevels): devnull = open('/dev/null', 'w') for patchlevel in patchlevels: patchArgs = [ 'nohup', 'patch', '-d', destDir, '-p%s'%patchlevel, ] if self.backup: patchArgs.extend(['-b', '-z', self.backup]) if self.extraArgs: patchArgs.extend(self.extraArgs) |
logmessage = open('nohup.out').read() os.unlink('nohup.out') print logmessage.strip() | logFile.flush() logFile.seek(0,0) print logFile.read().strip() | def patchme(self, patch, f, destDir, patchlevels): devnull = open('/dev/null', 'w') for patchlevel in patchlevels: patchArgs = [ 'nohup', 'patch', '-d', destDir, '-p%s'%patchlevel, ] if self.backup: patchArgs.extend(['-b', '-z', self.backup]) if self.extraArgs: patchArgs.extend(self.extraArgs) |
if p2.wait(): | logFile.close() if failed: | def patchme(self, patch, f, destDir, patchlevels): devnull = open('/dev/null', 'w') for patchlevel in patchlevels: patchArgs = [ 'nohup', 'patch', '-d', destDir, '-p%s'%patchlevel, ] if self.backup: patchArgs.extend(['-b', '-z', self.backup]) if self.extraArgs: patchArgs.extend(self.extraArgs) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.