# localrepo.py - read/write repository class for mercurial

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

import errno

import hashlib

import os

import random

import sys

import time

import weakref

from .i18n import _

from .node import (

    hex,

    nullid,

    short,

)

from . import (

    bookmarks,

    branchmap,

    bundle2,

    changegroup,

    changelog,

    color,

    context,

    dirstate,

    dirstateguard,

    discovery,

    encoding,

    error,

    exchange,

    extensions,

    filelog,

    hook,

    lock as lockmod,

    manifest,

    match as matchmod,

    merge as mergemod,

    mergeutil,

    namespaces,

    narrowspec,

    obsolete,

    pathutil,

    phases,

    pushkey,

    pycompat,

    repository,

    repoview,

    revset,

    revsetlang,

    scmutil,

    sparse,

    store as storemod,

    subrepoutil,

    tags as tagsmod,

    transaction,

    txnutil,

    util,

    vfs as vfsmod,

)

from .utils import (

    interfaceutil,

    procutil,

    stringutil,

)

from .revlogutils import (

    constants as revlogconst,

)

release = lockmod.release

urlerr = util.urlerr

urlreq = util.urlreq

# set of (path, vfs-location) tuples. vfs-location is:

# - 'plain for vfs relative paths

# - '' for svfs relative paths

_cachedfiles = set()

class _basefilecache(scmutil.filecache):

    """All filecache usage on repo are done for logic that should be unfiltered

    """

    def __get__(self, repo, type=None):

        if repo is None:

            return self

        return super(_basefilecache, self).__get__(repo.unfiltered(), type)

    def __set__(self, repo, value):

        return super(_basefilecache, self).__set__(repo.unfiltered(), value)

    def __delete__(self, repo):

        return super(_basefilecache, self).__delete__(repo.unfiltered())

class repofilecache(_basefilecache):

    """filecache for files in .hg but outside of .hg/store"""

    def __init__(self, *paths):

        super(repofilecache, self).__init__(*paths)

        for path in paths:

            _cachedfiles.add((path, 'plain'))

    def join(self, obj, fname):

        return obj.vfs.join(fname)

class storecache(_basefilecache):

    """filecache for files in the store"""

    def __init__(self, *paths):

        super(storecache, self).__init__(*paths)

        for path in paths:

            _cachedfiles.add((path, ''))

    def join(self, obj, fname):

        return obj.sjoin(fname)

def isfilecached(repo, name):

    """check if a repo has already cached "name" filecache-ed property

    This returns (cachedobj-or-None, iscached) tuple.

    """

    cacheentry = repo.unfiltered()._filecache.get(name, None)

    if not cacheentry:

        return None, False

    return cacheentry.obj, True

class unfilteredpropertycache(util.propertycache):

    """propertycache that apply to unfiltered repo only"""

    def __get__(self, repo, type=None):

        unfi = repo.unfiltered()

        if unfi is repo:

            return super(unfilteredpropertycache, self).__get__(unfi)

        return getattr(unfi, self.name)

class filteredpropertycache(util.propertycache):

    """propertycache that must take filtering in account"""

    def cachevalue(self, obj, value):

        object.__setattr__(obj, self.name, value)

def hasunfilteredcache(repo, name):

    """check if a repo has an unfilteredpropertycache value for <name>"""

    return name in vars(repo.unfiltered())

def unfilteredmethod(orig):

    """decorate method that always need to be run on unfiltered version"""

    def wrapper(repo, *args, **kwargs):

        return orig(repo.unfiltered(), *args, **kwargs)

    return wrapper

moderncaps = {'lookup', 'branchmap', 'pushkey', 'known', 'getbundle',

              'unbundle'}

legacycaps = moderncaps.union({'changegroupsubset'})

@interfaceutil.implementer(repository.ipeercommandexecutor)

class localcommandexecutor(object):

    def __init__(self, peer):

        self._peer = peer

        self._sent = False

        self._closed = False

    def __enter__(self):

        return self

    def __exit__(self, exctype, excvalue, exctb):

        self.close()

    def callcommand(self, command, args):

        if self._sent:

            raise error.ProgrammingError('callcommand() cannot be used after '

                                         'sendcommands()')

        if self._closed:

            raise error.ProgrammingError('callcommand() cannot be used after '

                                         'close()')

        # We don't need to support anything fancy. Just call the named

        # method on the peer and return a resolved future.

        fn = getattr(self._peer, pycompat.sysstr(command))

        f = pycompat.futures.Future()

        try:

            result = fn(**pycompat.strkwargs(args))

        except Exception:

            pycompat.future_set_exception_info(f, sys.exc_info()[1:])

        else:

            f.set_result(result)

        return f

    def sendcommands(self):

        self._sent = True

    def close(self):

        self._closed = True

@interfaceutil.implementer(repository.ipeercommands)

