# debugcommands.py - command processing for debug* commands

#

# Copyright 2005-2016 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 codecs

import collections

import difflib

import errno

import operator

import os

import platform

import random

import re

import socket

import ssl

import stat

import string

import subprocess

import sys

import time

from .i18n import _

from .node import (

    bin,

    hex,

    nullhex,

    nullid,

    nullrev,

    short,

)

from .pycompat import (

    getattr,

    open,

)

from . import (

    bundle2,

    changegroup,

    cmdutil,

    color,

    context,

    copies,

    dagparser,

    encoding,

    error,

    exchange,

    extensions,

    filemerge,

    filesetlang,

    formatter,

    hg,

    httppeer,

    localrepo,

    lock as lockmod,

    logcmdutil,

    merge as mergemod,

    obsolete,

    obsutil,

    pathutil,

    phases,

    policy,

    pvec,

    pycompat,

    registrar,

    repair,

    revlog,

    revset,

    revsetlang,

    scmutil,

    setdiscovery,

    simplemerge,

    sshpeer,

    sslutil,

    streamclone,

    tags as tagsmod,

    templater,

    treediscovery,

    upgrade,

    url as urlmod,

    util,

    vfs as vfsmod,

    wireprotoframing,

    wireprotoserver,

    wireprotov2peer,

)

from .utils import (

    cborutil,

    compression,

    dateutil,

    procutil,

    stringutil,

)

from .revlogutils import (

    deltas as deltautil,

    nodemap,

)

release = lockmod.release

command = registrar.command()

@command(b'debugancestor', [], _(b'[INDEX] REV1 REV2'), optionalrepo=True)

def debugancestor(ui, repo, *args):

    """find the ancestor revision of two revisions in a given index"""

    if len(args) == 3:

        index, rev1, rev2 = args

        r = revlog.revlog(vfsmod.vfs(encoding.getcwd(), audit=False), index)

        lookup = r.lookup

    elif len(args) == 2:

        if not repo:

            raise error.Abort(

                _(b'there is no Mercurial repository here (.hg not found)')

            )

        rev1, rev2 = args

        r = repo.changelog

        lookup = repo.lookup

    else:

        raise error.Abort(_(b'either two or three arguments required'))

    a = r.ancestor(lookup(rev1), lookup(rev2))

    ui.write(b'%d:%s\n' % (r.rev(a), hex(a)))

@command(b'debugapplystreamclonebundle', [], b'FILE')

def debugapplystreamclonebundle(ui, repo, fname):

    """apply a stream clone bundle file"""

    f = hg.openpath(ui, fname)

    gen = exchange.readbundle(ui, f, fname)

    gen.apply(repo)

@command(

    b'debugbuilddag',

    [

        (

            b'm',

            b'mergeable-file',

            None,

            _(b'add single file mergeable changes'),

        ),

        (

            b'o',

            b'overwritten-file',

            None,

            _(b'add single file all revs overwrite'),

        ),

        (b'n', b'new-file', None, _(b'add new file at each rev')),

    ],

    _(b'[OPTION]... [TEXT]'),

)

