# 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 inspect

import os

import random

import time

import weakref

from .i18n import _

from .node import (

    hex,

    nullid,

    short,

    wdirrev,

)

from . import (

    bookmarks,

    branchmap,

    bundle2,

    changegroup,

    changelog,

    cmdutil,

    context,

    dirstate,

    encoding,

    error,

    exchange,

    extensions,

    filelog,

    hook,

    lock as lockmod,

    manifest,

    match as matchmod,

    merge as mergemod,

    namespaces,

    obsolete,

    pathutil,

    peer,

    phases,

    pushkey,

    repoview,

    revset,

    scmutil,

    store,

    subrepo,

    tags as tagsmod,

    transaction,

    util,

)

release = lockmod.release

urlerr = util.urlerr

urlreq = util.urlreq

class repofilecache(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(repofilecache, self).__get__(repo.unfiltered(), type)

    def __set__(self, repo, value):

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

    def __delete__(self, repo):

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

class storecache(repofilecache):

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

    def join(self, obj, fname):

        return obj.sjoin(fname)

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 = set(('lookup', 'branchmap', 'pushkey', 'known', 'getbundle',

                  'unbundle'))

legacycaps = moderncaps.union(set(['changegroupsubset']))

class localpeer(peer.peerrepository):

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

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

        peer.peerrepository.__init__(self)

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

        self.ui = repo.ui

        self._caps = repo._restrictcapabilities(caps)

        self.requirements = repo.requirements

        self.supportedformats = repo.supportedformats

    def close(self):

        self._repo.close()

    def _capabilities(self):

        return self._caps

    def local(self):

        return self._repo

    def canpush(self):

        return True

    def url(self):

        return self._repo.url()

    def lookup(self, key):

        return self._repo.lookup(key)

    def branchmap(self):

        return self._repo.branchmap()

    def heads(self):

        return self._repo.heads()

    def known(self, nodes):

        return self._repo.known(nodes)

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

                  **kwargs):

        cg = exchange.getbundle(self._repo, source, heads=heads,

                                common=common, bundlecaps=bundlecaps, **kwargs)

        if bundlecaps is not None and 'HG20' in 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.

            cg = bundle2.getunbundler(self.ui, cg)

        return cg

    # TODO We might want to move the next two calls into legacypeer and add

    # unbundle instead.

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

        """apply a bundle on a repo

        This function handles the repo locking itself."""

        try:

            try:

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

                ret = exchange.unbundle(self._repo, cg, 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:'), str(exc))

    def lock(self):

        return self._repo.lock()

    def addchangegroup(self, cg, source, url):

        return cg.apply(self._repo, source, url)

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

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

    def listkeys(self, namespace):

        return self._repo.listkeys(namespace)

    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, three, four, five)