class localpeer(repository.peer):

    '''peer for a local repo; reflects only the most recent API'''

    def __init__(self, repo, caps=None):

        super(localpeer, self).__init__()

        if caps is None:

            caps = moderncaps.copy()

        self._repo = repo.filtered('served')

        self.ui = repo.ui

        self._caps = repo._restrictcapabilities(caps)

    # Begin of _basepeer interface.

    def url(self):

        return self._repo.url()

    def local(self):

        return self._repo

    def peer(self):

        return self

    def canpush(self):

        return True

    def close(self):

        self._repo.close()

    # End of _basepeer interface.

    # Begin of _basewirecommands interface.

    def branchmap(self):

        return self._repo.branchmap()

    def capabilities(self):

        return self._caps

    def clonebundles(self):

        return self._repo.tryread('clonebundles.manifest')

    def debugwireargs(self, one, two, three=None, four=None, five=None):

        """Used to test argument passing over the wire"""

        return "%s %s %s %s %s" % (one, two, pycompat.bytestr(three),

                                   pycompat.bytestr(four),

                                   pycompat.bytestr(five))

    def getbundle(self, source, heads=None, common=None, bundlecaps=None,

                  **kwargs):

        chunks = exchange.getbundlechunks(self._repo, source, heads=heads,

                                          common=common, bundlecaps=bundlecaps,

                                          **kwargs)[1]

        cb = util.chunkbuffer(chunks)

        if exchange.bundle2requested(bundlecaps):

            # When requesting a bundle2, getbundle returns a stream to make the

            # wire level function happier. We need to build a proper object

            # from it in local peer.

            return bundle2.getunbundler(self.ui, cb)

        else:

            return changegroup.getunbundler('01', cb, None)

    def heads(self):

        return self._repo.heads()

    def known(self, nodes):

        return self._repo.known(nodes)

    def listkeys(self, namespace):

        return self._repo.listkeys(namespace)

    def lookup(self, key):

        return self._repo.lookup(key)

    def pushkey(self, namespace, key, old, new):

        return self._repo.pushkey(namespace, key, old, new)

    def stream_out(self):

        raise error.Abort(_('cannot perform stream clone against local '

                            'peer'))

    def unbundle(self, bundle, heads, url):

        """apply a bundle on a repo

        This function handles the repo locking itself."""

        try:

            try:

                bundle = exchange.readbundle(self.ui, bundle, None)

                ret = exchange.unbundle(self._repo, bundle, heads, 'push', url)

                if util.safehasattr(ret, 'getchunks'):

                    # This is a bundle20 object, turn it into an unbundler.

                    # This little dance should be dropped eventually when the

                    # API is finally improved.

                    stream = util.chunkbuffer(ret.getchunks())

                    ret = bundle2.getunbundler(self.ui, stream)

                return ret

            except Exception as exc:

                # If the exception contains output salvaged from a bundle2

                # reply, we need to make sure it is printed before continuing

                # to fail. So we build a bundle2 with such output and consume

                # it directly.

                #

                # This is not very elegant but allows a "simple" solution for

                # issue4594

                output = getattr(exc, '_bundle2salvagedoutput', ())

                if output:

                    bundler = bundle2.bundle20(self._repo.ui)

                    for out in output:

                        bundler.addpart(out)

                    stream = util.chunkbuffer(bundler.getchunks())

                    b = bundle2.getunbundler(self.ui, stream)

                    bundle2.processbundle(self._repo, b)

                raise

        except error.PushRaced as exc:

            raise error.ResponseError(_('push failed:'),

                                      stringutil.forcebytestr(exc))

    # End of _basewirecommands interface.

    # Begin of peer interface.

    def commandexecutor(self):

        return localcommandexecutor(self)

    # End of peer interface.

@interfaceutil.implementer(repository.ipeerlegacycommands)

class locallegacypeer(localpeer):

    '''peer extension which implements legacy methods too; used for tests with

    restricted capabilities'''

    def __init__(self, repo):

        super(locallegacypeer, self).__init__(repo, caps=legacycaps)

    # Begin of baselegacywirecommands interface.

    def between(self, pairs):

        return self._repo.between(pairs)

    def branches(self, nodes):

        return self._repo.branches(nodes)

    def changegroup(self, nodes, source):

        outgoing = discovery.outgoing(self._repo, missingroots=nodes,

                                      missingheads=self._repo.heads())

        return changegroup.makechangegroup(self._repo, outgoing, '01', source)

    def changegroupsubset(self, bases, heads, source):

        outgoing = discovery.outgoing(self._repo, missingroots=bases,

                                      missingheads=heads)

        return changegroup.makechangegroup(self._repo, outgoing, '01', source)

    # End of baselegacywirecommands interface.

# Increment the sub-version when the revlog v2 format changes to lock out old

# clients.

REVLOGV2_REQUIREMENT = 'exp-revlogv2.0'

# A repository with the sparserevlog feature will have delta chains that

# can spread over a larger span. Sparse reading cuts these large spans into

# pieces, so that each piece isn't too big.

# Without the sparserevlog capability, reading from the repository could use

# huge amounts of memory, because the whole span would be read at once,

# including all the intermediate revisions that aren't pertinent for the chain.

# This is why once a repository has enabled sparse-read, it becomes required.

SPARSEREVLOG_REQUIREMENT = 'sparserevlog'

# Functions receiving (ui, features) that extensions can register to impact

# the ability to load repositories with custom requirements. Only

# functions defined in loaded extensions are called.

#

# The function receives a set of requirement strings that the repository

# is capable of opening. Functions will typically add elements to the

# set to reflect that the extension knows how to handle that requirements.

featuresetupfuncs = set()

def makelocalrepository(baseui, path, intents=None):

    """Create a local repository object.

    Given arguments needed to construct a local repository, this function

    performs various early repository loading functionality (such as

    reading the ``.hg/requires`` and ``.hg/hgrc`` files), validates that

    the repository can be opened, derives a type suitable for representing

    that repository, and returns an instance of it.

    The returned object conforms to the ``repository.completelocalrepository``

    interface.