This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4535

hg: allow extra arguments to be passed to repo creation
ClosedPublic

Authored by indygreg on Sep 11 2018, 8:27 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG089fc0db0954: hg: allow extra arguments to be passed to repo creation (API)
Summary

Currently, repository creation is influenced by consulting the
ui instance and turning config options into requirements. This
means that in order to influence repository creation, you need
to define and set a config option and that the option must translate
to a requirement stored in the .hg/requires file.

This commit introduces a new mechanism to influence repository
creation. hg.repository() and hg.peer() have been taught to
receive a new optional argument defining extra options to apply
to repository creation. This value is passed along to the various
instance() functions and can be used to influence repository
creation. This will allow us to pass rich data directly to repository
creation without having to go through the config layer. It also allows
us to be more explicit about the features requested during repository
creation and provides a natural point to detect unhandled options
influencing repository creation. The new code detects when unknown
creation options are present and aborts in that case.

.. api:: options can now be passed to influence repository creation

The various instance() functions to spawn new peers or repository
instances now receive a ``createopts`` argument that can be a
dict defining additional options to influence repository creation.

localrepo.newreporequirements() also receives this argument.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

indygreg created this revision.Sep 11 2018, 8:27 PM
yuja added a subscriber: yuja.Sep 12 2018, 8:43 AM

