# 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

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.

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/

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

    # Deprecated: see [phabricator.auth] below

    #token = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx

    # 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

    [phabricator.auth]

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

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

    example.token = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx

"""

from __future__ import absolute_import

import itertools

import json

import operator

import re

from mercurial.node import bin, nullid

from mercurial.i18n import _

from mercurial import (

    cmdutil,

    context,

    encoding,

    error,

    mdiff,

    obsutil,

    parser,

    patch,

    registrar,

    scmutil,

    smartset,

    tags,

    url as urlmod,

    util,

)

from mercurial.utils import (

    procutil,

)

cmdtable = {}

command = registrar.command(cmdtable)

colortable = {

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

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

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

    'phabricator.desc': '',

    'phabricator.drev': 'bold',

    'phabricator.node': '',

}

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, obj):

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

        if items is None:

            flatparams[prefix] = obj

        else:

            for k, v in items(obj):

                if prefix:

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

                else:

                    process(k, v)

    process('', params)

    return util.urlreq.urlencode(flatparams)

printed_token_warning = False

def readlegacytoken(repo):

    """Transitional support for old phabricator tokens.

    Remove before the 4.6 release.

    """

    global printed_token_warning

    token = repo.ui.config('phabricator', 'token')

    if token and not printed_token_warning:

        printed_token_warning = True

        repo.ui.warn(_('phabricator.token is deprecated - please '

                       'migrate to the phabricator.auth section.\n'))

    return token

def readurltoken(repo):

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

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

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

    """

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

    if not url:

        raise error.Abort(_('config %s.%s is required')

                          % ('phabricator', 'url'))

    groups = {}

    for key, val in repo.ui.configitems('phabricator.auth'):

        if '.' not in key:

            repo.ui.warn(_("ignoring invalid [phabricator.auth] key '%s'\n")

                         % key)

            continue

        group, setting = key.rsplit('.', 1)

        groups.setdefault(group, {})[setting] = val

    token = None

    for group, auth in groups.iteritems():

        if url != auth.get('url'):

            continue

        token = auth.get('token')

        if token:

            break

    if not token:

        token = readlegacytoken(repo)

        if not token:

            raise error.Abort(_('Can\'t find conduit token associated to %s')

                              % (url,))

    return url, token

def callconduit(repo, name, params):

    """call Conduit API, params is a dict. return json.loads result, or None"""

    host, token = readurltoken(repo)

    url, authinfo = util.url('/'.join([host, 'api', name])).authinfo()

    repo.ui.debug('Conduit Call: %s %s\n' % (url, params))

    params = params.copy()

    params['api.token'] = token

    data = urlencodenested(params)

    curlcmd = repo.ui.config('phabricator', 'curlcmd')

    if curlcmd:

        sin, sout = procutil.popen2('%s -d @- %s'

                                    % (curlcmd, procutil.shellquote(url)))

        sin.write(data)

        sin.close()

        body = sout.read()

    else:

        urlopener = urlmod.opener(repo.ui, authinfo)

        request = util.urlreq.request(url, data=data)

        body = urlopener.open(request).read()

    repo.ui.debug('Conduit Response: %s\n' % body)

    parsed = json.loads(body)

    if parsed.get(r'error_code'):

        msg = (_('Conduit Error (%s): %s')

               % (parsed[r'error_code'], parsed[r'error_info']))

        raise error.Abort(msg)

    return parsed[r'result']

@command('debugcallconduit', [], _('METHOD'))

def debugcallconduit(ui, repo, name):

    """call Conduit API

    Call parameters are read from stdin as a JSON blob. Result will be written

    to stdout as a JSON blob.

    """

    params = json.loads(ui.fin.read())

    result = callconduit(repo, name, params)

    s = json.dumps(result, sort_keys=True, indent=2, separators=(',', ': '))

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

def getrepophid(repo):

    """given callsign, return repository PHID or None"""

    # developer config: phabricator.repophid

    repophid = repo.ui.config('phabricator', 'repophid')

    if repophid:

        return repophid

    callsign = repo.ui.config('phabricator', 'callsign')

    if not callsign:

        return None

    query = callconduit(repo, 'diffusion.repository.search',

                        {'constraints': {'callsigns': [callsign]}})

    if len(query[r'data']) == 0:

        return None

    repophid = encoding.strtolocal(query[r'data'][0][r'phid'])

    repo.ui.setconfig('phabricator', 'repophid', repophid)

    return repophid

_differentialrevisiontagre = re.compile('\AD([1-9][0-9]*)\Z')

_differentialrevisiondescre = re.compile(

    '^Differential Revision:\s*(?P<url>(?:.*)D(?P<id>[1-9][0-9]*))$', re.M)

