Mercurial > hg
view hgext/largefiles/lfcommands.py @ 43256:00de32aa834e
copies: use an unfiltered repository for the changeset centric algorithm
Since the algorithm work form heads to ancestors, we don't need to check
filtering for anything but the two entries.
Using an unfiltered version is noticeably more efficient.
Some timing on the pypy repo:
revision: large amount; added files: large amount; rename small amount; c3b14617fbd7 9ba6ab77fd29
before: ! wall 2.717861 comb 2.720000 user 2.700000 sys 0.020000 (median of 10)
after: ! wall 2.582204 comb 2.580000 user 2.560000 sys 0.020000 (median of 10)
revision: large amount; added files: small amount; rename small amount; c3b14617fbd7 f650a9b140d2
before: ! wall 4.003146 comb 4.010000 user 3.970000 sys 0.040000 (median of 10)
after: ! wall 3.814613 comb 3.810000 user 3.760000 sys 0.050000 (median of 10)
revision: large amount; added files: large amount; rename large amount; 08ea3258278e d9fa043f30c0
before: ! wall 0.704204 comb 0.700000 user 0.700000 sys 0.000000 (median of 13)
after: ! wall 0.657387 comb 0.650000 user 0.640000 sys 0.010000 (best of 14)
revision: small amount; added files: large amount; rename large amount; df6f7a526b60 a83dc6a2d56f
before: ! wall 0.013493 comb 0.020000 user 0.020000 sys 0.000000 (median of 219)
after: ! wall 0.013523 comb 0.020000 user 0.020000 sys 0.000000 (median of 218)
revision: small amount; added files: large amount; rename small amount; 4aa4e1f8e19a 169138063d63
before: ! wall 0.003017 comb 0.000000 user 0.000000 sys 0.000000 (median of 985)
after: ! wall 0.002876 comb 0.000000 user 0.000000 sys 0.000000 (median of 1000)
revision: small amount; added files: small amount; rename small amount; 4bc173b045a6 964879152e2e
before: ! wall 0.000073 comb 0.000000 user 0.000000 sys 0.000000 (median of 12672)
after: ! wall 0.000082 comb 0.000000 user 0.000000 sys 0.000000 (median of 11456)
revision: medium amount; added files: large amount; rename medium amount; c95f1ced15f2 2c68e87c3efe
before: ! wall 0.478061 comb 0.470000 user 0.470000 sys 0.000000 (median of 19)
after: ! wall 0.452420 comb 0.450000 user 0.450000 sys 0.000000 (median of 21)
revision: medium amount; added files: medium amount; rename small amount; d343da0c55a8 d7746d32bf9d
before: ! wall 0.116015 comb 0.110000 user 0.110000 sys 0.000000 (median of 84)
after: ! wall 0.109153 comb 0.100000 user 0.100000 sys 0.000000 (median of 90)
Differential Revision: https://phab.mercurial-scm.org/D7123
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Tue, 15 Oct 2019 18:42:03 +0200 |
parents | 687b865b95ad |
children | 9f70512ae2cf |
line wrap: on
line source
# Copyright 2009-2010 Gregory P. Ward # Copyright 2009-2010 Intelerad Medical Systems Incorporated # Copyright 2010-2011 Fog Creek Software # Copyright 2010-2011 Unity Technologies # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. '''High-level command function for lfconvert, plus the cmdtable.''' from __future__ import absolute_import import errno import hashlib import os import shutil from mercurial.i18n import _ from mercurial import ( cmdutil, context, error, exthelper, hg, lock, match as matchmod, node, pycompat, scmutil, util, ) from ..convert import ( convcmd, filemap, ) from . import lfutil, storefactory release = lock.release # -- Commands ---------------------------------------------------------- eh = exthelper.exthelper() @eh.command( b'lfconvert', [ ( b's', b'size', b'', _(b'minimum size (MB) for files to be converted as largefiles'), b'SIZE', ), ( b'', b'to-normal', False, _(b'convert from a largefiles repo to a normal repo'), ), ], _(b'hg lfconvert SOURCE DEST [FILE ...]'), norepo=True, inferrepo=True, ) def lfconvert(ui, src, dest, *pats, **opts): '''convert a normal repository to a largefiles repository Convert repository SOURCE to a new repository DEST, identical to SOURCE except that certain files will be converted as largefiles: specifically, any file that matches any PATTERN *or* whose size is above the minimum size threshold is converted as a largefile. The size used to determine whether or not to track a file as a largefile is the size of the first version of the file. The minimum size can be specified either with --size or in configuration as ``largefiles.size``. After running this command you will need to make sure that largefiles is enabled anywhere you intend to push the new repository. Use --to-normal to convert largefiles back to normal files; after this, the DEST repository can be used without largefiles at all.''' opts = pycompat.byteskwargs(opts) if opts[b'to_normal']: tolfile = False else: tolfile = True size = lfutil.getminsize(ui, True, opts.get(b'size'), default=None) if not hg.islocal(src): raise error.Abort(_(b'%s is not a local Mercurial repo') % src) if not hg.islocal(dest): raise error.Abort(_(b'%s is not a local Mercurial repo') % dest) rsrc = hg.repository(ui, src) ui.status(_(b'initializing destination %s\n') % dest) rdst = hg.repository(ui, dest, create=True) success = False dstwlock = dstlock = None try: # Get a list of all changesets in the source. The easy way to do this # is to simply walk the changelog, using changelog.nodesbetween(). # Take a look at mercurial/revlog.py:639 for more details. # Use a generator instead of a list to decrease memory usage ctxs = ( rsrc[ctx] for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0] ) revmap = {node.nullid: node.nullid} if tolfile: # Lock destination to prevent modification while it is converted to. # Don't need to lock src because we are just reading from its # history which can't change. dstwlock = rdst.wlock() dstlock = rdst.lock() lfiles = set() normalfiles = set() if not pats: pats = ui.configlist(lfutil.longname, b'patterns') if pats: matcher = matchmod.match(rsrc.root, b'', list(pats)) else: matcher = None lfiletohash = {} with ui.makeprogress( _(b'converting revisions'), unit=_(b'revisions'), total=rsrc[b'tip'].rev(), ) as progress: for ctx in ctxs: progress.update(ctx.rev()) _lfconvert_addchangeset( rsrc, rdst, ctx, revmap, lfiles, normalfiles, matcher, size, lfiletohash, ) if rdst.wvfs.exists(lfutil.shortname): rdst.wvfs.rmtree(lfutil.shortname) for f in lfiletohash.keys(): if rdst.wvfs.isfile(f): rdst.wvfs.unlink(f) try: rdst.wvfs.removedirs(rdst.wvfs.dirname(f)) except OSError: pass # If there were any files converted to largefiles, add largefiles # to the destination repository's requirements. if lfiles: rdst.requirements.add(b'largefiles') rdst._writerequirements() else: class lfsource(filemap.filemap_source): def __init__(self, ui, source): super(lfsource, self).__init__(ui, source, None) self.filemapper.rename[lfutil.shortname] = b'.' def getfile(self, name, rev): realname, realrev = rev f = super(lfsource, self).getfile(name, rev) if ( not realname.startswith(lfutil.shortnameslash) or f[0] is None ): return f # Substitute in the largefile data for the hash hash = f[0].strip() path = lfutil.findfile(rsrc, hash) if path is None: raise error.Abort( _(b"missing largefile for '%s' in %s") % (realname, realrev) ) return util.readfile(path), f[1] class converter(convcmd.converter): def __init__(self, ui, source, dest, revmapfile, opts): src = lfsource(ui, source) super(converter, self).__init__( ui, src, dest, revmapfile, opts ) found, missing = downloadlfiles(ui, rsrc) if missing != 0: raise error.Abort(_(b"all largefiles must be present locally")) orig = convcmd.converter convcmd.converter = converter try: convcmd.convert( ui, src, dest, source_type=b'hg', dest_type=b'hg' ) finally: convcmd.converter = orig success = True finally: if tolfile: rdst.dirstate.clear() release(dstlock, dstwlock) if not success: # we failed, remove the new directory shutil.rmtree(rdst.root) def _lfconvert_addchangeset( rsrc, rdst, ctx, revmap, lfiles, normalfiles, matcher, size, lfiletohash ): # Convert src parents to dst parents parents = _convertparents(ctx, revmap) # Generate list of changed files files = _getchangedfiles(ctx, parents) dstfiles = [] for f in files: if f not in lfiles and f not in normalfiles: islfile = _islfile(f, ctx, matcher, size) # If this file was renamed or copied then copy # the largefile-ness of its predecessor if f in ctx.manifest(): fctx = ctx.filectx(f) renamed = fctx.copysource() if renamed is None: # the code below assumes renamed to be a boolean or a list # and won't quite work with the value None renamed = False renamedlfile = renamed and renamed in lfiles islfile |= renamedlfile if b'l' in fctx.flags(): if renamedlfile: raise error.Abort( _(b'renamed/copied largefile %s becomes symlink') % f ) islfile = False if islfile: lfiles.add(f) else: normalfiles.add(f) if f in lfiles: fstandin = lfutil.standin(f) dstfiles.append(fstandin) # largefile in manifest if it has not been removed/renamed if f in ctx.manifest(): fctx = ctx.filectx(f) if b'l' in fctx.flags(): renamed = fctx.copysource() if renamed and renamed in lfiles: raise error.Abort( _(b'largefile %s becomes symlink') % f ) # largefile was modified, update standins m = hashlib.sha1(b'') m.update(ctx[f].data()) hash = node.hex(m.digest()) if f not in lfiletohash or lfiletohash[f] != hash: rdst.wwrite(f, ctx[f].data(), ctx[f].flags()) executable = b'x' in ctx[f].flags() lfutil.writestandin(rdst, fstandin, hash, executable) lfiletohash[f] = hash else: # normal file dstfiles.append(f) def getfilectx(repo, memctx, f): srcfname = lfutil.splitstandin(f) if srcfname is not None: # if the file isn't in the manifest then it was removed # or renamed, return None to indicate this try: fctx = ctx.filectx(srcfname) except error.LookupError: return None renamed = fctx.copysource() if renamed: # standin is always a largefile because largefile-ness # doesn't change after rename or copy renamed = lfutil.standin(renamed) return context.memfilectx( repo, memctx, f, lfiletohash[srcfname] + b'\n', b'l' in fctx.flags(), b'x' in fctx.flags(), renamed, ) else: return _getnormalcontext(repo, ctx, f, revmap) # Commit _commitcontext(rdst, parents, ctx, dstfiles, getfilectx, revmap) def _commitcontext(rdst, parents, ctx, dstfiles, getfilectx, revmap): mctx = context.memctx( rdst, parents, ctx.description(), dstfiles, getfilectx, ctx.user(), ctx.date(), ctx.extra(), ) ret = rdst.commitctx(mctx) lfutil.copyalltostore(rdst, ret) rdst.setparents(ret) revmap[ctx.node()] = rdst.changelog.tip() # Generate list of changed files def _getchangedfiles(ctx, parents): files = set(ctx.files()) if node.nullid not in parents: mc = ctx.manifest() for pctx in ctx.parents(): for fn in pctx.manifest().diff(mc): files.add(fn) return files # Convert src parents to dst parents def _convertparents(ctx, revmap): parents = [] for p in ctx.parents(): parents.append(revmap[p.node()]) while len(parents) < 2: parents.append(node.nullid) return parents # Get memfilectx for a normal file def _getnormalcontext(repo, ctx, f, revmap): try: fctx = ctx.filectx(f) except error.LookupError: return None renamed = fctx.copysource() data = fctx.data() if f == b'.hgtags': data = _converttags(repo.ui, revmap, data) return context.memfilectx( repo, ctx, f, data, b'l' in fctx.flags(), b'x' in fctx.flags(), renamed ) # Remap tag data using a revision map def _converttags(ui, revmap, data): newdata = [] for line in data.splitlines(): try: id, name = line.split(b' ', 1) except ValueError: ui.warn(_(b'skipping incorrectly formatted tag %s\n') % line) continue try: newid = node.bin(id) except TypeError: ui.warn(_(b'skipping incorrectly formatted id %s\n') % id) continue try: newdata.append(b'%s %s\n' % (node.hex(revmap[newid]), name)) except KeyError: ui.warn(_(b'no mapping for id %s\n') % id) continue return b''.join(newdata) def _islfile(file, ctx, matcher, size): '''Return true if file should be considered a largefile, i.e. matcher matches it or it is larger than size.''' # never store special .hg* files as largefiles if file == b'.hgtags' or file == b'.hgignore' or file == b'.hgsigs': return False if matcher and matcher(file): return True try: return ctx.filectx(file).size() >= size * 1024 * 1024 except error.LookupError: return False def uploadlfiles(ui, rsrc, rdst, files): '''upload largefiles to the central store''' if not files: return store = storefactory.openstore(rsrc, rdst, put=True) at = 0 ui.debug(b"sending statlfile command for %d largefiles\n" % len(files)) retval = store.exists(files) files = [h for h in files if not retval[h]] ui.debug(b"%d largefiles need to be uploaded\n" % len(files)) with ui.makeprogress( _(b'uploading largefiles'), unit=_(b'files'), total=len(files) ) as progress: for hash in files: progress.update(at) source = lfutil.findfile(rsrc, hash) if not source: raise error.Abort( _( b'largefile %s missing from store' b' (needs to be uploaded)' ) % hash ) # XXX check for errors here store.put(source, hash) at += 1 def verifylfiles(ui, repo, all=False, contents=False): '''Verify that every largefile revision in the current changeset exists in the central store. With --contents, also verify that the contents of each local largefile file revision are correct (SHA-1 hash matches the revision ID). With --all, check every changeset in this repository.''' if all: revs = repo.revs(b'all()') else: revs = [b'.'] store = storefactory.openstore(repo) return store.verify(revs, contents=contents) def cachelfiles(ui, repo, node, filelist=None): '''cachelfiles ensures that all largefiles needed by the specified revision are present in the repository's largefile cache. returns a tuple (cached, missing). cached is the list of files downloaded by this operation; missing is the list of files that were needed but could not be found.''' lfiles = lfutil.listlfiles(repo, node) if filelist: lfiles = set(lfiles) & set(filelist) toget = [] ctx = repo[node] for lfile in lfiles: try: expectedhash = lfutil.readasstandin(ctx[lfutil.standin(lfile)]) except IOError as err: if err.errno == errno.ENOENT: continue # node must be None and standin wasn't found in wctx raise if not lfutil.findfile(repo, expectedhash): toget.append((lfile, expectedhash)) if toget: store = storefactory.openstore(repo) ret = store.get(toget) return ret return ([], []) def downloadlfiles(ui, repo, rev=None): match = scmutil.match(repo[None], [repo.wjoin(lfutil.shortname)], {}) def prepare(ctx, fns): pass totalsuccess = 0 totalmissing = 0 if rev != []: # walkchangerevs on empty list would return all revs for ctx in cmdutil.walkchangerevs(repo, match, {b'rev': rev}, prepare): success, missing = cachelfiles(ui, repo, ctx.node()) totalsuccess += len(success) totalmissing += len(missing) ui.status(_(b"%d additional largefiles cached\n") % totalsuccess) if totalmissing > 0: ui.status(_(b"%d largefiles failed to download\n") % totalmissing) return totalsuccess, totalmissing def updatelfiles( ui, repo, filelist=None, printmessage=None, normallookup=False ): '''Update largefiles according to standins in the working directory If ``printmessage`` is other than ``None``, it means "print (or ignore, for false) message forcibly". ''' statuswriter = lfutil.getstatuswriter(ui, repo, printmessage) with repo.wlock(): lfdirstate = lfutil.openlfdirstate(ui, repo) lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate) if filelist is not None: filelist = set(filelist) lfiles = [f for f in lfiles if f in filelist] update = {} dropped = set() updated, removed = 0, 0 wvfs = repo.wvfs wctx = repo[None] for lfile in lfiles: lfileorig = os.path.relpath( scmutil.backuppath(ui, repo, lfile), start=repo.root ) standin = lfutil.standin(lfile) standinorig = os.path.relpath( scmutil.backuppath(ui, repo, standin), start=repo.root ) if wvfs.exists(standin): if wvfs.exists(standinorig) and wvfs.exists(lfile): shutil.copyfile(wvfs.join(lfile), wvfs.join(lfileorig)) wvfs.unlinkpath(standinorig) expecthash = lfutil.readasstandin(wctx[standin]) if expecthash != b'': if lfile not in wctx: # not switched to normal file if repo.dirstate[standin] != b'?': wvfs.unlinkpath(lfile, ignoremissing=True) else: dropped.add(lfile) # use normallookup() to allocate an entry in largefiles # dirstate to prevent lfilesrepo.status() from reporting # missing files as removed. lfdirstate.normallookup(lfile) update[lfile] = expecthash else: # Remove lfiles for which the standin is deleted, unless the # lfile is added to the repository again. This happens when a # largefile is converted back to a normal file: the standin # disappears, but a new (normal) file appears as the lfile. if ( wvfs.exists(lfile) and repo.dirstate.normalize(lfile) not in wctx ): wvfs.unlinkpath(lfile) removed += 1 # largefile processing might be slow and be interrupted - be prepared lfdirstate.write() if lfiles: lfiles = [f for f in lfiles if f not in dropped] for f in dropped: repo.wvfs.unlinkpath(lfutil.standin(f)) # This needs to happen for dropped files, otherwise they stay in # the M state. lfutil.synclfdirstate(repo, lfdirstate, f, normallookup) statuswriter(_(b'getting changed largefiles\n')) cachelfiles(ui, repo, None, lfiles) for lfile in lfiles: update1 = 0 expecthash = update.get(lfile) if expecthash: if not lfutil.copyfromcache(repo, expecthash, lfile): # failed ... but already removed and set to normallookup continue # Synchronize largefile dirstate to the last modified # time of the file lfdirstate.normal(lfile) update1 = 1 # copy the exec mode of largefile standin from the repository's # dirstate to its state in the lfdirstate. standin = lfutil.standin(lfile) if wvfs.exists(standin): # exec is decided by the users permissions using mask 0o100 standinexec = wvfs.stat(standin).st_mode & 0o100 st = wvfs.stat(lfile) mode = st.st_mode if standinexec != mode & 0o100: # first remove all X bits, then shift all R bits to X mode &= ~0o111 if standinexec: mode |= (mode >> 2) & 0o111 & ~util.umask wvfs.chmod(lfile, mode) update1 = 1 updated += update1 lfutil.synclfdirstate(repo, lfdirstate, lfile, normallookup) lfdirstate.write() if lfiles: statuswriter( _(b'%d largefiles updated, %d removed\n') % (updated, removed) ) @eh.command( b'lfpull', [(b'r', b'rev', [], _(b'pull largefiles for these revisions'))] + cmdutil.remoteopts, _(b'-r REV... [-e CMD] [--remotecmd CMD] [SOURCE]'), ) def lfpull(ui, repo, source=b"default", **opts): """pull largefiles for the specified revisions from the specified source Pull largefiles that are referenced from local changesets but missing locally, pulling from a remote repository to the local cache. If SOURCE is omitted, the 'default' path will be used. See :hg:`help urls` for more information. .. container:: verbose Some examples: - pull largefiles for all branch heads:: hg lfpull -r "head() and not closed()" - pull largefiles on the default branch:: hg lfpull -r "branch(default)" """ repo.lfpullsource = source revs = opts.get(r'rev', []) if not revs: raise error.Abort(_(b'no revisions specified')) revs = scmutil.revrange(repo, revs) numcached = 0 for rev in revs: ui.note(_(b'pulling largefiles for revision %d\n') % rev) (cached, missing) = cachelfiles(ui, repo, rev) numcached += len(cached) ui.status(_(b"%d largefiles cached\n") % numcached) @eh.command(b'debuglfput', [] + cmdutil.remoteopts, _(b'FILE')) def debuglfput(ui, repo, filepath, **kwargs): hash = lfutil.hashfile(filepath) storefactory.openstore(repo).put(filepath, hash) ui.write(b'%s\n' % hash) return 0