This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4707

localrepo: support shared repo creation
ClosedPublic

Authored by indygreg on Sep 24 2018, 12:12 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG4ece3cdfd907: localrepo: support shared repo creation
Summary

Previously, hg.share() had its own logic for creating a new
repository on the filesystem.

With the recent introduction of the createopts dict for passing
options to influence repository creation, it is now possible
to consolidate the repo creation code for both the normal and
shared use cases.

This commit teaches the repo creation code in localrepo to
recognize when we're creating a shared repo and to act
appropriately.

Meaningful behavior should be identical. However, there are a
few subtle changes:

  • The .hg/requires file is written out in sorted order (rather than having share-related requirements appended at end).
  • The .hg directory is created with notindexed=True when a shared repo is being created.

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 24 2018, 12:12 PM
Closed by commit rHG4ece3cdfd907: localrepo: support shared repo creation (authored by indygreg). · Explain WhySep 26 2018, 1:23 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/hg.py (43 lines)
Mmercurial/localrepo.py (46 lines)
Mtests/test-share.t (2 lines)

Diff 11379

mercurial/hg.py

ui as uimod, ui as uimod,
unionrepo, unionrepo,
url, url,
util, util,
verify as verifymod, verify as verifymod,
vfs as vfsmod, vfs as vfsmod,
) )
from .utils import (
stringutil,
)
release = lock.release release = lock.release
# shared features # shared features
sharedbookmarks = 'bookmarks' sharedbookmarks = 'bookmarks'
def _local(path): def _local(path):
path = util.expandpath(util.urllocalpath(path)) path = util.expandpath(util.urllocalpath(path))
return (os.path.isfile(path) and bundlerepo or localrepo) return (os.path.isfile(path) and bundlerepo or localrepo)
if isinstance(source, bytes): if isinstance(source, bytes):
origsource = ui.expandpath(source) origsource = ui.expandpath(source)
source, branches = parseurl(origsource) source, branches = parseurl(origsource)
srcrepo = repository(ui, source) srcrepo = repository(ui, source)
rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None) rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None)
else: else:
srcrepo = source.local() srcrepo = source.local()
origsource = source = srcrepo.url()
checkout = None checkout = None
sharedpath = srcrepo.sharedpath # if our source is already sharing r = repository(ui, dest, create=True, createopts={
'sharedrepo': srcrepo,
destwvfs = vfsmod.vfs(dest, realpath=True) 'sharedrelative': relative,
destvfs = vfsmod.vfs(os.path.join(destwvfs.base, '.hg'), realpath=True) })
if destvfs.lexists():
raise error.Abort(_('destination already exists'))
if not destwvfs.isdir():
destwvfs.makedirs()
destvfs.makedir()
requirements = ''
try:
requirements = srcrepo.vfs.read('requires')
except IOError as inst:
if inst.errno != errno.ENOENT:
raise
if relative:
try:
sharedpath = os.path.relpath(sharedpath, destvfs.base)
requirements += 'relshared\n'
except (IOError, ValueError) as e:
# ValueError is raised on Windows if the drive letters differ on
# each path
raise error.Abort(_('cannot calculate relative path'),
hint=stringutil.forcebytestr(e))
else:
requirements += 'shared\n'
destvfs.write('requires', requirements)
destvfs.write('sharedpath', sharedpath)
r = repository(ui, destwvfs.base)
postshare(srcrepo, r, bookmarks=bookmarks, defaultpath=defaultpath) postshare(srcrepo, r, bookmarks=bookmarks, defaultpath=defaultpath)
_postshareupdate(r, update, checkout=checkout) _postshareupdate(r, update, checkout=checkout)
return r return r
def unshare(ui, repo): def unshare(ui, repo):
"""convert a shared repository to a normal one """convert a shared repository to a normal one
Copy the store data to the repo and remove the sharedpath data. Copy the store data to the repo and remove the sharedpath data.

mercurial/localrepo.py