+def filterknowncreateopts(ui, createopts):
+ """Filters a dict of repo creation options against options that are known.

Nit: I thought this would select only known options.

+ raise error.Abort(_('unable to create repository because of unknown '
+ 'creation option: %s') %
+ ', '.sorted(unknownopts.keys()),

Removed .keys() to make it clearer that we don't need a new list on Py2.

Closed by commit rHG089fc0db0954: hg: allow extra arguments to be passed to repo creation (API) (authored by indygreg). · Explain WhySep 12 2018, 9:02 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 10925

hgext/schemes.py

try: try:
self.parts = max(map(int, _partre.findall(self.url))) self.parts = max(map(int, _partre.findall(self.url)))
except ValueError: except ValueError:
self.parts = 0 self.parts = 0
def __repr__(self): def __repr__(self):
return '<ShortRepository: %s>' % self.scheme return '<ShortRepository: %s>' % self.scheme
def instance(self, ui, url, create, intents=None): def instance(self, ui, url, create, intents=None, createopts=None):
url = self.resolve(url) url = self.resolve(url)
return hg._peerlookup(url).instance(ui, url, create, intents=intents) return hg._peerlookup(url).instance(ui, url, create, intents=intents,
createopts=createopts)
def resolve(self, url): def resolve(self, url):
# Should this use the util.url class, or is manual parsing better? # Should this use the util.url class, or is manual parsing better?
try: try:
url = url.split('://', 1)[1] url = url.split('://', 1)[1]
except IndexError: except IndexError:
raise error.Abort(_("no '://' in scheme url '%s'") % url) raise error.Abort(_("no '://' in scheme url '%s'") % url)
parts = url.split('/', self.parts) parts = url.split('/', self.parts)

mercurial/bundlerepo.py

p2rev = self.changelog.rev(p2) p2rev = self.changelog.rev(p2)
msg = _("setting parent to node %s that only exists in the bundle\n") msg = _("setting parent to node %s that only exists in the bundle\n")
if self.changelog.repotiprev < p1rev: if self.changelog.repotiprev < p1rev:
self.ui.warn(msg % nodemod.hex(p1)) self.ui.warn(msg % nodemod.hex(p1))
if self.changelog.repotiprev < p2rev: if self.changelog.repotiprev < p2rev:
self.ui.warn(msg % nodemod.hex(p2)) self.ui.warn(msg % nodemod.hex(p2))
return super(bundlerepository, self).setparents(p1, p2) return super(bundlerepository, self).setparents(p1, p2)
def instance(ui, path, create, intents=None): def instance(ui, path, create, intents=None, createopts=None):
if create: if create:
raise error.Abort(_('cannot create new bundle repository')) raise error.Abort(_('cannot create new bundle repository'))
# internal config: bundle.mainreporoot # internal config: bundle.mainreporoot
parentpath = ui.config("bundle", "mainreporoot") parentpath = ui.config("bundle", "mainreporoot")
if not parentpath: if not parentpath:
# try to find the correct path to the working directory repo # try to find the correct path to the working directory repo
parentpath = cmdutil.findrepo(pycompat.getcwd()) parentpath = cmdutil.findrepo(pycompat.getcwd())
if parentpath is None: if parentpath is None:

mercurial/hg.py

return util.posixfile(pathurl.localpath(), 'rb') return util.posixfile(pathurl.localpath(), 'rb')
else: else:
return url.open(ui, path) return url.open(ui, path)
# a list of (ui, repo) functions called for wire peer initialization # a list of (ui, repo) functions called for wire peer initialization
wirepeersetupfuncs = [] wirepeersetupfuncs = []
def _peerorrepo(ui, path, create=False, presetupfuncs=None, def _peerorrepo(ui, path, create=False, presetupfuncs=None,
intents=None): intents=None, createopts=None):
"""return a repository object for the specified path""" """return a repository object for the specified path"""
obj = _peerlookup(path).instance(ui, path, create, intents=intents) obj = _peerlookup(path).instance(ui, path, create, intents=intents,
createopts=createopts)
ui = getattr(obj, "ui", ui) ui = getattr(obj, "ui", ui)
if ui.configbool('devel', 'debug.extensions'): if ui.configbool('devel', 'debug.extensions'):
log = lambda msg, *values: ui.debug('debug.extensions: ', log = lambda msg, *values: ui.debug('debug.extensions: ',
msg % values, label='debug.extensions') msg % values, label='debug.extensions')
else: else:
log = lambda *a, **kw: None log = lambda *a, **kw: None
for f in presetupfuncs or []: for f in presetupfuncs or []:
f(ui, obj) f(ui, obj)
log('- executing reposetup hooks\n') log('- executing reposetup hooks\n')
with util.timedcm('all reposetup') as allreposetupstats: with util.timedcm('all reposetup') as allreposetupstats:
for name, module in extensions.extensions(ui): for name, module in extensions.extensions(ui):
log(' - running reposetup for %s\n' % (name,)) log(' - running reposetup for %s\n' % (name,))
hook = getattr(module, 'reposetup', None) hook = getattr(module, 'reposetup', None)
if hook: if hook:
with util.timedcm('reposetup %r', name) as stats: with util.timedcm('reposetup %r', name) as stats:
hook(ui, obj) hook(ui, obj)
log(' > reposetup for %r took %s\n', name, stats) log(' > reposetup for %r took %s\n', name, stats)
log('> all reposetup took %s\n', allreposetupstats) log('> all reposetup took %s\n', allreposetupstats)
if not obj.local(): if not obj.local():
for f in wirepeersetupfuncs: for f in wirepeersetupfuncs:
f(ui, obj) f(ui, obj)
return obj return obj
def repository(ui, path='', create=False, presetupfuncs=None, intents=None): def repository(ui, path='', create=False, presetupfuncs=None, intents=None,
createopts=None):
"""return a repository object for the specified path""" """return a repository object for the specified path"""
peer = _peerorrepo(ui, path, create, presetupfuncs=presetupfuncs, peer = _peerorrepo(ui, path, create, presetupfuncs=presetupfuncs,
intents=intents) intents=intents, createopts=createopts)
repo = peer.local() repo = peer.local()
if not repo: if not repo:
raise error.Abort(_("repository '%s' is not local") % raise error.Abort(_("repository '%s' is not local") %
(path or peer.url())) (path or peer.url()))
return repo.filtered('visible') return repo.filtered('visible')
def peer(uiorrepo, opts, path, create=False, intents=None): def peer(uiorrepo, opts, path, create=False, intents=None, createopts=None):
'''return a repository peer for the specified path''' '''return a repository peer for the specified path'''
rui = remoteui(uiorrepo, opts) rui = remoteui(uiorrepo, opts)
return _peerorrepo(rui, path, create, intents=intents).peer() return _peerorrepo(rui, path, create, intents=intents,
createopts=createopts).peer()
def defaultdest(source): def defaultdest(source):
'''return default destination of clone if none is given '''return default destination of clone if none is given
>>> defaultdest(b'foo') >>> defaultdest(b'foo')
'foo' 'foo'
>>> defaultdest(b'/foo/bar') >>> defaultdest(b'/foo/bar')
'bar' 'bar'

mercurial/httppeer.py

return API_PEERS[service]['init'](ui, respurl, apipath, opener, return API_PEERS[service]['init'](ui, respurl, apipath, opener,
requestbuilder, requestbuilder,
info['apis'][service]) info['apis'][service])
# Failed to construct an API peer. Fall back to legacy. # Failed to construct an API peer. Fall back to legacy.
return httppeer(ui, path, respurl, opener, requestbuilder, return httppeer(ui, path, respurl, opener, requestbuilder,
info['v1capabilities']) info['v1capabilities'])
def instance(ui, path, create, intents=None): def instance(ui, path, create, intents=None, createopts=None):
if create: if create:
raise error.Abort(_('cannot create new http repository')) raise error.Abort(_('cannot create new http repository'))
try: try:
if path.startswith('https:') and not urlmod.has_https: if path.startswith('https:') and not urlmod.has_https:
raise error.Abort(_('Python support for SSL and HTTPS ' raise error.Abort(_('Python support for SSL and HTTPS '
'is not installed')) 'is not installed'))
inst = makepeer(ui, path) inst = makepeer(ui, path)

mercurial/localrepo.py

pass pass
return a return a
def undoname(fn): def undoname(fn):
base, name = os.path.split(fn) base, name = os.path.split(fn)
assert name.startswith('journal') assert name.startswith('journal')
return os.path.join(base, name.replace('journal', 'undo', 1)) return os.path.join(base, name.replace('journal', 'undo', 1))
def instance(ui, path, create, intents=None): def instance(ui, path, create, intents=None, createopts=None):
if create: if create:
vfs = vfsmod.vfs(path, expandpath=True, realpath=True) vfs = vfsmod.vfs(path, expandpath=True, realpath=True)
if vfs.exists('.hg'): if vfs.exists('.hg'):
raise error.RepoError(_('repository %s already exists') % path) raise error.RepoError(_('repository %s already exists') % path)
createrepository(ui, vfs) createrepository(ui, vfs, createopts=createopts)
return localrepository(ui, util.urllocalpath(path), intents=intents) return localrepository(ui, util.urllocalpath(path), intents=intents)
def islocal(path): def islocal(path):
return True return True
def newreporequirements(ui): def newreporequirements(ui, createopts=None):
"""Determine the set of requirements for a new local repository. """Determine the set of requirements for a new local repository.
Extensions can wrap this function to specify custom requirements for Extensions can wrap this function to specify custom requirements for
new repositories. new repositories.
""" """
createopts = createopts or {}
requirements = {'revlogv1'} requirements = {'revlogv1'}
if ui.configbool('format', 'usestore'): if ui.configbool('format', 'usestore'):
requirements.add('store') requirements.add('store')
if ui.configbool('format', 'usefncache'): if ui.configbool('format', 'usefncache'):
requirements.add('fncache') requirements.add('fncache')
if ui.configbool('format', 'dotencode'): if ui.configbool('format', 'dotencode'):
requirements.add('dotencode') requirements.add('dotencode')
requirements.discard('generaldelta') requirements.discard('generaldelta')
requirements.add(REVLOGV2_REQUIREMENT) requirements.add(REVLOGV2_REQUIREMENT)
# experimental config: format.internal-phase # experimental config: format.internal-phase
if ui.configbool('format', 'internal-phase'): if ui.configbool('format', 'internal-phase'):
requirements.add('internal-phase') requirements.add('internal-phase')
return requirements return requirements
def createrepository(ui, wdirvfs): def filterknowncreateopts(ui, createopts):
"""Filters a dict of repo creation options against options that are known.
Receives a dict of repo creation options and returns a dict of those
options that we don't know how to handle.
This function is called as part of repository creation. If the
returned dict contains any items, repository creation will not
be allowed, as it means there was a request to create a repository
with options not recognized by loaded code.
Extensions can wrap this function to filter out creation options
they know how to handle.
"""
return dict(createopts)
def createrepository(ui, wdirvfs, createopts=None):
"""Create a new repository in a vfs. """Create a new repository in a vfs.
``wdirvfs`` is a vfs instance pointing at the working directory. ``wdirvfs`` is a vfs instance pointing at the working directory.
``requirements`` is a set of requirements for the new repository. ``requirements`` is a set of requirements for the new repository.
""" """
requirements = newreporequirements(ui) createopts = createopts or {}
unknownopts = filterknowncreateopts(ui, createopts)
if not isinstance(unknownopts, dict):
raise error.ProgrammingError('filterknowncreateopts() did not return '
'a dict')
if unknownopts:
raise error.Abort(_('unable to create repository because of unknown '
'creation option: %s') %
', '.sorted(unknownopts),
hint=_('is a required extension not loaded?'))
requirements = newreporequirements(ui, createopts=createopts)
if not wdirvfs.exists(): if not wdirvfs.exists():
wdirvfs.makedirs() wdirvfs.makedirs()
hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg')) hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
hgvfs.makedir(notindexed=True) hgvfs.makedir(notindexed=True)
if b'store' in requirements: if b'store' in requirements:

mercurial/sshpeer.py

elif protoname == wireprototypes.SSHV2: elif protoname == wireprototypes.SSHV2:
return sshv2peer(ui, path, proc, stdin, stdout, stderr, caps, return sshv2peer(ui, path, proc, stdin, stdout, stderr, caps,
autoreadstderr=autoreadstderr) autoreadstderr=autoreadstderr)
else: else:
_cleanuppipes(ui, stdout, stdin, stderr) _cleanuppipes(ui, stdout, stdin, stderr)
raise error.RepoError(_('unknown version of SSH protocol: %s') % raise error.RepoError(_('unknown version of SSH protocol: %s') %
protoname) protoname)
def instance(ui, path, create, intents=None): def instance(ui, path, create, intents=None, createopts=None):
"""Create an SSH peer. """Create an SSH peer.
The returned object conforms to the ``wireprotov1peer.wirepeer`` interface. The returned object conforms to the ``wireprotov1peer.wirepeer`` interface.
""" """
u = util.url(path, parsequery=False, parsefragment=False) u = util.url(path, parsequery=False, parsefragment=False)
if u.scheme != 'ssh' or not u.host or u.path is None: if u.scheme != 'ssh' or not u.host or u.path is None:
raise error.RepoError(_("couldn't parse location %s") % path) raise error.RepoError(_("couldn't parse location %s") % path)
util.checksafessh(path) util.checksafessh(path)
if u.passwd is not None: if u.passwd is not None:
raise error.RepoError(_('password in URL not supported')) raise error.RepoError(_('password in URL not supported'))
sshcmd = ui.config('ui', 'ssh') sshcmd = ui.config('ui', 'ssh')
remotecmd = ui.config('ui', 'remotecmd') remotecmd = ui.config('ui', 'remotecmd')
sshaddenv = dict(ui.configitems('sshenv')) sshaddenv = dict(ui.configitems('sshenv'))
sshenv = procutil.shellenviron(sshaddenv) sshenv = procutil.shellenviron(sshaddenv)
remotepath = u.path or '.' remotepath = u.path or '.'
args = procutil.sshargs(sshcmd, u.host, u.user, u.port) args = procutil.sshargs(sshcmd, u.host, u.user, u.port)
if create: if create:
# We /could/ do this, but only if the remote init command knows how to
# handle them. We don't yet make any assumptions about that. And without
# querying the remote, there's no way of knowing if the remote even
# supports said requested feature.
if createopts:
raise error.RepoError(_('cannot create remote SSH repositories '
'with extra options'))
cmd = '%s %s %s' % (sshcmd, args, cmd = '%s %s %s' % (sshcmd, args,
procutil.shellquote('%s init %s' % procutil.shellquote('%s init %s' %
(_serverquote(remotecmd), _serverquote(remotepath)))) (_serverquote(remotecmd), _serverquote(remotepath))))
ui.debug('running %s\n' % cmd) ui.debug('running %s\n' % cmd)
res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv) res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv)
if res != 0: if res != 0:
raise error.RepoError(_('could not create remote repo')) raise error.RepoError(_('could not create remote repo'))

mercurial/statichttprepo.py

_('cannot lock static-http repository')) _('cannot lock static-http repository'))
def lock(self, wait=True): def lock(self, wait=True):
raise error.Abort(_('cannot lock static-http repository')) raise error.Abort(_('cannot lock static-http repository'))
def _writecaches(self): def _writecaches(self):
pass # statichttprepository are read only pass # statichttprepository are read only
def instance(ui, path, create, intents=None): def instance(ui, path, create, intents=None, createopts=None):
if create: if create:
raise error.Abort(_('cannot create new static-http repository')) raise error.Abort(_('cannot create new static-http repository'))
return statichttprepository(ui, path[7:]) return statichttprepository(ui, path[7:])

mercurial/unionrepo.py

return False return False
def peer(self): def peer(self):
return unionpeer(self) return unionpeer(self)
def getcwd(self): def getcwd(self):
return pycompat.getcwd() # always outside the repo return pycompat.getcwd() # always outside the repo
def instance(ui, path, create, intents=None): def instance(ui, path, create, intents=None, createopts=None):
if create: if create:
raise error.Abort(_('cannot create new union repository')) raise error.Abort(_('cannot create new union repository'))
parentpath = ui.config("bundle", "mainreporoot") parentpath = ui.config("bundle", "mainreporoot")
if not parentpath: if not parentpath:
# try to find the correct path to the working directory repo # try to find the correct path to the working directory repo
parentpath = cmdutil.findrepo(pycompat.getcwd()) parentpath = cmdutil.findrepo(pycompat.getcwd())
if parentpath is None: if parentpath is None:
parentpath = '' parentpath = ''