def debugbuilddag(

    ui,

    repo,

    text=None,

    mergeable_file=False,

    overwritten_file=False,

    new_file=False,

):

    """builds a repo with a given DAG from scratch in the current empty repo

    The description of the DAG is read from stdin if not given on the

    command line.

    Elements:

     - "+n" is a linear run of n nodes based on the current default parent

     - "." is a single node based on the current default parent

     - "$" resets the default parent to null (implied at the start);

           otherwise the default parent is always the last node created

     - "<p" sets the default parent to the backref p

     - "*p" is a fork at parent p, which is a backref

     - "*p1/p2" is a merge of parents p1 and p2, which are backrefs

     - "/p2" is a merge of the preceding node and p2

     - ":tag" defines a local tag for the preceding node

     - "@branch" sets the named branch for subsequent nodes

     - "#...\\n" is a comment up to the end of the line

    Whitespace between the above elements is ignored.

    A backref is either

     - a number n, which references the node curr-n, where curr is the current

       node, or

     - the name of a local tag you placed earlier using ":tag", or

     - empty to denote the default parent.

    All string valued-elements are either strictly alphanumeric, or must

    be enclosed in double quotes ("..."), with "\\" as escape character.

    """

    if text is None:

        ui.status(_(b"reading DAG from stdin\n"))

        text = ui.fin.read()

    cl = repo.changelog

    if len(cl) > 0:

        raise error.Abort(_(b'repository is not empty'))

    # determine number of revs in DAG

    total = 0

    for type, data in dagparser.parsedag(text):

        if type == b'n':

            total += 1

    if mergeable_file:

        linesperrev = 2

        # make a file with k lines per rev

        initialmergedlines = [

            b'%d' % i for i in pycompat.xrange(0, total * linesperrev)

        ]

        initialmergedlines.append(b"")

    tags = []

    progress = ui.makeprogress(

        _(b'building'), unit=_(b'revisions'), total=total

    )

    with progress, repo.wlock(), repo.lock(), repo.transaction(b"builddag"):

        at = -1

        atbranch = b'default'

        nodeids = []

        id = 0

        progress.update(id)

        for type, data in dagparser.parsedag(text):

            if type == b'n':

                ui.note((b'node %s\n' % pycompat.bytestr(data)))

                id, ps = data

                files = []

                filecontent = {}

                p2 = None

                if mergeable_file:

                    fn = b"mf"

                    p1 = repo[ps[0]]

                    if len(ps) > 1:

                        p2 = repo[ps[1]]

                        pa = p1.ancestor(p2)

                        base, local, other = [

                            x[fn].data() for x in (pa, p1, p2)

                        ]

                        m3 = simplemerge.Merge3Text(base, local, other)

                        ml = [l.strip() for l in m3.merge_lines()]

                        ml.append(b"")

                    elif at > 0:

                        ml = p1[fn].data().split(b"\n")

                    else:

                        ml = initialmergedlines

                    ml[id * linesperrev] += b" r%i" % id

                    mergedtext = b"\n".join(ml)

                    files.append(fn)

                    filecontent[fn] = mergedtext

                if overwritten_file:

                    fn = b"of"

                    files.append(fn)

                    filecontent[fn] = b"r%i\n" % id

                if new_file:

                    fn = b"nf%i" % id

                    files.append(fn)

                    filecontent[fn] = b"r%i\n" % id

                    if len(ps) > 1:

                        if not p2:

                            p2 = repo[ps[1]]

                        for fn in p2:

                            if fn.startswith(b"nf"):

                                files.append(fn)

                                filecontent[fn] = p2[fn].data()

                def fctxfn(repo, cx, path):

                    if path in filecontent:

                        return context.memfilectx(

                            repo, cx, path, filecontent[path]

                        )

                    return None

                if len(ps) == 0 or ps[0] < 0:

                    pars = [None, None]

                elif len(ps) == 1:

                    pars = [nodeids[ps[0]], None]

                else:

                    pars = [nodeids[p] for p in ps]

                cx = context.memctx(

                    repo,

                    pars,

                    b"r%i" % id,

                    files,

                    fctxfn,

                    date=(id, 0),

                    user=b"debugbuilddag",

                    extra={b'branch': atbranch},

                )

                nodeid = repo.commitctx(cx)

                nodeids.append(nodeid)

                at = id

            elif type == b'l':

                id, name = data

                ui.note((b'tag %s\n' % name))

                tags.append(b"%s %s\n" % (hex(repo.changelog.node(id)), name))

            elif type == b'a':

                ui.note((b'branch %s\n' % data))

                atbranch = data

            progress.update(id)

        if tags:

            repo.vfs.write(b"localtags", b"".join(tags))

def _debugchangegroup(ui, gen, all=None, indent=0, **opts):

    indent_string = b' ' * indent

    if all:

        ui.writenoi18n(

            b"%sformat: id, p1, p2, cset, delta base, len(delta)\n"

            % indent_string

        )

        def showchunks(named):

            ui.write(b"\n%s%s\n" % (indent_string, named))

            for deltadata in gen.deltaiter():

                node, p1, p2, cs, deltabase, delta, flags = deltadata

                ui.write(

                    b"%s%s %s %s %s %s %d\n"

                    % (

                        indent_string,

                        hex(node),

                        hex(p1),

                        hex(p2),

                        hex(cs),

                        hex(deltabase),

                        len(delta),

                    )

                )

        gen.changelogheader()

        showchunks(b"changelog")

        gen.manifestheader()

        showchunks(b"manifest")

        for chunkdata in iter(gen.filelogheader, {}):

            fname = chunkdata[b'filename']

            showchunks(fname)

    else:

        if isinstance(gen, bundle2.unbundle20):

            raise error.Abort(_(b'use debugbundle2 for this file'))

        gen.changelogheader()

        for deltadata in gen.deltaiter():

            node, p1, p2, cs, deltabase, delta, flags = deltadata

            ui.write(b"%s%s\n" % (indent_string, hex(node)))

