repository: define interface for local repositories Per discussions on the mailing list and at the 4.4 and 4.6 sprints, we want to start defining interfaces for local repository primitives so that we a) have a better idea of what the formal interface for various types is b) can more easily introduce alternate implementations of various components (e.g. in Rust). We have previously implemented interfaces that declare the peer and wire protocol APIs using the abc module. This commit introduces a monolithic interface for the localrepository class. It uses zope.interface - not abc - for defining and declaring the interface. The newly defined "completelocalrepository" interface is objectively horrible. It is based on what is actually in localrepository and doesn't represent a reasonable interface definition IMO. There's lots of... unwanted garbage in the interface. In other words, it reflects the horrible state of the localrepository "god object." But this is fine: a goal of this commit is to get the interface defined so that we have an interface. Future commits can refactor the interface into sub-interfaces, remove unwanted public attributes, etc. I attempted to define reasonable docstrings for the various interface members. But there are so many of them and I didn't know what some are used for. So I was lazy in a number of places and didn't write docstrings or detailed usage docs. Also, the members of the interface are defined in the order they are declared in localrepo.py. This revealed that the grouping of things in localrepo.py is... odd. The localrepository class now declares that it implements our newly defined interface. Unlike abc, zope.interface doesn't check interface conformance at type creation time (abc uses __metaclass__ magic to validate interface conformance when a type is created - usually at module import time). It does provide some functions for validating class and object conformance with declared interfaces. We add these checks to test-check-interfaces.py. We /could/ validate at run-time. But we hold off for now. (I'm a bit scared of doing that because of the various ways extensions monkeypatch repo instances.) After this commit, test-check-interfaces.py will fail if the set of public attributes on the localrepository class or instances change without corresponding updates to the interface. This is by design. Differential Revision: https://phab.mercurial-scm.org/D2933

     1

# Test that certain objects conform to well-defined interfaces.

     2

     3

from __future__ import absolute_import, print_function

     4

     5

import os

     6

     7

from mercurial.thirdparty.zope import (

     8

    interface as zi,

     9

)

    10

from mercurial.thirdparty.zope.interface import (

    11

    verify as ziverify,

    12

)

    13

from mercurial import (

    14

    bundlerepo,

    15

    httppeer,

    16

    localrepo,

    17

    repository,

    18

    sshpeer,

    19

    statichttprepo,

    20

    ui as uimod,

    21

    unionrepo,

    22

)

    23

    24

rootdir = os.path.normpath(os.path.join(os.path.dirname(__file__), '..'))

    25

    26

def checkobject(o):

    27

    """Verify a constructed object conforms to interface rules.

    28

    29

    An object must have __abstractmethods__ defined.

    30

    31

    All "public" attributes of the object (attributes not prefixed with

    32

    an underscore) must be in __abstractmethods__ or appear on a base class

    33

    with __abstractmethods__.

    34

    """

    35

    name = o.__class__.__name__

    36

    37

    allowed = set()

    38

    for cls in o.__class__.__mro__:

    39

        if not getattr(cls, '__abstractmethods__', set()):

    40

            continue

    41

    42

        allowed |= cls.__abstractmethods__

    43

        allowed |= {a for a in dir(cls) if not a.startswith('_')}

    44

    45

    if not allowed:

    46

        print('%s does not have abstract methods' % name)

    47

        return

    48

    49

    public = {a for a in dir(o) if not a.startswith('_')}

    50

    51

    for attr in sorted(public - allowed):

    52

        print('public attributes not in abstract interface: %s.%s' % (

    53

            name, attr))

    54

    55

def checkzobject(o):

    56

    """Verify an object with a zope interface."""

    57

    ifaces = zi.providedBy(o)

    58

    if not ifaces:

    59

        print('%r does not provide any zope interfaces' % o)

    60

        return

    61

    62

    # Run zope.interface's built-in verification routine. This verifies that

    63

    # everything that is supposed to be present is present.

    64

    for iface in ifaces:

    65

        ziverify.verifyObject(iface, o)

    66

    67

    # Now verify that the object provides no extra public attributes that

    68

    # aren't declared as part of interfaces.

    69

    allowed = set()

    70

    for iface in ifaces:

    71

        allowed |= set(iface.names(all=True))

    72

    73

    public = {a for a in dir(o) if not a.startswith('_')}

    74

    75

    for attr in sorted(public - allowed):

    76

        print('public attribute not declared in interfaces: %s.%s' % (

    77

            o.__class__.__name__, attr))

    78

    79

# Facilitates testing localpeer.

    80

class dummyrepo(object):

    81

    def __init__(self):

    82

        self.ui = uimod.ui()

    83

    def filtered(self, name):

    84

        pass

    85

    def _restrictcapabilities(self, caps):

    86

        pass

    87

    88

class dummyopener(object):

    89

    handlers = []

    90

    91

# Facilitates testing sshpeer without requiring an SSH server.

    92

class badpeer(httppeer.httppeer):

    93

    def __init__(self):

    94

        super(badpeer, self).__init__(None, None, None, dummyopener())

    95

        self.badattribute = True

    96

    97

    def badmethod(self):

    98

        pass

    99

   100

class dummypipe(object):

   101

    def close(self):

   102

        pass

   103

   104

def main():

   105

    ui = uimod.ui()

   106

    # Needed so we can open a local repo with obsstore without a warning.

   107

    ui.setconfig('experimental', 'evolution.createmarkers', True)

   108

   109

    checkobject(badpeer())

   110

    checkobject(httppeer.httppeer(None, None, None, dummyopener()))

   111

    checkobject(localrepo.localpeer(dummyrepo()))

   112

    checkobject(sshpeer.sshv1peer(ui, 'ssh://localhost/foo', None, dummypipe(),

   113

                                  dummypipe(), None, None))

   114

    checkobject(sshpeer.sshv2peer(ui, 'ssh://localhost/foo', None, dummypipe(),

   115

                                  dummypipe(), None, None))

   116

    checkobject(bundlerepo.bundlepeer(dummyrepo()))

   117

    checkobject(statichttprepo.statichttppeer(dummyrepo()))

   118

    checkobject(unionrepo.unionpeer(dummyrepo()))

   119

   120

    ziverify.verifyClass(repository.completelocalrepository,

   121

                         localrepo.localrepository)

   122

    repo = localrepo.localrepository(ui, rootdir)

   123

    checkzobject(repo)

   124

   125

main()