# hg.py - repository classes for mercurial

#

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

# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.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 shutil

from .i18n import _

from .node import nullid

from . import (

    bookmarks,

    bundlerepo,

    cmdutil,

    destutil,

    discovery,

    error,

    exchange,

    extensions,

    httppeer,

    localrepo,

    lock,

    merge as mergemod,

    node,

    phases,

    repoview,

    scmutil,

    sshpeer,

    statichttprepo,

    ui as uimod,

    unionrepo,

    url,

    util,

    verify as verifymod,

)

release = lock.release

# shared features

sharedbookmarks = 'bookmarks'

def _local(path):

    path = util.expandpath(util.urllocalpath(path))

    return (os.path.isfile(path) and bundlerepo or localrepo)

def addbranchrevs(lrepo, other, branches, revs):

    peer = other.peer() # a courtesy to callers using a localrepo for other

    hashbranch, branches = branches

    if not hashbranch and not branches:

        x = revs or None

        if util.safehasattr(revs, 'first'):

            y = revs.first()

        elif revs:

            y = revs[0]

        else:

            y = None

        return x, y

    if revs:

        revs = list(revs)

    else:

        revs = []

    if not peer.capable('branchmap'):

        if branches:

            raise error.Abort(_("remote branch lookup not supported"))

        revs.append(hashbranch)

        return revs, revs[0]

    branchmap = peer.branchmap()

    def primary(branch):

        if branch == '.':

            if not lrepo:

                raise error.Abort(_("dirstate branch not accessible"))

            branch = lrepo.dirstate.branch()

        if branch in branchmap:

            revs.extend(node.hex(r) for r in reversed(branchmap[branch]))

            return True

        else:

            return False

    for branch in branches:

        if not primary(branch):

            raise error.RepoLookupError(_("unknown branch '%s'") % branch)

    if hashbranch:

        if not primary(hashbranch):

            revs.append(hashbranch)

    return revs, revs[0]

def parseurl(path, branches=None):

    '''parse url#branch, returning (url, (branch, branches))'''

    u = util.url(path)

    branch = None

    if u.fragment:

        branch = u.fragment

        u.fragment = None

    return str(u), (branch, branches or [])

schemes = {

    'bundle': bundlerepo,

    'union': unionrepo,

    'file': _local,

    'http': httppeer,

    'https': httppeer,

    'ssh': sshpeer,

    'static-http': statichttprepo,

}

def _peerlookup(path):

    u = util.url(path)

    scheme = u.scheme or 'file'

    thing = schemes.get(scheme) or schemes['file']

    try:

        return thing(path)

    except TypeError:

        # we can't test callable(thing) because 'thing' can be an unloaded

        # module that implements __call__

        if not util.safehasattr(thing, 'instance'):

            raise

        return thing

def islocal(repo):

    '''return true if repo (or path pointing to repo) is local'''

    if isinstance(repo, str):

        try:

            return _peerlookup(repo).islocal(repo)

        except AttributeError:

            return False

    return repo.local()

def openpath(ui, path):

    '''open path with open if local, url.open if remote'''

    pathurl = util.url(path, parsequery=False, parsefragment=False)

    if pathurl.islocal():

        return util.posixfile(pathurl.localpath(), 'rb')

    else:

        return url.open(ui, path)

# a list of (ui, repo) functions called for wire peer initialization

wirepeersetupfuncs = []

def _peerorrepo(ui, path, create=False):

    """return a repository object for the specified path"""

    obj = _peerlookup(path).instance(ui, path, create)

    ui = getattr(obj, "ui", ui)

    for name, module in extensions.extensions(ui):

        hook = getattr(module, 'reposetup', None)

        if hook:

            hook(ui, obj)

    if not obj.local():

        for f in wirepeersetupfuncs:

            f(ui, obj)

    return obj

def repository(ui, path='', create=False):

    """return a repository object for the specified path"""

    peer = _peerorrepo(ui, path, create)

    repo = peer.local()

    if not repo:

        raise error.Abort(_("repository '%s' is not local") %

                         (path or peer.url()))

    return repo.filtered('visible')

def peer(uiorrepo, opts, path, create=False):

    '''return a repository peer for the specified path'''

    rui = remoteui(uiorrepo, opts)

    return _peerorrepo(rui, path, create).peer()

def defaultdest(source):

    '''return default destination of clone if none is given

    >>> defaultdest('foo')

    'foo'

    >>> defaultdest('/foo/bar')

    'bar'

    >>> defaultdest('/')

    ''

    >>> defaultdest('')

    ''

    >>> defaultdest('http://example.org/')

    ''

    >>> defaultdest('http://example.org/foo/')

    'foo'

    '''

    path = util.url(source).path

    if not path:

        return ''

    return os.path.basename(os.path.normpath(path))

