mirror of
https://github.com/facebook/sapling.git
synced 2024-10-11 17:27:53 +03:00
331b10b445
Summary: Tracking remote bookmarks that was pulled with ``` hg pull -B <remote name> ``` All these remotenames, if they exist, will be stored in `.hg/selectivepullusedbookmarks` file. It will allow us to estimate how much memory do we need to keep remote names in sync state in Commit Cloud and automatically mark collected remote bookmarks as "interesting" when the selective pull will be enabled. Reviewed By: markbt Differential Revision: D14912903 fbshipit-source-id: 3001869175553327c0840e2cfb829724dfd82893
2008 lines
66 KiB
Python
2008 lines
66 KiB
Python
# Copyright 2010 Mercurial Contributors
|
|
#
|
|
# This software may be used and distributed according to the terms of the
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
"""mercurial extension for improving client/server workflows
|
|
|
|
The remotenames extension provides additional information to clients that is
|
|
particularly useful when pushing and pulling to peer repositories.
|
|
|
|
Before diving in to using remotebookmarks, we suggest you read the included
|
|
README file, which explains the changes to expect, the configuration knobs
|
|
available (note: almost everything is configurable), and gives examples of
|
|
how to set up the configuration options in useful ways.
|
|
|
|
This extension is the work of Sean Farley forked from Augie Fackler's seminal
|
|
remotebranches extension. Ryan McElroy of Facebook also contributed.
|
|
"""
|
|
|
|
import errno
|
|
import os
|
|
import re
|
|
import shutil
|
|
import sys
|
|
import UserDict
|
|
|
|
from edenscm.mercurial import (
|
|
bookmarks,
|
|
commands,
|
|
discovery,
|
|
encoding,
|
|
error,
|
|
exchange,
|
|
extensions,
|
|
hg,
|
|
localrepo,
|
|
lock as lockmod,
|
|
mutation,
|
|
namespaces,
|
|
obsutil,
|
|
registrar,
|
|
repair,
|
|
repoview,
|
|
revset,
|
|
scmutil,
|
|
setdiscovery,
|
|
smartset,
|
|
templatekw,
|
|
ui as uimod,
|
|
url,
|
|
util,
|
|
vfs as vfsmod,
|
|
)
|
|
from edenscm.mercurial.i18n import _
|
|
from edenscm.mercurial.node import bin, hex, nullid, short
|
|
|
|
from . import schemes
|
|
from .convert import hg as converthg
|
|
|
|
|
|
configtable = {}
|
|
configitem = registrar.configitem(configtable)
|
|
|
|
configitem("remotenames", "alias.default", default=False)
|
|
configitem("remotenames", "allownonfastforward", default=False)
|
|
configitem("remotenames", "bookmarks", default=True)
|
|
configitem("remotenames", "calculatedistance", default=True)
|
|
configitem("remotenames", "disallowedbookmarks", default=[])
|
|
configitem("remotenames", "disallowedhint", default=None)
|
|
configitem("remotenames", "disallowedto", default=None)
|
|
configitem("remotenames", "fastheaddiscovery", default=False)
|
|
configitem("remotenames", "forcecompat", default=False)
|
|
configitem("remotenames", "forceto", default=False)
|
|
configitem("remotenames", "hoist", default="default")
|
|
configitem("remotenames", "precachecurrent", default=True)
|
|
configitem("remotenames", "precachedistance", default=True)
|
|
configitem("remotenames", "pushanonheads", default=False)
|
|
configitem("remotenames", "pushrev", default=None)
|
|
configitem("remotenames", "resolvenodes", default=True)
|
|
configitem("remotenames", "selectivepull", default=False)
|
|
configitem("remotenames", "selectivepulldefault", default=[])
|
|
configitem("remotenames", "selectivepullaccessedbookmarks", default=False)
|
|
configitem("remotenames", "syncbookmarks", default=False)
|
|
configitem("remotenames", "tracking", default=True)
|
|
configitem("remotenames", "transitionbookmarks", default=[])
|
|
configitem("remotenames", "transitionmessage", default=None)
|
|
configitem("remotenames", "upstream", default=[])
|
|
|
|
namespacepredicate = registrar.namespacepredicate()
|
|
templatekeyword = registrar.templatekeyword()
|
|
revsetpredicate = registrar.revsetpredicate()
|
|
|
|
# namespace to use when recording an hg journal entry
|
|
journalremotebookmarktype = "remotebookmark"
|
|
# name of the file that is used to mark that transition to selectivepull has
|
|
# happened
|
|
_selectivepullenabledfile = "selectivepullenabled"
|
|
_selectivepullaccessedbookmarks = "selectivepullaccessedbookmarks"
|
|
|
|
|
|
def exbookcalcupdate(orig, ui, repo, checkout):
|
|
"""Return a tuple (targetrev, movemarkfrom) indicating the rev to
|
|
check out and where to move the active bookmark from, if needed."""
|
|
movemarkfrom = None
|
|
if checkout is None:
|
|
activemark = repo._activebookmark
|
|
if not activemark:
|
|
# if no active bookmark then keep using the old code path for now
|
|
return orig(ui, repo, checkout)
|
|
if bookmarks.isactivewdirparent(repo):
|
|
movemarkfrom = repo["."].node()
|
|
ui.status(_("updating to active bookmark %s\n") % activemark)
|
|
checkout = activemark
|
|
return (checkout, movemarkfrom)
|
|
|
|
|
|
def expush(orig, repo, remote, *args, **kwargs):
|
|
res = orig(repo, remote, *args, **kwargs)
|
|
pullremotenames(repo, remote, remote.listkeys("bookmarks"))
|
|
return res
|
|
|
|
|
|
def expushop(
|
|
orig,
|
|
pushop,
|
|
repo,
|
|
remote,
|
|
force=False,
|
|
revs=None,
|
|
bookmarks=(),
|
|
pushvars=None,
|
|
**kwargs
|
|
):
|
|
orig(pushop, repo, remote, force, revs, bookmarks, pushvars)
|
|
|
|
for flag in ["to", "delete", "create", "allowanon", "nonforwardmove"]:
|
|
setattr(pushop, flag, kwargs.pop(flag, None))
|
|
|
|
|
|
def _isselectivepull(ui):
|
|
return ui.configbool("remotenames", "selectivepull")
|
|
|
|
|
|
def _trackaccessedbookmarks(ui):
|
|
return ui.configbool("remotenames", "selectivepullaccessedbookmarks")
|
|
|
|
|
|
def _getselectivepulldefaultbookmarks(ui):
|
|
default_books = ui.configlist("remotenames", "selectivepulldefault")
|
|
if not default_books:
|
|
raise error.Abort(_("no default bookmarks specified for selectivepull"))
|
|
return default_books
|
|
|
|
|
|
def _listremotebookmarks(remote, bookmarks):
|
|
remotebookmarks = remote.listkeys("bookmarks")
|
|
result = {}
|
|
for book in bookmarks:
|
|
if book in remotebookmarks:
|
|
result[book] = remotebookmarks[book]
|
|
return result
|
|
|
|
|
|
def _trypullremotebookmark(mayberemotebookmark, repo, ui):
|
|
ui.warn(
|
|
_("`%s` not found: assuming it is a remote bookmark " "and trying to pull it\n")
|
|
% mayberemotebookmark
|
|
)
|
|
sourcerenames = dict((v, k) for k, v in _getrenames(ui).iteritems())
|
|
remote, bookmarkname = splitremotename(mayberemotebookmark)
|
|
paths = dict((path, url) for path, url in ui.configitems("paths"))
|
|
if remote in sourcerenames:
|
|
source = sourcerenames[remote]
|
|
elif remote in paths:
|
|
source = remote
|
|
else:
|
|
source = "default"
|
|
bookmarkname = mayberemotebookmark
|
|
|
|
try:
|
|
commands.pull(ui, repo, source=source, bookmark=[bookmarkname])
|
|
except Exception:
|
|
ui.warn(_("pull failed: %s\n") % sys.exc_info()[1])
|
|
else:
|
|
ui.warn(_("`%s` found remotely\n") % mayberemotebookmark)
|
|
|
|
|
|
def updateaccessedbookmarks(repo, remote, bookmarks):
|
|
if not _trackaccessedbookmarks(repo.ui):
|
|
return
|
|
|
|
vfs = repo.sharedvfs
|
|
remotepath = activepath(repo.ui, remote)
|
|
|
|
if vfs.exists(_selectivepullaccessedbookmarks):
|
|
knownbooks = set(_readremotenamesfrom(vfs, _selectivepullaccessedbookmarks))
|
|
else:
|
|
knownbooks = set()
|
|
|
|
with repo.wlock(), vfs(_selectivepullaccessedbookmarks, "w", atomictemp=True) as f:
|
|
newbookmarks = {}
|
|
for node, nametype, oldremote, rname in knownbooks:
|
|
if nametype != "bookmarks":
|
|
continue
|
|
|
|
if oldremote != remotepath:
|
|
_writesingleremotename(f, oldremote, nametype, rname, node)
|
|
else:
|
|
newbookmarks[rname] = node
|
|
|
|
nodemap = repo.unfiltered().changelog.nodemap
|
|
for rname, node in bookmarks.iteritems():
|
|
# if the node is known locally, update the old value or add new
|
|
if bin(node) in nodemap:
|
|
newbookmarks[rname] = node
|
|
|
|
for rname, node in newbookmarks.iteritems():
|
|
_writesingleremotename(f, remotepath, "bookmarks", rname, node)
|
|
|
|
|
|
def expull(orig, repo, remote, *args, **kwargs):
|
|
if _isselectivepull(repo.ui):
|
|
# if selectivepull is enabled then we don't save all of the remote
|
|
# bookmarks in remotenames file. Instead we save only bookmarks that
|
|
# are "interesting" to a user. Moreover, "hg pull" without parameters
|
|
# pulls only "interesting" bookmarks. There is a config option to
|
|
# set default "interesting" bookmarks
|
|
# (see _getselectivepulldefaultbookmarks).
|
|
# Then bookmark is considered "interesting" if user did
|
|
# "hg update REMOTE_BOOK_NAME" or "hg pull -B REMOTE_BOOK_NAME".
|
|
# Selectivepull is helpful when server has too many remote bookmarks
|
|
# because it may slow down clients.
|
|
path = activepath(repo.ui, remote)
|
|
remotebookmarkslist = []
|
|
if repo.localvfs.exists(_selectivepullenabledfile):
|
|
# 'selectivepullenabled' file is used for transition between
|
|
# non-selectivepull repo to selectivepull repo. It is used as
|
|
# indicator to whether "non-interesting" bookmarks were removed
|
|
# from remotenames file.
|
|
remotebookmarkslist = list(readbookmarknames(repo, path))
|
|
if not remotebookmarkslist:
|
|
remotebookmarkslist = _getselectivepulldefaultbookmarks(repo.ui)
|
|
|
|
if kwargs.get("bookmarks"):
|
|
remotebookmarkslist.extend(kwargs["bookmarks"])
|
|
bookmarks = _listremotebookmarks(remote, remotebookmarkslist)
|
|
else:
|
|
bookmarks = _listremotebookmarks(remote, remotebookmarkslist)
|
|
heads = kwargs.get("heads") or []
|
|
# heads may be passed as positional args
|
|
if len(args) > 0:
|
|
if args[0]:
|
|
heads = args[0]
|
|
args = args[1:]
|
|
for node in bookmarks.values():
|
|
heads.append(bin(node))
|
|
kwargs["bookmarks"] = bookmarks.keys()
|
|
kwargs["heads"] = heads
|
|
else:
|
|
bookmarks = remote.listkeys("bookmarks")
|
|
|
|
with extensions.wrappedfunction(setdiscovery, "findcommonheads", exfindcommonheads):
|
|
res = orig(repo, remote, *args, **kwargs)
|
|
pullremotenames(repo, remote, bookmarks)
|
|
if repo.localvfs.exists(_selectivepullenabledfile):
|
|
if not _isselectivepull(repo.ui):
|
|
with repo.wlock():
|
|
repo.localvfs.unlink(_selectivepullenabledfile)
|
|
else:
|
|
if _isselectivepull(repo.ui):
|
|
with repo.wlock(), repo.localvfs(_selectivepullenabledfile, "w") as f:
|
|
f.write("enabled") # content doesn't matter
|
|
|
|
if _trackaccessedbookmarks(repo.ui):
|
|
if "bookmarks" in kwargs:
|
|
accessedbookmarks = _listremotebookmarks(remote, kwargs["bookmarks"])
|
|
updateaccessedbookmarks(repo, remote, accessedbookmarks)
|
|
|
|
return res
|
|
|
|
|
|
def exfindcommonheads(orig, ui, local, remote, **kwargs):
|
|
"""Return a tuple (common, anyincoming, remoteheads) used to identify
|
|
missing nodes from or in remote.
|
|
"""
|
|
# The normal findcommonheads implementation tries to find the exact boundary
|
|
# between what the client has and what the server has. With remotenames, we
|
|
# have pretty good knowledge about what local commits already exist on the
|
|
# server, so we can short circuit all the discovery logic by just assuming
|
|
# the current remotenames are representative of what's on the server. In the
|
|
# worst case the data might be slightly out of sync and the server sends us
|
|
# more data than necessary, but this should be rare.
|
|
if not ui.configbool("remotenames", "fastheaddiscovery"):
|
|
return orig(ui, local, remote, **kwargs)
|
|
|
|
cl = local.changelog
|
|
|
|
remotepath = activepath(local.ui, remote)
|
|
remotenodes = []
|
|
for node, nametype, remotename, rname in readremotenames(local):
|
|
# Note: It's important that this excludes hidden commits (by doing
|
|
# node in local), since the callers assume all nodes in common are
|
|
# visible.
|
|
node = bin(node)
|
|
if remotename == remotepath and node in local:
|
|
remotenodes.append(node)
|
|
|
|
# If we have no remotenames, fallback to normal discovery.
|
|
if not remotenodes:
|
|
return orig(ui, local, remote, **kwargs)
|
|
|
|
remotenodes = set(remotenodes)
|
|
|
|
# Check which remote nodes still exist on the server
|
|
ui.status(_("searching for changes\n"))
|
|
batch = remote.iterbatch()
|
|
batch.heads()
|
|
batch.known(remotenodes)
|
|
batch.submit()
|
|
srvheadhashes, yesno = batch.results()
|
|
common = list(n for i, n in enumerate(remotenodes) if yesno[i])
|
|
|
|
# If we don't know of any server commits, fall back to legacy discovery
|
|
if not common:
|
|
# If this path is hit, it will print "searching for changes" twice,
|
|
# which is weird. This should be very rare though, since it only happens
|
|
# if the client has remote names, but none of those names exist on the
|
|
# server (i.e. the server has been completely replaced, or stripped).
|
|
ui.status(
|
|
_(
|
|
"server has changed since last pull - falling back to the "
|
|
"default search strategy\n"
|
|
)
|
|
)
|
|
return orig(ui, local, remote, **kwargs)
|
|
|
|
if cl.tip() == nullid:
|
|
if srvheadhashes != [nullid]:
|
|
return [nullid], True, srvheadhashes
|
|
return ([nullid], False, [])
|
|
|
|
# early exit if we know all the specified remote heads already
|
|
clrev = cl.rev
|
|
clcontains = cl.__contains__
|
|
srvheads = list(clrev(n) for n in srvheadhashes if clcontains(n))
|
|
if len(srvheads) == len(srvheadhashes):
|
|
ui.debug("all remote heads known locally\n")
|
|
return (srvheadhashes, False, srvheadhashes)
|
|
|
|
return (common, True, srvheadhashes)
|
|
|
|
|
|
def pullremotenames(repo, remote, bookmarks):
|
|
# when working between multiple local repos which do not all have
|
|
# remotenames enabled, do this work only for those with it enabled
|
|
if not util.safehasattr(repo, "_remotenames"):
|
|
return
|
|
|
|
path = activepath(repo.ui, remote)
|
|
if path:
|
|
# on a push, we don't want to keep obsolete heads since
|
|
# they won't show up as heads on the next pull, so we
|
|
# remove them here otherwise we would require the user
|
|
# to issue a pull to refresh .hg/remotenames
|
|
repo = repo.unfiltered()
|
|
saveremotenames(repo, path, bookmarks)
|
|
|
|
precachedistance(repo)
|
|
|
|
|
|
def blockerhook(orig, repo, *args, **kwargs):
|
|
blockers = orig(repo)
|
|
|
|
unblock = util.safehasattr(repo, "_unblockhiddenremotenames")
|
|
if not unblock:
|
|
return blockers
|
|
|
|
# add remotenames to blockers by looping over all names in our own cache
|
|
cl = repo.changelog
|
|
for remotename in repo._remotenames.keys():
|
|
rname = "remote" + remotename
|
|
try:
|
|
ns = repo.names[rname]
|
|
except KeyError:
|
|
continue
|
|
for name in ns.listnames(repo):
|
|
blockers.update(cl.rev(node) for node in ns.nodes(repo, name))
|
|
|
|
return blockers
|
|
|
|
|
|
def exupdatefromremote(orig, ui, repo, remotemarks, path, trfunc, explicit=()):
|
|
if ui.configbool("remotenames", "syncbookmarks"):
|
|
return orig(ui, repo, remotemarks, path, trfunc, explicit)
|
|
|
|
ui.debug("remotenames: skipped syncing local bookmarks\n")
|
|
|
|
|
|
def exclone(orig, ui, *args, **opts):
|
|
"""
|
|
We may not want local bookmarks on clone... but we always want remotenames!
|
|
"""
|
|
srcpeer, dstpeer = orig(ui, *args, **opts)
|
|
|
|
pullremotenames(dstpeer.local(), srcpeer, srcpeer.listkeys("bookmarks"))
|
|
|
|
if not ui.configbool("remotenames", "syncbookmarks"):
|
|
ui.debug("remotenames: removing cloned bookmarks\n")
|
|
repo = dstpeer.local()
|
|
wlock = repo.wlock()
|
|
try:
|
|
try:
|
|
vfs = repo.sharedvfs
|
|
vfs.unlink("bookmarks")
|
|
except OSError as inst:
|
|
if inst.errno != errno.ENOENT:
|
|
raise
|
|
finally:
|
|
wlock.release()
|
|
|
|
return (srcpeer, dstpeer)
|
|
|
|
|
|
def excommit(orig, repo, *args, **opts):
|
|
res = orig(repo, *args, **opts)
|
|
precachedistance(repo)
|
|
return res
|
|
|
|
|
|
def exupdate(orig, repo, *args, **opts):
|
|
res = orig(repo, *args, **opts)
|
|
precachedistance(repo)
|
|
return res
|
|
|
|
|
|
def exactivate(orig, repo, mark):
|
|
res = orig(repo, mark)
|
|
precachedistance(repo)
|
|
return res
|
|
|
|
|
|
def exconvertbookmarks(orig, source):
|
|
"""Make hg convert map remote bookmarks in the source to normal bookmarks in
|
|
the target.
|
|
|
|
This is useful for instance if you need to convert a repo from server A to
|
|
server B. You clone the repo from A (now you have remote bookmarks), convert
|
|
to a local version of B, and push those bookmarks to server B.
|
|
"""
|
|
bookmarks = orig(source)
|
|
|
|
repo = source.repo
|
|
n = "remotebookmarks"
|
|
if n in repo.names:
|
|
ns = repo.names[n]
|
|
for name in ns.listnames(repo):
|
|
nodes = ns.nodes(repo, name)
|
|
if nodes:
|
|
bookmarks.setdefault(name, hex(nodes[0]))
|
|
|
|
return bookmarks
|
|
|
|
|
|
def updatecmd(orig, ui, repo, node=None, rev=None, **kwargs):
|
|
if rev and node:
|
|
raise error.Abort(_("please specify just one revision"))
|
|
|
|
if _isselectivepull(repo.ui) and not kwargs.get("date"):
|
|
# Make sure that rev or node is present in the repo.
|
|
# Otherwise pull it from remote
|
|
try:
|
|
scmutil.revsingle(repo, rev or node)
|
|
except (error.RepoLookupError, error.Abort):
|
|
_trypullremotebookmark(rev or node, repo, ui)
|
|
|
|
book = kwargs.get("bookmark")
|
|
if book:
|
|
del kwargs["bookmark"]
|
|
if book in repo._bookmarks:
|
|
raise error.Abort("bookmark '%s' already exists" % book)
|
|
ret = orig(ui, repo, node=node, rev=rev, **kwargs)
|
|
commands.bookmark(ui, repo, book)
|
|
|
|
if not _tracking(ui):
|
|
return ret
|
|
|
|
oldtracking = _readtracking(repo)
|
|
tracking = dict(oldtracking)
|
|
|
|
if node:
|
|
tracking[book] = node
|
|
elif rev:
|
|
tracking[book] = rev
|
|
|
|
if tracking != oldtracking:
|
|
_writetracking(repo, tracking)
|
|
# update the cache
|
|
precachedistance(repo)
|
|
return ret
|
|
if "bookmark" in kwargs:
|
|
del kwargs["bookmark"]
|
|
return orig(ui, repo, node=node, rev=rev, **kwargs)
|
|
|
|
|
|
class lazyremotenamedict(UserDict.DictMixin):
|
|
"""Read-only dict-like Class to lazily resolve remotename entries
|
|
|
|
We are doing that because remotenames startup was slow.
|
|
We lazily read the remotenames file once to figure out the potential entries
|
|
and store them in self.potentialentries. Then when asked to resolve an
|
|
entry, if it is not in self.potentialentries, then it isn't there, if it
|
|
is in self.potentialentries we resolve it and store the result in
|
|
self.cache. We cannot be lazy is when asked all the entries (keys).
|
|
"""
|
|
|
|
def __init__(self, kind, repo):
|
|
self.cache = {}
|
|
self.potentialentries = {}
|
|
assert kind == "bookmarks" # only support bookmarks
|
|
self._kind = kind
|
|
self._repo = repo
|
|
self.loaded = False
|
|
|
|
def _load(self):
|
|
"""Read the remotenames file, store entries matching selected kind"""
|
|
self.loaded = True
|
|
repo = self._repo
|
|
alias_default = repo.ui.configbool("remotenames", "alias.default")
|
|
for node, nametype, remote, rname in readremotenames(repo):
|
|
if nametype != self._kind:
|
|
continue
|
|
# handle alias_default here
|
|
if remote != "default" and rname == "default" and alias_default:
|
|
name = remote
|
|
else:
|
|
name = joinremotename(remote, rname)
|
|
self.potentialentries[name] = (node, nametype, remote, rname)
|
|
|
|
def _resolvedata(self, potentialentry):
|
|
"""Check that the node for potentialentry exists and return it"""
|
|
if not potentialentry in self.potentialentries:
|
|
return None
|
|
node, nametype, remote, rname = self.potentialentries[potentialentry]
|
|
repo = self._repo
|
|
binnode = bin(node)
|
|
# if the node doesn't exist, skip it
|
|
try:
|
|
repo.changelog.rev(binnode)
|
|
except LookupError:
|
|
return None
|
|
# Skip closed branches
|
|
if nametype == "branches" and repo[binnode].closesbranch():
|
|
return None
|
|
return [binnode]
|
|
|
|
def __getitem__(self, key):
|
|
if not self.loaded:
|
|
self._load()
|
|
val = self._fetchandcache(key)
|
|
if val is not None:
|
|
return val
|
|
else:
|
|
raise KeyError()
|
|
|
|
def _fetchandcache(self, key):
|
|
if key in self.cache:
|
|
return self.cache[key]
|
|
val = self._resolvedata(key)
|
|
if val is not None:
|
|
self.cache[key] = val
|
|
return val
|
|
else:
|
|
return None
|
|
|
|
def keys(self, resolvenodes=None):
|
|
"""Get a list of bookmark names
|
|
|
|
`resolvenodes` allows callee to ask whether nodes to which these keys
|
|
point should be resolved in a revlog (to safeguard against a key
|
|
pointing to a non-existent node). If this kwarg:
|
|
- is None: remotenames.resolvenodes config value is read,
|
|
defaulting to True, as the behavior before this fix
|
|
- is not None: the bool value of resolvenodes is used"""
|
|
if resolvenodes is None:
|
|
resolvenodes = self._repo.ui.configbool("remotenames", "resolvenodes")
|
|
if not self.loaded:
|
|
self._load()
|
|
if resolvenodes:
|
|
for u in self.potentialentries.keys():
|
|
self._fetchandcache(u)
|
|
return self.cache.keys()
|
|
return self.potentialentries.keys()
|
|
|
|
def iteritems(self, resolvenodes=None):
|
|
"""Iterate over (name, node) tuples
|
|
|
|
`resolvenodes` has the same meaning as in `keys()` method"""
|
|
if not self.loaded:
|
|
self._load()
|
|
if resolvenodes is None:
|
|
resolvenodes = self._repo.ui.configbool("remotenames", "resolvenodes")
|
|
for k, vtup in self.potentialentries.iteritems():
|
|
if resolvenodes:
|
|
self._fetchandcache(k)
|
|
yield (k, [bin(vtup[0])])
|
|
|
|
|
|
class remotenames(dict):
|
|
"""This class encapsulates all the remotenames state. It also contains
|
|
methods to access that state in convenient ways. Remotenames are lazy
|
|
loaded. Whenever client code needs to ensure the freshest copy of
|
|
remotenames, use the `clearnames` method to force an eventual load.
|
|
"""
|
|
|
|
def __init__(self, repo, *args):
|
|
dict.__init__(self, *args)
|
|
self._repo = repo
|
|
self.clearnames()
|
|
|
|
def clearnames(self):
|
|
"""Clear all remote names state"""
|
|
self["bookmarks"] = lazyremotenamedict("bookmarks", self._repo)
|
|
self._invalidatecache()
|
|
self._loadednames = False
|
|
|
|
def _invalidatecache(self):
|
|
self._node2marks = None
|
|
self._hoist2nodes = None
|
|
self._node2hoists = None
|
|
self._node2branch = None
|
|
|
|
def mark2nodes(self):
|
|
return self["bookmarks"]
|
|
|
|
def node2marks(self):
|
|
if not self._node2marks:
|
|
mark2nodes = self.mark2nodes()
|
|
self._node2marks = {}
|
|
for name, node in mark2nodes.iteritems():
|
|
self._node2marks.setdefault(node[0], []).append(name)
|
|
return self._node2marks
|
|
|
|
def hoist2nodes(self, hoist):
|
|
if not self._hoist2nodes:
|
|
mark2nodes = self.mark2nodes()
|
|
self._hoist2nodes = {}
|
|
hoist += "/"
|
|
for name, node in mark2nodes.iteritems():
|
|
if name.startswith(hoist):
|
|
name = name[len(hoist) :]
|
|
self._hoist2nodes[name] = node
|
|
return self._hoist2nodes
|
|
|
|
def node2hoists(self, hoist):
|
|
if not self._node2hoists:
|
|
mark2nodes = self.mark2nodes()
|
|
self._node2hoists = {}
|
|
hoist += "/"
|
|
for name, node in mark2nodes.iteritems():
|
|
if name.startswith(hoist):
|
|
name = name[len(hoist) :]
|
|
self._node2hoists.setdefault(node[0], []).append(name)
|
|
return self._node2hoists
|
|
|
|
def branch2nodes(self):
|
|
return self["branches"]
|
|
|
|
def node2branch(self):
|
|
if not self._node2branch:
|
|
branch2nodes = self.branch2nodes()
|
|
self._node2branch = {}
|
|
for name, nodes in branch2nodes.iteritems():
|
|
for node in nodes:
|
|
self._node2branch[node] = [name]
|
|
return self._node2branch
|
|
|
|
|
|
@namespacepredicate("remotebookmarks", priority=55)
|
|
def remotebookmarks(repo):
|
|
if repo.ui.configbool("remotenames", "bookmarks"):
|
|
return namespaces.namespace(
|
|
templatename="remotebookmarks",
|
|
logname="bookmark",
|
|
colorname="remotebookmark",
|
|
listnames=lambda repo: repo._remotenames.mark2nodes().keys(),
|
|
namemap=lambda repo, name: repo._remotenames.mark2nodes().get(name, []),
|
|
nodemap=lambda repo, node: repo._remotenames.node2marks().get(node, []),
|
|
)
|
|
else:
|
|
return None
|
|
|
|
|
|
@namespacepredicate("hoistednames", priority=60)
|
|
def hoistednames(repo):
|
|
hoist = repo.ui.config("remotenames", "hoist")
|
|
# hoisting only works if there are remote bookmarks
|
|
if repo.ui.configbool("remotenames", "bookmarks") and hoist:
|
|
return namespaces.namespace(
|
|
templatename="hoistednames",
|
|
logname="hoistedname",
|
|
colorname="hoistedname",
|
|
listnames=lambda repo: repo._remotenames.hoist2nodes(hoist).keys(),
|
|
namemap=lambda repo, name: repo._remotenames.hoist2nodes(hoist).get(
|
|
name, []
|
|
),
|
|
nodemap=lambda repo, node: repo._remotenames.node2hoists(hoist).get(
|
|
node, []
|
|
),
|
|
)
|
|
else:
|
|
return None
|
|
|
|
|
|
def reposetup(ui, repo):
|
|
if not repo.local():
|
|
return
|
|
|
|
repo._remotenames = remotenames(repo)
|
|
|
|
|
|
def _tracking(ui):
|
|
# omg default true
|
|
return ui.configbool("remotenames", "tracking")
|
|
|
|
|
|
def _branchesenabled(ui):
|
|
return False
|
|
|
|
|
|
def exrebasecmd(orig, ui, repo, *pats, **opts):
|
|
dest = opts["dest"]
|
|
source = opts["source"]
|
|
revs = opts["rev"]
|
|
base = opts["base"]
|
|
cont = opts["continue"]
|
|
abort = opts["abort"]
|
|
|
|
current = repo._activebookmark
|
|
|
|
if not (cont or abort or dest or source or revs or base) and current:
|
|
tracking = _readtracking(repo)
|
|
if current in tracking:
|
|
opts["dest"] = tracking[current]
|
|
|
|
ret = orig(ui, repo, *pats, **opts)
|
|
precachedistance(repo)
|
|
return ret
|
|
|
|
|
|
def exstrip(orig, ui, repo, *args, **opts):
|
|
ret = orig(ui, repo, *args, **opts)
|
|
precachedistance(repo)
|
|
return ret
|
|
|
|
|
|
def exhistedit(orig, ui, repo, *args, **opts):
|
|
ret = orig(ui, repo, *args, **opts)
|
|
precachedistance(repo)
|
|
return ret
|
|
|
|
|
|
def expaths(orig, ui, repo, *args, **opts):
|
|
"""allow adding and removing remote paths
|
|
|
|
This is very hacky and only exists as an experimentation.
|
|
|
|
"""
|
|
delete = opts.get("delete")
|
|
add = opts.get("add")
|
|
if delete:
|
|
# find the first section and remote path that matches, and delete that
|
|
foundpaths = False
|
|
if not repo.localvfs.isfile("hgrc"):
|
|
raise error.Abort(_("could not find hgrc file"))
|
|
oldhgrc = repo.localvfs.read("hgrc").splitlines(True)
|
|
f = repo.localvfs("hgrc", "w", atomictemp=True)
|
|
for line in oldhgrc:
|
|
if "[paths]" in line:
|
|
foundpaths = True
|
|
if not (foundpaths and line.strip().startswith(delete)):
|
|
f.write(line)
|
|
f.close()
|
|
saveremotenames(repo, delete)
|
|
precachedistance(repo)
|
|
return
|
|
|
|
if add:
|
|
# find the first section that matches, then look for previous value; if
|
|
# not found add a new entry
|
|
foundpaths = False
|
|
oldhgrc = []
|
|
if repo.localvfs.isfile("hgrc"):
|
|
oldhgrc = repo.localvfs.read("hgrc").splitlines(True)
|
|
f = repo.localvfs("hgrc", "w", atomictemp=True)
|
|
done = False
|
|
for line in oldhgrc:
|
|
if "[paths]" in line:
|
|
foundpaths = True
|
|
if foundpaths and line.strip().startswith(add):
|
|
done = True
|
|
line = "%s = %s\n" % (add, args[0])
|
|
f.write(line)
|
|
|
|
# did we not find an existing path?
|
|
if not done:
|
|
done = True
|
|
f.write("[paths]\n")
|
|
f.write("%s = %s\n" % (add, args[0]))
|
|
|
|
f.close()
|
|
return
|
|
|
|
return orig(ui, repo, *args)
|
|
|
|
|
|
def exnowarnheads(orig, pushop):
|
|
heads = orig(pushop)
|
|
if pushop.to:
|
|
repo = pushop.repo.unfiltered()
|
|
rev = pushop.revs[0]
|
|
heads.add(repo[rev].node())
|
|
return heads
|
|
|
|
|
|
def exstripbmrevset(orig, repo, mark):
|
|
return orig(repo, mark) - repo.revs(
|
|
"ancestors(remotenames() and " "not bookmark(%s))", mark
|
|
)
|
|
|
|
|
|
def extsetup(ui):
|
|
extensions.wrapfunction(bookmarks, "calculateupdate", exbookcalcupdate)
|
|
extensions.wrapfunction(exchange.pushoperation, "__init__", expushop)
|
|
extensions.wrapfunction(exchange, "push", expush)
|
|
extensions.wrapfunction(exchange, "pull", expull)
|
|
# _getdynamicblockers was renamed to pinnedrevs in 4.3
|
|
blockername = "pinnedrevs"
|
|
if not util.safehasattr(repoview, blockername):
|
|
# but there was a temporary name of revealedrevs, remove after 4.3
|
|
blockername = "revealedrevs"
|
|
if not util.safehasattr(repoview, blockername):
|
|
blockername = "_getdynamicblockers"
|
|
extensions.wrapfunction(repoview, blockername, blockerhook)
|
|
extensions.wrapfunction(bookmarks, "updatefromremote", exupdatefromremote)
|
|
extensions.wrapfunction(repair, "stripbmrevset", exstripbmrevset)
|
|
if util.safehasattr(bookmarks, "activate"):
|
|
extensions.wrapfunction(bookmarks, "activate", exactivate)
|
|
else:
|
|
extensions.wrapfunction(bookmarks, "setcurrent", exactivate)
|
|
extensions.wrapfunction(hg, "clone", exclone)
|
|
extensions.wrapfunction(hg, "updaterepo", exupdate)
|
|
extensions.wrapfunction(localrepo.localrepository, "commit", excommit)
|
|
|
|
extensions.wrapfunction(
|
|
converthg.mercurial_source, "getbookmarks", exconvertbookmarks
|
|
)
|
|
|
|
if util.safehasattr(discovery, "_nowarnheads"):
|
|
extensions.wrapfunction(discovery, "_nowarnheads", exnowarnheads)
|
|
|
|
if _tracking(ui):
|
|
try:
|
|
rebase = extensions.find("rebase")
|
|
extensions.wrapcommand(rebase.cmdtable, "rebase", exrebasecmd)
|
|
except KeyError:
|
|
# rebase isn't on, that's fine
|
|
pass
|
|
|
|
entry = extensions.wrapcommand(commands.table, "log", exlog)
|
|
entry[1].append(("", "remote", None, "show remote names even if hidden"))
|
|
|
|
entry = extensions.wrapcommand(commands.table, "paths", expaths)
|
|
entry[1].append(("d", "delete", "", "delete remote path", "NAME"))
|
|
entry[1].append(("a", "add", "", "add remote path", "NAME PATH"))
|
|
|
|
extensions.wrapcommand(commands.table, "pull", expullcmd)
|
|
|
|
entry = extensions.wrapcommand(commands.table, "clone", exclonecmd)
|
|
entry[1].append(("", "mirror", None, "sync all bookmarks"))
|
|
|
|
entry = extensions.wrapcommand(commands.table, "update", updatecmd)
|
|
entry[1].append(("B", "bookmark", "", "create new bookmark"))
|
|
|
|
exchange.pushdiscoverymapping["bookmarks"] = expushdiscoverybookmarks
|
|
|
|
try:
|
|
strip = extensions.find("strip")
|
|
if strip:
|
|
extensions.wrapcommand(strip.cmdtable, "strip", exstrip)
|
|
except KeyError:
|
|
# strip isn't on
|
|
pass
|
|
|
|
try:
|
|
histedit = extensions.find("histedit")
|
|
if histedit:
|
|
extensions.wrapcommand(histedit.cmdtable, "histedit", exhistedit)
|
|
except KeyError:
|
|
# histedit isn't on
|
|
pass
|
|
|
|
def hasjournal(loaded):
|
|
if not loaded:
|
|
return
|
|
# register our namespace as 'shared' when bookmarks are shared
|
|
journal = extensions.find("journal")
|
|
journal.sharednamespaces[journalremotebookmarktype] = hg.sharedbookmarks
|
|
|
|
extensions.afterloaded("journal", hasjournal)
|
|
|
|
bookcmd = extensions.wrapcommand(commands.table, "bookmarks", exbookmarks)
|
|
pushcmd = extensions.wrapcommand(commands.table, "push", expushcmd)
|
|
|
|
if _tracking(ui):
|
|
bookcmd[1].append(
|
|
("t", "track", "", "track this bookmark or remote name", "BOOKMARK")
|
|
)
|
|
bookcmd[1].append(
|
|
("u", "untrack", None, "remove tracking for this bookmark", "BOOKMARK")
|
|
)
|
|
|
|
newopts = [
|
|
(bookcmd, ("a", "all", None, "show both remote and local bookmarks")),
|
|
(bookcmd, ("", "remote", None, "show only remote bookmarks")),
|
|
(pushcmd, ("t", "to", "", "push revs to this bookmark", "BOOKMARK")),
|
|
(pushcmd, ("d", "delete", "", "delete remote bookmark", "BOOKMARK")),
|
|
(pushcmd, ("", "create", None, "create a new remote bookmark")),
|
|
(pushcmd, ("", "allow-anon", None, "allow a new unbookmarked head")),
|
|
(
|
|
pushcmd,
|
|
(
|
|
"",
|
|
"non-forward-move",
|
|
None,
|
|
"allows moving a remote bookmark to an arbitrary place",
|
|
),
|
|
),
|
|
]
|
|
|
|
def afterload(loaded):
|
|
if loaded:
|
|
raise ValueError("nonexistant extension should not be loaded")
|
|
|
|
for cmd, newopt in newopts:
|
|
# avoid adding duplicate optionms
|
|
skip = False
|
|
for opt in cmd[1]:
|
|
if opt[1] == newopt[1]:
|
|
skip = True
|
|
if not skip:
|
|
cmd[1].append(newopt)
|
|
|
|
extensions.afterloaded("nonexistant", afterload)
|
|
|
|
|
|
def exlog(orig, ui, repo, *args, **opts):
|
|
# hack for logging that turns on the dynamic blockerhook
|
|
if opts.get("remote"):
|
|
repo.__setattr__("_unblockhiddenremotenames", True)
|
|
res = orig(ui, repo, *args, **opts)
|
|
if opts.get("remote"):
|
|
repo.__setattr__("_unblockhiddenremotenames", False)
|
|
return res
|
|
|
|
|
|
def expushdiscoverybookmarks(pushop):
|
|
repo = pushop.repo.unfiltered()
|
|
remotemarks = pushop.remote.listkeys("bookmarks")
|
|
|
|
if pushop.delete:
|
|
if pushop.delete not in remotemarks:
|
|
raise error.Abort(_("remote bookmark %s does not exist") % pushop.delete)
|
|
pushop.outbookmarks.append([pushop.delete, remotemarks[pushop.delete], ""])
|
|
return exchange._pushdiscoverybookmarks(pushop)
|
|
|
|
if not pushop.to:
|
|
ret = exchange._pushdiscoverybookmarks(pushop)
|
|
if not pushop.allowanon:
|
|
# check to make sure we don't push an anonymous head
|
|
if pushop.revs:
|
|
revs = set(pushop.revs)
|
|
else:
|
|
revs = set(repo.lookup(r) for r in repo.revs("head()"))
|
|
revs -= set(pushop.remoteheads)
|
|
# find heads that don't have a bookmark going with them
|
|
for bookmark in pushop.bookmarks:
|
|
rev = repo.lookup(bookmark)
|
|
if rev in revs:
|
|
revs.remove(rev)
|
|
# remove heads that advance bookmarks (old mercurial behavior)
|
|
for bookmark, old, new in pushop.outbookmarks:
|
|
rev = repo.lookup(new)
|
|
if rev in revs:
|
|
revs.remove(rev)
|
|
|
|
# we use known() instead of lookup() due to lookup throwing an
|
|
# aborting error causing the connection to close
|
|
anonheads = []
|
|
knownlist = pushop.remote.known(revs)
|
|
for node, known in zip(revs, knownlist):
|
|
ctx = repo[node]
|
|
if (
|
|
known
|
|
or ctx.obsolete()
|
|
or ctx.closesbranch()
|
|
or
|
|
# if there is a topic, let's just skip it for now
|
|
(ctx.mutable() and "topic" in ctx.extra())
|
|
):
|
|
continue
|
|
anonheads.append(short(node))
|
|
|
|
if anonheads:
|
|
msg = _("push would create new anonymous heads (%s)")
|
|
hint = _("use --allow-anon to override this warning")
|
|
raise error.Abort(msg % ", ".join(sorted(anonheads)), hint=hint)
|
|
return ret
|
|
|
|
# in this path, we have a push --to command
|
|
if not len(pushop.bookmarks):
|
|
# if there are no bookmarks, something went wrong. bail gracefully.
|
|
raise error.Abort("no bookmark found to push")
|
|
|
|
bookmark = pushop.bookmarks[0]
|
|
rev = pushop.revs[0]
|
|
|
|
# allow new bookmark only if --create is specified
|
|
old = ""
|
|
if bookmark in remotemarks:
|
|
old = remotemarks[bookmark]
|
|
elif not pushop.create:
|
|
msg = _("not creating new remote bookmark")
|
|
hint = _("use --create to create a new bookmark")
|
|
raise error.Abort(msg, hint=hint)
|
|
|
|
# allow non-fg bookmark move only if --non-forward-move is specified
|
|
if not pushop.nonforwardmove and old != "":
|
|
# the first check isn't technically about non-fg moves, but the non-fg
|
|
# check relies on the old bm location being in the local repo
|
|
if old not in repo:
|
|
msg = _("remote bookmark revision is not in local repo")
|
|
hint = _("pull and merge or rebase or use --non-forward-move")
|
|
raise error.Abort(msg, hint=hint)
|
|
if mutation.enabled(repo):
|
|
foreground = mutation.foreground(repo, [repo.lookup(old)])
|
|
else:
|
|
foreground = obsutil.foreground(repo, [repo.lookup(old)])
|
|
if repo[rev].node() not in foreground:
|
|
msg = _("pushed rev is not in the foreground of remote bookmark")
|
|
hint = _("use --non-forward-move flag to complete arbitrary moves")
|
|
raise error.Abort(msg, hint=hint)
|
|
if repo[old] == repo[rev]:
|
|
repo.ui.status(_("remote bookmark already points at pushed rev\n"))
|
|
return
|
|
|
|
pushop.outbookmarks.append((bookmark, old, hex(rev)))
|
|
|
|
|
|
def _pushrevs(repo, ui, rev):
|
|
"""Given configuration and default rev, return the revs to be pushed"""
|
|
pushrev = ui.config("remotenames", "pushrev")
|
|
if pushrev == "!":
|
|
return []
|
|
elif pushrev:
|
|
return [repo[pushrev].rev()]
|
|
if rev:
|
|
return [repo[rev].rev()]
|
|
return []
|
|
|
|
|
|
def expullcmd(orig, ui, repo, source="default", **opts):
|
|
revrenames = dict((v, k) for k, v in _getrenames(ui).iteritems())
|
|
source = revrenames.get(source, source)
|
|
|
|
if opts.get("update") and opts.get("rebase"):
|
|
raise error.Abort(_("specify either rebase or update, not both"))
|
|
|
|
if not opts.get("rebase"):
|
|
return orig(ui, repo, source, **opts)
|
|
|
|
rebasemodule = extensions.find("rebase")
|
|
|
|
if not rebasemodule:
|
|
return orig(ui, repo, source, **opts)
|
|
|
|
if not _tracking(ui):
|
|
return orig(ui, repo, source, **opts)
|
|
|
|
dest = _getrebasedest(repo, opts)
|
|
|
|
if dest:
|
|
# Let `pull` do its thing without `rebase.py->pullrebase()`
|
|
del opts["rebase"]
|
|
tool = opts.pop("tool", "")
|
|
ret = orig(ui, repo, source, **opts)
|
|
return ret or rebasemodule.rebase(ui, repo, dest=dest, tool=tool)
|
|
else:
|
|
return orig(ui, repo, source, **opts)
|
|
|
|
|
|
def _getrebasedest(repo, opts):
|
|
"""opts is passed in for extensibility"""
|
|
tracking = _readtracking(repo)
|
|
active = repo._activebookmark
|
|
return tracking.get(active)
|
|
|
|
|
|
def expushcmd(orig, ui, repo, dest=None, **opts):
|
|
# during the upgrade from old to new remotenames, tooling that uses --force
|
|
# will continue working if remotenames.forcecompat is enabled
|
|
forcecompat = ui.configbool("remotenames", "forcecompat")
|
|
|
|
# needed for discovery method
|
|
opargs = {
|
|
"delete": opts.get("delete"),
|
|
"to": opts.get("to"),
|
|
"create": opts.get("create") or (opts.get("force") and forcecompat),
|
|
"allowanon": opts.get("allow_anon")
|
|
or repo.ui.configbool("remotenames", "pushanonheads")
|
|
or (opts.get("force") and forcecompat),
|
|
"nonforwardmove": opts.get("non_forward_move")
|
|
or repo.ui.configbool("remotenames", "allownonfastforward")
|
|
or (opts.get("force") and forcecompat),
|
|
}
|
|
|
|
if opargs["delete"]:
|
|
flag = None
|
|
for f in ("to", "bookmark", "branch", "rev"):
|
|
if opts.get(f):
|
|
flag = f
|
|
break
|
|
if flag:
|
|
msg = _("do not specify --delete and " "--%s at the same time") % flag
|
|
raise error.Abort(msg)
|
|
# we want to skip pushing any changesets while deleting a remote
|
|
# bookmark, so we send the null revision
|
|
opts["rev"] = ["null"]
|
|
return orig(ui, repo, dest, opargs=opargs, **opts)
|
|
|
|
revs = opts.get("rev")
|
|
|
|
paths = dict((path, url) for path, url in ui.configitems("paths"))
|
|
revrenames = dict((v, k) for k, v in _getrenames(ui).iteritems())
|
|
|
|
origdest = dest
|
|
defaultpush = ui.paths.get("default-push") or ui.paths.get("default")
|
|
if defaultpush:
|
|
defaultpush = defaultpush.loc
|
|
if (
|
|
(not dest or dest == defaultpush)
|
|
and not opargs["to"]
|
|
and not revs
|
|
and _tracking(ui)
|
|
):
|
|
current = repo._activebookmark
|
|
tracking = _readtracking(repo)
|
|
ui.debug("tracking on %s %s\n" % (current, tracking))
|
|
if current and current in tracking:
|
|
track = tracking[current]
|
|
path, book = splitremotename(track)
|
|
# un-rename a path, if needed
|
|
path = revrenames.get(path, path)
|
|
if book and path in paths:
|
|
dest = path
|
|
opargs["to"] = book
|
|
|
|
# un-rename passed path
|
|
dest = revrenames.get(dest, dest)
|
|
|
|
# if dest was renamed to default but we aren't specifically requesting
|
|
# to push to default, change dest to default-push, if available
|
|
if not origdest and dest == "default" and "default-push" in paths:
|
|
dest = "default-push"
|
|
|
|
# get the actual path we will push to so we can do some url sniffing
|
|
for check in [
|
|
# dest may be a path name, or an actual url
|
|
paths.get(dest, dest),
|
|
paths.get("default-push"),
|
|
paths.get("default"),
|
|
]:
|
|
if check:
|
|
# hgsubversion and hggit do funky things on push. Just call direct.
|
|
if check.startswith("svn+") or check.startswith("git+"):
|
|
return orig(ui, repo, dest, opargs=opargs, **opts)
|
|
# Once we have found the path where we are pushing, do not continue
|
|
# checking for places we are not pushing.
|
|
break
|
|
|
|
if not opargs["to"]:
|
|
if ui.configbool("remotenames", "forceto"):
|
|
msg = _("must specify --to when pushing")
|
|
hint = _("see configuration option %s") % "remotenames.forceto"
|
|
raise error.Abort(msg, hint=hint)
|
|
|
|
if not revs:
|
|
opts["rev"] = _pushrevs(repo, ui, None)
|
|
|
|
return orig(ui, repo, dest, opargs=opargs, **opts)
|
|
|
|
if opts.get("bookmark"):
|
|
msg = _("do not specify --to/-t and --bookmark/-B at the same time")
|
|
raise error.Abort(msg)
|
|
if opts.get("branch"):
|
|
msg = _("do not specify --to/-t and --branch/-b at the same time")
|
|
raise error.Abort(msg)
|
|
|
|
# if we are not using the original push command implementation, make sure
|
|
# pushvars is included in opargs
|
|
pushvars = opts.get("pushvars")
|
|
if pushvars:
|
|
opargs["pushvars"] = pushvars
|
|
|
|
if revs:
|
|
revs = [repo.lookup(r) for r in scmutil.revrange(repo, revs)]
|
|
else:
|
|
revs = _pushrevs(repo, ui, ".")
|
|
if len(revs) != 1:
|
|
msg = _("--to requires exactly one rev to push")
|
|
hint = _("use --rev BOOKMARK or omit --rev for current commit (.)")
|
|
raise error.Abort(msg, hint=hint)
|
|
rev = revs[0]
|
|
|
|
# big can o' copypasta from commands.push
|
|
dest = ui.expandpath(dest or "default-push", dest or "default")
|
|
dest, branches = hg.parseurl(dest, opts.get("branch"))
|
|
try:
|
|
other = hg.peer(repo, opts, dest)
|
|
except error.RepoError:
|
|
if dest == "default-push":
|
|
hint = _('see the "path" section in "hg help config"')
|
|
raise error.Abort(_("default repository not configured!"), hint=hint)
|
|
else:
|
|
raise
|
|
|
|
# all checks pass, go for it!
|
|
node = repo.lookup(rev)
|
|
ui.status(
|
|
_("pushing rev %s to destination %s bookmark %s\n")
|
|
% (short(node), dest, opargs["to"])
|
|
)
|
|
|
|
force = opts.get("force")
|
|
bookmark = opargs["to"]
|
|
pattern = ui.config("remotenames", "disallowedto")
|
|
if pattern and re.match(pattern, bookmark):
|
|
msg = _("this remote bookmark name is not allowed")
|
|
hint = ui.config("remotenames", "disallowedhint") or _(
|
|
"use another bookmark name"
|
|
)
|
|
raise error.Abort(msg, hint=hint)
|
|
# NB: despite the name, 'revs' doesn't work if it's a numeric rev
|
|
pushop = exchange.push(
|
|
repo, other, force, revs=[node], bookmarks=(opargs["to"],), opargs=opargs
|
|
)
|
|
|
|
result = not pushop.cgresult
|
|
if pushop.bkresult is not None:
|
|
if pushop.bkresult == 2:
|
|
result = 2
|
|
elif not result and pushop.bkresult:
|
|
result = 2
|
|
|
|
return result
|
|
|
|
|
|
def exclonecmd(orig, ui, *args, **opts):
|
|
if opts["mirror"]:
|
|
ui.setconfig("remotenames", "syncbookmarks", True, "mirror-clone")
|
|
orig(ui, *args, **opts)
|
|
|
|
|
|
def _readtracking(repo):
|
|
tracking = {}
|
|
try:
|
|
vfs = repo.sharedvfs
|
|
for line in vfs.read("bookmarks.tracking").strip().split("\n"):
|
|
try:
|
|
book, track = line.strip().split(" ", 1)
|
|
tracking[book] = track
|
|
except ValueError:
|
|
# corrupt file, ignore entry
|
|
pass
|
|
except IOError:
|
|
pass
|
|
return tracking
|
|
|
|
|
|
def _writetracking(repo, tracking):
|
|
with repo.wlock():
|
|
data = ""
|
|
for book, track in tracking.iteritems():
|
|
data += "%s %s\n" % (book, track)
|
|
vfs = repo.sharedvfs
|
|
vfs.write("bookmarks.tracking", data)
|
|
|
|
|
|
def _removetracking(repo, bookmarks):
|
|
tracking = _readtracking(repo)
|
|
needwrite = False
|
|
for bmark in bookmarks:
|
|
try:
|
|
del tracking[bmark]
|
|
needwrite = True
|
|
except KeyError:
|
|
pass
|
|
if needwrite:
|
|
_writetracking(repo, tracking)
|
|
|
|
|
|
def exbookmarks(orig, ui, repo, *args, **opts):
|
|
"""Bookmark output is sorted by bookmark name.
|
|
|
|
This has the side benefit of grouping all remote bookmarks by remote name.
|
|
|
|
"""
|
|
delete = opts.get("delete")
|
|
rename = opts.get("rename")
|
|
inactive = opts.get("inactive")
|
|
remote = opts.get("remote")
|
|
track = opts.get("track")
|
|
untrack = opts.get("untrack")
|
|
|
|
disallowed = set(ui.configlist("remotenames", "disallowedbookmarks"))
|
|
# Adds local bookmark if one of the options is called and args is empty
|
|
if not args and (track or untrack):
|
|
book = repo._bookmarks.active
|
|
if book:
|
|
args = (book,)
|
|
|
|
if not delete:
|
|
for name in args:
|
|
if name in disallowed:
|
|
msg = _("bookmark '%s' not allowed by configuration")
|
|
raise error.Abort(msg % name)
|
|
|
|
if untrack:
|
|
if track:
|
|
msg = _("do not specify --untrack and --track at the same time")
|
|
raise error.Abort(msg)
|
|
_removetracking(repo, args)
|
|
return
|
|
|
|
if delete or rename or args or inactive:
|
|
if delete and track:
|
|
msg = _("do not specifiy --track and --delete at the same time")
|
|
raise error.Abort(msg)
|
|
|
|
ret = orig(ui, repo, *args, **opts)
|
|
|
|
oldtracking = _readtracking(repo)
|
|
tracking = dict(oldtracking)
|
|
|
|
if rename and not track:
|
|
if rename in tracking:
|
|
tracked = tracking[rename]
|
|
del tracking[rename]
|
|
for arg in args:
|
|
tracking[arg] = tracked
|
|
|
|
if track:
|
|
for arg in args:
|
|
tracking[arg] = track
|
|
|
|
if delete:
|
|
for arg in args:
|
|
if arg in tracking:
|
|
del tracking[arg]
|
|
|
|
if tracking != oldtracking:
|
|
_writetracking(repo, tracking)
|
|
# update the cache
|
|
precachedistance(repo)
|
|
|
|
return ret
|
|
|
|
fm = ui.formatter("bookmarks", opts)
|
|
if not remote:
|
|
displaylocalbookmarks(ui, repo, opts, fm)
|
|
|
|
if remote or opts.get("all"):
|
|
displayremotebookmarks(ui, repo, opts, fm)
|
|
|
|
fm.end()
|
|
|
|
|
|
def displaylocalbookmarks(ui, repo, opts, fm):
|
|
# copy pasta from commands.py; need to patch core
|
|
hexfn = fm.hexfunc
|
|
marks = repo._bookmarks
|
|
if len(marks) == 0 and (not fm or fm.isplain()):
|
|
ui.status(_("no bookmarks set\n"))
|
|
|
|
tracking = _readtracking(repo)
|
|
distances = readdistancecache(repo)
|
|
nq = not ui.quiet
|
|
|
|
for bmark, n in sorted(marks.iteritems()):
|
|
current = repo._activebookmark
|
|
if bmark == current:
|
|
prefix, label = "*", "bookmarks.current bookmarks.active"
|
|
else:
|
|
prefix, label = " ", ""
|
|
|
|
fm.startitem()
|
|
if nq:
|
|
fm.plain(" %s " % prefix, label=label)
|
|
fm.write("bookmark", "%s", bmark, label=label)
|
|
pad = " " * (25 - encoding.colwidth(bmark))
|
|
rev = repo.changelog.rev(n)
|
|
h = hexfn(n)
|
|
fm.condwrite(nq, "rev node", pad + " %d:%s", rev, h, label=label)
|
|
if ui.verbose and bmark in tracking:
|
|
tracked = tracking[bmark]
|
|
if bmark in distances:
|
|
distance = distances[bmark]
|
|
else:
|
|
distance = calculatenamedistance(repo, bmark, tracked)
|
|
if tracked:
|
|
fmt = "%s"
|
|
args = (tracked,)
|
|
fields = ["tracking"]
|
|
if distance != (0, 0) and distance != (None, None):
|
|
ahead, behind = distance
|
|
fmt += ": %s ahead, %s behind"
|
|
args += ahead, behind
|
|
fields += ["ahead", "behind"]
|
|
pad = " " * (
|
|
25 - encoding.colwidth(str(rev)) - encoding.colwidth(str(h))
|
|
)
|
|
fm.write(" ".join(fields), "%s[%s]" % (pad, fmt), *args, label=label)
|
|
if distance != (None, None):
|
|
distances[bmark] = distance
|
|
fm.data(active=(bmark == current))
|
|
fm.plain("\n")
|
|
|
|
# write distance cache
|
|
writedistancecache(repo, distances)
|
|
|
|
|
|
def displayremotebookmarks(ui, repo, opts, fm):
|
|
n = "remotebookmarks"
|
|
if n not in repo.names:
|
|
return
|
|
ns = repo.names[n]
|
|
color = ns.colorname
|
|
label = "log." + color
|
|
|
|
# it seems overkill to hide displaying hidden remote bookmarks
|
|
repo = repo.unfiltered()
|
|
useformatted = repo.ui.formatted()
|
|
|
|
for name in sorted(ns.listnames(repo)):
|
|
nodes = ns.nodes(repo, name)
|
|
if not nodes:
|
|
continue
|
|
|
|
node = nodes[0]
|
|
ctx = repo[node]
|
|
fm.startitem()
|
|
|
|
if not ui.quiet:
|
|
fm.plain(" ")
|
|
|
|
padsize = max(25 - encoding.colwidth(name), 0)
|
|
fmt = " " * padsize + " %d:%s"
|
|
|
|
tmplabel = label
|
|
if useformatted and ctx.obsolete():
|
|
tmplabel = tmplabel + " changeset.obsolete"
|
|
fm.write(color, "%s", name, label=label)
|
|
fm.condwrite(
|
|
not ui.quiet, "rev node", fmt, ctx.rev(), fm.hexfunc(node), label=tmplabel
|
|
)
|
|
fm.plain("\n")
|
|
|
|
|
|
def _normalizeremote(remote):
|
|
"""
|
|
Normalises a remote for grouping
|
|
|
|
Remote URL can have QueryStrings or Fragments which we consider to be
|
|
parameters, rather then being part of the repo path. So normalization strips
|
|
away the QueryString and Fragments and returns the stripped remote.
|
|
"""
|
|
u = util.url(remote)
|
|
u.query = None
|
|
u.fragment = None
|
|
return bytes(u)
|
|
|
|
|
|
def activepath(ui, remote):
|
|
local = None
|
|
try:
|
|
local = remote.local()
|
|
except AttributeError:
|
|
pass
|
|
|
|
# determine the remote path from the repo, if possible; else just
|
|
# use the string given to us
|
|
rpath = remote
|
|
if local:
|
|
rpath = getattr(remote, "root", None)
|
|
if rpath is None:
|
|
# Maybe a localpeer? (hg@1ac628cd7113, 2.3)
|
|
rpath = getattr(getattr(remote, "_repo", None), "root", None)
|
|
elif not isinstance(remote, str):
|
|
try:
|
|
rpath = _normalizeremote(remote.url())
|
|
except AttributeError:
|
|
# Handled by "isinstance(rpath, basestring)" below
|
|
pass
|
|
else:
|
|
rpath = _normalizeremote(rpath)
|
|
|
|
candidates = []
|
|
for path, uri in ui.configitems("paths"):
|
|
uri = ui.expandpath(expandscheme(ui, uri))
|
|
if local:
|
|
uri = os.path.realpath(uri)
|
|
else:
|
|
uri = _normalizeremote(uri)
|
|
if uri.startswith("http"):
|
|
try:
|
|
uri = util.url(uri).authinfo()[0]
|
|
except AttributeError:
|
|
uri = url.getauthinfo(uri)[0]
|
|
uri = uri.rstrip("/")
|
|
# guard against hgsubversion nonsense
|
|
if not isinstance(rpath, basestring): # noqa
|
|
continue
|
|
rpath = rpath.rstrip("/")
|
|
if uri == rpath:
|
|
candidates.append(path)
|
|
|
|
if not candidates:
|
|
return ""
|
|
|
|
# be stable under different orderings of paths in config files
|
|
# prefer any name other than 'default', 'default-push', 'infinitepush' or 'infinitepush-other' if available
|
|
# prefer shortest name of remaining names, and break ties by alphabetizing
|
|
cset = set(candidates)
|
|
cset.discard("default")
|
|
cset.discard("default-push")
|
|
cset.discard("infinitepush")
|
|
cset.discard("infinitepush-other")
|
|
if cset:
|
|
candidates = list(cset)
|
|
|
|
candidates.sort() # alphabetical
|
|
candidates.sort(key=len) # sort is stable so first will be the correct one
|
|
bestpath = candidates[0]
|
|
|
|
renames = _getrenames(ui)
|
|
realpath = renames.get(bestpath, bestpath)
|
|
return realpath
|
|
|
|
|
|
# memoization
|
|
_renames = None
|
|
|
|
|
|
def _getrenames(ui):
|
|
global _renames
|
|
if _renames is None:
|
|
_renames = {}
|
|
for k, v in ui.configitems("remotenames"):
|
|
if k.startswith("rename."):
|
|
_renames[k[7:]] = v
|
|
return _renames
|
|
|
|
|
|
def expandscheme(ui, uri):
|
|
"""For a given uri, expand the scheme for it"""
|
|
urischemes = [s for s in schemes.schemes.iterkeys() if uri.startswith("%s://" % s)]
|
|
for s in urischemes:
|
|
# TODO: refactor schemes so we don't
|
|
# duplicate this logic
|
|
ui.note(_("performing schemes expansion with " "scheme %s\n") % s)
|
|
scheme = hg.schemes[s]
|
|
parts = uri.split("://", 1)[1].split("/", scheme.parts)
|
|
if len(parts) > scheme.parts:
|
|
tail = parts[-1]
|
|
parts = parts[:-1]
|
|
else:
|
|
tail = ""
|
|
ctx = dict((str(i + 1), v) for i, v in enumerate(parts))
|
|
uri = "".join(scheme.templater.process(scheme.url, ctx)) + tail
|
|
return uri
|
|
|
|
|
|
def splitremotename(remote):
|
|
name = ""
|
|
if "/" in remote:
|
|
remote, name = remote.split("/", 1)
|
|
return remote, name
|
|
|
|
|
|
def joinremotename(remote, ref):
|
|
if ref:
|
|
remote += "/" + ref
|
|
return remote
|
|
|
|
|
|
def shareawarecachevfs(repo):
|
|
if repo.shared():
|
|
return vfsmod.vfs(os.path.join(repo.sharedpath, "cache"))
|
|
else:
|
|
return repo.cachevfs
|
|
|
|
|
|
def _readremotenamesfrom(vfs, filename):
|
|
if not vfs.exists(filename):
|
|
return
|
|
|
|
f = vfs(filename)
|
|
for line in f:
|
|
nametype = None
|
|
line = line.strip()
|
|
if not line:
|
|
continue
|
|
nametype = None
|
|
remote, rname = None, None
|
|
|
|
node, name = line.split(" ", 1)
|
|
|
|
# check for nametype being written into the file format
|
|
if " " in name:
|
|
nametype, name = name.split(" ", 1)
|
|
|
|
remote, rname = splitremotename(name)
|
|
|
|
# skip old data that didn't write the name (only wrote the alias)
|
|
if not rname:
|
|
continue
|
|
|
|
yield node, nametype, remote, rname
|
|
|
|
f.close()
|
|
|
|
|
|
def readbookmarknames(repo, remote):
|
|
for node, nametype, remotename, rname in readremotenames(repo):
|
|
if nametype == "bookmarks" and remotename == remote:
|
|
yield rname
|
|
|
|
|
|
def readremotenames(repo):
|
|
return _readremotenamesfrom(repo.sharedvfs, "remotenames")
|
|
|
|
|
|
def _writesingleremotename(fd, remote, nametype, name, node):
|
|
remotename = joinremotename(remote, name)
|
|
fd.write("%s %s %s\n" % (node, nametype, remotename))
|
|
|
|
|
|
def transition(repo, ui):
|
|
"""
|
|
Help with transitioning to using a remotenames workflow.
|
|
|
|
Allows deleting matching local bookmarks defined in a config file:
|
|
|
|
[remotenames]
|
|
transitionbookmarks = master
|
|
stable
|
|
"""
|
|
transmarks = ui.configlist("remotenames", "transitionbookmarks")
|
|
localmarks = repo._bookmarks
|
|
changes = []
|
|
for mark in transmarks:
|
|
if mark in localmarks:
|
|
changes.append((mark, None)) # delete this bookmark
|
|
lock = tr = None
|
|
try:
|
|
lock = repo.lock()
|
|
tr = repo.transaction("remotenames")
|
|
localmarks.applychanges(repo, tr, changes)
|
|
tr.close()
|
|
finally:
|
|
lockmod.release(lock, tr)
|
|
|
|
message = ui.config("remotenames", "transitionmessage")
|
|
if message:
|
|
ui.warn(message + "\n")
|
|
|
|
|
|
def saveremotenames(repo, remotepath, bookmarks=None):
|
|
vfs = repo.sharedvfs
|
|
wlock = repo.wlock()
|
|
if bookmarks is None:
|
|
bookmarks = {}
|
|
try:
|
|
# delete old files
|
|
try:
|
|
vfs.unlink("remotedistance")
|
|
except OSError as inst:
|
|
if inst.errno != errno.ENOENT:
|
|
raise
|
|
|
|
if not vfs.exists("remotenames"):
|
|
transition(repo, repo.ui)
|
|
|
|
# read in all data first before opening file to write
|
|
olddata = set(readremotenames(repo))
|
|
oldbooks = {}
|
|
|
|
f = vfs("remotenames", "w", atomictemp=True)
|
|
|
|
# only update the given 'remote path'; iterate over
|
|
# old data and re-save it
|
|
for node, nametype, oldremote, rname in olddata:
|
|
if oldremote != remotepath:
|
|
_writesingleremotename(f, oldremote, nametype, rname, node)
|
|
elif nametype == "bookmarks":
|
|
oldbooks[rname] = node
|
|
|
|
# record a journal entry if journal is loaded
|
|
if util.safehasattr(repo, "journal"):
|
|
entrydata = []
|
|
for rmbookmark, newnode in bookmarks.iteritems():
|
|
oldnode = oldbooks.get(rmbookmark, hex(nullid))
|
|
if oldnode != newnode:
|
|
joinedremotename = joinremotename(remotepath, rmbookmark)
|
|
entrydata.append((joinedremotename, bin(oldnode), bin(newnode)))
|
|
repo.journal.recordmany(journalremotebookmarktype, entrydata)
|
|
|
|
nm = repo.unfiltered().changelog.nodemap
|
|
for bookmark, n in bookmarks.iteritems():
|
|
bookhex = n
|
|
if not bin(bookhex) in nm:
|
|
# node is unknown locally, don't change the bookmark
|
|
bookhex = oldbooks.get(bookmark)
|
|
if bookhex:
|
|
_writesingleremotename(f, remotepath, "bookmarks", bookmark, bookhex)
|
|
f.close()
|
|
|
|
# Old paths have been deleted, refresh remotenames
|
|
repo._remotenames.clearnames()
|
|
|
|
finally:
|
|
wlock.release()
|
|
|
|
|
|
def calculatedistance(repo, fromrev, torev):
|
|
"""
|
|
Return the (ahead, behind) distance between `fromrev` and `torev`.
|
|
The returned tuple will contain ints if calculated, Nones otherwise.
|
|
"""
|
|
if not repo.ui.configbool("remotenames", "calculatedistance"):
|
|
return (None, None)
|
|
|
|
ahead = len(repo.revs("only(%d, %d)" % (fromrev, torev)))
|
|
behind = len(repo.revs("only(%d, %d)" % (torev, fromrev)))
|
|
|
|
return (ahead, behind)
|
|
|
|
|
|
def calculatenamedistance(repo, fromname, toname):
|
|
"""
|
|
Similar to calculatedistance, but accepts names such as local and remote
|
|
bookmarks, and will return (None, None) if any of the names do not resolve
|
|
in the given repository.
|
|
"""
|
|
distance = (None, None)
|
|
if fromname and fromname in repo and toname in repo:
|
|
rev1 = repo[fromname].rev()
|
|
rev2 = repo[toname].rev()
|
|
distance = calculatedistance(repo, rev1, rev2)
|
|
return distance
|
|
|
|
|
|
def writedistancecache(repo, distance):
|
|
try:
|
|
cachevfs = shareawarecachevfs(repo)
|
|
f = cachevfs("distance", "w", atomictemp=True)
|
|
for k, v in distance.iteritems():
|
|
f.write("%s %d %d\n" % (k, v[0], v[1]))
|
|
except (IOError, OSError):
|
|
pass
|
|
|
|
|
|
def readdistancecache(repo):
|
|
distances = {}
|
|
try:
|
|
cachevfs = shareawarecachevfs(repo)
|
|
for line in cachevfs.read("distance").splitlines():
|
|
line = line.rsplit(" ", 2)
|
|
try:
|
|
d = (int(line[1]), int(line[2]))
|
|
distances[line[0]] = d
|
|
except ValueError:
|
|
# corrupt entry, ignore line
|
|
pass
|
|
except (IOError, OSError):
|
|
pass
|
|
|
|
return distances
|
|
|
|
|
|
def invalidatedistancecache(repo):
|
|
"""Try to invalidate any existing distance caches"""
|
|
error = False
|
|
cachevfs = shareawarecachevfs(repo)
|
|
try:
|
|
if cachevfs.isdir("distance"):
|
|
shutil.rmtree(cachevfs.join("distance"))
|
|
else:
|
|
cachevfs.unlink("distance")
|
|
except (OSError, IOError) as inst:
|
|
if inst.errno != errno.ENOENT:
|
|
error = True
|
|
try:
|
|
cachevfs.unlink("distance.current")
|
|
except (OSError, IOError) as inst:
|
|
if inst.errno != errno.ENOENT:
|
|
error = True
|
|
|
|
if error:
|
|
repo.ui.warn(
|
|
_(
|
|
"Unable to invalidate tracking cache; "
|
|
+ "distance displayed may be incorrect\n"
|
|
)
|
|
)
|
|
|
|
|
|
def precachedistance(repo):
|
|
"""
|
|
Caclulate and cache the distance between bookmarks and what they
|
|
track, plus the distance from the tipmost head on current topological
|
|
branch. This can be an expensive operation especially in repositories
|
|
with a high commit rate, so it can be turned off in your hgrc:
|
|
|
|
[remotenames]
|
|
precachedistance = False
|
|
precachecurrent = False
|
|
"""
|
|
# when working between multiple local repos which do not all have
|
|
# remotenames enabled, do this work only for those with it enabled
|
|
if not util.safehasattr(repo, "_remotenames"):
|
|
return
|
|
|
|
# to avoid stale namespaces, let's reload
|
|
repo._remotenames.clearnames()
|
|
|
|
wlock = repo.wlock()
|
|
try:
|
|
invalidatedistancecache(repo)
|
|
|
|
distances = {}
|
|
if repo.ui.configbool("remotenames", "precachedistance"):
|
|
distances = {}
|
|
for bmark, tracked in _readtracking(repo).iteritems():
|
|
distance = calculatenamedistance(repo, bmark, tracked)
|
|
if distance != (None, None):
|
|
distances[bmark] = distance
|
|
writedistancecache(repo, distances)
|
|
|
|
if repo.ui.configbool("remotenames", "precachecurrent"):
|
|
# are we on a 'branch' but not at the head?
|
|
# i.e. is there a bookmark that we are heading towards?
|
|
revs = list(repo.revs("limit(.:: and bookmark() - ., 1)"))
|
|
if revs:
|
|
# if we are here then we have one or more bookmarks
|
|
# and we'll pick the first one for now
|
|
bmark = repo[revs[0]].bookmarks()[0]
|
|
distance = len(repo.revs("only(%d, .)" % revs[0]))
|
|
cachevfs = shareawarecachevfs(repo)
|
|
cachevfs.write("distance.current", "%s %d" % (bmark, distance))
|
|
|
|
finally:
|
|
wlock.release()
|
|
|
|
|
|
#########
|
|
# revsets
|
|
#########
|
|
|
|
|
|
def upstream_revs(filt, repo, subset, x):
|
|
upstream_tips = set()
|
|
for remotename in repo._remotenames.keys():
|
|
rname = "remote" + remotename
|
|
try:
|
|
ns = repo.names[rname]
|
|
except KeyError:
|
|
continue
|
|
for name in ns.listnames(repo):
|
|
if filt(splitremotename(name)[0]):
|
|
upstream_tips.update(ns.nodes(repo, name))
|
|
|
|
if not upstream_tips:
|
|
return smartset.baseset([])
|
|
|
|
tipancestors = repo.revs("::%ln", upstream_tips)
|
|
return smartset.filteredset(subset, lambda n: n in tipancestors)
|
|
|
|
|
|
@revsetpredicate("upstream()")
|
|
def upstream(repo, subset, x):
|
|
"""Select changesets in an upstream repository according to remotenames."""
|
|
repo = repo.unfiltered()
|
|
upstream_names = repo.ui.configlist("remotenames", "upstream")
|
|
# override default args from hgrc with args passed in on the command line
|
|
if x:
|
|
upstream_names = [
|
|
revset.getstring(symbol, "remote path must be a string")
|
|
for symbol in revset.getlist(x)
|
|
]
|
|
|
|
default_path = dict(repo.ui.configitems("paths")).get("default")
|
|
if not upstream_names and default_path:
|
|
default_path = expandscheme(repo.ui, default_path)
|
|
upstream_names = [activepath(repo.ui, default_path)]
|
|
|
|
def filt(name):
|
|
if upstream_names:
|
|
return name in upstream_names
|
|
return True
|
|
|
|
return upstream_revs(filt, repo, subset, x)
|
|
|
|
|
|
@revsetpredicate("pushed()")
|
|
def pushed(repo, subset, x):
|
|
"""Select changesets in any remote repository according to remotenames."""
|
|
revset.getargs(x, 0, 0, "pushed takes no arguments")
|
|
return upstream_revs(lambda x: True, repo, subset, x)
|
|
|
|
|
|
def getremoterevs(repo, namespacename, matchpattern=None):
|
|
try:
|
|
ns = repo.names[namespacename]
|
|
except KeyError:
|
|
return set()
|
|
|
|
if matchpattern is None:
|
|
nodes = set()
|
|
for name in ns.listnames(repo):
|
|
nodes.update(ns.namemap(repo, name))
|
|
else:
|
|
kind, pattern, matcher = util.stringmatcher(matchpattern)
|
|
if kind == "literal":
|
|
nodes = ns.namemap(repo, pattern)
|
|
else:
|
|
nodes = set()
|
|
for name in ns.listnames(repo):
|
|
if matcher(name):
|
|
nodes.update(ns.namemap(repo, name))
|
|
return {repo[node].rev() for node in nodes if node in repo}
|
|
|
|
|
|
@revsetpredicate("remotenames()")
|
|
def remotenamesrevset(repo, subset, x):
|
|
"""All remote bookmarks and branches."""
|
|
if not util.safehasattr(repo, "_remotenames"):
|
|
# If this repository does not have remotenames enabled just evaluate to the
|
|
# empty set.
|
|
return smartset.baseset([])
|
|
|
|
revset.getargs(x, 0, 0, "remotenames takes no arguments")
|
|
remoterevs = set()
|
|
for rname in repo._remotenames.keys():
|
|
remoterevs.update(getremoterevs(repo, "remote" + rname))
|
|
return subset & smartset.baseset(sorted(remoterevs))
|
|
|
|
|
|
@revsetpredicate("remotebookmark([name])")
|
|
def remotebookmarkrevset(repo, subset, x):
|
|
"""The named remote bookmark, or all remote bookmarks.
|
|
|
|
Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
|
|
"""
|
|
args = revset.getargs(x, 0, 1, _("remotebookmark takes one or no arguments"))
|
|
if args:
|
|
bookmarkname = revset.getstring(
|
|
args[0], _("the argument to remotebookmark must be a string")
|
|
)
|
|
else:
|
|
bookmarkname = None
|
|
remoterevs = getremoterevs(repo, "remotebookmarks", bookmarkname)
|
|
if not remoterevs and bookmarkname is not None:
|
|
raise error.RepoLookupError(
|
|
_("no remote bookmarks exist that match '%s'") % bookmarkname
|
|
)
|
|
return subset & smartset.baseset(sorted(remoterevs))
|
|
|
|
|
|
###########
|
|
# templates
|
|
###########
|
|
|
|
|
|
@templatekeyword("remotenames")
|
|
def remotenameskw(**args):
|
|
""":remotenames: List of strings. List of remote names associated with the
|
|
changeset. If remotenames.suppressbranches is True then branch names will
|
|
be hidden if there is a bookmark at the same changeset.
|
|
|
|
"""
|
|
repo, ctx = args["repo"], args["ctx"]
|
|
|
|
remotenames = []
|
|
if "remotebookmarks" in repo.names:
|
|
remotenames = repo.names["remotebookmarks"].names(repo, ctx.node())
|
|
|
|
return templatekw.showlist("remotename", remotenames, args, plural="remotenames")
|