This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4534

localrepo: move repo creation logic out of localrepository.__init__
ClosedPublic

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

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG7ce9dea3a14a: localrepo: move repo creation logic out of localrepository.__init__ (API)
Summary

It has long bothered me that local repository creation is handled as
part of localrepository.init. Upcoming changes I want to make
around how repositories are initialized and instantiated will make
the continued existence of repository creation code in
localrepository.init even more awkward.

localrepository instances are almost never constructed directly:
instead, callers are supposed to go through hg.repository() to obtain
a handle on a repository. And hg.repository() calls
localrepo.instance() to return a new repo instance.

This commit teaches localrepo.instance() to handle the create=True
logic. Most of the code for repo construction has been moved to a
standalone function. This allows extensions to monkeypatch the function
to further customize freshly-created repositories.

A few calls to localrepo.localrepository.init that were passing
create=True were converted to call localrepo.instance().

.. api:: local repo creation moved out of constructor

``localrepo.localrepository.__init__`` no longer accepts a
``create`` argument to create a new repository. New repository
creation is now performed as part of ``localrepo.instance()``
and the bulk of the work is performed by
``localrepo.createrepository()``.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mhgext/keyword.py (2 lines)
Mmercurial/localrepo.py (83 lines)
Mtests/test-status-inprocess.py (2 lines)

Diff 10911

hgext/keyword.py

fn = 'demo.txt' fn = 'demo.txt'
tmpdir = pycompat.mkdtemp('', 'kwdemo.') tmpdir = pycompat.mkdtemp('', 'kwdemo.')
ui.note(_('creating temporary repository at %s\n') % tmpdir) ui.note(_('creating temporary repository at %s\n') % tmpdir)
if repo is None: if repo is None:
baseui = ui baseui = ui
else: else:
baseui = repo.baseui baseui = repo.baseui
repo = localrepo.localrepository(baseui, tmpdir, True) repo = localrepo.instance(baseui, tmpdir, create=True)
ui.setconfig('keyword', fn, '', 'keyword') ui.setconfig('keyword', fn, '', 'keyword')
svn = ui.configbool('keywordset', 'svn') svn = ui.configbool('keywordset', 'svn')
# explicitly set keywordset for demo output # explicitly set keywordset for demo output
ui.setconfig('keywordset', 'svn', svn, 'keyword') ui.setconfig('keywordset', 'svn', svn, 'keyword')
uikwmaps = ui.configitems('keywordmaps') uikwmaps = ui.configitems('keywordmaps')
if args or opts.get(r'rcfile'): if args or opts.get(r'rcfile'):
ui.status(_('\n\tconfiguration using custom keyword template maps\n')) ui.status(_('\n\tconfiguration using custom keyword template maps\n'))

mercurial/localrepo.py

