# exchange.py - utility to exchange data between repos.

#

# 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 i18n import _

from node import hex, nullid

import errno, urllib

import util, scmutil, changegroup, base85, error

import discovery, phases, obsolete, bookmarks as bookmod, bundle2, pushkey

import lock as lockmod

def readbundle(ui, fh, fname, vfs=None):

    header = changegroup.readexactly(fh, 4)

    alg = None

    if not fname:

        fname = "stream"

        if not header.startswith('HG') and header.startswith('\0'):

            fh = changegroup.headerlessfixup(fh, header)

            header = "HG10"

            alg = 'UN'

    elif vfs:

        fname = vfs.join(fname)

    magic, version = header[0:2], header[2:4]

    if magic != 'HG':

        raise util.Abort(_('%s: not a Mercurial bundle') % fname)

    if version == '10':

        if alg is None:

            alg = changegroup.readexactly(fh, 2)

        return changegroup.cg1unpacker(fh, alg)

    elif version.startswith('2'):

        return bundle2.getunbundler(ui, fh, header=magic + version)

    else:

        raise util.Abort(_('%s: unknown bundle version %s') % (fname, version))

def buildobsmarkerspart(bundler, markers):

    """add an obsmarker part to the bundler with <markers>

    No part is created if markers is empty.

    Raises ValueError if the bundler doesn't support any known obsmarker format.

    """

    if markers:

        remoteversions = bundle2.obsmarkersversion(bundler.capabilities)

        version = obsolete.commonversion(remoteversions)

        if version is None:

            raise ValueError('bundler do not support common obsmarker format')

        stream = obsolete.encodemarkers(markers, True, version=version)

        return bundler.newpart('obsmarkers', data=stream)

    return None

def _canusebundle2(op):

    """return true if a pull/push can use bundle2

    Feel free to nuke this function when we drop the experimental option"""

    return (op.repo.ui.configbool('experimental', 'bundle2-exp', False)

            and op.remote.capable('bundle2'))

class pushoperation(object):

    """A object that represent a single push operation

    It purpose is to carry push related state and very common operation.

    A new should be created at the beginning of each push and discarded

    afterward.

    """

    def __init__(self, repo, remote, force=False, revs=None, newbranch=False,

                 bookmarks=()):

        # repo we push from

        self.repo = repo

        self.ui = repo.ui

        # repo we push to

        self.remote = remote

        # force option provided

        self.force = force

        # revs to be pushed (None is "all")

        self.revs = revs

        # bookmark explicitly pushed

        self.bookmarks = bookmarks

        # allow push of new branch

        self.newbranch = newbranch

        # did a local lock get acquired?

        self.locallocked = None

        # step already performed

        # (used to check what steps have been already performed through bundle2)

        self.stepsdone = set()

        # Integer version of the changegroup push result

        # - None means nothing to push

        # - 0 means HTTP error

        # - 1 means we pushed and remote head count is unchanged *or*

        #   we have outgoing changesets but refused to push

        # - other values as described by addchangegroup()

        self.cgresult = None

        # Boolean value for the bookmark push

        self.bkresult = None

        # discover.outgoing object (contains common and outgoing data)

        self.outgoing = None

        # all remote heads before the push

        self.remoteheads = None

        # testable as a boolean indicating if any nodes are missing locally.

        self.incoming = None

        # phases changes that must be pushed along side the changesets

        self.outdatedphases = None

        # phases changes that must be pushed if changeset push fails

        self.fallbackoutdatedphases = None

        # outgoing obsmarkers

        self.outobsmarkers = set()

        # outgoing bookmarks

        self.outbookmarks = []

        # transaction manager

        self.trmanager = None

    @util.propertycache

    def futureheads(self):

        """future remote heads if the changeset push succeeds"""

        return self.outgoing.missingheads

    @util.propertycache

    def fallbackheads(self):

        """future remote heads if the changeset push fails"""

        if self.revs is None:

            # not target to push, all common are relevant

            return self.outgoing.commonheads

        unfi = self.repo.unfiltered()

        # I want cheads = heads(::missingheads and ::commonheads)

        # (missingheads is revs with secret changeset filtered out)

        #

        # This can be expressed as:

        #     cheads = ( (missingheads and ::commonheads)

        #              + (commonheads and ::missingheads))"

        #              )

        #

        # while trying to push we already computed the following:

        #     common = (::commonheads)

        #     missing = ((commonheads::missingheads) - commonheads)

        #

        # We can pick:

        # * missingheads part of common (::commonheads)

        common = set(self.outgoing.common)

        nm = self.repo.changelog.nodemap

        cheads = [node for node in self.revs if nm[node] in common]

        # and

        # * commonheads parents on missing

        revset = unfi.set('%ln and parents(roots(%ln))',

                         self.outgoing.commonheads,

                         self.outgoing.missing)

        cheads.extend(c.node() for c in revset)

        return cheads

    @property

    def commonheads(self):

        """set of all common heads after changeset bundle push"""

        if self.cgresult:

            return self.futureheads

        else:

            return self.fallbackheads

