delta-find: use "-1" as depth snapshot-dept for non snapshot in debug
This will help do distinct full snapshot (level 0) and normal delta (not a snapshot, no snapshot level)
# sparse.py - functionality for sparse checkouts
#
# Copyright 2014 Facebook, Inc.
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
import os
from .i18n import _
from .node import hex
from . import (
error,
match as matchmod,
merge as mergemod,
mergestate as mergestatemod,
pathutil,
pycompat,
requirements,
scmutil,
util,
)
from .utils import hashutil
# Whether sparse features are enabled. This variable is intended to be
# temporary to facilitate porting sparse to core. It should eventually be
# a per-repo option, possibly a repo requirement.
enabled = False
def use_sparse(repo):
if getattr(repo, "_has_sparse", False):
# When enabling sparse the first time we need it to be enabled before
# actually enabling it. This hack could be avoided if the code was
# improved further, however this is an improvement over the previously
# existing global variable.
return True
return requirements.SPARSE_REQUIREMENT in repo.requirements
def parseconfig(ui, raw, action):
"""Parse sparse config file content.
action is the command which is trigerring this read, can be narrow, sparse
Returns a tuple of includes, excludes, and profiles.
"""
with util.timedcm(
'sparse.parseconfig(ui, %d bytes, action=%s)', len(raw), action
):
includes = set()
excludes = set()
profiles = set()
current = None
havesection = False
for line in raw.split(b'\n'):
line = line.strip()
if not line or line.startswith(b'#'):
# empty or comment line, skip
continue
elif line.startswith(b'%include '):
line = line[9:].strip()
if line:
profiles.add(line)
elif line == b'[include]':
if havesection and current != includes:
# TODO pass filename into this API so we can report it.
raise error.Abort(
_(
b'%(action)s config cannot have includes '
b'after excludes'
)
% {b'action': action}
)
havesection = True
current = includes
continue
elif line == b'[exclude]':
havesection = True
current = excludes
elif line:
if current is None:
raise error.Abort(
_(
b'%(action)s config entry outside of '
b'section: %(line)s'
)
% {b'action': action, b'line': line},
hint=_(
b'add an [include] or [exclude] line '
b'to declare the entry type'
),
)
if line.strip().startswith(b'/'):
ui.warn(
_(
b'warning: %(action)s profile cannot use'
b' paths starting with /, ignoring %(line)s\n'
)
% {b'action': action, b'line': line}
)
continue
current.add(line)
return includes, excludes, profiles
# Exists as separate function to facilitate monkeypatching.
def readprofile(repo, profile, changeid):
"""Resolve the raw content of a sparse profile file."""
# TODO add some kind of cache here because this incurs a manifest
# resolve and can be slow.
return repo.filectx(profile, changeid=changeid).data()
def patternsforrev(repo, rev):
"""Obtain sparse checkout patterns for the given rev.
Returns a tuple of iterables representing includes, excludes, and
patterns.
"""
# Feature isn't enabled. No-op.
if not use_sparse(repo):
return set(), set(), set()
raw = repo.vfs.tryread(b'sparse')
if not raw:
return set(), set(), set()
if rev is None:
raise error.Abort(
_(b'cannot parse sparse patterns from working directory')
)
includes, excludes, profiles = parseconfig(repo.ui, raw, b'sparse')
ctx = repo[rev]
if profiles:
visited = set()
while profiles:
profile = profiles.pop()
if profile in visited:
continue
visited.add(profile)
try:
raw = readprofile(repo, profile, rev)
except error.ManifestLookupError:
msg = (
b"warning: sparse profile '%s' not found "
b"in rev %s - ignoring it\n" % (profile, ctx)
)
# experimental config: sparse.missingwarning
if repo.ui.configbool(b'sparse', b'missingwarning'):
repo.ui.warn(msg)
else:
repo.ui.debug(msg)
continue
pincludes, pexcludes, subprofs = parseconfig(
repo.ui, raw, b'sparse'
)
includes.update(pincludes)
excludes.update(pexcludes)
profiles.update(subprofs)
profiles = visited
if includes:
includes.add(b'.hg*')
return includes, excludes, profiles
def activeconfig(repo):
"""Determine the active sparse config rules.
Rules are constructed by reading the current sparse config and bringing in
referenced profiles from parents of the working directory.
"""
revs = [
repo.changelog.rev(node)
for node in repo.dirstate.parents()
if node != repo.nullid
]
allincludes = set()
allexcludes = set()
allprofiles = set()
for rev in revs:
includes, excludes, profiles = patternsforrev(repo, rev)
allincludes |= includes
allexcludes |= excludes
allprofiles |= profiles
return allincludes, allexcludes, allprofiles
def configsignature(repo, includetemp=True):
"""Obtain the signature string for the current sparse configuration.
This is used to construct a cache key for matchers.
"""
cache = repo._sparsesignaturecache
signature = cache.get(b'signature')
if includetemp:
tempsignature = cache.get(b'tempsignature')
else:
tempsignature = b'0'
if signature is None or (includetemp and tempsignature is None):
signature = hex(hashutil.sha1(repo.vfs.tryread(b'sparse')).digest())
cache[b'signature'] = signature
if includetemp:
raw = repo.vfs.tryread(b'tempsparse')
tempsignature = hex(hashutil.sha1(raw).digest())
cache[b'tempsignature'] = tempsignature
return b'%s %s' % (signature, tempsignature)
def writeconfig(repo, includes, excludes, profiles):
"""Write the sparse config file given a sparse configuration."""
with repo.vfs(b'sparse', b'wb') as fh:
for p in sorted(profiles):
fh.write(b'%%include %s\n' % p)
if includes:
fh.write(b'[include]\n')
for i in sorted(includes):
fh.write(i)
fh.write(b'\n')
if excludes:
fh.write(b'[exclude]\n')
for e in sorted(excludes):
fh.write(e)
fh.write(b'\n')
repo._sparsesignaturecache.clear()
def readtemporaryincludes(repo):
raw = repo.vfs.tryread(b'tempsparse')
if not raw:
return set()
return set(raw.split(b'\n'))
def writetemporaryincludes(repo, includes):
repo.vfs.write(b'tempsparse', b'\n'.join(sorted(includes)))
repo._sparsesignaturecache.clear()
def addtemporaryincludes(repo, additional):
includes = readtemporaryincludes(repo)
for i in additional:
includes.add(i)
writetemporaryincludes(repo, includes)
def prunetemporaryincludes(repo):
if not use_sparse(repo) or not repo.vfs.exists(b'tempsparse'):
return
s = repo.status()
if s.modified or s.added or s.removed or s.deleted:
# Still have pending changes. Don't bother trying to prune.
return
sparsematch = matcher(repo, includetemp=False)
dirstate = repo.dirstate
mresult = mergemod.mergeresult()
dropped = []
tempincludes = readtemporaryincludes(repo)
for file in tempincludes:
if file in dirstate and not sparsematch(file):
message = _(b'dropping temporarily included sparse files')
mresult.addfile(file, mergestatemod.ACTION_REMOVE, None, message)
dropped.append(file)
mergemod.applyupdates(
repo, mresult, repo[None], repo[b'.'], False, wantfiledata=False
)
# Fix dirstate
for file in dropped:
dirstate.update_file(file, p1_tracked=False, wc_tracked=False)
repo.vfs.unlink(b'tempsparse')
repo._sparsesignaturecache.clear()
msg = _(
b'cleaned up %d temporarily added file(s) from the '
b'sparse checkout\n'
)
repo.ui.status(msg % len(tempincludes))
def forceincludematcher(matcher, includes):
"""Returns a matcher that returns true for any of the forced includes
before testing against the actual matcher."""
kindpats = [(b'path', include, b'') for include in includes]
includematcher = matchmod.includematcher(b'', kindpats)
return matchmod.unionmatcher([includematcher, matcher])
def matcher(repo, revs=None, includetemp=True):
"""Obtain a matcher for sparse working directories for the given revs.
If multiple revisions are specified, the matcher is the union of all
revs.
``includetemp`` indicates whether to use the temporary sparse profile.
"""
# If sparse isn't enabled, sparse matcher matches everything.
if not use_sparse(repo):
return matchmod.always()
if not revs or revs == [None]:
revs = [
repo.changelog.rev(node)
for node in repo.dirstate.parents()
if node != repo.nullid
]
signature = configsignature(repo, includetemp=includetemp)
key = b'%s %s' % (signature, b' '.join(map(pycompat.bytestr, revs)))
result = repo._sparsematchercache.get(key)
if result:
return result
matchers = []
for rev in revs:
try:
includes, excludes, profiles = patternsforrev(repo, rev)
if includes or excludes:
matcher = matchmod.match(
repo.root,
b'',
[],
include=includes,
exclude=excludes,
default=b'relpath',
)
matchers.append(matcher)
except IOError:
pass
if not matchers:
result = matchmod.always()
elif len(matchers) == 1:
result = matchers[0]
else:
result = matchmod.unionmatcher(matchers)
if includetemp:
tempincludes = readtemporaryincludes(repo)
result = forceincludematcher(result, tempincludes)
repo._sparsematchercache[key] = result
return result
def filterupdatesactions(repo, wctx, mctx, branchmerge, mresult):
"""Filter updates to only lay out files that match the sparse rules."""
if not use_sparse(repo):
return
oldrevs = [pctx.rev() for pctx in wctx.parents()]
oldsparsematch = matcher(repo, oldrevs)
if oldsparsematch.always():
return
files = set()
prunedactions = {}
if branchmerge:
# If we're merging, use the wctx filter, since we're merging into
# the wctx.
sparsematch = matcher(repo, [wctx.p1().rev()])
else:
# If we're updating, use the target context's filter, since we're
# moving to the target context.
sparsematch = matcher(repo, [mctx.rev()])
temporaryfiles = []
for file, action in mresult.filemap():
type, args, msg = action
files.add(file)
if sparsematch(file):
prunedactions[file] = action
elif type == mergestatemod.ACTION_MERGE:
temporaryfiles.append(file)
prunedactions[file] = action
elif branchmerge:
if not type.no_op:
temporaryfiles.append(file)
prunedactions[file] = action
elif type == mergestatemod.ACTION_FORGET:
prunedactions[file] = action
elif file in wctx:
prunedactions[file] = (mergestatemod.ACTION_REMOVE, args, msg)
# in case or rename on one side, it is possible that f1 might not
# be present in sparse checkout we should include it
# TODO: should we do the same for f2?
# exists as a separate check because file can be in sparse and hence
# if we try to club this condition in above `elif type == ACTION_MERGE`
# it won't be triggered
if branchmerge and type == mergestatemod.ACTION_MERGE:
f1, f2, fa, move, anc = args
if not sparsematch(f1):
temporaryfiles.append(f1)
if len(temporaryfiles) > 0:
repo.ui.status(
_(
b'temporarily included %d file(s) in the sparse '
b'checkout for merging\n'
)
% len(temporaryfiles)
)
addtemporaryincludes(repo, temporaryfiles)
# Add the new files to the working copy so they can be merged, etc
tmresult = mergemod.mergeresult()
message = b'temporarily adding to sparse checkout'
wctxmanifest = repo[None].manifest()
for file in temporaryfiles:
if file in wctxmanifest:
fctx = repo[None][file]
tmresult.addfile(
file,
mergestatemod.ACTION_GET,
(fctx.flags(), False),
message,
)
with repo.dirstate.changing_parents(repo):
mergemod.applyupdates(
repo,
tmresult,
repo[None],
repo[b'.'],
False,
wantfiledata=False,
)
dirstate = repo.dirstate
for file, flags, msg in tmresult.getactions(
[mergestatemod.ACTION_GET]
):
dirstate.update_file(file, p1_tracked=True, wc_tracked=True)
profiles = activeconfig(repo)[2]
changedprofiles = profiles & files
# If an active profile changed during the update, refresh the checkout.
# Don't do this during a branch merge, since all incoming changes should
# have been handled by the temporary includes above.
if changedprofiles and not branchmerge:
mf = mctx.manifest()
for file in mf:
old = oldsparsematch(file)
new = sparsematch(file)
if not old and new:
flags = mf.flags(file)
prunedactions[file] = (
mergestatemod.ACTION_GET,
(flags, False),
b'',
)
elif old and not new:
prunedactions[file] = (mergestatemod.ACTION_REMOVE, [], b'')
mresult.setactions(prunedactions)
def refreshwdir(repo, origstatus, origsparsematch, force=False):
"""Refreshes working directory by taking sparse config into account.
The old status and sparse matcher is compared against the current sparse
matcher.
Will abort if a file with pending changes is being excluded or included
unless ``force`` is True.
"""
# Verify there are no pending changes
pending = set()
pending.update(origstatus.modified)
pending.update(origstatus.added)
pending.update(origstatus.removed)
sparsematch = matcher(repo)
abort = False
for f in pending:
if not sparsematch(f):
repo.ui.warn(_(b"pending changes to '%s'\n") % f)
abort = not force
if abort:
raise error.Abort(
_(b'could not update sparseness due to pending changes')
)
# Calculate merge result
dirstate = repo.dirstate
ctx = repo[b'.']
added = []
lookup = []
dropped = []
mf = ctx.manifest()
files = set(mf)
mresult = mergemod.mergeresult()
for file in files:
old = origsparsematch(file)
new = sparsematch(file)
# Add files that are newly included, or that don't exist in
# the dirstate yet.
if (new and not old) or (old and new and not file in dirstate):
fl = mf.flags(file)
if repo.wvfs.exists(file):
mresult.addfile(file, mergestatemod.ACTION_EXEC, (fl,), b'')
lookup.append(file)
else:
mresult.addfile(
file, mergestatemod.ACTION_GET, (fl, False), b''
)
added.append(file)
# Drop files that are newly excluded, or that still exist in
# the dirstate.
elif (old and not new) or (not old and not new and file in dirstate):
dropped.append(file)
if file not in pending:
mresult.addfile(file, mergestatemod.ACTION_REMOVE, [], b'')
# Verify there are no pending changes in newly included files
abort = False
for file in lookup:
repo.ui.warn(_(b"pending changes to '%s'\n") % file)
abort = not force
if abort:
raise error.Abort(
_(
b'cannot change sparseness due to pending '
b'changes (delete the files or use '
b'--force to bring them back dirty)'
)
)
# Check for files that were only in the dirstate.
for file, state in dirstate.items():
if not file in files:
old = origsparsematch(file)
new = sparsematch(file)
if old and not new:
dropped.append(file)
mergemod.applyupdates(
repo, mresult, repo[None], repo[b'.'], False, wantfiledata=False
)
# Fix dirstate
for file in added:
dirstate.update_file(file, p1_tracked=True, wc_tracked=True)
for file in dropped:
dirstate.update_file(file, p1_tracked=False, wc_tracked=False)
for file in lookup:
# File exists on disk, and we're bringing it back in an unknown state.
dirstate.update_file(
file, p1_tracked=True, wc_tracked=True, possibly_dirty=True
)
return added, dropped, lookup
def aftercommit(repo, node):
"""Perform actions after a working directory commit."""
# This function is called unconditionally, even if sparse isn't
# enabled.
ctx = repo[node]
profiles = patternsforrev(repo, ctx.rev())[2]
# profiles will only have data if sparse is enabled.
if profiles & set(ctx.files()):
origstatus = repo.status()
origsparsematch = matcher(repo)
refreshwdir(repo, origstatus, origsparsematch, force=True)
prunetemporaryincludes(repo)
def _updateconfigandrefreshwdir(
repo, includes, excludes, profiles, force=False, removing=False
):
"""Update the sparse config and working directory state."""
with repo.lock():
raw = repo.vfs.tryread(b'sparse')
oldincludes, oldexcludes, oldprofiles = parseconfig(
repo.ui, raw, b'sparse'
)
oldstatus = repo.status()
oldmatch = matcher(repo)
oldrequires = set(repo.requirements)
# TODO remove this try..except once the matcher integrates better
# with dirstate. We currently have to write the updated config
# because that will invalidate the matcher cache and force a
# re-read. We ideally want to update the cached matcher on the
# repo instance then flush the new config to disk once wdir is
# updated. But this requires massive rework to matcher() and its
# consumers.
if requirements.SPARSE_REQUIREMENT in oldrequires and removing:
repo.requirements.discard(requirements.SPARSE_REQUIREMENT)
scmutil.writereporequirements(repo)
elif requirements.SPARSE_REQUIREMENT not in oldrequires:
repo.requirements.add(requirements.SPARSE_REQUIREMENT)
scmutil.writereporequirements(repo)
try:
writeconfig(repo, includes, excludes, profiles)
return refreshwdir(repo, oldstatus, oldmatch, force=force)
except Exception:
if repo.requirements != oldrequires:
repo.requirements.clear()
repo.requirements |= oldrequires
scmutil.writereporequirements(repo)
writeconfig(repo, oldincludes, oldexcludes, oldprofiles)
raise
def clearrules(repo, force=False):
"""Clears include/exclude rules from the sparse config.
The remaining sparse config only has profiles, if defined. The working
directory is refreshed, as needed.
"""
with repo.wlock(), repo.dirstate.changing_parents(repo):
raw = repo.vfs.tryread(b'sparse')
includes, excludes, profiles = parseconfig(repo.ui, raw, b'sparse')
if not includes and not excludes:
return
_updateconfigandrefreshwdir(repo, set(), set(), profiles, force=force)
def importfromfiles(repo, opts, paths, force=False):
"""Import sparse config rules from files.
The updated sparse config is written out and the working directory
is refreshed, as needed.
"""
with repo.wlock(), repo.dirstate.changing_parents(repo):
# read current configuration
raw = repo.vfs.tryread(b'sparse')
includes, excludes, profiles = parseconfig(repo.ui, raw, b'sparse')
aincludes, aexcludes, aprofiles = activeconfig(repo)
# Import rules on top; only take in rules that are not yet
# part of the active rules.
changed = False
for p in paths:
with util.posixfile(util.expandpath(p), mode=b'rb') as fh:
raw = fh.read()
iincludes, iexcludes, iprofiles = parseconfig(
repo.ui, raw, b'sparse'
)
oldsize = len(includes) + len(excludes) + len(profiles)
includes.update(iincludes - aincludes)
excludes.update(iexcludes - aexcludes)
profiles.update(iprofiles - aprofiles)
if len(includes) + len(excludes) + len(profiles) > oldsize:
changed = True
profilecount = includecount = excludecount = 0
fcounts = (0, 0, 0)
if changed:
profilecount = len(profiles - aprofiles)
includecount = len(includes - aincludes)
excludecount = len(excludes - aexcludes)
fcounts = map(
len,
_updateconfigandrefreshwdir(
repo, includes, excludes, profiles, force=force
),
)
printchanges(
repo.ui, opts, profilecount, includecount, excludecount, *fcounts
)
def updateconfig(
repo,
opts,
include=(),
exclude=(),
reset=False,
delete=(),
enableprofile=(),
disableprofile=(),
force=False,
usereporootpaths=False,
):
"""Perform a sparse config update.
The new config is written out and a working directory refresh is performed.
"""
with repo.wlock(), repo.lock(), repo.dirstate.changing_parents(repo):
raw = repo.vfs.tryread(b'sparse')
oldinclude, oldexclude, oldprofiles = parseconfig(
repo.ui, raw, b'sparse'
)
if reset:
newinclude = set()
newexclude = set()
newprofiles = set()
else:
newinclude = set(oldinclude)
newexclude = set(oldexclude)
newprofiles = set(oldprofiles)
def normalize_pats(pats):
if any(os.path.isabs(pat) for pat in pats):
raise error.Abort(_(b'paths cannot be absolute'))
if usereporootpaths:
return pats
# let's treat paths as relative to cwd
root, cwd = repo.root, repo.getcwd()
abspats = []
for kindpat in pats:
kind, pat = matchmod._patsplit(kindpat, None)
if kind in matchmod.cwdrelativepatternkinds or kind is None:
ap = (kind + b':' if kind else b'') + pathutil.canonpath(
root, cwd, pat
)
abspats.append(ap)
else:
abspats.append(kindpat)
return abspats
include = normalize_pats(include)
exclude = normalize_pats(exclude)
delete = normalize_pats(delete)
disableprofile = normalize_pats(disableprofile)
enableprofile = normalize_pats(enableprofile)
newinclude.difference_update(delete)
newexclude.difference_update(delete)
newprofiles.difference_update(disableprofile)
newinclude.update(include)
newprofiles.update(enableprofile)
newexclude.update(exclude)
profilecount = len(newprofiles - oldprofiles) - len(
oldprofiles - newprofiles
)
includecount = len(newinclude - oldinclude) - len(
oldinclude - newinclude
)
excludecount = len(newexclude - oldexclude) - len(
oldexclude - newexclude
)
fcounts = map(
len,
_updateconfigandrefreshwdir(
repo,
newinclude,
newexclude,
newprofiles,
force=force,
removing=reset,
),
)
printchanges(
repo.ui, opts, profilecount, includecount, excludecount, *fcounts
)
def printchanges(
ui,
opts,
profilecount=0,
includecount=0,
excludecount=0,
added=0,
dropped=0,
conflicting=0,
):
"""Print output summarizing sparse config changes."""
with ui.formatter(b'sparse', opts) as fm:
fm.startitem()
fm.condwrite(
ui.verbose,
b'profiles_added',
_(b'Profiles changed: %d\n'),
profilecount,
)
fm.condwrite(
ui.verbose,
b'include_rules_added',
_(b'Include rules changed: %d\n'),
includecount,
)
fm.condwrite(
ui.verbose,
b'exclude_rules_added',
_(b'Exclude rules changed: %d\n'),
excludecount,
)
# In 'plain' verbose mode, mergemod.applyupdates already outputs what
# files are added or removed outside of the templating formatter
# framework. No point in repeating ourselves in that case.
if not fm.isplain():
fm.condwrite(
ui.verbose, b'files_added', _(b'Files added: %d\n'), added
)
fm.condwrite(
ui.verbose, b'files_dropped', _(b'Files dropped: %d\n'), dropped
)
fm.condwrite(
ui.verbose,
b'files_conflicting',
_(b'Files conflicting: %d\n'),
conflicting,
)