# 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

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 == '2Y':

        return bundle2.unbundle20(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('B2X:OBSMARKERS', data=stream)

    return None

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 = []

    @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

    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 (pushop.repo.ui.configbool('experimental', 'bundle2-exp',

                                          False)

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

                _pushbundle2(pushop)

            _pushchangeset(pushop)

            _pushsyncphase(pushop)

            _pushobsolete(pushop)

            _pushbookmark(pushop)

        finally:

            if lock is not None:

                lock.release()

    finally:

        if locallock is not None:

            locallock.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"""

    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

@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

        #

        # 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

    for b, scid, dcid in same:

        if b in explicit:

            explicit.remove(b)

    if explicit:

        explicit = sorted(explicit)

        # we should probably list all of them

        ui.warn(_('bookmark %s does not exist on the local '

                  'or remote repository!\n') % explicit[0])

        pushop.bkresult = 2

    pushop.outbookmarks.sort()

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