view contrib/dumprevlog @ 44066:f5d2720f3bea

revlog-native: introduced ABI version in capsule

Concerns that an inconsistency could arise between the actual contents
of the capsule in revlog.c and the Rust consumer have been raised after
the switch to the array of data and function pointers in f384d68d8ea8.

It has been suggested that the `version` from parsers.c could be use for
this. In this change, we introduce instead a separate ABI version number,
which should have the following advantages:

- no need to change the consuming Rust code for changes that have nothing
  to do with the contents of the capsule
- the version number in parsers.c is not explicitely flagged as ABI. It's
  not obvious to me whether an ABI change that would be invisible to Python
  would warrant an increment

The drawback is that developers now have to consider two version numbers.

We expect the added cost of the check to be negligible because it occurs
at instantiation of `CIndex` only, which in turn is tied to instantiation
of Python objects such as `LazyAncestors` and `MixedIndex`. Frequent calls
to `Cindex::new` should also probably hit the CPU branch predictor.

Differential Revision: https://phab.mercurial-scm.org/D7856

#!/usr/bin/env python
# Dump revlogs as raw data stream
# $ find .hg/store/ -name "*.i" | xargs dumprevlog > repo.dump

from __future__ import absolute_import, print_function

import sys
from mercurial import (
    encoding,
    node,
    pycompat,
    revlog,
)
from mercurial.utils import procutil

for fp in (sys.stdin, sys.stdout, sys.stderr):
    procutil.setbinary(fp)


def binopen(path, mode=b'rb'):
    if b'b' not in mode:
        mode = mode + b'b'
    return open(path, pycompat.sysstr(mode))


binopen.options = {}


def printb(data, end=b'\n'):
    sys.stdout.flush()
    pycompat.stdout.write(data + end)


for f in sys.argv[1:]:
    r = revlog.revlog(binopen, encoding.strtolocal(f))
    print("file:", f)
    for i in r:
        n = r.node(i)
        p = r.parents(n)
        d = r.revision(n)
        printb(b"node: %s" % node.hex(n))
        printb(b"linkrev: %d" % r.linkrev(i))
        printb(b"parents: %s %s" % (node.hex(p[0]), node.hex(p[1])))
        printb(b"length: %d" % len(d))
        printb(b"-start-")
        printb(d)
        printb(b"-end-")