comparison mercurial/dirstate.py @ 50002:e358f6e0e50e

dirstate: do not write an empty dirstate just for backup

This will get in the way when we get more strict about holding the lock when
writing the dirstate.

Instead, we simply don't copy dirstate files around if there are None at backup
time.

A couple of tests are impacted they no longer need to backup such "empty"
dirstate.

50001:9313d8666a0f

    def _new_backup_data_filename(self, backupname):
        """return a filename to backup a data-file or None"""
        if not self._use_dirstate_v2:
            return None
        data_filename = self._map.docket.data_filename()
        return data_filename, self.data_backup_filename(backupname)

    def backup_data_file(self, backupname):
        if not self._use_dirstate_v2:

        assert backupname != filename

        # use '_writedirstate' instead of 'write' to write changes certainly,
        # because the latter omits writing out if transaction is running.
        # output file will be used to create backup of dirstate at this point.
        if self._dirty or not self._opener.exists(filename):
            self._writedirstate(
                tr,
                self._opener(filename, b"w", atomictemp=True, checkambig=True),
            )

            # failure, even if tr.writepending isn't invoked until the
            # end of this transaction
            tr.registertmp(filename, location=b'plain')

        self._opener.tryunlink(backupname)
        if True:
            # hardlink backup is okay because _writedirstate is always called
            # with an "atomictemp=True" file.
            util.copyfile(
                self._opener.join(filename),
                self._opener.join(backupname),

    def restorebackup(self, tr, backupname):
        '''Restore dirstate by backup file'''
        # this "invalidate()" prevents "wlock.release()" from writing
        # changes of dirstate out after restoring from backup file
        self.invalidate()
        filename = self._actualfilename(tr)
        o = self._opener
        data_pair = self.backup_data_file(backupname)
        if util.samefile(o.join(backupname), o.join(filename)):
            o.unlink(backupname)
        else:
            o.rename(backupname, filename, checkambig=True)

        if data_pair is not None:

                o.rename(data_backup, target, checkambig=True)

    def clearbackup(self, tr, backupname):
        '''Clear backup file'''
        o = self._opener
        data_backup = self.backup_data_file(backupname)
        o.unlink(backupname)

        if data_backup is not None:
            o.unlink(data_backup[0])

    def verify(self, m1, m2, p1, narrow_matcher=None):
        """
        check the dirstate contents against the parent manifest and yield errors
        """

50002:e358f6e0e50e

    def _new_backup_data_filename(self, backupname):
        """return a filename to backup a data-file or None"""
        if not self._use_dirstate_v2:
            return None
        if self._map.docket.uuid is None:
            # not created yet, nothing to backup
            return None
        data_filename = self._map.docket.data_filename()
        return data_filename, self.data_backup_filename(backupname)

    def backup_data_file(self, backupname):
        if not self._use_dirstate_v2:

        assert backupname != filename

        # use '_writedirstate' instead of 'write' to write changes certainly,
        # because the latter omits writing out if transaction is running.
        # output file will be used to create backup of dirstate at this point.
        if self._dirty:
            self._writedirstate(
                tr,
                self._opener(filename, b"w", atomictemp=True, checkambig=True),
            )

            # failure, even if tr.writepending isn't invoked until the
            # end of this transaction
            tr.registertmp(filename, location=b'plain')

        self._opener.tryunlink(backupname)
        if self._opener.exists(filename):
            # hardlink backup is okay because _writedirstate is always called
            # with an "atomictemp=True" file.
            util.copyfile(
                self._opener.join(filename),
                self._opener.join(backupname),

    def restorebackup(self, tr, backupname):
        '''Restore dirstate by backup file'''
        # this "invalidate()" prevents "wlock.release()" from writing
        # changes of dirstate out after restoring from backup file
        self.invalidate()
        o = self._opener
        if not o.exists(backupname):
            # there was no file backup, delete existing files
            filename = self._actualfilename(tr)
            data_file = None
            if self._use_dirstate_v2:
                data_file = self._map.docket.data_filename()
            if o.exists(filename):
                o.unlink(filename)
            if data_file is not None and o.exists(data_file):
                o.unlink(data_file)
            return
        filename = self._actualfilename(tr)
        data_pair = self.backup_data_file(backupname)
        if o.exists(filename) and util.samefile(
            o.join(backupname), o.join(filename)
        ):
            o.unlink(backupname)
        else:
            o.rename(backupname, filename, checkambig=True)

        if data_pair is not None:

                o.rename(data_backup, target, checkambig=True)

    def clearbackup(self, tr, backupname):
        '''Clear backup file'''
        o = self._opener
        if o.exists(backupname):
            data_backup = self.backup_data_file(backupname)
            o.unlink(backupname)
            if data_backup is not None:
                o.unlink(data_backup[0])

    def verify(self, m1, m2, p1, narrow_matcher=None):
        """
        check the dirstate contents against the parent manifest and yield errors
        """