'''enable experimental obsolescence feature of Mercurial

OBSOLESCENCE IS AN EXPERIMENTAL FEATURE MAKE SURE YOU UNDERSTOOD THE INVOLVED

CONCEPT BEFORE USING IT.

/!\ THIS EXTENSION IS INTENDED FOR SERVER SIDE ONLY USAGE /!\

For client side usages it is recommended to use the evolve extension for

improved user interface.'''

from __future__ import absolute_import

import hashlib

import struct

from cStringIO import StringIO

import sys

import os

from mercurial import (

    error,

    exchange,

    extensions,

    localrepo,

    lock as lockmod,

    node,

    obsolete,

    util,

    wireproto

)

from mercurial.hgweb import hgweb_mod

from mercurial.i18n import _

_pack = struct.pack

gboptslist = gboptsmap = None

try:

    gboptslist = getattr(wireproto, 'gboptslist', None)

    gboptsmap = getattr(wireproto, 'gboptsmap', None)

except (ImportError, AttributeError):

    raise error.Abort('Your Mercurial is too old for this version of Evolve\n'

                      'requires version 3.0.1 or above')

# Start of simple4server specific content

from mercurial import pushkey

try:

    from . import (

        metadata,

        utility,

    )

except ValueError as exc:

    if exc.message != 'Attempted relative import in non-package':

        raise

    # extension imported using direct path

    sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))

    from evolve import (

        metadata,

        utility,

    )

__version__ = metadata.__version__

testedwith = metadata.testedwith

minimumhgversion = metadata.minimumhgversion

buglink = metadata.buglink

obsexcmsg = utility.obsexcmsg

# specific content also include the wrapping int extsetup

def _nslist(orig, repo):

    rep = orig(repo)

    if not repo.ui.configbool('__temporary__', 'advertiseobsolete', True):

        rep.pop('obsolete')

    return rep

# End of simple4server specific content

def _pushobsmarkers(repo, data):

    tr = lock = None

    try:

        lock = repo.lock()

        tr = repo.transaction('pushkey: obsolete markers')

        new = repo.obsstore.mergemarkers(tr, data)

        if new is not None:

            obsexcmsg(repo.ui, "%i obsolescence markers added\n" % new, True)

        tr.close()

    finally:

        lockmod.release(tr, lock)

    repo.hook('evolve_pushobsmarkers')

def srv_pushobsmarkers(repo, proto):

    """wireprotocol command"""

    fp = StringIO()

    proto.redirect()

    proto.getfile(fp)

    data = fp.getvalue()

    fp.close()

    _pushobsmarkers(repo, data)

    return wireproto.pushres(0)

def _getobsmarkersstream(repo, heads=None, common=None):

    """Get a binary stream for all markers relevant to `::<heads> - ::<common>`

    """

    revset = ''

    args = []

    repo = repo.unfiltered()

    if heads is None:

        revset = 'all()'

    elif heads:

        revset += "(::%ln)"

        args.append(heads)

    else:

        assert False, 'pulling no heads?'

    if common:

        revset += ' - (::%ln)'

        args.append(common)

    nodes = [c.node() for c in repo.set(revset, *args)]

    markers = repo.obsstore.relevantmarkers(nodes)

    obsdata = StringIO()

    for chunk in obsolete.encodemarkers(markers, True):

        obsdata.write(chunk)

    obsdata.seek(0)

    return obsdata

# The wireproto.streamres API changed, handling chunking and compression

# directly. Handle either case.

if util.safehasattr(wireproto.abstractserverproto, 'groupchunks'):

    # We need to handle chunking and compression directly

    def streamres(d, proto):

        return wireproto.streamres(proto.groupchunks(d))

else:

    # Leave chunking and compression to streamres

    def streamres(d, proto):

        return wireproto.streamres(reader=d, v1compressible=True)

def srv_pullobsmarkers(repo, proto, others):

    """serves a binary stream of markers.

    Serves relevant to changeset between heads and common. The stream is prefix

    by a -string- representation of an integer. This integer is the size of the

    stream."""

    opts = wireproto.options('', ['heads', 'common'], others)

    for k, v in opts.iteritems():

        if k in ('heads', 'common'):

            opts[k] = wireproto.decodelist(v)

    obsdata = _getobsmarkersstream(repo, **opts)

    finaldata = StringIO()

    obsdata = obsdata.getvalue()

    finaldata.write('%20i' % len(obsdata))

    finaldata.write(obsdata)

    finaldata.seek(0)

    return streamres(finaldata, proto)

def _obsrelsethashtreefm0(repo):

    return _obsrelsethashtree(repo, obsolete._fm0encodeonemarker)

def _obsrelsethashtreefm1(repo):

    return _obsrelsethashtree(repo, obsolete._fm1encodeonemarker)

