# 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 node import hex, nullid, wdirrev, short

from i18n import _

import urllib

import peer, changegroup, subrepo, pushkey, obsolete, repoview

import changelog, dirstate, filelog, manifest, context, bookmarks, phases

import lock as lockmod

import transaction, store, encoding, exchange, bundle2

import scmutil, util, extensions, hook, error, revset, cmdutil

import match as matchmod

import merge as mergemod

import tags as tagsmod

from lock import release

import weakref, errno, os, time, inspect, random

import branchmap, pathutil

import namespaces

propertycache = util.propertycache

filecache = scmutil.filecache

class repofilecache(filecache):

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

    """

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

        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(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(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 _baserequirements(self, create):

        return ['revlogv1']

    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.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:

                if not self.wvfs.exists():

                    self.wvfs.makedirs()

                self.vfs.makedir(notindexed=True)

                self.requirements.update(self._baserequirements(create))

                if self.ui.configbool('format', 'usestore', True):

                    self.vfs.mkdir("store")

                    self.requirements.add("store")

                    if self.ui.configbool('format', 'usefncache', True):

                        self.requirements.add("fncache")

                        if self.ui.configbool('format', 'dotencode', True):

                            self.requirements.add('dotencode')

                    # create an invalid changelog

                    self.vfs.append(

                        "00changelog.i",

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

                        ' dummy changelog to prevent using the old repo layout'

                    )

                # experimental config: format.generaldelta

                if self.ui.configbool('format', 'generaldelta', False):

                    self.requirements.add("generaldelta")

                if self.ui.configbool('experimental', 'treemanifest', False):

                    self.requirements.add("treemanifest")

                if self.ui.configbool('experimental', 'manifestv2', False):

                    self.requirements.add("manifestv2")

            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=' + urllib.quote(capsblob))

        return caps

    def _applyopenerreqs(self):

        self.svfs.options = dict((r, 1) for r in self.requirements

                                           if r in self.openerreqs)

        # experimental config: format.chunkcachesize

        chunkcachesize = self.ui.configint('format', 'chunkcachesize')

        if chunkcachesize is not None:

            self.svfs.options['chunkcachesize'] = chunkcachesize

        # experimental config: format.maxchainlen

        maxchainlen = self.ui.configint('format', 'maxchainlen')

        if maxchainlen is not None:

            self.svfs.options['maxchainlen'] = maxchainlen

        # experimental config: format.manifestcachesize

        manifestcachesize = self.ui.configint('format', 'manifestcachesize')

        if manifestcachesize is not None:

            self.svfs.options['manifestcachesize'] = manifestcachesize

        # experimental config: format.aggressivemergedeltas

        aggressivemergedeltas = self.ui.configbool('format',