def share(ui, source, dest=None, update=True, bookmarks=True, defaultpath=None,

          relative=False):

    '''create a shared repository'''

    if not islocal(source):

        raise error.Abort(_('can only share local repositories'))

    if not dest:

        dest = defaultdest(source)

    else:

        dest = ui.expandpath(dest)

    if isinstance(source, str):

        origsource = ui.expandpath(source)

        source, branches = parseurl(origsource)

        srcrepo = repository(ui, source)

        rev, checkout = addbranchrevs(srcrepo, srcrepo, branches, None)

    else:

        srcrepo = source.local()

        origsource = source = srcrepo.url()

        checkout = None

    sharedpath = srcrepo.sharedpath # if our source is already sharing

    destwvfs = scmutil.vfs(dest, realpath=True)

    destvfs = scmutil.vfs(os.path.join(destwvfs.base, '.hg'), realpath=True)

    if destvfs.lexists():

        raise error.Abort(_('destination already exists'))

    if not destwvfs.isdir():

        destwvfs.mkdir()

    destvfs.makedir()

    requirements = ''

    try:

        requirements = srcrepo.vfs.read('requires')

    except IOError as inst:

        if inst.errno != errno.ENOENT:

            raise

    if relative:

        try:

            sharedpath = os.path.relpath(sharedpath, destvfs.base)

            requirements += 'relshared\n'

        except IOError as e:

            raise error.Abort(_('cannot calculate relative path'),

                              hint=str(e))

    else:

        requirements += 'shared\n'

    destvfs.write('requires', requirements)

    destvfs.write('sharedpath', sharedpath)

    r = repository(ui, destwvfs.base)

    postshare(srcrepo, r, bookmarks=bookmarks, defaultpath=defaultpath)

    _postshareupdate(r, update, checkout=checkout)

def postshare(sourcerepo, destrepo, bookmarks=True, defaultpath=None):

    """Called after a new shared repo is created.

    The new repo only has a requirements file and pointer to the source.

    This function configures additional shared data.

    Extensions can wrap this function and write additional entries to

    destrepo/.hg/shared to indicate additional pieces of data to be shared.

    """

    default = defaultpath or sourcerepo.ui.config('paths', 'default')

    if default:

        fp = destrepo.vfs("hgrc", "w", text=True)

        fp.write("[paths]\n")

        fp.write("default = %s\n" % default)

        fp.close()

    with destrepo.wlock():

        if bookmarks:

            fp = destrepo.vfs('shared', 'w')

            fp.write(sharedbookmarks + '\n')

            fp.close()

def _postshareupdate(repo, update, checkout=None):

    """Maybe perform a working directory update after a shared repo is created.

    ``update`` can be a boolean or a revision to update to.

    """

    if not update:

        return

    repo.ui.status(_("updating working directory\n"))

    if update is not True:

        checkout = update

    for test in (checkout, 'default', 'tip'):

        if test is None:

            continue

        try:

            uprev = repo.lookup(test)

            break

        except error.RepoLookupError:

            continue

    _update(repo, uprev)

def copystore(ui, srcrepo, destpath):

    '''copy files from store of srcrepo in destpath

    returns destlock

    '''

    destlock = None

    try:

        hardlink = None

        num = 0

        closetopic = [None]

        def prog(topic, pos):

            if pos is None:

                closetopic[0] = topic

            else:

                ui.progress(topic, pos + num)

        srcpublishing = srcrepo.publishing()

        srcvfs = scmutil.vfs(srcrepo.sharedpath)

        dstvfs = scmutil.vfs(destpath)

        for f in srcrepo.store.copylist():

            if srcpublishing and f.endswith('phaseroots'):

                continue

            dstbase = os.path.dirname(f)

            if dstbase and not dstvfs.exists(dstbase):

                dstvfs.mkdir(dstbase)

            if srcvfs.exists(f):

                if f.endswith('data'):

                    # 'dstbase' may be empty (e.g. revlog format 0)

                    lockfile = os.path.join(dstbase, "lock")

                    # lock to avoid premature writing to the target

                    destlock = lock.lock(dstvfs, lockfile)

                hardlink, n = util.copyfiles(srcvfs.join(f), dstvfs.join(f),

                                             hardlink, progress=prog)

                num += n

        if hardlink:

            ui.debug("linked %d files\n" % num)

            if closetopic[0]:

                ui.progress(closetopic[0], None)

        else:

            ui.debug("copied %d files\n" % num)

            if closetopic[0]:

                ui.progress(closetopic[0], None)

        return destlock

    except: # re-raises

        release(destlock)

        raise

def clonewithshare(ui, peeropts, sharepath, source, srcpeer, dest, pull=False,

                   rev=None, update=True, stream=False):

    """Perform a clone using a shared repo.

    The store for the repository will be located at <sharepath>/.hg. The

    specified revisions will be cloned or pulled from "source". A shared repo

    will be created at "dest" and a working copy will be created if "update" is

    True.

    """

    revs = None

    if rev:

        if not srcpeer.capable('lookup'):

            raise error.Abort(_("src repository does not support "

                               "revision lookup and so doesn't "

                               "support clone by revision"))

        revs = [srcpeer.lookup(r) for r in rev]

    # Obtain a lock before checking for or cloning the pooled repo otherwise

    # 2 clients may race creating or populating it.

    pooldir = os.path.dirname(sharepath)

    # lock class requires the directory to exist.

    try:

        util.makedir(pooldir, False)

    except OSError as e:

        if e.errno != errno.EEXIST:

            raise

    poolvfs = scmutil.vfs(pooldir)

    basename = os.path.basename(sharepath)

    with lock.lock(poolvfs, '%s.lock' % basename):

        if os.path.exists(sharepath):

            ui.status(_('(sharing from existing pooled repository %s)\n') %