def newreporequirements(ui, createopts=None): 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 {} createopts = createopts or {}
# If the repo is being created from a shared repository, we copy
# its requirements.
if 'sharedrepo' in createopts:
requirements = set(createopts['sharedrepo'].requirements)
if createopts.get('sharedrelative'):
requirements.add('relshared')
else:
requirements.add('shared')
return requirements
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')
This function is called as part of repository creation. If the This function is called as part of repository creation. If the
returned dict contains any items, repository creation will not returned dict contains any items, repository creation will not
be allowed, as it means there was a request to create a repository be allowed, as it means there was a request to create a repository
with options not recognized by loaded code. with options not recognized by loaded code.
Extensions can wrap this function to filter out creation options Extensions can wrap this function to filter out creation options
they know how to handle. they know how to handle.
""" """
known = {'narrowfiles'} known = {
'narrowfiles',
'sharedrepo',
'sharedrelative',
}
return {k: v for k, v in createopts.items() if k not in known} return {k: v for k, v in createopts.items() if k not in known}
def createrepository(ui, path, createopts=None): def createrepository(ui, path, createopts=None):
"""Create a new repository in a vfs. """Create a new repository in a vfs.
``path`` path to the new repo's working directory. ``path`` path to the new repo's working directory.
``createopts`` options for the new repository. ``createopts`` options for the new repository.
The following keys for ``createopts`` are recognized:
narrowfiles
Set up repository to support narrow file storage.
sharedrepo
Repository object from which storage should be shared.
sharedrelative
Boolean indicating if the path to the shared repo should be
stored as relative. By default, the pointer to the "parent" repo
is stored as an absolute path.
""" """
createopts = createopts or {} createopts = createopts or {}
unknownopts = filterknowncreateopts(ui, createopts) unknownopts = filterknowncreateopts(ui, createopts)
if not isinstance(unknownopts, dict): if not isinstance(unknownopts, dict):
raise error.ProgrammingError('filterknowncreateopts() did not return ' raise error.ProgrammingError('filterknowncreateopts() did not return '
'a dict') 'a dict')
if unknownopts: if unknownopts:
raise error.Abort(_('unable to create repository because of unknown ' raise error.Abort(_('unable to create repository because of unknown '
'creation option: %s') % 'creation option: %s') %
', '.join(sorted(unknownopts)), ', '.join(sorted(unknownopts)),
hint=_('is a required extension not loaded?')) hint=_('is a required extension not loaded?'))
requirements = newreporequirements(ui, createopts=createopts) requirements = newreporequirements(ui, createopts=createopts)
wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True) wdirvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg')) hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
if hgvfs.exists(): if hgvfs.exists():
raise error.RepoError(_('repository %s already exists') % path) raise error.RepoError(_('repository %s already exists') % path)
if 'sharedrepo' in createopts:
sharedpath = createopts['sharedrepo'].sharedpath
if createopts.get('sharedrelative'):
try:
sharedpath = os.path.relpath(sharedpath, hgvfs.base)
except (IOError, ValueError) as e:
# ValueError is raised on Windows if the drive letters differ
# on each path.
raise error.Abort(_('cannot calculate relative path'),
hint=stringutil.forcebytestr(e))
if not wdirvfs.exists(): if not wdirvfs.exists():
wdirvfs.makedirs() wdirvfs.makedirs()
hgvfs.makedir(notindexed=True) hgvfs.makedir(notindexed=True)
if b'store' in requirements: if b'store' in requirements and 'sharedrepo' not in createopts:
hgvfs.mkdir(b'store') hgvfs.mkdir(b'store')
# We create an invalid changelog outside the store so very old # We create an invalid changelog outside the store so very old
# Mercurial versions (which didn't know about the requirements # Mercurial versions (which didn't know about the requirements
# file) encounter an error on reading the changelog. This # file) encounter an error on reading the changelog. This
# effectively locks out old clients and prevents them from # effectively locks out old clients and prevents them from
# mucking with a repo in an unknown format. # mucking with a repo in an unknown format.
# #
# The revlog header has version 2, which won't be recognized by # The revlog header has version 2, which won't be recognized by
# such old clients. # such old clients.
hgvfs.append(b'00changelog.i', hgvfs.append(b'00changelog.i',
b'\0\0\0\2 dummy changelog to prevent using the old repo ' b'\0\0\0\2 dummy changelog to prevent using the old repo '
b'layout') b'layout')
scmutil.writerequires(hgvfs, requirements) scmutil.writerequires(hgvfs, requirements)
# Write out file telling readers where to find the shared store.
if 'sharedrepo' in createopts:
hgvfs.write(b'sharedpath', sharedpath)
def poisonrepository(repo): def poisonrepository(repo):
"""Poison a repository instance so it can no longer be used.""" """Poison a repository instance so it can no longer be used."""
# Perform any cleanup on the instance. # Perform any cleanup on the instance.
repo.close() repo.close()
# Our strategy is to replace the type of the object with one that # Our strategy is to replace the type of the object with one that
# has all attribute lookups result in error. # has all attribute lookups result in error.
# #

tests/test-share.t

$ mkdir thisdir $ mkdir thisdir
$ hg init thisdir/orig $ hg init thisdir/orig
$ hg share -U thisdir/orig thisdir/abs $ hg share -U thisdir/orig thisdir/abs
$ hg share -U --relative thisdir/abs thisdir/rel $ hg share -U --relative thisdir/abs thisdir/rel
$ cat thisdir/rel/.hg/sharedpath $ cat thisdir/rel/.hg/sharedpath
../../orig/.hg (no-eol) ../../orig/.hg (no-eol)
$ grep shared thisdir/*/.hg/requires $ grep shared thisdir/*/.hg/requires
thisdir/abs/.hg/requires:shared thisdir/abs/.hg/requires:shared
thisdir/rel/.hg/requires:shared
thisdir/rel/.hg/requires:relshared thisdir/rel/.hg/requires:relshared
thisdir/rel/.hg/requires:shared
test that relative shared paths aren't relative to $PWD test that relative shared paths aren't relative to $PWD
$ cd thisdir $ cd thisdir
$ hg -R rel root $ hg -R rel root
$TESTTMP/thisdir/rel $TESTTMP/thisdir/rel
$ cd .. $ cd ..