largefiles: set the extension as enabled locally after a share requiring it

This has been done for clone since e1dbe0b215ae, so it makes sense here for the
same reasons.

hgext/largefiles/overrides.py

@@ -1,1460 +1,1468
 # 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.
 
 '''Overridden Mercurial commands and functions for the largefiles extension'''
 from __future__ import absolute_import
 
 import copy
 import os
 
 from mercurial.i18n import _
 
 from mercurial import (
     archival,
     cmdutil,
     error,
     hg,
     match as matchmod,
     pathutil,
     registrar,
     scmutil,
     smartset,
     util,
 )
 
 from . import (
     lfcommands,
     lfutil,
     storefactory,
 )
 
 # -- Utility functions: commonly/repeatedly needed functionality ---------------
 
 def composelargefilematcher(match, manifest):
     '''create a matcher that matches only the largefiles in the original
     matcher'''
     m = copy.copy(match)
     lfile = lambda f: lfutil.standin(f) in manifest
     m._files = filter(lfile, m._files)
     m._fileroots = set(m._files)
     m._always = False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: lfile(f) and origmatchfn(f)
     return m
 
 def composenormalfilematcher(match, manifest, exclude=None):
     excluded = set()
     if exclude is not None:
         excluded.update(exclude)
 
     m = copy.copy(match)
     notlfile = lambda f: not (lfutil.isstandin(f) or lfutil.standin(f) in
             manifest or f in excluded)
     m._files = filter(notlfile, m._files)
     m._fileroots = set(m._files)
     m._always = False
     origmatchfn = m.matchfn
     m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
     return m
 
 def installnormalfilesmatchfn(manifest):
     '''installmatchfn with a matchfn that ignores all largefiles'''
     def overridematch(ctx, pats=(), opts=None, globbed=False,
             default='relpath', badfn=None):
         if opts is None:
             opts = {}
         match = oldmatch(ctx, pats, opts, globbed, default, badfn=badfn)
         return composenormalfilematcher(match, manifest)
     oldmatch = installmatchfn(overridematch)
 
 def installmatchfn(f):
     '''monkey patch the scmutil module with a custom match function.
     Warning: it is monkey patching the _module_ on runtime! Not thread safe!'''
     oldmatch = scmutil.match
     setattr(f, 'oldmatch', oldmatch)
     scmutil.match = f
     return oldmatch
 
 def restorematchfn():
     '''restores scmutil.match to what it was before installmatchfn
     was called.  no-op if scmutil.match is its original function.
 
     Note that n calls to installmatchfn will require n calls to
     restore the original matchfn.'''
     scmutil.match = getattr(scmutil.match, 'oldmatch')
 
 def installmatchandpatsfn(f):
     oldmatchandpats = scmutil.matchandpats
     setattr(f, 'oldmatchandpats', oldmatchandpats)
     scmutil.matchandpats = f
     return oldmatchandpats
 
 def restorematchandpatsfn():
     '''restores scmutil.matchandpats to what it was before
     installmatchandpatsfn was called. No-op if scmutil.matchandpats
     is its original function.
 
     Note that n calls to installmatchandpatsfn will require n calls
     to restore the original matchfn.'''
     scmutil.matchandpats = getattr(scmutil.matchandpats, 'oldmatchandpats',
             scmutil.matchandpats)
 
 def addlargefiles(ui, repo, isaddremove, matcher, **opts):
     large = opts.get('large')
     lfsize = lfutil.getminsize(
         ui, lfutil.islfilesrepo(repo), opts.get('lfsize'))
 
     lfmatcher = None
     if lfutil.islfilesrepo(repo):
         lfpats = ui.configlist(lfutil.longname, 'patterns', default=[])
         if lfpats:
             lfmatcher = matchmod.match(repo.root, '', list(lfpats))
 
     lfnames = []
     m = matcher
 
     wctx = repo[None]
     for f in repo.walk(matchmod.badmatch(m, lambda x, y: None)):
         exact = m.exact(f)
         lfile = lfutil.standin(f) in wctx
         nfile = f in wctx
         exists = lfile or nfile
 
         # addremove in core gets fancy with the name, add doesn't
         if isaddremove:
             name = m.uipath(f)
         else:
             name = m.rel(f)
 
         # Don't warn the user when they attempt to add a normal tracked file.
         # The normal add code will do that for us.
         if exact and exists:
             if lfile:
                 ui.warn(_('%s already a largefile\n') % name)
             continue
 
         if (exact or not exists) and not lfutil.isstandin(f):
             # In case the file was removed previously, but not committed
             # (issue3507)
             if not repo.wvfs.exists(f):
                 continue
 
             abovemin = (lfsize and
                         repo.wvfs.lstat(f).st_size >= lfsize * 1024 * 1024)
             if large or abovemin or (lfmatcher and lfmatcher(f)):
                 lfnames.append(f)
                 if ui.verbose or not exact:
                     ui.status(_('adding %s as a largefile\n') % name)
 
     bad = []
 
     # Need to lock, otherwise there could be a race condition between
     # when standins are created and added to the repo.
     with repo.wlock():
         if not opts.get('dry_run'):
             standins = []
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             for f in lfnames:
                 standinname = lfutil.standin(f)
                 lfutil.writestandin(repo, standinname, hash='',
                     executable=lfutil.getexecutable(repo.wjoin(f)))
                 standins.append(standinname)
                 if lfdirstate[f] == 'r':
                     lfdirstate.normallookup(f)
                 else:
                     lfdirstate.add(f)
             lfdirstate.write()
             bad += [lfutil.splitstandin(f)
                     for f in repo[None].add(standins)
                     if f in m.files()]
 
         added = [f for f in lfnames if f not in bad]
     return added, bad
 
 def removelargefiles(ui, repo, isaddremove, matcher, **opts):
     after = opts.get('after')
     m = composelargefilematcher(matcher, repo[None].manifest())
     try:
         repo.lfstatus = True
         s = repo.status(match=m, clean=not isaddremove)
     finally:
         repo.lfstatus = False
     manifest = repo[None].manifest()
     modified, added, deleted, clean = [[f for f in list
                                         if lfutil.standin(f) in manifest]
                                        for list in (s.modified, s.added,
                                                     s.deleted, s.clean)]
 
     def warn(files, msg):
         for f in files:
             ui.warn(msg % m.rel(f))
         return int(len(files) > 0)
 
     result = 0
 
     if after:
         remove = deleted
         result = warn(modified + added + clean,
                       _('not removing %s: file still exists\n'))
     else:
         remove = deleted + clean
         result = warn(modified, _('not removing %s: file is modified (use -f'
                                   ' to force removal)\n'))
         result = warn(added, _('not removing %s: file has been marked for add'
                                ' (use forget to undo)\n')) or result
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in sorted(remove):
             if ui.verbose or not m.exact(f):
                 # addremove in core gets fancy with the name, remove doesn't
                 if isaddremove:
                     name = m.uipath(f)
                 else:
                     name = m.rel(f)
                 ui.status(_('removing %s\n') % name)
 
             if not opts.get('dry_run'):
                 if not after:
                     repo.wvfs.unlinkpath(f, ignoremissing=True)
 
         if opts.get('dry_run'):
             return result
 
         remove = [lfutil.standin(f) for f in remove]
         # If this is being called by addremove, let the original addremove
         # function handle this.
         if not isaddremove:
             for f in remove:
                 repo.wvfs.unlinkpath(f, ignoremissing=True)
         repo[None].forget(remove)
 
         for f in remove:
             lfutil.synclfdirstate(repo, lfdirstate, lfutil.splitstandin(f),
                                   False)
 
         lfdirstate.write()
 
     return result
 
 # For overriding mercurial.hgweb.webcommands so that largefiles will
 # appear at their right place in the manifests.
 def decodepath(orig, path):
     return lfutil.splitstandin(path) or path
 
 # -- Wrappers: modify existing commands --------------------------------
 
 def overrideadd(orig, ui, repo, *pats, **opts):
     if opts.get('normal') and opts.get('large'):
         raise error.Abort(_('--normal cannot be used with --large'))
     return orig(ui, repo, *pats, **opts)
 
 def cmdutiladd(orig, ui, repo, matcher, prefix, explicitonly, **opts):
     # The --normal flag short circuits this override
     if opts.get('normal'):
         return orig(ui, repo, matcher, prefix, explicitonly, **opts)
 
     ladded, lbad = addlargefiles(ui, repo, False, matcher, **opts)
     normalmatcher = composenormalfilematcher(matcher, repo[None].manifest(),
                                              ladded)
     bad = orig(ui, repo, normalmatcher, prefix, explicitonly, **opts)
 
     bad.extend(f for f in lbad)
     return bad
 
 def cmdutilremove(orig, ui, repo, matcher, prefix, after, force, subrepos):
     normalmatcher = composenormalfilematcher(matcher, repo[None].manifest())
     result = orig(ui, repo, normalmatcher, prefix, after, force, subrepos)
     return removelargefiles(ui, repo, False, matcher, after=after,
                             force=force) or result
 
 def overridestatusfn(orig, repo, rev2, **opts):
     try:
         repo._repo.lfstatus = True
         return orig(repo, rev2, **opts)
     finally:
         repo._repo.lfstatus = False
 
 def overridestatus(orig, ui, repo, *pats, **opts):
     try:
         repo.lfstatus = True
         return orig(ui, repo, *pats, **opts)
     finally:
         repo.lfstatus = False
 
 def overridedirty(orig, repo, ignoreupdate=False):
     try:
         repo._repo.lfstatus = True
         return orig(repo, ignoreupdate)
     finally:
         repo._repo.lfstatus = False
 
 def overridelog(orig, ui, repo, *pats, **opts):
     def overridematchandpats(ctx, pats=(), opts=None, globbed=False,
             default='relpath', badfn=None):
         """Matcher that merges root directory with .hglf, suitable for log.
         It is still possible to match .hglf directly.
         For any listed files run log on the standin too.
         matchfn tries both the given filename and with .hglf stripped.
         """
         if opts is None:
             opts = {}
         matchandpats = oldmatchandpats(ctx, pats, opts, globbed, default,
                                        badfn=badfn)
         m, p = copy.copy(matchandpats)
 
         if m.always():
             # We want to match everything anyway, so there's no benefit trying
             # to add standins.
             return matchandpats
 
         pats = set(p)
 
         def fixpats(pat, tostandin=lfutil.standin):
             if pat.startswith('set:'):
                 return pat
 
             kindpat = matchmod._patsplit(pat, None)
 
             if kindpat[0] is not None:
                 return kindpat[0] + ':' + tostandin(kindpat[1])
             return tostandin(kindpat[1])
 
         if m._cwd:
             hglf = lfutil.shortname
             back = util.pconvert(m.rel(hglf)[:-len(hglf)])
 
             def tostandin(f):
                 # The file may already be a standin, so truncate the back
                 # prefix and test before mangling it.  This avoids turning
                 # 'glob:../.hglf/foo*' into 'glob:../.hglf/../.hglf/foo*'.
                 if f.startswith(back) and lfutil.splitstandin(f[len(back):]):
                     return f
 
                 # An absolute path is from outside the repo, so truncate the
                 # path to the root before building the standin.  Otherwise cwd
                 # is somewhere in the repo, relative to root, and needs to be
                 # prepended before building the standin.
                 if os.path.isabs(m._cwd):
                     f = f[len(back):]
                 else:
                     f = m._cwd + '/' + f
                 return back + lfutil.standin(f)
 
             pats.update(fixpats(f, tostandin) for f in p)
         else:
             def tostandin(f):
                 if lfutil.isstandin(f):
                     return f
                 return lfutil.standin(f)
             pats.update(fixpats(f, tostandin) for f in p)
 
         for i in range(0, len(m._files)):
             # Don't add '.hglf' to m.files, since that is already covered by '.'
             if m._files[i] == '.':
                 continue
             standin = lfutil.standin(m._files[i])
             # If the "standin" is a directory, append instead of replace to
             # support naming a directory on the command line with only
             # largefiles.  The original directory is kept to support normal
             # files.
             if standin in ctx:
                 m._files[i] = standin
             elif m._files[i] not in ctx and repo.wvfs.isdir(standin):
                 m._files.append(standin)
 
         m._fileroots = set(m._files)
         m._always = False
         origmatchfn = m.matchfn
         def lfmatchfn(f):
             lf = lfutil.splitstandin(f)
             if lf is not None and origmatchfn(lf):
                 return True
             r = origmatchfn(f)
             return r
         m.matchfn = lfmatchfn
 
         ui.debug('updated patterns: %s\n' % sorted(pats))
         return m, pats
 
     # For hg log --patch, the match object is used in two different senses:
     # (1) to determine what revisions should be printed out, and
     # (2) to determine what files to print out diffs for.
     # The magic matchandpats override should be used for case (1) but not for
     # case (2).
     def overridemakelogfilematcher(repo, pats, opts, badfn=None):
         wctx = repo[None]
         match, pats = oldmatchandpats(wctx, pats, opts, badfn=badfn)
         return lambda rev: match
 
     oldmatchandpats = installmatchandpatsfn(overridematchandpats)
     oldmakelogfilematcher = cmdutil._makenofollowlogfilematcher
     setattr(cmdutil, '_makenofollowlogfilematcher', overridemakelogfilematcher)
 
     try:
         return orig(ui, repo, *pats, **opts)
     finally:
         restorematchandpatsfn()
         setattr(cmdutil, '_makenofollowlogfilematcher', oldmakelogfilematcher)
 
 def overrideverify(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     all = opts.pop('lfa', False)
     contents = opts.pop('lfc', False)
 
     result = orig(ui, repo, *pats, **opts)
     if large or all or contents:
         result = result or lfcommands.verifylfiles(ui, repo, all, contents)
     return result
 
 def overridedebugstate(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     if large:
         class fakerepo(object):
             dirstate = lfutil.openlfdirstate(ui, repo)
         orig(ui, fakerepo, *pats, **opts)
     else:
         orig(ui, repo, *pats, **opts)
 
 # Before starting the manifest merge, merge.updates will call
 # _checkunknownfile to check if there are any files in the merged-in
 # changeset that collide with unknown files in the working copy.
 #
 # The largefiles are seen as unknown, so this prevents us from merging
 # in a file 'foo' if we already have a largefile with the same name.
 #
 # The overridden function filters the unknown files by removing any
 # largefiles. This makes the merge proceed and we can then handle this
 # case further in the overridden calculateupdates function below.
 def overridecheckunknownfile(origfn, repo, wctx, mctx, f, f2=None):
     if lfutil.standin(repo.dirstate.normalize(f)) in wctx:
         return False
     return origfn(repo, wctx, mctx, f, f2)
 
 # The manifest merge handles conflicts on the manifest level. We want
 # to handle changes in largefile-ness of files at this level too.
 #
 # The strategy is to run the original calculateupdates and then process
 # the action list it outputs. There are two cases we need to deal with:
 #
 # 1. Normal file in p1, largefile in p2. Here the largefile is
 #    detected via its standin file, which will enter the working copy
 #    with a "get" action. It is not "merge" since the standin is all
 #    Mercurial is concerned with at this level -- the link to the
 #    existing normal file is not relevant here.
 #
 # 2. Largefile in p1, normal file in p2. Here we get a "merge" action
 #    since the largefile will be present in the working copy and
 #    different from the normal file in p2. Mercurial therefore
 #    triggers a merge action.
 #
 # In both cases, we prompt the user and emit new actions to either
 # remove the standin (if the normal file was kept) or to remove the
 # normal file and get the standin (if the largefile was kept). The
 # default prompt answer is to use the largefile version since it was
 # presumably changed on purpose.
 #
 # Finally, the merge.applyupdates function will then take care of
 # writing the files into the working copy and lfcommands.updatelfiles
 # will update the largefiles.
 def overridecalculateupdates(origfn, repo, p1, p2, pas, branchmerge, force,
                              acceptremote, *args, **kwargs):
     overwrite = force and not branchmerge
     actions, diverge, renamedelete = origfn(
         repo, p1, p2, pas, branchmerge, force, acceptremote, *args, **kwargs)
 
     if overwrite:
         return actions, diverge, renamedelete
 
     # Convert to dictionary with filename as key and action as value.
     lfiles = set()
     for f in actions:
         splitstandin = lfutil.splitstandin(f)
         if splitstandin in p1:
             lfiles.add(splitstandin)
         elif lfutil.standin(f) in p1:
             lfiles.add(f)
 
     for lfile in sorted(lfiles):
         standin = lfutil.standin(lfile)
         (lm, largs, lmsg) = actions.get(lfile, (None, None, None))
         (sm, sargs, smsg) = actions.get(standin, (None, None, None))
         if sm in ('g', 'dc') and lm != 'r':
             if sm == 'dc':
                 f1, f2, fa, move, anc = sargs
                 sargs = (p2[f2].flags(), False)
             # Case 1: normal file in the working copy, largefile in
             # the second parent
             usermsg = _('remote turned local normal file %s into a largefile\n'
                         'use (l)argefile or keep (n)ormal file?'
                         '$$ &Largefile $$ &Normal file') % lfile
             if repo.ui.promptchoice(usermsg, 0) == 0: # pick remote largefile
                 actions[lfile] = ('r', None, 'replaced by standin')
                 actions[standin] = ('g', sargs, 'replaces standin')
             else: # keep local normal file
                 actions[lfile] = ('k', None, 'replaces standin')
                 if branchmerge:
                     actions[standin] = ('k', None, 'replaced by non-standin')
                 else:
                     actions[standin] = ('r', None, 'replaced by non-standin')
         elif lm in ('g', 'dc') and sm != 'r':
             if lm == 'dc':
                 f1, f2, fa, move, anc = largs
                 largs = (p2[f2].flags(), False)
             # Case 2: largefile in the working copy, normal file in
             # the second parent
             usermsg = _('remote turned local largefile %s into a normal file\n'
                     'keep (l)argefile or use (n)ormal file?'
                     '$$ &Largefile $$ &Normal file') % lfile
             if repo.ui.promptchoice(usermsg, 0) == 0: # keep local largefile
                 if branchmerge:
                     # largefile can be restored from standin safely
                     actions[lfile] = ('k', None, 'replaced by standin')
                     actions[standin] = ('k', None, 'replaces standin')
                 else:
                     # "lfile" should be marked as "removed" without
                     # removal of itself
                     actions[lfile] = ('lfmr', None,
                                       'forget non-standin largefile')
 
                     # linear-merge should treat this largefile as 're-added'
                     actions[standin] = ('a', None, 'keep standin')
             else: # pick remote normal file
                 actions[lfile] = ('g', largs, 'replaces standin')
                 actions[standin] = ('r', None, 'replaced by non-standin')
 
     return actions, diverge, renamedelete
 
 def mergerecordupdates(orig, repo, actions, branchmerge):
     if 'lfmr' in actions:
         lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
         for lfile, args, msg in actions['lfmr']:
             # this should be executed before 'orig', to execute 'remove'
             # before all other actions
             repo.dirstate.remove(lfile)
             # make sure lfile doesn't get synclfdirstate'd as normal
             lfdirstate.add(lfile)
         lfdirstate.write()
 
     return orig(repo, actions, branchmerge)
 
 # Override filemerge to prompt the user about how they wish to merge
 # largefiles. This will handle identical edits without prompting the user.
 def overridefilemerge(origfn, premerge, repo, mynode, orig, fcd, fco, fca,
                       labels=None):
     if not lfutil.isstandin(orig) or fcd.isabsent() or fco.isabsent():
         return origfn(premerge, repo, mynode, orig, fcd, fco, fca,
                       labels=labels)
 
     ahash = lfutil.readasstandin(fca).lower()
     dhash = lfutil.readasstandin(fcd).lower()
     ohash = lfutil.readasstandin(fco).lower()
     if (ohash != ahash and
         ohash != dhash and
         (dhash == ahash or
          repo.ui.promptchoice(
              _('largefile %s has a merge conflict\nancestor was %s\n'
                'keep (l)ocal %s or\ntake (o)ther %s?'
                '$$ &Local $$ &Other') %
                (lfutil.splitstandin(orig), ahash, dhash, ohash),
              0) == 1)):
         repo.wwrite(fcd.path(), fco.data(), fco.flags())
     return True, 0, False
 
 def copiespathcopies(orig, ctx1, ctx2, match=None):
     copies = orig(ctx1, ctx2, match=match)
     updated = {}
 
     for k, v in copies.iteritems():
         updated[lfutil.splitstandin(k) or k] = lfutil.splitstandin(v) or v
 
     return updated
 
 # Copy first changes the matchers to match standins instead of
 # largefiles.  Then it overrides util.copyfile in that function it
 # checks if the destination largefile already exists. It also keeps a
 # list of copied files so that the largefiles can be copied and the
 # dirstate updated.
 def overridecopy(orig, ui, repo, pats, opts, rename=False):
     # doesn't remove largefile on rename
     if len(pats) < 2:
         # this isn't legal, let the original function deal with it
         return orig(ui, repo, pats, opts, rename)
 
     # This could copy both lfiles and normal files in one command,
     # but we don't want to do that. First replace their matcher to
     # only match normal files and run it, then replace it to just
     # match largefiles and run it again.
     nonormalfiles = False
     nolfiles = False
     installnormalfilesmatchfn(repo[None].manifest())
     try:
         result = orig(ui, repo, pats, opts, rename)
     except error.Abort as e:
         if str(e) != _('no files to copy'):
             raise e
         else:
             nonormalfiles = True
         result = 0
     finally:
         restorematchfn()
 
     # The first rename can cause our current working directory to be removed.
     # In that case there is nothing left to copy/rename so just quit.
     try:
         repo.getcwd()
     except OSError:
         return result
 
     def makestandin(relpath):
         path = pathutil.canonpath(repo.root, repo.getcwd(), relpath)
         return repo.wvfs.join(lfutil.standin(path))
 
     fullpats = scmutil.expandpats(pats)
     dest = fullpats[-1]
 
     if os.path.isdir(dest):
         if not os.path.isdir(makestandin(dest)):
             os.makedirs(makestandin(dest))
 
     try:
         # When we call orig below it creates the standins but we don't add
         # them to the dir state until later so lock during that time.
         wlock = repo.wlock()
 
         manifest = repo[None].manifest()
         def overridematch(ctx, pats=(), opts=None, globbed=False,
                 default='relpath', badfn=None):
             if opts is None:
                 opts = {}
             newpats = []
             # The patterns were previously mangled to add the standin
             # directory; we need to remove that now
             for pat in pats:
                 if matchmod.patkind(pat) is None and lfutil.shortname in pat:
                     newpats.append(pat.replace(lfutil.shortname, ''))
                 else:
                     newpats.append(pat)
             match = oldmatch(ctx, newpats, opts, globbed, default, badfn=badfn)
             m = copy.copy(match)
             lfile = lambda f: lfutil.standin(f) in manifest
             m._files = [lfutil.standin(f) for f in m._files if lfile(f)]
             m._fileroots = set(m._files)
             origmatchfn = m.matchfn
             def matchfn(f):
                 lfile = lfutil.splitstandin(f)
                 return (lfile is not None and
                         (f in manifest) and
                         origmatchfn(lfile) or
                         None)
             m.matchfn = matchfn
             return m
         oldmatch = installmatchfn(overridematch)
         listpats = []
         for pat in pats:
             if matchmod.patkind(pat) is not None:
                 listpats.append(pat)
             else:
                 listpats.append(makestandin(pat))
 
         try:
             origcopyfile = util.copyfile
             copiedfiles = []
             def overridecopyfile(src, dest):
                 if (lfutil.shortname in src and
                     dest.startswith(repo.wjoin(lfutil.shortname))):
                     destlfile = dest.replace(lfutil.shortname, '')
                     if not opts['force'] and os.path.exists(destlfile):
                         raise IOError('',
                             _('destination largefile already exists'))
                 copiedfiles.append((src, dest))
                 origcopyfile(src, dest)
 
             util.copyfile = overridecopyfile
             result += orig(ui, repo, listpats, opts, rename)
         finally:
             util.copyfile = origcopyfile
 
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for (src, dest) in copiedfiles:
             if (lfutil.shortname in src and
                 dest.startswith(repo.wjoin(lfutil.shortname))):
                 srclfile = src.replace(repo.wjoin(lfutil.standin('')), '')
                 destlfile = dest.replace(repo.wjoin(lfutil.standin('')), '')
                 destlfiledir = repo.wvfs.dirname(repo.wjoin(destlfile)) or '.'
                 if not os.path.isdir(destlfiledir):
                     os.makedirs(destlfiledir)
                 if rename:
                     os.rename(repo.wjoin(srclfile), repo.wjoin(destlfile))
 
                     # The file is gone, but this deletes any empty parent
                     # directories as a side-effect.
                     repo.wvfs.unlinkpath(srclfile, ignoremissing=True)
                     lfdirstate.remove(srclfile)
                 else:
                     util.copyfile(repo.wjoin(srclfile),
                                   repo.wjoin(destlfile))
 
                 lfdirstate.add(destlfile)
         lfdirstate.write()
     except error.Abort as e:
         if str(e) != _('no files to copy'):
             raise e
         else:
             nolfiles = True
     finally:
         restorematchfn()
         wlock.release()
 
     if nolfiles and nonormalfiles:
         raise error.Abort(_('no files to copy'))
 
     return result
 
 # When the user calls revert, we have to be careful to not revert any
 # changes to other largefiles accidentally. This means we have to keep
 # track of the largefiles that are being reverted so we only pull down
 # the necessary largefiles.
 #
 # Standins are only updated (to match the hash of largefiles) before
 # commits. Update the standins then run the original revert, changing
 # the matcher to hit standins instead of largefiles. Based on the
 # resulting standins update the largefiles.
 def overriderevert(orig, ui, repo, ctx, parents, *pats, **opts):
     # Because we put the standins in a bad state (by updating them)
     # and then return them to a correct state we need to lock to
     # prevent others from changing them in their incorrect state.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         s = lfutil.lfdirstatestatus(lfdirstate, repo)
         lfdirstate.write()
         for lfile in s.modified:
             lfutil.updatestandin(repo, lfile, lfutil.standin(lfile))
         for lfile in s.deleted:
             fstandin = lfutil.standin(lfile)
             if (repo.wvfs.exists(fstandin)):
                 repo.wvfs.unlink(fstandin)
 
         oldstandins = lfutil.getstandinsstate(repo)
 
         def overridematch(mctx, pats=(), opts=None, globbed=False,
                 default='relpath', badfn=None):
             if opts is None:
                 opts = {}
             match = oldmatch(mctx, pats, opts, globbed, default, badfn=badfn)
             m = copy.copy(match)
 
             # revert supports recursing into subrepos, and though largefiles
             # currently doesn't work correctly in that case, this match is
             # called, so the lfdirstate above may not be the correct one for
             # this invocation of match.
             lfdirstate = lfutil.openlfdirstate(mctx.repo().ui, mctx.repo(),
                                                False)
 
             wctx = repo[None]
             matchfiles = []
             for f in m._files:
                 standin = lfutil.standin(f)
                 if standin in ctx or standin in mctx:
                     matchfiles.append(standin)
                 elif standin in wctx or lfdirstate[f] == 'r':
                     continue
                 else:
                     matchfiles.append(f)
             m._files = matchfiles
             m._fileroots = set(m._files)
             origmatchfn = m.matchfn
             def matchfn(f):
                 lfile = lfutil.splitstandin(f)
                 if lfile is not None:
                     return (origmatchfn(lfile) and
                             (f in ctx or f in mctx))
                 return origmatchfn(f)
             m.matchfn = matchfn
             return m
         oldmatch = installmatchfn(overridematch)
         try:
             orig(ui, repo, ctx, parents, *pats, **opts)
         finally:
             restorematchfn()
 
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
         # lfdirstate should be 'normallookup'-ed for updated files,
         # because reverting doesn't touch dirstate for 'normal' files
         # when target revision is explicitly specified: in such case,
         # 'n' and valid timestamp in dirstate doesn't ensure 'clean'
         # of target (standin) file.
         lfcommands.updatelfiles(ui, repo, filelist, printmessage=False,
                                 normallookup=True)
 
 # after pulling changesets, we need to take some extra care to get
 # largefiles updated remotely
 def overridepull(orig, ui, repo, source=None, **opts):
     revsprepull = len(repo)
     if not source:
         source = 'default'
     repo.lfpullsource = source
     result = orig(ui, repo, source, **opts)
     revspostpull = len(repo)
     lfrevs = opts.get('lfrev', [])
     if opts.get('all_largefiles'):
         lfrevs.append('pulled()')
     if lfrevs and revspostpull > revsprepull:
         numcached = 0
         repo.firstpulled = revsprepull # for pulled() revset expression
         try:
             for rev in scmutil.revrange(repo, lfrevs):
                 ui.note(_('pulling largefiles for revision %s\n') % rev)
                 (cached, missing) = lfcommands.cachelfiles(ui, repo, rev)
                 numcached += len(cached)
         finally:
             del repo.firstpulled
         ui.status(_("%d largefiles cached\n") % numcached)
     return result
 
 def overridepush(orig, ui, repo, *args, **kwargs):
     """Override push command and store --lfrev parameters in opargs"""
     lfrevs = kwargs.pop('lfrev', None)
     if lfrevs:
         opargs = kwargs.setdefault('opargs', {})
         opargs['lfrevs'] = scmutil.revrange(repo, lfrevs)
     return orig(ui, repo, *args, **kwargs)
 
 def exchangepushoperation(orig, *args, **kwargs):
     """Override pushoperation constructor and store lfrevs parameter"""
     lfrevs = kwargs.pop('lfrevs', None)
     pushop = orig(*args, **kwargs)
     pushop.lfrevs = lfrevs
     return pushop
 
 revsetpredicate = registrar.revsetpredicate()
 
 @revsetpredicate('pulled()')
 def pulledrevsetsymbol(repo, subset, x):
     """Changesets that just has been pulled.
 
     Only available with largefiles from pull --lfrev expressions.
 
     .. container:: verbose
 
       Some examples:
 
       - pull largefiles for all new changesets::
 
           hg pull -lfrev "pulled()"
 
       - pull largefiles for all new branch heads::
 
           hg pull -lfrev "head(pulled()) and not closed()"
 
     """
 
     try:
         firstpulled = repo.firstpulled
     except AttributeError:
         raise error.Abort(_("pulled() only available in --lfrev"))
     return smartset.baseset([r for r in subset if r >= firstpulled])
 
 def overrideclone(orig, ui, source, dest=None, **opts):
     d = dest
     if d is None:
         d = hg.defaultdest(source)
     if opts.get('all_largefiles') and not hg.islocal(d):
             raise error.Abort(_(
             '--all-largefiles is incompatible with non-local destination %s') %
             d)
 
     return orig(ui, source, dest, **opts)
 
 def hgclone(orig, ui, opts, *args, **kwargs):
     result = orig(ui, opts, *args, **kwargs)
 
     if result is not None:
         sourcerepo, destrepo = result
         repo = destrepo.local()
 
         # When cloning to a remote repo (like through SSH), no repo is available
         # from the peer.   Therefore the largefiles can't be downloaded and the
         # hgrc can't be updated.
         if not repo:
             return result
 
         # If largefiles is required for this repo, permanently enable it locally
         if 'largefiles' in repo.requirements:
             with repo.vfs('hgrc', 'a', text=True) as fp:
                 fp.write('\n[extensions]\nlargefiles=\n')
 
         # Caching is implicitly limited to 'rev' option, since the dest repo was
         # truncated at that point.  The user may expect a download count with
         # this option, so attempt whether or not this is a largefile repo.
         if opts.get('all_largefiles'):
             success, missing = lfcommands.downloadlfiles(ui, repo, None)
 
             if missing != 0:
                 return None
 
     return result
 
+def hgpostshare(orig, sourcerepo, destrepo, bookmarks=True, defaultpath=None):
+    orig(sourcerepo, destrepo, bookmarks, defaultpath)
+
+    # If largefiles is required for this repo, permanently enable it locally
+    if 'largefiles' in destrepo.requirements:
+        with destrepo.vfs('hgrc', 'a+', text=True) as fp:
+            fp.write('\n[extensions]\nlargefiles=\n')
+
 def overriderebase(orig, ui, repo, **opts):
     if not util.safehasattr(repo, '_largefilesenabled'):
         return orig(ui, repo, **opts)
 
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         return orig(ui, repo, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
 
 def overridearchivecmd(orig, ui, repo, dest, **opts):
     repo.unfiltered().lfstatus = True
 
     try:
         return orig(ui, repo.unfiltered(), dest, **opts)
     finally:
         repo.unfiltered().lfstatus = False
 
 def hgwebarchive(orig, web, req, tmpl):
     web.repo.lfstatus = True
 
     try:
         return orig(web, req, tmpl)
     finally:
         web.repo.lfstatus = False
 
 def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None,
             prefix='', mtime=None, subrepos=None):
     # For some reason setting repo.lfstatus in hgwebarchive only changes the
     # unfiltered repo's attr, so check that as well.
     if not repo.lfstatus and not repo.unfiltered().lfstatus:
         return orig(repo, dest, node, kind, decode, matchfn, prefix, mtime,
                     subrepos)
 
     # No need to lock because we are only reading history and
     # largefile caches, neither of which are modified.
     if node is not None:
         lfcommands.cachelfiles(repo.ui, repo, node)
 
     if kind not in archival.archivers:
         raise error.Abort(_("unknown archive type '%s'") % kind)
 
     ctx = repo[node]
 
     if kind == 'files':
         if prefix:
             raise error.Abort(
                 _('cannot give prefix when archiving to files'))
     else:
         prefix = archival.tidyprefix(dest, kind, prefix)
 
     def write(name, mode, islink, getdata):
         if matchfn and not matchfn(name):
             return
         data = getdata()
         if decode:
             data = repo.wwritedata(name, data)
         archiver.addfile(prefix + name, mode, islink, data)
 
     archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
 
     if repo.ui.configbool("ui", "archivemeta", True):
         write('.hg_archival.txt', 0o644, False,
               lambda: archival.buildmetadata(ctx))
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         lfile = lfutil.splitstandin(f)
         if lfile is not None:
             if node is not None:
                 path = lfutil.findfile(repo, getdata().strip())
 
                 if path is None:
                     raise error.Abort(
                        _('largefile %s not found in repo store or system cache')
                        % lfile)
             else:
                 path = lfile
 
             f = lfile
 
             getdata = lambda: util.readfile(path)
         write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, getdata)
 
     if subrepos:
         for subpath in sorted(ctx.substate):
             sub = ctx.workingsub(subpath)
             submatch = matchmod.subdirmatcher(subpath, matchfn)
             sub._repo.lfstatus = True
             sub.archive(archiver, prefix, submatch)
 
     archiver.done()
 
 def hgsubrepoarchive(orig, repo, archiver, prefix, match=None, decode=True):
     if not repo._repo.lfstatus:
         return orig(repo, archiver, prefix, match, decode)
 
     repo._get(repo._state + ('hg',))
     rev = repo._state[1]
     ctx = repo._repo[rev]
 
     if ctx.node() is not None:
         lfcommands.cachelfiles(repo.ui, repo._repo, ctx.node())
 
     def write(name, mode, islink, getdata):
         # At this point, the standin has been replaced with the largefile name,
         # so the normal matcher works here without the lfutil variants.
         if match and not match(f):
             return
         data = getdata()
         if decode:
             data = repo._repo.wwritedata(name, data)
 
         archiver.addfile(prefix + repo._path + '/' + name, mode, islink, data)
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         lfile = lfutil.splitstandin(f)
         if lfile is not None:
             if ctx.node() is not None:
                 path = lfutil.findfile(repo._repo, getdata().strip())
 
                 if path is None:
                     raise error.Abort(
                        _('largefile %s not found in repo store or system cache')
                        % lfile)
             else:
                 path = lfile
 
             f = lfile
 
             getdata = lambda: util.readfile(os.path.join(prefix, path))
 
         write(f, 'x' in ff and 0o755 or 0o644, 'l' in ff, getdata)
 
     for subpath in sorted(ctx.substate):
         sub = ctx.workingsub(subpath)
         submatch = matchmod.subdirmatcher(subpath, match)
         sub._repo.lfstatus = True
         sub.archive(archiver, prefix + repo._path + '/', submatch, decode)
 
 # If a largefile is modified, the change is not reflected in its
 # standin until a commit. cmdutil.bailifchanged() raises an exception
 # if the repo has uncommitted changes. Wrap it to also check if
 # largefiles were changed. This is used by bisect, backout and fetch.
 def overridebailifchanged(orig, repo, *args, **kwargs):
     orig(repo, *args, **kwargs)
     repo.lfstatus = True
     s = repo.status()
     repo.lfstatus = False
     if s.modified or s.added or s.removed or s.deleted:
         raise error.Abort(_('uncommitted changes'))
 
 def postcommitstatus(orig, repo, *args, **kwargs):
     repo.lfstatus = True
     try:
         return orig(repo, *args, **kwargs)
     finally:
         repo.lfstatus = False
 
 def cmdutilforget(orig, ui, repo, match, prefix, explicitonly):
     normalmatcher = composenormalfilematcher(match, repo[None].manifest())
     bad, forgot = orig(ui, repo, normalmatcher, prefix, explicitonly)
     m = composelargefilematcher(match, repo[None].manifest())
 
     try:
         repo.lfstatus = True
         s = repo.status(match=m, clean=True)
     finally:
         repo.lfstatus = False
     manifest = repo[None].manifest()
     forget = sorted(s.modified + s.added + s.deleted + s.clean)
     forget = [f for f in forget if lfutil.standin(f) in manifest]
 
     for f in forget:
         fstandin = lfutil.standin(f)
         if fstandin not in repo.dirstate and not repo.wvfs.isdir(fstandin):
             ui.warn(_('not removing %s: file is already untracked\n')
                     % m.rel(f))
             bad.append(f)
 
     for f in forget:
         if ui.verbose or not m.exact(f):
             ui.status(_('removing %s\n') % m.rel(f))
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race in-between.
     with repo.wlock():
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in forget:
             if lfdirstate[f] == 'a':
                 lfdirstate.drop(f)
             else:
                 lfdirstate.remove(f)
         lfdirstate.write()
         standins = [lfutil.standin(f) for f in forget]
         for f in standins:
             repo.wvfs.unlinkpath(f, ignoremissing=True)
         rejected = repo[None].forget(standins)
 
     bad.extend(f for f in rejected if f in m.files())
     forgot.extend(f for f in forget if f not in rejected)
     return bad, forgot
 
 def _getoutgoings(repo, other, missing, addfunc):
     """get pairs of filename and largefile hash in outgoing revisions
     in 'missing'.
 
     largefiles already existing on 'other' repository are ignored.
 
     'addfunc' is invoked with each unique pairs of filename and
     largefile hash value.
     """
     knowns = set()
     lfhashes = set()
     def dedup(fn, lfhash):
         k = (fn, lfhash)
         if k not in knowns:
             knowns.add(k)
             lfhashes.add(lfhash)
     lfutil.getlfilestoupload(repo, missing, dedup)
     if lfhashes:
         lfexists = storefactory.openstore(repo, other).exists(lfhashes)
         for fn, lfhash in knowns:
             if not lfexists[lfhash]: # lfhash doesn't exist on "other"
                 addfunc(fn, lfhash)
 
 def outgoinghook(ui, repo, other, opts, missing):
     if opts.pop('large', None):
         lfhashes = set()
         if ui.debugflag:
             toupload = {}
             def addfunc(fn, lfhash):
                 if fn not in toupload:
                     toupload[fn] = []
                 toupload[fn].append(lfhash)
                 lfhashes.add(lfhash)
             def showhashes(fn):
                 for lfhash in sorted(toupload[fn]):
                     ui.debug('    %s\n' % (lfhash))
         else:
             toupload = set()
             def addfunc(fn, lfhash):
                 toupload.add(fn)
                 lfhashes.add(lfhash)
             def showhashes(fn):
                 pass
         _getoutgoings(repo, other, missing, addfunc)
 
         if not toupload:
             ui.status(_('largefiles: no files to upload\n'))
         else:
             ui.status(_('largefiles to upload (%d entities):\n')
                       % (len(lfhashes)))
             for file in sorted(toupload):
                 ui.status(lfutil.splitstandin(file) + '\n')
                 showhashes(file)
             ui.status('\n')
 
 def summaryremotehook(ui, repo, opts, changes):
     largeopt = opts.get('large', False)
     if changes is None:
         if largeopt:
             return (False, True) # only outgoing check is needed
         else:
             return (False, False)
     elif largeopt:
         url, branch, peer, outgoing = changes[1]
         if peer is None:
             # i18n: column positioning for "hg summary"
             ui.status(_('largefiles: (no remote repo)\n'))
             return
 
         toupload = set()
         lfhashes = set()
         def addfunc(fn, lfhash):
             toupload.add(fn)
             lfhashes.add(lfhash)
         _getoutgoings(repo, peer, outgoing.missing, addfunc)
 
         if not toupload:
             # i18n: column positioning for "hg summary"
             ui.status(_('largefiles: (no files to upload)\n'))
         else:
             # i18n: column positioning for "hg summary"
             ui.status(_('largefiles: %d entities for %d files to upload\n')
                       % (len(lfhashes), len(toupload)))
 
 def overridesummary(orig, ui, repo, *pats, **opts):
     try:
         repo.lfstatus = True
         orig(ui, repo, *pats, **opts)
     finally:
         repo.lfstatus = False
 
 def scmutiladdremove(orig, repo, matcher, prefix, opts=None, dry_run=None,
                      similarity=None):
     if opts is None:
         opts = {}
     if not lfutil.islfilesrepo(repo):
         return orig(repo, matcher, prefix, opts, dry_run, similarity)
     # Get the list of missing largefiles so we can remove them
     lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
     unsure, s = lfdirstate.status(matchmod.always(repo.root, repo.getcwd()), [],
                                   False, False, False)
 
     # Call into the normal remove code, but the removing of the standin, we want
     # to have handled by original addremove.  Monkey patching here makes sure
     # we don't remove the standin in the largefiles code, preventing a very
     # confused state later.
     if s.deleted:
         m = copy.copy(matcher)
 
         # The m._files and m._map attributes are not changed to the deleted list
         # because that affects the m.exact() test, which in turn governs whether
         # or not the file name is printed, and how.  Simply limit the original
         # matches to those in the deleted status list.
         matchfn = m.matchfn
         m.matchfn = lambda f: f in s.deleted and matchfn(f)
 
         removelargefiles(repo.ui, repo, True, m, **opts)
     # Call into the normal add code, and any files that *should* be added as
     # largefiles will be
     added, bad = addlargefiles(repo.ui, repo, True, matcher, **opts)
     # Now that we've handled largefiles, hand off to the original addremove
     # function to take care of the rest.  Make sure it doesn't do anything with
     # largefiles by passing a matcher that will ignore them.
     matcher = composenormalfilematcher(matcher, repo[None].manifest(), added)
     return orig(repo, matcher, prefix, opts, dry_run, similarity)
 
 # Calling purge with --all will cause the largefiles to be deleted.
 # Override repo.status to prevent this from happening.
 def overridepurge(orig, ui, repo, *dirs, **opts):
     # XXX Monkey patching a repoview will not work. The assigned attribute will
     # be set on the unfiltered repo, but we will only lookup attributes in the
     # unfiltered repo if the lookup in the repoview object itself fails. As the
     # monkey patched method exists on the repoview class the lookup will not
     # fail. As a result, the original version will shadow the monkey patched
     # one, defeating the monkey patch.
     #
     # As a work around we use an unfiltered repo here. We should do something
     # cleaner instead.
     repo = repo.unfiltered()
     oldstatus = repo.status
     def overridestatus(node1='.', node2=None, match=None, ignored=False,
                         clean=False, unknown=False, listsubrepos=False):
         r = oldstatus(node1, node2, match, ignored, clean, unknown,
                       listsubrepos)
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         unknown = [f for f in r.unknown if lfdirstate[f] == '?']
         ignored = [f for f in r.ignored if lfdirstate[f] == '?']
         return scmutil.status(r.modified, r.added, r.removed, r.deleted,
                               unknown, ignored, r.clean)
     repo.status = overridestatus
     orig(ui, repo, *dirs, **opts)
     repo.status = oldstatus
 def overriderollback(orig, ui, repo, **opts):
     with repo.wlock():
         before = repo.dirstate.parents()
         orphans = set(f for f in repo.dirstate
                       if lfutil.isstandin(f) and repo.dirstate[f] != 'r')
         result = orig(ui, repo, **opts)
         after = repo.dirstate.parents()
         if before == after:
             return result # no need to restore standins
 
         pctx = repo['.']
         for f in repo.dirstate:
             if lfutil.isstandin(f):
                 orphans.discard(f)
                 if repo.dirstate[f] == 'r':
                     repo.wvfs.unlinkpath(f, ignoremissing=True)
                 elif f in pctx:
                     fctx = pctx[f]
                     repo.wwrite(f, fctx.data(), fctx.flags())
                 else:
                     # content of standin is not so important in 'a',
                     # 'm' or 'n' (coming from the 2nd parent) cases
                     lfutil.writestandin(repo, f, '', False)
         for standin in orphans:
             repo.wvfs.unlinkpath(standin, ignoremissing=True)
 
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         orphans = set(lfdirstate)
         lfiles = lfutil.listlfiles(repo)
         for file in lfiles:
             lfutil.synclfdirstate(repo, lfdirstate, file, True)
             orphans.discard(file)
         for lfile in orphans:
             lfdirstate.drop(lfile)
         lfdirstate.write()
     return result
 
 def overridetransplant(orig, ui, repo, *revs, **opts):
     resuming = opts.get('continue')
     repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
     repo._lfstatuswriters.append(lambda *msg, **opts: None)
     try:
         result = orig(ui, repo, *revs, **opts)
     finally:
         repo._lfstatuswriters.pop()
         repo._lfcommithooks.pop()
     return result
 
 def overridecat(orig, ui, repo, file1, *pats, **opts):
     ctx = scmutil.revsingle(repo, opts.get('rev'))
     err = 1
     notbad = set()
     m = scmutil.match(ctx, (file1,) + pats, opts)
     origmatchfn = m.matchfn
     def lfmatchfn(f):
         if origmatchfn(f):
             return True
         lf = lfutil.splitstandin(f)
         if lf is None:
             return False
         notbad.add(lf)
         return origmatchfn(lf)
     m.matchfn = lfmatchfn
     origbadfn = m.bad
     def lfbadfn(f, msg):
         if not f in notbad:
             origbadfn(f, msg)
     m.bad = lfbadfn
 
     origvisitdirfn = m.visitdir
     def lfvisitdirfn(dir):
         if dir == lfutil.shortname:
             return True
         ret = origvisitdirfn(dir)
         if ret:
             return ret
         lf = lfutil.splitstandin(dir)
         if lf is None:
             return False
         return origvisitdirfn(lf)
     m.visitdir = lfvisitdirfn
 
     for f in ctx.walk(m):
         with cmdutil.makefileobj(repo, opts.get('output'), ctx.node(),
                                  pathname=f) as fp:
             lf = lfutil.splitstandin(f)
             if lf is None or origmatchfn(f):
                 # duplicating unreachable code from commands.cat
                 data = ctx[f].data()
                 if opts.get('decode'):
                     data = repo.wwritedata(f, data)
                 fp.write(data)
             else:
                 hash = lfutil.readasstandin(ctx[f])
                 if not lfutil.inusercache(repo.ui, hash):
                     store = storefactory.openstore(repo)
                     success, missing = store.get([(lf, hash)])
                     if len(success) != 1:
                         raise error.Abort(
                             _('largefile %s is not in cache and could not be '
                               'downloaded')  % lf)
                 path = lfutil.usercachepath(repo.ui, hash)
                 with open(path, "rb") as fpin:
                     for chunk in util.filechunkiter(fpin):
                         fp.write(chunk)
         err = 0
     return err
 
 def mergeupdate(orig, repo, node, branchmerge, force,
                 *args, **kwargs):
     matcher = kwargs.get('matcher', None)
     # note if this is a partial update
     partial = matcher and not matcher.always()
     with repo.wlock():
         # branch |       |         |
         #  merge | force | partial | action
         # -------+-------+---------+--------------
         #    x   |   x   |    x    | linear-merge
         #    o   |   x   |    x    | branch-merge
         #    x   |   o   |    x    | overwrite (as clean update)
         #    o   |   o   |    x    | force-branch-merge (*1)
         #    x   |   x   |    o    |   (*)
         #    o   |   x   |    o    |   (*)
         #    x   |   o   |    o    | overwrite (as revert)
         #    o   |   o   |    o    |   (*)
         #
         # (*) don't care
         # (*1) deprecated, but used internally (e.g: "rebase --collapse")
 
         lfdirstate = lfutil.openlfdirstate(repo.ui, repo)
         unsure, s = lfdirstate.status(matchmod.always(repo.root,
                                                     repo.getcwd()),
                                       [], False, True, False)
         oldclean = set(s.clean)
         pctx = repo['.']
         dctx = repo[node]
         for lfile in unsure + s.modified:
             lfileabs = repo.wvfs.join(lfile)
             if not repo.wvfs.exists(lfileabs):
                 continue
             lfhash = lfutil.hashfile(lfileabs)
             standin = lfutil.standin(lfile)
             lfutil.writestandin(repo, standin, lfhash,
                                 lfutil.getexecutable(lfileabs))
             if (standin in pctx and
                 lfhash == lfutil.readasstandin(pctx[standin])):
                 oldclean.add(lfile)
         for lfile in s.added:
             fstandin = lfutil.standin(lfile)
             if fstandin not in dctx:
                 # in this case, content of standin file is meaningless
                 # (in dctx, lfile is unknown, or normal file)
                 continue
             lfutil.updatestandin(repo, lfile, fstandin)
         # mark all clean largefiles as dirty, just in case the update gets
         # interrupted before largefiles and lfdirstate are synchronized
         for lfile in oldclean:
             lfdirstate.normallookup(lfile)
         lfdirstate.write()
 
         oldstandins = lfutil.getstandinsstate(repo)
 
         result = orig(repo, node, branchmerge, force, *args, **kwargs)
 
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
 
         # to avoid leaving all largefiles as dirty and thus rehash them, mark
         # all the ones that didn't change as clean
         for lfile in oldclean.difference(filelist):
             lfdirstate.normal(lfile)
         lfdirstate.write()
 
         if branchmerge or force or partial:
             filelist.extend(s.deleted + s.removed)
 
         lfcommands.updatelfiles(repo.ui, repo, filelist=filelist,
                                 normallookup=partial)
 
         return result
 
 def scmutilmarktouched(orig, repo, files, *args, **kwargs):
     result = orig(repo, files, *args, **kwargs)
 
     filelist = []
     for f in files:
         lf = lfutil.splitstandin(f)
         if lf is not None:
             filelist.append(lf)
     if filelist:
         lfcommands.updatelfiles(repo.ui, repo, filelist=filelist,
                                 printmessage=False, normallookup=True)
 
     return result

hgext/largefiles/uisetup.py

@@ -1,203 +1,204
 # 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.
 
 '''setup for largefiles extension: uisetup'''
 from __future__ import absolute_import
 
 from mercurial.i18n import _
 
 from mercurial.hgweb import (
     hgweb_mod,
     webcommands,
 )
 
 from mercurial import (
     archival,
     cmdutil,
     commands,
     copies,
     exchange,
     extensions,
     filemerge,
     hg,
     httppeer,
     merge,
     scmutil,
     sshpeer,
     subrepo,
     wireproto,
 )
 
 from . import (
     overrides,
     proto,
 )
 
 def uisetup(ui):
     # Disable auto-status for some commands which assume that all
     # files in the result are under Mercurial's control
 
     entry = extensions.wrapcommand(commands.table, 'add',
                                    overrides.overrideadd)
     addopt = [('', 'large', None, _('add as largefile')),
               ('', 'normal', None, _('add as normal file')),
               ('', 'lfsize', '', _('add all files above this size '
                                    '(in megabytes) as largefiles '
                                    '(default: 10)'))]
     entry[1].extend(addopt)
 
     # The scmutil function is called both by the (trivial) addremove command,
     # and in the process of handling commit -A (issue3542)
     entry = extensions.wrapfunction(scmutil, 'addremove',
                                     overrides.scmutiladdremove)
     extensions.wrapfunction(cmdutil, 'add', overrides.cmdutiladd)
     extensions.wrapfunction(cmdutil, 'remove', overrides.cmdutilremove)
     extensions.wrapfunction(cmdutil, 'forget', overrides.cmdutilforget)
 
     extensions.wrapfunction(copies, 'pathcopies', overrides.copiespathcopies)
 
     # Subrepos call status function
     entry = extensions.wrapcommand(commands.table, 'status',
                                    overrides.overridestatus)
     entry = extensions.wrapfunction(subrepo.hgsubrepo, 'status',
                                     overrides.overridestatusfn)
 
     entry = extensions.wrapcommand(commands.table, 'log',
                                    overrides.overridelog)
     entry = extensions.wrapcommand(commands.table, 'rollback',
                                    overrides.overriderollback)
     entry = extensions.wrapcommand(commands.table, 'verify',
                                    overrides.overrideverify)
 
     verifyopt = [('', 'large', None,
                   _('verify that all largefiles in current revision exists')),
                  ('', 'lfa', None,
                   _('verify largefiles in all revisions, not just current')),
                  ('', 'lfc', None,
                   _('verify local largefile contents, not just existence'))]
     entry[1].extend(verifyopt)
 
     entry = extensions.wrapcommand(commands.table, 'debugstate',
                                    overrides.overridedebugstate)
     debugstateopt = [('', 'large', None, _('display largefiles dirstate'))]
     entry[1].extend(debugstateopt)
 
     outgoing = lambda orgfunc, *arg, **kwargs: orgfunc(*arg, **kwargs)
     entry = extensions.wrapcommand(commands.table, 'outgoing', outgoing)
     outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
     entry[1].extend(outgoingopt)
     cmdutil.outgoinghooks.add('largefiles', overrides.outgoinghook)
     entry = extensions.wrapcommand(commands.table, 'summary',
                                    overrides.overridesummary)
     summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
     entry[1].extend(summaryopt)
     cmdutil.summaryremotehooks.add('largefiles', overrides.summaryremotehook)
 
     entry = extensions.wrapcommand(commands.table, 'pull',
                                    overrides.overridepull)
     pullopt = [('', 'all-largefiles', None,
                  _('download all pulled versions of largefiles (DEPRECATED)')),
                ('', 'lfrev', [],
                 _('download largefiles for these revisions'), _('REV'))]
     entry[1].extend(pullopt)
 
     entry = extensions.wrapcommand(commands.table, 'push',
                                    overrides.overridepush)
     pushopt = [('', 'lfrev', [],
                 _('upload largefiles for these revisions'), _('REV'))]
     entry[1].extend(pushopt)
     entry = extensions.wrapfunction(exchange, 'pushoperation',
                                     overrides.exchangepushoperation)
 
     entry = extensions.wrapcommand(commands.table, 'clone',
                                    overrides.overrideclone)
     cloneopt = [('', 'all-largefiles', None,
                  _('download all versions of all largefiles'))]
     entry[1].extend(cloneopt)
     entry = extensions.wrapfunction(hg, 'clone', overrides.hgclone)
+    entry = extensions.wrapfunction(hg, 'postshare', overrides.hgpostshare)
 
     entry = extensions.wrapcommand(commands.table, 'cat',
                                    overrides.overridecat)
     entry = extensions.wrapfunction(merge, '_checkunknownfile',
                                     overrides.overridecheckunknownfile)
     entry = extensions.wrapfunction(merge, 'calculateupdates',
                                     overrides.overridecalculateupdates)
     entry = extensions.wrapfunction(merge, 'recordupdates',
                                     overrides.mergerecordupdates)
     entry = extensions.wrapfunction(merge, 'update',
                                     overrides.mergeupdate)
     entry = extensions.wrapfunction(filemerge, '_filemerge',
                                     overrides.overridefilemerge)
     entry = extensions.wrapfunction(cmdutil, 'copy',
                                     overrides.overridecopy)
 
     # Summary calls dirty on the subrepos
     entry = extensions.wrapfunction(subrepo.hgsubrepo, 'dirty',
                                     overrides.overridedirty)
 
     entry = extensions.wrapfunction(cmdutil, 'revert',
                                     overrides.overriderevert)
 
     extensions.wrapcommand(commands.table, 'archive',
                            overrides.overridearchivecmd)
     extensions.wrapfunction(archival, 'archive', overrides.overridearchive)
     extensions.wrapfunction(subrepo.hgsubrepo, 'archive',
                             overrides.hgsubrepoarchive)
     extensions.wrapfunction(webcommands, 'archive',
                             overrides.hgwebarchive)
     extensions.wrapfunction(cmdutil, 'bailifchanged',
                             overrides.overridebailifchanged)
 
     extensions.wrapfunction(cmdutil, 'postcommitstatus',
                             overrides.postcommitstatus)
     extensions.wrapfunction(scmutil, 'marktouched',
                             overrides.scmutilmarktouched)
 
     # create the new wireproto commands ...
     wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
     wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
     wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
 
     # ... and wrap some existing ones
     wireproto.commands['capabilities'] = (proto.capabilities, '')
     wireproto.commands['heads'] = (proto.heads, '')
     wireproto.commands['lheads'] = (wireproto.heads, '')
 
     # make putlfile behave the same as push and {get,stat}lfile behave
     # the same as pull w.r.t. permissions checks
     hgweb_mod.perms['putlfile'] = 'push'
     hgweb_mod.perms['getlfile'] = 'pull'
     hgweb_mod.perms['statlfile'] = 'pull'
 
     extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
 
     # the hello wireproto command uses wireproto.capabilities, so it won't see
     # our largefiles capability unless we replace the actual function as well.
     proto.capabilitiesorig = wireproto.capabilities
     wireproto.capabilities = proto.capabilities
 
     # can't do this in reposetup because it needs to have happened before
     # wirerepo.__init__ is called
     proto.ssholdcallstream = sshpeer.sshpeer._callstream
     proto.httpoldcallstream = httppeer.httppeer._callstream
     sshpeer.sshpeer._callstream = proto.sshrepocallstream
     httppeer.httppeer._callstream = proto.httprepocallstream
 
     # override some extensions' stuff as well
     for name, module in extensions.extensions():
         if name == 'purge':
             extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
                 overrides.overridepurge)
         if name == 'rebase':
             extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
                 overrides.overriderebase)
             extensions.wrapfunction(module, 'rebase',
                                     overrides.overriderebase)
         if name == 'transplant':
             extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
                 overrides.overridetransplant)