def _obsrelsethashtree(repo, encodeonemarker):

    cache = []

    unfi = repo.unfiltered()

    markercache = {}

    repo.ui.progress(_("preparing locally"), 0, total=len(unfi))

    for i in unfi:

        ctx = unfi[i]

        entry = 0

        sha = hashlib.sha1()

        # add data from p1

        for p in ctx.parents():

            p = p.rev()

            if p < 0:

                p = node.nullid

            else:

                p = cache[p][1]

            if p != node.nullid:

                entry += 1

                sha.update(p)

        tmarkers = repo.obsstore.relevantmarkers([ctx.node()])

        if tmarkers:

            bmarkers = []

            for m in tmarkers:

                if m not in markercache:

                    markercache[m] = encodeonemarker(m)

                bmarkers.append(markercache[m])

            bmarkers.sort()

            for m in bmarkers:

                entry += 1

                sha.update(m)

        if entry:

            cache.append((ctx.node(), sha.digest()))

        else:

            cache.append((ctx.node(), node.nullid))

        repo.ui.progress(_("preparing locally"), i, total=len(unfi))

    repo.ui.progress(_("preparing locally"), None)

    return cache

def _obshash(repo, nodes, version=0):

    if version == 0:

        hashs = _obsrelsethashtreefm0(repo)

    elif version == 1:

        hashs = _obsrelsethashtreefm1(repo)

    else:

        assert False

    nm = repo.changelog.nodemap

    revs = [nm.get(n) for n in nodes]

    return [r is None and node.nullid or hashs[r][1] for r in revs]

def srv_obshash(repo, proto, nodes):

    return wireproto.encodelist(_obshash(repo, wireproto.decodelist(nodes)))

def srv_obshash1(repo, proto, nodes):

    return wireproto.encodelist(_obshash(repo, wireproto.decodelist(nodes),

                                version=1))

def capabilities(orig, repo, proto):

    """wrapper to advertise new capability"""

    caps = orig(repo, proto)

    advertise = repo.ui.configbool('__temporary__', 'advertiseobsolete', True)

    if obsolete.isenabled(repo, obsolete.exchangeopt) and advertise:

def _getbundleobsmarkerpart(orig, bundler, repo, source, **kwargs):

    if 'evo_obscommon' not in kwargs:

        return orig(bundler, repo, source, **kwargs)

    heads = kwargs.get('heads')

    if kwargs.get('obsmarkers', False):

        if heads is None:

            heads = repo.heads()

        obscommon = kwargs.get('evo_obscommon', ())

        assert obscommon

        obsset = repo.unfiltered().set('::%ln - ::%ln', heads, obscommon)

        subset = [c.node() for c in obsset]

        markers = repo.obsstore.relevantmarkers(subset)

        exchange.buildobsmarkerspart(bundler, markers)

def extsetup(ui):

    localrepo.moderncaps.add('_evoext_b2x_obsmarkers_0')

    gboptsmap['evo_obscommon'] = 'nodes'

    hgweb_mod.perms['evoext_pushobsmarkers_0'] = 'push'

    hgweb_mod.perms['evoext_pullobsmarkers_0'] = 'pull'

    hgweb_mod.perms['evoext_obshash'] = 'pull'

    hgweb_mod.perms['evoext_obshash1'] = 'pull'

    wireproto.commands['evoext_pushobsmarkers_0'] = (srv_pushobsmarkers, '')

    wireproto.commands['evoext_pullobsmarkers_0'] = (srv_pullobsmarkers, '*')

    # wrap module content

    origfunc = exchange.getbundle2partsmapping['obsmarkers']

    def newfunc(*args, **kwargs):

        return _getbundleobsmarkerpart(origfunc, *args, **kwargs)

    exchange.getbundle2partsmapping['obsmarkers'] = newfunc

    extensions.wrapfunction(wireproto, 'capabilities', capabilities)

    # wrap command content

    oldcap, args = wireproto.commands['capabilities']

    def newcap(repo, proto):

        return capabilities(oldcap, repo, proto)

    wireproto.commands['capabilities'] = (newcap, args)

    wireproto.commands['evoext_obshash'] = (srv_obshash, 'nodes')

    wireproto.commands['evoext_obshash1'] = (srv_obshash1, 'nodes')

    # specific simple4server content

    extensions.wrapfunction(pushkey, '_nslist', _nslist)

    pushkey._namespaces['namespaces'] = (lambda *x: False, pushkey._nslist)

def reposetup(ui, repo):

    evolveopts = ui.configlist('experimental', 'evolution')

    if not evolveopts:

        evolveopts = 'all'

        ui.setconfig('experimental', 'evolution', evolveopts)