# changegroup.py - Mercurial changegroup manipulation functions

#

#  Copyright 2006 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 __future__ import absolute_import

import os

import struct

import tempfile

import weakref

from .i18n import _

from .node import (

    hex,

    nullid,

    nullrev,

    short,

)

from . import (

    branchmap,

    dagutil,

    discovery,

    error,

    mdiff,

    phases,

    util,

)

_CHANGEGROUPV1_DELTA_HEADER = "20s20s20s20s"

_CHANGEGROUPV2_DELTA_HEADER = "20s20s20s20s20s"

def readexactly(stream, n):

    '''read n bytes from stream.read and abort if less was available'''

    s = stream.read(n)

    if len(s) < n:

        raise util.Abort(_("stream ended unexpectedly"

                           " (got %d bytes, expected %d)")

                          % (len(s), n))

    return s

def getchunk(stream):

    """return the next chunk from stream as a string"""

    d = readexactly(stream, 4)

    l = struct.unpack(">l", d)[0]

    if l <= 4:

        if l:

            raise util.Abort(_("invalid chunk length %d") % l)

        return ""

    return readexactly(stream, l - 4)

def chunkheader(length):

    """return a changegroup chunk header (string)"""

    return struct.pack(">l", length + 4)

def closechunk():

    """return a changegroup chunk header (string) for a zero-length chunk"""

    return struct.pack(">l", 0)

def combineresults(results):

    """logic to combine 0 or more addchangegroup results into one"""

    changedheads = 0

    result = 1

    for ret in results:

        # If any changegroup result is 0, return 0

        if ret == 0:

            result = 0

            break

        if ret < -1:

            changedheads += ret + 1

        elif ret > 1:

            changedheads += ret - 1

    if changedheads > 0:

        result = 1 + changedheads

    elif changedheads < 0:

        result = -1 + changedheads

    return result

bundletypes = {

    "": ("", None),       # only when using unbundle on ssh and old http servers

                          # since the unification ssh accepts a header but there

                          # is no capability signaling it.

    "HG20": (), # special-cased below

    "HG10UN": ("HG10UN", None),

    "HG10BZ": ("HG10", 'BZ'),

    "HG10GZ": ("HG10GZ", 'GZ'),

}

# hgweb uses this list to communicate its preferred type

bundlepriority = ['HG10GZ', 'HG10BZ', 'HG10UN']

def writebundle(ui, cg, filename, bundletype, vfs=None, compression=None):

    """Write a bundle file and return its filename.

    Existing files will not be overwritten.

    If no filename is specified, a temporary file is created.

    bz2 compression can be turned off.

    The bundle file will be deleted in case of errors.

    """

    fh = None

    cleanup = None

    try:

        if filename:

            if vfs:

                fh = vfs.open(filename, "wb")

            else:

                fh = open(filename, "wb")

        else:

            fd, filename = tempfile.mkstemp(prefix="hg-bundle-", suffix=".hg")

            fh = os.fdopen(fd, "wb")

        cleanup = filename

        if bundletype == "HG20":

            from . import bundle2

            bundle = bundle2.bundle20(ui)

            bundle.setcompression(compression)

            part = bundle.newpart('changegroup', data=cg.getchunks())

            part.addparam('version', cg.version)

            z = util.compressors[None]()

            chunkiter = bundle.getchunks()

        else:

            # compression argument is only for the bundle2 case

            assert compression is None

            if cg.version != '01':

                raise util.Abort(_('old bundle types only supports v1 '

                                   'changegroups'))

            header, comp = bundletypes[bundletype]

            fh.write(header)

            if comp not in util.compressors:

                raise util.Abort(_('unknown stream compression type: %s')

                                 % comp)

            z = util.compressors[comp]()

            chunkiter = cg.getchunks()

        # parse the changegroup data, otherwise we will block

        # in case of sshrepo because we don't know the end of the stream

        # an empty chunkgroup is the end of the changegroup

        # a changegroup has at least 2 chunkgroups (changelog and manifest).

        # after that, an empty chunkgroup is the end of the changegroup

        for chunk in chunkiter:

            fh.write(z.compress(chunk))

        fh.write(z.flush())

        cleanup = None

        return filename

    finally:

        if fh is not None:

            fh.close()

        if cleanup is not None:

            if filename and vfs:

                vfs.unlink(cleanup)

            else:

                os.unlink(cleanup)

