Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 1 | #include "cache.h" |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 2 | #include "submodule-config.h" |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 3 | #include "submodule.h" |
| 4 | #include "dir.h" |
| 5 | #include "diff.h" |
| 6 | #include "commit.h" |
| 7 | #include "revision.h" |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 8 | #include "run-command.h" |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 9 | #include "diffcore.h" |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 10 | #include "refs.h" |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 11 | #include "string-list.h" |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 12 | #include "sha1-array.h" |
Jeff King | c1189ca | 2011-09-13 17:57:57 -0400 | [diff] [blame] | 13 | #include "argv-array.h" |
Jens Lehmann | 5fee995 | 2013-07-30 21:50:34 +0200 | [diff] [blame] | 14 | #include "blob.h" |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 15 | #include "thread-utils.h" |
Jeff King | 4638728 | 2016-04-28 09:38:20 -0400 | [diff] [blame] | 16 | #include "quote.h" |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 17 | |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 18 | static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND; |
Stefan Beller | a028a19 | 2016-02-29 18:07:13 -0800 | [diff] [blame] | 19 | static int parallel_jobs = 1; |
Junio C Hamano | 2071fb0 | 2011-04-04 15:02:01 -0700 | [diff] [blame] | 20 | static struct string_list changed_submodule_paths; |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 21 | static int initialized_fetch_ref_tips; |
| 22 | static struct sha1_array ref_tips_before_fetch; |
| 23 | static struct sha1_array ref_tips_after_fetch; |
| 24 | |
Jens Lehmann | d4e98b5 | 2011-05-14 18:26:58 +0200 | [diff] [blame] | 25 | /* |
| 26 | * The following flag is set if the .gitmodules file is unmerged. We then |
| 27 | * disable recursion for all submodules where .git/config doesn't have a |
| 28 | * matching config entry because we can't guess what might be configured in |
| 29 | * .gitmodules unless the user resolves the conflict. When a command line |
| 30 | * option is given (which always overrides configuration) this flag will be |
| 31 | * ignored. |
| 32 | */ |
| 33 | static int gitmodules_is_unmerged; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 34 | |
Jens Lehmann | 5fee995 | 2013-07-30 21:50:34 +0200 | [diff] [blame] | 35 | /* |
| 36 | * This flag is set if the .gitmodules file had unstaged modifications on |
| 37 | * startup. This must be checked before allowing modifications to the |
| 38 | * .gitmodules file with the intention to stage them later, because when |
| 39 | * continuing we would stage the modifications the user didn't stage herself |
| 40 | * too. That might change in a future version when we learn to stage the |
| 41 | * changes we do ourselves without staging any previous modifications. |
| 42 | */ |
| 43 | static int gitmodules_is_modified; |
| 44 | |
Jens Lehmann | 5fee995 | 2013-07-30 21:50:34 +0200 | [diff] [blame] | 45 | int is_staging_gitmodules_ok(void) |
| 46 | { |
| 47 | return !gitmodules_is_modified; |
| 48 | } |
| 49 | |
Jens Lehmann | 0656781 | 2013-08-06 21:15:11 +0200 | [diff] [blame] | 50 | /* |
| 51 | * Try to update the "path" entry in the "submodule.<name>" section of the |
| 52 | * .gitmodules file. Return 0 only if a .gitmodules file was found, a section |
| 53 | * with the correct path=<oldpath> setting was found and we could update it. |
| 54 | */ |
| 55 | int update_path_in_gitmodules(const char *oldpath, const char *newpath) |
| 56 | { |
| 57 | struct strbuf entry = STRBUF_INIT; |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 58 | const struct submodule *submodule; |
Jens Lehmann | 0656781 | 2013-08-06 21:15:11 +0200 | [diff] [blame] | 59 | |
| 60 | if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */ |
| 61 | return -1; |
| 62 | |
| 63 | if (gitmodules_is_unmerged) |
| 64 | die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first")); |
| 65 | |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 66 | submodule = submodule_from_path(null_sha1, oldpath); |
| 67 | if (!submodule || !submodule->name) { |
Jens Lehmann | 0656781 | 2013-08-06 21:15:11 +0200 | [diff] [blame] | 68 | warning(_("Could not find section in .gitmodules where path=%s"), oldpath); |
| 69 | return -1; |
| 70 | } |
| 71 | strbuf_addstr(&entry, "submodule."); |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 72 | strbuf_addstr(&entry, submodule->name); |
Jens Lehmann | 0656781 | 2013-08-06 21:15:11 +0200 | [diff] [blame] | 73 | strbuf_addstr(&entry, ".path"); |
Patrick Steinhardt | 30598ad | 2016-02-22 12:23:35 +0100 | [diff] [blame] | 74 | if (git_config_set_in_file_gently(".gitmodules", entry.buf, newpath) < 0) { |
Jens Lehmann | 0656781 | 2013-08-06 21:15:11 +0200 | [diff] [blame] | 75 | /* Maybe the user already did that, don't error out here */ |
| 76 | warning(_("Could not update .gitmodules entry %s"), entry.buf); |
| 77 | strbuf_release(&entry); |
| 78 | return -1; |
| 79 | } |
| 80 | strbuf_release(&entry); |
| 81 | return 0; |
| 82 | } |
| 83 | |
Jens Lehmann | 95c1641 | 2013-08-06 21:15:25 +0200 | [diff] [blame] | 84 | /* |
| 85 | * Try to remove the "submodule.<name>" section from .gitmodules where the given |
| 86 | * path is configured. Return 0 only if a .gitmodules file was found, a section |
| 87 | * with the correct path=<path> setting was found and we could remove it. |
| 88 | */ |
| 89 | int remove_path_from_gitmodules(const char *path) |
| 90 | { |
| 91 | struct strbuf sect = STRBUF_INIT; |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 92 | const struct submodule *submodule; |
Jens Lehmann | 95c1641 | 2013-08-06 21:15:25 +0200 | [diff] [blame] | 93 | |
| 94 | if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */ |
| 95 | return -1; |
| 96 | |
| 97 | if (gitmodules_is_unmerged) |
| 98 | die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first")); |
| 99 | |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 100 | submodule = submodule_from_path(null_sha1, path); |
| 101 | if (!submodule || !submodule->name) { |
Jens Lehmann | 95c1641 | 2013-08-06 21:15:25 +0200 | [diff] [blame] | 102 | warning(_("Could not find section in .gitmodules where path=%s"), path); |
| 103 | return -1; |
| 104 | } |
| 105 | strbuf_addstr(§, "submodule."); |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 106 | strbuf_addstr(§, submodule->name); |
Jens Lehmann | 95c1641 | 2013-08-06 21:15:25 +0200 | [diff] [blame] | 107 | if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) { |
| 108 | /* Maybe the user already did that, don't error out here */ |
| 109 | warning(_("Could not remove .gitmodules entry for %s"), path); |
| 110 | strbuf_release(§); |
| 111 | return -1; |
| 112 | } |
| 113 | strbuf_release(§); |
| 114 | return 0; |
| 115 | } |
| 116 | |
Jens Lehmann | 5fee995 | 2013-07-30 21:50:34 +0200 | [diff] [blame] | 117 | void stage_updated_gitmodules(void) |
| 118 | { |
Jens Lehmann | bc8d6b9 | 2013-11-07 15:33:43 +0100 | [diff] [blame] | 119 | if (add_file_to_cache(".gitmodules", 0)) |
Jens Lehmann | 5fee995 | 2013-07-30 21:50:34 +0200 | [diff] [blame] | 120 | die(_("staging updated .gitmodules failed")); |
| 121 | } |
| 122 | |
Junio C Hamano | cb58c93 | 2010-01-11 22:31:58 -0800 | [diff] [blame] | 123 | static int add_submodule_odb(const char *path) |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 124 | { |
| 125 | struct strbuf objects_directory = STRBUF_INIT; |
| 126 | struct alternate_object_database *alt_odb; |
Jens Lehmann | de7a796 | 2010-01-31 17:43:49 +0100 | [diff] [blame] | 127 | int ret = 0; |
Jeff King | 50a6c8e | 2016-02-22 17:44:35 -0500 | [diff] [blame] | 128 | size_t alloc; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 129 | |
Max Kirillov | 35fb4d2 | 2015-09-14 01:17:41 +0300 | [diff] [blame] | 130 | strbuf_git_path_submodule(&objects_directory, path, "objects/"); |
Jens Lehmann | de7a796 | 2010-01-31 17:43:49 +0100 | [diff] [blame] | 131 | if (!is_directory(objects_directory.buf)) { |
| 132 | ret = -1; |
| 133 | goto done; |
| 134 | } |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 135 | /* avoid adding it twice */ |
Jeff King | 9a6e4f0 | 2015-10-28 10:07:25 -0400 | [diff] [blame] | 136 | prepare_alt_odb(); |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 137 | for (alt_odb = alt_odb_list; alt_odb; alt_odb = alt_odb->next) |
| 138 | if (alt_odb->name - alt_odb->base == objects_directory.len && |
| 139 | !strncmp(alt_odb->base, objects_directory.buf, |
| 140 | objects_directory.len)) |
Jens Lehmann | de7a796 | 2010-01-31 17:43:49 +0100 | [diff] [blame] | 141 | goto done; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 142 | |
Jeff King | 50a6c8e | 2016-02-22 17:44:35 -0500 | [diff] [blame] | 143 | alloc = st_add(objects_directory.len, 42); /* for "12/345..." sha1 */ |
| 144 | alt_odb = xmalloc(st_add(sizeof(*alt_odb), alloc)); |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 145 | alt_odb->next = alt_odb_list; |
Jeff King | c7ab0ba | 2015-09-24 17:08:12 -0400 | [diff] [blame] | 146 | xsnprintf(alt_odb->base, alloc, "%s", objects_directory.buf); |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 147 | alt_odb->name = alt_odb->base + objects_directory.len; |
| 148 | alt_odb->name[2] = '/'; |
| 149 | alt_odb->name[40] = '\0'; |
| 150 | alt_odb->name[41] = '\0'; |
| 151 | alt_odb_list = alt_odb; |
Heiko Voigt | 5e73633 | 2012-05-14 18:24:45 +0200 | [diff] [blame] | 152 | |
| 153 | /* add possible alternates from the submodule */ |
| 154 | read_info_alternates(objects_directory.buf, 0); |
Jens Lehmann | de7a796 | 2010-01-31 17:43:49 +0100 | [diff] [blame] | 155 | done: |
| 156 | strbuf_release(&objects_directory); |
| 157 | return ret; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 158 | } |
| 159 | |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 160 | void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt, |
| 161 | const char *path) |
| 162 | { |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 163 | const struct submodule *submodule = submodule_from_path(null_sha1, path); |
| 164 | if (submodule) { |
| 165 | if (submodule->ignore) |
| 166 | handle_ignore_submodules_arg(diffopt, submodule->ignore); |
Jens Lehmann | d4e98b5 | 2011-05-14 18:26:58 +0200 | [diff] [blame] | 167 | else if (gitmodules_is_unmerged) |
| 168 | DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES); |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 169 | } |
| 170 | } |
| 171 | |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 172 | int submodule_config(const char *var, const char *value, void *cb) |
Jens Lehmann | 302ad7a | 2010-08-06 00:40:48 +0200 | [diff] [blame] | 173 | { |
Stefan Beller | a028a19 | 2016-02-29 18:07:13 -0800 | [diff] [blame] | 174 | if (!strcmp(var, "submodule.fetchjobs")) { |
| 175 | parallel_jobs = git_config_int(var, value); |
| 176 | if (parallel_jobs < 0) |
| 177 | die(_("negative values not allowed for submodule.fetchJobs")); |
| 178 | return 0; |
| 179 | } else if (starts_with(var, "submodule.")) |
Jens Lehmann | 302ad7a | 2010-08-06 00:40:48 +0200 | [diff] [blame] | 180 | return parse_submodule_config_option(var, value); |
Jens Lehmann | be254a0 | 2010-11-11 00:55:02 +0100 | [diff] [blame] | 181 | else if (!strcmp(var, "fetch.recursesubmodules")) { |
Jens Lehmann | 1fb2550 | 2011-03-06 23:11:48 +0100 | [diff] [blame] | 182 | config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value); |
Jens Lehmann | be254a0 | 2010-11-11 00:55:02 +0100 | [diff] [blame] | 183 | return 0; |
| 184 | } |
Jens Lehmann | 302ad7a | 2010-08-06 00:40:48 +0200 | [diff] [blame] | 185 | return 0; |
| 186 | } |
| 187 | |
| 188 | void gitmodules_config(void) |
| 189 | { |
| 190 | const char *work_tree = get_git_work_tree(); |
| 191 | if (work_tree) { |
| 192 | struct strbuf gitmodules_path = STRBUF_INIT; |
Jens Lehmann | d4e98b5 | 2011-05-14 18:26:58 +0200 | [diff] [blame] | 193 | int pos; |
Jens Lehmann | 302ad7a | 2010-08-06 00:40:48 +0200 | [diff] [blame] | 194 | strbuf_addstr(&gitmodules_path, work_tree); |
| 195 | strbuf_addstr(&gitmodules_path, "/.gitmodules"); |
Jens Lehmann | d4e98b5 | 2011-05-14 18:26:58 +0200 | [diff] [blame] | 196 | if (read_cache() < 0) |
| 197 | die("index file corrupt"); |
| 198 | pos = cache_name_pos(".gitmodules", 11); |
| 199 | if (pos < 0) { /* .gitmodules not found or isn't merged */ |
| 200 | pos = -1 - pos; |
| 201 | if (active_nr > pos) { /* there is a .gitmodules */ |
| 202 | const struct cache_entry *ce = active_cache[pos]; |
| 203 | if (ce_namelen(ce) == 11 && |
| 204 | !memcmp(ce->name, ".gitmodules", 11)) |
| 205 | gitmodules_is_unmerged = 1; |
| 206 | } |
Jens Lehmann | 5fee995 | 2013-07-30 21:50:34 +0200 | [diff] [blame] | 207 | } else if (pos < active_nr) { |
| 208 | struct stat st; |
| 209 | if (lstat(".gitmodules", &st) == 0 && |
| 210 | ce_match_stat(active_cache[pos], &st, 0) & DATA_CHANGED) |
| 211 | gitmodules_is_modified = 1; |
Jens Lehmann | d4e98b5 | 2011-05-14 18:26:58 +0200 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | if (!gitmodules_is_unmerged) |
| 215 | git_config_from_file(submodule_config, gitmodules_path.buf, NULL); |
Jens Lehmann | 302ad7a | 2010-08-06 00:40:48 +0200 | [diff] [blame] | 216 | strbuf_release(&gitmodules_path); |
| 217 | } |
| 218 | } |
| 219 | |
Stefan Beller | ea2fa5a | 2016-02-29 18:07:11 -0800 | [diff] [blame] | 220 | int parse_submodule_update_strategy(const char *value, |
| 221 | struct submodule_update_strategy *dst) |
| 222 | { |
| 223 | free((void*)dst->command); |
| 224 | dst->command = NULL; |
| 225 | if (!strcmp(value, "none")) |
| 226 | dst->type = SM_UPDATE_NONE; |
| 227 | else if (!strcmp(value, "checkout")) |
| 228 | dst->type = SM_UPDATE_CHECKOUT; |
| 229 | else if (!strcmp(value, "rebase")) |
| 230 | dst->type = SM_UPDATE_REBASE; |
| 231 | else if (!strcmp(value, "merge")) |
| 232 | dst->type = SM_UPDATE_MERGE; |
| 233 | else if (skip_prefix(value, "!", &value)) { |
| 234 | dst->type = SM_UPDATE_COMMAND; |
| 235 | dst->command = xstrdup(value); |
| 236 | } else |
| 237 | return -1; |
| 238 | return 0; |
| 239 | } |
| 240 | |
Stefan Beller | 3604242 | 2016-04-15 17:50:13 -0700 | [diff] [blame] | 241 | const char *submodule_strategy_to_string(const struct submodule_update_strategy *s) |
| 242 | { |
| 243 | struct strbuf sb = STRBUF_INIT; |
| 244 | switch (s->type) { |
| 245 | case SM_UPDATE_CHECKOUT: |
| 246 | return "checkout"; |
| 247 | case SM_UPDATE_MERGE: |
| 248 | return "merge"; |
| 249 | case SM_UPDATE_REBASE: |
| 250 | return "rebase"; |
| 251 | case SM_UPDATE_NONE: |
| 252 | return "none"; |
| 253 | case SM_UPDATE_UNSPECIFIED: |
| 254 | return NULL; |
| 255 | case SM_UPDATE_COMMAND: |
| 256 | strbuf_addf(&sb, "!%s", s->command); |
| 257 | return strbuf_detach(&sb, NULL); |
| 258 | } |
| 259 | return NULL; |
| 260 | } |
| 261 | |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 262 | void handle_ignore_submodules_arg(struct diff_options *diffopt, |
| 263 | const char *arg) |
| 264 | { |
Johannes Schindelin | be4f2b4 | 2010-08-05 10:49:55 +0200 | [diff] [blame] | 265 | DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES); |
| 266 | DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES); |
| 267 | DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES); |
| 268 | |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 269 | if (!strcmp(arg, "all")) |
| 270 | DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES); |
| 271 | else if (!strcmp(arg, "untracked")) |
| 272 | DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES); |
| 273 | else if (!strcmp(arg, "dirty")) |
| 274 | DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES); |
Jens Lehmann | aee9c7d | 2010-08-06 00:39:25 +0200 | [diff] [blame] | 275 | else if (strcmp(arg, "none")) |
Jens Lehmann | 46a958b | 2010-06-25 16:56:47 +0200 | [diff] [blame] | 276 | die("bad --ignore-submodules argument: %s", arg); |
| 277 | } |
| 278 | |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 279 | static int prepare_submodule_summary(struct rev_info *rev, const char *path, |
| 280 | struct commit *left, struct commit *right, |
| 281 | int *fast_forward, int *fast_backward) |
| 282 | { |
| 283 | struct commit_list *merge_bases, *list; |
| 284 | |
| 285 | init_revisions(rev, NULL); |
| 286 | setup_revisions(0, NULL, rev, NULL); |
| 287 | rev->left_right = 1; |
| 288 | rev->first_parent_only = 1; |
| 289 | left->object.flags |= SYMMETRIC_LEFT; |
| 290 | add_pending_object(rev, &left->object, path); |
| 291 | add_pending_object(rev, &right->object, path); |
Junio C Hamano | 2ce406c | 2014-10-30 12:20:44 -0700 | [diff] [blame] | 292 | merge_bases = get_merge_bases(left, right); |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 293 | if (merge_bases) { |
| 294 | if (merge_bases->item == left) |
| 295 | *fast_forward = 1; |
| 296 | else if (merge_bases->item == right) |
| 297 | *fast_backward = 1; |
| 298 | } |
| 299 | for (list = merge_bases; list; list = list->next) { |
| 300 | list->item->object.flags |= UNINTERESTING; |
| 301 | add_pending_object(rev, &list->item->object, |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 302 | oid_to_hex(&list->item->object.oid)); |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 303 | } |
| 304 | return prepare_revision_walk(rev); |
| 305 | } |
| 306 | |
| 307 | static void print_submodule_summary(struct rev_info *rev, FILE *f, |
John Keeping | 0f33a06 | 2013-04-05 17:12:08 +0100 | [diff] [blame] | 308 | const char *line_prefix, |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 309 | const char *del, const char *add, const char *reset) |
| 310 | { |
| 311 | static const char format[] = " %m %s"; |
| 312 | struct strbuf sb = STRBUF_INIT; |
| 313 | struct commit *commit; |
| 314 | |
| 315 | while ((commit = get_revision(rev))) { |
| 316 | struct pretty_print_context ctx = {0}; |
| 317 | ctx.date_mode = rev->date_mode; |
Alexey Shumkin | ecaee80 | 2013-06-26 14:19:50 +0400 | [diff] [blame] | 318 | ctx.output_encoding = get_log_output_encoding(); |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 319 | strbuf_setlen(&sb, 0); |
John Keeping | 0f33a06 | 2013-04-05 17:12:08 +0100 | [diff] [blame] | 320 | strbuf_addstr(&sb, line_prefix); |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 321 | if (commit->object.flags & SYMMETRIC_LEFT) { |
| 322 | if (del) |
| 323 | strbuf_addstr(&sb, del); |
| 324 | } |
| 325 | else if (add) |
| 326 | strbuf_addstr(&sb, add); |
| 327 | format_commit_message(commit, format, &sb, &ctx); |
| 328 | if (reset) |
| 329 | strbuf_addstr(&sb, reset); |
| 330 | strbuf_addch(&sb, '\n'); |
| 331 | fprintf(f, "%s", sb.buf); |
| 332 | } |
| 333 | strbuf_release(&sb); |
| 334 | } |
| 335 | |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 336 | void show_submodule_summary(FILE *f, const char *path, |
John Keeping | 0f33a06 | 2013-04-05 17:12:08 +0100 | [diff] [blame] | 337 | const char *line_prefix, |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 338 | unsigned char one[20], unsigned char two[20], |
Ramkumar Ramachandra | 4e21513 | 2012-11-13 21:12:47 +0530 | [diff] [blame] | 339 | unsigned dirty_submodule, const char *meta, |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 340 | const char *del, const char *add, const char *reset) |
| 341 | { |
| 342 | struct rev_info rev; |
Jeff King | 8371549 | 2013-03-22 12:19:56 -0400 | [diff] [blame] | 343 | struct commit *left = NULL, *right = NULL; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 344 | const char *message = NULL; |
| 345 | struct strbuf sb = STRBUF_INIT; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 346 | int fast_forward = 0, fast_backward = 0; |
| 347 | |
| 348 | if (is_null_sha1(two)) |
| 349 | message = "(submodule deleted)"; |
| 350 | else if (add_submodule_odb(path)) |
| 351 | message = "(not checked out)"; |
| 352 | else if (is_null_sha1(one)) |
| 353 | message = "(new submodule)"; |
| 354 | else if (!(left = lookup_commit_reference(one)) || |
| 355 | !(right = lookup_commit_reference(two))) |
| 356 | message = "(commits not present)"; |
Jeff King | 8371549 | 2013-03-22 12:19:56 -0400 | [diff] [blame] | 357 | else if (prepare_submodule_summary(&rev, path, left, right, |
| 358 | &fast_forward, &fast_backward)) |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 359 | message = "(revision walker failed)"; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 360 | |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 361 | if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) |
John Keeping | 0f33a06 | 2013-04-05 17:12:08 +0100 | [diff] [blame] | 362 | fprintf(f, "%sSubmodule %s contains untracked content\n", |
| 363 | line_prefix, path); |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 364 | if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED) |
John Keeping | 0f33a06 | 2013-04-05 17:12:08 +0100 | [diff] [blame] | 365 | fprintf(f, "%sSubmodule %s contains modified content\n", |
| 366 | line_prefix, path); |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 367 | |
| 368 | if (!hashcmp(one, two)) { |
| 369 | strbuf_release(&sb); |
| 370 | return; |
| 371 | } |
| 372 | |
John Keeping | 0f33a06 | 2013-04-05 17:12:08 +0100 | [diff] [blame] | 373 | strbuf_addf(&sb, "%s%sSubmodule %s %s..", line_prefix, meta, path, |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 374 | find_unique_abbrev(one, DEFAULT_ABBREV)); |
| 375 | if (!fast_backward && !fast_forward) |
| 376 | strbuf_addch(&sb, '.'); |
| 377 | strbuf_addf(&sb, "%s", find_unique_abbrev(two, DEFAULT_ABBREV)); |
| 378 | if (message) |
Ramkumar Ramachandra | 4e21513 | 2012-11-13 21:12:47 +0530 | [diff] [blame] | 379 | strbuf_addf(&sb, " %s%s\n", message, reset); |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 380 | else |
Ramkumar Ramachandra | 4e21513 | 2012-11-13 21:12:47 +0530 | [diff] [blame] | 381 | strbuf_addf(&sb, "%s:%s\n", fast_backward ? " (rewind)" : "", reset); |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 382 | fwrite(sb.buf, sb.len, 1, f); |
| 383 | |
Jeff King | 8371549 | 2013-03-22 12:19:56 -0400 | [diff] [blame] | 384 | if (!message) /* only NULL if we succeeded in setting up the walk */ |
John Keeping | 0f33a06 | 2013-04-05 17:12:08 +0100 | [diff] [blame] | 385 | print_submodule_summary(&rev, f, line_prefix, del, add, reset); |
Jeff King | 8371549 | 2013-03-22 12:19:56 -0400 | [diff] [blame] | 386 | if (left) |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 387 | clear_commit_marks(left, ~0); |
Jeff King | 8371549 | 2013-03-22 12:19:56 -0400 | [diff] [blame] | 388 | if (right) |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 389 | clear_commit_marks(right, ~0); |
Jonathan Nieder | 808a95d | 2011-03-16 02:14:11 -0500 | [diff] [blame] | 390 | |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 391 | strbuf_release(&sb); |
| 392 | } |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 393 | |
Jens Lehmann | be254a0 | 2010-11-11 00:55:02 +0100 | [diff] [blame] | 394 | void set_config_fetch_recurse_submodules(int value) |
| 395 | { |
| 396 | config_fetch_recurse_submodules = value; |
| 397 | } |
| 398 | |
Michael Haggerty | 7290ef5 | 2015-05-25 18:39:07 +0000 | [diff] [blame] | 399 | static int has_remote(const char *refname, const struct object_id *oid, |
| 400 | int flags, void *cb_data) |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 401 | { |
| 402 | return 1; |
| 403 | } |
| 404 | |
| 405 | static int submodule_needs_pushing(const char *path, const unsigned char sha1[20]) |
| 406 | { |
| 407 | if (add_submodule_odb(path) || !lookup_commit_reference(sha1)) |
| 408 | return 0; |
| 409 | |
| 410 | if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) { |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 411 | struct child_process cp = CHILD_PROCESS_INIT; |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 412 | const char *argv[] = {"rev-list", NULL, "--not", "--remotes", "-n", "1" , NULL}; |
| 413 | struct strbuf buf = STRBUF_INIT; |
| 414 | int needs_pushing = 0; |
| 415 | |
| 416 | argv[1] = sha1_to_hex(sha1); |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 417 | cp.argv = argv; |
Jeff King | c12e865 | 2016-04-28 09:39:15 -0400 | [diff] [blame] | 418 | prepare_submodule_repo_env(&cp.env_array); |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 419 | cp.git_cmd = 1; |
| 420 | cp.no_stdin = 1; |
| 421 | cp.out = -1; |
| 422 | cp.dir = path; |
| 423 | if (start_command(&cp)) |
| 424 | die("Could not run 'git rev-list %s --not --remotes -n 1' command in submodule %s", |
| 425 | sha1_to_hex(sha1), path); |
| 426 | if (strbuf_read(&buf, cp.out, 41)) |
| 427 | needs_pushing = 1; |
| 428 | finish_command(&cp); |
| 429 | close(cp.out); |
| 430 | strbuf_release(&buf); |
| 431 | return needs_pushing; |
| 432 | } |
| 433 | |
| 434 | return 0; |
| 435 | } |
| 436 | |
| 437 | static void collect_submodules_from_diff(struct diff_queue_struct *q, |
| 438 | struct diff_options *options, |
| 439 | void *data) |
| 440 | { |
| 441 | int i; |
Heiko Voigt | a762e51 | 2012-03-29 09:21:23 +0200 | [diff] [blame] | 442 | struct string_list *needs_pushing = data; |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 443 | |
| 444 | for (i = 0; i < q->nr; i++) { |
| 445 | struct diff_filepair *p = q->queue[i]; |
| 446 | if (!S_ISGITLINK(p->two->mode)) |
| 447 | continue; |
Heiko Voigt | a762e51 | 2012-03-29 09:21:23 +0200 | [diff] [blame] | 448 | if (submodule_needs_pushing(p->two->path, p->two->sha1)) |
| 449 | string_list_insert(needs_pushing, p->two->path); |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 450 | } |
| 451 | } |
| 452 | |
Heiko Voigt | a762e51 | 2012-03-29 09:21:23 +0200 | [diff] [blame] | 453 | static void find_unpushed_submodule_commits(struct commit *commit, |
| 454 | struct string_list *needs_pushing) |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 455 | { |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 456 | struct rev_info rev; |
| 457 | |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 458 | init_revisions(&rev, NULL); |
| 459 | rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK; |
| 460 | rev.diffopt.format_callback = collect_submodules_from_diff; |
| 461 | rev.diffopt.format_callback_data = needs_pushing; |
René Scharfe | 78e98ea | 2011-12-17 11:27:19 +0100 | [diff] [blame] | 462 | diff_tree_combined_merge(commit, 1, &rev); |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 463 | } |
| 464 | |
Heiko Voigt | a762e51 | 2012-03-29 09:21:23 +0200 | [diff] [blame] | 465 | int find_unpushed_submodules(unsigned char new_sha1[20], |
| 466 | const char *remotes_name, struct string_list *needs_pushing) |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 467 | { |
| 468 | struct rev_info rev; |
| 469 | struct commit *commit; |
| 470 | const char *argv[] = {NULL, NULL, "--not", "NULL", NULL}; |
| 471 | int argc = ARRAY_SIZE(argv) - 1; |
| 472 | char *sha1_copy; |
Heiko Voigt | a762e51 | 2012-03-29 09:21:23 +0200 | [diff] [blame] | 473 | |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 474 | struct strbuf remotes_arg = STRBUF_INIT; |
| 475 | |
| 476 | strbuf_addf(&remotes_arg, "--remotes=%s", remotes_name); |
| 477 | init_revisions(&rev, NULL); |
| 478 | sha1_copy = xstrdup(sha1_to_hex(new_sha1)); |
| 479 | argv[1] = sha1_copy; |
| 480 | argv[3] = remotes_arg.buf; |
| 481 | setup_revisions(argc, argv, &rev, NULL); |
| 482 | if (prepare_revision_walk(&rev)) |
| 483 | die("revision walk setup failed"); |
| 484 | |
Heiko Voigt | a762e51 | 2012-03-29 09:21:23 +0200 | [diff] [blame] | 485 | while ((commit = get_revision(&rev)) != NULL) |
| 486 | find_unpushed_submodule_commits(commit, needs_pushing); |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 487 | |
Heiko Voigt | bcc0a3e | 2012-03-29 09:21:21 +0200 | [diff] [blame] | 488 | reset_revision_walk(); |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 489 | free(sha1_copy); |
| 490 | strbuf_release(&remotes_arg); |
| 491 | |
Heiko Voigt | a762e51 | 2012-03-29 09:21:23 +0200 | [diff] [blame] | 492 | return needs_pushing->nr; |
Fredrik Gustafsson | d2b17b3 | 2011-08-20 00:08:47 +0200 | [diff] [blame] | 493 | } |
| 494 | |
Heiko Voigt | eb21c73 | 2012-03-29 09:21:24 +0200 | [diff] [blame] | 495 | static int push_submodule(const char *path) |
| 496 | { |
| 497 | if (add_submodule_odb(path)) |
| 498 | return 1; |
| 499 | |
| 500 | if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) { |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 501 | struct child_process cp = CHILD_PROCESS_INIT; |
Heiko Voigt | eb21c73 | 2012-03-29 09:21:24 +0200 | [diff] [blame] | 502 | const char *argv[] = {"push", NULL}; |
| 503 | |
Heiko Voigt | eb21c73 | 2012-03-29 09:21:24 +0200 | [diff] [blame] | 504 | cp.argv = argv; |
Jeff King | c12e865 | 2016-04-28 09:39:15 -0400 | [diff] [blame] | 505 | prepare_submodule_repo_env(&cp.env_array); |
Heiko Voigt | eb21c73 | 2012-03-29 09:21:24 +0200 | [diff] [blame] | 506 | cp.git_cmd = 1; |
| 507 | cp.no_stdin = 1; |
| 508 | cp.dir = path; |
| 509 | if (run_command(&cp)) |
| 510 | return 0; |
| 511 | close(cp.out); |
| 512 | } |
| 513 | |
| 514 | return 1; |
| 515 | } |
| 516 | |
| 517 | int push_unpushed_submodules(unsigned char new_sha1[20], const char *remotes_name) |
| 518 | { |
| 519 | int i, ret = 1; |
Tanay Abhra | f93d7c6 | 2014-07-18 02:19:00 -0700 | [diff] [blame] | 520 | struct string_list needs_pushing = STRING_LIST_INIT_DUP; |
Heiko Voigt | eb21c73 | 2012-03-29 09:21:24 +0200 | [diff] [blame] | 521 | |
| 522 | if (!find_unpushed_submodules(new_sha1, remotes_name, &needs_pushing)) |
| 523 | return 1; |
| 524 | |
| 525 | for (i = 0; i < needs_pushing.nr; i++) { |
| 526 | const char *path = needs_pushing.items[i].string; |
| 527 | fprintf(stderr, "Pushing submodule '%s'\n", path); |
| 528 | if (!push_submodule(path)) { |
| 529 | fprintf(stderr, "Unable to push submodule '%s'\n", path); |
| 530 | ret = 0; |
| 531 | } |
| 532 | } |
| 533 | |
| 534 | string_list_clear(&needs_pushing, 0); |
| 535 | |
| 536 | return ret; |
| 537 | } |
| 538 | |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 539 | static int is_submodule_commit_present(const char *path, unsigned char sha1[20]) |
| 540 | { |
| 541 | int is_present = 0; |
| 542 | if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) { |
| 543 | /* Even if the submodule is checked out and the commit is |
| 544 | * present, make sure it is reachable from a ref. */ |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 545 | struct child_process cp = CHILD_PROCESS_INIT; |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 546 | const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL}; |
| 547 | struct strbuf buf = STRBUF_INIT; |
| 548 | |
| 549 | argv[3] = sha1_to_hex(sha1); |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 550 | cp.argv = argv; |
Jeff King | c12e865 | 2016-04-28 09:39:15 -0400 | [diff] [blame] | 551 | prepare_submodule_repo_env(&cp.env_array); |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 552 | cp.git_cmd = 1; |
| 553 | cp.no_stdin = 1; |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 554 | cp.dir = path; |
Jeff King | 1d4974c | 2015-03-22 23:53:56 -0400 | [diff] [blame] | 555 | if (!capture_command(&cp, &buf, 1024) && !buf.len) |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 556 | is_present = 1; |
| 557 | |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 558 | strbuf_release(&buf); |
| 559 | } |
| 560 | return is_present; |
| 561 | } |
| 562 | |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 563 | static void submodule_collect_changed_cb(struct diff_queue_struct *q, |
| 564 | struct diff_options *options, |
| 565 | void *data) |
| 566 | { |
| 567 | int i; |
| 568 | for (i = 0; i < q->nr; i++) { |
| 569 | struct diff_filepair *p = q->queue[i]; |
| 570 | if (!S_ISGITLINK(p->two->mode)) |
| 571 | continue; |
| 572 | |
| 573 | if (S_ISGITLINK(p->one->mode)) { |
| 574 | /* NEEDSWORK: We should honor the name configured in |
| 575 | * the .gitmodules file of the commit we are examining |
| 576 | * here to be able to correctly follow submodules |
| 577 | * being moved around. */ |
| 578 | struct string_list_item *path; |
| 579 | path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path); |
Jens Lehmann | c16c3e4 | 2011-03-06 23:12:58 +0100 | [diff] [blame] | 580 | if (!path && !is_submodule_commit_present(p->two->path, p->two->sha1)) |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 581 | string_list_append(&changed_submodule_paths, xstrdup(p->two->path)); |
| 582 | } else { |
| 583 | /* Submodule is new or was moved here */ |
| 584 | /* NEEDSWORK: When the .git directories of submodules |
| 585 | * live inside the superprojects .git directory some |
| 586 | * day we should fetch new submodules directly into |
| 587 | * that location too when config or options request |
| 588 | * that so they can be checked out from there. */ |
| 589 | continue; |
| 590 | } |
| 591 | } |
| 592 | } |
| 593 | |
Michael Haggerty | 7290ef5 | 2015-05-25 18:39:07 +0000 | [diff] [blame] | 594 | static int add_sha1_to_array(const char *ref, const struct object_id *oid, |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 595 | int flags, void *data) |
| 596 | { |
Michael Haggerty | 7290ef5 | 2015-05-25 18:39:07 +0000 | [diff] [blame] | 597 | sha1_array_append(data, oid->hash); |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 598 | return 0; |
| 599 | } |
| 600 | |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 601 | void check_for_new_submodule_commits(unsigned char new_sha1[20]) |
| 602 | { |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 603 | if (!initialized_fetch_ref_tips) { |
| 604 | for_each_ref(add_sha1_to_array, &ref_tips_before_fetch); |
| 605 | initialized_fetch_ref_tips = 1; |
| 606 | } |
| 607 | |
| 608 | sha1_array_append(&ref_tips_after_fetch, new_sha1); |
| 609 | } |
| 610 | |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 611 | static void add_sha1_to_argv(const unsigned char sha1[20], void *data) |
| 612 | { |
Jeff King | c1189ca | 2011-09-13 17:57:57 -0400 | [diff] [blame] | 613 | argv_array_push(data, sha1_to_hex(sha1)); |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 614 | } |
| 615 | |
| 616 | static void calculate_changed_submodule_paths(void) |
| 617 | { |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 618 | struct rev_info rev; |
| 619 | struct commit *commit; |
Jeff King | c1189ca | 2011-09-13 17:57:57 -0400 | [diff] [blame] | 620 | struct argv_array argv = ARGV_ARRAY_INIT; |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 621 | |
Jens Lehmann | 18322ba | 2011-09-09 20:22:03 +0200 | [diff] [blame] | 622 | /* No need to check if there are no submodules configured */ |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 623 | if (!submodule_from_path(NULL, NULL)) |
Jens Lehmann | 18322ba | 2011-09-09 20:22:03 +0200 | [diff] [blame] | 624 | return; |
| 625 | |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 626 | init_revisions(&rev, NULL); |
Jeff King | c1189ca | 2011-09-13 17:57:57 -0400 | [diff] [blame] | 627 | argv_array_push(&argv, "--"); /* argv[0] program name */ |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 628 | sha1_array_for_each_unique(&ref_tips_after_fetch, |
| 629 | add_sha1_to_argv, &argv); |
Jeff King | c1189ca | 2011-09-13 17:57:57 -0400 | [diff] [blame] | 630 | argv_array_push(&argv, "--not"); |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 631 | sha1_array_for_each_unique(&ref_tips_before_fetch, |
| 632 | add_sha1_to_argv, &argv); |
| 633 | setup_revisions(argv.argc, argv.argv, &rev, NULL); |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 634 | if (prepare_revision_walk(&rev)) |
| 635 | die("revision walk setup failed"); |
| 636 | |
| 637 | /* |
| 638 | * Collect all submodules (whether checked out or not) for which new |
| 639 | * commits have been recorded upstream in "changed_submodule_paths". |
| 640 | */ |
| 641 | while ((commit = get_revision(&rev))) { |
| 642 | struct commit_list *parent = commit->parents; |
| 643 | while (parent) { |
| 644 | struct diff_options diff_opts; |
| 645 | diff_setup(&diff_opts); |
Jens Lehmann | ea2d325 | 2011-06-20 20:18:03 +0200 | [diff] [blame] | 646 | DIFF_OPT_SET(&diff_opts, RECURSIVE); |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 647 | diff_opts.output_format |= DIFF_FORMAT_CALLBACK; |
| 648 | diff_opts.format_callback = submodule_collect_changed_cb; |
Thomas Rast | 2845265 | 2012-08-03 14:16:24 +0200 | [diff] [blame] | 649 | diff_setup_done(&diff_opts); |
brian m. carlson | ed1c997 | 2015-11-10 02:22:29 +0000 | [diff] [blame] | 650 | diff_tree_sha1(parent->item->object.oid.hash, commit->object.oid.hash, "", &diff_opts); |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 651 | diffcore_std(&diff_opts); |
| 652 | diff_flush(&diff_opts); |
| 653 | parent = parent->next; |
| 654 | } |
| 655 | } |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 656 | |
Jeff King | c1189ca | 2011-09-13 17:57:57 -0400 | [diff] [blame] | 657 | argv_array_clear(&argv); |
Jeff King | 6859de4 | 2011-09-12 15:56:52 -0400 | [diff] [blame] | 658 | sha1_array_clear(&ref_tips_before_fetch); |
| 659 | sha1_array_clear(&ref_tips_after_fetch); |
| 660 | initialized_fetch_ref_tips = 0; |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 661 | } |
| 662 | |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 663 | struct submodule_parallel_fetch { |
| 664 | int count; |
| 665 | struct argv_array args; |
| 666 | const char *work_tree; |
| 667 | const char *prefix; |
| 668 | int command_line_option; |
| 669 | int quiet; |
| 670 | int result; |
| 671 | }; |
| 672 | #define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0} |
| 673 | |
| 674 | static int get_next_submodule(struct child_process *cp, |
| 675 | struct strbuf *err, void *data, void **task_cb) |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 676 | { |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 677 | int ret = 0; |
| 678 | struct submodule_parallel_fetch *spf = data; |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 679 | |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 680 | for (; spf->count < active_nr; spf->count++) { |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 681 | struct strbuf submodule_path = STRBUF_INIT; |
| 682 | struct strbuf submodule_git_dir = STRBUF_INIT; |
| 683 | struct strbuf submodule_prefix = STRBUF_INIT; |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 684 | const struct cache_entry *ce = active_cache[spf->count]; |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 685 | const char *git_dir, *default_argv; |
| 686 | const struct submodule *submodule; |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 687 | |
| 688 | if (!S_ISGITLINK(ce->ce_mode)) |
| 689 | continue; |
| 690 | |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 691 | submodule = submodule_from_path(null_sha1, ce->name); |
| 692 | if (!submodule) |
| 693 | submodule = submodule_from_name(null_sha1, ce->name); |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 694 | |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 695 | default_argv = "yes"; |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 696 | if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) { |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 697 | if (submodule && |
| 698 | submodule->fetch_recurse != |
| 699 | RECURSE_SUBMODULES_NONE) { |
| 700 | if (submodule->fetch_recurse == |
| 701 | RECURSE_SUBMODULES_OFF) |
Jens Lehmann | c1a3c36 | 2010-11-11 00:55:41 +0100 | [diff] [blame] | 702 | continue; |
Heiko Voigt | 851e18c | 2015-08-17 17:21:59 -0700 | [diff] [blame] | 703 | if (submodule->fetch_recurse == |
| 704 | RECURSE_SUBMODULES_ON_DEMAND) { |
Jens Lehmann | bf42b38 | 2011-03-06 23:12:19 +0100 | [diff] [blame] | 705 | if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name)) |
| 706 | continue; |
| 707 | default_argv = "on-demand"; |
| 708 | } |
Jens Lehmann | c1a3c36 | 2010-11-11 00:55:41 +0100 | [diff] [blame] | 709 | } else { |
Jens Lehmann | d4e98b5 | 2011-05-14 18:26:58 +0200 | [diff] [blame] | 710 | if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) || |
| 711 | gitmodules_is_unmerged) |
Jens Lehmann | c1a3c36 | 2010-11-11 00:55:41 +0100 | [diff] [blame] | 712 | continue; |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 713 | if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) { |
| 714 | if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name)) |
| 715 | continue; |
| 716 | default_argv = "on-demand"; |
| 717 | } |
Jens Lehmann | c1a3c36 | 2010-11-11 00:55:41 +0100 | [diff] [blame] | 718 | } |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 719 | } else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) { |
Jens Lehmann | 8f0700d | 2011-03-06 23:11:21 +0100 | [diff] [blame] | 720 | if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name)) |
| 721 | continue; |
| 722 | default_argv = "on-demand"; |
Jens Lehmann | be254a0 | 2010-11-11 00:55:02 +0100 | [diff] [blame] | 723 | } |
| 724 | |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 725 | strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name); |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 726 | strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf); |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 727 | strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name); |
Junio C Hamano | 13d6ec9 | 2011-08-22 14:04:56 -0700 | [diff] [blame] | 728 | git_dir = read_gitfile(submodule_git_dir.buf); |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 729 | if (!git_dir) |
| 730 | git_dir = submodule_git_dir.buf; |
| 731 | if (is_directory(git_dir)) { |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 732 | child_process_init(cp); |
| 733 | cp->dir = strbuf_detach(&submodule_path, NULL); |
Jeff King | c12e865 | 2016-04-28 09:39:15 -0400 | [diff] [blame] | 734 | prepare_submodule_repo_env(&cp->env_array); |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 735 | cp->git_cmd = 1; |
| 736 | if (!spf->quiet) |
| 737 | strbuf_addf(err, "Fetching submodule %s%s\n", |
| 738 | spf->prefix, ce->name); |
| 739 | argv_array_init(&cp->args); |
| 740 | argv_array_pushv(&cp->args, spf->args.argv); |
| 741 | argv_array_push(&cp->args, default_argv); |
| 742 | argv_array_push(&cp->args, "--submodule-prefix"); |
| 743 | argv_array_push(&cp->args, submodule_prefix.buf); |
| 744 | ret = 1; |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 745 | } |
| 746 | strbuf_release(&submodule_path); |
| 747 | strbuf_release(&submodule_git_dir); |
| 748 | strbuf_release(&submodule_prefix); |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 749 | if (ret) { |
| 750 | spf->count++; |
| 751 | return 1; |
| 752 | } |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 753 | } |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 754 | return 0; |
| 755 | } |
| 756 | |
Stefan Beller | 2a73b3d | 2016-02-29 13:57:06 -0800 | [diff] [blame] | 757 | static int fetch_start_failure(struct strbuf *err, |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 758 | void *cb, void *task_cb) |
| 759 | { |
| 760 | struct submodule_parallel_fetch *spf = cb; |
| 761 | |
| 762 | spf->result = 1; |
| 763 | |
| 764 | return 0; |
| 765 | } |
| 766 | |
Stefan Beller | 2a73b3d | 2016-02-29 13:57:06 -0800 | [diff] [blame] | 767 | static int fetch_finish(int retvalue, struct strbuf *err, |
| 768 | void *cb, void *task_cb) |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 769 | { |
| 770 | struct submodule_parallel_fetch *spf = cb; |
| 771 | |
| 772 | if (retvalue) |
| 773 | spf->result = 1; |
| 774 | |
| 775 | return 0; |
| 776 | } |
| 777 | |
| 778 | int fetch_populated_submodules(const struct argv_array *options, |
| 779 | const char *prefix, int command_line_option, |
Stefan Beller | 62104ba | 2015-12-15 16:04:12 -0800 | [diff] [blame] | 780 | int quiet, int max_parallel_jobs) |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 781 | { |
| 782 | int i; |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 783 | struct submodule_parallel_fetch spf = SPF_INIT; |
| 784 | |
| 785 | spf.work_tree = get_git_work_tree(); |
| 786 | spf.command_line_option = command_line_option; |
| 787 | spf.quiet = quiet; |
| 788 | spf.prefix = prefix; |
| 789 | |
| 790 | if (!spf.work_tree) |
| 791 | goto out; |
| 792 | |
| 793 | if (read_cache() < 0) |
| 794 | die("index file corrupt"); |
| 795 | |
| 796 | argv_array_push(&spf.args, "fetch"); |
| 797 | for (i = 0; i < options->argc; i++) |
| 798 | argv_array_push(&spf.args, options->argv[i]); |
| 799 | argv_array_push(&spf.args, "--recurse-submodules-default"); |
| 800 | /* default value, "--submodule-prefix" and its value are added later */ |
| 801 | |
Stefan Beller | a028a19 | 2016-02-29 18:07:13 -0800 | [diff] [blame] | 802 | if (max_parallel_jobs < 0) |
| 803 | max_parallel_jobs = parallel_jobs; |
| 804 | |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 805 | calculate_changed_submodule_paths(); |
| 806 | run_processes_parallel(max_parallel_jobs, |
| 807 | get_next_submodule, |
| 808 | fetch_start_failure, |
| 809 | fetch_finish, |
| 810 | &spf); |
| 811 | |
| 812 | argv_array_clear(&spf.args); |
Jens Lehmann | 88a2197 | 2011-03-06 23:10:46 +0100 | [diff] [blame] | 813 | out: |
| 814 | string_list_clear(&changed_submodule_paths, 1); |
Stefan Beller | fe85ee6 | 2015-12-15 16:04:11 -0800 | [diff] [blame] | 815 | return spf.result; |
Jens Lehmann | 7dce19d | 2010-11-12 13:54:52 +0100 | [diff] [blame] | 816 | } |
| 817 | |
Jens Lehmann | 3bfc450 | 2010-03-13 23:00:27 +0100 | [diff] [blame] | 818 | unsigned is_submodule_modified(const char *path, int ignore_untracked) |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 819 | { |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 820 | ssize_t len; |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 821 | struct child_process cp = CHILD_PROCESS_INIT; |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 822 | const char *argv[] = { |
| 823 | "status", |
| 824 | "--porcelain", |
| 825 | NULL, |
Jens Lehmann | 3bfc450 | 2010-03-13 23:00:27 +0100 | [diff] [blame] | 826 | NULL, |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 827 | }; |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 828 | struct strbuf buf = STRBUF_INIT; |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 829 | unsigned dirty_submodule = 0; |
| 830 | const char *line, *next_line; |
Jens Lehmann | eee49b6 | 2010-04-10 19:01:12 +0200 | [diff] [blame] | 831 | const char *git_dir; |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 832 | |
Jens Lehmann | eee49b6 | 2010-04-10 19:01:12 +0200 | [diff] [blame] | 833 | strbuf_addf(&buf, "%s/.git", path); |
Junio C Hamano | 13d6ec9 | 2011-08-22 14:04:56 -0700 | [diff] [blame] | 834 | git_dir = read_gitfile(buf.buf); |
Jens Lehmann | eee49b6 | 2010-04-10 19:01:12 +0200 | [diff] [blame] | 835 | if (!git_dir) |
| 836 | git_dir = buf.buf; |
| 837 | if (!is_directory(git_dir)) { |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 838 | strbuf_release(&buf); |
| 839 | /* The submodule is not checked out, so it is not modified */ |
| 840 | return 0; |
| 841 | |
| 842 | } |
| 843 | strbuf_reset(&buf); |
| 844 | |
Jens Lehmann | 3bfc450 | 2010-03-13 23:00:27 +0100 | [diff] [blame] | 845 | if (ignore_untracked) |
| 846 | argv[2] = "-uno"; |
| 847 | |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 848 | cp.argv = argv; |
Jeff King | c12e865 | 2016-04-28 09:39:15 -0400 | [diff] [blame] | 849 | prepare_submodule_repo_env(&cp.env_array); |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 850 | cp.git_cmd = 1; |
| 851 | cp.no_stdin = 1; |
| 852 | cp.out = -1; |
Jens Lehmann | eee49b6 | 2010-04-10 19:01:12 +0200 | [diff] [blame] | 853 | cp.dir = path; |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 854 | if (start_command(&cp)) |
Jens Lehmann | 6a5ceda | 2011-12-07 22:50:14 +0100 | [diff] [blame] | 855 | die("Could not run 'git status --porcelain' in submodule %s", path); |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 856 | |
| 857 | len = strbuf_read(&buf, cp.out, 1024); |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 858 | line = buf.buf; |
| 859 | while (len > 2) { |
| 860 | if ((line[0] == '?') && (line[1] == '?')) { |
| 861 | dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED; |
| 862 | if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED) |
| 863 | break; |
| 864 | } else { |
| 865 | dirty_submodule |= DIRTY_SUBMODULE_MODIFIED; |
Jens Lehmann | 3bfc450 | 2010-03-13 23:00:27 +0100 | [diff] [blame] | 866 | if (ignore_untracked || |
| 867 | (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)) |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 868 | break; |
| 869 | } |
| 870 | next_line = strchr(line, '\n'); |
| 871 | if (!next_line) |
| 872 | break; |
| 873 | next_line++; |
| 874 | len -= (next_line - line); |
| 875 | line = next_line; |
| 876 | } |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 877 | close(cp.out); |
| 878 | |
| 879 | if (finish_command(&cp)) |
Jens Lehmann | 6a5ceda | 2011-12-07 22:50:14 +0100 | [diff] [blame] | 880 | die("'git status --porcelain' failed in submodule %s", path); |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 881 | |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 882 | strbuf_release(&buf); |
Jens Lehmann | c7e1a73 | 2010-03-04 22:20:33 +0100 | [diff] [blame] | 883 | return dirty_submodule; |
Jens Lehmann | ee6fc51 | 2010-01-16 18:42:24 +0100 | [diff] [blame] | 884 | } |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 885 | |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 886 | int submodule_uses_gitfile(const char *path) |
| 887 | { |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 888 | struct child_process cp = CHILD_PROCESS_INIT; |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 889 | const char *argv[] = { |
| 890 | "submodule", |
| 891 | "foreach", |
| 892 | "--quiet", |
| 893 | "--recursive", |
| 894 | "test -f .git", |
| 895 | NULL, |
| 896 | }; |
| 897 | struct strbuf buf = STRBUF_INIT; |
| 898 | const char *git_dir; |
| 899 | |
| 900 | strbuf_addf(&buf, "%s/.git", path); |
| 901 | git_dir = read_gitfile(buf.buf); |
| 902 | if (!git_dir) { |
| 903 | strbuf_release(&buf); |
| 904 | return 0; |
| 905 | } |
| 906 | strbuf_release(&buf); |
| 907 | |
| 908 | /* Now test that all nested submodules use a gitfile too */ |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 909 | cp.argv = argv; |
Jeff King | c12e865 | 2016-04-28 09:39:15 -0400 | [diff] [blame] | 910 | prepare_submodule_repo_env(&cp.env_array); |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 911 | cp.git_cmd = 1; |
| 912 | cp.no_stdin = 1; |
| 913 | cp.no_stderr = 1; |
| 914 | cp.no_stdout = 1; |
| 915 | cp.dir = path; |
| 916 | if (run_command(&cp)) |
| 917 | return 0; |
| 918 | |
| 919 | return 1; |
| 920 | } |
| 921 | |
| 922 | int ok_to_remove_submodule(const char *path) |
| 923 | { |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 924 | ssize_t len; |
René Scharfe | d318027 | 2014-08-19 21:09:35 +0200 | [diff] [blame] | 925 | struct child_process cp = CHILD_PROCESS_INIT; |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 926 | const char *argv[] = { |
| 927 | "status", |
| 928 | "--porcelain", |
| 929 | "-u", |
| 930 | "--ignore-submodules=none", |
| 931 | NULL, |
| 932 | }; |
| 933 | struct strbuf buf = STRBUF_INIT; |
| 934 | int ok_to_remove = 1; |
| 935 | |
René Scharfe | dbe44fa | 2015-05-19 23:44:23 +0200 | [diff] [blame] | 936 | if (!file_exists(path) || is_empty_dir(path)) |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 937 | return 1; |
| 938 | |
| 939 | if (!submodule_uses_gitfile(path)) |
| 940 | return 0; |
| 941 | |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 942 | cp.argv = argv; |
Jeff King | c12e865 | 2016-04-28 09:39:15 -0400 | [diff] [blame] | 943 | prepare_submodule_repo_env(&cp.env_array); |
Jens Lehmann | 293ab15 | 2012-09-26 20:21:13 +0200 | [diff] [blame] | 944 | cp.git_cmd = 1; |
| 945 | cp.no_stdin = 1; |
| 946 | cp.out = -1; |
| 947 | cp.dir = path; |
| 948 | if (start_command(&cp)) |
| 949 | die("Could not run 'git status --porcelain -uall --ignore-submodules=none' in submodule %s", path); |
| 950 | |
| 951 | len = strbuf_read(&buf, cp.out, 1024); |
| 952 | if (len > 2) |
| 953 | ok_to_remove = 0; |
| 954 | close(cp.out); |
| 955 | |
| 956 | if (finish_command(&cp)) |
| 957 | die("'git status --porcelain -uall --ignore-submodules=none' failed in submodule %s", path); |
| 958 | |
| 959 | strbuf_release(&buf); |
| 960 | return ok_to_remove; |
| 961 | } |
| 962 | |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 963 | static int find_first_merges(struct object_array *result, const char *path, |
| 964 | struct commit *a, struct commit *b) |
| 965 | { |
| 966 | int i, j; |
Michael Haggerty | 3826902 | 2013-05-25 11:08:12 +0200 | [diff] [blame] | 967 | struct object_array merges = OBJECT_ARRAY_INIT; |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 968 | struct commit *commit; |
| 969 | int contains_another; |
| 970 | |
| 971 | char merged_revision[42]; |
| 972 | const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path", |
| 973 | "--all", merged_revision, NULL }; |
| 974 | struct rev_info revs; |
| 975 | struct setup_revision_opt rev_opts; |
| 976 | |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 977 | memset(result, 0, sizeof(struct object_array)); |
| 978 | memset(&rev_opts, 0, sizeof(rev_opts)); |
| 979 | |
| 980 | /* get all revisions that merge commit a */ |
| 981 | snprintf(merged_revision, sizeof(merged_revision), "^%s", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 982 | oid_to_hex(&a->object.oid)); |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 983 | init_revisions(&revs, NULL); |
| 984 | rev_opts.submodule = path; |
Elia Pinto | 94c0cc8 | 2014-06-27 05:11:39 -0700 | [diff] [blame] | 985 | setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts); |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 986 | |
| 987 | /* save all revisions from the above list that contain b */ |
| 988 | if (prepare_revision_walk(&revs)) |
| 989 | die("revision walk setup failed"); |
| 990 | while ((commit = get_revision(&revs)) != NULL) { |
| 991 | struct object *o = &(commit->object); |
Junio C Hamano | a20efee | 2012-08-27 14:46:01 -0700 | [diff] [blame] | 992 | if (in_merge_bases(b, commit)) |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 993 | add_object_array(o, NULL, &merges); |
| 994 | } |
Heiko Voigt | bcc0a3e | 2012-03-29 09:21:21 +0200 | [diff] [blame] | 995 | reset_revision_walk(); |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 996 | |
| 997 | /* Now we've got all merges that contain a and b. Prune all |
| 998 | * merges that contain another found merge and save them in |
| 999 | * result. |
| 1000 | */ |
| 1001 | for (i = 0; i < merges.nr; i++) { |
| 1002 | struct commit *m1 = (struct commit *) merges.objects[i].item; |
| 1003 | |
| 1004 | contains_another = 0; |
| 1005 | for (j = 0; j < merges.nr; j++) { |
| 1006 | struct commit *m2 = (struct commit *) merges.objects[j].item; |
Junio C Hamano | a20efee | 2012-08-27 14:46:01 -0700 | [diff] [blame] | 1007 | if (i != j && in_merge_bases(m2, m1)) { |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1008 | contains_another = 1; |
| 1009 | break; |
| 1010 | } |
| 1011 | } |
| 1012 | |
| 1013 | if (!contains_another) |
Michael Haggerty | 5de0c01 | 2013-05-25 11:08:13 +0200 | [diff] [blame] | 1014 | add_object_array(merges.objects[i].item, NULL, result); |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1015 | } |
| 1016 | |
| 1017 | free(merges.objects); |
| 1018 | return result->nr; |
| 1019 | } |
| 1020 | |
| 1021 | static void print_commit(struct commit *commit) |
| 1022 | { |
| 1023 | struct strbuf sb = STRBUF_INIT; |
| 1024 | struct pretty_print_context ctx = {0}; |
Jeff King | a5481a6 | 2015-06-25 12:55:02 -0400 | [diff] [blame] | 1025 | ctx.date_mode.type = DATE_NORMAL; |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1026 | format_commit_message(commit, " %h: %m %s", &sb, &ctx); |
| 1027 | fprintf(stderr, "%s\n", sb.buf); |
| 1028 | strbuf_release(&sb); |
| 1029 | } |
| 1030 | |
| 1031 | #define MERGE_WARNING(path, msg) \ |
| 1032 | warning("Failed to merge submodule %s (%s)", path, msg); |
| 1033 | |
| 1034 | int merge_submodule(unsigned char result[20], const char *path, |
| 1035 | const unsigned char base[20], const unsigned char a[20], |
Brad King | 8098878 | 2011-10-13 08:59:05 -0400 | [diff] [blame] | 1036 | const unsigned char b[20], int search) |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1037 | { |
| 1038 | struct commit *commit_base, *commit_a, *commit_b; |
| 1039 | int parent_count; |
| 1040 | struct object_array merges; |
| 1041 | |
| 1042 | int i; |
| 1043 | |
| 1044 | /* store a in result in case we fail */ |
| 1045 | hashcpy(result, a); |
| 1046 | |
| 1047 | /* we can not handle deletion conflicts */ |
| 1048 | if (is_null_sha1(base)) |
| 1049 | return 0; |
| 1050 | if (is_null_sha1(a)) |
| 1051 | return 0; |
| 1052 | if (is_null_sha1(b)) |
| 1053 | return 0; |
| 1054 | |
| 1055 | if (add_submodule_odb(path)) { |
| 1056 | MERGE_WARNING(path, "not checked out"); |
| 1057 | return 0; |
| 1058 | } |
| 1059 | |
| 1060 | if (!(commit_base = lookup_commit_reference(base)) || |
| 1061 | !(commit_a = lookup_commit_reference(a)) || |
| 1062 | !(commit_b = lookup_commit_reference(b))) { |
| 1063 | MERGE_WARNING(path, "commits not present"); |
| 1064 | return 0; |
| 1065 | } |
| 1066 | |
| 1067 | /* check whether both changes are forward */ |
Junio C Hamano | a20efee | 2012-08-27 14:46:01 -0700 | [diff] [blame] | 1068 | if (!in_merge_bases(commit_base, commit_a) || |
| 1069 | !in_merge_bases(commit_base, commit_b)) { |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1070 | MERGE_WARNING(path, "commits don't follow merge-base"); |
| 1071 | return 0; |
| 1072 | } |
| 1073 | |
| 1074 | /* Case #1: a is contained in b or vice versa */ |
Junio C Hamano | a20efee | 2012-08-27 14:46:01 -0700 | [diff] [blame] | 1075 | if (in_merge_bases(commit_a, commit_b)) { |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1076 | hashcpy(result, b); |
| 1077 | return 1; |
| 1078 | } |
Junio C Hamano | a20efee | 2012-08-27 14:46:01 -0700 | [diff] [blame] | 1079 | if (in_merge_bases(commit_b, commit_a)) { |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1080 | hashcpy(result, a); |
| 1081 | return 1; |
| 1082 | } |
| 1083 | |
| 1084 | /* |
| 1085 | * Case #2: There are one or more merges that contain a and b in |
| 1086 | * the submodule. If there is only one, then present it as a |
| 1087 | * suggestion to the user, but leave it marked unmerged so the |
| 1088 | * user needs to confirm the resolution. |
| 1089 | */ |
| 1090 | |
Brad King | 8098878 | 2011-10-13 08:59:05 -0400 | [diff] [blame] | 1091 | /* Skip the search if makes no sense to the calling context. */ |
| 1092 | if (!search) |
| 1093 | return 0; |
| 1094 | |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1095 | /* find commit which merges them */ |
| 1096 | parent_count = find_first_merges(&merges, path, commit_a, commit_b); |
| 1097 | switch (parent_count) { |
| 1098 | case 0: |
| 1099 | MERGE_WARNING(path, "merge following commits not found"); |
| 1100 | break; |
| 1101 | |
| 1102 | case 1: |
| 1103 | MERGE_WARNING(path, "not fast-forward"); |
| 1104 | fprintf(stderr, "Found a possible merge resolution " |
| 1105 | "for the submodule:\n"); |
| 1106 | print_commit((struct commit *) merges.objects[0].item); |
| 1107 | fprintf(stderr, |
| 1108 | "If this is correct simply add it to the index " |
| 1109 | "for example\n" |
| 1110 | "by using:\n\n" |
| 1111 | " git update-index --cacheinfo 160000 %s \"%s\"\n\n" |
| 1112 | "which will accept this suggestion.\n", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 1113 | oid_to_hex(&merges.objects[0].item->oid), path); |
Heiko Voigt | 68d03e4 | 2010-07-07 15:39:13 +0200 | [diff] [blame] | 1114 | break; |
| 1115 | |
| 1116 | default: |
| 1117 | MERGE_WARNING(path, "multiple merges found"); |
| 1118 | for (i = 0; i < merges.nr; i++) |
| 1119 | print_commit((struct commit *) merges.objects[i].item); |
| 1120 | } |
| 1121 | |
| 1122 | free(merges.objects); |
| 1123 | return 0; |
| 1124 | } |
Jens Lehmann | a88c915 | 2013-07-30 21:50:03 +0200 | [diff] [blame] | 1125 | |
| 1126 | /* Update gitfile and core.worktree setting to connect work tree and git dir */ |
| 1127 | void connect_work_tree_and_git_dir(const char *work_tree, const char *git_dir) |
| 1128 | { |
| 1129 | struct strbuf file_name = STRBUF_INIT; |
| 1130 | struct strbuf rel_path = STRBUF_INIT; |
| 1131 | const char *real_work_tree = xstrdup(real_path(work_tree)); |
Jens Lehmann | a88c915 | 2013-07-30 21:50:03 +0200 | [diff] [blame] | 1132 | |
| 1133 | /* Update gitfile */ |
| 1134 | strbuf_addf(&file_name, "%s/.git", work_tree); |
Junio C Hamano | 1f76a10 | 2015-08-24 13:20:39 -0700 | [diff] [blame] | 1135 | write_file(file_name.buf, "gitdir: %s", |
Nguyễn Thái Ngọc Duy | 91aacda | 2014-11-30 15:24:46 +0700 | [diff] [blame] | 1136 | relative_path(git_dir, real_work_tree, &rel_path)); |
Jens Lehmann | a88c915 | 2013-07-30 21:50:03 +0200 | [diff] [blame] | 1137 | |
| 1138 | /* Update core.worktree setting */ |
| 1139 | strbuf_reset(&file_name); |
| 1140 | strbuf_addf(&file_name, "%s/config", git_dir); |
Patrick Steinhardt | 3d18064 | 2016-02-22 12:23:36 +0100 | [diff] [blame] | 1141 | git_config_set_in_file(file_name.buf, "core.worktree", |
| 1142 | relative_path(real_work_tree, git_dir, |
| 1143 | &rel_path)); |
Jens Lehmann | a88c915 | 2013-07-30 21:50:03 +0200 | [diff] [blame] | 1144 | |
| 1145 | strbuf_release(&file_name); |
| 1146 | strbuf_release(&rel_path); |
| 1147 | free((void *)real_work_tree); |
| 1148 | } |
Stefan Beller | a028a19 | 2016-02-29 18:07:13 -0800 | [diff] [blame] | 1149 | |
| 1150 | int parallel_submodules(void) |
| 1151 | { |
| 1152 | return parallel_jobs; |
| 1153 | } |
Junio C Hamano | e059388 | 2016-05-17 14:38:25 -0700 | [diff] [blame] | 1154 | |
Jeff King | 4638728 | 2016-04-28 09:38:20 -0400 | [diff] [blame] | 1155 | void prepare_submodule_repo_env(struct argv_array *out) |
| 1156 | { |
| 1157 | const char * const *var; |
| 1158 | |
| 1159 | for (var = local_repo_env; *var; var++) { |
Jeff King | 89044ba | 2016-05-04 21:22:19 -0400 | [diff] [blame] | 1160 | if (strcmp(*var, CONFIG_DATA_ENVIRONMENT)) |
Jeff King | 4638728 | 2016-04-28 09:38:20 -0400 | [diff] [blame] | 1161 | argv_array_push(out, *var); |
Jeff King | 4638728 | 2016-04-28 09:38:20 -0400 | [diff] [blame] | 1162 | } |
Jeff King | 4638728 | 2016-04-28 09:38:20 -0400 | [diff] [blame] | 1163 | } |