# XXX shouldn't be dirstate covered by the wlock? # XXX shouldn't be dirstate covered by the wlock?
'dirstate', 'dirstate',
# XXX bisect was still a bit too messy at the time # XXX bisect was still a bit too messy at the time
# this changeset was introduced. Someone should fix # this changeset was introduced. Someone should fix
# the remainig bit and drop this line # the remainig bit and drop this line
'bisect.state', 'bisect.state',
} }
def __init__(self, baseui, path, create=False, intents=None): def __init__(self, baseui, path, intents=None):
"""Create a new local repository instance.
Most callers should use ``hg.repository()`` or ``localrepo.instance()``
for obtaining a new repository object.
"""
self.requirements = set() self.requirements = set()
self.filtername = None self.filtername = None
# wvfs: rooted at the repository root, used to access the working copy # wvfs: rooted at the repository root, used to access the working copy
self.wvfs = vfsmod.vfs(path, expandpath=True, realpath=True) self.wvfs = vfsmod.vfs(path, expandpath=True, realpath=True)
# vfs: rooted at .hg, used to access repo files outside of .hg/store # vfs: rooted at .hg, used to access repo files outside of .hg/store
self.vfs = None self.vfs = None
# svfs: usually rooted at .hg/store, used to access repository history # svfs: usually rooted at .hg/store, used to access repository history
# If this is a shared repository, this vfs may point to another # If this is a shared repository, this vfs may point to another
# Add compression engines. # Add compression engines.
for name in util.compengines: for name in util.compengines:
engine = util.compengines[name] engine = util.compengines[name]
if engine.revlogheader(): if engine.revlogheader():
self.supported.add('exp-compression-%s' % name) self.supported.add('exp-compression-%s' % name)
if not self.vfs.isdir(): if not self.vfs.isdir():
if create:
self.requirements = newreporequirements(self.ui)
if not self.wvfs.exists():
self.wvfs.makedirs()
self.vfs.makedir(notindexed=True)
if 'store' in self.requirements:
self.vfs.mkdir("store")
# create an invalid changelog
self.vfs.append(
"00changelog.i",
'\0\0\0\2' # represents revlogv2
' dummy changelog to prevent using the old repo layout'
)
else:
try: try:
self.vfs.stat() self.vfs.stat()
except OSError as inst: except OSError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
raise raise
raise error.RepoError(_("repository %s not found") % path) raise error.RepoError(_("repository %s not found") % path)
elif create:
raise error.RepoError(_("repository %s already exists") % path)
else: else:
try: try:
self.requirements = scmutil.readrequires( self.requirements = scmutil.readrequires(
self.vfs, self.supported) self.vfs, self.supported)
except IOError as inst: except IOError as inst:
if inst.errno != errno.ENOENT: if inst.errno != errno.ENOENT:
raise raise
self.cachevfs.createmode = self.store.createmode self.cachevfs.createmode = self.store.createmode
if (self.ui.configbool('devel', 'all-warnings') or if (self.ui.configbool('devel', 'all-warnings') or
self.ui.configbool('devel', 'check-locks')): self.ui.configbool('devel', 'check-locks')):
if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs if util.safehasattr(self.svfs, 'vfs'): # this is filtervfs
self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit) self.svfs.vfs.audit = self._getsvfsward(self.svfs.vfs.audit)
else: # standard vfs else: # standard vfs
self.svfs.audit = self._getsvfsward(self.svfs.audit) self.svfs.audit = self._getsvfsward(self.svfs.audit)
self._applyopenerreqs() self._applyopenerreqs()
if create:
self._writerequirements()
self._dirstatevalidatewarned = False self._dirstatevalidatewarned = False
self._branchcaches = {} self._branchcaches = {}
self._revbranchcache = None self._revbranchcache = None
self._filterpats = {} self._filterpats = {}
self._datafilters = {} self._datafilters = {}
self._transref = self._lockref = self._wlockref = None self._transref = self._lockref = self._wlockref = None
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):
return localrepository(ui, util.urllocalpath(path), create, if create:
intents=intents) vfs = vfsmod.vfs(path, expandpath=True, realpath=True)
if vfs.exists('.hg'):
raise error.RepoError(_('repository %s already exists') % path)
createrepository(ui, vfs)
return localrepository(ui, util.urllocalpath(path), intents=intents)
def islocal(path): def islocal(path):
return True return True
def newreporequirements(ui): def newreporequirements(ui):
"""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
# generaldelta is implied by revlogv2. # generaldelta is implied by revlogv2.
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):
"""Create a new repository in a vfs.
``wdirvfs`` is a vfs instance pointing at the working directory.
``requirements`` is a set of requirements for the new repository.
"""
requirements = newreporequirements(ui)
if not wdirvfs.exists():
wdirvfs.makedirs()
hgvfs = vfsmod.vfs(wdirvfs.join(b'.hg'))
hgvfs.makedir(notindexed=True)
if b'store' in requirements:
hgvfs.mkdir(b'store')
# We create an invalid changelog outside the store so very old
# Mercurial versions (which didn't know about the requirements
# file) encounter an error on reading the changelog. This
# effectively locks out old clients and prevents them from
# mucking with a repo in an unknown format.
#
# The revlog header has version 2, which won't be recognized by
# such old clients.
hgvfs.append(b'00changelog.i',
b'\0\0\0\2 dummy changelog to prevent using the old repo '
b'layout')
scmutil.writerequires(hgvfs, requirements)

tests/test-status-inprocess.py

ui object will, but this was easier for porting the test. ui object will, but this was easier for porting the test.
""" """
print_(*args, **kwargs) print_(*args, **kwargs)
sys.stdout.flush() sys.stdout.flush()
u = uimod.ui.load() u = uimod.ui.load()
print('% creating repo') print('% creating repo')
repo = localrepo.localrepository(u, b'.', create=True) repo = localrepo.instance(u, b'.', create=True)
f = open('test.py', 'w') f = open('test.py', 'w')
try: try:
f.write('foo\n') f.write('foo\n')
finally: finally:
f.close f.close
print('% add and commit') print('% add and commit')