def getoldnodedrevmap(repo, nodelist):

    """find previous nodes that has been sent to Phabricator

    return {node: (oldnode, Differential diff, Differential Revision ID)}

    for node in nodelist with known previous sent versions, or associated

    Differential Revision IDs. ``oldnode`` and ``Differential diff`` could

    be ``None``.

    Examines commit messages like "Differential Revision:" to get the

    association information.

    If such commit message line is not found, examines all precursors and their

    tags. Tags with format like "D1234" are considered a match and the node

    with that tag, and the number after "D" (ex. 1234) will be returned.

    The ``old node``, if not None, is guaranteed to be the last diff of

    corresponding Differential Revision, and exist in the repo.

    """

    url, token = readurltoken(repo)

    unfi = repo.unfiltered()

    nodemap = unfi.changelog.nodemap

    result = {} # {node: (oldnode?, lastdiff?, drev)}

    toconfirm = {} # {node: (force, {precnode}, drev)}

    for node in nodelist:

        ctx = unfi[node]

        # For tags like "D123", put them into "toconfirm" to verify later

        precnodes = list(obsutil.allpredecessors(unfi.obsstore, [node]))

        for n in precnodes:

            if n in nodemap:

                for tag in unfi.nodetags(n):

                    m = _differentialrevisiontagre.match(tag)

                    if m:

                        toconfirm[node] = (0, set(precnodes), int(m.group(1)))

                        continue

        # Check commit message

        m = _differentialrevisiondescre.search(ctx.description())

        if m:

            toconfirm[node] = (1, set(precnodes), int(m.group('id')))

    # Double check if tags are genuine by collecting all old nodes from

    # Phabricator, and expect precursors overlap with it.

    if toconfirm:

        drevs = [drev for force, precs, drev in toconfirm.values()]

        alldiffs = callconduit(unfi, 'differential.querydiffs',

                               {'revisionIDs': drevs})

        getnode = lambda d: bin(encoding.unitolocal(

            getdiffmeta(d).get(r'node', ''))) or None

        for newnode, (force, precset, drev) in toconfirm.items():

            diffs = [d for d in alldiffs.values()

                     if int(d[r'revisionID']) == drev]

            # "precursors" as known by Phabricator

            phprecset = set(getnode(d) for d in diffs)

            # Ignore if precursors (Phabricator and local repo) do not overlap,

            # and force is not set (when commit message says nothing)

            if not force and not bool(phprecset & precset):

                tagname = 'D%d' % drev

                tags.tag(repo, tagname, nullid, message=None, user=None,

                         date=None, local=True)

                unfi.ui.warn(_('D%s: local tag removed - does not match '

                               'Differential history\n') % drev)

                continue

            # Find the last node using Phabricator metadata, and make sure it

            # exists in the repo

            oldnode = lastdiff = None

            if diffs:

                lastdiff = max(diffs, key=lambda d: int(d[r'id']))

                oldnode = getnode(lastdiff)

                if oldnode and oldnode not in nodemap:

                    oldnode = None

            result[newnode] = (oldnode, lastdiff, drev)

    return result

def getdiff(ctx, diffopts):

    """plain-text diff without header (user, commit message, etc)"""

    output = util.stringio()

    for chunk, _label in patch.diffui(ctx.repo(), ctx.p1().node(), ctx.node(),

                                      None, opts=diffopts):

        output.write(chunk)

    return output.getvalue()

def creatediff(ctx):

    """create a Differential Diff"""

    repo = ctx.repo()

    repophid = getrepophid(repo)

    # Create a "Differential Diff" via "differential.createrawdiff" API

    params = {'diff': getdiff(ctx, mdiff.diffopts(git=True, context=32767))}

    if repophid:

        params['repositoryPHID'] = repophid

    diff = callconduit(repo, 'differential.createrawdiff', params)

    if not diff:

        raise error.Abort(_('cannot create diff for %s') % ctx)

    return diff

def writediffproperties(ctx, diff):

    """write metadata to diff so patches could be applied losslessly"""

    params = {

        'diff_id': diff[r'id'],

        'name': 'hg:meta',

        'data': json.dumps({

            'user': ctx.user(),

            'date': '%d %d' % ctx.date(),

            'node': ctx.hex(),

            'parent': ctx.p1().hex(),

        }),

    }

    callconduit(ctx.repo(), 'differential.setdiffproperty', params)

def createdifferentialrevision(ctx, revid=None, parentrevid=None, oldnode=None,

                               olddiff=None, actions=None):

    """create or update a Differential Revision

    If revid is None, create a new Differential Revision, otherwise update

    revid. If parentrevid is not None, set it as a dependency.

    If oldnode is not None, check if the patch content (without commit message

    and metadata) has changed before creating another diff.

    If actions is not None, they will be appended to the transaction.

    """

    repo = ctx.repo()

    if oldnode:

        diffopts = mdiff.diffopts(git=True, context=32767)

        oldctx = repo.unfiltered()[oldnode]

        neednewdiff = (getdiff(ctx, diffopts) != getdiff(oldctx, diffopts))

    else:

        neednewdiff = True

    transactions = []

    if neednewdiff:

        diff = creatediff(ctx)

        transactions.append({'type': 'update', 'value': diff[r'phid']})

    else:

        # Even if we don't need to upload a new diff because the patch content

        # does not change. We might still need to update its metadata so

        # pushers could know the correct node metadata.

        assert olddiff

        diff = olddiff

    writediffproperties(ctx, diff)

    # Use a temporary summary to set dependency. There might be better ways but

    # I cannot find them for now. But do not do that if we are updating an

    # existing revision (revid is not None) since that introduces visible

    # churns (someone edited "Summary" twice) on the web page.

    if parentrevid and revid is None:

        summary = 'Depends on D%s' % parentrevid

        transactions += [{'type': 'summary', 'value': summary},

                         {'type': 'summary', 'value': ' '}]

    if actions: