# phabricator.py - simple Phabricator integration

#

# Copyright 2017 Facebook, Inc.

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

"""simple Phabricator integration (EXPERIMENTAL)

This extension provides a ``phabsend`` command which sends a stack of

changesets to Phabricator, and a ``phabread`` command which prints a stack of

revisions in a format suitable for :hg:`import`, and a ``phabupdate`` command

to update statuses in batch.

A "phabstatus" view for :hg:`show` is also provided; it displays status

information of Phabricator differentials associated with unfinished

changesets.

By default, Phabricator requires ``Test Plan`` which might prevent some

changeset from being sent. The requirement could be disabled by changing

``differential.require-test-plan-field`` config server side.

Config::

    [phabricator]

    # Phabricator URL

    url = https://phab.example.com/

    # Repo callsign. If a repo has a URL https://$HOST/diffusion/FOO, then its

    # callsign is "FOO".

    callsign = FOO

    # curl command to use. If not set (default), use builtin HTTP library to

    # communicate. If set, use the specified curl command. This could be useful

    # if you need to specify advanced options that is not easily supported by

    # the internal library.

    curlcmd = curl --connect-timeout 2 --retry 3 --silent

    # retry failed command N time (default 0). Useful when using the extension

    # over flakly connection.

    #

    # We wait `retry.interval` between each retry, in seconds.

    # (default 1 second).

    retry = 3

    retry.interval = 10

    # the retry option can combine well with the http.timeout one.

    #

    # For example to give up on http request after 20 seconds:

    [http]

    timeout=20

    [auth]

    example.schemes = https

    example.prefix = phab.example.com

    # API token. Get it from https://$HOST/conduit/login/

    example.phabtoken = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx

"""

import base64

import contextlib

import hashlib

import io

import itertools

import json

import mimetypes

import operator

import re

import time

from mercurial.node import bin, short

from mercurial.i18n import _

from mercurial.thirdparty import attr

from mercurial import (

    cmdutil,

    context,

    copies,

    encoding,

    error,

    exthelper,

    graphmod,

    httpconnection as httpconnectionmod,

    localrepo,

    logcmdutil,

    match,

    mdiff,

    obsutil,

    parser,

    patch,

    phases,

    pycompat,

    rewriteutil,

    scmutil,

    smartset,

    tags,

    templatefilters,

    templateutil,

    url as urlmod,

    util,

)

from mercurial.utils import (

    procutil,

    stringutil,

    urlutil,

)

from . import show

# Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for

# extensions which SHIP WITH MERCURIAL. Non-mainline extensions should

# be specifying the version(s) of Mercurial they are tested with, or

# leave the attribute unspecified.

testedwith = b'ships-with-hg-core'

eh = exthelper.exthelper()

cmdtable = eh.cmdtable

command = eh.command

configtable = eh.configtable

templatekeyword = eh.templatekeyword

uisetup = eh.finaluisetup

# developer config: phabricator.batchsize

eh.configitem(

    b'phabricator',

    b'batchsize',

    default=12,

)

eh.configitem(

    b'phabricator',

    b'callsign',

    default=None,

)

eh.configitem(

    b'phabricator',

    b'curlcmd',

    default=None,

)

# developer config: phabricator.debug

eh.configitem(

    b'phabricator',

    b'debug',

    default=False,

)

# developer config: phabricator.repophid

eh.configitem(

    b'phabricator',

    b'repophid',

    default=None,

)

eh.configitem(

    b'phabricator',

    b'retry',

    default=0,

)

eh.configitem(

    b'phabricator',

    b'retry.interval',

    default=1,

)

eh.configitem(

    b'phabricator',

    b'url',

    default=None,

)

eh.configitem(

    b'phabsend',

    b'confirm',

    default=False,

)

eh.configitem(

    b'phabimport',

    b'secret',

    default=False,

)

eh.configitem(

    b'phabimport',

    b'obsolete',

    default=False,

)

colortable = {

    b'phabricator.action.created': b'green',

    b'phabricator.action.skipped': b'magenta',

    b'phabricator.action.updated': b'magenta',

    b'phabricator.drev': b'bold',

    b'phabricator.status.abandoned': b'magenta dim',

    b'phabricator.status.accepted': b'green bold',

    b'phabricator.status.closed': b'green',

    b'phabricator.status.needsreview': b'yellow',

    b'phabricator.status.needsrevision': b'red',

    b'phabricator.status.changesplanned': b'red',

}

_VCR_FLAGS = [

    (

        b'',

        b'test-vcr',

        b'',

        _(

            b'Path to a vcr file. If nonexistent, will record a new vcr transcript'

            b', otherwise will mock all http requests using the specified vcr file.'

            b' (ADVANCED)'

        ),

    ),

]

@eh.wrapfunction(localrepo, "loadhgrc")

