This is an archive of the discontinued Mercurial Phabricator instance.

Differential D4555

bundlerepo: dynamically create repository type from base repository
ClosedPublic

Authored by indygreg on Sep 12 2018, 10:02 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG335ae4d0a552: bundlerepo: dynamically create repository type from base repository
Summary

Previously, bundlerepository inherited from localrepo.localrepository.
You simply instantiated a bundlerepository and its init called
localrepo.localrepository.init. Things were simple.

Unfortunately, this strategy is limiting because it assumes that
the base repository is a localrepository instance. And it assumes
various properties of localrepository, such as the arguments its
init takes. And it prevents us from changing behavior of
localrepository.init without also having to change derived classes.

Previous and ongoing work to abstract storage revealed these
limitations.

This commit changes the initialization strategy of bundle repositories
to dynamically create a type to represent the repository. Instead of
a static type, we instantiate a new local repo instance via
localrepo.instance(). We then combine its class with
bundlerepository to produce a new type. This ensures that no matter
how localrepo.instance() decides to create a repository object, we
can derive a bundle repo object from it. i.e. localrepo.instance()
could return a type that isn't a localrepository and it would "just
work."

Well, it would "just work" if bundlerepository's custom implementations
only accessed attributes in the documented repository interface. I'm
pretty sure it violates the interface contract in a handful of
places. But we can worry about that another day. This change gets us
closer to doing more clever things around instantiating repository
instances without having to worry about teaching bundlerepository about
them.

.. api::

``bundlerepo.bundlerepository`` is no longer usable on its own.

The class is combined with the class of the base repository it is
associated with at run-time.

New bundlerepository instances can be obtained by calling
``bundlerepo.instance()`` or ``bundlerepo.makebundlerepository()``.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Revision Contents
Changeset List

PathPackages
Mmercurial/bundlerepo.py (62 lines)

Diff 10987

mercurial/bundlerepo.py

filespos = {} filespos = {}
for chunkdata in iter(cgunpacker.filelogheader, {}): for chunkdata in iter(cgunpacker.filelogheader, {}):
fname = chunkdata['filename'] fname = chunkdata['filename']
filespos[fname] = cgunpacker.tell() filespos[fname] = cgunpacker.tell()
for chunk in iter(lambda: cgunpacker.deltachunk(None), {}): for chunk in iter(lambda: cgunpacker.deltachunk(None), {}):
pass pass
return filespos return filespos
class bundlerepository(localrepo.localrepository): class bundlerepository(object):
"""A repository instance that is a union of a local repo and a bundle. """A repository instance that is a union of a local repo and a bundle.
Instances represent a read-only repository composed of a local repository Instances represent a read-only repository composed of a local repository
with the contents of a bundle file applied. The repository instance is with the contents of a bundle file applied. The repository instance is
conceptually similar to the state of a repository after an conceptually similar to the state of a repository after an
``hg unbundle`` operation. However, the contents of the bundle are never ``hg unbundle`` operation. However, the contents of the bundle are never
applied to the actual base repository. applied to the actual base repository.
Instances constructed directly are not usable as repository objects.
Use instance() or makebundlerepository() to create instances.
""" """
def __init__(self, ui, repopath, bundlepath): def __init__(self, bundlepath, url, tempparent):
self._tempparent = None self._tempparent = tempparent
try: self._url = url
localrepo.localrepository.__init__(self, ui, repopath)
except error.RepoError:
self._tempparent = pycompat.mkdtemp()
localrepo.instance(ui, self._tempparent, create=True)
localrepo.localrepository.__init__(self, ui, self._tempparent)
self.ui.setconfig('phases', 'publish', False, 'bundlerepo')
if repopath: self.ui.setconfig('phases', 'publish', False, 'bundlerepo')
self._url = 'bundle:' + util.expandpath(repopath) + '+' + bundlepath
else:
self._url = 'bundle:' + bundlepath
self.tempfile = None self.tempfile = None
f = util.posixfile(bundlepath, "rb") f = util.posixfile(bundlepath, "rb")
bundle = exchange.readbundle(ui, f, bundlepath) bundle = exchange.readbundle(self.ui, f, bundlepath)
if isinstance(bundle, bundle2.unbundle20): if isinstance(bundle, bundle2.unbundle20):
self._bundlefile = bundle self._bundlefile = bundle
self._cgunpacker = None self._cgunpacker = None
cgpart = None cgpart = None
for part in bundle.iterparts(seekable=True): for part in bundle.iterparts(seekable=True):
if part.type == 'changegroup': if part.type == 'changegroup':
# because iterparts() will seek to end of payload after the # because iterparts() will seek to end of payload after the
# generator returns control to iterparts(). # generator returns control to iterparts().
cgpart.seek(0, os.SEEK_SET) cgpart.seek(0, os.SEEK_SET)
elif isinstance(bundle, changegroup.cg1unpacker): elif isinstance(bundle, changegroup.cg1unpacker):
if bundle.compressed(): if bundle.compressed():
f = self._writetempbundle(bundle.read, '.hg10un', f = self._writetempbundle(bundle.read, '.hg10un',
header='HG10UN') header='HG10UN')
bundle = exchange.readbundle(ui, f, bundlepath, self.vfs) bundle = exchange.readbundle(self.ui, f, bundlepath, self.vfs)
self._bundlefile = bundle self._bundlefile = bundle
self._cgunpacker = bundle self._cgunpacker = bundle
else: else:
raise error.Abort(_('bundle type %s cannot be read') % raise error.Abort(_('bundle type %s cannot be read') %
type(bundle)) type(bundle))
# dict with the mapping 'filename' -> position in the changegroup. # dict with the mapping 'filename' -> position in the changegroup.
repopath, bundlename = s repopath, bundlename = s
else: else:
repopath, bundlename = parentpath, path repopath, bundlename = parentpath, path
return makebundlerepository(ui, repopath, bundlename) return makebundlerepository(ui, repopath, bundlename)
def makebundlerepository(ui, repopath, bundlepath): def makebundlerepository(ui, repopath, bundlepath):
"""Make a bundle repository object based on repo and bundle paths.""" """Make a bundle repository object based on repo and bundle paths."""
return bundlerepository(ui, repopath, bundlepath) if repopath:
url = 'bundle:%s+%s' % (util.expandpath(repopath), bundlepath)
else:
url = 'bundle:%s' % bundlepath
# Because we can't make any guarantees about the type of the base
# repository, we can't have a static class representing the bundle
# repository. We also can't make any guarantees about how to even
# call the base repository's constructor!
#
# So, our strategy is to go through ``localrepo.instance()`` to construct
# a repo instance. Then, we dynamically create a new type derived from
# both it and our ``bundlerepository`` class which overrides some
# functionality. We then change the type of the constructed repository
# to this new type and initialize the bundle-specific bits of it.
try:
parentrepo = localrepo.instance(ui, repopath, create=False)
tempparent = None
except error.RepoError:
tempparent = pycompat.mkdtemp()
try:
parentrepo = localrepo.instance(ui, tempparent, create=True)
except Exception:
shutil.rmtree(tempparent)
raise
class derivedbundlerepository(bundlerepository, parentrepo.__class__):
pass
repo = parentrepo
repo.__class__ = derivedbundlerepository
bundlerepository.__init__(repo, bundlepath, url, tempparent)
return repo
class bundletransactionmanager(object): class bundletransactionmanager(object):
def transaction(self): def transaction(self):
return None return None
def close(self): def close(self):
raise NotImplementedError raise NotImplementedError