tests/test-largefiles-misc.t

@@ -1,1103 +1,1115
 This file contains testcases that tend to be related to special cases or less
 common commands affecting largefile.
 
 Each sections should be independent of each others.
 
   $ USERCACHE="$TESTTMP/cache"; export USERCACHE
   $ mkdir "${USERCACHE}"
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > purge=
   > rebase=
   > transplant=
   > [phases]
   > publish=False
   > [largefiles]
   > minsize=2
   > patterns=glob:**.dat
   > usercache=${USERCACHE}
   > [hooks]
   > precommit=sh -c "echo \\"Invoking status precommit hook\\"; hg status"
   > EOF
 
 
 
 Test copies and moves from a directory other than root (issue3516)
 =========================================================================
 
   $ hg init lf_cpmv
   $ cd lf_cpmv
   $ mkdir dira
   $ mkdir dira/dirb
   $ touch dira/dirb/largefile
   $ hg add --large dira/dirb/largefile
   $ hg commit -m "added"
   Invoking status precommit hook
   A dira/dirb/largefile
   $ cd dira
   $ hg cp dirb/largefile foo/largefile
 
 TODO: Ideally, this should mention the largefile, not the standin
   $ hg log -T '{rev}\n' --stat 'set:clean()'
   0
    .hglf/dira/dirb/largefile |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   
   $ hg ci -m "deep copy"
   Invoking status precommit hook
   A dira/foo/largefile
   $ find . | sort
   .
   ./dirb
   ./dirb/largefile
   ./foo
   ./foo/largefile
   $ hg mv foo/largefile baz/largefile
   $ hg ci -m "moved"
   Invoking status precommit hook
   A dira/baz/largefile
   R dira/foo/largefile
   $ find . | sort
   .
   ./baz
   ./baz/largefile
   ./dirb
   ./dirb/largefile
   $ cd ..
   $ hg mv dira dirc
   moving .hglf/dira/baz/largefile to .hglf/dirc/baz/largefile (glob)
   moving .hglf/dira/dirb/largefile to .hglf/dirc/dirb/largefile (glob)
   $ find * | sort
   dirc
   dirc/baz
   dirc/baz/largefile
   dirc/dirb
   dirc/dirb/largefile
 
   $ hg clone -q . ../fetch
   $ hg --config extensions.fetch= fetch ../fetch
   abort: uncommitted changes
   [255]
   $ hg up -qC
   $ cd ..
 
 Clone a local repository owned by another user
 ===================================================
 
 #if unix-permissions
 
 We have to simulate that here by setting $HOME and removing write permissions
   $ ORIGHOME="$HOME"
   $ mkdir alice
   $ HOME="`pwd`/alice"
   $ cd alice
   $ hg init pubrepo
   $ cd pubrepo
   $ dd if=/dev/zero bs=1k count=11k > a-large-file 2> /dev/null
   $ hg add --large a-large-file
   $ hg commit -m "Add a large file"
   Invoking status precommit hook
   A a-large-file
   $ cd ..
   $ chmod -R a-w pubrepo
   $ cd ..
   $ mkdir bob
   $ HOME="`pwd`/bob"
   $ cd bob
   $ hg clone --pull ../alice/pubrepo pubrepo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   updating to branch default
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
   $ chmod -R u+w alice/pubrepo
   $ HOME="$ORIGHOME"
 
 #endif
 
 
 Symlink to a large largefile should behave the same as a symlink to a normal file
 =====================================================================================
 
 #if symlink
 
   $ hg init largesymlink
   $ cd largesymlink
   $ dd if=/dev/zero bs=1k count=10k of=largefile 2>/dev/null
   $ hg add --large largefile
   $ hg commit -m "commit a large file"
   Invoking status precommit hook
   A largefile
   $ ln -s largefile largelink
   $ hg add largelink
   $ hg commit -m "commit a large symlink"
   Invoking status precommit hook
   A largelink
   $ rm -f largelink
   $ hg up >/dev/null
   $ test -f largelink
   [1]
   $ test -L largelink
   [1]
   $ rm -f largelink # make next part of the test independent of the previous
   $ hg up -C >/dev/null
   $ test -f largelink
   $ test -L largelink
   $ cd ..
 
 #endif
 
 
 test for pattern matching on 'hg status':
 ==============================================
 
 
 to boost performance, largefiles checks whether specified patterns are
 related to largefiles in working directory (NOT to STANDIN) or not.
 
   $ hg init statusmatch
   $ cd statusmatch
 
   $ mkdir -p a/b/c/d
   $ echo normal > a/b/c/d/e.normal.txt
   $ hg add a/b/c/d/e.normal.txt
   $ echo large > a/b/c/d/e.large.txt
   $ hg add --large a/b/c/d/e.large.txt
   $ mkdir -p a/b/c/x
   $ echo normal > a/b/c/x/y.normal.txt
   $ hg add a/b/c/x/y.normal.txt
   $ hg commit -m 'add files'
   Invoking status precommit hook
   A a/b/c/d/e.large.txt
   A a/b/c/d/e.normal.txt
   A a/b/c/x/y.normal.txt
 
 (1) no pattern: no performance boost
   $ hg status -A
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 (2) pattern not related to largefiles: performance boost
   $ hg status -A a/b/c/x
   C a/b/c/x/y.normal.txt
 
 (3) pattern related to largefiles: no performance boost
   $ hg status -A a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
 
 (4) pattern related to STANDIN (not to largefiles): performance boost
   $ hg status -A .hglf/a
   C .hglf/a/b/c/d/e.large.txt
 
 (5) mixed case: no performance boost
   $ hg status -A a/b/c/x a/b/c/d
   C a/b/c/d/e.large.txt
   C a/b/c/d/e.normal.txt
   C a/b/c/x/y.normal.txt
 
 verify that largefiles doesn't break filesets
 
   $ hg log --rev . --exclude "set:binary()"
   changeset:   0:41bd42f10efa
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     add files
   
