mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'cc/git-replay' into next

Browse Source 
Introduce "git replay", a tool meant on the server side without
working tree to recreate a history.

* cc/git-replay:
  replay: stop assuming replayed branches do not diverge
  replay: add --contained to rebase contained branches
  replay: add --advance or 'cherry-pick' mode
  replay: use standard revision ranges
  replay: make it a minimal server side command
  replay: remove HEAD related sanity check
  replay: remove progress and info output
  replay: add an important FIXME comment about gpg signing
  replay: change rev walking options
  replay: introduce pick_regular_commit()
  replay: die() instead of failing assert()
  replay: start using parse_options API
  replay: introduce new builtin
  t6429: remove switching aspects of fast-rebase
This commit is contained in:
Junio C Hamano
2023-12-09 16:42:19 -08:00
parent 80b7ebc080 e928c11e29
commit 25141c06ed
12 changed files with 801 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -135,6 +135,7 @@
/git-remote-ext /git-remote-ext
/git-repack /git-repack
/git-replace /git-replace
/git-replay
/git-request-pull /git-request-pull
/git-rerere /git-rerere
/git-reset /git-reset

127
Documentation/git-replay.txt Normal file
View File

@ -0,0 +1,127 @@
git-replay(1)
=============
NAME
----
git-replay - EXPERIMENTAL: Replay commits on a new base, works with bare repos too
SYNOPSIS
--------
[verse]
(EXPERIMENTAL!) 'git replay' ([--contained] --onto <newbase> | --advance <branch>) <revision-range>...
DESCRIPTION
-----------
Takes ranges of commits and replays them onto a new location. Leaves
the working tree and the index untouched, and updates no references.
The output of this command is meant to be used as input to
`git update-ref --stdin`, which would update the relevant branches
(see the OUTPUT section below).
THIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.
OPTIONS
-------
--onto <newbase>::
Starting point at which to create the new commits. May be any
valid commit, and not just an existing branch name.
+
When `--onto` is specified, the update-ref command(s) in the output will
update the branch(es) in the revision range to point at the new
commits, similar to the way how `git rebase --update-refs` updates
multiple branches in the affected range.
--advance <branch>::
Starting point at which to create the new commits; must be a
branch name.
+
When `--advance` is specified, the update-ref command(s) in the output
will update the branch passed as an argument to `--advance` to point at
the new commits (in other words, this mimics a cherry-pick operation).
<revision-range>::
Range of commits to replay. More than one <revision-range> can
be passed, but in `--advance <branch>` mode, they should have
a single tip, so that it's clear where <branch> should point
to. See "Specifying Ranges" in linkgit:git-rev-parse and the
"Commit Limiting" options below.
include::rev-list-options.txt[]
OUTPUT
------
When there are no conflicts, the output of this command is usable as
input to `git update-ref --stdin`. It is of the form:
update refs/heads/branch1 ${NEW_branch1_HASH} ${OLD_branch1_HASH}
update refs/heads/branch2 ${NEW_branch2_HASH} ${OLD_branch2_HASH}
update refs/heads/branch3 ${NEW_branch3_HASH} ${OLD_branch3_HASH}
where the number of refs updated depends on the arguments passed and
the shape of the history being replayed. When using `--advance`, the
number of refs updated is always one, but for `--onto`, it can be one
or more (rebasing multiple branches simultaneously is supported).
EXIT STATUS
-----------
For a successful, non-conflicted replay, the exit status is 0. When
the replay has conflicts, the exit status is 1. If the replay is not
able to complete (or start) due to some kind of error, the exit status
is something other than 0 or 1.
EXAMPLES
--------
To simply rebase `mybranch` onto `target`:
------------
$ git replay --onto target origin/main..mybranch
update refs/heads/mybranch ${NEW_mybranch_HASH} ${OLD_mybranch_HASH}
------------
To cherry-pick the commits from mybranch onto target:
------------
$ git replay --advance target origin/main..mybranch
update refs/heads/target ${NEW_target_HASH} ${OLD_target_HASH}
------------
Note that the first two examples replay the exact same commits and on
top of the exact same new base, they only differ in that the first
provides instructions to make mybranch point at the new commits and
the second provides instructions to make target point at them.
What if you have a stack of branches, one depending upon another, and
you'd really like to rebase the whole set?
------------
$ git replay --contained --onto origin/main origin/main..tipbranch
update refs/heads/branch1 ${NEW_branch1_HASH} ${OLD_branch1_HASH}
update refs/heads/branch2 ${NEW_branch2_HASH} ${OLD_branch2_HASH}
update refs/heads/tipbranch ${NEW_tipbranch_HASH} ${OLD_tipbranch_HASH}
------------
When calling `git replay`, one does not need to specify a range of
commits to replay using the syntax `A..B`; any range expression will
do:
------------
$ git replay --onto origin/main ^base branch1 branch2 branch3
update refs/heads/branch1 ${NEW_branch1_HASH} ${OLD_branch1_HASH}
update refs/heads/branch2 ${NEW_branch2_HASH} ${OLD_branch2_HASH}
update refs/heads/branch3 ${NEW_branch3_HASH} ${OLD_branch3_HASH}
------------
This will simultaneously rebase `branch1`, `branch2`, and `branch3`,
all commits they have since `base`, playing them on top of
`origin/main`. These three branches may have commits on top of `base`
that they have in common, but that does not need to be the case.
GIT
---
Part of the linkgit:git[1] suite