def _debugobsmarkers(ui, part, indent=0, **opts):

    """display version and markers contained in 'data'"""

    opts = pycompat.byteskwargs(opts)

    data = part.read()

    indent_string = b' ' * indent

    try:

        version, markers = obsolete._readmarkers(data)

    except error.UnknownVersion as exc:

        msg = b"%sunsupported version: %s (%d bytes)\n"

        msg %= indent_string, exc.version, len(data)

        ui.write(msg)

    else:

        msg = b"%sversion: %d (%d bytes)\n"

        msg %= indent_string, version, len(data)

        ui.write(msg)

        fm = ui.formatter(b'debugobsolete', opts)

        for rawmarker in sorted(markers):

            m = obsutil.marker(None, rawmarker)

            fm.startitem()

            fm.plain(indent_string)

            cmdutil.showmarker(fm, m)

        fm.end()

def _debugphaseheads(ui, data, indent=0):

    """display version and markers contained in 'data'"""

    indent_string = b' ' * indent

    headsbyphase = phases.binarydecode(data)

    for phase in phases.allphases:

        for head in headsbyphase[phase]:

            ui.write(indent_string)

            ui.write(b'%s %s\n' % (hex(head), phases.phasenames[phase]))

def _quasirepr(thing):

    if isinstance(thing, (dict, util.sortdict, collections.OrderedDict)):

        return b'{%s}' % (

            b', '.join(b'%s: %s' % (k, thing[k]) for k in sorted(thing))

        )

    return pycompat.bytestr(repr(thing))

def _debugbundle2(ui, gen, all=None, **opts):

    """lists the contents of a bundle2"""

    if not isinstance(gen, bundle2.unbundle20):

        raise error.Abort(_(b'not a bundle2 file'))

    ui.write((b'Stream params: %s\n' % _quasirepr(gen.params)))

    parttypes = opts.get('part_type', [])

    for part in gen.iterparts():

        if parttypes and part.type not in parttypes:

            continue

        msg = b'%s -- %s (mandatory: %r)\n'

        ui.write((msg % (part.type, _quasirepr(part.params), part.mandatory)))

        if part.type == b'changegroup':

            version = part.params.get(b'version', b'01')

            cg = changegroup.getunbundler(version, part, b'UN')

            if not ui.quiet:

                _debugchangegroup(ui, cg, all=all, indent=4, **opts)

        if part.type == b'obsmarkers':

            if not ui.quiet:

                _debugobsmarkers(ui, part, indent=4, **opts)

        if part.type == b'phase-heads':

            if not ui.quiet:

                _debugphaseheads(ui, part, indent=4)

@command(

    b'debugbundle',

    [

        (b'a', b'all', None, _(b'show all details')),

        (b'', b'part-type', [], _(b'show only the named part type')),

        (b'', b'spec', None, _(b'print the bundlespec of the bundle')),

    ],

    _(b'FILE'),

    norepo=True,

)

def debugbundle(ui, bundlepath, all=None, spec=None, **opts):

    """lists the contents of a bundle"""

    with hg.openpath(ui, bundlepath) as f:

        if spec:

            spec = exchange.getbundlespec(ui, f)

            ui.write(b'%s\n' % spec)

            return

        gen = exchange.readbundle(ui, f, bundlepath)

        if isinstance(gen, bundle2.unbundle20):

            return _debugbundle2(ui, gen, all=all, **opts)

        _debugchangegroup(ui, gen, all=all, **opts)

@command(b'debugcapabilities', [], _(b'PATH'), norepo=True)

def debugcapabilities(ui, path, **opts):

    """lists the capabilities of a remote peer"""

    opts = pycompat.byteskwargs(opts)

    peer = hg.peer(ui, opts, path)

    caps = peer.capabilities()

    ui.writenoi18n(b'Main capabilities:\n')

    for c in sorted(caps):

        ui.write(b'  %s\n' % c)

    b2caps = bundle2.bundle2caps(peer)

    if b2caps:

        ui.writenoi18n(b'Bundle2 capabilities:\n')

        for key, values in sorted(pycompat.iteritems(b2caps)):

            ui.write(b'  %s\n' % key)

            for v in values:

                ui.write(b'    %s\n' % v)

@command(b'debugcheckstate', [], b'')

def debugcheckstate(ui, repo):

    """validate the correctness of the current dirstate"""

    parent1, parent2 = repo.dirstate.parents()

    m1 = repo[parent1].manifest()

    m2 = repo[parent2].manifest()

    errors = 0

    for f in repo.dirstate:

        state = repo.dirstate[f]

        if state in b"nr" and f not in m1:

            ui.warn(_(b"%s in state %s, but not in manifest1\n") % (f, state))

            errors += 1

        if state in b"a" and f in m1:

            ui.warn(_(b"%s in state %s, but also in manifest1\n") % (f, state))

            errors += 1

        if state in b"m" and f not in m1 and f not in m2:

            ui.warn(

                _(b"%s in state %s, but not in either manifest\n") % (f, state)