Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
base_args = ("-p", new_base)
# Blast our current tree as the newest commit, merging
# against the previous pull entry, and the newest base.
tree = commit.patch.apply(self.sh, self.base_tree)
# Nothing to do, just ignore the diff
if tree == self.base_tree:
self.ignored_diffs.append((commit, number))
logging.warn("Skipping PR #{} {}, as the commit now has no changes"
.format(number, elab_commit.title))
return
new_pull = GitCommitHash(self.sh.git(
"commit-tree", tree,
"-p", "origin/" + branch_head(self.username, ghnum),
*base_args,
input='{} on "{}"\n\n{}\n\n[ghstack-poisoned]'.format(self.msg, elab_commit.title, non_orig_commit_msg)))
# Perform what is effectively an interactive rebase
# on the orig branch.
#
# Hypothetically, there could be a case when this isn't
# necessary, but it's INCREDIBLY unlikely (because we'd
# have to look EXACTLY like the original orig, and since
# we're in the branch that says "hey we changed
# something" that's probably not what happened.
logging.info("Restacking commit on {}".format(self.base_orig))
new_orig = GitCommitHash(self.sh.git(
"origin/" + branch_base(self.username, ghnum),
self.base_commit, exitcode=True)
if is_ancestor:
new_base = self.base_commit
else:
# If we've gotten here, it means that the new
# base and the old base are completely
# unrelated. We'll make a fake commit that
# "resets" the tree back to something that makes
# sense and merge with that. This doesn't fix
# the fact that we still incorrectly report
# the old base as an ancestor of our commit, but
# it's better than nothing.
new_base = GitCommitHash(self.sh.git(
"commit-tree", self.base_tree,
"-p", "origin/" + branch_base(self.username, ghnum),
"-p", self.base_commit,
input='Update base for {} on "{}"\n\n{}\n\n[ghstack-poisoned]'
.format(self.msg, elab_commit.title,
non_orig_commit_msg)))
base_args = ("-p", new_base)
# Blast our current tree as the newest commit, merging
# against the previous pull entry, and the newest base.
tree = commit.patch.apply(self.sh, self.base_tree)
# Nothing to do, just ignore the diff
if tree == self.base_tree:
# We land the entire stack pointed to by a URL.
# Local state is ignored; PR is source of truth
# Furthermore, the parent commits of PR are ignored: we always
# take the canonical version of the patch from any given pr
params = ghstack.github_utils.parse_pull_request(pull_request)
orig_ref = lookup_pr_to_orig_ref(github, **params)
if sh is None:
# Use CWD
sh = ghstack.shell.Shell()
# Get up-to-date
sh.git("fetch", "origin")
remote_orig_ref = "origin/" + orig_ref
base = GitCommitHash(sh.git("merge-base", "origin/master", remote_orig_ref))
# compute the stack of commits in chronological order (does not
# include base)
stack = ghstack.git.parse_header(
sh.git("rev-list", "--reverse", "--header", "^" + base, remote_orig_ref))
# Switch working copy
try:
prev_ref = sh.git("symbolic-ref", "--short", "HEAD")
except RuntimeError:
prev_ref = sh.git("rev-parse", "HEAD")
# If this fails, we don't have to reset
sh.git("checkout", "origin/master")
try:
"commit-tree", tree,
"-p", "origin/" + branch_head(self.username, ghnum),
*base_args,
input='{} on "{}"\n\n{}\n\n[ghstack-poisoned]'.format(self.msg, elab_commit.title, non_orig_commit_msg)))
# Perform what is effectively an interactive rebase
# on the orig branch.
#
# Hypothetically, there could be a case when this isn't
# necessary, but it's INCREDIBLY unlikely (because we'd
# have to look EXACTLY like the original orig, and since
# we're in the branch that says "hey we changed
# something" that's probably not what happened.
logging.info("Restacking commit on {}".format(self.base_orig))
new_orig = GitCommitHash(self.sh.git(
"commit-tree", tree,
"-p", self.base_orig, input=summary))
push_branches = (
(new_base, "base"),
(new_pull, "head"),
(new_orig, "orig"),
)
if elab_commit.closed:
what = 'Skipped closed'
else:
what = 'Updated'
self.stack_meta.append(DiffMeta(
title=elab_commit.title,
self.stack_meta.append(DiffMeta(
title=commit.title,
number=commit.number,
body=commit.body,
ghnum=ghnum,
push_branches=(),
head_branch=None,
what='Skipped',
closed=commit.closed,
pr_url=commit.pull_request_resolved.url(),
))
self.base_commit = GitCommitHash(self.sh.git(
"rev-parse", "origin/" + branch_head(self.username, ghnum)))
self.base_orig = GitCommitHash(self.sh.git(
"rev-parse", "origin/" + branch_orig(self.username, ghnum)
))
self.base_tree = GitTreeHash(self.sh.git(
"rev-parse", self.base_orig + "^{tree}"
))
def branch(username: str, ghnum: GhNumber, kind: BranchKind
) -> GitCommitHash:
return GitCommitHash("gh/{}/{}/{}".format(username, ghnum, kind))
# branches this diff corresponds to
BranchKind = str
# Metadata describing a diff we submitted to GitHub
# TODO: Make this directly contain a DiffWithGitHubMetadata?
DiffMeta = NamedTuple('DiffMeta', [
('title', str),
('number', GitHubNumber),
('body', str),
('ghnum', GhNumber),
# What Git commit hash we should push to what branch
('push_branches', Tuple[Tuple[GitCommitHash, BranchKind], ...]),
# What Git commit hash corresponds to head for this
# (previously, we got this out of push_branches, but this is not
# guaranteed to be set.) None if we didn't change it.
('head_branch', Optional[GitCommitHash]),
# A human-readable string like 'Created' which describes what
# happened to this pull request
('what', str),
('closed', bool),
('pr_url', str),
])
# Ya, sometimes we get carriage returns. Crazy right?
RE_STACK = re.compile(r'Stack.*:\r?\n(\* [^\r\n]+\r?\n)+')
# NB: This regex is fuzzy because the D1234567 identifier is typically
# linkified.
RE_DIFF_REV = re.compile(r'^Differential Revision:.+?(D[0-9]+)', re.MULTILINE)
def parents(self) -> List[GitCommitHash]:
return [GitCommitHash(m.group("commit"))
for m in RE_RAW_PARENT.finditer(self.raw_header)]