class locallegacypeer(localpeer):

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

    restricted capabilities'''

    def __init__(self, repo):

        localpeer.__init__(self, repo, caps=legacycaps)

    def branches(self, nodes):

        return self._repo.branches(nodes)

    def between(self, pairs):

        return self._repo.between(pairs)

    def changegroup(self, basenodes, source):

        return changegroup.changegroup(self._repo, basenodes, source)

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

        return changegroup.changegroupsubset(self._repo, bases, heads, source)

class localrepository(object):

    supportedformats = set(('revlogv1', 'generaldelta', 'treemanifest',

                            'manifestv2'))

    _basesupported = supportedformats | set(('store', 'fncache', 'shared',

                                             'dotencode'))

    openerreqs = set(('revlogv1', 'generaldelta', 'treemanifest', 'manifestv2'))

    filtername = None

    # a list of (ui, featureset) functions.

    # only functions defined in module of enabled extensions are invoked

    featuresetupfuncs = set()

    def __init__(self, baseui, path=None, create=False):

        self.requirements = set()

        self.wvfs = scmutil.vfs(path, expandpath=True, realpath=True)

        self.wopener = self.wvfs

        self.root = self.wvfs.base

        self.path = self.wvfs.join(".hg")

        self.origroot = path

        self.auditor = pathutil.pathauditor(self.root, self._checknested)

        self.nofsauditor = pathutil.pathauditor(self.root, self._checknested,

                                                realfs=False)

        self.vfs = scmutil.vfs(self.path)

        self.opener = self.vfs

        self.baseui = baseui

        self.ui = baseui.copy()

        self.ui.copy = baseui.copy # prevent copying repo configuration

        # A list of callback to shape the phase if no data were found.

        # Callback are in the form: func(repo, roots) --> processed root.

        # This list it to be filled by extension during repo setup

        self._phasedefaults = []

        try:

            self.ui.readconfig(self.join("hgrc"), self.root)

            extensions.loadall(self.ui)

        except IOError:

            pass

        if self.featuresetupfuncs:

            self.supported = set(self._basesupported) # use private copy

            extmods = set(m.__name__ for n, m

                          in extensions.extensions(self.ui))

            for setupfunc in self.featuresetupfuncs:

                if setupfunc.__module__ in extmods:

                    setupfunc(self.ui, self.supported)

        else:

            self.supported = self._basesupported

        if not self.vfs.isdir():

            if create:

                self.requirements = newreporequirements(self)

                if not self.wvfs.exists():

                    self.wvfs.makedirs()

                self.vfs.makedir(notindexed=True)

                if 'store' in self.requirements:

                    self.vfs.mkdir("store")

                    # create an invalid changelog

                    self.vfs.append(

                        "00changelog.i",

                        '\0\0\0\2' # represents revlogv2

                        ' dummy changelog to prevent using the old repo layout'

                    )

            else:

                raise error.RepoError(_("repository %s not found") % path)

        elif create:

            raise error.RepoError(_("repository %s already exists") % path)

        else:

            try:

                self.requirements = scmutil.readrequires(

                        self.vfs, self.supported)

            except IOError as inst:

                if inst.errno != errno.ENOENT:

                    raise

        self.sharedpath = self.path

        try:

            vfs = scmutil.vfs(self.vfs.read("sharedpath").rstrip('\n'),

                              realpath=True)

            s = vfs.base

            if not vfs.exists():

                raise error.RepoError(

                    _('.hg/sharedpath points to nonexistent directory %s') % s)

            self.sharedpath = s

        except IOError as inst:

            if inst.errno != errno.ENOENT:

                raise

        self.store = store.store(

                self.requirements, self.sharedpath, scmutil.vfs)

        self.spath = self.store.path

        self.svfs = self.store.vfs

        self.sjoin = self.store.join

        self.vfs.createmode = self.store.createmode

        self._applyopenerreqs()

        if create:

            self._writerequirements()

        self._dirstatevalidatewarned = False

        self._branchcaches = {}

        self._revbranchcache = None

        self.filterpats = {}

        self._datafilters = {}

        self._transref = self._lockref = self._wlockref = None

        # A cache for various files under .hg/ that tracks file changes,

        # (used by the filecache decorator)

        #

        # Maps a property name to its util.filecacheentry

        self._filecache = {}

        # hold sets of revision to be filtered

        # should be cleared when something might have changed the filter value:

        # - new changesets,

        # - phase change,

        # - new obsolescence marker,

        # - working directory parent change,

        # - bookmark changes

        self.filteredrevcache = {}

        # generic mapping between names and nodes

        self.names = namespaces.namespaces()

    def close(self):

        self._writecaches()

    def _writecaches(self):

        if self._revbranchcache:

            self._revbranchcache.write()

    def _restrictcapabilities(self, caps):

        if self.ui.configbool('experimental', 'bundle2-advertise', True):

            caps = set(caps)

            capsblob = bundle2.encodecaps(bundle2.getrepocaps(self))

            caps.add('bundle2=' + urlreq.quote(capsblob))

        return caps

    def _applyopenerreqs(self):