# mapping of message used when pushing bookmark

bookmsgmap = {'update': (_("updating bookmark %s\n"),

                         _('updating bookmark %s failed!\n')),

              'export': (_("exporting bookmark %s\n"),

                         _('exporting bookmark %s failed!\n')),

              'delete': (_("deleting remote bookmark %s\n"),

                         _('deleting remote bookmark %s failed!\n')),

              }

def push(repo, remote, force=False, revs=None, newbranch=False, bookmarks=()):

    '''Push outgoing changesets (limited by revs) from a local

    repository to remote. Return an integer:

      - None means nothing to push

      - 0 means HTTP error

      - 1 means we pushed and remote head count is unchanged *or*

        we have outgoing changesets but refused to push

      - other values as described by addchangegroup()

    '''

    pushop = pushoperation(repo, remote, force, revs, newbranch, bookmarks)

    if pushop.remote.local():

        missing = (set(pushop.repo.requirements)

                   - pushop.remote.local().supported)

        if missing:

            msg = _("required features are not"

                    " supported in the destination:"

                    " %s") % (', '.join(sorted(missing)))

            raise util.Abort(msg)

    # there are two ways to push to remote repo:

    #

    # addchangegroup assumes local user can lock remote

    # repo (local filesystem, old ssh servers).

    #

    # unbundle assumes local user cannot lock remote repo (new ssh

    # servers, http servers).

    if not pushop.remote.canpush():

        raise util.Abort(_("destination does not support push"))

    # get local lock as we might write phase data

    localwlock = locallock = None

    try:

        # bundle2 push may receive a reply bundle touching bookmarks or other

        # things requiring the wlock. Take it now to ensure proper ordering.

        maypushback = pushop.ui.configbool('experimental', 'bundle2.pushback')

        if _canusebundle2(pushop) and maypushback:

            localwlock = pushop.repo.wlock()

        locallock = pushop.repo.lock()

        pushop.locallocked = True

    except IOError, err:

        pushop.locallocked = False

        if err.errno != errno.EACCES:

            raise

        # source repo cannot be locked.

        # We do not abort the push, but just disable the local phase

        # synchronisation.

        msg = 'cannot lock source repository: %s\n' % err

        pushop.ui.debug(msg)

    try:

        if pushop.locallocked:

            pushop.trmanager = transactionmanager(repo,

                                                  'push-response',

                                                  pushop.remote.url())

        pushop.repo.checkpush(pushop)

        lock = None

        unbundle = pushop.remote.capable('unbundle')

        if not unbundle:

            lock = pushop.remote.lock()

        try:

            _pushdiscovery(pushop)

            if _canusebundle2(pushop):

                _pushbundle2(pushop)

            _pushchangeset(pushop)

            _pushsyncphase(pushop)

            _pushobsolete(pushop)

            _pushbookmark(pushop)

        finally:

            if lock is not None:

                lock.release()

        if pushop.trmanager:

            pushop.trmanager.close()

    finally:

        if pushop.trmanager:

            pushop.trmanager.release()

        if locallock is not None:

            locallock.release()

        if localwlock is not None:

            localwlock.release()

    return pushop

# list of steps to perform discovery before push

pushdiscoveryorder = []

# Mapping between step name and function

#

# This exists to help extensions wrap steps if necessary

pushdiscoverymapping = {}

def pushdiscovery(stepname):

    """decorator for function performing discovery before push

    The function is added to the step -> function mapping and appended to the

    list of steps.  Beware that decorated function will be added in order (this

    may matter).

    You can only use this decorator for a new step, if you want to wrap a step

    from an extension, change the pushdiscovery dictionary directly."""

    def dec(func):

        assert stepname not in pushdiscoverymapping

        pushdiscoverymapping[stepname] = func

        pushdiscoveryorder.append(stepname)

        return func

    return dec

