# 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, bundle2

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.unbundle10(fh, alg)

    elif version == '2X':

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

    else:

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

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

        # 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

        # allow push of new branch

        self.newbranch = newbranch

        # did a local lock get acquired?

        self.locallocked = None

        # Integer version of the 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.ret = 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

        # set of all heads common after changeset bundle push

        self.commonheads = None

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

    '''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)

    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

    locallock = None

    try:

        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:

        pushop.repo.checkpush(pushop)

        lock = None

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

        if not unbundle:

            lock = pushop.remote.lock()

        try:

            _pushdiscovery(pushop)

            if _pushcheckoutgoing(pushop):

                pushop.repo.prepushoutgoinghooks(pushop.repo,

                                                 pushop.remote,

                                                 pushop.outgoing)

                if (pushop.repo.ui.configbool('experimental', 'bundle2-exp',

                                              False)

                    and pushop.remote.capable('bundle2-exp')):

                    _pushbundle2(pushop)

                else:

                    _pushchangeset(pushop)

            _pushcomputecommonheads(pushop)

            _pushsyncphase(pushop)

            _pushobsolete(pushop)

        finally:

            if lock is not None:

                lock.release()

    finally:

        if locallock is not None:

            locallock.release()

    _pushbookmark(pushop)

    return pushop.ret

def _pushdiscovery(pushop):

    # discovery

    unfi = pushop.repo.unfiltered()

    fci = discovery.findcommonincoming

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

    common, inc, remoteheads = commoninc

    fco = discovery.findcommonoutgoing

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

                   commoninc=commoninc, force=pushop.force)

    pushop.outgoing = outgoing

    pushop.remoteheads = remoteheads

    pushop.incoming = inc

def _pushcheckoutgoing(pushop):

    outgoing = pushop.outgoing

    unfi = pushop.repo.unfiltered()

    if not outgoing.missing:

        # nothing to push

        scmutil.nochangesfound(unfi.ui, unfi, outgoing.excluded)

        return False

    # something to push

    if not pushop.force:

        # if repo.obsstore == False --> no obsolete

        # then, save the iteration

        if unfi.obsstore:

            # this message are here for 80 char limit reason

            mso = _("push includes obsolete changeset: %s!")

            mst = "push includes %s changeset: %s!"

            # plain versions for i18n tool to detect them

            _("push includes unstable changeset: %s!")

            _("push includes bumped changeset: %s!")

            _("push includes divergent changeset: %s!")

            # If we are to push if there is at least one

            # obsolete or unstable changeset in missing, at

            # least one of the missinghead will be obsolete or

            # unstable. So checking heads only is ok

            for node in outgoing.missingheads:

                ctx = unfi[node]

                if ctx.obsolete():

                    raise util.Abort(mso % ctx)

                elif ctx.troubled():

                    raise util.Abort(_(mst)

                                     % (ctx.troubles()[0],

                                        ctx))

        newbm = pushop.ui.configlist('bookmarks', 'pushing')

        discovery.checkheads(unfi, pushop.remote, outgoing,

                             pushop.remoteheads,

                             pushop.newbranch,

                             bool(pushop.incoming),

                             newbm)

    return True

def _pushbundle2(pushop):

    """push data to the remote using bundle2

    The only currently supported type of data is changegroup but this will

    evolve in the future."""

    # Send known head to the server for race detection.

    capsblob = urllib.unquote(pushop.remote.capable('bundle2-exp'))

    caps = bundle2.decodecaps(capsblob)

    bundler = bundle2.bundle20(pushop.ui, caps)

    # create reply capability

    capsblob = bundle2.encodecaps(pushop.repo.bundle2caps)

    bundler.addpart(bundle2.bundlepart('b2x:replycaps', data=capsblob))

    if not pushop.force:

        part = bundle2.bundlepart('B2X:CHECK:HEADS',

                                  data=iter(pushop.remoteheads))

        bundler.addpart(part)

    extrainfo = _pushbundle2extraparts(pushop, bundler)

    # add the changegroup bundle

    cg = changegroup.getlocalbundle(pushop.repo, 'push', pushop.outgoing)

    cgpart = bundle2.bundlepart('B2X:CHANGEGROUP', data=cg.getchunks())

    bundler.addpart(cgpart)

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

    try:

        reply = pushop.remote.unbundle(stream, ['force'], 'push')

    except bundle2.UnknownPartError, exc:

        raise util.Abort('missing support for %s' % exc)

    try:

        op = bundle2.processbundle(pushop.repo, reply)

    except bundle2.UnknownPartError, exc:

        raise util.Abort('missing support for %s' % exc)

    cgreplies = op.records.getreplies(cgpart.id)

    assert len(cgreplies['changegroup']) == 1

    pushop.ret = cgreplies['changegroup'][0]['return']

    _pushbundle2extrareply(pushop, op, extrainfo)

def _pushbundle2extraparts(pushop, bundler):

    """hook function to let extensions add parts

    Return a dict to let extensions pass data to the reply processing.

    """

    return {}

def _pushbundle2extrareply(pushop, op, extrainfo):

    """hook function to let extensions react to part replies

    The dict from _pushbundle2extrareply is fed to this function.

    """

    pass

def _pushchangeset(pushop):

    """Make the actual push of changeset bundle to remote repo"""

    outgoing = pushop.outgoing

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

    # TODO: get bundlecaps from remote

    bundlecaps = None

    # create a changegroup from local

    if pushop.revs is None and not (outgoing.excluded

                            or pushop.repo.changelog.filteredrevs):

        # push everything,

        # use the fast path, no race possible on push

        bundler = changegroup.bundle10(pushop.repo, bundlecaps)

        cg = changegroup.getsubset(pushop.repo,

                                   outgoing,

                                   bundler,

                                   'push',

                                   fastpath=True)

    else:

        cg = changegroup.getlocalbundle(pushop.repo, 'push', outgoing,

                                        bundlecaps)

    # apply changegroup to remote

    if unbundle:

        # local repo finds heads on server, finds out what

        # revs it must push. once revs transferred, if server

        # finds it has different heads (someone else won

        # commit/push race), server aborts.

        if pushop.force:

            remoteheads = ['force']

        else:

            remoteheads = pushop.remoteheads

        # ssh: return remote's addchangegroup()

        # http: return remote's addchangegroup() or 0 for error

        pushop.ret = pushop.remote.unbundle(cg, remoteheads,

                                            'push')

    else:

        # we return an integer indicating remote head count

        # change

        pushop.ret = pushop.remote.addchangegroup(cg, 'push', pushop.repo.url())

def _pushcomputecommonheads(pushop):

    unfi = pushop.repo.unfiltered()

    if pushop.ret:

        # push succeed, synchronize target of the push

        cheads = pushop.outgoing.missingheads

    elif pushop.revs is None:

        # All out push fails. synchronize all common

        cheads = pushop.outgoing.commonheads

    else:

        # 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(pushop.outgoing.common)

        nm = pushop.repo.changelog.nodemap

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

        # and

        # * commonheads parents on missing

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

                         pushop.outgoing.commonheads,

                         pushop.outgoing.missing)

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

    pushop.commonheads = cheads

def _pushsyncphase(pushop):

    """synchronise phase information locally and remotely"""

    unfi = pushop.repo.unfiltered()

    cheads = pushop.commonheads

    # even when we don't push, exchanging phase data is useful

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

    if (pushop.ui.configbool('ui', '_usedassubrepo', False)

        and remotephases    # server supports phases

        and pushop.ret is None # nothing was pushed

        and remotephases.get('publishing', False)):

        # When:

        # - this is a subrepo push

        # - and remote support phase

        # - and no changeset was pushed

        # - and remote is publishing

        # We may be in issue 3871 case!

        # We drop the possible phase synchronisation done by

        # courtesy to publish changesets possibly locally draft

        # on the remote.

        remotephases = {'publishing': 'True'}

    if not remotephases: # old server or public only reply from non-publishing

        _localphasemove(pushop, cheads)

        # don't push any phase data as there is nothing to push

    else:

        ana = phases.analyzeremotephases(pushop.repo, cheads,

                                         remotephases)

        pheads, droots = ana

        ### Apply remote phase on local

        if remotephases.get('publishing', False):

            _localphasemove(pushop, cheads)

        else: # publish = False

            _localphasemove(pushop, pheads)

            _localphasemove(pushop, cheads, phases.draft)

        ### Apply local phase on remote

        # 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

        outdated =  unfi.set('heads((%ln::%ln) and public())',

                             droots, cheads)

        for newremotehead in outdated:

            r = pushop.remote.pushkey('phases',

                                      newremotehead.hex(),

                                      str(phases.draft),

                                      str(phases.public))

            if not r:

                pushop.ui.warn(_('updating %s to public failed!\n')

                                       % newremotehead)

def _localphasemove(pushop, nodes, phase=phases.public):

    """move <nodes> to <phase> in the local source repo"""

    if pushop.locallocked:

        phases.advanceboundary(pushop.repo, phase, nodes)

    else: