def testinheritlock(self):
d = tempfile.mkdtemp(dir=encoding.getcwd())
parentstate = teststate(self, d)
parentlock = parentstate.makelock()
parentstate.assertacquirecalled(True)
# set up lock inheritance
with parentlock.inherit() as lockname:
parentstate.assertreleasecalled(True)
parentstate.assertpostreleasecalled(False)
parentstate.assertlockexists(True)
childstate = teststate(self, d, pidoffset=1)
childlock = childstate.makelock(parentlock=lockname)
childstate.assertacquirecalled(True)
childlock.release()
childstate.assertreleasecalled(True)
childstate.assertpostreleasecalled(False)
childstate.assertlockexists(True)
parentstate.resetacquirefn()
parentstate.assertacquirecalled(True)
parentlock.release()
parentstate.assertreleasecalled(True)
parentstate.assertpostreleasecalled(True)
parentstate.assertlockexists(False)
def testfrequentlockunlock(self):
"""This tests whether lock acquisition fails as expected, even if
(1) lock can't be acquired (makelock fails by EEXIST), and
(2) locker info can't be read in (readlock fails by ENOENT) while
retrying 5 times.
"""
d = tempfile.mkdtemp(dir=encoding.getcwd())
state = teststate(self, d)
def emulatefrequentlock(*args):
raise OSError(errno.EEXIST, "File exists")
def emulatefrequentunlock(*args):
raise OSError(errno.ENOENT, "No such file or directory")
state.vfs.makelock = emulatefrequentlock
state.vfs.readlock = emulatefrequentunlock
try:
state.makelock(timeout=0)
self.fail("unexpected lock acquisition")
except error.LockHeld as why:
self.assertTrue(why.errno == errno.ETIMEDOUT)
self.assertTrue(why.locker == "")
state.assertlockexists(False)
def testinheritlockfork(self):
d = tempfile.mkdtemp(dir=encoding.getcwd())
parentstate = teststate(self, d)
parentlock = parentstate.makelock()
parentstate.assertacquirecalled(True)
# set up lock inheritance
with parentlock.inherit() as lockname:
childstate = teststate(self, d, pidoffset=1)
childlock = childstate.makelock(parentlock=lockname)
childstate.assertacquirecalled(True)
# fork the child lock
forkchildlock = copy.deepcopy(childlock)
forkchildlock._pidoffset += 1
forkchildlock.release()
childstate.assertreleasecalled(False)
childstate.assertpostreleasecalled(False)
childstate.assertlockexists(True)
# release the child lock
childlock.release()
childstate.assertreleasecalled(True)
childstate.assertpostreleasecalled(False)
childstate.assertlockexists(True)
parentlock.release()
def _parse(self):
if self.changeset is not None:
return
self.changeset = {}
maxrev = 0
if self.revs:
if len(self.revs) > 1:
raise error.Abort(_('cvs source does not support specifying '
'multiple revs'))
# TODO: handle tags
try:
# patchset number?
maxrev = int(self.revs[0])
except ValueError:
raise error.Abort(_('revision %s is not a patchset number')
% self.revs[0])
d = encoding.getcwd()
try:
os.chdir(self.path)
id = None
cache = 'update'
if not self.ui.configbool('convert', 'cvsps.cache'):
cache = None
db = cvsps.createlog(self.ui, cache=cache)
db = cvsps.createchangeset(self.ui, db,
fuzz=int(self.ui.config('convert', 'cvsps.fuzz')),
mergeto=self.ui.config('convert', 'cvsps.mergeto'),
mergefrom=self.ui.config('convert', 'cvsps.mergefrom'))
for cs in db:
if maxrev and cs.id > maxrev:
break
id = (b"%d" % cs.id)
cs.author = self.recode(cs.author)
self.lastbranch[cs.branch] = id
cs.comment = self.recode(cs.comment)
if self.ui.configbool('convert', 'localtimezone'):
cs.date = makedatetimestamp(cs.date[0])
date = dateutil.datestr(cs.date, '%Y-%m-%d %H:%M:%S %1%2')
self.tags.update(dict.fromkeys(cs.tags, id))
files = {}
for f in cs.entries:
files[f.file] = "%s%s" % ('.'.join([(b"%d" % x)
for x in f.revision]),
['', '(DEAD)'][f.dead])
# add current commit to set
c = commit(author=cs.author, date=date,
parents=[(b"%d" % p.id) for p in cs.parents],
desc=cs.comment, branch=cs.branch or '')
self.changeset[id] = c
self.files[id] = files
self.heads = self.lastbranch.values()
finally:
os.chdir(d)
def testlock(self):
state = teststate(self, tempfile.mkdtemp(dir=encoding.getcwd()))
lock = state.makelock()
state.assertacquirecalled(True)
lock.release()
state.assertreleasecalled(True)
state.assertpostreleasecalled(True)
state.assertlockexists(False)
def testinheritcheck(self):
d = tempfile.mkdtemp(dir=encoding.getcwd())
state = teststate(self, d)
def check():
raise error.LockInheritanceContractViolation('check failed')
lock = state.makelock(inheritchecker=check)
state.assertacquirecalled(True)
with self.assertRaises(error.LockInheritanceContractViolation):
with lock.inherit():
pass
lock.release()
def testlockfork(self):
state = teststate(self, tempfile.mkdtemp(dir=encoding.getcwd()))
lock = state.makelock()
state.assertacquirecalled(True)
# fake a fork
forklock = copy.deepcopy(lock)
forklock._pidoffset = 1
forklock.release()
state.assertreleasecalled(False)
state.assertpostreleasecalled(False)
state.assertlockexists(True)
# release the actual lock
lock.release()
state.assertreleasecalled(True)
state.assertpostreleasecalled(True)
state.assertlockexists(False)
def clonenarrowcmd(orig, ui, repo, *args, **opts):
"""Wraps clone command, so 'hg clone' first wraps localrepo.clone()."""
opts = pycompat.byteskwargs(opts)
wrappedextraprepare = util.nullcontextmanager()
narrowspecfile = opts[b'narrowspec']
if narrowspecfile:
filepath = os.path.join(encoding.getcwd(), narrowspecfile)
ui.status(_(b"reading narrowspec from '%s'\n") % filepath)
try:
fdata = util.readfile(filepath)
except IOError as inst:
raise error.Abort(
_(b"cannot read narrowspecs from '%s': %s") %
(filepath, encoding.strtolocal(inst.strerror)))
includes, excludes, profiles = sparse.parseconfig(ui, fdata, b'narrow')
if profiles:
raise error.Abort(
_(b"cannot specify other files using '%include' in"
b" narrowspec"))
narrowspec.validatepatterns(includes)
narrowspec.validatepatterns(excludes)
# narrowspec is passed so we should assume that user wants narrow clone
opts[b'narrow'] = True
opts[b'include'].extend(includes)
opts[b'exclude'].extend(excludes)
if opts[b'narrow']:
def pullbundle2extraprepare_widen(orig, pullop, kwargs):
orig(pullop, kwargs)
if opts.get(b'depth'):
kwargs[b'depth'] = opts[b'depth']
wrappedextraprepare = extensions.wrappedfunction(
exchange, b'_pullbundle2extraprepare',
pullbundle2extraprepare_widen)
with wrappedextraprepare:
return orig(ui, repo, *args, **pycompat.strkwargs(opts))
def testrecursivelock(self):
state = teststate(self, tempfile.mkdtemp(dir=encoding.getcwd()))
lock = state.makelock()
state.assertacquirecalled(True)
state.resetacquirefn()
lock.lock()
# recursive lock should not call acquirefn again
state.assertacquirecalled(False)
lock.release() # brings lock refcount down from 2 to 1
state.assertreleasecalled(False)
state.assertpostreleasecalled(False)
state.assertlockexists(True)
lock.release() # releases the lock
state.assertreleasecalled(True)
state.assertpostreleasecalled(True)
state.assertlockexists(False)
def _matchpaths(repo, rev, pats, opts, aopts=facontext.defaultopts):
"""generate paths matching given patterns"""
perfhack = repo.ui.configbool(b'fastannotate', b'perfhack')
# disable perfhack if:
# a) any walkopt is used
# b) if we treat pats as plain file names, some of them do not have
# corresponding linelog files
if perfhack:
# cwd related to reporoot
reporoot = os.path.dirname(repo.path)
reldir = os.path.relpath(encoding.getcwd(), reporoot)
if reldir == b'.':
reldir = b''
if any(opts.get(o[1]) for o in commands.walkopts): # a)
perfhack = False
else: # b)
relpats = [
os.path.relpath(p, reporoot) if os.path.isabs(p) else p
for p in pats
]
# disable perfhack on '..' since it allows escaping from the repo
if any((b'..' in f or not os.path.isfile(
facontext.pathhelper(repo, f, aopts).linelogpath))
for f in relpats):
perfhack = False
# perfhack: emit paths directory without checking with manifest
# this can be incorrect if the rev dos not have file.
if perfhack:
for p in relpats:
yield os.path.join(reldir, p)
else:
def bad(x, y):
raise error.Abort(b"%s: %s" % (x, y))
ctx = scmutil.revsingle(repo, rev)
m = scmutil.match(ctx, pats, opts, badfn=bad)
for p in ctx.walk(m):
yield p
def testmultilock(self):
d = tempfile.mkdtemp(dir=encoding.getcwd())
state0 = teststate(self, d)
lock0 = state0.makelock()
state0.assertacquirecalled(True)
with lock0.inherit() as lock0name:
state0.assertreleasecalled(True)
state0.assertpostreleasecalled(False)
state0.assertlockexists(True)
state1 = teststate(self, d, pidoffset=1)
lock1 = state1.makelock(parentlock=lock0name)
state1.assertacquirecalled(True)
# from within lock1, acquire another lock
with lock1.inherit() as lock1name:
# since the file on disk is lock0's this should have the same
# name
self.assertEqual(lock0name, lock1name)
state2 = teststate(self, d, pidoffset=2)
lock2 = state2.makelock(parentlock=lock1name)
state2.assertacquirecalled(True)
lock2.release()
state2.assertreleasecalled(True)
state2.assertpostreleasecalled(False)
state2.assertlockexists(True)
state1.resetacquirefn()
state1.assertacquirecalled(True)
lock1.release()
state1.assertreleasecalled(True)
state1.assertpostreleasecalled(False)
state1.assertlockexists(True)
lock0.release()
def trackedcmd(ui, repo, remotepath=None, *pats, **opts):
"""show or change the current narrowspec
With no argument, shows the current narrowspec entries, one per line. Each
line will be prefixed with 'I' or 'X' for included or excluded patterns,
respectively.
The narrowspec is comprised of expressions to match remote files and/or
directories that should be pulled into your client.
The narrowspec has *include* and *exclude* expressions, with excludes always
trumping includes: that is, if a file matches an exclude expression, it will
be excluded even if it also matches an include expression.
Excluding files that were never included has no effect.
Each included or excluded entry is in the format described by
'hg help patterns'.
The options allow you to add or remove included and excluded expressions.
If --clear is specified, then all previous includes and excludes are DROPPED
and replaced by the new ones specified to --addinclude and --addexclude.
If --clear is specified without any further options, the narrowspec will be
empty and will not match any files.
"""
opts = pycompat.byteskwargs(opts)
if repository.NARROW_REQUIREMENT not in repo.requirements:
ui.warn(_('The narrow command is only supported on respositories cloned'
' with --narrow.\n'))
return 1
# Before supporting, decide whether it "hg tracked --clear" should mean
# tracking no paths or all paths.
if opts['clear']:
ui.warn(_('The --clear option is not yet supported.\n'))
return 1
# import rules from a file
newrules = opts.get('import_rules')
if newrules:
try:
filepath = os.path.join(encoding.getcwd(), newrules)
fdata = util.readfile(filepath)
except IOError as inst:
raise error.Abort(_("cannot read narrowspecs from '%s': %s") %
(filepath, encoding.strtolocal(inst.strerror)))
includepats, excludepats, profiles = sparse.parseconfig(ui, fdata,
'narrow')
if profiles:
raise error.Abort(_("including other spec files using '%include' "
"is not supported in narrowspec"))
opts['addinclude'].extend(includepats)
opts['addexclude'].extend(excludepats)
addedincludes = narrowspec.parsepatterns(opts['addinclude'])
removedincludes = narrowspec.parsepatterns(opts['removeinclude'])
addedexcludes = narrowspec.parsepatterns(opts['addexclude'])
removedexcludes = narrowspec.parsepatterns(opts['removeexclude'])
only_show = not (addedincludes or removedincludes or addedexcludes or
removedexcludes or newrules)
oldincludes, oldexcludes = repo.narrowpats
# filter the user passed additions and deletions into actual additions and
# deletions of excludes and includes
addedincludes -= oldincludes
removedincludes &= oldincludes
addedexcludes -= oldexcludes
removedexcludes &= oldexcludes
widening = addedincludes or removedexcludes
narrowing = removedincludes or addedexcludes
# Only print the current narrowspec.
if only_show:
ui.pager('tracked')
fm = ui.formatter('narrow', opts)
for i in sorted(oldincludes):
fm.startitem()
fm.write('status', '%s ', 'I', label='narrow.included')
fm.write('pat', '%s\n', i, label='narrow.included')
for i in sorted(oldexcludes):
fm.startitem()
fm.write('status', '%s ', 'X', label='narrow.excluded')
fm.write('pat', '%s\n', i, label='narrow.excluded')
fm.end()
return 0
if not widening and not narrowing:
ui.status(_("nothing to widen or narrow\n"))
return 0
with repo.wlock(), repo.lock():
cmdutil.bailifchanged(repo)
# Find the revisions we have in common with the remote. These will
# be used for finding local-only changes for narrowing. They will
# also define the set of revisions to update for widening.
remotepath = ui.expandpath(remotepath or 'default')
url, branches = hg.parseurl(remotepath)
ui.status(_('comparing with %s\n') % util.hidepassword(url))
remote = hg.peer(repo, opts, url)
# check narrow support before doing anything if widening needs to be
# performed. In future we should also abort if client is ellipses and
# server does not support ellipses
if widening and wireprototypes.NARROWCAP not in remote.capabilities():
raise error.Abort(_("server does not support narrow clones"))
commoninc = discovery.findcommonincoming(repo, remote)
if narrowing:
newincludes = oldincludes - removedincludes
newexcludes = oldexcludes | addedexcludes
_narrow(ui, repo, remote, commoninc, oldincludes, oldexcludes,
newincludes, newexcludes,
opts['force_delete_local_changes'])
# _narrow() updated the narrowspec and _widen() below needs to
# use the updated values as its base (otherwise removed includes
# and addedexcludes will be lost in the resulting narrowspec)
oldincludes = newincludes
oldexcludes = newexcludes
if widening:
newincludes = oldincludes | addedincludes
newexcludes = oldexcludes - removedexcludes
_widen(ui, repo, remote, commoninc, oldincludes, oldexcludes,
newincludes, newexcludes)
return 0
def trackedcmd(ui, repo, remotepath=None, *pats, **opts):
"""show or change the current narrowspec
With no argument, shows the current narrowspec entries, one per line. Each
line will be prefixed with 'I' or 'X' for included or excluded patterns,
respectively.
The narrowspec is comprised of expressions to match remote files and/or
directories that should be pulled into your client.
The narrowspec has *include* and *exclude* expressions, with excludes always
trumping includes: that is, if a file matches an exclude expression, it will
be excluded even if it also matches an include expression.
Excluding files that were never included has no effect.
Each included or excluded entry is in the format described by
'hg help patterns'.
The options allow you to add or remove included and excluded expressions.
If --clear is specified, then all previous includes and excludes are DROPPED
and replaced by the new ones specified to --addinclude and --addexclude.
If --clear is specified without any further options, the narrowspec will be
empty and will not match any files.
If --auto-remove-includes is specified, then those includes that don't match
any files modified by currently visible local commits (those not shared by
the remote) will be added to the set of explicitly specified includes to
remove.
--import-rules accepts a path to a file containing rules, allowing you to
add --addinclude, --addexclude rules in bulk. Like the other include and
exclude switches, the changes are applied immediately.
"""
opts = pycompat.byteskwargs(opts)
if repository.NARROW_REQUIREMENT not in repo.requirements:
raise error.Abort(
_(b'the tracked command is only supported on '
b'repositories cloned with --narrow'))
# Before supporting, decide whether it "hg tracked --clear" should mean
# tracking no paths or all paths.
if opts[b'clear']:
raise error.Abort(_(b'the --clear option is not yet supported'))
# import rules from a file
newrules = opts.get(b'import_rules')
if newrules:
try:
filepath = os.path.join(encoding.getcwd(), newrules)
fdata = util.readfile(filepath)
except IOError as inst:
raise error.Abort(
_(b"cannot read narrowspecs from '%s': %s") %
(filepath, encoding.strtolocal(inst.strerror)))
includepats, excludepats, profiles = sparse.parseconfig(
ui, fdata, b'narrow')
if profiles:
raise error.Abort(
_(b"including other spec files using '%include' "
b"is not supported in narrowspec"))
opts[b'addinclude'].extend(includepats)
opts[b'addexclude'].extend(excludepats)
addedincludes = narrowspec.parsepatterns(opts[b'addinclude'])
removedincludes = narrowspec.parsepatterns(opts[b'removeinclude'])
addedexcludes = narrowspec.parsepatterns(opts[b'addexclude'])
removedexcludes = narrowspec.parsepatterns(opts[b'removeexclude'])
autoremoveincludes = opts[b'auto_remove_includes']
update_working_copy = opts[b'update_working_copy']
only_show = not (addedincludes or removedincludes or addedexcludes
or removedexcludes or newrules or autoremoveincludes
or update_working_copy)
oldincludes, oldexcludes = repo.narrowpats
# filter the user passed additions and deletions into actual additions and
# deletions of excludes and includes
addedincludes -= oldincludes
removedincludes &= oldincludes
addedexcludes -= oldexcludes
removedexcludes &= oldexcludes
widening = addedincludes or removedexcludes
narrowing = removedincludes or addedexcludes
# Only print the current narrowspec.
if only_show:
ui.pager(b'tracked')
fm = ui.formatter(b'narrow', opts)
for i in sorted(oldincludes):
fm.startitem()
fm.write(b'status', b'%s ', b'I', label=b'narrow.included')
fm.write(b'pat', b'%s\n', i, label=b'narrow.included')
for i in sorted(oldexcludes):
fm.startitem()
fm.write(b'status', b'%s ', b'X', label=b'narrow.excluded')
fm.write(b'pat', b'%s\n', i, label=b'narrow.excluded')
fm.end()
return 0
if update_working_copy:
with repo.wlock(), repo.lock(), repo.transaction(b'narrow-wc'):
narrowspec.updateworkingcopy(repo)
narrowspec.copytoworkingcopy(repo)
return 0
if not (widening or narrowing or autoremoveincludes):
ui.status(_(b"nothing to widen or narrow\n"))
return 0
with repo.wlock(), repo.lock():
cmdutil.bailifchanged(repo)
# Find the revisions we have in common with the remote. These will
# be used for finding local-only changes for narrowing. They will
# also define the set of revisions to update for widening.
remotepath = ui.expandpath(remotepath or b'default')
url, branches = hg.parseurl(remotepath)
ui.status(_(b'comparing with %s\n') % util.hidepassword(url))
remote = hg.peer(repo, opts, url)
# check narrow support before doing anything if widening needs to be
# performed. In future we should also abort if client is ellipses and
# server does not support ellipses
if widening and wireprototypes.NARROWCAP not in remote.capabilities():
raise error.Abort(_(b"server does not support narrow clones"))
commoninc = discovery.findcommonincoming(repo, remote)
if autoremoveincludes:
outgoing = discovery.findcommonoutgoing(repo,
remote,
commoninc=commoninc)
ui.status(_(b'looking for unused includes to remove\n'))
localfiles = set()
for n in itertools.chain(outgoing.missing, outgoing.excluded):
localfiles.update(repo[n].files())
suggestedremovals = []
for include in sorted(oldincludes):
match = narrowspec.match(repo.root, [include], oldexcludes)
if not any(match(f) for f in localfiles):
suggestedremovals.append(include)
if suggestedremovals:
for s in suggestedremovals:
ui.status(b'%s\n' % s)
if (ui.promptchoice(
_(b'remove these unused includes (yn)?'
b'$$ &Yes $$ &No')) == 0):
removedincludes.update(suggestedremovals)
narrowing = True
else:
ui.status(_(b'found no unused includes\n'))
if narrowing:
newincludes = oldincludes - removedincludes
newexcludes = oldexcludes | addedexcludes
_narrow(
ui,
repo,
remote,
commoninc,
oldincludes,
oldexcludes,
newincludes,
newexcludes,
opts[b'force_delete_local_changes'],
)
# _narrow() updated the narrowspec and _widen() below needs to
# use the updated values as its base (otherwise removed includes
# and addedexcludes will be lost in the resulting narrowspec)
oldincludes = newincludes
oldexcludes = newexcludes
if widening:
newincludes = oldincludes | addedincludes
newexcludes = oldexcludes - removedexcludes
_widen(
ui,
repo,
remote,
commoninc,
oldincludes,
oldexcludes,
newincludes,
newexcludes,
)
return 0