2
Makefile
View File

@ -803,7 +803,6 @@ TEST_BUILTINS_OBJS += test-dump-split-index.o
TEST_BUILTINS_OBJS += test-dump-untracked-cache.o TEST_BUILTINS_OBJS += test-dump-untracked-cache.o
TEST_BUILTINS_OBJS += test-env-helper.o TEST_BUILTINS_OBJS += test-env-helper.o
TEST_BUILTINS_OBJS += test-example-decorate.o TEST_BUILTINS_OBJS += test-example-decorate.o
TEST_BUILTINS_OBJS += test-fast-rebase.o
TEST_BUILTINS_OBJS += test-find-pack.o TEST_BUILTINS_OBJS += test-find-pack.o
TEST_BUILTINS_OBJS += test-fsmonitor-client.o TEST_BUILTINS_OBJS += test-fsmonitor-client.o
TEST_BUILTINS_OBJS += test-genrandom.o TEST_BUILTINS_OBJS += test-genrandom.o
@ -1294,6 +1293,7 @@ BUILTIN_OBJS += builtin/remote-fd.o
BUILTIN_OBJS += builtin/remote.o BUILTIN_OBJS += builtin/remote.o
BUILTIN_OBJS += builtin/repack.o BUILTIN_OBJS += builtin/repack.o
BUILTIN_OBJS += builtin/replace.o BUILTIN_OBJS += builtin/replace.o
BUILTIN_OBJS += builtin/replay.o
BUILTIN_OBJS += builtin/rerere.o BUILTIN_OBJS += builtin/rerere.o
BUILTIN_OBJS += builtin/reset.o BUILTIN_OBJS += builtin/reset.o
BUILTIN_OBJS += builtin/rev-list.o BUILTIN_OBJS += builtin/rev-list.o

1
builtin.h
View File

@ -211,6 +211,7 @@ int cmd_remote(int argc, const char **argv, const char *prefix);
int cmd_remote_ext(int argc, const char **argv, const char *prefix); int cmd_remote_ext(int argc, const char **argv, const char *prefix);
int cmd_remote_fd(int argc, const char **argv, const char *prefix); int cmd_remote_fd(int argc, const char **argv, const char *prefix);
int cmd_repack(int argc, const char **argv, const char *prefix); int cmd_repack(int argc, const char **argv, const char *prefix);
int cmd_replay(int argc, const char **argv, const char *prefix);
int cmd_rerere(int argc, const char **argv, const char *prefix); int cmd_rerere(int argc, const char **argv, const char *prefix);
int cmd_reset(int argc, const char **argv, const char *prefix); int cmd_reset(int argc, const char **argv, const char *prefix);
int cmd_restore(int argc, const char **argv, const char *prefix); int cmd_restore(int argc, const char **argv, const char *prefix);

446
builtin/replay.c Normal file
View File

