def cleanupnode(ui, repo, name, nodes):
"""strip a group of nodes from the repository
The set of node to strip may contains unknown nodes."""
ui.debug('should strip %s nodes %s\n' %
(name, ', '.join([node.short(n) for n in nodes])))
lock = None
try:
lock = repo.lock()
# do not let filtering get in the way of the cleanse
# we should probably get rid of obsolescence marker created during the
# histedit, but we currently do not have such information.
repo = repo.unfiltered()
# Find all nodes that need to be stripped
# (we use %lr instead of %ln to silently ignore unknown items)
nm = repo.changelog.nodemap
nodes = sorted(n for n in nodes if n in nm)
roots = [c.node() for c in repo.set("roots(%ln)", nodes)]
for c in roots:
# We should process node in reverse order to strip tip most first.
# but this trigger a bug in changegroup hook.
# This would reduce bundle overhead
repair.strip(ui, repo, c)
finally:
release(lock)
def strip(ui,
repo,
revs,
update=True,
backup="all",
force=None,
bookmark=None):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if update:
checklocalchanges(repo, force=force)
urev, p2 = repo.changelog.parents(revs[0])
if (util.safehasattr(repo, 'mq') and p2 != nullid
and p2 in [x.node for x in repo.mq.applied]):
urev = p2
hg.clean(repo, urev)
repo.dirstate.write()
repair.strip(ui, repo, revs, backup)
marks = repo._bookmarks
if bookmark:
if bookmark == repo._bookmarkcurrent:
bookmarks.unsetcurrent(repo)
del marks[bookmark]
marks.write()
ui.write(_("bookmark '%s' deleted\n") % bookmark)
finally:
release(lock, wlock)
def strip(ui, repo, revs, update=True, backup=True, force=None, bookmark=None):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if update:
checklocalchanges(repo, force=force)
urev, p2 = repo.changelog.parents(revs[0])
if (util.safehasattr(repo, 'mq') and
p2 != nullid
and p2 in [x.node for x in repo.mq.applied]):
urev = p2
hg.clean(repo, urev)
repo.dirstate.write()
repair.strip(ui, repo, revs, backup)
marks = repo._bookmarks
if bookmark:
if bookmark == repo._bookmarkcurrent:
bookmarks.unsetcurrent(repo)
del marks[bookmark]
marks.write()
ui.write(_("bookmark '%s' deleted\n") % bookmark)
finally:
release(lock, wlock)
def kwcommitctx(self, ctx, error=False):
wlock = lock = None
try:
wlock = self.wlock()
lock = self.lock()
# store and postpone commit hooks
commithooks = {}
for name, cmd in ui.configitems('hooks'):
if name.split('.', 1)[0] == 'commit':
commithooks[name] = cmd
ui.setconfig('hooks', name, None)
if commithooks:
# store parents for commit hooks
p1, p2 = ctx.p1(), ctx.p2()
xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
n = super(kwrepo, self).commitctx(ctx, error)
kwt.overwrite(n, True, None)
if commithooks:
for name, cmd in commithooks.iteritems():
ui.setconfig('hooks', name, cmd)
self.hook('commit', node=n, parent1=xp1, parent2=xp2)
return n
finally:
release(lock, wlock)
def strip(ui, repo, revs, update=True, backup=True, force=None, bookmarks=None):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if update:
checklocalchanges(repo, force=force)
urev, p2 = repo.changelog.parents(revs[0])
if (util.safehasattr(repo, 'mq') and
p2 != nullid
and p2 in [x.node for x in repo.mq.applied]):
urev = p2
hg.clean(repo, urev)
repo.dirstate.write(repo.currenttransaction())
repair.strip(ui, repo, revs, backup)
repomarks = repo._bookmarks
if bookmarks:
with repo.transaction('strip') as tr:
if repo._activebookmark in bookmarks:
bookmarksmod.deactivate(repo)
for bookmark in bookmarks:
del repomarks[bookmark]
repomarks.recordchange(tr)
for bookmark in sorted(bookmarks):
ui.write(_("bookmark '%s' deleted\n") % bookmark)
finally:
release(lock, wlock)
def concludenode(repo, rev, p1, p2, commitmsg=None, editor=None, extrafn=None):
"""Commit the wd changes with parents p1 and p2. Reuse commit info from rev
but also store useful information in extra.
Return node of committed revision."""
dsguard = cmdutil.dirstateguard(repo, "rebase")
try:
repo.setparents(repo[p1].node(), repo[p2].node())
ctx = repo[rev]
if commitmsg is None:
commitmsg = ctx.description()
extra = {"rebase_source": ctx.hex()}
if extrafn:
extrafn(ctx, extra)
backup = repo.ui.backupconfig("phases", "new-commit")
try:
targetphase = max(ctx.phase(), phases.draft)
repo.ui.setconfig("phases", "new-commit", targetphase, "rebase")
# Commit might fail if unresolved files exist
newnode = repo.commit(text=commitmsg, user=ctx.user(), date=ctx.date(), extra=extra, editor=editor)
finally:
repo.ui.restoreconfig(backup)
repo.dirstate.setbranch(repo[newnode].branch())
dsguard.close()
return newnode
finally:
release(dsguard)
def histedit(ui, repo, *freeargs, **opts):
"""interactively edit changeset history
This command edits changesets between ANCESTOR and the parent of
the working directory.
With --outgoing, this edits changesets not found in the
destination repository. If URL of the destination is omitted, the
'default-push' (or 'default') path will be used.
For safety, this command is aborted, also if there are ambiguous
outgoing revisions which may confuse users: for example, there are
multiple branches containing outgoing revisions.
Use "min(outgoing() and ::.)" or similar revset specification
instead of --outgoing to specify edit target revision exactly in
such ambiguous situation. See :hg:`help revsets` for detail about
selecting revisions.
Returns 0 on success, 1 if user intervention is required (not only
for intentional "edit" command, but also for resolving unexpected
conflicts).
"""
state = histeditstate(repo)
try:
state.wlock = repo.wlock()
state.lock = repo.lock()
_histedit(ui, repo, state, *freeargs, **opts)
finally:
release(state.lock, state.wlock)
def concludenode(repo, rev, p1, p2, commitmsg=None, editor=None, extrafn=None):
'''Commit the wd changes with parents p1 and p2. Reuse commit info from rev
but also store useful information in extra.
Return node of committed revision.'''
dsguard = cmdutil.dirstateguard(repo, 'rebase')
try:
repo.setparents(repo[p1].node(), repo[p2].node())
ctx = repo[rev]
if commitmsg is None:
commitmsg = ctx.description()
extra = {'rebase_source': ctx.hex()}
if extrafn:
extrafn(ctx, extra)
backup = repo.ui.backupconfig('phases', 'new-commit')
try:
targetphase = max(ctx.phase(), phases.draft)
repo.ui.setconfig('phases', 'new-commit', targetphase, 'rebase')
# Commit might fail if unresolved files exist
newnode = repo.commit(text=commitmsg, user=ctx.user(),
date=ctx.date(), extra=extra, editor=editor)
finally:
repo.ui.restoreconfig(backup)
repo.dirstate.setbranch(repo[newnode].branch())
dsguard.close()
return newnode
finally:
release(dsguard)
def unshelveabort(ui, repo, state, opts):
"""subcommand that abort an in-progress unshelve"""
wlock = repo.wlock()
lock = None
try:
checkparents(repo, state)
util.rename(repo.join('unshelverebasestate'),
repo.join('rebasestate'))
try:
rebase.rebase(ui, repo, **{
'abort' : True
})
except Exception:
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise
lock = repo.lock()
mergefiles(ui, repo, state.wctx, state.pendingctx)
repair.strip(ui, repo, state.stripnodes, backup=False, topic='shelve')
shelvedstate.clear(repo)
ui.warn(_("unshelve of '%s' aborted\n") % state.name)
finally:
lockmod.release(lock, wlock)
def unshelveabort(ui, repo, state, opts):
"""subcommand that abort an in-progress unshelve"""
wlock = repo.wlock()
lock = None
try:
checkparents(repo, state)
util.rename(repo.join('unshelverebasestate'),
repo.join('rebasestate'))
try:
rebase.rebase(ui, repo, **{
'abort' : True
})
except Exception:
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise
lock = repo.lock()
mergefiles(ui, repo, state.wctx, state.pendingctx)
repair.strip(ui, repo, state.stripnodes, backup='none', topic='shelve')
shelvedstate.clear(repo)
ui.warn(_("unshelve of '%s' aborted\n") % state.name)
finally:
lockmod.release(lock, wlock)
def apply(self, repo, series, list=False, update_status=True,
strict=False, patchdir=None, merge=None, all_files=None,
tobackup=None, keepchanges=False):
wlock = lock = tr = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction("qpush")
try:
ret = self._apply(repo, series, list, update_status,
strict, patchdir, merge, all_files=all_files,
tobackup=tobackup, keepchanges=keepchanges)
tr.close()
self.savedirty()
return ret
except AbortNoCleanup:
tr.close()
self.savedirty()
return 2, repo.dirstate.p1()
except: # re-raises
try:
tr.abort()
finally:
repo.invalidate()
repo.dirstate.invalidate()
self.invalidate()
raise
finally:
release(tr, lock, wlock)
self.removeundo(repo)
def kwcommitctx(self, ctx, error=False):
wlock = lock = None
try:
wlock = self.wlock()
lock = self.lock()
# store and postpone commit hooks
commithooks = {}
for name, cmd in ui.configitems('hooks'):
if name.split('.', 1)[0] == 'commit':
commithooks[name] = cmd
ui.setconfig('hooks', name, None)
if commithooks:
# store parents for commit hooks
p1, p2 = ctx.p1(), ctx.p2()
xp1, xp2 = p1.hex(), p2 and p2.hex() or ''
n = super(kwrepo, self).commitctx(ctx, error)
kwt.overwrite(n, True, None)
if commithooks:
for name, cmd in commithooks.iteritems():
ui.setconfig('hooks', name, cmd)
self.hook('commit', node=n, parent1=xp1, parent2=xp2)
return n
finally:
release(lock, wlock)
def _inhibitmarkers(repo, nodes):
"""add marker inhibitor for all obsolete revision under <nodes>
Content of <nodes> and all mutable ancestors are considered. Marker for
obsolete revision only are created.
"""
if not _inhibitenabled(repo):
return
# we add (non public()) as a lower boundary to
# - use the C code in 3.6 (no ancestors in C as this is written)
# - restrict the search space. Otherwise, the ancestors can spend a lot of
# time iterating if you have a check very low in the repo. We do not need
# to iterate over tens of thousand of public revisions with higher
# revision number
#
# In addition, the revset logic could be made significantly smarter here.
newinhibit = repo.revs('(not public())::%ln and obsolete()', nodes)
if newinhibit:
node = repo.changelog.node
lock = tr = None
try:
lock = repo.lock()
tr = repo.transaction('obsinhibit')
repo._obsinhibit.update(node(r) for r in newinhibit)
_schedulewrite(tr, _filterpublic(repo, repo._obsinhibit))
repo.invalidatevolatilesets()
tr.close()
finally:
lockmod.release(tr, lock)
def updatebookmarks(repo, changes, name='git_handler'):
"""abstract writing bookmarks for backwards compatibility"""
bms = repo._bookmarks
tr = lock = wlock = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction(name)
if hgutil.safehasattr(bms, 'applychanges'):
# applychanges was added in mercurial 4.3
bms.applychanges(repo, tr, changes)
else:
for name, node in changes:
if node is None:
del bms[name]
else:
bms[name] = node
if hgutil.safehasattr(bms, 'recordchange'):
# recordchange was added in mercurial 3.2
bms.recordchange(tr)
else:
bms.write()
tr.close()
finally:
lockmod.release(tr, lock, wlock)
def unshelveabort(ui, repo, state, opts):
"""subcommand that abort an in-progress unshelve"""
wlock = repo.wlock()
lock = None
try:
checkparents(repo, state)
lock = repo.lock()
merge.mergestate(repo).reset()
if opts['keep']:
repo.setparents(repo.dirstate.parents()[0])
else:
revertfiles = readshelvedfiles(repo, state.name)
wctx = repo.parents()[0]
cmdutil.revert(ui, repo, wctx, [wctx.node(), nullid],
*revertfiles, **{'no_backup': True})
# fix up the weird dirstate states the merge left behind
mf = wctx.manifest()
dirstate = repo.dirstate
for f in revertfiles:
if f in mf:
dirstate.normallookup(f)
else:
dirstate.drop(f)
dirstate._pl = (wctx.node(), nullid)
dirstate._dirty = True
repair.strip(ui, repo, state.stripnodes, backup='none', topic='shelve')
shelvedstate.clear(repo)
ui.warn(_("unshelve of '%s' aborted\n") % state.name)
finally:
lockmod.release(lock, wlock)
def histedit(ui, repo, *freeargs, **opts):
"""interactively edit changeset history
This command edits changesets between ANCESTOR and the parent of
the working directory.
With --outgoing, this edits changesets not found in the
destination repository. If URL of the destination is omitted, the
'default-push' (or 'default') path will be used.
For safety, this command is aborted, also if there are ambiguous
outgoing revisions which may confuse users: for example, there are
multiple branches containing outgoing revisions.
Use "min(outgoing() and ::.)" or similar revset specification
instead of --outgoing to specify edit target revision exactly in
such ambiguous situation. See :hg:`help revsets` for detail about
selecting revisions.
Returns 0 on success, 1 if user intervention is required (not only
for intentional "edit" command, but also for resolving unexpected
conflicts).
"""
state = histeditstate(repo)
try:
state.wlock = repo.wlock()
state.lock = repo.lock()
_histedit(ui, repo, state, *freeargs, **opts)
finally:
release(state.lock, state.wlock)
def _deleteunreachable(repo, ctx):
"""Deletes all ancestor and descendant commits of the given revision that
aren't reachable from another bookmark.
"""
keepheads = "bookmark() + ."
try:
extensions.find('remotenames')
keepheads += " + remotenames()"
except KeyError:
pass
hiderevs = repo.revs('::%s - ::(%r)', ctx.rev(), keepheads)
if hiderevs:
lock = None
try:
lock = repo.lock()
if _isobsstoreenabled(repo):
markers = []
for rev in hiderevs:
markers.append((repo[rev], ()))
obsolete.createmarkers(repo, markers)
repo.ui.status(_("%d changesets pruned\n") % len(hiderevs))
else:
repair.strip(repo.ui, repo,
[repo.changelog.node(r) for r in hiderevs])
finally:
lockmod.release(lock)
def strip(ui, repo, revs, update=True, backup=True, force=None, bookmarks=None):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if update:
checklocalchanges(repo, force=force)
urev, p2 = repo.changelog.parents(revs[0])
if (util.safehasattr(repo, 'mq') and
p2 != nullid
and p2 in [x.node for x in repo.mq.applied]):
urev = p2
hg.clean(repo, urev)
repo.dirstate.write(repo.currenttransaction())
repair.strip(ui, repo, revs, backup)
repomarks = repo._bookmarks
if bookmarks:
tr = None
try:
tr = repo.transaction('strip')
if repo._activebookmark in bookmarks:
bookmarksmod.deactivate(repo)
for bookmark in bookmarks:
del repomarks[bookmark]
repomarks.recordchange(tr)
tr.close()
for bookmark in sorted(bookmarks):
ui.write(_("bookmark '%s' deleted\n") % bookmark)
finally:
release(tr)
finally:
release(lock, wlock)
def concludenode(repo, rev, p1, p2, commitmsg=None, editor=None, extrafn=None,
keepbranches=False):
'''Commit the wd changes with parents p1 and p2. Reuse commit info from rev
but also store useful information in extra.
Return node of committed revision.'''
dsguard = cmdutil.dirstateguard(repo, 'rebase')
try:
repo.setparents(repo[p1].node(), repo[p2].node())
ctx = repo[rev]
if commitmsg is None:
commitmsg = ctx.description()
keepbranch = keepbranches and repo[p1].branch() != ctx.branch()
extra = {'rebase_source': ctx.hex()}
if extrafn:
extrafn(ctx, extra)
backup = repo.ui.backupconfig('phases', 'new-commit')
try:
targetphase = max(ctx.phase(), phases.draft)
repo.ui.setconfig('phases', 'new-commit', targetphase, 'rebase')
if keepbranch:
repo.ui.setconfig('ui', 'allowemptycommit', True)
# Commit might fail if unresolved files exist
newnode = repo.commit(text=commitmsg, user=ctx.user(),
date=ctx.date(), extra=extra, editor=editor)
finally:
repo.ui.restoreconfig(backup)
repo.dirstate.setbranch(repo[newnode].branch())
dsguard.close()
return newnode
finally:
release(dsguard)
def run(self):
state = self.state
repo, ctxnode = state.repo, state.parentctxnode
hg.update(repo, ctxnode)
# release locks so the program can call hg and then relock.
lock.release(state.lock, state.wlock)
try:
ctx = repo[ctxnode]
shell = encoding.environ.get('SHELL', None)
cmd = self.command
if shell and self.repo.ui.config('fbhistedit',
'exec_in_user_shell'):
cmd = "%s -c -i %s" % (shell, quote(cmd))
rc = repo.ui.system(cmd, environ={'HGNODE': ctx.hex()},
cwd=self.cwd, blockedtag='histedit_exec')
except OSError as ose:
raise error.InterventionRequired(
_("Cannot execute command '%s': %s") % (self.command, ose))
finally:
# relock the repository
state.wlock = repo.wlock()
state.lock = repo.lock()
repo.invalidateall()
if rc != 0:
raise error.InterventionRequired(
_("Command '%s' failed with exit status %d") %
(self.command, rc))
m, a, r, d = self.repo.status()[:4]
if m or a or r or d:
self.continuedirty()
return self.continueclean()
def cleanupnode(ui, repo, name, nodes):
"""strip a group of nodes from the repository
The set of node to strip may contains unknown nodes."""
ui.debug('should strip %s nodes %s\n' %
(name, ', '.join([node.short(n) for n in nodes])))
lock = None
try:
lock = repo.lock()
# do not let filtering get in the way of the cleanse
# we should probably get rid of obsolescence marker created during the
# histedit, but we currently do not have such information.
repo = repo.unfiltered()
# Find all nodes that need to be stripped
# (we use %lr instead of %ln to silently ignore unknown items)
nm = repo.changelog.nodemap
nodes = sorted(n for n in nodes if n in nm)
roots = [c.node() for c in repo.set("roots(%ln)", nodes)]
for c in roots:
# We should process node in reverse order to strip tip most first.
# but this trigger a bug in changegroup hook.
# This would reduce bundle overhead
repair.strip(ui, repo, c)
finally:
release(lock)
def censor(ui, repo, path, rev='', tombstone='', **opts):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
return _docensor(ui, repo, path, rev, tombstone, **opts)
finally:
lockmod.release(lock, wlock)
def censor(ui, repo, path, rev='', tombstone='', **opts):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
return _docensor(ui, repo, path, rev, tombstone, **opts)
finally:
lockmod.release(lock, wlock)
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
wlock = repo.wlock()
try:
cmdutil.checkunfinished(repo)
return _docreatecmd(ui, repo, pats, opts)
finally:
lockmod.release(wlock)
def testlock(self):
state = teststate(self, tempfile.mkdtemp(dir=os.getcwd()))
lock = state.makelock()
state.assertacquirecalled(True)
lock.release()
state.assertreleasecalled(True)
state.assertpostreleasecalled(True)
state.assertlockexists(False)
def testlock(self):
state = teststate(self, tempfile.mkdtemp(dir=os.getcwd()))
lock = state.makelock()
state.assertacquirecalled(True)
lock.release()
state.assertreleasecalled(True)
state.assertpostreleasecalled(True)
state.assertlockexists(False)
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
wlock = repo.wlock()
try:
cmdutil.checkunfinished(repo)
return _docreatecmd(ui, repo, pats, opts)
finally:
lockmod.release(wlock)
def transplant(ui, repo, *revs, **opts):
'''transplant changesets from another branch
Selected changesets will be applied on top of the current working
directory with the log of the original changeset. The changesets
are copied and will thus appear twice in the history with different
identities.
Consider using the graft command if everything is inside the same
repository - it will use merges and will usually give a better result.
Use the rebase extension if the changesets are unpublished and you want
to move them instead of copying them.
If --log is specified, log messages will have a comment appended
of the form::
(transplanted from CHANGESETHASH)
You can rewrite the changelog message with the --filter option.
Its argument will be invoked with the current changelog message as
$1 and the patch as $2.
--source/-s specifies another repository to use for selecting changesets,
just as if it temporarily had been pulled.
If --branch/-b is specified, these revisions will be used as
heads when deciding which changesets to transplant, just as if only
these revisions had been pulled.
If --all/-a is specified, all the revisions up to the heads specified
with --branch will be transplanted.
Example:
- transplant all changes up to REV on top of your current revision::
hg transplant --branch REV --all
You can optionally mark selected transplanted changesets as merge
changesets. You will not be prompted to transplant any ancestors
of a merged transplant, and you can merge descendants of them
normally instead of transplanting them.
Merge changesets may be transplanted directly by specifying the
proper parent changeset by calling :hg:`transplant --parent`.
If no merges or revisions are provided, :hg:`transplant` will
start an interactive changeset browser.
If a changeset application fails, you can fix the merge by hand
and then resume where you left off by calling :hg:`transplant
--continue/-c`.
'''
wlock = None
try:
wlock = repo.wlock()
return _dotransplant(ui, repo, *revs, **opts)
finally:
lockmod.release(wlock)
def transplant(ui, repo, *revs, **opts):
'''transplant changesets from another branch
Selected changesets will be applied on top of the current working
directory with the log of the original changeset. The changesets
are copied and will thus appear twice in the history with different
identities.
Consider using the graft command if everything is inside the same
repository - it will use merges and will usually give a better result.
Use the rebase extension if the changesets are unpublished and you want
to move them instead of copying them.
If --log is specified, log messages will have a comment appended
of the form::
(transplanted from CHANGESETHASH)
You can rewrite the changelog message with the --filter option.
Its argument will be invoked with the current changelog message as
$1 and the patch as $2.
--source/-s specifies another repository to use for selecting changesets,
just as if it temporarily had been pulled.
If --branch/-b is specified, these revisions will be used as
heads when deciding which changesets to transplant, just as if only
these revisions had been pulled.
If --all/-a is specified, all the revisions up to the heads specified
with --branch will be transplanted.
Example:
- transplant all changes up to REV on top of your current revision::
hg transplant --branch REV --all
You can optionally mark selected transplanted changesets as merge
changesets. You will not be prompted to transplant any ancestors
of a merged transplant, and you can merge descendants of them
normally instead of transplanting them.
Merge changesets may be transplanted directly by specifying the
proper parent changeset by calling :hg:`transplant --parent`.
If no merges or revisions are provided, :hg:`transplant` will
start an interactive changeset browser.
If a changeset application fails, you can fix the merge by hand
and then resume where you left off by calling :hg:`transplant
--continue/-c`.
'''
wlock = None
try:
wlock = repo.wlock()
return _dotransplant(ui, repo, *revs, **opts)
finally:
lockmod.release(wlock)
def kwcommitctx(self, ctx, error=False):
wlock = lock = None
try:
wlock = self.wlock()
lock = self.lock()
n = super(kwrepo, self).commitctx(ctx, error)
kwt.overwrite(n, True, None)
return n
finally:
release(lock, wlock)
def kwcommitctx(self, ctx, error=False):
wlock = lock = None
try:
wlock = self.wlock()
lock = self.lock()
n = super(kwrepo, self).commitctx(ctx, error)
kwt.overwrite(n, True, None)
return n
finally:
release(lock, wlock)
def cleanupcmd(ui, repo):
"""subcommand that deletes all shelves"""
wlock = None
try:
wlock = repo.wlock()
for (name, _) in repo.vfs.readdir('shelved'):
suffix = name.rsplit('.', 1)[-1]
if suffix in ('hg', 'files', 'patch'):
shelvedfile(repo, name).unlink()
finally:
lockmod.release(wlock)
def cleanupcmd(ui, repo):
"""subcommand that deletes all shelves"""
wlock = None
try:
wlock = repo.wlock()
for (name, _) in repo.vfs.readdir('shelved'):
suffix = name.rsplit('.', 1)[-1]
if suffix in ('hg', 'files', 'patch'):
shelvedfile(repo, name).unlink()
finally:
lockmod.release(wlock)
def _createmarkers(orig, repo, relations, flag=0, date=None, metadata=None):
"""wrap markers create to make sure we de-inhibit target nodes"""
# wrapping transactio to unify the one in each function
lock = tr = None
try:
lock = repo.lock()
tr = repo.transaction('add-obsolescence-marker')
orig(repo, relations, flag, date, metadata)
precs = (r[0].node() for r in relations)
_deinhibitmarkers(repo, precs)
tr.close()
finally:
lockmod.release(tr, lock)
def testinheritcheck(self):
d = tempfile.mkdtemp(dir=os.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 pullrebase(orig, ui, repo, *args, **opts):
'Call rebase after pull if the latter has been invoked with --rebase'
ret = None
if opts.get('rebase'):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
movemarkfrom = repo['.'].node()
revsprepull = len(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
try:
ret = orig(ui, repo, *args, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
# --rev option from pull conflict with rebase own --rev
# dropping it
if 'rev' in opts:
del opts['rev']
# positional argument from pull conflicts with rebase's own
# --source.
if 'source' in opts:
del opts['source']
rebase(ui, repo, **opts)
branch = repo[None].branch()
dest = repo[branch].rev()
if dest != repo['.'].rev():
# there was nothing to rebase we force an update
hg.update(repo, dest)
if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
ui.status(_("updating bookmark %s\n")
% repo._activebookmark)
finally:
release(lock, wlock)
else:
if opts.get('tool'):
raise error.Abort(_('--tool can only be used with --rebase'))
ret = orig(ui, repo, *args, **opts)
return ret
def deletecmd(ui, repo, pats):
"""subcommand that deletes a specific shelve"""
if not pats:
raise util.Abort(_('no shelved changes specified!'))
wlock = repo.wlock()
try:
for name in pats:
for suffix in 'hg patch'.split():
shelvedfile(repo, name, suffix).unlink()
except OSError as err:
if err.errno != errno.ENOENT:
raise
raise util.Abort(_("shelved change '%s' not found") % name)
finally:
lockmod.release(wlock)
def testinheritcheck(self):
d = tempfile.mkdtemp(dir=os.getcwd())
state = teststate(self, d)
def check():
raise error.LockInheritanceContractViolation('check failed')
lock = state.makelock(inheritchecker=check)
state.assertacquirecalled(True)
def tryinherit():
with lock.inherit():
pass
self.assertRaises(error.LockInheritanceContractViolation, tryinherit)
lock.release()
def strip(self, repo, revs, update=True, backup="all", force=None):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if update:
self.checklocalchanges(repo, force=force, refresh=False)
urev = self.qparents(repo, revs[0])
hg.clean(repo, urev)
repo.dirstate.write()
repair.strip(self.ui, repo, revs, backup)
finally:
release(lock, wlock)
def _deletebookmark(repo, repomarks, bookmarks):
wlock = lock = tr = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction('prune')
changes = []
for bookmark in bookmarks:
changes.append((bookmark, None)) # delete the bookmark
repomarks.applychanges(repo, tr, changes)
tr.close()
for bookmark in sorted(bookmarks):
repo.ui.write(_("bookmark '%s' deleted\n") % bookmark)
finally:
lockmod.release(tr, lock, wlock)
def recordbookmarks(repo, bms, name='git_handler'):
"""abstract writing bookmarks for backwards compatibility"""
tr = lock = wlock = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction(name)
if hgutil.safehasattr(bms, 'recordchange'):
# recordchange was added in mercurial 3.2
bms.recordchange(tr)
else:
bms.write()
tr.close()
finally:
lockmod.release(tr, lock, wlock)
def deletecmd(ui, repo, pats):
"""subcommand that deletes a specific shelve"""
if not pats:
raise util.Abort(_('no shelved changes specified!'))
wlock = repo.wlock()
try:
for name in pats:
for suffix in 'hg patch'.split():
shelvedfile(repo, name, suffix).unlink()
except OSError as err:
if err.errno != errno.ENOENT:
raise
raise util.Abort(_("shelved change '%s' not found") % name)
finally:
lockmod.release(wlock)
def recordbookmarks(repo, bms, name='git_handler'):
"""abstract writing bookmarks for backwards compatibility"""
tr = lock = wlock = None
try:
wlock = repo.wlock()
lock = repo.lock()
tr = repo.transaction(name)
if hgutil.safehasattr(bms, 'recordchange'):
# recordchange was added in mercurial 3.2
bms.recordchange(tr)
else:
bms.write()
tr.close()
finally:
lockmod.release(tr, lock, wlock)
def putbookmarks(self, updatedbookmark):
if not len(updatedbookmark):
return
wlock = lock = tr = None
try:
wlock = self.repo.wlock()
lock = self.repo.lock()
tr = self.repo.transaction(b'bookmark')
self.ui.status(_(b"updating bookmarks\n"))
destmarks = self.repo._bookmarks
changes = [(bookmark, bin(updatedbookmark[bookmark]))
for bookmark in updatedbookmark]
destmarks.applychanges(self.repo, tr, changes)
tr.close()
finally:
lockmod.release(lock, wlock, tr)
def putbookmarks(self, updatedbookmark):
if not len(updatedbookmark):
return
wlock = lock = tr = None
try:
wlock = self.repo.wlock()
lock = self.repo.lock()
tr = self.repo.transaction('bookmark')
self.ui.status(_("updating bookmarks\n"))
destmarks = self.repo._bookmarks
for bookmark in updatedbookmark:
destmarks[bookmark] = bin(updatedbookmark[bookmark])
destmarks.recordchange(tr)
tr.close()
finally:
lockmod.release(lock, wlock, tr)
def _kwfwrite(ui, repo, expand, *pats, **opts):
'''Selects files and passes them to kwtemplater.overwrite.'''
if repo.dirstate.parents()[1] != nullid:
raise util.Abort(_('outstanding uncommitted merge'))
kwt = kwtools['templater']
status = _status(ui, repo, kwt, *pats, **opts)
modified, added, removed, deleted = status[:4]
if modified or added or removed or deleted:
raise util.Abort(_('outstanding uncommitted changes'))
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
kwt.overwrite(None, expand, status[6])
finally:
release(lock, wlock)
def _kwfwrite(ui, repo, expand, *pats, **opts):
'''Selects files and passes them to kwtemplater.overwrite.'''
if repo.dirstate.parents()[1] != nullid:
raise util.Abort(_('outstanding uncommitted merge'))
kwt = kwtools['templater']
status = _status(ui, repo, kwt, *pats, **opts)
modified, added, removed, deleted = status[:4]
if modified or added or removed or deleted:
raise util.Abort(_('outstanding uncommitted changes'))
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
kwt.overwrite(None, expand, status[6])
finally:
release(lock, wlock)
def putbookmarks(self, updatedbookmark):
if not len(updatedbookmark):
return
wlock = lock = tr = None
try:
wlock = self.repo.wlock()
lock = self.repo.lock()
tr = self.repo.transaction('bookmark')
self.ui.status(_("updating bookmarks\n"))
destmarks = self.repo._bookmarks
for bookmark in updatedbookmark:
destmarks[bookmark] = nodemod.bin(updatedbookmark[bookmark])
destmarks.recordchange(tr)
tr.close()
finally:
lockmod.release(lock, wlock, tr)
def pullrebase(orig, ui, repo, *args, **opts):
'Call rebase after pull if the latter has been invoked with --rebase'
if opts.get('rebase'):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if opts.get('update'):
del opts['update']
ui.debug('--update and --rebase are not compatible, ignoring '
'the update flag\n')
movemarkfrom = repo['.'].node()
revsprepull = len(repo)
origpostincoming = commands.postincoming
def _dummy(*args, **kwargs):
pass
commands.postincoming = _dummy
try:
orig(ui, repo, *args, **opts)
finally:
commands.postincoming = origpostincoming
revspostpull = len(repo)
if revspostpull > revsprepull:
# --rev option from pull conflict with rebase own --rev
# dropping it
if 'rev' in opts:
del opts['rev']
# positional argument from pull conflicts with rebase's own
# --source.
if 'source' in opts:
del opts['source']
rebase(ui, repo, **opts)
branch = repo[None].branch()
dest = repo[branch].rev()
if dest != repo['.'].rev():
# there was nothing to rebase we force an update
hg.update(repo, dest)
if bookmarks.update(repo, [movemarkfrom], repo['.'].node()):
ui.status(_("updating bookmark %s\n")
% repo._activebookmark)
finally:
release(lock, wlock)
else:
if opts.get('tool'):
raise util.Abort(_('--tool can only be used with --rebase'))
orig(ui, repo, *args, **opts)
def strip(ui, repo, revs, update=True, backup="all", force=None):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if update:
checklocalchanges(repo, force=force)
urev, p2 = repo.changelog.parents(revs[0])
if p2 != nullid and p2 in [x.node for x in repo.mq.applied]:
urev = p2
hg.clean(repo, urev)
repo.dirstate.write()
repair.strip(ui, repo, revs, backup)
finally:
release(lock, wlock)
def sign(ui, repo, *revs, **opts):
"""add a signature for the current or given revision
If no revision is given, the parent of the working directory is used,
or tip if no revision is checked out.
The ``gpg.cmd`` config setting can be used to specify the command
to run. A default key can be specified with ``gpg.key``.
See :hg:`help dates` for a list of formats valid for -d/--date.
"""
wlock = None
try:
wlock = repo.wlock()
return _dosign(ui, repo, *revs, **opts)
finally:
lockmod.release(wlock)
def sign(ui, repo, *revs, **opts):
"""add a signature for the current or given revision
If no revision is given, the parent of the working directory is used,
or tip if no revision is checked out.
The ``gpg.cmd`` config setting can be used to specify the command
to run. A default key can be specified with ``gpg.key``.
See :hg:`help dates` for a list of formats valid for -d/--date.
"""
wlock = None
try:
wlock = repo.wlock()
return _dosign(ui, repo, *revs, **opts)
finally:
lockmod.release(wlock)
def testlockfork(self):
state = teststate(self, tempfile.mkdtemp(dir=os.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 testrecursivelock(self):
state = teststate(self, tempfile.mkdtemp(dir=os.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 strip(ui, repo, revs, update=True, backup="all", force=None):
wlock = lock = None
try:
wlock = repo.wlock()
lock = repo.lock()
if update:
checklocalchanges(repo, force=force)
urev, p2 = repo.changelog.parents(revs[0])
if (util.safehasattr(repo, 'mq') and
p2 != nullid
and p2 in [x.node for x in repo.mq.applied]):
urev = p2
hg.clean(repo, urev)
repo.dirstate.write()
repair.strip(ui, repo, revs, backup)
finally:
release(lock, wlock)
def _update(orig, ui, repo, *args, **kwargs):
"""
When moving to a commit we want to inhibit any obsolete commit affecting
the changeset we are updating to. In other words we don't want any visible
commit to be obsolete.
"""
wlock = None
try:
# Evolve is running a hook on lock release to display a warning message
# if the workind dir's parent is obsolete.
# We take the lock here to make sure that we inhibit the parent before
# that hook get a chance to run.
wlock = repo.wlock()
res = orig(ui, repo, *args, **kwargs)
newhead = repo['.'].node()
_inhibitmarkers(repo, [newhead])
return res
finally:
lockmod.release(wlock)
def dosync(self):
"""pull changes from a remote repository, merge new changes if needed.
This finds all changes from the repository at the specified path
or URL and adds them to the local repository.
If the pulled changes add a new branch head, the head is
automatically merged, and the result of the merge is committed.
Otherwise, the working directory is updated to include the new
changes.
When a merge is needed, the working directory is first updated to
the newly pulled changes. Local changes are then merged into the
pulled changes. To switch the merge order, use --switch-parent.
See :hg:`help dates` for a list of formats valid for -d/--date.
Returns 0 on success.
"""
initialrevision, p2 = self.repo.dirstate.parents()
if p2 != nullid:
raise util.Abort(_('outstanding uncommitted merge'))
wlock = lock = None
try:
wlock = self.repo.wlock()
lock = self.repo.lock()
self.dopull()
self.raiseifuncleanstatus()
self.updateormerge(initialrevision)
self.push()
self.ui.status('sync complete\n')
finally:
release(lock, wlock)
def unshelvecontinue(ui, repo, state, opts):
"""subcommand to continue an in-progress unshelve"""
# We're finishing off a merge. First parent is our original
# parent, second is the temporary "fake" commit we're unshelving.
wlock = repo.wlock()
lock = None
try:
checkparents(repo, state)
ms = merge.mergestate(repo)
if [f for f in ms if ms[f] == 'u']:
raise util.Abort(
_("unresolved conflicts, can't continue"),
hint=_("see 'hg resolve', then 'hg unshelve --continue'"))
lock = repo.lock()
util.rename(repo.join('unshelverebasestate'),
repo.join('rebasestate'))
try:
rebase.rebase(ui, repo, **{
'continue' : True
})
except Exception:
util.rename(repo.join('rebasestate'),
repo.join('unshelverebasestate'))
raise
shelvectx = repo['tip']
if not shelvectx in state.pendingctx.children():
# rebase was a no-op, so it produced no child commit
shelvectx = state.pendingctx
else:
# only strip the shelvectx if the rebase produced it
state.stripnodes.append(shelvectx.node())
mergefiles(ui, repo, state.wctx, shelvectx)
repair.strip(ui, repo, state.stripnodes, backup=False, topic='shelve')
shelvedstate.clear(repo)
unshelvecleanup(ui, repo, state.name, opts)
ui.status(_("unshelve of '%s' complete\n") % state.name)
finally:
lockmod.release(lock, wlock)
