comparison mercurial/dirstate.py @ 49958:96e526fe5fb0

dirstate: invalidate changes when parent-change fails

When an error occurs during changing parents, we should invalidate all dirstate
modifications and reload the dirstate. This is currently done by a `unlock`
callback on the `wlock`.

To fix this anomaly, we start dealing with the error directly in the context
manager and its potential nesting.

The "hard" part is to make sure that, when the parent-change context are nested,
we and higher level nesting do not continue to use the invalidated dirstate.
We introduce dedicated code to enforce that.

49957:ff4df0954742

def requires_parents_change(func):
    def wrap(self, *args, **kwargs):
        if not self.pendingparentchange():
            msg = 'calling `%s` outside of a parentchange context'
            msg %= func.__name__
            raise error.ProgrammingError(msg)
        return func(self, *args, **kwargs)

    return wrap

        self._dirty = False
        # True if the set of tracked file may be different
        self._dirty_tracked_set = False
        self._ui = ui
        self._filecache = {}
        self._parentwriters = 0
        self._filename = b'dirstate'
        self._filename_th = b'dirstate-tracked-hint'
        self._pendingfilename = b'%s.pending' % self._filename
        self._plchangecallbacks = {}
        self._origpl = None

        If an exception occurs in the scope of the context manager,
        the incoherent dirstate won't be written when wlock is
        released.
        """
        self._parentwriters += 1
        yield
        # Typically we want the "undo" step of a context manager in a
        # finally block so it happens even when an exception
        # occurs. In this case, however, we only want to decrement
        # parentwriters if the code in the with statement exits
        # normally, so we don't have a try/finally here on purpose.
        self._parentwriters -= 1

    def pendingparentchange(self):
        """Returns true if the dirstate is in the middle of a set of changes
        that modify the dirstate parent.
        """

        for a in ("_map", "_branch", "_ignore"):
            if a in self.__dict__:
                delattr(self, a)
        self._dirty = False
        self._dirty_tracked_set = False
        self._parentwriters = 0
        self._origpl = None

    def copy(self, source, dest):
        """Mark dest as a copy of source. Unmark dest if source is None."""
        if source == dest:

49958:96e526fe5fb0

def requires_parents_change(func):
    def wrap(self, *args, **kwargs):
        if not self.pendingparentchange():
            msg = 'calling `%s` outside of a parentchange context'
            msg %= func.__name__
            raise error.ProgrammingError(msg)
        if self._invalidated_context:
            msg = 'calling `%s` after the dirstate was invalidated'
            raise error.ProgrammingError(msg)
        return func(self, *args, **kwargs)

    return wrap

        self._dirty = False
        # True if the set of tracked file may be different
        self._dirty_tracked_set = False
        self._ui = ui
        self._filecache = {}
        # nesting level of `parentchange` context
        self._parentwriters = 0
        # True if the current dirstate changing operations have been
        # invalidated (used to make sure all nested contexts have been exited)
        self._invalidated_context = False
        self._filename = b'dirstate'
        self._filename_th = b'dirstate-tracked-hint'
        self._pendingfilename = b'%s.pending' % self._filename
        self._plchangecallbacks = {}
        self._origpl = None

        If an exception occurs in the scope of the context manager,
        the incoherent dirstate won't be written when wlock is
        released.
        """
        if self._invalidated_context:
            msg = "trying to use an invalidated dirstate before it has reset"
            raise error.ProgrammingError(msg)
        self._parentwriters += 1
        try:
            yield
        except Exception:
            self.invalidate()
            raise
        finally:
            if self._parentwriters > 0:
                if self._invalidated_context:
                    # make sure we invalidate anything an upper context might
                    # have changed.
                    self.invalidate()
                self._parentwriters -= 1
                # The invalidation is complete once we exit the final context
                # manager
                if self._parentwriters <= 0:
                    assert self._parentwriters == 0
                    self._invalidated_context = False

    def pendingparentchange(self):
        """Returns true if the dirstate is in the middle of a set of changes
        that modify the dirstate parent.
        """

        for a in ("_map", "_branch", "_ignore"):
            if a in self.__dict__:
                delattr(self, a)
        self._dirty = False
        self._dirty_tracked_set = False
        self._invalidated_context = self._parentwriters > 0
        self._origpl = None

    def copy(self, source, dest):
        """Mark dest as a copy of source. Unmark dest if source is None."""
        if source == dest: