# revlog.py - storage back-end for mercurial

#

# 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.

"""Storage back-end for Mercurial.

This provides efficient delta storage with O(1) retrieve and append

and O(changes) merge between branches.

"""

# import stuff from node for others to import from revlog

from node import bin, hex, nullid, nullrev, short #@UnusedImport

from i18n import _

import changegroup, ancestor, mdiff, parsers, error, util

import struct, zlib, errno

_pack = struct.pack

_unpack = struct.unpack

_compress = zlib.compress

_decompress = zlib.decompress

_sha = util.sha1

# revlog header flags

REVLOGV0 = 0

REVLOGNG = 1

REVLOGNGINLINEDATA = (1 << 16)

REVLOGSHALLOW = (1 << 17)

REVLOG_DEFAULT_FLAGS = REVLOGNGINLINEDATA

REVLOG_DEFAULT_FORMAT = REVLOGNG

REVLOG_DEFAULT_VERSION = REVLOG_DEFAULT_FORMAT | REVLOG_DEFAULT_FLAGS

REVLOGNG_FLAGS = REVLOGNGINLINEDATA | REVLOGSHALLOW

# revlog index flags

REVIDX_PARENTDELTA  = 1

REVIDX_PUNCHED_FLAG = 2

REVIDX_KNOWN_FLAGS = REVIDX_PUNCHED_FLAG | REVIDX_PARENTDELTA

# max size of revlog with inline data

_maxinline = 131072

RevlogError = error.RevlogError

LookupError = error.LookupError

def getoffset(q):

    return int(q >> 16)

def gettype(q):

    return int(q & 0xFFFF)

def offset_type(offset, type):

    return long(long(offset) << 16 | type)

nullhash = _sha(nullid)

def hash(text, p1, p2):

    """generate a hash from the given text and its parent hashes

    This hash combines both the current file contents and its history

    in a manner that makes it easy to distinguish nodes with the same

    content in the revision graph.

    """

    # As of now, if one of the parent node is null, p2 is null

    if p2 == nullid:

        # deep copy of a hash is faster than creating one

        s = nullhash.copy()

        s.update(p1)

    else:

        # none of the parent nodes are nullid

        l = [p1, p2]

        l.sort()

        s = _sha(l[0])

        s.update(l[1])

    s.update(text)

    return s.digest()

def compress(text):

    """ generate a possibly-compressed representation of text """

    if not text:

        return ("", text)

    l = len(text)

    bin = None

    if l < 44:

        pass

    elif l > 1000000:

        # zlib makes an internal copy, thus doubling memory usage for

        # large files, so lets do this in pieces

        z = zlib.compressobj()

        p = []

        pos = 0

        while pos < l:

            pos2 = pos + 2**20

            p.append(z.compress(text[pos:pos2]))

            pos = pos2

        p.append(z.flush())

        if sum(map(len, p)) < l:

            bin = "".join(p)

    else:

        bin = _compress(text)

    if bin is None or len(bin) > l:

        if text[0] == '\0':

            return ("", text)

        return ('u', text)

    return ("", bin)

def decompress(bin):

    """ decompress the given input """

    if not bin:

        return bin

    t = bin[0]

    if t == '\0':

        return bin

    if t == 'x':

        return _decompress(bin)

    if t == 'u':

        return bin[1:]

    raise RevlogError(_("unknown compression type %r") % t)

indexformatv0 = ">4l20s20s20s"

v0shaoffset = 56

class revlogoldio(object):

    def __init__(self):

        self.size = struct.calcsize(indexformatv0)

    def parseindex(self, fp, data, inline):

        s = self.size

        index = []

        nodemap =  {nullid: nullrev}

        n = off = 0

        l = len(data)

        while off + s <= l:

            cur = data[off:off + s]

            off += s

            e = _unpack(indexformatv0, cur)

            # transform to revlogv1 format

            e2 = (offset_type(e[0], 0), e[1], -1, e[2], e[3],

                  nodemap.get(e[4], nullrev), nodemap.get(e[5], nullrev), e[6])

            index.append(e2)

            nodemap[e[6]] = n

            n += 1

        return index, nodemap, None

    def packentry(self, entry, node, version, rev):

        if gettype(entry[0]):

            raise RevlogError(_("index entry flags need RevlogNG"))

        e2 = (getoffset(entry[0]), entry[1], entry[3], entry[4],

              node(entry[5]), node(entry[6]), entry[7])

        return _pack(indexformatv0, *e2)

# index ng:

#  6 bytes: offset

#  2 bytes: flags

#  4 bytes: compressed length

#  4 bytes: uncompressed length

#  4 bytes: base rev

#  4 bytes: link rev

#  4 bytes: parent 1 rev

#  4 bytes: parent 2 rev

# 32 bytes: nodeid

indexformatng = ">Qiiiiii20s12x"

ngshaoffset = 32

versionformat = ">I"

class revlogio(object):

    def __init__(self):

        self.size = struct.calcsize(indexformatng)

    def parseindex(self, fp, data, inline):

        # call the C implementation to parse the index data

        index, nodemap, cache = parsers.parse_index(data, inline)

        return index, nodemap, cache

    def packentry(self, entry, node, version, rev):

        p = _pack(indexformatng, *entry)

        if rev == 0:

            p = _pack(versionformat, version) + p[4:]

        return p

class revlog(object):

    """

    the underlying revision storage object

    A revlog consists of two parts, an index and the revision data.

    The index is a file with a fixed record size containing

    information on each revision, including its nodeid (hash), the

    nodeids of its parents, the position and offset of its data within

    the data file, and the revision it's based on. Finally, each entry

    contains a linkrev entry that can serve as a pointer to external

    data.

    The revision data itself is a linear collection of data chunks.

    Each chunk represents a revision and is usually represented as a

    delta against the previous chunk. To bound lookup time, runs of

    deltas are limited to about 2 times the length of the original

    version data. This makes retrieval of a version proportional to

    its size, or O(1) relative to the number of revisions.

    Both pieces of the revlog are written to in an append-only

    fashion, which means we never need to rewrite a file to insert or

    remove data, and can use some simple techniques to avoid the need

    for locking while reading.

    """

    def __init__(self, opener, indexfile, shallowroot=None):

        """

        create a revlog object

        opener is a function that abstracts the file opening operation

        and can be used to implement COW semantics or the like.

        """

        self.indexfile = indexfile

        self.datafile = indexfile[:-2] + ".d"

        self.opener = opener

        self._cache = None

        self._chunkcache = (0, '')

        self.nodemap = {nullid: nullrev}

        self.index = []

        self._shallowroot = shallowroot

        self._parentdelta = 0

        v = REVLOG_DEFAULT_VERSION

        if hasattr(opener, 'options') and 'defversion' in opener.options:

            v = opener.options['defversion']

            if v & REVLOGNG:

                v |= REVLOGNGINLINEDATA

            if v & REVLOGNG and 'parentdelta' in opener.options:

                self._parentdelta = 1

        if shallowroot:

            v |= REVLOGSHALLOW

        i = ''

        try:

            f = self.opener(self.indexfile)

            if len(i) > 0:

                v = struct.unpack(versionformat, i[:4])[0]

        except IOError, inst:

            if inst.errno != errno.ENOENT:

                raise

        self.version = v

        self._inline = v & REVLOGNGINLINEDATA

        self._shallow = v & REVLOGSHALLOW

        flags = v & ~0xFFFF

        fmt = v & 0xFFFF

        if fmt == REVLOGV0 and flags:

            raise RevlogError(_("index %s unknown flags %#04x for format v0")

                              % (self.indexfile, flags >> 16))

        elif fmt == REVLOGNG and flags & ~REVLOGNG_FLAGS:

            raise RevlogError(_("index %s unknown flags %#04x for revlogng")

                              % (self.indexfile, flags >> 16))

        elif fmt > REVLOGNG:

            raise RevlogError(_("index %s unknown format %d")

                              % (self.indexfile, fmt))

        self._io = revlogio()

        if self.version == REVLOGV0:

            self._io = revlogoldio()

        if i:

            try:

                d = self._io.parseindex(f, i, self._inline)

            except (ValueError, IndexError):

                raise RevlogError(_("index %s is corrupted") % (self.indexfile))

            self.index, self.nodemap, self._chunkcache = d

            if not self._chunkcache:

                self._chunkclear()

        # add the magic null revision at -1 (if it hasn't been done already)

            self.index.append((0, 0, 0, -1, -1, -1, -1, nullid))

    def tip(self):

        return self.node(len(self.index) - 2)

    def __len__(self):

        return len(self.index) - 1

    def __iter__(self):

        for i in xrange(len(self)):

            yield i

    def rev(self, node):

        try:

            return self.nodemap[node]

        except KeyError:

            raise LookupError(node, self.indexfile, _('no node'))

    def node(self, rev):

        return self.index[rev][7]

    def linkrev(self, rev):

        return self.index[rev][4]

    def parents(self, node):

        i = self.index

        d = i[self.rev(node)]

        return i[d[5]][7], i[d[6]][7] # map revisions to nodes inline

    def parentrevs(self, rev):

        return self.index[rev][5:7]

    def start(self, rev):

        return int(self.index[rev][0] >> 16)

    def end(self, rev):

        return self.start(rev) + self.length(rev)

    def length(self, rev):

        return self.index[rev][1]

    def base(self, rev):

        return self.index[rev][3]

    def flags(self, rev):

        return self.index[rev][0] & 0xFFFF

    def rawsize(self, rev):

        """return the length of the uncompressed text for a given revision"""

        l = self.index[rev][2]

        if l >= 0:

            return l

        t = self.revision(self.node(rev))

        return len(t)

    size = rawsize

    def reachable(self, node, stop=None):

        """return the set of all nodes ancestral to a given node, including

         the node itself, stopping when stop is matched"""

        reachable = set((node,))

        visit = [node]

        if stop:

            stopn = self.rev(stop)

        else:

            stopn = 0

        while visit:

            n = visit.pop(0)

            if n == stop:

                continue

            if n == nullid:

                continue

            for p in self.parents(n):

                if self.rev(p) < stopn:

                    continue

                if p not in reachable:

                    reachable.add(p)

                    visit.append(p)

        return reachable

    def ancestors(self, *revs):

        """Generate the ancestors of 'revs' in reverse topological order.

        Yield a sequence of revision numbers starting with the parents

        of each revision in revs, i.e., each revision is *not* considered

        an ancestor of itself.  Results are in breadth-first order:

        parents of each rev in revs, then parents of those, etc.  Result

        does not include the null revision."""

        visit = list(revs)

        seen = set([nullrev])

        while visit:

            for parent in self.parentrevs(visit.pop(0)):

                if parent not in seen:

                    visit.append(parent)

                    seen.add(parent)

                    yield parent

    def descendants(self, *revs):

        """Generate the descendants of 'revs' in revision order.

        Yield a sequence of revision numbers starting with a child of

        some rev in revs, i.e., each revision is *not* considered a

        descendant of itself.  Results are ordered by revision number (a

        topological sort)."""

        first = min(revs)

        if first == nullrev:

            for i in self:

                yield i

            return

        seen = set(revs)