def _pushdiscovery(pushop):

    """Run all discovery steps"""

    for stepname in pushdiscoveryorder:

        step = pushdiscoverymapping[stepname]

        step(pushop)

@pushdiscovery('changeset')

def _pushdiscoverychangeset(pushop):

    """discover the changeset that need to be pushed"""

    fci = discovery.findcommonincoming

    commoninc = fci(pushop.repo, pushop.remote, force=pushop.force)

    common, inc, remoteheads = commoninc

    fco = discovery.findcommonoutgoing

    outgoing = fco(pushop.repo, pushop.remote, onlyheads=pushop.revs,

                   commoninc=commoninc, force=pushop.force)

    pushop.outgoing = outgoing

    pushop.remoteheads = remoteheads

    pushop.incoming = inc

@pushdiscovery('phase')

def _pushdiscoveryphase(pushop):

    """discover the phase that needs to be pushed

    (computed for both success and failure case for changesets push)"""

    outgoing = pushop.outgoing

    unfi = pushop.repo.unfiltered()

    remotephases = pushop.remote.listkeys('phases')

    publishing = remotephases.get('publishing', False)

    ana = phases.analyzeremotephases(pushop.repo,

                                     pushop.fallbackheads,

                                     remotephases)

    pheads, droots = ana

    extracond = ''

    if not publishing:

        extracond = ' and public()'

    revset = 'heads((%%ln::%%ln) %s)' % extracond

    # Get the list of all revs draft on remote by public here.

    # XXX Beware that revset break if droots is not strictly

    # XXX root we may want to ensure it is but it is costly

    fallback = list(unfi.set(revset, droots, pushop.fallbackheads))

    if not outgoing.missing:

        future = fallback

    else:

        # adds changeset we are going to push as draft

        #

        # should not be necessary for publishing server, but because of an

        # issue fixed in xxxxx we have to do it anyway.

        fdroots = list(unfi.set('roots(%ln  + %ln::)',

                       outgoing.missing, droots))

        fdroots = [f.node() for f in fdroots]

        future = list(unfi.set(revset, fdroots, pushop.futureheads))

    pushop.outdatedphases = future

    pushop.fallbackoutdatedphases = fallback

@pushdiscovery('obsmarker')

def _pushdiscoveryobsmarkers(pushop):

    if (obsolete.isenabled(pushop.repo, obsolete.exchangeopt)

        and pushop.repo.obsstore

        and 'obsolete' in pushop.remote.listkeys('namespaces')):

        repo = pushop.repo

        # very naive computation, that can be quite expensive on big repo.

        # However: evolution is currently slow on them anyway.

        nodes = (c.node() for c in repo.set('::%ln', pushop.futureheads))

        pushop.outobsmarkers = pushop.repo.obsstore.relevantmarkers(nodes)

@pushdiscovery('bookmarks')

def _pushdiscoverybookmarks(pushop):

    ui = pushop.ui

    repo = pushop.repo.unfiltered()

    remote = pushop.remote

    ui.debug("checking for updated bookmarks\n")

    ancestors = ()

    if pushop.revs:

        revnums = map(repo.changelog.rev, pushop.revs)

        ancestors = repo.changelog.ancestors(revnums, inclusive=True)

    remotebookmark = remote.listkeys('bookmarks')

    explicit = set(pushop.bookmarks)

    comp = bookmod.compare(repo, repo._bookmarks, remotebookmark, srchex=hex)

    addsrc, adddst, advsrc, advdst, diverge, differ, invalid, same = comp

    for b, scid, dcid in advsrc:

        if b in explicit:

            explicit.remove(b)

        if not ancestors or repo[scid].rev() in ancestors:

            pushop.outbookmarks.append((b, dcid, scid))

    # search added bookmark

    for b, scid, dcid in addsrc:

        if b in explicit:

            explicit.remove(b)

            pushop.outbookmarks.append((b, '', scid))

    # search for overwritten bookmark

    for b, scid, dcid in advdst + diverge + differ:

        if b in explicit:

            explicit.remove(b)

            pushop.outbookmarks.append((b, dcid, scid))

    # search for bookmark to delete

    for b, scid, dcid in adddst:

        if b in explicit:

            explicit.remove(b)

            # treat as "deleted locally"

            pushop.outbookmarks.append((b, dcid, ''))

    # identical bookmarks shouldn't get reported