| hg-reviewers |
This will help us make hg debugcallconduit work outside a hg repo as next
patch will mark that command as no repo.
| Lint Skipped |
| Unit Tests Skipped |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgext/phabricator.py (40 lines) |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| b2be3e974ddb | 6cdbb1d19a57 | Pulkit Goyal | Jun 8 2019, 11:41 AM |
| token = auth.get(b'phabtoken') | token = auth.get(b'phabtoken') | ||||
| if not token: | if not token: | ||||
| raise error.Abort(_(b'Can\'t find conduit token associated to %s') | raise error.Abort(_(b'Can\'t find conduit token associated to %s') | ||||
| % (url,)) | % (url,)) | ||||
| return url, token | return url, token | ||||
| def callconduit(repo, name, params): | def callconduit(ui, name, params): | ||||
| """call Conduit API, params is a dict. return json.loads result, or None""" | """call Conduit API, params is a dict. return json.loads result, or None""" | ||||
| host, token = readurltoken(repo.ui) | host, token = readurltoken(ui) | ||||
| url, authinfo = util.url(b'/'.join([host, b'api', name])).authinfo() | url, authinfo = util.url(b'/'.join([host, b'api', name])).authinfo() | ||||
| repo.ui.debug(b'Conduit Call: %s %s\n' % (url, pycompat.byterepr(params))) | ui.debug(b'Conduit Call: %s %s\n' % (url, pycompat.byterepr(params))) | ||||
| params = params.copy() | params = params.copy() | ||||
| params[b'api.token'] = token | params[b'api.token'] = token | ||||
| data = urlencodenested(params) | data = urlencodenested(params) | ||||
| curlcmd = repo.ui.config(b'phabricator', b'curlcmd') | curlcmd = ui.config(b'phabricator', b'curlcmd') | ||||
| if curlcmd: | if curlcmd: | ||||
| sin, sout = procutil.popen2(b'%s -d @- %s' | sin, sout = procutil.popen2(b'%s -d @- %s' | ||||
| % (curlcmd, procutil.shellquote(url))) | % (curlcmd, procutil.shellquote(url))) | ||||
| sin.write(data) | sin.write(data) | ||||
| sin.close() | sin.close() | ||||
| body = sout.read() | body = sout.read() | ||||
| else: | else: | ||||
| urlopener = urlmod.opener(repo.ui, authinfo) | urlopener = urlmod.opener(ui, authinfo) | ||||
| request = util.urlreq.request(pycompat.strurl(url), data=data) | request = util.urlreq.request(pycompat.strurl(url), data=data) | ||||
| with contextlib.closing(urlopener.open(request)) as rsp: | with contextlib.closing(urlopener.open(request)) as rsp: | ||||
| body = rsp.read() | body = rsp.read() | ||||
| repo.ui.debug(b'Conduit Response: %s\n' % body) | ui.debug(b'Conduit Response: %s\n' % body) | ||||
| parsed = pycompat.rapply( | parsed = pycompat.rapply( | ||||
| lambda x: encoding.unitolocal(x) if isinstance(x, pycompat.unicode) | lambda x: encoding.unitolocal(x) if isinstance(x, pycompat.unicode) | ||||
| else x, | else x, | ||||
| json.loads(body) | json.loads(body) | ||||
| ) | ) | ||||
| if parsed.get(b'error_code'): | if parsed.get(b'error_code'): | ||||
| msg = (_(b'Conduit Error (%s): %s') | msg = (_(b'Conduit Error (%s): %s') | ||||
| % (parsed[b'error_code'], parsed[b'error_info'])) | % (parsed[b'error_code'], parsed[b'error_info'])) | ||||
| # json.loads only returns unicode strings | # json.loads only returns unicode strings | ||||
| params = pycompat.rapply(lambda x: | params = pycompat.rapply(lambda x: | ||||
| encoding.unitolocal(x) if isinstance(x, pycompat.unicode) else x, | encoding.unitolocal(x) if isinstance(x, pycompat.unicode) else x, | ||||
| json.loads(rawparams) | json.loads(rawparams) | ||||
| ) | ) | ||||
| # json.dumps only accepts unicode strings | # json.dumps only accepts unicode strings | ||||
| result = pycompat.rapply(lambda x: | result = pycompat.rapply(lambda x: | ||||
| encoding.unifromlocal(x) if isinstance(x, bytes) else x, | encoding.unifromlocal(x) if isinstance(x, bytes) else x, | ||||
| callconduit(repo, name, params) | callconduit(ui, name, params) | ||||
| ) | ) | ||||
| s = json.dumps(result, sort_keys=True, indent=2, separators=(u',', u': ')) | s = json.dumps(result, sort_keys=True, indent=2, separators=(u',', u': ')) | ||||
| ui.write(b'%s\n' % encoding.unitolocal(s)) | ui.write(b'%s\n' % encoding.unitolocal(s)) | ||||
| def getrepophid(repo): | def getrepophid(repo): | ||||
| """given callsign, return repository PHID or None""" | """given callsign, return repository PHID or None""" | ||||
| # developer config: phabricator.repophid | # developer config: phabricator.repophid | ||||
| repophid = repo.ui.config(b'phabricator', b'repophid') | repophid = repo.ui.config(b'phabricator', b'repophid') | ||||
| if repophid: | if repophid: | ||||
| return repophid | return repophid | ||||
| callsign = repo.ui.config(b'phabricator', b'callsign') | callsign = repo.ui.config(b'phabricator', b'callsign') | ||||
| if not callsign: | if not callsign: | ||||
| return None | return None | ||||
| query = callconduit(repo, b'diffusion.repository.search', | query = callconduit(repo.ui, b'diffusion.repository.search', | ||||
| {b'constraints': {b'callsigns': [callsign]}}) | {b'constraints': {b'callsigns': [callsign]}}) | ||||
| if len(query[b'data']) == 0: | if len(query[b'data']) == 0: | ||||
| return None | return None | ||||
| repophid = query[b'data'][0][b'phid'] | repophid = query[b'data'][0][b'phid'] | ||||
| repo.ui.setconfig(b'phabricator', b'repophid', repophid) | repo.ui.setconfig(b'phabricator', b'repophid', repophid) | ||||
| return repophid | return repophid | ||||
| _differentialrevisiontagre = re.compile(br'\AD([1-9][0-9]*)\Z') | _differentialrevisiontagre = re.compile(br'\AD([1-9][0-9]*)\Z') | ||||
| m = _differentialrevisiondescre.search(ctx.description()) | m = _differentialrevisiondescre.search(ctx.description()) | ||||
| if m: | if m: | ||||
| toconfirm[node] = (1, set(precnodes), int(m.group(r'id'))) | toconfirm[node] = (1, set(precnodes), int(m.group(r'id'))) | ||||
| # Double check if tags are genuine by collecting all old nodes from | # Double check if tags are genuine by collecting all old nodes from | ||||
| # Phabricator, and expect precursors overlap with it. | # Phabricator, and expect precursors overlap with it. | ||||
| if toconfirm: | if toconfirm: | ||||
| drevs = [drev for force, precs, drev in toconfirm.values()] | drevs = [drev for force, precs, drev in toconfirm.values()] | ||||
| alldiffs = callconduit(unfi, b'differential.querydiffs', | alldiffs = callconduit(unfi.ui, b'differential.querydiffs', | ||||
| {b'revisionIDs': drevs}) | {b'revisionIDs': drevs}) | ||||
| getnode = lambda d: bin( | getnode = lambda d: bin( | ||||
| getdiffmeta(d).get(b'node', b'')) or None | getdiffmeta(d).get(b'node', b'')) or None | ||||
| for newnode, (force, precset, drev) in toconfirm.items(): | for newnode, (force, precset, drev) in toconfirm.items(): | ||||
| diffs = [d for d in alldiffs.values() | diffs = [d for d in alldiffs.values() | ||||
| if int(d[b'revisionID']) == drev] | if int(d[b'revisionID']) == drev] | ||||
| # "precursors" as known by Phabricator | # "precursors" as known by Phabricator | ||||
| def creatediff(ctx): | def creatediff(ctx): | ||||
| """create a Differential Diff""" | """create a Differential Diff""" | ||||
| repo = ctx.repo() | repo = ctx.repo() | ||||
| repophid = getrepophid(repo) | repophid = getrepophid(repo) | ||||
| # Create a "Differential Diff" via "differential.createrawdiff" API | # Create a "Differential Diff" via "differential.createrawdiff" API | ||||
| params = {b'diff': getdiff(ctx, mdiff.diffopts(git=True, context=32767))} | params = {b'diff': getdiff(ctx, mdiff.diffopts(git=True, context=32767))} | ||||
| if repophid: | if repophid: | ||||
| params[b'repositoryPHID'] = repophid | params[b'repositoryPHID'] = repophid | ||||
| diff = callconduit(repo, b'differential.createrawdiff', params) | diff = callconduit(repo.ui, b'differential.createrawdiff', params) | ||||
| if not diff: | if not diff: | ||||
| raise error.Abort(_(b'cannot create diff for %s') % ctx) | raise error.Abort(_(b'cannot create diff for %s') % ctx) | ||||
| return diff | return diff | ||||
| def writediffproperties(ctx, diff): | def writediffproperties(ctx, diff): | ||||
| """write metadata to diff so patches could be applied losslessly""" | """write metadata to diff so patches could be applied losslessly""" | ||||
| params = { | params = { | ||||
| b'diff_id': diff[b'id'], | b'diff_id': diff[b'id'], | ||||
| b'name': b'hg:meta', | b'name': b'hg:meta', | ||||
| b'data': templatefilters.json({ | b'data': templatefilters.json({ | ||||
| b'user': ctx.user(), | b'user': ctx.user(), | ||||
| b'date': b'%d %d' % ctx.date(), | b'date': b'%d %d' % ctx.date(), | ||||
| b'branch': ctx.branch(), | b'branch': ctx.branch(), | ||||
| b'node': ctx.hex(), | b'node': ctx.hex(), | ||||
| b'parent': ctx.p1().hex(), | b'parent': ctx.p1().hex(), | ||||
| }), | }), | ||||
| } | } | ||||
| callconduit(ctx.repo(), b'differential.setdiffproperty', params) | callconduit(ctx.repo().ui, b'differential.setdiffproperty', params) | ||||
| params = { | params = { | ||||
| b'diff_id': diff[b'id'], | b'diff_id': diff[b'id'], | ||||
| b'name': b'local:commits', | b'name': b'local:commits', | ||||
| b'data': templatefilters.json({ | b'data': templatefilters.json({ | ||||
| ctx.hex(): { | ctx.hex(): { | ||||
| b'author': stringutil.person(ctx.user()), | b'author': stringutil.person(ctx.user()), | ||||
| b'authorEmail': stringutil.email(ctx.user()), | b'authorEmail': stringutil.email(ctx.user()), | ||||
| b'time': int(ctx.date()[0]), | b'time': int(ctx.date()[0]), | ||||
| b'commit': ctx.hex(), | b'commit': ctx.hex(), | ||||
| b'parents': [ctx.p1().hex()], | b'parents': [ctx.p1().hex()], | ||||
| b'branch': ctx.branch(), | b'branch': ctx.branch(), | ||||
| }, | }, | ||||
| }), | }), | ||||
| } | } | ||||
| callconduit(ctx.repo(), b'differential.setdiffproperty', params) | callconduit(ctx.repo().ui, b'differential.setdiffproperty', params) | ||||
| def createdifferentialrevision(ctx, revid=None, parentrevid=None, oldnode=None, | def createdifferentialrevision(ctx, revid=None, parentrevid=None, oldnode=None, | ||||
| olddiff=None, actions=None): | olddiff=None, actions=None): | ||||
| """create or update a Differential Revision | """create or update a Differential Revision | ||||
| If revid is None, create a new Differential Revision, otherwise update | If revid is None, create a new Differential Revision, otherwise update | ||||
| revid. If parentrevid is not None, set it as a dependency. | revid. If parentrevid is not None, set it as a dependency. | ||||
| transactions += [{b'type': b'summary', b'value': summary}, | transactions += [{b'type': b'summary', b'value': summary}, | ||||
| {b'type': b'summary', b'value': b' '}] | {b'type': b'summary', b'value': b' '}] | ||||
| if actions: | if actions: | ||||
| transactions += actions | transactions += actions | ||||
| # Parse commit message and update related fields. | # Parse commit message and update related fields. | ||||
| desc = ctx.description() | desc = ctx.description() | ||||
| info = callconduit(repo, b'differential.parsecommitmessage', | info = callconduit(repo.ui, b'differential.parsecommitmessage', | ||||
| {b'corpus': desc}) | {b'corpus': desc}) | ||||
| for k, v in info[b'fields'].items(): | for k, v in info[b'fields'].items(): | ||||
| if k in [b'title', b'summary', b'testPlan']: | if k in [b'title', b'summary', b'testPlan']: | ||||
| transactions.append({b'type': k, b'value': v}) | transactions.append({b'type': k, b'value': v}) | ||||
| params = {b'transactions': transactions} | params = {b'transactions': transactions} | ||||
| if revid is not None: | if revid is not None: | ||||
| # Update an existing Differential Revision | # Update an existing Differential Revision | ||||
| params[b'objectIdentifier'] = revid | params[b'objectIdentifier'] = revid | ||||
| revision = callconduit(repo, b'differential.revision.edit', params) | revision = callconduit(repo.ui, b'differential.revision.edit', params) | ||||
| if not revision: | if not revision: | ||||
| raise error.Abort(_(b'cannot create revision for %s') % ctx) | raise error.Abort(_(b'cannot create revision for %s') % ctx) | ||||
| return revision, diff | return revision, diff | ||||
| def userphids(repo, names): | def userphids(repo, names): | ||||
| """convert user names to PHIDs""" | """convert user names to PHIDs""" | ||||
| names = [name.lower() for name in names] | names = [name.lower() for name in names] | ||||
| query = {b'constraints': {b'usernames': names}} | query = {b'constraints': {b'usernames': names}} | ||||
| result = callconduit(repo, b'user.search', query) | result = callconduit(repo.ui, b'user.search', query) | ||||
| # username not found is not an error of the API. So check if we have missed | # username not found is not an error of the API. So check if we have missed | ||||
| # some names here. | # some names here. | ||||
| data = result[b'data'] | data = result[b'data'] | ||||
| resolved = set(entry[b'fields'][b'username'].lower() for entry in data) | resolved = set(entry[b'fields'][b'username'].lower() for entry in data) | ||||
| unresolved = set(names) - resolved | unresolved = set(names) - resolved | ||||
| if unresolved: | if unresolved: | ||||
| raise error.Abort(_(b'unknown username: %s') | raise error.Abort(_(b'unknown username: %s') | ||||
| % b' '.join(sorted(unresolved))) | % b' '.join(sorted(unresolved))) | ||||
| ui.write(_(b'%s - %s - %s: %s\n') % (drevdesc, actiondesc, nodedesc, | ui.write(_(b'%s - %s - %s: %s\n') % (drevdesc, actiondesc, nodedesc, | ||||
| desc)) | desc)) | ||||
| drevids.append(newrevid) | drevids.append(newrevid) | ||||
| lastrevid = newrevid | lastrevid = newrevid | ||||
| # Update commit messages and remove tags | # Update commit messages and remove tags | ||||
| if opts.get(b'amend'): | if opts.get(b'amend'): | ||||
| unfi = repo.unfiltered() | unfi = repo.unfiltered() | ||||
| drevs = callconduit(repo, b'differential.query', {b'ids': drevids}) | drevs = callconduit(ui, b'differential.query', {b'ids': drevids}) | ||||
| with repo.wlock(), repo.lock(), repo.transaction(b'phabsend'): | with repo.wlock(), repo.lock(), repo.transaction(b'phabsend'): | ||||
| wnode = unfi[b'.'].node() | wnode = unfi[b'.'].node() | ||||
| mapping = {} # {oldnode: [newnode]} | mapping = {} # {oldnode: [newnode]} | ||||
| for i, rev in enumerate(revs): | for i, rev in enumerate(revs): | ||||
| old = unfi[rev] | old = unfi[rev] | ||||
| drevid = drevids[i] | drevid = drevids[i] | ||||
| drev = [d for d in drevs if int(d[b'id']) == drevid][0] | drev = [d for d in drevs if int(d[b'id']) == drevid][0] | ||||
| newdesc = getdescfromdrev(drev) | newdesc = getdescfromdrev(drev) | ||||
| "sourcePath": null | "sourcePath": null | ||||
| } | } | ||||
| """ | """ | ||||
| def fetch(params): | def fetch(params): | ||||
| """params -> single drev or None""" | """params -> single drev or None""" | ||||
| key = (params.get(b'ids') or params.get(b'phids') or [None])[0] | key = (params.get(b'ids') or params.get(b'phids') or [None])[0] | ||||
| if key in prefetched: | if key in prefetched: | ||||
| return prefetched[key] | return prefetched[key] | ||||
| drevs = callconduit(repo, b'differential.query', params) | drevs = callconduit(repo.ui, b'differential.query', params) | ||||
| # Fill prefetched with the result | # Fill prefetched with the result | ||||
| for drev in drevs: | for drev in drevs: | ||||
| prefetched[drev[b'phid']] = drev | prefetched[drev[b'phid']] = drev | ||||
| prefetched[int(drev[b'id'])] = drev | prefetched[int(drev[b'id'])] = drev | ||||
| if key not in prefetched: | if key not in prefetched: | ||||
| raise error.Abort(_(b'cannot get Differential Revision %r') | raise error.Abort(_(b'cannot get Differential Revision %r') | ||||
| % params) | % params) | ||||
| return prefetched[key] | return prefetched[key] | ||||
| def readpatch(repo, drevs, write): | def readpatch(repo, drevs, write): | ||||
| """generate plain-text patch readable by 'hg import' | """generate plain-text patch readable by 'hg import' | ||||
| write is usually ui.write. drevs is what "querydrev" returns, results of | write is usually ui.write. drevs is what "querydrev" returns, results of | ||||
| "differential.query". | "differential.query". | ||||
| """ | """ | ||||
| # Prefetch hg:meta property for all diffs | # Prefetch hg:meta property for all diffs | ||||
| diffids = sorted(set(max(int(v) for v in drev[b'diffs']) for drev in drevs)) | diffids = sorted(set(max(int(v) for v in drev[b'diffs']) for drev in drevs)) | ||||
| diffs = callconduit(repo, b'differential.querydiffs', {b'ids': diffids}) | diffs = callconduit(repo.ui, b'differential.querydiffs', {b'ids': diffids}) | ||||
| # Generate patch for each drev | # Generate patch for each drev | ||||
| for drev in drevs: | for drev in drevs: | ||||
| repo.ui.note(_(b'reading D%s\n') % drev[b'id']) | repo.ui.note(_(b'reading D%s\n') % drev[b'id']) | ||||
| diffid = max(int(v) for v in drev[b'diffs']) | diffid = max(int(v) for v in drev[b'diffs']) | ||||
| body = callconduit(repo, b'differential.getrawdiff', | body = callconduit(repo.ui, b'differential.getrawdiff', | ||||
| {b'diffID': diffid}) | {b'diffID': diffid}) | ||||
| desc = getdescfromdrev(drev) | desc = getdescfromdrev(drev) | ||||
| header = b'# HG changeset patch\n' | header = b'# HG changeset patch\n' | ||||
| # Try to preserve metadata from hg:meta property. Write hg patch | # Try to preserve metadata from hg:meta property. Write hg patch | ||||
| # headers that can be read by the "import" command. See patchheadermap | # headers that can be read by the "import" command. See patchheadermap | ||||
| # and extract in mercurial/patch.py for supported headers. | # and extract in mercurial/patch.py for supported headers. | ||||
| meta = getdiffmeta(diffs[b'%d' % diffid]) | meta = getdiffmeta(diffs[b'%d' % diffid]) | ||||
| drevs = querydrev(repo, spec) | drevs = querydrev(repo, spec) | ||||
| for i, drev in enumerate(drevs): | for i, drev in enumerate(drevs): | ||||
| if i + 1 == len(drevs) and opts.get(b'comment'): | if i + 1 == len(drevs) and opts.get(b'comment'): | ||||
| actions.append({b'type': b'comment', b'value': opts[b'comment']}) | actions.append({b'type': b'comment', b'value': opts[b'comment']}) | ||||
| if actions: | if actions: | ||||
| params = {b'objectIdentifier': drev[b'phid'], | params = {b'objectIdentifier': drev[b'phid'], | ||||
| b'transactions': actions} | b'transactions': actions} | ||||
| callconduit(repo, b'differential.revision.edit', params) | callconduit(ui, b'differential.revision.edit', params) | ||||
| templatekeyword = registrar.templatekeyword() | templatekeyword = registrar.templatekeyword() | ||||
| @templatekeyword(b'phabreview', requires={b'ctx'}) | @templatekeyword(b'phabreview', requires={b'ctx'}) | ||||
| def template_review(context, mapping): | def template_review(context, mapping): | ||||
| """:phabreview: Object describing the review for this changeset. | """:phabreview: Object describing the review for this changeset. | ||||
| Has attributes `url` and `id`. | Has attributes `url` and `id`. | ||||
| """ | """ | ||||