mercurial/unionrepo.py

convert: change socket mode from b'r+' to 'rwb' in cvs.py (issue6789)

'r+' mode used to open sockets for read/write operations, but '+' is not
supported in Python 3. We're using bytes with these sockets everywhere, so the
mode should have 'b'.  But the mode argument has to be str, not bytes.

# unionrepo.py - repository class for viewing union of repository changesets
#
# Derived from bundlerepo.py
# Copyright 2006, 2007 Benoit Boissinot <[e-mail]>
# Copyright 2013 Unity Technologies, Mads Kiilerich <[e-mail]>
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.

"""Repository class for "in-memory pull" of one local repository to another,
allowing operations like diff and log with revsets.
"""


from .i18n import _
from .pycompat import getattr

from . import (
    changelog,
    cmdutil,
    encoding,
    error,
    filelog,
    localrepo,
    manifest,
    mdiff,
    pathutil,
    revlog,
    util,
    vfs as vfsmod,
)

from .revlogutils import (
    constants as revlog_constants,
)


class unionrevlog(revlog.revlog):
    def __init__(self, opener, radix, revlog2, linkmapper):
        # How it works:
        # To retrieve a revision, we just need to know the node id so we can
        # look it up in revlog2.
        #
        # To differentiate a rev in the second revlog from a rev in the revlog,
        # we check revision against repotiprev.
        opener = vfsmod.readonlyvfs(opener)
        target = getattr(revlog2, 'target', None)
        if target is None:
            # a revlog wrapper, eg: the manifestlog that is not an actual revlog
            target = revlog2._revlog.target
        revlog.revlog.__init__(self, opener, target=target, radix=radix)
        self.revlog2 = revlog2

        n = len(self)
        self.repotiprev = n - 1
        self.bundlerevs = set()  # used by 'bundle()' revset expression
        for rev2 in self.revlog2:
            rev = self.revlog2.index[rev2]
            # rev numbers - in revlog2, very different from self.rev
            (
                _start,
                _csize,
                rsize,
                base,
                linkrev,
                p1rev,
                p2rev,
                node,
                _sdo,
                _sds,
                _dcm,
                _sdcm,
                rank,
            ) = rev
            flags = _start & 0xFFFF

            if linkmapper is None:  # link is to same revlog
                assert linkrev == rev2  # we never link back
                link = n
            else:  # rev must be mapped from repo2 cl to unified cl by linkmapper
                link = linkmapper(linkrev)

            if linkmapper is not None:  # link is to same revlog
                base = linkmapper(base)

            this_rev = self.index.get_rev(node)
            if this_rev is not None:
                # this happens for the common revlog revisions
                self.bundlerevs.add(this_rev)
                continue

            p1node = self.revlog2.node(p1rev)
            p2node = self.revlog2.node(p2rev)

            # TODO: it's probably wrong to set compressed length to -1, but
            # I have no idea if csize is valid in the base revlog context.
            e = (
                flags,
                -1,
                rsize,
                base,
                link,
                self.rev(p1node),
                self.rev(p2node),
                node,
                0,  # sidedata offset
                0,  # sidedata size
                revlog_constants.COMP_MODE_INLINE,
                revlog_constants.COMP_MODE_INLINE,
                rank,
            )
            self.index.append(e)
            self.bundlerevs.add(n)
            n += 1

    def _chunk(self, rev):
        if rev <= self.repotiprev:
            return revlog.revlog._chunk(self, rev)
        return self.revlog2._chunk(self.node(rev))

    def revdiff(self, rev1, rev2):
        """return or calculate a delta between two revisions"""
        if rev1 > self.repotiprev and rev2 > self.repotiprev:
            return self.revlog2.revdiff(
                self.revlog2.rev(self.node(rev1)),
                self.revlog2.rev(self.node(rev2)),
            )
        elif rev1 <= self.repotiprev and rev2 <= self.repotiprev:
            return super(unionrevlog, self).revdiff(rev1, rev2)

        return mdiff.textdiff(self.rawdata(rev1), self.rawdata(rev2))

    def _revisiondata(self, nodeorrev, _df=None, raw=False):
        if isinstance(nodeorrev, int):
            rev = nodeorrev
            node = self.node(rev)
        else:
            node = nodeorrev
            rev = self.rev(node)

        if rev > self.repotiprev:
            # work around manifestrevlog NOT being a revlog
            revlog2 = getattr(self.revlog2, '_revlog', self.revlog2)
            func = revlog2._revisiondata
        else:
            func = super(unionrevlog, self)._revisiondata
        return func(node, _df=_df, raw=raw)

    def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
        raise NotImplementedError

    def addgroup(
        self,
        deltas,
        linkmapper,
        transaction,
        alwayscache=False,
        addrevisioncb=None,
        duplicaterevisioncb=None,
        maybemissingparents=False,
    ):
        raise NotImplementedError

    def strip(self, minlink, transaction):
        raise NotImplementedError

    def checksize(self):
        raise NotImplementedError