def _loadhgrc(orig, ui, wdirvfs, hgvfs, requirements, *args, **opts):

    """Load ``.arcconfig`` content into a ui instance on repository open."""

    result = False

    arcconfig = {}

    try:

        # json.loads only accepts bytes from 3.6+

        rawparams = encoding.unifromlocal(wdirvfs.read(b".arcconfig"))

        # json.loads only returns unicode strings

        arcconfig = pycompat.rapply(

            lambda x: encoding.unitolocal(x) if isinstance(x, str) else x,

            pycompat.json_loads(rawparams),

        )

        result = True

    except ValueError:

        ui.warn(_(b"invalid JSON in %s\n") % wdirvfs.join(b".arcconfig"))

    except IOError:

        pass

    cfg = util.sortdict()

    if b"repository.callsign" in arcconfig:

        cfg[(b"phabricator", b"callsign")] = arcconfig[b"repository.callsign"]

    if b"phabricator.uri" in arcconfig:

        cfg[(b"phabricator", b"url")] = arcconfig[b"phabricator.uri"]

    if cfg:

        ui.applyconfig(cfg, source=wdirvfs.join(b".arcconfig"))

    return (

        orig(ui, wdirvfs, hgvfs, requirements, *args, **opts) or result

    )  # Load .hg/hgrc

def vcrcommand(name, flags, spec, helpcategory=None, optionalrepo=False):

    fullflags = flags + _VCR_FLAGS

    def hgmatcher(r1, r2):

        if r1.uri != r2.uri or r1.method != r2.method:

            return False

        r1params = util.urlreq.parseqs(r1.body)

        r2params = util.urlreq.parseqs(r2.body)

        for key in r1params:

            if key not in r2params:

                return False

            value = r1params[key][0]

            # we want to compare json payloads without worrying about ordering

            if value.startswith(b'{') and value.endswith(b'}'):

                r1json = pycompat.json_loads(value)

                r2json = pycompat.json_loads(r2params[key][0])

                if r1json != r2json:

                    return False

            elif r2params[key][0] != value:

                return False

        return True

    def sanitiserequest(request):

        request.body = re.sub(

            br'cli-[a-z0-9]+', br'cli-hahayouwish', request.body

        )

        return request

    def sanitiseresponse(response):

        if 'set-cookie' in response['headers']:

            del response['headers']['set-cookie']

        return response

    def decorate(fn):

        def inner(*args, **kwargs):

            vcr = kwargs.pop('test_vcr')

            if vcr:

                cassette = pycompat.fsdecode(vcr)

                import hgdemandimport

                with hgdemandimport.deactivated():

                    # pytype: disable=import-error

                    import vcr as vcrmod

                    import vcr.stubs as stubs

                    # pytype: enable=import-error

                    vcr = vcrmod.VCR(

                        serializer='json',

                        before_record_request=sanitiserequest,

                        before_record_response=sanitiseresponse,

                        custom_patches=[

                            (

                                urlmod,

                                'httpconnection',

                                stubs.VCRHTTPConnection,

                            ),

                            (

                                urlmod,

                                'httpsconnection',

                                stubs.VCRHTTPSConnection,

                            ),

                        ],

                    )

                    vcr.register_matcher('hgmatcher', hgmatcher)

                    with vcr.use_cassette(cassette, match_on=['hgmatcher']):

                        return fn(*args, **kwargs)

            return fn(*args, **kwargs)

        cmd = util.checksignature(inner, depth=2)

        cmd.__name__ = fn.__name__

        cmd.__doc__ = fn.__doc__

        return command(

            name,

            fullflags,

            spec,

            helpcategory=helpcategory,

            optionalrepo=optionalrepo,

        )(cmd)

    return decorate

def _debug(ui, *msg, **opts):

    """write debug output for Phabricator if ``phabricator.debug`` is set

    Specifically, this avoids dumping Conduit and HTTP auth chatter that is

    printed with the --debug argument.

    """

    if ui.configbool(b"phabricator", b"debug"):

        flag = ui.debugflag

        try:

            ui.debugflag = True

            ui.write(*msg, **opts)

        finally:

            ui.debugflag = flag

def urlencodenested(params):

    """like urlencode, but works with nested parameters.

    For example, if params is {'a': ['b', 'c'], 'd': {'e': 'f'}}, it will be

    flattened to {'a[0]': 'b', 'a[1]': 'c', 'd[e]': 'f'} and then passed to

    urlencode. Note: the encoding is consistent with PHP's http_build_query.

    """

    flatparams = util.sortdict()

    def process(prefix: bytes, obj):

        if isinstance(obj, bool):

            obj = {True: b'true', False: b'false'}[obj]  # Python -> PHP form

        lister = lambda l: [(b'%d' % k, v) for k, v in enumerate(l)]

        # .items() will only be called for a dict type

        # pytype: disable=attribute-error

        items = {list: lister, dict: lambda x: x.items()}.get(type(obj))

        # pytype: enable=attribute-error

        if items is None:

            flatparams[prefix] = obj

        else:

            for k, v in items(obj):

                if prefix:

                    process(b'%s[%s]' % (prefix, k), v)

                else:

                    process(k, v)

    process(b'', params)

    return urlutil.urlreq.urlencode(flatparams)

def readurltoken(ui):

    """return conduit url, token and make sure they exist

    Currently read from [auth] config section. In the future, it might

    make sense to read from .arcconfig and .arcrc as well.

    """

    url = ui.config(b'phabricator', b'url')

    if not url:

        raise error.Abort(

            _(b'config %s.%s is required') % (b'phabricator', b'url')

        )

    res = httpconnectionmod.readauthforuri(ui, url, urlutil.url(url).user)

    token = None

    if res:

        group, auth = res

        ui.debug(b"using auth.%s.* for authentication\n" % group)

        token = auth.get(b'phabtoken')

    if not token:

        raise error.Abort(

            _(b'Can\'t find conduit token associated to %s') % (url,)