11    error,

    34 class excludeddir(manifest.treemanifest):

    35     """Stand-in for a directory that is excluded from the repository.

    36 

    37     With narrowing active on a repository that uses treemanifests,

    38     some of the directory revlogs will be excluded from the resulting

    39     clone. This is a huge storage win for clients, but means we need

    40     some sort of pseudo-manifest to surface to internals so we can

    41     detect a merge conflict outside the narrowspec. That's what this

    42     class is: it stands in for a directory whose node is known, but

    43     whose contents are unknown.

    44     """

    45     def __init__(self, dir, node):

    46         super(excludeddir, self).__init__(dir)

    47         self._node = node

    48         # Add an empty file, which will be included by iterators and such,

    49         # appearing as the directory itself (i.e. something like "dir/")

    50         self._files[''] = node

    51         self._flags[''] = 't'

    52 

    53     # Manifests outside the narrowspec should never be modified, so avoid

    54     # copying. This makes a noticeable difference when there are very many

    55     # directories outside the narrowspec. Also, it makes sense for the copy to

    56     # be of the same type as the original, which would not happen with the

    57     # super type's copy().

    58     def copy(self):

    59         return self

    60 

    61 class excludeddirmanifestctx(manifest.treemanifestctx):

    62     """context wrapper for excludeddir - see that docstring for rationale"""

    63     def __init__(self, dir, node):

    64         self._dir = dir

    65         self._node = node

    66 

    67     def read(self):

    68         return excludeddir(self._dir, self._node)

    69 

    70     def write(self, *args):

    71         raise error.ProgrammingError(

    72             'attempt to write manifest from excluded dir %s' % self._dir)

    73 

    74 class excludedmanifestrevlog(manifest.manifestrevlog):

    75     """Stand-in for excluded treemanifest revlogs.

    76 

    77     When narrowing is active on a treemanifest repository, we'll have

    78     references to directories we can't see due to the revlog being

    79     skipped. This class exists to conform to the manifestrevlog

    80     interface for those directories and proactively prevent writes to

    81     outside the narrowspec.

    82     """

    83 

    84     def __init__(self, dir):

    85         self._dir = dir

    86 

    87     def __len__(self):

    88         raise error.ProgrammingError(

    89             'attempt to get length of excluded dir %s' % self._dir)

    90 

    91     def rev(self, node):

    92         raise error.ProgrammingError(

    93             'attempt to get rev from excluded dir %s' % self._dir)

    94 

    95     def linkrev(self, node):

    96         raise error.ProgrammingError(

    97             'attempt to get linkrev from excluded dir %s' % self._dir)

    98 

    99     def node(self, rev):

   100         raise error.ProgrammingError(

   101             'attempt to get node from excluded dir %s' % self._dir)

   102 

   103     def add(self, *args, **kwargs):

   104         # We should never write entries in dirlogs outside the narrow clone.

   105         # However, the method still gets called from writesubtree() in

   106         # _addtree(), so we need to handle it. We should possibly make that

   107         # avoid calling add() with a clean manifest (_dirty is always False

   108         # in excludeddir instances).

   109         pass

   110