class unionchangelog(unionrevlog, changelog.changelog):
    def __init__(self, opener, opener2):
        changelog.changelog.__init__(self, opener)
        linkmapper = None
        changelog2 = changelog.changelog(opener2)
        unionrevlog.__init__(self, opener, self.radix, changelog2, linkmapper)


class unionmanifest(unionrevlog, manifest.manifestrevlog):
    def __init__(self, nodeconstants, opener, opener2, linkmapper):
        manifest.manifestrevlog.__init__(self, nodeconstants, opener)
        manifest2 = manifest.manifestrevlog(nodeconstants, opener2)
        unionrevlog.__init__(
            self, opener, self._revlog.radix, manifest2, linkmapper
        )


class unionfilelog(filelog.filelog):
    def __init__(self, opener, path, opener2, linkmapper, repo):
        filelog.filelog.__init__(self, opener, path)
        filelog2 = filelog.filelog(opener2, path)
        self._revlog = unionrevlog(
            opener, self._revlog.radix, filelog2._revlog, linkmapper
        )
        self._repo = repo
        self.repotiprev = self._revlog.repotiprev
        self.revlog2 = self._revlog.revlog2

    def iscensored(self, rev):
        """Check if a revision is censored."""
        if rev <= self.repotiprev:
            return filelog.filelog.iscensored(self, rev)
        node = self.node(rev)
        return self.revlog2.iscensored(self.revlog2.rev(node))


class unionpeer(localrepo.localpeer):
    def canpush(self):
        return False


class unionrepository:
    """Represents the union of data in 2 repositories.

    Instances are not usable if constructed directly. Use ``instance()``
    or ``makeunionrepository()`` to create a usable instance.
    """

    def __init__(self, repo2, url):
        self.repo2 = repo2
        self._url = url

        self.ui.setconfig(b'phases', b'publish', False, b'unionrepo')

    @localrepo.unfilteredpropertycache
    def changelog(self):
        return unionchangelog(self.svfs, self.repo2.svfs)

    @localrepo.unfilteredpropertycache
    def manifestlog(self):
        rootstore = unionmanifest(
            self.nodeconstants,
            self.svfs,
            self.repo2.svfs,
            self.unfiltered()._clrev,
        )
        return manifest.manifestlog(
            self.svfs, self, rootstore, self.narrowmatch()
        )

    def _clrev(self, rev2):
        """map from repo2 changelog rev to temporary rev in self.changelog"""
        node = self.repo2.changelog.node(rev2)
        return self.changelog.rev(node)

    def url(self):
        return self._url

    def file(self, f):
        return unionfilelog(
            self.svfs, f, self.repo2.svfs, self.unfiltered()._clrev, self
        )

    def close(self):
        self.repo2.close()

    def cancopy(self):
        return False

    def peer(self):
        return unionpeer(self)

    def getcwd(self):
        return encoding.getcwd()  # always outside the repo


def instance(ui, path, create, intents=None, createopts=None):
    if create:
        raise error.Abort(_(b'cannot create new union repository'))
    parentpath = ui.config(b"bundle", b"mainreporoot")
    if not parentpath:
        # try to find the correct path to the working directory repo
        parentpath = cmdutil.findrepo(encoding.getcwd())
        if parentpath is None:
            parentpath = b''
    if parentpath:
        # Try to make the full path relative so we get a nice, short URL.
        # In particular, we don't want temp dir names in test outputs.
        cwd = encoding.getcwd()
        if parentpath == cwd:
            parentpath = b''
        else:
            cwd = pathutil.normasprefix(cwd)
            if parentpath.startswith(cwd):
                parentpath = parentpath[len(cwd) :]
    if path.startswith(b'union:'):
        s = path.split(b":", 1)[1].split(b"+", 1)
        if len(s) == 1:
            repopath, repopath2 = parentpath, s[0]
        else:
            repopath, repopath2 = s
    else:
        repopath, repopath2 = parentpath, path

    return makeunionrepository(ui, repopath, repopath2)


def makeunionrepository(ui, repopath1, repopath2):
    """Make a union repository object from 2 local repo paths."""
    repo1 = localrepo.instance(ui, repopath1, create=False)
    repo2 = localrepo.instance(ui, repopath2, create=False)

    url = b'union:%s+%s' % (
        util.expandpath(repopath1),
        util.expandpath(repopath2),
    )

    class derivedunionrepository(unionrepository, repo1.__class__):
        pass

    repo = repo1
    repo.__class__ = derivedunionrepository
    unionrepository.__init__(repo1, repo2, url)

    return repo