comparison mercurial/store.py @ 50473:5a2fb64d38b2

store: use specialized class for store entries

We introduce two different classes for revlog and other entries. For now, we
still have multiple entry for the same revlog, but we will work toward grouping
the different file in a single entry in this series.

Having the distinction is a step toward this goal.

50472:9fdc28e21b68

FILETYPE_FILELOG_OTHER = FILEFLAGS_FILELOG | FILEFLAGS_REVLOG_OTHER
FILETYPE_OTHER = FILEFLAGS_OTHER


@attr.s(slots=True)
class StoreEntry:
    """An entry in the store

    This is returned by `store.walk` and represent some data in the store."""

    unencoded_path = attr.ib()
    is_revlog = attr.ib(default=False)
    revlog_type = attr.ib(default=None)
    is_revlog_main = attr.ib(default=None)
    is_volatile = attr.ib(default=False)
    file_size = attr.ib(default=None)

    def files(self):
        return [

                unencoded_path=self.unencoded_path,
                file_size=self.file_size,
                is_volatile=self.is_volatile,
            )
        ]


@attr.s(slots=True)
class StoreFile:
    """a file matching an entry"""

        rootstore = manifest.manifestrevlog(repo.nodeconstants, self.vfs)
        return manifest.manifestlog(self.vfs, repo, rootstore, storenarrowmatch)

    def datafiles(
        self, matcher=None, undecodable=None
    ) -> Generator[StoreEntry, None, None]:
        """Like walk, but excluding the changelog and root manifest.

        When [undecodable] is None, revlogs names that can't be
        decoded cause an exception. When it is provided, it should
        be a list and the filenames that can't be decoded are added
        to it instead. This is very rarely needed."""
        files = self._walk(b'data', True) + self._walk(b'meta', True)
        for (t, u, s) in files:
            if t is not None:
                yield StoreEntry(
                    unencoded_path=u,
                    is_revlog=True,
                    revlog_type=FILEFLAGS_FILELOG,
                    is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
                    file_size=s,
                )

    def topfiles(self) -> Generator[StoreEntry, None, None]:
        # yield manifest before changelog
        files = reversed(self._walk(b'', False))
        for (t, u, s) in files:
            if u.startswith(b'00changelog'):
                revlog_type = FILEFLAGS_CHANGELOG
            elif u.startswith(b'00manifest'):
                revlog_type = FILEFLAGS_MANIFESTLOG
            else:
                revlog_type = None
            yield StoreEntry(
                unencoded_path=u,
                is_revlog=revlog_type is not None,
                revlog_type=revlog_type,
                is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
                is_volatile=bool(t & FILEFLAGS_VOLATILE),
                file_size=s,
            )

    def walk(self, matcher=None) -> Generator[StoreEntry, None, None]:
        """return files related to data storage (ie: revlogs)

        yields (file_type, unencoded, size)

        if a matcher is passed, storage files of only those tracked paths

    # However that might change so we should probably add a test and encoding
    # decoding for it too. see issue6548

    def datafiles(
        self, matcher=None, undecodable=None
    ) -> Generator[StoreEntry, None, None]:
        for entry in super(encodedstore, self).datafiles():
            try:
                f1 = entry.unencoded_path
                f2 = decodefilename(f1)
            except KeyError:

    def getsize(self, path):
        return self.rawvfs.stat(path).st_size

    def datafiles(
        self, matcher=None, undecodable=None
    ) -> Generator[StoreEntry, None, None]:
        for f in sorted(self.fncache):
            if not _matchtrackedpath(f, matcher):
                continue
            ef = self.encode(f)
            t = revlog_type(f)

                # Note: this should not be in the fncache then…
                #
                # However the fncache might contains such file added by
                # previous version of Mercurial.
                continue
            t |= FILEFLAGS_FILELOG
            try:
                yield StoreEntry(
                    unencoded_path=f,
                    is_revlog=True,
                    revlog_type=FILEFLAGS_FILELOG,
                    is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
                    file_size=self.getsize(ef),
                )

50473:5a2fb64d38b2

FILETYPE_FILELOG_OTHER = FILEFLAGS_FILELOG | FILEFLAGS_REVLOG_OTHER
FILETYPE_OTHER = FILEFLAGS_OTHER


@attr.s(slots=True)
class BaseStoreEntry:
    """An entry in the store

    This is returned by `store.walk` and represent some data in the store."""

    unencoded_path = attr.ib()
    is_volatile = attr.ib(default=False)
    file_size = attr.ib(default=None)

    def files(self):
        return [

                unencoded_path=self.unencoded_path,
                file_size=self.file_size,
                is_volatile=self.is_volatile,
            )
        ]


@attr.s(slots=True)
class SimpleStoreEntry(BaseStoreEntry):
    """A generic entry in the store"""

    is_revlog = False


@attr.s(slots=True)
class RevlogStoreEntry(BaseStoreEntry):
    """A revlog entry in the store"""

    is_revlog = True
    revlog_type = attr.ib(default=None)
    is_revlog_main = attr.ib(default=None)


@attr.s(slots=True)
class StoreFile:
    """a file matching an entry"""

        rootstore = manifest.manifestrevlog(repo.nodeconstants, self.vfs)
        return manifest.manifestlog(self.vfs, repo, rootstore, storenarrowmatch)

    def datafiles(
        self, matcher=None, undecodable=None
    ) -> Generator[BaseStoreEntry, None, None]:
        """Like walk, but excluding the changelog and root manifest.

        When [undecodable] is None, revlogs names that can't be
        decoded cause an exception. When it is provided, it should
        be a list and the filenames that can't be decoded are added
        to it instead. This is very rarely needed."""
        files = self._walk(b'data', True) + self._walk(b'meta', True)
        for (t, u, s) in files:
            if t is not None:
                yield RevlogStoreEntry(
                    unencoded_path=u,
                    revlog_type=FILEFLAGS_FILELOG,
                    is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
                    file_size=s,
                )

    def topfiles(self) -> Generator[BaseStoreEntry, None, None]:
        # yield manifest before changelog
        files = reversed(self._walk(b'', False))
        for (t, u, s) in files:
            if u.startswith(b'00changelog'):
                yield RevlogStoreEntry(
                    unencoded_path=u,
                    revlog_type=FILEFLAGS_CHANGELOG,
                    is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
                    file_size=s,
                )
            elif u.startswith(b'00manifest'):
                yield RevlogStoreEntry(
                    unencoded_path=u,
                    revlog_type=FILEFLAGS_MANIFESTLOG,
                    is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
                    file_size=s,
                )
            else:
                yield SimpleStoreEntry(
                    unencoded_path=u,
                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
                    file_size=s,
                )

    def walk(self, matcher=None) -> Generator[BaseStoreEntry, None, None]:
        """return files related to data storage (ie: revlogs)

        yields (file_type, unencoded, size)

        if a matcher is passed, storage files of only those tracked paths

    # However that might change so we should probably add a test and encoding
    # decoding for it too. see issue6548

    def datafiles(
        self, matcher=None, undecodable=None
    ) -> Generator[BaseStoreEntry, None, None]:
        for entry in super(encodedstore, self).datafiles():
            try:
                f1 = entry.unencoded_path
                f2 = decodefilename(f1)
            except KeyError:

    def getsize(self, path):
        return self.rawvfs.stat(path).st_size

    def datafiles(
        self, matcher=None, undecodable=None
    ) -> Generator[BaseStoreEntry, None, None]:
        for f in sorted(self.fncache):
            if not _matchtrackedpath(f, matcher):
                continue
            ef = self.encode(f)
            t = revlog_type(f)

                # Note: this should not be in the fncache then…
                #
                # However the fncache might contains such file added by
                # previous version of Mercurial.
                continue
            try:
                yield RevlogStoreEntry(
                    unencoded_path=f,
                    revlog_type=FILEFLAGS_FILELOG,
                    is_revlog_main=bool(t & FILEFLAGS_REVLOG_MAIN),
                    is_volatile=bool(t & FILEFLAGS_VOLATILE),
                    file_size=self.getsize(ef),
                )