| Restricted Project |
Backport phabricator.py in D127 since it won't get in the 4.3 release and we
use author-push workflow where phabsend --amend is important for a good UX.
| Lint Skipped |
| Unit Tests Skipped |
| # 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 without amending commit messages, 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/ | |||||
| token = cli-xxxxxxxxxxxxxxxxxxxxxxxxxxxx | |||||
| # Repo callsign. If a repo has a URL https://$HOST/diffusion/FOO, then its | |||||
| # callsign is "FOO". | |||||
| callsign = FOO | |||||
| """ | |||||
| 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, | |||||
| obsolete, | |||||
| parser, | |||||
| patch, | |||||
| registrar, | |||||
| scmutil, | |||||
| smartset, | |||||
| tags, | |||||
| url as urlmod, | |||||
| util, | |||||
| ) | |||||
| cmdtable = {} | |||||
| command = registrar.command(cmdtable) | |||||
| 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) | |||||
| 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. | |||||
| """ | |||||
| values = [] | |||||
| section = 'phabricator' | |||||
| for name in ['url', 'token']: | |||||
| value = repo.ui.config(section, name) | |||||
| if not value: | |||||
| raise error.Abort(_('config %s.%s is required') % (section, name)) | |||||
| values.append(value) | |||||
| return values | |||||
| 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() | |||||
| urlopener = urlmod.opener(repo.ui, authinfo) | |||||
| repo.ui.debug('Conduit Call: %s %s\n' % (url, params)) | |||||
| params = params.copy() | |||||
| params['api.token'] = token | |||||
| request = util.urlreq.request(url, data=urlencodenested(params)) | |||||
| 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:.*D([1-9][0-9]*)$', re.M) | |||||
| def getoldnodedrevmap(repo, nodelist): | |||||
| """find previous nodes that has been sent to Phabricator | |||||
| return {node: (oldnode or None, Differential Revision ID)} | |||||
| for node in nodelist with known previous sent versions, or associated | |||||
| Differential Revision IDs. | |||||
| 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 or None, 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(obsolete.allprecursors(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. If "Differential Revision:" exists and matches | |||||
| # the URL. Trust it blindly even if precursors do not match. | |||||
| m = _differentialrevisiondescre.search(ctx.description()) | |||||
| if m: | |||||
| toconfirm[node] = (1, set(precnodes), int(m.group(1))) | |||||
| # 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 | |||||
| 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, 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, | |||||
| 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=1) | |||||
| oldctx = repo.unfiltered()[oldnode] | |||||
| neednewdiff = (getdiff(ctx, diffopts) != getdiff(oldctx, diffopts)) | |||||
| else: | |||||
| neednewdiff = True | |||||
| transactions = [] | |||||
| if neednewdiff: | |||||
| diff = creatediff(ctx) | |||||
| writediffproperties(ctx, diff) | |||||
| transactions.append({'type': 'update', 'value': diff[r'phid']}) | |||||
| # 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: | |||||
| transactions += actions | |||||
| # Parse commit message and update related fields. | |||||
| desc = ctx.description() | |||||
| info = callconduit(repo, 'differential.parsecommitmessage', | |||||
| {'corpus': desc}) | |||||
| for k, v in info[r'fields'].items(): | |||||
| if k in ['title', 'summary', 'testPlan']: | |||||
| transactions.append({'type': k, 'value': v}) | |||||
| params = {'transactions': transactions} | |||||
| if revid is not None: | |||||
| # Update an existing Differential Revision | |||||
| params['objectIdentifier'] = revid | |||||
| revision = callconduit(repo, 'differential.revision.edit', params) | |||||
| if not revision: | |||||
| raise error.Abort(_('cannot create revision for %s') % ctx) | |||||
| return revision | |||||
| def userphids(repo, names): | |||||
| """convert user names to PHIDs""" | |||||
| query = {'constraints': {'usernames': names}} | |||||
| result = callconduit(repo, 'user.search', query) | |||||
| # username not found is not an error of the API. So check if we have missed | |||||
| # some names here. | |||||
| data = result[r'data'] | |||||
| resolved = set(entry[r'fields'][r'username'] for entry in data) | |||||
| unresolved = set(names) - resolved | |||||
| if unresolved: | |||||
| raise error.Abort(_('unknown username: %s') | |||||
| % ' '.join(sorted(unresolved))) | |||||
| return [entry[r'phid'] for entry in data] | |||||
| @command('phabsend', | |||||
| [('r', 'rev', [], _('revisions to send'), _('REV')), | |||||
| ('', 'amend', False, _('update commit messages')), | |||||
| ('', 'reviewer', [], _('specify reviewers'))], | |||||
| _('REV [OPTIONS]')) | |||||
| def phabsend(ui, repo, *revs, **opts): | |||||
| """upload changesets to Phabricator | |||||
| If there are multiple revisions specified, they will be send as a stack | |||||
| with a linear dependencies relationship using the order specified by the | |||||
| revset. | |||||
| If --amend is set, update commit messages so they have the | |||||
| ``Differential Revision`` URL, remove related tags. This is similar to what | |||||
| arcanist will do, and is more desired in author-push workflows. Otherwise, | |||||
| use local tags to record the ``Differential Revision`` association. | |||||
| phabsend will check obsstore and the above association to decide whether to | |||||
| update an existing Differential Revision, or create a new one. | |||||
| """ | |||||
| revs = list(revs) + opts.get('rev', []) | |||||
| revs = scmutil.revrange(repo, revs) | |||||
| if not revs: | |||||
| raise error.Abort(_('phabsend requires at least one changeset')) | |||||
| if opts.get('amend'): | |||||
| cmdutil.checkunfinished(repo) | |||||
| actions = [] | |||||
| reviewers = opts.get('reviewer', []) | |||||
| if reviewers: | |||||
| phids = userphids(repo, reviewers) | |||||
| actions.append({'type': 'reviewers.add', 'value': phids}) | |||||
| oldnodedrev = getoldnodedrevmap(repo, [repo[r].node() for r in revs]) | |||||
| # Send patches one by one so we know their Differential Revision IDs and | |||||
| # can provide dependency relationship | |||||
| drevids = [] | |||||
| lastrevid = None | |||||
| for rev in revs: | |||||
| ui.debug('sending rev %d\n' % rev) | |||||
| ctx = repo[rev] | |||||
| # Get Differential Revision ID | |||||
| oldnode, revid = oldnodedrev.get(ctx.node(), (None, None)) | |||||
| if oldnode != ctx.node(): | |||||
| # Create or update Differential Revision | |||||
| revision = createdifferentialrevision(ctx, revid, lastrevid, | |||||
| oldnode, actions) | |||||
| newrevid = int(revision[r'object'][r'id']) | |||||
| if revid: | |||||
| action = _('updated') | |||||
| else: | |||||
| action = _('created') | |||||
| # Create a local tag to note the association, if commit message | |||||
| # does not have it already | |||||
| m = _differentialrevisiondescre.search(ctx.description()) | |||||
| if not m or int(m.group(1)) != newrevid: | |||||
| tagname = 'D%d' % newrevid | |||||
| tags.tag(repo, tagname, ctx.node(), message=None, user=None, | |||||
| date=None, local=True) | |||||
| else: | |||||
| # Nothing changed. But still set "newrevid" so the next revision | |||||
| # could depend on this one. | |||||
| newrevid = revid | |||||
| action = _('skipped') | |||||
| ui.write(_('D%s: %s - %s: %s\n') % (newrevid, action, ctx, | |||||
| ctx.description().split('\n')[0])) | |||||
| drevids.append(newrevid) | |||||
| lastrevid = newrevid | |||||
| # Update commit messages and remove tags | |||||
| if opts.get('amend'): | |||||
| unfi = repo.unfiltered() | |||||
| drevs = callconduit(repo, 'differential.query', {'ids': drevids}) | |||||
| with repo.wlock(), repo.lock(), repo.transaction('phabsend'): | |||||
| wnode = unfi['.'].node() | |||||
| mapping = {} # {oldnode: newnode} | |||||
| for i, rev in enumerate(revs): | |||||
| old = unfi[rev] | |||||
| drevid = drevids[i] | |||||
| drev = [d for d in drevs if int(d[r'id']) == drevid][0] | |||||
| newdesc = getdescfromdrev(drev) | |||||
| # Make sure commit message contain "Differential Revision" | |||||
| if old.description() != newdesc: | |||||
| parents = [ | |||||
| mapping.get(old.p1().node(), (old.p1(),))[0], | |||||
| mapping.get(old.p2().node(), (old.p2(),))[0], | |||||
| ] | |||||
| new = context.metadataonlyctx( | |||||
| repo, old, parents=parents, text=newdesc, | |||||
| user=old.user(), date=old.date(), extra=old.extra()) | |||||
| mapping[old.node()] = [new.commit()] | |||||
| # Remove local tags since it's no longer necessary | |||||
| tagname = 'D%d' % drevid | |||||
| if tagname in repo.tags(): | |||||
| tags.tag(repo, tagname, nullid, message=None, user=None, | |||||
| date=None, local=True) | |||||
| scmutil.cleanupnodes(repo, mapping, 'phabsend') | |||||
| if wnode in mapping: | |||||
| unfi.setparents(mapping[wnode][0]) | |||||
| # Map from "hg:meta" keys to header understood by "hg import". The order is | |||||
| # consistent with "hg export" output. | |||||
| _metanamemap = util.sortdict([(r'user', 'User'), (r'date', 'Date'), | |||||
| (r'node', 'Node ID'), (r'parent', 'Parent ')]) | |||||
| _knownstatusnames = {'accepted', 'needsreview', 'needsrevision', 'closed', | |||||
| 'abandoned'} | |||||
| def _getstatusname(drev): | |||||
| """get normalized status name from a Differential Revision""" | |||||
| return drev[r'statusName'].replace(' ', '').lower() | |||||
| # Small language to specify differential revisions. Support symbols: (), :X, | |||||
| # +, and -. | |||||
| _elements = { | |||||
| # token-type: binding-strength, primary, prefix, infix, suffix | |||||
| '(': (12, None, ('group', 1, ')'), None, None), | |||||
| ':': (8, None, ('ancestors', 8), None, None), | |||||
| '&': (5, None, None, ('and_', 5), None), | |||||
| '+': (4, None, None, ('add', 4), None), | |||||
| '-': (4, None, None, ('sub', 4), None), | |||||
| ')': (0, None, None, None, None), | |||||
| 'symbol': (0, 'symbol', None, None, None), | |||||
| 'end': (0, None, None, None, None), | |||||
| } | |||||
| def _tokenize(text): | |||||
| view = memoryview(text) # zero-copy slice | |||||
| special = '():+-& ' | |||||
| pos = 0 | |||||
| length = len(text) | |||||
| while pos < length: | |||||
| symbol = ''.join(itertools.takewhile(lambda ch: ch not in special, | |||||
| view[pos:])) | |||||
| if symbol: | |||||
| yield ('symbol', symbol, pos) | |||||
| pos += len(symbol) | |||||
| else: # special char, ignore space | |||||
| if text[pos] != ' ': | |||||
| yield (text[pos], None, pos) | |||||
| pos += 1 | |||||
| yield ('end', None, pos) | |||||
| def _parse(text): | |||||
| tree, pos = parser.parser(_elements).parse(_tokenize(text)) | |||||
| if pos != len(text): | |||||
| raise error.ParseError('invalid token', pos) | |||||
| return tree | |||||
| def _parsedrev(symbol): | |||||
| """str -> int or None, ex. 'D45' -> 45; '12' -> 12; 'x' -> None""" | |||||
| if symbol.startswith('D') and symbol[1:].isdigit(): | |||||
| return int(symbol[1:]) | |||||
| if symbol.isdigit(): | |||||
| return int(symbol) | |||||
| def _prefetchdrevs(tree): | |||||
| """return ({single-drev-id}, {ancestor-drev-id}) to prefetch""" | |||||
| drevs = set() | |||||
| ancestordrevs = set() | |||||
| op = tree[0] | |||||
| if op == 'symbol': | |||||
| r = _parsedrev(tree[1]) | |||||
| if r: | |||||
| drevs.add(r) | |||||
| elif op == 'ancestors': | |||||
| r, a = _prefetchdrevs(tree[1]) | |||||
| drevs.update(r) | |||||
| ancestordrevs.update(r) | |||||
| ancestordrevs.update(a) | |||||
| else: | |||||
| for t in tree[1:]: | |||||
| r, a = _prefetchdrevs(t) | |||||
| drevs.update(r) | |||||
| ancestordrevs.update(a) | |||||
| return drevs, ancestordrevs | |||||
| def querydrev(repo, spec): | |||||
| """return a list of "Differential Revision" dicts | |||||
| spec is a string using a simple query language, see docstring in phabread | |||||
| for details. | |||||
| A "Differential Revision dict" looks like: | |||||
| { | |||||
| "id": "2", | |||||
| "phid": "PHID-DREV-672qvysjcczopag46qty", | |||||
| "title": "example", | |||||
| "uri": "https://phab.example.com/D2", | |||||
| "dateCreated": "1499181406", | |||||
| "dateModified": "1499182103", | |||||
| "authorPHID": "PHID-USER-tv3ohwc4v4jeu34otlye", | |||||
| "status": "0", | |||||
| "statusName": "Needs Review", | |||||
| "properties": [], | |||||
| "branch": null, | |||||
| "summary": "", | |||||
| "testPlan": "", | |||||
| "lineCount": "2", | |||||
| "activeDiffPHID": "PHID-DIFF-xoqnjkobbm6k4dk6hi72", | |||||
| "diffs": [ | |||||
| "3", | |||||
| "4", | |||||
| ], | |||||
| "commits": [], | |||||
| "reviewers": [], | |||||
| "ccs": [], | |||||
| "hashes": [], | |||||
| "auxiliary": { | |||||
| "phabricator:projects": [], | |||||
| "phabricator:depends-on": [ | |||||
| "PHID-DREV-gbapp366kutjebt7agcd" | |||||
| ] | |||||
| }, | |||||
| "repositoryPHID": "PHID-REPO-hub2hx62ieuqeheznasv", | |||||
| "sourcePath": null | |||||
| } | |||||
| """ | |||||
| def fetch(params): | |||||
| """params -> single drev or None""" | |||||
| key = (params.get(r'ids') or params.get(r'phids') or [None])[0] | |||||
| if key in prefetched: | |||||
| return prefetched[key] | |||||
| drevs = callconduit(repo, 'differential.query', params) | |||||
| # Fill prefetched with the result | |||||
| for drev in drevs: | |||||
| prefetched[drev[r'phid']] = drev | |||||
| prefetched[int(drev[r'id'])] = drev | |||||
| if key not in prefetched: | |||||
| raise error.Abort(_('cannot get Differential Revision %r') % params) | |||||
| return prefetched[key] | |||||
| def getstack(topdrevids): | |||||
| """given a top, get a stack from the bottom, [id] -> [id]""" | |||||
| visited = set() | |||||
| result = [] | |||||
| queue = [{r'ids': [i]} for i in topdrevids] | |||||
| while queue: | |||||
| params = queue.pop() | |||||
| drev = fetch(params) | |||||
| if drev[r'id'] in visited: | |||||
| continue | |||||
| visited.add(drev[r'id']) | |||||
| result.append(int(drev[r'id'])) | |||||
| auxiliary = drev.get(r'auxiliary', {}) | |||||
| depends = auxiliary.get(r'phabricator:depends-on', []) | |||||
| for phid in depends: | |||||
| queue.append({'phids': [phid]}) | |||||
| result.reverse() | |||||
| return smartset.baseset(result) | |||||
| # Initialize prefetch cache | |||||
| prefetched = {} # {id or phid: drev} | |||||
| tree = _parse(spec) | |||||
| drevs, ancestordrevs = _prefetchdrevs(tree) | |||||
| # developer config: phabricator.batchsize | |||||
| batchsize = repo.ui.configint('phabricator', 'batchsize', 12) | |||||
| # Prefetch Differential Revisions in batch | |||||
| tofetch = set(drevs) | |||||
| for r in ancestordrevs: | |||||
| tofetch.update(range(max(1, r - batchsize), r + 1)) | |||||
| if drevs: | |||||
| fetch({r'ids': list(tofetch)}) | |||||
| validids = sorted(set(getstack(list(ancestordrevs))) | set(drevs)) | |||||
| # Walk through the tree, return smartsets | |||||
| def walk(tree): | |||||
| op = tree[0] | |||||
| if op == 'symbol': | |||||
| drev = _parsedrev(tree[1]) | |||||
| if drev: | |||||
| return smartset.baseset([drev]) | |||||
| elif tree[1] in _knownstatusnames: | |||||
| drevs = [r for r in validids | |||||
| if _getstatusname(prefetched[r]) == tree[1]] | |||||
| return smartset.baseset(drevs) | |||||
| else: | |||||
| raise error.Abort(_('unknown symbol: %s') % tree[1]) | |||||
| elif op in {'and_', 'add', 'sub'}: | |||||
| assert(len(tree) == 3) | |||||
| return getattr(operator, op)(walk(tree[1]), walk(tree[2])) | |||||
| elif op == 'group': | |||||
| return walk(tree[1]) | |||||
| elif op == 'ancestors': | |||||
| return getstack(walk(tree[1])) | |||||
| else: | |||||
| raise error.ProgrammingError('illegal tree: %r' % tree) | |||||
| return [prefetched[r] for r in walk(tree)] | |||||
| def getdescfromdrev(drev): | |||||
| """get description (commit message) from "Differential Revision" | |||||
| This is similar to differential.getcommitmessage API. But we only care | |||||
| about limited fields: title, summary, test plan, and URL. | |||||
| """ | |||||
| title = drev[r'title'] | |||||
| summary = drev[r'summary'].rstrip() | |||||
| testplan = drev[r'testPlan'].rstrip() | |||||
| if testplan: | |||||
| testplan = 'Test Plan:\n%s' % testplan | |||||
| uri = 'Differential Revision: %s' % drev[r'uri'] | |||||
| return '\n\n'.join(filter(None, [title, summary, testplan, uri])) | |||||
| def getdiffmeta(diff): | |||||
| """get commit metadata (date, node, user, p1) from a diff object | |||||
| The metadata could be "hg:meta", sent by phabsend, like: | |||||
| "properties": { | |||||
| "hg:meta": { | |||||
| "date": "1499571514 25200", | |||||
| "node": "98c08acae292b2faf60a279b4189beb6cff1414d", | |||||
| "user": "Foo Bar <foo@example.com>", | |||||
| "parent": "6d0abad76b30e4724a37ab8721d630394070fe16" | |||||
| } | |||||
| } | |||||
| Or converted from "local:commits", sent by "arc", like: | |||||
| "properties": { | |||||
| "local:commits": { | |||||
| "98c08acae292b2faf60a279b4189beb6cff1414d": { | |||||
| "author": "Foo Bar", | |||||
| "time": 1499546314, | |||||
| "branch": "default", | |||||
| "tag": "", | |||||
| "commit": "98c08acae292b2faf60a279b4189beb6cff1414d", | |||||
| "rev": "98c08acae292b2faf60a279b4189beb6cff1414d", | |||||
| "local": "1000", | |||||
| "parents": ["6d0abad76b30e4724a37ab8721d630394070fe16"], | |||||
| "summary": "...", | |||||
| "message": "...", | |||||
| "authorEmail": "foo@example.com" | |||||
| } | |||||
| } | |||||
| } | |||||
| Note: metadata extracted from "local:commits" will lose time zone | |||||
| information. | |||||
| """ | |||||
| props = diff.get(r'properties') or {} | |||||
| meta = props.get(r'hg:meta') | |||||
| if not meta and props.get(r'local:commits'): | |||||
| commit = sorted(props[r'local:commits'].values())[0] | |||||
| meta = { | |||||
| r'date': r'%d 0' % commit[r'time'], | |||||
| r'node': commit[r'rev'], | |||||
| r'user': r'%s <%s>' % (commit[r'author'], commit[r'authorEmail']), | |||||
| } | |||||
| if len(commit.get(r'parents', ())) >= 1: | |||||
| meta[r'parent'] = commit[r'parents'][0] | |||||
| return meta or {} | |||||
| def readpatch(repo, drevs, write): | |||||
| """generate plain-text patch readable by 'hg import' | |||||
| write is usually ui.write. drevs is what "querydrev" returns, results of | |||||
| "differential.query". | |||||
| """ | |||||
| # Prefetch hg:meta property for all diffs | |||||
| diffids = sorted(set(max(int(v) for v in drev[r'diffs']) for drev in drevs)) | |||||
| diffs = callconduit(repo, 'differential.querydiffs', {'ids': diffids}) | |||||
| # Generate patch for each drev | |||||
| for drev in drevs: | |||||
| repo.ui.note(_('reading D%s\n') % drev[r'id']) | |||||
| diffid = max(int(v) for v in drev[r'diffs']) | |||||
| body = callconduit(repo, 'differential.getrawdiff', {'diffID': diffid}) | |||||
| desc = getdescfromdrev(drev) | |||||
| header = '# HG changeset patch\n' | |||||
| # Try to preserve metadata from hg:meta property. Write hg patch | |||||
| # headers that can be read by the "import" command. See patchheadermap | |||||
| # and extract in mercurial/patch.py for supported headers. | |||||
| meta = getdiffmeta(diffs[str(diffid)]) | |||||
| for k in _metanamemap.keys(): | |||||
| if k in meta: | |||||
| header += '# %s %s\n' % (_metanamemap[k], meta[k]) | |||||
| write(('%s%s\n%s') % (header, desc, body)) | |||||
| @command('phabread', | |||||
| [('', 'stack', False, _('read dependencies'))], | |||||
| _('DREVSPEC [OPTIONS]')) | |||||
| def phabread(ui, repo, spec, **opts): | |||||
| """print patches from Phabricator suitable for importing | |||||
| DREVSPEC could be a Differential Revision identity, like ``D123``, or just | |||||
| the number ``123``. It could also have common operators like ``+``, ``-``, | |||||
| ``&``, ``(``, ``)`` for complex queries. Prefix ``:`` could be used to | |||||
| select a stack. | |||||
| ``abandoned``, ``accepted``, ``closed``, ``needsreview``, ``needsrevision`` | |||||
| could be used to filter patches by status. For performance reason, they | |||||
| only represent a subset of non-status selections and cannot be used alone. | |||||
| For example, ``:D6+8-(2+D4)`` selects a stack up to D6, plus D8 and exclude | |||||
| D2 and D4. ``:D9 & needsreview`` selects "Needs Review" revisions in a | |||||
| stack up to D9. | |||||
| If --stack is given, follow dependencies information and read all patches. | |||||
| It is equivalent to the ``:`` operator. | |||||
| """ | |||||
| if opts.get('stack'): | |||||
| spec = ':(%s)' % spec | |||||
| drevs = querydrev(repo, spec) | |||||
| readpatch(repo, drevs, ui.write) | |||||
| @command('phabupdate', | |||||
| [('', 'accept', False, _('accept revisions')), | |||||
| ('', 'reject', False, _('reject revisions')), | |||||
| ('', 'abandon', False, _('abandon revisions')), | |||||
| ('', 'reclaim', False, _('reclaim revisions')), | |||||
| ('m', 'comment', '', _('comment on the last revision')), | |||||
| ], _('DREVSPEC [OPTIONS]')) | |||||
| def phabupdate(ui, repo, spec, **opts): | |||||
| """update Differential Revision in batch | |||||
| DREVSPEC selects revisions. See :hg:`help phabread` for its usage. | |||||
| """ | |||||
| flags = [n for n in 'accept reject abandon reclaim'.split() if opts.get(n)] | |||||
| if len(flags) > 1: | |||||
| raise error.Abort(_('%s cannot be used together') % ', '.join(flags)) | |||||
| actions = [] | |||||
| for f in flags: | |||||
| actions.append({'type': f, 'value': 'true'}) | |||||
| drevs = querydrev(repo, spec) | |||||
| for i, drev in enumerate(drevs): | |||||
| if i + 1 == len(drevs) and opts.get('comment'): | |||||
| actions.append({'type': 'comment', 'value': opts['comment']}) | |||||
| if actions: | |||||
| params = {'objectIdentifier': drev[r'phid'], | |||||
| 'transactions': actions} | |||||
| callconduit(repo, 'differential.revision.edit', params) | |||||