@ -0,0 +1,446 @@
/*
* "git replay" builtin command
*/
#define USE_THE_INDEX_VARIABLE
#include "git-compat-util.h"
#include "builtin.h"
#include "environment.h"
#include "hex.h"
#include "lockfile.h"
#include "merge-ort.h"
#include "object-name.h"
#include "parse-options.h"
#include "refs.h"
#include "revision.h"
#include "strmap.h"
#include <oidset.h>
#include <tree.h>
static const char *short_commit_name(struct commit *commit)
{
return repo_find_unique_abbrev(the_repository, &commit->object.oid,
DEFAULT_ABBREV);
}
static struct commit *peel_committish(const char *name)
{
struct object *obj;
struct object_id oid;
if (repo_get_oid(the_repository, name, &oid))
return NULL;
obj = parse_object(the_repository, &oid);
return (struct commit *)repo_peel_to_type(the_repository, name, 0, obj,
OBJ_COMMIT);
}
static char *get_author(const char *message)
{
size_t len;
const char *a;
a = find_commit_header(message, "author", &len);
if (a)
return xmemdupz(a, len);
return NULL;
}
static struct commit *create_commit(struct tree *tree,
struct commit *based_on,
struct commit *parent)
{
struct object_id ret;
struct object *obj;
struct commit_list *parents = NULL;
char *author;
char *sign_commit = NULL; /* FIXME: cli users might want to sign again */
struct commit_extra_header *extra;
struct strbuf msg = STRBUF_INIT;
const char *out_enc = get_commit_output_encoding();
const char *message = repo_logmsg_reencode(the_repository, based_on,
NULL, out_enc);
const char *orig_message = NULL;
const char *exclude_gpgsig[] = { "gpgsig", NULL };
commit_list_insert(parent, &parents);
extra = read_commit_extra_headers(based_on, exclude_gpgsig);
find_commit_subject(message, &orig_message);
strbuf_addstr(&msg, orig_message);
author = get_author(message);
reset_ident_date();
if (commit_tree_extended(msg.buf, msg.len, &tree->object.oid, parents,
&ret, author, NULL, sign_commit, extra)) {
error(_("failed to write commit object"));
return NULL;
}
free(author);
strbuf_release(&msg);
obj = parse_object(the_repository, &ret);
return (struct commit *)obj;
}
struct ref_info {
struct commit *onto;
struct strset positive_refs;
struct strset negative_refs;
int positive_refexprs;
int negative_refexprs;
};
static void get_ref_information(struct rev_cmdline_info *cmd_info,
struct ref_info *ref_info)
{
int i;
ref_info->onto = NULL;
strset_init(&ref_info->positive_refs);
strset_init(&ref_info->negative_refs);
ref_info->positive_refexprs = 0;
ref_info->negative_refexprs = 0;
/*
* When the user specifies e.g.
* git replay origin/main..mybranch
* git replay ^origin/next mybranch1 mybranch2
* we want to be able to determine where to replay the commits. In
* these examples, the branches are probably based on an old version
* of either origin/main or origin/next, so we want to replay on the
* newest version of that branch. In contrast we would want to error
* out if they ran
* git replay ^origin/master ^origin/next mybranch
* git replay mybranch~2..mybranch
* the first of those because there's no unique base to choose, and
* the second because they'd likely just be replaying commits on top
* of the same commit and not making any difference.
*/
for (i = 0; i < cmd_info->nr; i++) {
struct rev_cmdline_entry *e = cmd_info->rev + i;
struct object_id oid;
const char *refexpr = e->name;
char *fullname = NULL;
int can_uniquely_dwim = 1;
if (*refexpr == '^')
refexpr++;
if (repo_dwim_ref(the_repository, refexpr, strlen(refexpr), &oid, &fullname, 0) != 1)
can_uniquely_dwim = 0;
if (e->flags & BOTTOM) {
if (can_uniquely_dwim)
strset_add(&ref_info->negative_refs, fullname);
if (!ref_info->negative_refexprs)
ref_info->onto = lookup_commit_reference_gently(the_repository,
&e->item->oid, 1);
ref_info->negative_refexprs++;
} else {
if (can_uniquely_dwim)
strset_add(&ref_info->positive_refs, fullname);
ref_info->positive_refexprs++;
}
free(fullname);
}
}
static void determine_replay_mode(struct rev_cmdline_info *cmd_info,
const char *onto_name,
const char **advance_name,
struct commit **onto,
struct strset **update_refs)
{
struct ref_info rinfo;
get_ref_information(cmd_info, &rinfo);
if (!rinfo.positive_refexprs)
die(_("need some commits to replay"));
if (onto_name && *advance_name)
die(_("--onto and --advance are incompatible"));
else if (onto_name) {
*onto = peel_committish(onto_name);
if (rinfo.positive_refexprs <
strset_get_size(&rinfo.positive_refs))
die(_("all positive revisions given must be references"));
} else if (*advance_name) {
struct object_id oid;
char *fullname = NULL;
*onto = peel_committish(*advance_name);
if (repo_dwim_ref(the_repository, *advance_name, strlen(*advance_name),
&oid, &fullname, 0) == 1) {
*advance_name = fullname;
} else {
die(_("argument to --advance must be a reference"));
}
if (rinfo.positive_refexprs > 1)
die(_("cannot advance target with multiple sources because ordering would be ill-defined"));
} else {
int positive_refs_complete = (
rinfo.positive_refexprs ==
strset_get_size(&rinfo.positive_refs));
int negative_refs_complete = (
rinfo.negative_refexprs ==
strset_get_size(&rinfo.negative_refs));
/*
* We need either positive_refs_complete or
* negative_refs_complete, but not both.
*/
if (rinfo.negative_refexprs > 0 &&
positive_refs_complete == negative_refs_complete)
die(_("cannot implicitly determine whether this is an --advance or --onto operation"));
if (negative_refs_complete) {
struct hashmap_iter iter;
struct strmap_entry *entry;
if (rinfo.negative_refexprs == 0)
die(_("all positive revisions given must be references"));
else if (rinfo.negative_refexprs > 1)
die(_("cannot implicitly determine whether this is an --advance or --onto operation"));
else if (rinfo.positive_refexprs > 1)
die(_("cannot advance target with multiple source branches because ordering would be ill-defined"));
/* Only one entry, but we have to loop to get it */
strset_for_each_entry(&rinfo.negative_refs,
&iter, entry) {
*advance_name = entry->key;
}
} else { /* positive_refs_complete */
if (rinfo.negative_refexprs > 1)
die(_("cannot implicitly determine correct base for --onto"));
if (rinfo.negative_refexprs == 1)
*onto = rinfo.onto;
}
}
if (!*advance_name) {
*update_refs = xcalloc(1, sizeof(**update_refs));
**update_refs = rinfo.positive_refs;
memset(&rinfo.positive_refs, 0, sizeof(**update_refs));
}
strset_clear(&rinfo.negative_refs);
strset_clear(&rinfo.positive_refs);
}
static struct commit *mapped_commit(kh_oid_map_t *replayed_commits,
struct commit *commit,
struct commit *fallback)
{
khint_t pos = kh_get_oid_map(replayed_commits, commit->object.oid);
if (pos == kh_end(replayed_commits))
return fallback;
return kh_value(replayed_commits, pos);
}
static struct commit *pick_regular_commit(struct commit *pickme,
kh_oid_map_t *replayed_commits,
struct commit *onto,
struct merge_options *merge_opt,
struct merge_result *result)
{
struct commit *base, *replayed_base;
struct tree *pickme_tree, *base_tree;
base = pickme->parents->item;
replayed_base = mapped_commit(replayed_commits, base, onto);
result->tree = repo_get_commit_tree(the_repository, replayed_base);
pickme_tree = repo_get_commit_tree(the_repository, pickme);
base_tree = repo_get_commit_tree(the_repository, base);
merge_opt->branch1 = short_commit_name(replayed_base);
merge_opt->branch2 = short_commit_name(pickme);
merge_opt->ancestor = xstrfmt("parent of %s", merge_opt->branch2);
merge_incore_nonrecursive(merge_opt,
base_tree,
result->tree,
pickme_tree,
result);
free((char*)merge_opt->ancestor);
merge_opt->ancestor = NULL;
if (!result->clean)
return NULL;
return create_commit(result->tree, pickme, replayed_base);
}
int cmd_replay(int argc, const char **argv, const char *prefix)
{
const char *advance_name = NULL;
struct commit *onto = NULL;
const char *onto_name = NULL;
int contained = 0;
struct rev_info revs;
struct commit *last_commit = NULL;
struct commit *commit;
struct merge_options merge_opt;
struct merge_result result;
struct strset *update_refs = NULL;
kh_oid_map_t *replayed_commits;
int ret = 0;
const char * const replay_usage[] = {
N_("(EXPERIMENTAL!) git replay "
"([--contained] --onto <newbase> | --advance <branch>) "
"<revision-range>..."),
NULL
};
struct option replay_options[] = {
OPT_STRING(0, "advance", &advance_name,
N_("branch"),
N_("make replay advance given branch")),
OPT_STRING(0, "onto", &onto_name,
N_("revision"),
N_("replay onto given commit")),
OPT_BOOL(0, "contained", &contained,
N_("advance all branches contained in revision-range")),
OPT_END()
};
argc = parse_options(argc, argv, prefix, replay_options, replay_usage,
PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN_OPT);
if (!onto_name && !advance_name) {
error(_("option --onto or --advance is mandatory"));
usage_with_options(replay_usage, replay_options);
}
if (advance_name && contained)
die(_("options '%s' and '%s' cannot be used together"),
"--advance", "--contained");
repo_init_revisions(the_repository, &revs, prefix);
/*
* Set desired values for rev walking options here. If they
* are changed by some user specified option in setup_revisions()
* below, we will detect that below and then warn.
*
* TODO: In the future we might want to either die(), or allow
* some options changing these values if we think they could
* be useful.
*/
revs.reverse = 1;
revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
revs.topo_order = 1;
revs.simplify_history = 0;
argc = setup_revisions(argc, argv, &revs, NULL);
if (argc > 1) {
ret = error(_("unrecognized argument: %s"), argv[1]);
goto cleanup;
}
/*
* Detect and warn if we override some user specified rev
* walking options.
*/
if (revs.reverse != 1) {
warning(_("some rev walking options will be overridden as "
"'%s' bit in 'struct rev_info' will be forced"),
"reverse");
revs.reverse = 1;
}
if (revs.sort_order != REV_SORT_IN_GRAPH_ORDER) {
warning(_("some rev walking options will be overridden as "
"'%s' bit in 'struct rev_info' will be forced"),
"sort_order");
revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
}
if (revs.topo_order != 1) {
warning(_("some rev walking options will be overridden as "
"'%s' bit in 'struct rev_info' will be forced"),
"topo_order");
revs.topo_order = 1;
}
if (revs.simplify_history != 0) {
warning(_("some rev walking options will be overridden as "
"'%s' bit in 'struct rev_info' will be forced"),
"simplify_history");
revs.simplify_history = 0;
}
determine_replay_mode(&revs.cmdline, onto_name, &advance_name,
&onto, &update_refs);
if (!onto) /* FIXME: Should handle replaying down to root commit */
die("Replaying down to root commit is not supported yet!");
if (prepare_revision_walk(&revs) < 0) {
ret = error(_("error preparing revisions"));
goto cleanup;
}
init_merge_options(&merge_opt, the_repository);
memset(&result, 0, sizeof(result));
merge_opt.show_rename_progress = 0;
last_commit = onto;
replayed_commits = kh_init_oid_map();
while ((commit = get_revision(&revs))) {
const struct name_decoration *decoration;
khint_t pos;
int hr;
if (!commit->parents)
die(_("replaying down to root commit is not supported yet!"));
if (commit->parents->next)
die(_("replaying merge commits is not supported yet!"));
last_commit = pick_regular_commit(commit, replayed_commits, onto,
&merge_opt, &result);
if (!last_commit)
break;
/* Record commit -> last_commit mapping */
pos = kh_put_oid_map(replayed_commits, commit->object.oid, &hr);
if (hr == 0)
BUG("Duplicate rewritten commit: %s\n",
oid_to_hex(&commit->object.oid));
kh_value(replayed_commits, pos) = last_commit;
/* Update any necessary branches */
if (advance_name)
continue;
decoration = get_name_decoration(&commit->object);
if (!decoration)
continue;
while (decoration) {
if (decoration->type == DECORATION_REF_LOCAL &&
(contained || strset_contains(update_refs,
decoration->name))) {
printf("update %s %s %s\n",
decoration->name,
oid_to_hex(&last_commit->object.oid),
oid_to_hex(&commit->object.oid));
}
decoration = decoration->next;
}
}
/* In --advance mode, advance the target ref */
if (result.clean == 1 && advance_name) {
printf("update %s %s %s\n",
advance_name,
oid_to_hex(&last_commit->object.oid),
oid_to_hex(&onto->object.oid));
}
merge_finalize(&merge_opt, &result);
kh_destroy_oid_map(replayed_commits);
if (update_refs) {
strset_clear(update_refs);
free(update_refs);
}
ret = result.clean;
cleanup:
release_revisions(&revs);
/* Return */
if (ret < 0)
exit(128);
return ret ? 0 : 1;
}