class cg1unpacker(object):

    deltaheader = _CHANGEGROUPV1_DELTA_HEADER

    deltaheadersize = struct.calcsize(deltaheader)

    version = '01'

    def __init__(self, fh, alg):

        if alg == 'UN':

            alg = None # get more modern without breaking too much

        if not alg in util.decompressors:

            raise util.Abort(_('unknown stream compression type: %s')

                             % alg)

        if alg == 'BZ':

            alg = '_truncatedBZ'

        self._stream = util.decompressors[alg](fh)

        self._type = alg

        self.callback = None

    def compressed(self):

        return self._type is not None

    def read(self, l):

        return self._stream.read(l)

    def seek(self, pos):

        return self._stream.seek(pos)

    def tell(self):

        return self._stream.tell()

    def close(self):

        return self._stream.close()

    def chunklength(self):

        d = readexactly(self._stream, 4)

        l = struct.unpack(">l", d)[0]

        if l <= 4:

            if l:

                raise util.Abort(_("invalid chunk length %d") % l)

            return 0

        if self.callback:

            self.callback()

        return l - 4

    def changelogheader(self):

        """v10 does not have a changelog header chunk"""

        return {}

    def manifestheader(self):

        """v10 does not have a manifest header chunk"""

        return {}

    def filelogheader(self):

        """return the header of the filelogs chunk, v10 only has the filename"""

        l = self.chunklength()

        if not l:

            return {}

        fname = readexactly(self._stream, l)

        return {'filename': fname}

    def _deltaheader(self, headertuple, prevnode):

        node, p1, p2, cs = headertuple

        if prevnode is None:

            deltabase = p1

        else:

            deltabase = prevnode

        return node, p1, p2, deltabase, cs

    def deltachunk(self, prevnode):

        l = self.chunklength()

        if not l:

            return {}

        headerdata = readexactly(self._stream, self.deltaheadersize)

        header = struct.unpack(self.deltaheader, headerdata)

        delta = readexactly(self._stream, l - self.deltaheadersize)

        node, p1, p2, deltabase, cs = self._deltaheader(header, prevnode)

        return {'node': node, 'p1': p1, 'p2': p2, 'cs': cs,

                'deltabase': deltabase, 'delta': delta}

    def getchunks(self):

        """returns all the chunks contains in the bundle

        Used when you need to forward the binary stream to a file or another

        network API. To do so, it parse the changegroup data, otherwise it will

        block in case of sshrepo because it don't know the end of the stream.

        """

        # an empty chunkgroup is the end of the changegroup

        # a changegroup has at least 2 chunkgroups (changelog and manifest).

        # after that, an empty chunkgroup is the end of the changegroup

        empty = False

        count = 0

        while not empty or count <= 2:

            empty = True

            count += 1

            while True:

                chunk = getchunk(self)

                if not chunk:

                    break

                empty = False

                yield chunkheader(len(chunk))

                pos = 0

                while pos < len(chunk):

                    next = pos + 2**20

                    yield chunk[pos:next]

                    pos = next

            yield closechunk()

class cg2unpacker(cg1unpacker):

    deltaheader = _CHANGEGROUPV2_DELTA_HEADER

    deltaheadersize = struct.calcsize(deltaheader)

    version = '02'

    def _deltaheader(self, headertuple, prevnode):

        node, p1, p2, deltabase, cs = headertuple

        return node, p1, p2, deltabase, cs

class headerlessfixup(object):

    def __init__(self, fh, h):

        self._h = h

        self._fh = fh

    def read(self, n):

        if self._h:

            d, self._h = self._h[:n], self._h[n:]

            if len(d) < n:

                d += readexactly(self._fh, n - len(d))

            return d

        return readexactly(self._fh, n)

class cg1packer(object):

    deltaheader = _CHANGEGROUPV1_DELTA_HEADER

    version = '01'

    def __init__(self, repo, bundlecaps=None):

        """Given a source repo, construct a bundler.

        bundlecaps is optional and can be used to specify the set of

        capabilities which can be used to build the bundle.

        """

        # Set of capabilities we can use to build the bundle.

        if bundlecaps is None:

            bundlecaps = set()

        self._bundlecaps = bundlecaps

        # experimental config: bundle.reorder

        reorder = repo.ui.config('bundle', 'reorder', 'auto')

        if reorder == 'auto':

            reorder = None

        else:

            reorder = util.parsebool(reorder)

        self._repo = repo

        self._reorder = reorder

        self._progress = repo.ui.progress

        if self._repo.ui.verbose and not self._repo.ui.debugflag:

            self._verbosenote = self._repo.ui.note

        else:

            self._verbosenote = lambda s: None

    def close(self):

        return closechunk()

    def fileheader(self, fname):

        return chunkheader(len(fname)) + fname

    def group(self, nodelist, revlog, lookup, units=None):

        """Calculate a delta group, yielding a sequence of changegroup chunks

        (strings).

        Given a list of changeset revs, return a set of deltas and

        metadata corresponding to nodes. The first delta is

        first parent(nodelist[0]) -> nodelist[0], the receiver is

        guaranteed to have this parent as it has all history before

        these changesets. In the case firstparent is nullrev the

        changegroup starts with a full revision.

        If units is not None, progress detail will be generated, units specifies

        the type of revlog that is touched (changelog, manifest, etc.).

        """

        # if we don't have any revisions touched by these changesets, bail

        if len(nodelist) == 0:

            yield self.close()

            return

        # for generaldelta revlogs, we linearize the revs; this will both be

        # much quicker and generate a much smaller bundle

        if (revlog._generaldelta and self._reorder is None) or self._reorder:

            dag = dagutil.revlogdag(revlog)

            revs = set(revlog.rev(n) for n in nodelist)

            revs = dag.linearize(revs)

        else:

            revs = sorted([revlog.rev(n) for n in nodelist])

        # add the parent of the first rev

        p = revlog.parentrevs(revs[0])[0]

        revs.insert(0, p)

        # build deltas

        total = len(revs) - 1

        msgbundling = _('bundling')

        for r in xrange(len(revs) - 1):

            if units is not None:

                self._progress(msgbundling, r + 1, unit=units, total=total)

            prev, curr = revs[r], revs[r + 1]

            linknode = lookup(revlog.node(curr))

            for c in self.revchunk(revlog, curr, prev, linknode):

                yield c

        if units is not None:

            self._progress(msgbundling, None)

        yield self.close()

    # filter any nodes that claim to be part of the known set

    def prune(self, revlog, missing, commonrevs):

        rr, rl = revlog.rev, revlog.linkrev

        return [n for n in missing if rl(rr(n)) not in commonrevs]

    def generate(self, commonrevs, clnodes, fastpathlinkrev, source):

        '''yield a sequence of changegroup chunks (strings)'''

        repo = self._repo

        cl = repo.changelog

        ml = repo.manifest

        clrevorder = {}

        mfs = {} # needed manifests

        fnodes = {} # needed file nodes

        changedfiles = set()

        # Callback for the changelog, used to collect changed files and manifest

        # nodes.

        # Returns the linkrev node (identity in the changelog case).

        def lookupcl(x):