comparison mercurial/localrepo.py @ 39711:cb2dcfa5cade

localrepo: move requirements reasonability testing to own function

Just because we know how to handle each listed requirement doesn't
mean that set of requirements is reasonable.

This commit introduces an extension-wrappable function to validate
that a set of requirements makes sense.

We could combine this with ensurerequirementsrecognized(). But I think
having a line between basic membership testing and compatibility
checking is more powerful as it will help differentiate between
missing support and buggy behavior.

Differential Revision: https://phab.mercurial-scm.org/D4571

39710:6192980553b4

        pass
    else:
        extensions.loadall(ui)

    supportedrequirements = gathersupportedrequirements(ui)
    ensurerequirementsrecognized(requirements, supportedrequirements)

    # At this point, we know we should be capable of opening the repository.
    # Now get on with doing that.

    return localrepository(

        raise error.RequirementError(
            _(b'repository requires features unknown to this Mercurial: %s') %
            b' '.join(sorted(missing)),
            hint=_(b'see https://mercurial-scm.org/wiki/MissingRequirement '
                   b'for more information'))

@interfaceutil.implementer(repository.completelocalrepository)
class localrepository(object):

    # obsolete experimental requirements:

                    _('.hg/sharedpath points to nonexistent directory %s') % s)
            self.sharedpath = s
        except IOError as inst:
            if inst.errno != errno.ENOENT:
                raise

        if 'exp-sparse' in self.requirements and not sparse.enabled:
            raise error.RepoError(_('repository is using sparse feature but '
                                    'sparse is not enabled; enable the '
                                    '"sparse" extensions to access'))

        self.store = store.store(
            self.requirements, self.sharedpath,
            lambda base: vfsmod.vfs(base, cacheaudited=True))
        self.spath = self.store.path

39711:cb2dcfa5cade

        pass
    else:
        extensions.loadall(ui)

    supportedrequirements = gathersupportedrequirements(ui)

    # We first validate the requirements are known.
    ensurerequirementsrecognized(requirements, supportedrequirements)

    # Then we validate that the known set is reasonable to use together.
    ensurerequirementscompatible(ui, requirements)

    # At this point, we know we should be capable of opening the repository.
    # Now get on with doing that.

    return localrepository(

        raise error.RequirementError(
            _(b'repository requires features unknown to this Mercurial: %s') %
            b' '.join(sorted(missing)),
            hint=_(b'see https://mercurial-scm.org/wiki/MissingRequirement '
                   b'for more information'))

def ensurerequirementscompatible(ui, requirements):
    """Validates that a set of recognized requirements is mutually compatible.

    Some requirements may not be compatible with others or require
    config options that aren't enabled. This function is called during
    repository opening to ensure that the set of requirements needed
    to open a repository is sane and compatible with config options.

    Extensions can monkeypatch this function to perform additional
    checking.

    ``error.RepoError`` should be raised on failure.
    """
    if b'exp-sparse' in requirements and not sparse.enabled:
        raise error.RepoError(_(b'repository is using sparse feature but '
                                b'sparse is not enabled; enable the '
                                b'"sparse" extensions to access'))

@interfaceutil.implementer(repository.completelocalrepository)
class localrepository(object):

    # obsolete experimental requirements:

                    _('.hg/sharedpath points to nonexistent directory %s') % s)
            self.sharedpath = s
        except IOError as inst:
            if inst.errno != errno.ENOENT:
                raise

        self.store = store.store(
            self.requirements, self.sharedpath,
            lambda base: vfsmod.vfs(base, cacheaudited=True))
        self.spath = self.store.path