1
command-list.txt
View File

@ -160,6 +160,7 @@ git-reflog ancillarymanipulators complete
git-remote ancillarymanipulators complete git-remote ancillarymanipulators complete
git-repack ancillarymanipulators complete git-repack ancillarymanipulators complete
git-replace ancillarymanipulators complete git-replace ancillarymanipulators complete
git-replay plumbingmanipulators
git-request-pull foreignscminterface complete git-request-pull foreignscminterface complete
git-rerere ancillaryinterrogators git-rerere ancillaryinterrogators
git-reset mainporcelain history git-reset mainporcelain history

1
git.c
View File

@ -594,6 +594,7 @@ static struct cmd_struct commands[] = {
{ "remote-fd", cmd_remote_fd, NO_PARSEOPT }, { "remote-fd", cmd_remote_fd, NO_PARSEOPT },
{ "repack", cmd_repack, RUN_SETUP }, { "repack", cmd_repack, RUN_SETUP },
{ "replace", cmd_replace, RUN_SETUP }, { "replace", cmd_replace, RUN_SETUP },
{ "replay", cmd_replay, RUN_SETUP },
{ "rerere", cmd_rerere, RUN_SETUP }, { "rerere", cmd_rerere, RUN_SETUP },
{ "reset", cmd_reset, RUN_SETUP }, { "reset", cmd_reset, RUN_SETUP },
{ "restore", cmd_restore, RUN_SETUP | NEED_WORK_TREE }, { "restore", cmd_restore, RUN_SETUP | NEED_WORK_TREE },

241
t/helper/test-fast-rebase.c
View File

@ -1,241 +0,0 @@
/*
* "git fast-rebase" builtin command
*
* FAST: Forking Any Subprocesses (is) Taboo
*
* This is meant SOLELY as a demo of what is possible. sequencer.c and
* rebase.c should be refactored to use the ideas here, rather than attempting
* to extend this file to replace those (unless Phillip or Dscho say that
* refactoring is too hard and we need a clean slate, but I'm guessing that
* refactoring is the better route).
*/
#define USE_THE_INDEX_VARIABLE
#include "test-tool.h"
#include "cache-tree.h"
#include "commit.h"
#include "environment.h"
#include "gettext.h"
#include "hash.h"
#include "hex.h"
#include "lockfile.h"
#include "merge-ort.h"
#include "object-name.h"
#include "read-cache-ll.h"
#include "refs.h"
#include "revision.h"
#include "sequencer.h"
#include "setup.h"
#include "strvec.h"
#include "tree.h"
static const char *short_commit_name(struct commit *commit)
{
return repo_find_unique_abbrev(the_repository, &commit->object.oid,
DEFAULT_ABBREV);
}
static struct commit *peel_committish(const char *name)
{
struct object *obj;
struct object_id oid;
if (repo_get_oid(the_repository, name, &oid))
return NULL;
obj = parse_object(the_repository, &oid);
return (struct commit *)repo_peel_to_type(the_repository, name, 0, obj,
OBJ_COMMIT);
}
static char *get_author(const char *message)
{
size_t len;
const char *a;
a = find_commit_header(message, "author", &len);
if (a)
return xmemdupz(a, len);
return NULL;
}
static struct commit *create_commit(struct tree *tree,
struct commit *based_on,
struct commit *parent)
{
struct object_id ret;
struct object *obj;
struct commit_list *parents = NULL;
char *author;
char *sign_commit = NULL;
struct commit_extra_header *extra;
struct strbuf msg = STRBUF_INIT;
const char *out_enc = get_commit_output_encoding();
const char *message = repo_logmsg_reencode(the_repository, based_on,
NULL, out_enc);
const char *orig_message = NULL;
const char *exclude_gpgsig[] = { "gpgsig", NULL };
commit_list_insert(parent, &parents);
extra = read_commit_extra_headers(based_on, exclude_gpgsig);
find_commit_subject(message, &orig_message);
strbuf_addstr(&msg, orig_message);
author = get_author(message);
reset_ident_date();
if (commit_tree_extended(msg.buf, msg.len, &tree->object.oid, parents,
&ret, author, NULL, sign_commit, extra)) {
error(_("failed to write commit object"));
return NULL;
}
free(author);
strbuf_release(&msg);
obj = parse_object(the_repository, &ret);
return (struct commit *)obj;
}
int cmd__fast_rebase(int argc, const char **argv)
{
struct commit *onto;
struct commit *last_commit = NULL, *last_picked_commit = NULL;
struct object_id head;
struct lock_file lock = LOCK_INIT;
struct strvec rev_walk_args = STRVEC_INIT;
struct rev_info revs;
struct commit *commit;
struct merge_options merge_opt;
struct tree *next_tree, *base_tree, *head_tree;
struct merge_result result;
struct strbuf reflog_msg = STRBUF_INIT;
struct strbuf branch_name = STRBUF_INIT;
int ret = 0;
/*
* test-tool stuff doesn't set up the git directory by default; need to
* do that manually.
*/
setup_git_directory();
if (argc == 2 && !strcmp(argv[1], "-h")) {
printf("Sorry, I am not a psychiatrist; I can not give you the help you need. Oh, you meant usage...\n");
exit(129);
}
if (argc != 5 || strcmp(argv[1], "--onto"))
die("usage: read the code, figure out how to use it, then do so");
onto = peel_committish(argv[2]);
strbuf_addf(&branch_name, "refs/heads/%s", argv[4]);
/* Sanity check */
if (repo_get_oid(the_repository, "HEAD", &head))
die(_("Cannot read HEAD"));
assert(oideq(&onto->object.oid, &head));
repo_hold_locked_index(the_repository, &lock, LOCK_DIE_ON_ERROR);
if (repo_read_index(the_repository) < 0)
BUG("Could not read index");
repo_init_revisions(the_repository, &revs, NULL);
revs.verbose_header = 1;
revs.max_parents = 1;
revs.cherry_mark = 1;
revs.limited = 1;
revs.reverse = 1;
revs.right_only = 1;
revs.sort_order = REV_SORT_IN_GRAPH_ORDER;
revs.topo_order = 1;
strvec_pushl(&rev_walk_args, "", argv[4], "--not", argv[3], NULL);
if (setup_revisions(rev_walk_args.nr, rev_walk_args.v, &revs, NULL) > 1) {
ret = error(_("unhandled options"));
goto cleanup;
}
strvec_clear(&rev_walk_args);
if (prepare_revision_walk(&revs) < 0) {
ret = error(_("error preparing revisions"));
goto cleanup;
}
init_merge_options(&merge_opt, the_repository);
memset(&result, 0, sizeof(result));
merge_opt.show_rename_progress = 1;
merge_opt.branch1 = "HEAD";
head_tree = repo_get_commit_tree(the_repository, onto);
result.tree = head_tree;
last_commit = onto;
while ((commit = get_revision(&revs))) {
struct commit *base;
fprintf(stderr, "Rebasing %s...\r",
oid_to_hex(&commit->object.oid));
assert(commit->parents && !commit->parents->next);
base = commit->parents->item;
next_tree = repo_get_commit_tree(the_repository, commit);
base_tree = repo_get_commit_tree(the_repository, base);
merge_opt.branch2 = short_commit_name(commit);
merge_opt.ancestor = xstrfmt("parent of %s", merge_opt.branch2);
merge_incore_nonrecursive(&merge_opt,
base_tree,
result.tree,
next_tree,
&result);
free((char*)merge_opt.ancestor);
merge_opt.ancestor = NULL;
if (!result.clean)
break;
last_picked_commit = commit;
last_commit = create_commit(result.tree, commit, last_commit);
}
merge_switch_to_result(&merge_opt, head_tree, &result, 1, !result.clean);
if (result.clean < 0)
exit(128);
if (result.clean) {
fprintf(stderr, "\nDone.\n");
strbuf_addf(&reflog_msg, "finish rebase %s onto %s",
oid_to_hex(&last_picked_commit->object.oid),
oid_to_hex(&last_commit->object.oid));
if (update_ref(reflog_msg.buf, branch_name.buf,
&last_commit->object.oid,
&last_picked_commit->object.oid,
REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
error(_("could not update %s"), argv[4]);
die("Failed to update %s", argv[4]);
}
if (create_symref("HEAD", branch_name.buf, reflog_msg.buf) < 0)
die(_("unable to update HEAD"));
prime_cache_tree(the_repository, the_repository->index,
result.tree);
} else {
fprintf(stderr, "\nAborting: Hit a conflict.\n");
strbuf_addf(&reflog_msg, "rebase progress up to %s",
oid_to_hex(&last_picked_commit->object.oid));
if (update_ref(reflog_msg.buf, "HEAD",
&last_commit->object.oid,
&head,
REF_NO_DEREF, UPDATE_REFS_MSG_ON_ERR)) {
error(_("could not update %s"), argv[4]);
die("Failed to update %s", argv[4]);
}
}
if (write_locked_index(&the_index, &lock,
COMMIT_LOCK | SKIP_IF_UNCHANGED))
die(_("unable to write %s"), get_index_file());
ret = (result.clean == 0);
cleanup:
strbuf_release(&reflog_msg);
strbuf_release(&branch_name);
release_revisions(&revs);
return ret;
}

1
t/helper/test-tool.c
View File

@ -30,7 +30,6 @@ static struct test_cmd cmds[] = {
{ "dump-untracked-cache", cmd__dump_untracked_cache }, { "dump-untracked-cache", cmd__dump_untracked_cache },
{ "env-helper", cmd__env_helper }, { "env-helper", cmd__env_helper },
{ "example-decorate", cmd__example_decorate }, { "example-decorate", cmd__example_decorate },
{ "fast-rebase", cmd__fast_rebase },
{ "find-pack", cmd__find_pack }, { "find-pack", cmd__find_pack },
{ "fsmonitor-client", cmd__fsmonitor_client }, { "fsmonitor-client", cmd__fsmonitor_client },
{ "genrandom", cmd__genrandom }, { "genrandom", cmd__genrandom },

1
t/helper/test-tool.h
View File

@ -24,7 +24,6 @@ int cmd__dump_untracked_cache(int argc, const char **argv);
int cmd__dump_reftable(int argc, const char **argv); int cmd__dump_reftable(int argc, const char **argv);
int cmd__env_helper(int argc, const char **argv); int cmd__env_helper(int argc, const char **argv);
int cmd__example_decorate(int argc, const char **argv); int cmd__example_decorate(int argc, const char **argv);
int cmd__fast_rebase(int argc, const char **argv);
int cmd__find_pack(int argc, const char **argv); int cmd__find_pack(int argc, const char **argv);
int cmd__fsmonitor_client(int argc, const char **argv); int cmd__fsmonitor_client(int argc, const char **argv);
int cmd__genrandom(int argc, const char **argv); int cmd__genrandom(int argc, const char **argv);

198
t/t3650-replay-basics.sh Executable file
View File

@ -0,0 +1,198 @@
#!/bin/sh
test_description='basic git replay tests'
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
. ./test-lib.sh
GIT_AUTHOR_NAME=author@name
GIT_AUTHOR_EMAIL=bogus@email@address
export GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL
test_expect_success 'setup' '
test_commit A &&
test_commit B &&
git switch -c topic1 &&
test_commit C &&
git switch -c topic2 &&
test_commit D &&
test_commit E &&
git switch topic1 &&
test_commit F &&
git switch -c topic3 &&
test_commit G &&
test_commit H &&
git switch -c topic4 main &&
test_commit I &&
test_commit J &&
git switch -c next main &&
test_commit K &&
git merge -m "Merge topic1" topic1 &&
git merge -m "Merge topic2" topic2 &&
git merge -m "Merge topic3" topic3 &&
>evil &&
git add evil &&
git commit --amend &&
git merge -m "Merge topic4" topic4 &&
git switch main &&
test_commit L &&
test_commit M &&
git switch -c conflict B &&
test_commit C.conflict C.t conflict
'
test_expect_success 'setup bare' '
git clone --bare . bare
'
test_expect_success 'using replay to rebase two branches, one on top of other' '
git replay --onto main topic1..topic2 >result &&
test_line_count = 1 result &&
git log --format=%s $(cut -f 3 -d " " result) >actual &&
test_write_lines E D M L B A >expect &&
test_cmp expect actual &&
printf "update refs/heads/topic2 " >expect &&
printf "%s " $(cut -f 3 -d " " result) >>expect &&
git rev-parse topic2 >>expect &&
test_cmp expect result
'
test_expect_success 'using replay on bare repo to rebase two branches, one on top of other' '
git -C bare replay --onto main topic1..topic2 >result-bare &&
test_cmp expect result-bare
'
test_expect_success 'using replay to rebase with a conflict' '
test_expect_code 1 git replay --onto topic1 B..conflict
'
test_expect_success 'using replay on bare repo to rebase with a conflict' '
test_expect_code 1 git -C bare replay --onto topic1 B..conflict
'
test_expect_success 'using replay to perform basic cherry-pick' '
# The differences between this test and previous ones are:
# --advance vs --onto
# 2nd field of result is refs/heads/main vs. refs/heads/topic2
# 4th field of result is hash for main instead of hash for topic2
git replay --advance main topic1..topic2 >result &&
test_line_count = 1 result &&
git log --format=%s $(cut -f 3 -d " " result) >actual &&
test_write_lines E D M L B A >expect &&
test_cmp expect actual &&
printf "update refs/heads/main " >expect &&
printf "%s " $(cut -f 3 -d " " result) >>expect &&
git rev-parse main >>expect &&
test_cmp expect result
'
test_expect_success 'using replay on bare repo to perform basic cherry-pick' '
git -C bare replay --advance main topic1..topic2 >result-bare &&
test_cmp expect result-bare
'
test_expect_success 'replay on bare repo fails with both --advance and --onto' '
test_must_fail git -C bare replay --advance main --onto main topic1..topic2 >result-bare
'
test_expect_success 'replay fails when both --advance and --onto are omitted' '
test_must_fail git replay topic1..topic2 >result
'
test_expect_success 'using replay to also rebase a contained branch' '
git replay --contained --onto main main..topic3 >result &&
test_line_count = 2 result &&
cut -f 3 -d " " result >new-branch-tips &&
git log --format=%s $(head -n 1 new-branch-tips) >actual &&
test_write_lines F C M L B A >expect &&
test_cmp expect actual &&
git log --format=%s $(tail -n 1 new-branch-tips) >actual &&
test_write_lines H G F C M L B A >expect &&
test_cmp expect actual &&
printf "update refs/heads/topic1 " >expect &&
printf "%s " $(head -n 1 new-branch-tips) >>expect &&
git rev-parse topic1 >>expect &&
printf "update refs/heads/topic3 " >>expect &&
printf "%s " $(tail -n 1 new-branch-tips) >>expect &&
git rev-parse topic3 >>expect &&
test_cmp expect result
'
test_expect_success 'using replay on bare repo to also rebase a contained branch' '
git -C bare replay --contained --onto main main..topic3 >result-bare &&
test_cmp expect result-bare
'
test_expect_success 'using replay to rebase multiple divergent branches' '
git replay --onto main ^topic1 topic2 topic4 >result &&
test_line_count = 2 result &&
cut -f 3 -d " " result >new-branch-tips &&
git log --format=%s $(head -n 1 new-branch-tips) >actual &&
test_write_lines E D M L B A >expect &&
test_cmp expect actual &&
git log --format=%s $(tail -n 1 new-branch-tips) >actual &&
test_write_lines J I M L B A >expect &&
test_cmp expect actual &&
printf "update refs/heads/topic2 " >expect &&
printf "%s " $(head -n 1 new-branch-tips) >>expect &&
git rev-parse topic2 >>expect &&
printf "update refs/heads/topic4 " >>expect &&
printf "%s " $(tail -n 1 new-branch-tips) >>expect &&
git rev-parse topic4 >>expect &&
test_cmp expect result
'
test_expect_success 'using replay on bare repo to rebase multiple divergent branches, including contained ones' '
git -C bare replay --contained --onto main ^main topic2 topic3 topic4 >result &&
test_line_count = 4 result &&
cut -f 3 -d " " result >new-branch-tips &&
>expect &&
for i in 2 1 3 4
do
printf "update refs/heads/topic$i " >>expect &&
printf "%s " $(grep topic$i result | cut -f 3 -d " ") >>expect &&
git -C bare rev-parse topic$i >>expect || return 1
done &&
test_cmp expect result &&
test_write_lines F C M L B A >expect1 &&
test_write_lines E D C M L B A >expect2 &&
test_write_lines H G F C M L B A >expect3 &&
test_write_lines J I M L B A >expect4 &&
for i in 1 2 3 4
do
git -C bare log --format=%s $(grep topic$i result | cut -f 3 -d " ") >actual &&
test_cmp expect$i actual || return 1
done
'
test_done

45
t/t6429-merge-sequence-rename-caching.sh
View File

@ -71,8 +71,9 @@ test_expect_success 'caching renames does not preclude finding new ones' '
git switch upstream && git switch upstream &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream~1..topic git update-ref --stdin <out &&
git checkout topic &&
git ls-files >tracked-files && git ls-files >tracked-files &&
test_line_count = 2 tracked-files && test_line_count = 2 tracked-files &&
@ -140,8 +141,9 @@ test_expect_success 'cherry-pick both a commit and its immediate revert' '
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream~1..topic && git update-ref --stdin <out &&
git checkout topic &&
grep region_enter.*diffcore_rename trace.output >calls && grep region_enter.*diffcore_rename trace.output >calls &&
test_line_count = 1 calls test_line_count = 1 calls
@ -199,8 +201,9 @@ test_expect_success 'rename same file identically, then reintroduce it' '
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream~1..topic && git update-ref --stdin <out &&
git checkout topic &&
git ls-files >tracked && git ls-files >tracked &&
test_line_count = 2 tracked && test_line_count = 2 tracked &&
@ -276,8 +279,9 @@ test_expect_success 'rename same file identically, then add file to old dir' '
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream~1..topic && git update-ref --stdin <out &&
git checkout topic &&
git ls-files >tracked && git ls-files >tracked &&
test_line_count = 4 tracked && test_line_count = 4 tracked &&
@ -353,10 +357,7 @@ test_expect_success 'cached dir rename does not prevent noticing later conflict'
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test_must_fail test-tool fast-rebase --onto HEAD upstream~1 topic >output && test_must_fail git replay --onto HEAD upstream~1..topic >output &&
#git cherry-pick upstream..topic &&
grep CONFLICT..rename/rename output &&
grep region_enter.*diffcore_rename trace.output >calls && grep region_enter.*diffcore_rename trace.output >calls &&
test_line_count = 2 calls test_line_count = 2 calls
@ -455,8 +456,9 @@ test_expect_success 'dir rename unneeded, then add new file to old dir' '
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream..topic && git update-ref --stdin <out &&
git checkout topic &&
grep region_enter.*diffcore_rename trace.output >calls && grep region_enter.*diffcore_rename trace.output >calls &&
test_line_count = 2 calls && test_line_count = 2 calls &&
@ -521,8 +523,9 @@ test_expect_success 'dir rename unneeded, then rename existing file into old dir
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream..topic && git update-ref --stdin <out &&
git checkout topic &&
grep region_enter.*diffcore_rename trace.output >calls && grep region_enter.*diffcore_rename trace.output >calls &&
test_line_count = 3 calls && test_line_count = 3 calls &&
@ -623,8 +626,9 @@ test_expect_success 'caching renames only on upstream side, part 1' '
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream..topic && git update-ref --stdin <out &&
git checkout topic &&
grep region_enter.*diffcore_rename trace.output >calls && grep region_enter.*diffcore_rename trace.output >calls &&
test_line_count = 1 calls && test_line_count = 1 calls &&
@ -681,8 +685,9 @@ test_expect_success 'caching renames only on upstream side, part 2' '
GIT_TRACE2_PERF="$(pwd)/trace.output" && GIT_TRACE2_PERF="$(pwd)/trace.output" &&
export GIT_TRACE2_PERF && export GIT_TRACE2_PERF &&
test-tool fast-rebase --onto HEAD upstream~1 topic && git replay --onto HEAD upstream~1..topic >out &&
#git cherry-pick upstream..topic && git update-ref --stdin <out &&
git checkout topic &&
grep region_enter.*diffcore_rename trace.output >calls && grep region_enter.*diffcore_rename trace.output >calls &&
test_line_count = 2 calls && test_line_count = 2 calls &&