def submit(repo, args):
if environment.DEBUG:
arcanist.ARC.append("--trace")
telemetry.metrics.mozphab.submission.preparation_time.start()
with wait_message("Checking connection to Phabricator."):
# Check if raw Conduit API can be used
if not conduit.check():
raise Error("Failed to use Conduit API")
# Check if local and remote VCS matches
repo.check_vcs()
# Check if arc is configured
if not args.no_arc and not repo.check_arc():
raise Error("Failed to run %s." % arcanist.ARC_COMMAND)
repo.before_submit()
# Find and preview commits to submits.
with wait_message("Looking for commits.."):
commits = repo.commit_stack(single=args.single)
if not commits:
raise Error("Failed to find any commits to submit")
with wait_message("Loading commits.."):
# Pre-process to load metadata.
morph_blocking_reviewers(commits)
augment_commits_from_body(commits)
update_commits_from_args(commits, args)
# Display a one-line summary of commit and WIP count.
commit_count = len(commits)
wip_commit_count = sum(1 for commit in commits if commit["wip"])
if wip_commit_count == commit_count:
status = "as Work In Progress"
elif wip_commit_count:
status = f"{wip_commit_count} as Work In Progress"
else:
status = "for review"
logger.warning(
f"Submitting {commit_count} commit{'s'[:commit_count^1]} {status}")
# Validate commit stack is suitable for review.
show_commit_stack(commits, validate=True)
try:
with wait_message("Checking commits.."):
repo.check_commits_for_submit(commits, require_bug=not args.no_bug)
except Error as e:
if not args.force:
raise Error("Unable to submit commits:\n\n%s" % e)
logger.error("Ignoring issues found with commits:\n\n%s", e)
if not any(commit["submit"] for commit in commits):
logger.warning("No changes to submit.")
return
# Show a warning if there are untracked files.
if config.warn_untracked:
untracked = repo.untracked()
if untracked:
logger.warning(
"Warning: found %s untracked file%s (will not be submitted):",
len(untracked),
"" if len(untracked) == 1 else "s",
)
if len(untracked) <= 5:
for filename in untracked:
logger.info(" %s", filename)
# Show a warning if -m is used and there are new commits.
if args.message and any([c for c in commits if not c["rev-id"]]):
logger.warning(
"Warning: --message works with updates only, and will not\n"
"be result in a comment on new revisions.")
telemetry.metrics.mozphab.submission.preparation_time.stop()
telemetry.metrics.mozphab.submission.commits_count.add(len(commits))
# Confirmation prompt.
if args.yes:
pass
elif config.auto_submit and not args.interactive:
logger.info(
"Automatically submitting (as per submit.auto_submit in %s)",
config.name)
else:
res = prompt(
"Submit to %s" %
PHABRICATOR_URLS.get(repo.phab_url, repo.phab_url),
["Yes", "No", "Always"],
)
if res == "No":
return
if res == "Always":
config.auto_submit = True
config.write()
# Process.
telemetry.metrics.mozphab.submission.process_time.start()
previous_commit = None
# Collect all existing revisions to get reviewers info.
rev_ids_to_update = [int(c["rev-id"]) for c in commits if c.get("rev-id")]
revisions_to_update = None
if rev_ids_to_update:
with wait_message("Loading revision data..."):
list_to_update = conduit.get_revisions(ids=rev_ids_to_update)
revisions_to_update = {str(r["id"]): r for r in list_to_update}
last_node = commits[-1]["orig-node"]
for commit in commits:
diff = None
check_in_needed = args.check_in_needed and commit[
"orig-node"] == last_node
# Only revisions being updated have an ID. Newly created ones don't.
if not commit["submit"]:
previous_commit = commit
continue
is_update = bool(commit["rev-id"])
revision_to_update = (revisions_to_update[commit["rev-id"]]
if is_update else None)
existing_reviewers = (
revision_to_update["attachments"]["reviewers"]["reviewers"]
if revision_to_update else None)
# Let the user know something's happening.
if is_update:
logger.info("\nUpdating revision D%s:", commit["rev-id"])
else:
logger.info("\nCreating new revision:")
logger.info("%s %s", commit["name"],
revision_title_from_commit(commit))
repo.checkout(commit["node"])
# WIP submissions shouldn't set reviewers on phabricator.
if commit["wip"]:
reviewers = ""
else:
reviewers = ", ".join(commit["reviewers"]["granted"] +
commit["reviewers"]["request"])
# Create arc-annotated commit description.
template_vars = dict(
title=revision_title_from_commit(commit),
body=commit["body"],
reviewers=reviewers,
bug_id=commit["bug-id"],
)
summary = commit["body"]
if previous_commit and not args.no_stack:
template_vars[
"depends_on"] = "Depends on D%s" % previous_commit["rev-id"]
summary = "%s\n\n%s" % (summary, template_vars["depends_on"])
message = arc_message(template_vars)
if args.no_arc:
# Create a diff if needed
with wait_message("Creating local diff..."):
diff = repo.get_diff(commit)
if diff:
telemetry.metrics.mozphab.submission.files_count.add(
len(diff.changes))
with wait_message("Uploading binary file(s)..."):
diff.upload_files()
with wait_message("Submitting the diff..."):
diff.submit(commit, message)
if is_update:
with wait_message("Updating revision..."):
rev = conduit.update_revision(
commit,
existing_reviewers,
diff_phid=diff.phid,
comment=args.message,
check_in_needed=check_in_needed,
)
else:
with wait_message("Creating a new revision..."):
rev = conduit.create_revision(
commit,
summary,
diff.phid,
check_in_needed=check_in_needed,
)
revision_url = "%s/D%s" % (repo.phab_url, rev["object"]["id"])
else:
# Run arc.
with temporary_file(message) as message_file:
arc_args = (["diff"] + ["--base", "arc:this"] +
["--allow-untracked", "--no-amend", "--no-ansi"] +
["--message-file", message_file])
if args.nolint:
arc_args.append("--nolint")
if commit["wip"]:
arc_args.append("--plan-changes")
if args.lesscontext:
arc_args.append("--less-context")
if is_update:
message = args.message if args.message else DEFAULT_UPDATE_MESSAGE
arc_args.extend(["--message", message] +
["--update", commit["rev-id"]])
else:
arc_args.append("--create")
revision_url = None
for line in check_call_by_line(arcanist.ARC + arc_args,
cwd=repo.path,
never_log=True):
print(line)
revision_url = extract_revision_url(line) or revision_url
if not revision_url:
raise Error("Failed to find 'Revision URL' in arc output")
if is_update:
current_status = revision_to_update["fields"]["status"][
"value"]
with wait_message("Updating D%s.." % commit["rev-id"]):
transactions = []
revision = conduit.get_revisions(
ids=[int(commit["rev-id"])])[0]
update_revision_description(transactions, commit, revision)
update_revision_bug_id(transactions, commit, revision)
# Add reviewers only if revision lacks them
if (not commit["wip"] and commit["has-reviewers"]
and not existing_reviewers):
conduit.update_revision_reviewers(transactions, commit)
if current_status != "needs-review":
transactions.append(dict(type="request-review"))
if transactions:
arcanist.call_conduit(
"differential.revision.edit",
{
"objectIdentifier": "D%s" % commit["rev-id"],
"transactions": transactions,
},
repo.path,
)
# Append/replace div rev url to/in commit description.
body = amend_revision_url(commit["body"], revision_url)
# Amend the commit if required.
# As commit rewriting can be expensive we avoid it in some circumstances, such
# as pre-pending "WIP: " to commits submitted as WIP to Phabricator.
if commit["title-preview"] != commit["title"] or body != commit["body"]:
commit["title"] = commit["title-preview"]
commit["body"] = body
commit["rev-id"] = parse_arc_diff_rev(commit["body"])
with wait_message("Updating commit.."):
repo.amend_commit(commit, commits)
# Diff property has to be set after potential SHA1 change.
if args.no_arc and diff:
with wait_message("Setting diff metadata..."):
diff.set_property(commit, message)
previous_commit = commit
# Cleanup (eg. strip nodes) and refresh to ensure the stack is right for the
# final showing.
with wait_message("Cleaning up.."):
repo.finalize(commits)
repo.after_submit()
repo.cleanup()
repo.refresh_commit_stack(commits)
logger.warning("\nCompleted")
show_commit_stack(commits,
validate=False,
show_rev_urls=True,
show_updated_only=True)
telemetry.metrics.mozphab.submission.process_time.stop()
def show_commit_stack(
commits,
validate=True,
show_rev_urls=False,
show_updated_only=False,
):
"""Log the commit stack in a human readable form."""
# keep output in columns by sizing the action column to the longest rev + 1 ("D")
max_len = (max(len(c.get("rev-id", "") or "")
for c in commits) + 1 if commits else "")
action_template = "(%" + str(max_len) + "s)"
if validate:
# preload all revisions
ids = [int(c["rev-id"]) for c in commits if c.get("rev-id")]
if ids:
with wait_message("Loading existing revisions..."):
revisions = conduit.get_revisions(ids=ids)
# preload diffs
with wait_message("Loading diffs..."):
diffs = conduit.get_diffs(
[r["fields"]["diffPHID"] for r in revisions])
for commit in reversed(commits):
if show_updated_only and not commit["submit"]:
continue
revision_is_closed = False
revision_is_wip = False
bug_id_changed = False
is_author = True
revision = None
if commit.get("rev-id"):
action = action_template % ("D" + commit["rev-id"])
if validate:
revisions = conduit.get_revisions(ids=[int(commit["rev-id"])])
if revisions:
revision = revisions[0]
fields = revision["fields"]
# WIP if either in changes-planned state, or if the revision has the
# `draft` flag set.
revision_is_wip = (fields["status"]["value"]
== "changes-planned"
or fields["isDraft"])
# Check if target bug ID is the same as in the Phabricator revision
bug_id_changed = fields.get("bugzilla.bug-id") and (
commit["bug-id"] != fields["bugzilla.bug-id"])
# Check if revision is closed
revision_is_closed = fields["status"]["closed"]
# Check if comandeering is required
with wait_message("Figuring out who you are..."):
whoami = conduit.whoami()
if "authorPHID" in fields and (fields["authorPHID"] !=
whoami["phid"]):
is_author = False
# Any reviewers added to a revision without them?
reviewers_added = bool(
not revision["attachments"]["reviewers"]["reviewers"]
and commit["reviewers"]["granted"])
# if SHA1 hasn't changed
# and we're not changing the WIP or draft status
# and we're not adding reviewers to a revision without reviewers
# and we're not changing the bug-id
diff_phid = fields["diffPHID"]
diff_commits = diffs[diff_phid]["attachments"]["commits"][
"commits"]
sha1_changed = commit["node"] != diff_commits[0][
"identifier"]
if (not sha1_changed and commit["wip"] == revision_is_wip
and not reviewers_added and not bug_id_changed
and not revision_is_closed):
commit["submit"] = False
else:
action = action_template % "New"
logger.info("%s %s %s", action, commit["name"],
commit["title-preview"])
if validate:
if not commit["submit"]:
logger.info(
" * This revision has not changed and will not be submitted."
)
continue
if revision:
if not commit["wip"] and revision_is_wip:
logger.warning(
'!! "Changes Planned" status will change to "Request Review"'
)
if commit["wip"] and not revision_is_wip:
logger.warning(
'!! "Request Review" status will change to "Changes Planned"'
)
if bug_id_changed:
logger.warning(
"!! Bug ID in Phabricator revision will change from %s to %s",
revision["fields"]["bugzilla.bug-id"],
commit["bug-id"],
)
if not is_author:
logger.warning(
"!! You don't own this revision. Normally, you should only\n"
' update revisions you own. You can "Commandeer" this\n'
" revision from the web interface if you want to become\n"
" the owner.")
if revision_is_closed:
logger.warning(
"!! This revision is closed!\n"
" It will be reopened if submission proceeds.\n"
" You can stop now and refine the stack range.")
if not commit["bug-id"]:
logger.warning("!! Missing Bug ID")
if commit["bug-id-orig"] and commit["bug-id"] != commit[
"bug-id-orig"]:
logger.warning(
"!! Bug ID changed from %s to %s",
commit["bug-id-orig"],
commit["bug-id"],
)
if not commit["has-reviewers"]:
logger.warning(
"!! Missing reviewers\n"
' It will be submitted as "Changes Planned".\n'
" Run submit again with --no-wip to prevent this.")
if show_rev_urls and commit["rev-id"]:
logger.warning("-> %s/D%s", conduit.repo.phab_url,
commit["rev-id"])
def show_commit_stack(
commits,
wip=None,
validate=True,
ignore_reviewers=False,
show_rev_urls=False,
show_updated_only=False,
):
"""Log the commit stack in a human readable form."""
# keep output in columns by sizing the action column to the longest rev + 1 ("D")
max_len = (max(len(c.get("rev-id", "") or "")
for c in commits) + 1 if commits else "")
action_template = "(%" + str(max_len) + "s)"
if validate:
# preload all revisions
ids = [int(c["rev-id"]) for c in commits if c.get("rev-id")]
if ids:
with wait_message("Loading existing revisions..."):
revisions = conduit.get_revisions(ids=ids)
# preload diffs
with wait_message("Loading diffs..."):
diffs = conduit.get_diffs(
[r["fields"]["diffPHID"] for r in revisions])
for commit in reversed(commits):
if show_updated_only and not commit["submit"]:
continue
closed = False
change_bug_id = False
is_author = True
revision = None
wip_removed = False
wip_set = False
reviewers_added = False
if commit.get("rev-id"):
action = action_template % ("D" + commit["rev-id"])
if validate:
revisions = conduit.get_revisions(ids=[int(commit["rev-id"])])
if len(revisions) > 0:
revision = revisions[0]
# Check if target bug ID is the same as in the Phabricator revision
change_bug_id = ("bugzilla.bug-id" in revision["fields"]
and revision["fields"]["bugzilla.bug-id"]
and
(commit["bug-id"] !=
revision["fields"]["bugzilla.bug-id"]))
# Check if revision is closed
closed = revision["fields"]["status"]["closed"]
# Check if comandeering is required
whoami = conduit.whoami()
if "authorPHID" in revision["fields"] and (
revision["fields"]["authorPHID"] !=
whoami["phid"]):
is_author = False
# Do we remove "Changes Planned" status?
wip_removed = (not wip
and revision["fields"]["status"]["value"]
== "changes-planned")
# Do we set "Changes Planned" status?
wip_set = (wip and revision["fields"]["status"]["value"] !=
"changes-planned")
# Any reviewers added to a revision without them?
reviewers_added = bool(
not revision["attachments"]["reviewers"]["reviewers"]
and commit["reviewers"]["granted"])
# if SHA1 hasn't changed
# and we're not changing the WIP status
# and we're not adding reviewers to a revision without reviewers
# and we're not changing the bug-id
sha1_changed = (
commit["node"] != diffs[revision["fields"]["diffPHID"]]
["attachments"]["commits"]["commits"][0]["identifier"])
if (not sha1_changed and not wip_removed and not wip_set
and not reviewers_added and not change_bug_id
and not closed):
commit["submit"] = False
else:
action = action_template % "New"
logger.info("%s %s %s", action, commit["name"],
commit["title-preview"])
if validate:
if not commit["submit"]:
logger.info(
" * This revision is not changed and will not be submitted."
)
else:
if wip_removed:
logger.warning(
'!! "Changes Planned" status will change to "Request Review"'
)
if change_bug_id:
logger.warning(
"!! Bug ID in Phabricator revision will change from %s to %s",
revision["fields"]["bugzilla.bug-id"],
commit["bug-id"],
)
if not is_author:
logger.warning(
"!! You don't own this revision. Normally, you should only\n"
' update revisions you own. You can "Commandeer" this\n'
" revision from the web interface if you want to become\n"
" the owner.")
if closed:
logger.warning(
"!! This revision is closed!\n"
" It will be reopened if submission proceeds.\n"
" You can stop now and refine the stack range.")
if not commit["bug-id"]:
logger.warning("!! Missing Bug ID")
if commit["bug-id-orig"] and commit["bug-id"] != commit[
"bug-id-orig"]:
logger.warning(
"!! Bug ID changed from %s to %s",
commit["bug-id-orig"],
commit["bug-id"],
)
if (not ignore_reviewers
and not commit["reviewers"]["granted"] +
commit["reviewers"]["request"]):
logger.warning("!! Missing reviewers")
if show_rev_urls and commit["rev-id"]:
logger.warning("-> %s/D%s", conduit.repo.phab_url,
commit["rev-id"])
def show_commit_stack(commits,
validate=True,
ignore_reviewers=False,
show_rev_urls=False):
"""Log the commit stack in a human readable form."""
# keep output in columns by sizing the action column to the longest rev + 1 ("D")
max_len = (max(len(c.get("rev-id", "") or "")
for c in commits) + 1 if commits else "")
action_template = "(%" + str(max_len) + "s)"
if validate:
# preload all revisions
ids = [int(c["rev-id"]) for c in commits if c.get("rev-id")]
if ids:
with wait_message("Loading existing revisions..."):
conduit.get_revisions(ids=ids)
for commit in reversed(commits):
closed = False
change_bug_id = False
is_author = True
revision = None
if commit.get("rev-id"):
action = action_template % ("D" + commit["rev-id"])
if validate:
revisions = conduit.get_revisions(ids=[int(commit["rev-id"])])
if len(revisions) > 0:
revision = revisions[0]
# Check if target bug ID is the same as in the Phabricator revision
change_bug_id = ("bugzilla.bug-id" in revision["fields"]
and revision["fields"]["bugzilla.bug-id"]
and
(commit["bug-id"] !=
revision["fields"]["bugzilla.bug-id"]))
# Check if revision is closed
closed = revision["fields"]["status"]["closed"]
# Check if comandeering is required
whoami = conduit.whoami()
if "authorPHID" in revision["fields"] and (
revision["fields"]["authorPHID"] !=
whoami["phid"]):
is_author = False
else:
action = action_template % "New"
logger.info("%s %s %s", action, commit["name"],
commit["title-preview"])
if validate:
if change_bug_id:
logger.warning(
"!! Bug ID in Phabricator revision will be changed from %s to %s",
revision["fields"]["bugzilla.bug-id"],
commit["bug-id"],
)
if not is_author:
logger.warning(
"!! You don't own this revision. Normally, you should only\n"
' update revisions you own. You can "Commandeer" this\n'
" revision from the web interface if you want to become\n"
" the owner.")
if closed:
logger.warning(
"!! This revision is closed!\n"
" It will be reopened if submission proceeds.\n"
" You can stop now and refine the stack range.")
if not commit["bug-id"]:
logger.warning("!! Missing Bug ID")
if commit["bug-id-orig"] and commit["bug-id"] != commit[
"bug-id-orig"]:
logger.warning(
"!! Bug ID changed from %s to %s",
commit["bug-id-orig"],
commit["bug-id"],
)
if (not ignore_reviewers and not commit["reviewers"]["granted"] +
commit["reviewers"]["request"]):
logger.warning("!! Missing reviewers")
if show_rev_urls and commit["rev-id"]:
logger.warning("-> %s/D%s", conduit.repo.phab_url,
commit["rev-id"])
def reorganise(repo, args):
telemetry.metrics.mozphab.submission.preparation_time.start()
with wait_message("Checking connection to Phabricator."):
# Check if raw Conduit API can be used
if not conduit.check():
raise Error("Failed to use Conduit API")
# Find and preview commits to submits.
with wait_message("Looking for commits.."):
commits = repo.commit_stack()
if not commits:
raise Error("Failed to find any commits to reorganise.")
with wait_message("Loading commits.."):
augment_commits_from_body(commits)
localstack_ids = [c["rev-id"] for c in commits]
if None in localstack_ids:
names = [c["name"] for c in commits if c["rev-id"] is None]
plural = len(names) > 1
raise Error(
"Found new commit{plural} in the local stack: {names}.\n"
"Please submit {them} separately and call the `reorg` again.".
format(
plural="s" if plural else "",
them="them" if plural else "it",
names=", ".join(names),
))
logger.warning("Reorganisation based on {} commit{}:".format(
len(commits),
"" if len(commits) == 1 else "s",
))
# Get PhabricatorStack
# Errors will be raised later in the `walk_llist` method
with wait_message("Detecting the remote stack..."):
try:
phabstack = conduit.get_stack(localstack_ids)
except Error:
logger.error("Remote stack is not linear.")
raise
# Preload the phabricator stack
with wait_message("Preloading Phabricator stack revisions..."):
conduit.get_revisions(phids=list(phabstack.keys()))
if phabstack:
try:
phabstack_phids = walk_llist(phabstack)
except Error:
logger.error("Remote stack is not linear.\n"
"Detected stack:\n{}".format(" <- ".join(
conduit.phids_to_ids(list(phabstack.keys())))))
raise
else:
phabstack_phids = []
localstack_phids = conduit.ids_to_phids(localstack_ids)
try:
transactions = stack_transactions(phabstack_phids, localstack_phids)
except Error:
logger.error("Unable to prepare stack transactions.")
raise
if not transactions:
raise Error("Reorganisation is not needed.")
logger.warning("Stack will be reorganised:")
for phid, rev_transactions in transactions.items():
node_id = conduit.phid_to_id(phid)
if "abandon" in [t["type"] for t in rev_transactions]:
logger.info(" * {} will be abandoned".format(node_id))
else:
for t in rev_transactions:
if t["type"] == "children.set":
logger.info(" * {child} will depend on {parent}".format(
child=conduit.phid_to_id(t["value"][0]),
parent=node_id,
))
if t["type"] == "children.remove":
logger.info(
" * {child} will no longer depend on {parent}".format(
child=conduit.phid_to_id(t["value"][0]),
parent=node_id,
))
telemetry.metrics.mozphab.submission.preparation_time.stop()
if args.yes:
pass
else:
res = prompt("Perform reorganisation", ["Yes", "No"])
if res == "No":
sys.exit(1)
telemetry.metrics.mozphab.submission.process_time.start()
with wait_message("Applying transactions..."):
for phid, rev_transactions in transactions.items():
conduit.edit_revision(rev_id=phid, transactions=rev_transactions)
telemetry.metrics.mozphab.submission.process_time.stop()
logger.info("Stack has been reorganised.")
def patch(repo, args):
"""Patch repository from Phabricator's revisions.
By default:
* perform sanity checks
* find the base commit
* create a new branch/bookmark
* apply the patches and commit the changes
args.no_commit is True - no commit will be created after applying diffs
args.apply_to - <head|tip|branch> (default: branch)
branch - find base commit and apply on top of it
head/tip - apply changes to current commit
args.raw is True - only print out the diffs (--force doesn't change anything)
Raises:
* Error if uncommitted changes are present in the working tree
* Error if Phabricator revision is not found
* Error if `--apply-to base` and no base commit found in the first diff
* Error if base commit not found in repository
"""
# Check if raw Conduit API can be used
with wait_message("Checking connection to Phabricator."):
# Check if raw Conduit API can be used
if not conduit.check():
raise Error("Failed to use Conduit API")
if not args.raw:
# Check if local and remote VCS matches
with wait_message("Checking VCS"):
repo.check_vcs()
# Look for any uncommitted changes
with wait_message("Checking repository.."):
clean = repo.is_worktree_clean()
if not clean:
raise Error(
"Uncommitted changes present. Please %s them or commit before patching."
% ("shelve" if isinstance(repo, Mercurial) else "stash"))
# Get the target revision
with wait_message("Fetching D%s.." % args.revision_id):
revs = conduit.get_revisions(ids=[args.revision_id])
if not revs:
raise Error("Revision not found")
revision = revs[0]
if not args.skip_dependencies:
with wait_message("Fetching D%s children.." % args.revision_id):
try:
children = conduit.get_successor_phids(
revision["phid"], include_abandoned=args.include_abandoned)
non_linear = False
except NonLinearException:
children = []
non_linear = True
patch_children = True
if children:
if args.yes or config.always_full_stack:
patch_children = True
else:
children_msg = ("a child commit"
if len(children) == 1 else "child commits")
res = prompt(
"Revision D%s has %s. Would you like to patch the "
"full stack?." % (args.revision_id, children_msg),
["Yes", "No", "Always"],
)
if res == "Always":
config.always_full_stack = True
config.write()
patch_children = res == "Yes" or res == "Always"
if patch_children:
if non_linear and not args.yes:
logger.warning(
"Revision D%s has a non-linear successor graph.\n"
"Unable to apply the full stack.",
args.revision_id,
)
res = prompt("Continue with only part of the stack?",
["Yes", "No"])
if res == "No":
return
# Get list of PHIDs in the stack
try:
with wait_message("Fetching D%s parents.." % args.revision_id):
phids = conduit.get_ancestor_phids(revision["phid"])
except NonLinearException:
raise Error(
"Non linear dependency detected. Unable to patch the stack.")
# Pull revisions data
if phids:
with wait_message("Fetching related revisions.."):
revs.extend(conduit.get_revisions(phids=phids))
revs.reverse()
if children and patch_children:
with wait_message("Fetching related revisions.."):
revs.extend(conduit.get_revisions(phids=children))
# Set the target id
rev_id = revs[-1]["id"]
logger.info(
"Patching revision%s: %s",
"s" if len(revs) > 1 else "",
" ".join(["D%s" % r["id"] for r in revs]),
)
# Pull diffs
with wait_message("Downloading patch information.."):
diffs = conduit.get_diffs([r["fields"]["diffPHID"] for r in revs])
if not args.no_commit and not args.raw:
for rev in revs:
diff = diffs[rev["fields"]["diffPHID"]]
if not diff["attachments"]["commits"]["commits"]:
raise Error(
"A diff without commit information detected in revision D%s.\n"
"Use `--no-commit` to patch the working tree." % rev["id"])
base_node = None
if not args.raw:
args.apply_to = args.apply_to or config.apply_patch_to
if args.apply_to == "base":
base_node = get_base_ref(diffs[revs[0]["fields"]["diffPHID"]])
if not base_node:
raise Error("Base commit not found in diff. "
"Use `--apply-to here` to patch current commit.")
elif args.apply_to != "here":
base_node = args.apply_to
if args.apply_to != "here":
try:
with wait_message("Checking %s.." % short_node(base_node)):
base_node = repo.check_node(base_node)
except NotFoundError as e:
msg = "Unknown revision: %s" % short_node(base_node)
if str(e):
msg += "\n%s" % str(e)
if args.apply_to == "base":
msg += "\nUse --apply-to to set the base commit."
raise Error(msg)
branch_name = None if args.no_commit else "phab-D%s" % rev_id
repo.before_patch(base_node, branch_name)
parent = None
for rev in revs:
# Prepare the body using just the data from Phabricator
body = prepare_body(
rev["fields"]["title"],
rev["fields"]["summary"],
rev["id"],
repo.phab_url,
depends_on=parent,
)
parent = rev["id"]
diff = diffs[rev["fields"]["diffPHID"]]
with wait_message("Downloading D%s.." % rev["id"]):
raw = conduit.call("differential.getrawdiff",
{"diffID": diff["id"]})
if args.no_commit:
with wait_message("Applying D%s.." % rev["id"]):
apply_patch(raw, repo.path)
else:
try:
diff_commits = diff["attachments"]["commits"]["commits"]
author = "%s <%s>" % (
diff_commits[0]["author"]["name"],
diff_commits[0]["author"]["email"],
)
except (IndexError, KeyError):
author = None
try:
date_created = diff["fields"]["dateCreated"]
except KeyError:
date_created = None
if args.raw:
# print rather than use logger.info; there's no need for this
# to be in our logs.
print(repo.format_patch(raw, body, author, date_created))
else:
try:
with wait_message("Applying D%s.." % rev["id"]):
repo.apply_patch(raw, body, author, date_created)
except subprocess.CalledProcessError:
raise Error("Patch failed to apply")
if rev["id"] != revs[-1]["id"]:
logger.info("D%s applied", rev["id"])
logger.warning("D%s applied", rev_id)