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

submodule--helper: teach update_data more options

Browse Source 
Refactor 'struct update_data' to hold the parsed args needed by "git
submodule--helper update" and refactor "update-clone" and
"run-update-procedure" (the functions that will be combined to form
"update") to use these options.

For "run-update-procedure", 'struct update_data' already holds its args,
so only arg parsing code needs to be updated.

For "update-clone", move its args from 'struct submodule_update_clone'
into 'struct update_data', and replace them with a pointer to 'struct
update_data'. Its other members hold the submodule iteration state of
"update-clone", so those are unchanged.

Incidentally, since we reformat the designated initializers of the
affected structs, also reformat MODULE_CLONE_DATA_INIT for consistency.

Signed-off-by: Glen Choo <chooglen@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Glen Choo 2022-03-15 14:09:22 -07:00 committed by Junio C Hamano
parent 49fd5b99a5
commit c9911c9358
2 changed files with 76 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
builtin/submodule--helper.c
View File

@ -1643,7 +1643,10 @@ struct module_clone_data {
unsigned int require_init: 1; unsigned int require_init: 1;
int single_branch; int single_branch;
}; };
#define MODULE_CLONE_DATA_INIT { .reference = STRING_LIST_INIT_NODUP, .single_branch = -1 } #define MODULE_CLONE_DATA_INIT { \
.reference = STRING_LIST_INIT_NODUP, \
.single_branch = -1, \
}
struct submodule_alternate_setup { struct submodule_alternate_setup {
const char *submodule_name; const char *submodule_name;
@ -1967,26 +1970,11 @@ struct update_clone_data {
}; };
struct submodule_update_clone { struct submodule_update_clone {
/* index into 'list', the list of submodules to look into for cloning */ /* index into 'update_data.list', the list of submodules to look into for cloning */
int current; int current;
struct module_list list;
unsigned warn_if_uninitialized : 1;
/* update parameter passed via commandline */
struct submodule_update_strategy update;
/* configuration parameters which are passed on to the children */ /* configuration parameters which are passed on to the children */
int progress; struct update_data *update_data;
int quiet;
int recommend_shallow;
struct string_list references;
int dissociate;
unsigned require_init;
const char *depth;
const char *recursive_prefix;
const char *prefix;
int single_branch;
struct list_objects_filter_options *filter_options;
/* to be consumed by git-submodule.sh */ /* to be consumed by git-submodule.sh */
struct update_clone_data *update_clone; struct update_clone_data *update_clone;
@ -1998,34 +1986,45 @@ struct submodule_update_clone {
/* failed clones to be retried again */ /* failed clones to be retried again */
const struct cache_entry **failed_clones; const struct cache_entry **failed_clones;
int failed_clones_nr, failed_clones_alloc; int failed_clones_nr, failed_clones_alloc;
int max_jobs;
unsigned int init;
}; };
#define SUBMODULE_UPDATE_CLONE_INIT { \ #define SUBMODULE_UPDATE_CLONE_INIT { 0 }
.list = MODULE_LIST_INIT, \
.update = SUBMODULE_UPDATE_STRATEGY_INIT, \
.recommend_shallow = -1, \
.references = STRING_LIST_INIT_DUP, \
.single_branch = -1, \
.max_jobs = 1, \
}
struct update_data { struct update_data {
const char *prefix;
const char *recursive_prefix; const char *recursive_prefix;
const char *sm_path; const char *sm_path;
const char *displaypath; const char *displaypath;
const char *update_default;
struct object_id oid; struct object_id oid;
struct object_id suboid; struct object_id suboid;
struct string_list references;
struct submodule_update_strategy update_strategy; struct submodule_update_strategy update_strategy;
struct list_objects_filter_options *filter_options;
struct module_list list;
int depth; int depth;
int max_jobs;
int single_branch;
int recommend_shallow;
unsigned int require_init;
unsigned int force; unsigned int force;
unsigned int quiet; unsigned int quiet;
unsigned int nofetch; unsigned int nofetch;
unsigned int just_cloned; unsigned int just_cloned;
unsigned int remote; unsigned int remote;
unsigned int progress;
unsigned int dissociate;
unsigned int init;
unsigned int warn_if_uninitialized;
}; };
#define UPDATE_DATA_INIT { .update_strategy = SUBMODULE_UPDATE_STRATEGY_INIT } #define UPDATE_DATA_INIT { \
.update_strategy = SUBMODULE_UPDATE_STRATEGY_INIT, \
.list = MODULE_LIST_INIT, \
.recommend_shallow = -1, \
.references = STRING_LIST_INIT_DUP, \
.single_branch = -1, \
.max_jobs = 1, \
.warn_if_uninitialized = 1, \
}
static void next_submodule_warn_missing(struct submodule_update_clone *suc, static void next_submodule_warn_missing(struct submodule_update_clone *suc,
struct strbuf *out, const char *displaypath) struct strbuf *out, const char *displaypath)
@ -2034,7 +2033,7 @@ static void next_submodule_warn_missing(struct submodule_update_clone *suc,
* Only mention uninitialized submodules when their * Only mention uninitialized submodules when their
* paths have been specified. * paths have been specified.
*/ */
if (suc->warn_if_uninitialized) { if (suc->update_data->warn_if_uninitialized) {
strbuf_addf(out, strbuf_addf(out,
_("Submodule path '%s' not initialized"), _("Submodule path '%s' not initialized"),
displaypath); displaypath);
@ -2066,8 +2065,8 @@ static int prepare_to_clone_next_submodule(const struct cache_entry *ce,
int need_free_url = 0; int need_free_url = 0;
if (ce_stage(ce)) { if (ce_stage(ce)) {
if (suc->recursive_prefix) if (suc->update_data->recursive_prefix)
strbuf_addf(&sb, "%s/%s", suc->recursive_prefix, ce->name); strbuf_addf(&sb, "%s/%s", suc->update_data->recursive_prefix, ce->name);
else else
strbuf_addstr(&sb, ce->name); strbuf_addstr(&sb, ce->name);
strbuf_addf(out, _("Skipping unmerged submodule %s"), sb.buf); strbuf_addf(out, _("Skipping unmerged submodule %s"), sb.buf);
@ -2077,8 +2076,8 @@ static int prepare_to_clone_next_submodule(const struct cache_entry *ce,
sub = submodule_from_path(the_repository, null_oid(), ce->name); sub = submodule_from_path(the_repository, null_oid(), ce->name);
if (suc->recursive_prefix) if (suc->update_data->recursive_prefix)
displaypath = relative_path(suc->recursive_prefix, displaypath = relative_path(suc->update_data->recursive_prefix,
ce->name, &displaypath_sb); ce->name, &displaypath_sb);
else else
displaypath = ce->name; displaypath = ce->name;
@ -2096,8 +2095,8 @@ static int prepare_to_clone_next_submodule(const struct cache_entry *ce,
} }
free(key); free(key);
if (suc->update.type == SM_UPDATE_NONE if (suc->update_data->update_strategy.type == SM_UPDATE_NONE
|| (suc->update.type == SM_UPDATE_UNSPECIFIED || (suc->update_data->update_strategy.type == SM_UPDATE_UNSPECIFIED
&& update_type == SM_UPDATE_NONE)) { && update_type == SM_UPDATE_NONE)) {
strbuf_addf(out, _("Skipping submodule '%s'"), displaypath); strbuf_addf(out, _("Skipping submodule '%s'"), displaypath);
strbuf_addch(out, '\n'); strbuf_addch(out, '\n');
@ -2141,33 +2140,33 @@ static int prepare_to_clone_next_submodule(const struct cache_entry *ce,
child->err = -1; child->err = -1;
strvec_push(&child->args, "submodule--helper"); strvec_push(&child->args, "submodule--helper");
strvec_push(&child->args, "clone"); strvec_push(&child->args, "clone");
if (suc->progress) if (suc->update_data->progress)
strvec_push(&child->args, "--progress"); strvec_push(&child->args, "--progress");
if (suc->quiet) if (suc->update_data->quiet)
strvec_push(&child->args, "--quiet"); strvec_push(&child->args, "--quiet");
if (suc->prefix) if (suc->update_data->prefix)
strvec_pushl(&child->args, "--prefix", suc->prefix, NULL); strvec_pushl(&child->args, "--prefix", suc->update_data->prefix, NULL);
if (suc->recommend_shallow && sub->recommend_shallow == 1) if (suc->update_data->recommend_shallow && sub->recommend_shallow == 1)
strvec_push(&child->args, "--depth=1"); strvec_push(&child->args, "--depth=1");
if (suc->filter_options && suc->filter_options->choice) else if (suc->update_data->depth)
strvec_pushf(&child->args, "--depth=%d", suc->update_data->depth);
if (suc->update_data->filter_options && suc->update_data->filter_options->choice)
strvec_pushf(&child->args, "--filter=%s", strvec_pushf(&child->args, "--filter=%s",
expand_list_objects_filter_spec(suc->filter_options)); expand_list_objects_filter_spec(suc->update_data->filter_options));
if (suc->require_init) if (suc->update_data->require_init)
strvec_push(&child->args, "--require-init"); strvec_push(&child->args, "--require-init");
strvec_pushl(&child->args, "--path", sub->path, NULL); strvec_pushl(&child->args, "--path", sub->path, NULL);
strvec_pushl(&child->args, "--name", sub->name, NULL); strvec_pushl(&child->args, "--name", sub->name, NULL);
strvec_pushl(&child->args, "--url", url, NULL); strvec_pushl(&child->args, "--url", url, NULL);
if (suc->references.nr) { if (suc->update_data->references.nr) {
struct string_list_item *item; struct string_list_item *item;
for_each_string_list_item(item, &suc->references) for_each_string_list_item(item, &suc->update_data->references)
strvec_pushl(&child->args, "--reference", item->string, NULL); strvec_pushl(&child->args, "--reference", item->string, NULL);
} }
if (suc->dissociate) if (suc->update_data->dissociate)
strvec_push(&child->args, "--dissociate"); strvec_push(&child->args, "--dissociate");
if (suc->depth) if (suc->update_data->single_branch >= 0)
strvec_push(&child->args, suc->depth); strvec_push(&child->args, suc->update_data->single_branch ?
if (suc->single_branch >= 0)
strvec_push(&child->args, suc->single_branch ?
"--single-branch" : "--single-branch" :
"--no-single-branch"); "--no-single-branch");
@ -2189,8 +2188,8 @@ static int update_clone_get_next_task(struct child_process *child,
const struct cache_entry *ce; const struct cache_entry *ce;
int index; int index;
for (; suc->current < suc->list.nr; suc->current++) { for (; suc->current < suc->update_data->list.nr; suc->current++) {
ce = suc->list.entries[suc->current]; ce = suc->update_data->list.entries[suc->current];
if (prepare_to_clone_next_submodule(ce, child, suc, err)) { if (prepare_to_clone_next_submodule(ce, child, suc, err)) {
int *p = xmalloc(sizeof(*p)); int *p = xmalloc(sizeof(*p));
*p = suc->current; *p = suc->current;
@ -2205,7 +2204,7 @@ static int update_clone_get_next_task(struct child_process *child,
* stragglers again, which we can imagine as an extension of the * stragglers again, which we can imagine as an extension of the
* entry list. * entry list.
*/ */
index = suc->current - suc->list.nr; index = suc->current - suc->update_data->list.nr;
if (index < suc->failed_clones_nr) { if (index < suc->failed_clones_nr) {
int *p; int *p;
ce = suc->failed_clones[index]; ce = suc->failed_clones[index];
@ -2250,8 +2249,8 @@ static int update_clone_task_finished(int result,
if (!result) if (!result)
return 0; return 0;
if (idx < suc->list.nr) { if (idx < suc->update_data->list.nr) {
ce = suc->list.entries[idx]; ce = suc->update_data->list.entries[idx];
strbuf_addf(err, _("Failed to clone '%s'. Retry scheduled"), strbuf_addf(err, _("Failed to clone '%s'. Retry scheduled"),
ce->name); ce->name);
strbuf_addch(err, '\n'); strbuf_addch(err, '\n');
@ -2261,7 +2260,7 @@ static int update_clone_task_finished(int result,
suc->failed_clones[suc->failed_clones_nr++] = ce; suc->failed_clones[suc->failed_clones_nr++] = ce;
return 0; return 0;
} else { } else {
idx -= suc->list.nr; idx -= suc->update_data->list.nr;
ce = suc->failed_clones[idx]; ce = suc->failed_clones[idx];
strbuf_addf(err, _("Failed to clone '%s' a second time, aborting"), strbuf_addf(err, _("Failed to clone '%s' a second time, aborting"),
ce->name); ce->name);
@ -2468,13 +2467,15 @@ static void update_submodule(struct update_clone_data *ucd)
ucd->sub->path); ucd->sub->path);
} }
static int update_submodules(struct submodule_update_clone *suc) static int update_submodules(struct update_data *update_data)
{ {
int i; int i;
struct submodule_update_clone suc = SUBMODULE_UPDATE_CLONE_INIT;
run_processes_parallel_tr2(suc->max_jobs, update_clone_get_next_task, suc.update_data = update_data;
run_processes_parallel_tr2(suc.update_data->max_jobs, update_clone_get_next_task,
update_clone_start_failure, update_clone_start_failure,
update_clone_task_finished, suc, "submodule", update_clone_task_finished, &suc, "submodule",
"parallel/update"); "parallel/update");
/* /*
@ -2485,41 +2486,40 @@ static int update_submodules(struct submodule_update_clone *suc)
* checkout involve more straightforward sequential I/O. * checkout involve more straightforward sequential I/O.
* - the listener can avoid doing any work if fetching failed. * - the listener can avoid doing any work if fetching failed.
*/ */
if (suc->quickstop) if (suc.quickstop)
return 1; return 1;
for (i = 0; i < suc->update_clone_nr; i++) for (i = 0; i < suc.update_clone_nr; i++)
update_submodule(&suc->update_clone[i]); update_submodule(&suc.update_clone[i]);
return 0; return 0;
} }
static int update_clone(int argc, const char **argv, const char *prefix) static int update_clone(int argc, const char **argv, const char *prefix)
{ {
const char *update = NULL;
struct pathspec pathspec; struct pathspec pathspec;
struct submodule_update_clone opt = SUBMODULE_UPDATE_CLONE_INIT; struct update_data opt = UPDATE_DATA_INIT;
struct list_objects_filter_options filter_options; struct list_objects_filter_options filter_options;
int ret; int ret;
struct option module_update_clone_options[] = { struct option module_update_clone_options[] = {
OPT_BOOL(0, "init", &opt.init, OPT_BOOL(0, "init", &opt.init,
N_("initialize uninitialized submodules before update")), N_("initialize uninitialized submodules before update")),
OPT_STRING(0, "prefix", &prefix, OPT_STRING(0, "prefix", &opt.prefix,
N_("path"), N_("path"),
N_("path into the working tree")), N_("path into the working tree")),
OPT_STRING(0, "recursive-prefix", &opt.recursive_prefix, OPT_STRING(0, "recursive-prefix", &opt.recursive_prefix,
N_("path"), N_("path"),
N_("path into the working tree, across nested " N_("path into the working tree, across nested "
"submodule boundaries")), "submodule boundaries")),
OPT_STRING(0, "update", &update, OPT_STRING(0, "update", &opt.update_default,
N_("string"), N_("string"),
N_("rebase, merge, checkout or none")), N_("rebase, merge, checkout or none")),
OPT_STRING_LIST(0, "reference", &opt.references, N_("repo"), OPT_STRING_LIST(0, "reference", &opt.references, N_("repo"),
N_("reference repository")), N_("reference repository")),
OPT_BOOL(0, "dissociate", &opt.dissociate, OPT_BOOL(0, "dissociate", &opt.dissociate,
N_("use --reference only while cloning")), N_("use --reference only while cloning")),
OPT_STRING(0, "depth", &opt.depth, "<depth>", OPT_INTEGER(0, "depth", &opt.depth,
N_("create a shallow clone truncated to the " N_("create a shallow clone truncated to the "
"specified number of revisions")), "specified number of revisions")),
OPT_INTEGER('j', "jobs", &opt.max_jobs, OPT_INTEGER('j', "jobs", &opt.max_jobs,
@ -2546,7 +2546,6 @@ static int update_clone(int argc, const char **argv, const char *prefix)
" [--recursive] [--[no-]single-branch] [--] [<path>...]"), " [--recursive] [--[no-]single-branch] [--] [<path>...]"),
NULL NULL
}; };
opt.prefix = prefix;
update_clone_config_from_gitmodules(&opt.max_jobs); update_clone_config_from_gitmodules(&opt.max_jobs);
git_config(git_update_clone_config, &opt.max_jobs); git_config(git_update_clone_config, &opt.max_jobs);
@ -2569,8 +2568,9 @@ static int update_clone(int argc, const char **argv, const char *prefix)
opt.filter_options = &filter_options; opt.filter_options = &filter_options;
if (update) if (opt.update_default)
if (parse_submodule_update_strategy(update, &opt.update) < 0) if (parse_submodule_update_strategy(opt.update_default,
&opt.update_strategy) < 0)
die(_("bad value for update parameter")); die(_("bad value for update parameter"));
if (module_list_compute(argc, argv, prefix, &pathspec, &opt.list) < 0) { if (module_list_compute(argc, argv, prefix, &pathspec, &opt.list) < 0) {
@ -2611,7 +2611,7 @@ static int update_clone(int argc, const char **argv, const char *prefix)
static int run_update_procedure(int argc, const char **argv, const char *prefix) static int run_update_procedure(int argc, const char **argv, const char *prefix)
{ {
char *prefixed_path, *update = NULL; char *prefixed_path;
struct update_data update_data = UPDATE_DATA_INIT; struct update_data update_data = UPDATE_DATA_INIT;
struct option options[] = { struct option options[] = {
@ -2627,7 +2627,7 @@ static int run_update_procedure(int argc, const char **argv, const char *prefix)
OPT_STRING(0, "prefix", &prefix, OPT_STRING(0, "prefix", &prefix,
N_("path"), N_("path"),
N_("path into the working tree")), N_("path into the working tree")),
OPT_STRING(0, "update", &update, OPT_STRING(0, "update", &update_data.update_default,
N_("string"), N_("string"),
N_("rebase, merge, checkout or none")), N_("rebase, merge, checkout or none")),
OPT_STRING(0, "recursive-prefix", &update_data.recursive_prefix, N_("path"), OPT_STRING(0, "recursive-prefix", &update_data.recursive_prefix, N_("path"),
@ -2661,7 +2661,7 @@ static int run_update_procedure(int argc, const char **argv, const char *prefix)
update_data.displaypath = get_submodule_displaypath(prefixed_path, prefix); update_data.displaypath = get_submodule_displaypath(prefixed_path, prefix);
determine_submodule_update_strategy(the_repository, update_data.just_cloned, determine_submodule_update_strategy(the_repository, update_data.just_cloned,
update_data.sm_path, update, update_data.sm_path, update_data.update_default,
&update_data.update_strategy); &update_data.update_strategy);
free(prefixed_path); free(prefixed_path);

2
git-submodule.sh
View File

@ -366,7 +366,7 @@ cmd_update()
${update:+--update "$update"} \ ${update:+--update "$update"} \
${reference:+"$reference"} \ ${reference:+"$reference"} \
${dissociate:+"--dissociate"} \ ${dissociate:+"--dissociate"} \
${depth:+--depth "$depth"} \ ${depth:+"$depth"} \
${require_init:+--require-init} \ ${require_init:+--require-init} \
$single_branch \ $single_branch \
$recommend_shallow \ $recommend_shallow \