+sharing a largefile repo automatically enables largefiles on the share
+
+  $ hg share --config extensions.share= . ../shared_lfrepo
+  updating working directory
+  getting changed largefiles
+  1 largefiles updated, 0 removed
+  3 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  $ cat ../shared_lfrepo/.hg/hgrc
+  
+  [extensions]
+  largefiles=
+
 verify that large files in subrepos handled properly
   $ hg init subrepo
   $ echo "subrepo = subrepo" > .hgsub
   $ hg add .hgsub
   $ hg ci -m "add subrepo"
   Invoking status precommit hook
   A .hgsub
   ? .hgsubstate
   $ echo "rev 1" > subrepo/large.txt
   $ hg add --large subrepo/large.txt
   $ hg sum
   parent: 1:8ee150ea2e9c tip
    add subrepo
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 2 draft
   $ hg st
   $ hg st -S
   A subrepo/large.txt
   $ hg ci -S -m "commit top repo"
   committing subrepository subrepo
   Invoking status precommit hook
   A large.txt
   Invoking status precommit hook
   M .hgsubstate
 # No differences
   $ hg st -S
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
   $ echo "rev 2" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
   $ hg sum
   parent: 2:ce4cd0c527a6 tip
    commit top repo
   branch: default
   commit: 1 subrepos
   update: (current)
   phases: 3 draft
   $ hg ci -m "this commit should fail without -S"
   abort: uncommitted changes in subrepository 'subrepo'
   (use --subrepos for recursive commit)
   [255]
 
 Add a normal file to the subrepo, then test archiving
 
   $ echo 'normal file' > subrepo/normal.txt
   $ touch large.dat
   $ mv subrepo/large.txt subrepo/renamed-large.txt
   $ hg addremove -S --dry-run
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg addremove --dry-run subrepo
   removing subrepo/large.txt (glob)
   adding subrepo/normal.txt (glob)
   adding subrepo/renamed-large.txt (glob)
   $ hg status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
   $ cd ..
 
   $ hg -R statusmatch addremove --dry-run statusmatch/subrepo
   removing statusmatch/subrepo/large.txt (glob)
   adding statusmatch/subrepo/normal.txt (glob)
   adding statusmatch/subrepo/renamed-large.txt (glob)
   $ hg -R statusmatch status -S
   ! subrepo/large.txt
   ? large.dat
   ? subrepo/normal.txt
   ? subrepo/renamed-large.txt
 
   $ hg -R statusmatch addremove --dry-run -S
   adding large.dat as a largefile
   removing subrepo/large.txt
   adding subrepo/normal.txt
   adding subrepo/renamed-large.txt
   $ cd statusmatch
 
   $ mv subrepo/renamed-large.txt subrepo/large.txt
   $ hg addremove subrepo
   adding subrepo/normal.txt (glob)
   $ hg forget subrepo/normal.txt
 
   $ hg addremove -S
   adding large.dat as a largefile
   adding subrepo/normal.txt
   $ rm large.dat
 
   $ hg addremove subrepo
   $ hg addremove -S
   removing large.dat
 
 Lock in subrepo, otherwise the change isn't archived
 
   $ hg ci -S -m "add normal file to top level"
   committing subrepository subrepo
   Invoking status precommit hook
   M large.txt
   A normal.txt
   Invoking status precommit hook
   M .hgsubstate
   $ hg archive -S ../lf_subrepo_archive
   $ find ../lf_subrepo_archive | sort
   ../lf_subrepo_archive
   ../lf_subrepo_archive/.hg_archival.txt
   ../lf_subrepo_archive/.hgsub
   ../lf_subrepo_archive/.hgsubstate
   ../lf_subrepo_archive/a
   ../lf_subrepo_archive/a/b
   ../lf_subrepo_archive/a/b/c
   ../lf_subrepo_archive/a/b/c/d
   ../lf_subrepo_archive/a/b/c/d/e.large.txt
   ../lf_subrepo_archive/a/b/c/d/e.normal.txt
   ../lf_subrepo_archive/a/b/c/x
   ../lf_subrepo_archive/a/b/c/x/y.normal.txt
   ../lf_subrepo_archive/subrepo
   ../lf_subrepo_archive/subrepo/large.txt
   ../lf_subrepo_archive/subrepo/normal.txt
   $ cat ../lf_subrepo_archive/.hg_archival.txt
   repo: 41bd42f10efa43698cc02052ea0977771cba506d
   node: d56a95e6522858bc08a724c4fe2bdee066d1c30b
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
 
 Test update with subrepos.
 
   $ hg update 0
   getting changed largefiles
   0 largefiles updated, 1 removed
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg status -S
   $ hg update tip
   getting changed largefiles
   1 largefiles updated, 0 removed
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 # modify a large file
   $ echo "modified" > subrepo/large.txt
   $ hg st -S
   M subrepo/large.txt
 # update -C should revert the change.
   $ hg update -C
   getting changed largefiles
   1 largefiles updated, 0 removed
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg status -S
 
   $ hg forget -v subrepo/large.txt
   removing subrepo/large.txt (glob)
 
 Test reverting a forgotten file
   $ hg revert -R subrepo subrepo/large.txt
   $ hg status -SA subrepo/large.txt
   C subrepo/large.txt
 
   $ hg rm -v subrepo/large.txt
   removing subrepo/large.txt (glob)
   $ hg revert -R subrepo subrepo/large.txt
   $ rm subrepo/large.txt
   $ hg addremove -S
   removing subrepo/large.txt
   $ hg st -S
   R subrepo/large.txt
 
 Test archiving a revision that references a subrepo that is not yet
 cloned (see test-subrepo-recursion.t):
 
   $ hg clone -U . ../empty
   $ cd ../empty
   $ hg archive --subrepos -r tip ../archive.tar.gz
   cloning subrepo subrepo from $TESTTMP/statusmatch/subrepo
   $ cd ..
 
 
 
 
 
 
 Test addremove, forget and others
 ==============================================
 
 Test that addremove picks up largefiles prior to the initial commit (issue3541)
 
   $ hg init addrm2
   $ cd addrm2
   $ touch large.dat
   $ touch large2.dat
   $ touch normal
   $ hg add --large large.dat
   $ hg addremove -v
   adding large2.dat as a largefile
   adding normal
 
 Test that forgetting all largefiles reverts to islfilesrepo() == False
 (addremove will add *.dat as normal files now)
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg addremove -v
   adding large.dat
   adding large2.dat
 
 Test commit's addremove option prior to the first commit
   $ hg forget large.dat
   $ hg forget large2.dat
   $ hg add --large large.dat
   $ hg ci -Am "commit"
   adding large2.dat as a largefile
   Invoking status precommit hook
   A large.dat
   A large2.dat
   A normal
   $ find .hglf | sort
   .hglf
   .hglf/large.dat
   .hglf/large2.dat
 
 Test actions on largefiles using relative paths from subdir
 
   $ mkdir sub
   $ cd sub
   $ echo anotherlarge > anotherlarge
   $ hg add --large anotherlarge
   $ hg st
   A sub/anotherlarge
   $ hg st anotherlarge
   A anotherlarge
   $ hg commit -m anotherlarge anotherlarge
   Invoking status precommit hook
   A sub/anotherlarge
   $ hg log anotherlarge
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg --debug log -T '{rev}: {desc}\n' ../sub/anotherlarge
   updated patterns: ['../.hglf/sub/../sub/anotherlarge', '../sub/anotherlarge']
   1: anotherlarge
 
   $ hg log -G anotherlarge
   @  changeset:   1:9627a577c5e9
   |  tag:         tip
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     anotherlarge
   
 
   $ hg log glob:another*
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg --debug log -T '{rev}: {desc}\n' -G glob:another*
   updated patterns: ['glob:../.hglf/sub/another*', 'glob:another*']
   @  1: anotherlarge
   |
   ~
 
 #if no-msys
   $ hg --debug log -T '{rev}: {desc}\n' 'glob:../.hglf/sub/another*' # no-msys
   updated patterns: ['glob:../.hglf/sub/another*']
   1: anotherlarge
 
   $ hg --debug log -G -T '{rev}: {desc}\n' 'glob:../.hglf/sub/another*' # no-msys
   updated patterns: ['glob:../.hglf/sub/another*']
   @  1: anotherlarge
   |
   ~
 #endif
 
   $ echo more >> anotherlarge
   $ hg st .
   M anotherlarge
   $ hg cat anotherlarge
   anotherlarge
   $ hg revert anotherlarge
   $ hg st
   ? sub/anotherlarge.orig
 
 Test orig files go where we want them
   $ echo moremore >> anotherlarge
   $ hg revert anotherlarge -v --config 'ui.origbackuppath=.hg/origbackups'
   creating directory: $TESTTMP/addrm2/.hg/origbackups/.hglf/sub (glob)
   saving current version of ../.hglf/sub/anotherlarge as $TESTTMP/addrm2/.hg/origbackups/.hglf/sub/anotherlarge.orig (glob)
   reverting ../.hglf/sub/anotherlarge (glob)
   creating directory: $TESTTMP/addrm2/.hg/origbackups/sub (glob)
   found 90c622cf65cebe75c5842f9136c459333faf392e in store
   found 90c622cf65cebe75c5842f9136c459333faf392e in store
   $ ls ../.hg/origbackups/sub
   anotherlarge.orig
   $ cd ..
 
 Test glob logging from the root dir
   $ hg log glob:**another*
   changeset:   1:9627a577c5e9
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     anotherlarge
   
   $ hg log -G glob:**another*
   @  changeset:   1:9627a577c5e9
   |  tag:         tip
   ~  user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     anotherlarge
   
 
   $ cd ..
 
 Log from outer space
   $ hg --debug log -R addrm2 -T '{rev}: {desc}\n' 'addrm2/sub/anotherlarge'
   updated patterns: ['addrm2/.hglf/sub/anotherlarge', 'addrm2/sub/anotherlarge']
   1: anotherlarge
   $ hg --debug log -R addrm2 -T '{rev}: {desc}\n' 'addrm2/.hglf/sub/anotherlarge'
   updated patterns: ['addrm2/.hglf/sub/anotherlarge']
   1: anotherlarge
 
 
 Check error message while exchange
 =========================================================
 
 issue3651: summary/outgoing with largefiles shows "no remote repo"
 unexpectedly
 
   $ mkdir issue3651
   $ cd issue3651
 
   $ hg init src
   $ echo a > src/a
   $ hg -R src add --large src/a
   $ hg -R src commit -m '#0'
   Invoking status precommit hook
   A a
 
 check messages when no remote repository is specified:
 "no remote repo" route for "hg outgoing --large" is not tested here,
 because it can't be reproduced easily.
 
   $ hg init clone1
   $ hg -R clone1 -q pull src
   $ hg -R clone1 -q update
   $ hg -R clone1 paths | grep default
   [1]
 
   $ hg -R clone1 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   phases: 1 draft
   largefiles: (no remote repo)
 
 check messages when there is no files to upload:
 
   $ hg -q clone src clone2
   $ hg -R clone2 paths | grep default
   default = $TESTTMP/issue3651/src (glob)
 
   $ hg -R clone2 summary --large
   parent: 0:fc0bd45326d3 tip
    #0
   branch: default
   commit: (clean)
   update: (current)
   phases: 1 draft
   largefiles: (no files to upload)
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
   [1]
 
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   no changes found
   largefiles: no files to upload
 
 check messages when there are files to upload:
 
   $ echo b > clone2/b
   $ hg -R clone2 add --large clone2/b
   $ hg -R clone2 commit -m '#1'
   Invoking status precommit hook
   A b
   $ hg -R clone2 summary --large
   parent: 1:1acbe71ce432 tip
    #1
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
   largefiles: 1 entities for 1 files to upload
   $ hg -R clone2 outgoing --large
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   changeset:   1:1acbe71ce432
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     #1
   
   largefiles to upload (1 entities):
   b
   
   $ hg -R clone2 outgoing --large --graph --template "{rev}"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   @  1
   
   largefiles to upload (1 entities):
   b
   
 
   $ cp clone2/b clone2/b1
   $ cp clone2/b clone2/b2
   $ hg -R clone2 add --large clone2/b1 clone2/b2
   $ hg -R clone2 commit -m '#2: add largefiles referring same entity'
   Invoking status precommit hook
   A b1
   A b2
   $ hg -R clone2 summary --large
   parent: 2:6095d0695d70 tip
    #2: add largefiles referring same entity
   branch: default
   commit: (clean)
   update: (current)
   phases: 3 draft
   largefiles: 1 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   largefiles to upload (1 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 1 clone2/.hglf/b
   89e6c98d92887913cadf06b2adb97f26cde4849b
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug --config progress.debug=true
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   finding outgoing largefiles: 0/2 revisions (0.00%)
   finding outgoing largefiles: 1/2 revisions (50.00%)
   largefiles to upload (1 entities):
   b
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
   $ echo bbb > clone2/b
   $ hg -R clone2 commit -m '#3: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ echo bbbb > clone2/b
   $ hg -R clone2 commit -m '#4: add new largefile entity as existing file'
   Invoking status precommit hook
   M b
   $ cp clone2/b1 clone2/b
   $ hg -R clone2 commit -m '#5: refer existing largefile entity again'
   Invoking status precommit hook
   M b
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   phases: 6 draft
   largefiles: 3 entities for 3 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (3 entities):
   b
   b1
   b2
   
   $ hg -R clone2 cat -r 3 clone2/.hglf/b
   c801c9cfe94400963fcb683246217d5db77f9a9a
   $ hg -R clone2 cat -r 4 clone2/.hglf/b
   13f9ed0898e315bf59dc2973fec52037b6f441a2
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug --config progress.debug=true
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   1:1acbe71ce432
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/5 revisions (0.00%)
   finding outgoing largefiles: 1/5 revisions (20.00%)
   finding outgoing largefiles: 2/5 revisions (40.00%)
   finding outgoing largefiles: 3/5 revisions (60.00%)
   finding outgoing largefiles: 4/5 revisions (80.00%)
   largefiles to upload (3 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       89e6c98d92887913cadf06b2adb97f26cde4849b
       c801c9cfe94400963fcb683246217d5db77f9a9a
   b1
       89e6c98d92887913cadf06b2adb97f26cde4849b
   b2
       89e6c98d92887913cadf06b2adb97f26cde4849b
   
 
 Pushing revision #1 causes uploading entity 89e6c98d9288, which is
 shared also by largefiles b1, b2 in revision #2 and b in revision #5.
 
 Then, entity 89e6c98d9288 is not treated as "outgoing entity" at "hg
 summary" and "hg outgoing", even though files in outgoing revision #2
 and #5 refer it.
 
   $ hg -R clone2 push -r 1 -q
   $ hg -R clone2 summary --large
   parent: 5:036794ea641c tip
    #5: refer existing largefile entity again
   branch: default
   commit: (clean)
   update: (current)
   phases: 6 draft
   largefiles: 2 entities for 1 files to upload
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n"
   comparing with $TESTTMP/issue3651/src (glob)
   searching for changes
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   largefiles to upload (2 entities):
   b
   
   $ hg -R clone2 outgoing --large -T "{rev}:{node|short}\n" --debug --config progress.debug=true
   comparing with $TESTTMP/issue3651/src (glob)
   query 1; heads
   searching for changes
   all remote heads known locally
   2:6095d0695d70
   3:7983dce246cc
   4:233f12ada4ae
   5:036794ea641c
   finding outgoing largefiles: 0/4 revisions (0.00%)
   finding outgoing largefiles: 1/4 revisions (25.00%)
   finding outgoing largefiles: 2/4 revisions (50.00%)
   finding outgoing largefiles: 3/4 revisions (75.00%)
   largefiles to upload (2 entities):
   b
       13f9ed0898e315bf59dc2973fec52037b6f441a2
       c801c9cfe94400963fcb683246217d5db77f9a9a
   
 
   $ cd ..
 
 merge action 'd' for 'local renamed directory to d2/g' which has no filename
 ==================================================================================
 
   $ hg init merge-action
   $ cd merge-action
   $ touch l
   $ hg add --large l
   $ mkdir d1
   $ touch d1/f
   $ hg ci -Aqm0
   Invoking status precommit hook
   A d1/f
   A l
   $ echo > d1/f
   $ touch d1/g
   $ hg ci -Aqm1
   Invoking status precommit hook
   M d1/f
   A d1/g
   $ hg up -qr0
   $ hg mv d1 d2
   moving d1/f to d2/f (glob)
   $ hg ci -qm2
   Invoking status precommit hook
   A d2/f
   R d1/f
   $ hg merge
   merging d2/f and d1/f to d2/f
   1 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cd ..
 
 
 Merge conflicts:
 =====================
 
   $ hg init merge
   $ cd merge
   $ echo 0 > f-different
   $ echo 0 > f-same
   $ echo 0 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ hg add --large *
   $ hg ci -m0
   Invoking status precommit hook
   A f-different
   A f-same
   A f-unchanged-1
   A f-unchanged-2
   $ echo tmp1 > f-unchanged-1
   $ echo tmp1 > f-unchanged-2
   $ echo tmp1 > f-same
   $ hg ci -m1
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ echo 2 > f-different
   $ echo 0 > f-unchanged-1
   $ echo 1 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m2
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg up -qr0
   $ echo tmp2 > f-unchanged-1
   $ echo tmp2 > f-unchanged-2
   $ echo tmp2 > f-same
   $ hg ci -m3
   Invoking status precommit hook
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   created new head
   $ echo 1 > f-different
   $ echo 1 > f-unchanged-1
   $ echo 0 > f-unchanged-2
   $ echo 1 > f-same
   $ hg ci -m4
   Invoking status precommit hook
   M f-different
   M f-same
   M f-unchanged-1
   M f-unchanged-2
   $ hg merge
   largefile f-different has a merge conflict
   ancestor was 09d2af8dd22201dd8d48e5dcfcaed281ff9422c7
   keep (l)ocal e5fa44f2b31c1fb553b6021e7360d07d5d91ff5e or
   take (o)ther 7448d8798a4380162d4b56f9b452e2f6f9e24e7a? l
   getting changed largefiles
   1 largefiles updated, 0 removed
   0 files updated, 4 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ cat f-different
   1
   $ cat f-same
   1
   $ cat f-unchanged-1
   1
   $ cat f-unchanged-2
   1
   $ cd ..
 
 Test largefile insulation (do not enabled a side effect
 ========================================================
 
 Check whether "largefiles" feature is supported only in repositories
 enabling largefiles extension.
 
   $ mkdir individualenabling
   $ cd individualenabling
 
   $ hg init enabledlocally
   $ echo large > enabledlocally/large
   $ hg -R enabledlocally add --large enabledlocally/large
   $ hg -R enabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ hg init notenabledlocally
   $ echo large > notenabledlocally/large
   $ hg -R notenabledlocally add --large notenabledlocally/large
   $ hg -R notenabledlocally commit -m '#0'
   Invoking status precommit hook
   A large
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > # disable globally
   > largefiles=!
   > EOF
   $ cat >> enabledlocally/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg -R enabledlocally root
   $TESTTMP/individualenabling/enabledlocally (glob)
   $ hg -R notenabledlocally root
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
   [255]
 
   $ hg init push-dst
   $ hg -R enabledlocally push push-dst
   pushing to push-dst
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg init pull-src
   $ hg -R pull-src pull enabledlocally
   pulling from enabledlocally
   abort: required features are not supported in the destination: largefiles
   [255]
 
   $ hg clone enabledlocally clone-dst
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
   [255]
   $ test -d clone-dst
   [1]
   $ hg clone --pull enabledlocally clone-pull-dst
   abort: required features are not supported in the destination: largefiles
   [255]
   $ test -d clone-pull-dst
   [1]
 
 #if serve
 
 Test largefiles specific peer setup, when largefiles is enabled
 locally (issue4109)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
   $ mkdir -p $TESTTMP/individualenabling/usercache
 
   $ hg serve -R enabledlocally -d -p $HGPORT --pid-file hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
 
   $ hg init pull-dst
   $ cat > pull-dst/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > [largefiles]
   > # ignore system cache to force largefiles specific wire proto access
   > usercache=$TESTTMP/individualenabling/usercache
   > EOF
   $ hg -R pull-dst -q pull -u http://localhost:$HGPORT
 
   $ killdaemons.py
 #endif
 
 Test overridden functions work correctly even for repos disabling
 largefiles (issue4547)
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
 (test updating implied by clone)
 
   $ hg init enabled-but-no-largefiles
   $ echo normal1 > enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal1
   $ hg -R enabled-but-no-largefiles commit -m '#0@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal1
   $ cat >> enabled-but-no-largefiles/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ hg clone -q enabled-but-no-largefiles no-largefiles
 
   $ echo normal2 > enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles add enabled-but-no-largefiles/normal2
   $ hg -R enabled-but-no-largefiles commit -m '#1@enabled-but-no-largefiles'
   Invoking status precommit hook
   A normal2
 
   $ echo normal3 > no-largefiles/normal3
   $ hg -R no-largefiles add no-largefiles/normal3
   $ hg -R no-largefiles commit -m '#1@no-largefiles'
   Invoking status precommit hook
   A normal3
 
   $ hg -R no-largefiles -q pull --rebase
   Invoking status precommit hook
   A normal3
 
 (test reverting)
 
   $ hg init subrepo-root
   $ cat >> subrepo-root/.hg/hgrc <<EOF
   > [extensions]
   > # enable locally
   > largefiles=
   > EOF
   $ echo large > subrepo-root/large
   $ hg -R subrepo-root add --large subrepo-root/large
   $ hg clone -q no-largefiles subrepo-root/no-largefiles
   $ cat > subrepo-root/.hgsub <<EOF
   > no-largefiles = no-largefiles
   > EOF
   $ hg -R subrepo-root add subrepo-root/.hgsub
   $ hg -R subrepo-root commit -m '#0'
   Invoking status precommit hook
   A .hgsub
   A large
   ? .hgsubstate
   $ echo dirty >> subrepo-root/large
   $ echo dirty >> subrepo-root/no-largefiles/normal1
   $ hg -R subrepo-root status -S
   M large
   M no-largefiles/normal1
   $ hg -R subrepo-root revert --all
   reverting subrepo-root/.hglf/large (glob)
   reverting subrepo no-largefiles
   reverting subrepo-root/no-largefiles/normal1 (glob)
 
   $ cd ..
 
 
 Test "pull --rebase" when rebase is enabled before largefiles (issue3861)
 =========================================================================
 
   $ hg showconfig extensions | grep largefiles
   extensions.largefiles=!
 
   $ mkdir issue3861
   $ cd issue3861
   $ hg init src
   $ hg clone -q src dst
   $ echo a > src/a
   $ hg -R src commit -Aqm "#0"
   Invoking status precommit hook
   A a
 
   $ cat >> dst/.hg/hgrc <<EOF
   > [extensions]
   > largefiles=
   > EOF
   $ hg -R dst pull --rebase
   pulling from $TESTTMP/issue3861/src (glob)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   nothing to rebase - updating instead
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cd ..

tests/test-share.t

@@ -1,416 +1,424
 #require killdaemons
 
   $ echo "[extensions]"      >> $HGRCPATH
   $ echo "share = "          >> $HGRCPATH
 
 prepare repo1
 
   $ hg init repo1
   $ cd repo1
   $ echo a > a
   $ hg commit -A -m'init'
   adding a
 
 share it
 
   $ cd ..
   $ hg share repo1 repo2
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 share shouldn't have a store dir
 
   $ cd repo2
   $ test -d .hg/store
   [1]
 
 Some sed versions appends newline, some don't, and some just fails
 
   $ cat .hg/sharedpath; echo
   $TESTTMP/repo1/.hg (glob)
 
 trailing newline on .hg/sharedpath is ok
   $ hg tip -q
   0:d3873e73d99e
   $ echo '' >> .hg/sharedpath
   $ cat .hg/sharedpath
   $TESTTMP/repo1/.hg (glob)
   $ hg tip -q
   0:d3873e73d99e
 
 commit in shared clone
 
   $ echo a >> a
   $ hg commit -m'change in shared clone'
 
 check original
 
   $ cd ../repo1
   $ hg log
   changeset:   1:8af4dc49db9e
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change in shared clone
   
   changeset:   0:d3873e73d99e
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat a             # should be two lines of "a"
   a
   a
 
 commit in original
 
   $ echo b > b
   $ hg commit -A -m'another file'
   adding b
 
 check in shared clone
 
   $ cd ../repo2
   $ hg log
   changeset:   2:c2e0ac586386
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another file
   
   changeset:   1:8af4dc49db9e
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     change in shared clone
   
   changeset:   0:d3873e73d99e
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat b             # should exist with one "b"
   b
 
 hg serve shared clone
 
   $ hg serve -n test -p $HGPORT -d --pid-file=hg.pid
   $ cat hg.pid >> $DAEMON_PIDS
   $ get-with-headers.py localhost:$HGPORT 'raw-file/'
   200 Script output follows
   
   
   -rw-r--r-- 4 a
   -rw-r--r-- 2 b
   
   
 
 test unshare command
 
   $ hg unshare
   $ test -d .hg/store
   $ test -f .hg/sharedpath
   [1]
   $ grep shared .hg/requires
   [1]
   $ hg unshare
   abort: this is not a shared repo
   [255]
 
 check that a change does not propagate
 
   $ echo b >> b
   $ hg commit -m'change in unshared'
   $ cd ../repo1
   $ hg id -r tip
   c2e0ac586386 tip
 
   $ cd ..
 
 
 test sharing bookmarks
 
   $ hg share -B repo1 repo3
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo1
   $ hg bookmark bm1
   $ hg bookmarks
    * bm1                       2:c2e0ac586386
   $ cd ../repo2
   $ hg book bm2
   $ hg bookmarks
    * bm2                       3:0e6e70d1d5f1
   $ cd ../repo3
   $ hg bookmarks
      bm1                       2:c2e0ac586386
   $ hg book bm3
   $ hg bookmarks
      bm1                       2:c2e0ac586386
    * bm3                       2:c2e0ac586386
   $ cd ../repo1
   $ hg bookmarks
    * bm1                       2:c2e0ac586386
      bm3                       2:c2e0ac586386
 
 check whether HG_PENDING makes pending changes only in relatd
 repositories visible to an external hook.
 
 In "hg share" case, another transaction can't run in other
 repositories sharing same source repository, because starting
 transaction requires locking store of source repository.
 
 Therefore, this test scenario ignores checking visibility of
 .hg/bookmakrs.pending in repo2, which shares repo1 without bookmarks.
 
   $ cat > $TESTTMP/checkbookmarks.sh <<EOF
   > echo "@repo1"
   > hg -R "$TESTTMP/repo1" bookmarks
   > echo "@repo2"
   > hg -R "$TESTTMP/repo2" bookmarks
   > echo "@repo3"
   > hg -R "$TESTTMP/repo3" bookmarks
   > exit 1 # to avoid adding new bookmark for subsequent tests
   > EOF
 
   $ cd ../repo1
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX
   @repo1
      bm1                       2:c2e0ac586386
      bm3                       2:c2e0ac586386
    * bmX                       2:c2e0ac586386
   @repo2
    * bm2                       3:0e6e70d1d5f1
   @repo3
      bm1                       2:c2e0ac586386
    * bm3                       2:c2e0ac586386
      bmX                       2:c2e0ac586386
   transaction abort!
   rollback completed
   abort: pretxnclose hook exited with status 1
   [255]
   $ hg book bm1
 
 FYI, in contrast to above test, bmX is invisible in repo1 (= shared
 src), because (1) HG_PENDING refers only repo3 and (2)
 "bookmarks.pending" is written only into repo3.
 
   $ cd ../repo3
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkbookmarks.sh" -q book bmX
   @repo1
    * bm1                       2:c2e0ac586386
      bm3                       2:c2e0ac586386
   @repo2
    * bm2                       3:0e6e70d1d5f1
   @repo3
      bm1                       2:c2e0ac586386
      bm3                       2:c2e0ac586386
    * bmX                       2:c2e0ac586386
   transaction abort!
   rollback completed
   abort: pretxnclose hook exited with status 1
   [255]
   $ hg book bm3
 
   $ cd ../repo1
 
 test that commits work
 
   $ echo 'shared bookmarks' > a
   $ hg commit -m 'testing shared bookmarks'
   $ hg bookmarks
    * bm1                       3:b87954705719
      bm3                       2:c2e0ac586386
   $ cd ../repo3
   $ hg bookmarks
      bm1                       3:b87954705719
    * bm3                       2:c2e0ac586386
   $ echo 'more shared bookmarks' > a
   $ hg commit -m 'testing shared bookmarks'
   created new head
   $ hg bookmarks
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
   $ cd ../repo1
   $ hg bookmarks
    * bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
   $ cd ..
 
+non largefiles repos won't enable largefiles
+
+  $ hg share --config extensions.largefiles= repo3 sharedrepo
+  updating working directory
+  2 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  $ [ -f sharedrepo/.hg/hgrc ]
+  [1]
+
 test pushing bookmarks works
 
   $ hg clone repo3 repo4
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo4
   $ hg boo bm4
   $ echo foo > b
   $ hg commit -m 'foo in b'
   $ hg boo
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
    * bm4                       5:92793bfc8cad
   $ hg push -B bm4
   pushing to $TESTTMP/repo3 (glob)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   exporting bookmark bm4
   $ cd ../repo1
   $ hg bookmarks
    * bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ../repo3
   $ hg bookmarks
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ..
 
 test behavior when sharing a shared repo
 
   $ hg share -B repo3 repo5
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo5
   $ hg book
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ..
 
 test what happens when an active bookmark is deleted
 
   $ cd repo1
   $ hg boo -d bm3
   $ hg boo
    * bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ cd ../repo3
   $ hg boo
      bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ cd ..
 
 verify that bookmarks are not written on failed transaction
 
   $ cat > failpullbookmarks.py << EOF
   > """A small extension that makes bookmark pulls fail, for testing"""
   > from mercurial import extensions, exchange, error
   > def _pullbookmarks(orig, pullop):
   >     orig(pullop)
   >     raise error.HookAbort('forced failure by extension')
   > def extsetup(ui):
   >     extensions.wrapfunction(exchange, '_pullbookmarks', _pullbookmarks)
   > EOF
   $ cd repo4
   $ hg boo
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
    * bm4                       5:92793bfc8cad
   $ cd ../repo3
   $ hg boo
      bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ hg --config "extensions.failpullbookmarks=$TESTTMP/failpullbookmarks.py" pull $TESTTMP/repo4
   pulling from $TESTTMP/repo4 (glob)
   searching for changes
   no changes found
   adding remote bookmark bm3
   abort: forced failure by extension
   [255]
   $ hg boo
      bm1                       3:b87954705719
      bm4                       5:92793bfc8cad
   $ hg pull $TESTTMP/repo4
   pulling from $TESTTMP/repo4 (glob)
   searching for changes
   no changes found
   adding remote bookmark bm3
   $ hg boo
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ..
 
 verify bookmark behavior after unshare
 
   $ cd repo3
   $ hg unshare
   $ hg boo
      bm1                       3:b87954705719
    * bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ hg boo -d bm4
   $ hg boo bm5
   $ hg boo
      bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
    * bm5                       4:62f4ded848e4
   $ cd ../repo1
   $ hg boo
    * bm1                       3:b87954705719
      bm3                       4:62f4ded848e4
      bm4                       5:92793bfc8cad
   $ cd ..
 
 test shared clones using relative paths work
 
   $ mkdir thisdir
   $ hg init thisdir/orig
   $ hg share -U thisdir/orig thisdir/abs
   $ hg share -U --relative thisdir/abs thisdir/rel
   $ cat thisdir/rel/.hg/sharedpath
   ../../orig/.hg (no-eol) (glob)
   $ grep shared thisdir/*/.hg/requires
   thisdir/abs/.hg/requires:shared
   thisdir/rel/.hg/requires:shared
   thisdir/rel/.hg/requires:relshared
 
 test that relative shared paths aren't relative to $PWD
 
   $ cd thisdir
   $ hg -R rel root
   $TESTTMP/thisdir/rel (glob)
   $ cd ..
 
 now test that relative paths really are relative, survive across
 renames and changes of PWD
 
   $ hg -R thisdir/abs root
   $TESTTMP/thisdir/abs (glob)
   $ hg -R thisdir/rel root
   $TESTTMP/thisdir/rel (glob)
   $ mv thisdir thatdir
   $ hg -R thatdir/abs root
   abort: .hg/sharedpath points to nonexistent directory $TESTTMP/thisdir/orig/.hg! (glob)
   [255]
   $ hg -R thatdir/rel root
   $TESTTMP/thatdir/rel (glob)
 
 test unshare relshared repo
 
   $ cd thatdir/rel
   $ hg unshare
   $ test -d .hg/store
   $ test -f .hg/sharedpath
   [1]
   $ grep shared .hg/requires
   [1]
   $ hg unshare
   abort: this is not a shared repo
   [255]
   $ cd ../..
 
   $ rm -r thatdir
 
 Explicitly kill daemons to let the test exit on Windows
 
   $ killdaemons.py