remote show: Clean up connection correctly if object fetch wasn't done
[git/git.git] / builtin-remote.c
CommitLineData
211c8968
JS
1#include "cache.h"
2#include "parse-options.h"
3#include "transport.h"
4#include "remote.h"
5#include "path-list.h"
6#include "strbuf.h"
7#include "run-command.h"
8#include "refs.h"
9
10static const char * const builtin_remote_usage[] = {
11 "git remote",
12 "git remote add <name> <url>",
13 "git remote rm <name>",
14 "git remote show <name>",
15 "git remote prune <name>",
16 "git remote update [group]",
17 NULL
18};
19
20static int verbose;
21
22static inline int postfixcmp(const char *string, const char *postfix)
23{
24 int len1 = strlen(string), len2 = strlen(postfix);
25 if (len1 < len2)
26 return 1;
27 return strcmp(string + len1 - len2, postfix);
28}
29
30static inline const char *skip_prefix(const char *name, const char *prefix)
31{
32 return !name ? "" :
33 prefixcmp(name, prefix) ? name : name + strlen(prefix);
34}
35
36static int opt_parse_track(const struct option *opt, const char *arg, int not)
37{
38 struct path_list *list = opt->value;
39 if (not)
40 path_list_clear(list, 0);
41 else
42 path_list_append(arg, list);
43 return 0;
44}
45
46static int fetch_remote(const char *name)
47{
48 const char *argv[] = { "fetch", name, NULL };
49 if (run_command_v_opt(argv, RUN_GIT_CMD))
50 return error("Could not fetch %s", name);
51 return 0;
52}
53
54static int add(int argc, const char **argv)
55{
56 int fetch = 0, mirror = 0;
57 struct path_list track = { NULL, 0, 0 };
58 const char *master = NULL;
59 struct remote *remote;
60 struct strbuf buf, buf2;
61 const char *name, *url;
62 int i;
63
64 struct option options[] = {
65 OPT_GROUP("add specific options"),
66 OPT_BOOLEAN('f', "fetch", &fetch, "fetch the remote branches"),
67 OPT_CALLBACK('t', "track", &track, "branch",
68 "branch(es) to track", opt_parse_track),
69 OPT_STRING('m', "master", &master, "branch", "master branch"),
70 OPT_BOOLEAN(0, "mirror", &mirror, "no separate remotes"),
71 OPT_END()
72 };
73
74 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
75
76 if (argc < 2)
77 usage_with_options(builtin_remote_usage, options);
78
79 name = argv[0];
80 url = argv[1];
81
82 remote = remote_get(name);
83 if (remote && (remote->url_nr > 1 || strcmp(name, remote->url[0]) ||
84 remote->fetch_refspec_nr))
85 die("remote %s already exists.", name);
86
87 strbuf_init(&buf, 0);
88 strbuf_init(&buf2, 0);
89
90 strbuf_addf(&buf, "remote.%s.url", name);
91 if (git_config_set(buf.buf, url))
92 return 1;
93
94 if (track.nr == 0)
95 path_list_append("*", &track);
96 for (i = 0; i < track.nr; i++) {
97 struct path_list_item *item = track.items + i;
98
99 strbuf_reset(&buf);
100 strbuf_addf(&buf, "remote.%s.fetch", name);
101
102 strbuf_reset(&buf2);
103 if (mirror)
104 strbuf_addf(&buf2, "refs/%s:refs/%s",
105 item->path, item->path);
106 else
107 strbuf_addf(&buf2, "refs/heads/%s:refs/remotes/%s/%s",
108 item->path, name, item->path);
109 if (git_config_set_multivar(buf.buf, buf2.buf, "^$", 0))
110 return 1;
111 }
112
113 if (fetch && fetch_remote(name))
114 return 1;
115
116 if (master) {
117 strbuf_reset(&buf);
118 strbuf_addf(&buf, "refs/remotes/%s/HEAD", name);
119
120 strbuf_reset(&buf2);
121 strbuf_addf(&buf2, "refs/remotes/%s/%s", name, master);
122
123 if (create_symref(buf.buf, buf2.buf, "remote add"))
124 return error("Could not setup master '%s'", master);
125 }
126
127 strbuf_release(&buf);
128 strbuf_release(&buf2);
129 path_list_clear(&track, 0);
130
131 return 0;
132}
133
134struct branch_info {
135 char *remote;
136 struct path_list merge;
137};
138
139static struct path_list branch_list;
140
141static int config_read_branches(const char *key, const char *value)
142{
143 if (!prefixcmp(key, "branch.")) {
144 char *name;
145 struct path_list_item *item;
146 struct branch_info *info;
147 enum { REMOTE, MERGE } type;
148
149 key += 7;
150 if (!postfixcmp(key, ".remote")) {
151 name = xstrndup(key, strlen(key) - 7);
152 type = REMOTE;
153 } else if (!postfixcmp(key, ".merge")) {
154 name = xstrndup(key, strlen(key) - 6);
155 type = MERGE;
156 } else
157 return 0;
158
159 item = path_list_insert(name, &branch_list);
160
161 if (!item->util)
162 item->util = xcalloc(sizeof(struct branch_info), 1);
163 info = item->util;
164 if (type == REMOTE) {
165 if (info->remote)
166 warning("more than one branch.%s", key);
167 info->remote = xstrdup(value);
168 } else {
169 char *space = strchr(value, ' ');
170 value = skip_prefix(value, "refs/heads/");
171 while (space) {
172 char *merge;
173 merge = xstrndup(value, space - value);
174 path_list_append(merge, &info->merge);
175 value = skip_prefix(space + 1, "refs/heads/");
176 space = strchr(value, ' ');
177 }
178 path_list_append(xstrdup(value), &info->merge);
179 }
180 }
181 return 0;
182}
183
184static void read_branches(void)
185{
186 if (branch_list.nr)
187 return;
188 git_config(config_read_branches);
189 sort_path_list(&branch_list);
190}
191
192struct ref_states {
193 struct remote *remote;
194 struct strbuf remote_prefix;
195 struct path_list new, stale, tracked;
196};
197
198static int handle_one_branch(const char *refname,
199 const unsigned char *sha1, int flags, void *cb_data)
200{
201 struct ref_states *states = cb_data;
202 struct refspec refspec;
203
204 memset(&refspec, 0, sizeof(refspec));
205 refspec.dst = (char *)refname;
206 if (!remote_find_tracking(states->remote, &refspec)) {
207 struct path_list_item *item;
208 const char *name = skip_prefix(refspec.src, "refs/heads/");
209 if (unsorted_path_list_has_path(&states->tracked, name) ||
210 unsorted_path_list_has_path(&states->new,
211 name))
212 return 0;
213 item = path_list_append(name, &states->stale);
214 item->util = xstrdup(refname);
215 }
216 return 0;
217}
218
219static int get_ref_states(const struct ref *ref, struct ref_states *states)
220{
221 struct ref *fetch_map = NULL, **tail = &fetch_map;
222 int i;
223
224 for (i = 0; i < states->remote->fetch_refspec_nr; i++)
225 if (get_fetch_map(ref, states->remote->fetch + i, &tail, 1))
226 die("Could not get fetch map for refspec %s",
227 states->remote->fetch_refspec[i]);
228
229 states->new.strdup_paths = states->tracked.strdup_paths = 1;
230 for (ref = fetch_map; ref; ref = ref->next) {
231 struct path_list *target = &states->tracked;
232 unsigned char sha1[20];
233 void *util = NULL;
234
235 if (!ref->peer_ref || read_ref(ref->peer_ref->name, sha1))
236 target = &states->new;
237 else {
238 target = &states->tracked;
239 if (hashcmp(sha1, ref->new_sha1))
240 util = &states;
241 }
242 path_list_append(skip_prefix(ref->name, "refs/heads/"),
243 target)->util = util;
244 }
245 free_refs(fetch_map);
246
247 strbuf_addf(&states->remote_prefix,
248 "refs/remotes/%s/", states->remote->name);
249 for_each_ref(handle_one_branch, states);
250 sort_path_list(&states->stale);
251
252 return 0;
253}
254
255struct branches_for_remote {
256 const char *prefix;
257 struct path_list *branches;
258};
259
260static int add_branch_for_removal(const char *refname,
261 const unsigned char *sha1, int flags, void *cb_data)
262{
263 struct branches_for_remote *branches = cb_data;
264
265 if (!prefixcmp(refname, branches->prefix)) {
266 struct path_list_item *item;
267 item = path_list_append(refname, branches->branches);
268 item->util = xmalloc(20);
269 hashcpy(item->util, sha1);
270 }
271
272 return 0;
273}
274
275static int remove_branches(struct path_list *branches)
276{
277 int i, result = 0;
278 for (i = 0; i < branches->nr; i++) {
279 struct path_list_item *item = branches->items + i;
280 const char *refname = item->path;
281 unsigned char *sha1 = item->util;
282
283 if (delete_ref(refname, sha1))
284 result |= error("Could not remove branch %s", refname);
285 }
286 return result;
287}
288
289static int rm(int argc, const char **argv)
290{
291 struct option options[] = {
292 OPT_END()
293 };
294 struct remote *remote;
295 struct strbuf buf;
296 struct path_list branches = { NULL, 0, 0, 1 };
297 struct branches_for_remote cb_data = { NULL, &branches };
298 int i;
299
300 if (argc != 2)
301 usage_with_options(builtin_remote_usage, options);
302
303 remote = remote_get(argv[1]);
304 if (!remote)
305 die("No such remote: %s", argv[1]);
306
307 strbuf_init(&buf, 0);
308 strbuf_addf(&buf, "remote.%s", remote->name);
309 if (git_config_rename_section(buf.buf, NULL) < 1)
310 return error("Could not remove config section '%s'", buf.buf);
311
312 read_branches();
313 for (i = 0; i < branch_list.nr; i++) {
314 struct path_list_item *item = branch_list.items + i;
315 struct branch_info *info = item->util;
316 if (info->remote && !strcmp(info->remote, remote->name)) {
317 const char *keys[] = { "remote", "merge", NULL }, **k;
318 for (k = keys; *k; k++) {
319 strbuf_reset(&buf);
320 strbuf_addf(&buf, "branch.%s.%s",
321 item->path, *k);
322 if (git_config_set(buf.buf, NULL)) {
323 strbuf_release(&buf);
324 return -1;
325 }
326 }
327 }
328 }
329
330 /*
331 * We cannot just pass a function to for_each_ref() which deletes
332 * the branches one by one, since for_each_ref() relies on cached
333 * refs, which are invalidated when deleting a branch.
334 */
335 strbuf_reset(&buf);
336 strbuf_addf(&buf, "refs/remotes/%s/", remote->name);
337 cb_data.prefix = buf.buf;
338 i = for_each_ref(add_branch_for_removal, &cb_data);
339 strbuf_release(&buf);
340
341 if (!i)
342 i = remove_branches(&branches);
343 path_list_clear(&branches, 1);
344
345 return i;
346}
347
348static void show_list(const char *title, struct path_list *list)
349{
350 int i;
351
352 if (!list->nr)
353 return;
354
355 printf(title, list->nr > 1 ? "es" : "");
356 printf("\n ");
357 for (i = 0; i < list->nr; i++)
358 printf("%s%s", i ? " " : "", list->items[i].path);
359 printf("\n");
360}
361
362static int show_or_prune(int argc, const char **argv, int prune)
363{
364 int dry_run = 0, result = 0;
365 struct option options[] = {
366 OPT_GROUP("show specific options"),
367 OPT__DRY_RUN(&dry_run),
368 OPT_END()
369 };
370 struct ref_states states;
371
372 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
373
374 if (argc < 1)
375 usage_with_options(builtin_remote_usage, options);
376
377 memset(&states, 0, sizeof(states));
378 for (; argc; argc--, argv++) {
379 struct transport *transport;
380 const struct ref *ref;
381 struct strbuf buf;
382 int i, got_states;
383
384 states.remote = remote_get(*argv);
385 if (!states.remote)
386 return error("No such remote: %s", *argv);
387 transport = transport_get(NULL, states.remote->url_nr > 0 ?
388 states.remote->url[0] : NULL);
389 ref = transport_get_remote_refs(transport);
62173678 390 transport_disconnect(transport);
211c8968
JS
391
392 read_branches();
393 got_states = get_ref_states(ref, &states);
394 if (got_states)
395 result = error("Error getting local info for '%s'",
396 states.remote->name);
397
398 if (prune) {
399 struct strbuf buf;
4ebc914c 400 int prefix_len;
211c8968
JS
401
402 strbuf_init(&buf, 0);
4ebc914c
JS
403 if (states.remote->fetch_refspec_nr == 1 &&
404 states.remote->fetch->pattern &&
405 !strcmp(states.remote->fetch->src,
406 states.remote->fetch->dst))
407 /* handle --mirror remote */
408 strbuf_addstr(&buf, "refs/heads/");
409 else
410 strbuf_addf(&buf, "refs/remotes/%s/", *argv);
411 prefix_len = buf.len;
412
211c8968 413 for (i = 0; i < states.stale.nr; i++) {
4ebc914c
JS
414 strbuf_setlen(&buf, prefix_len);
415 strbuf_addstr(&buf, states.stale.items[i].path);
211c8968
JS
416 result |= delete_ref(buf.buf, NULL);
417 }
418
419 strbuf_release(&buf);
420 goto cleanup_states;
421 }
422
423 printf("* remote %s\n URL: %s\n", *argv,
424 states.remote->url_nr > 0 ?
425 states.remote->url[0] : "(no URL)");
426
427 for (i = 0; i < branch_list.nr; i++) {
428 struct path_list_item *branch = branch_list.items + i;
429 struct branch_info *info = branch->util;
430 int j;
431
432 if (!info->merge.nr || strcmp(*argv, info->remote))
433 continue;
434 printf(" Remote branch%s merged with 'git pull' "
435 "while on branch %s\n ",
436 info->merge.nr > 1 ? "es" : "",
437 branch->path);
438 for (j = 0; j < info->merge.nr; j++)
439 printf(" %s", info->merge.items[j].path);
440 printf("\n");
441 }
442
443 if (got_states)
444 continue;
445 strbuf_init(&buf, 0);
446 strbuf_addf(&buf, " New remote branch%%s (next fetch will "
447 "store in remotes/%s)", states.remote->name);
448 show_list(buf.buf, &states.new);
449 strbuf_release(&buf);
450 show_list(" Stale tracking branch%s (use 'git remote prune')",
451 &states.stale);
452 show_list(" Tracked remote branch%s",
453 &states.tracked);
454
455 if (states.remote->push_refspec_nr) {
456 printf(" Local branch%s pushed with 'git push'\n ",
457 states.remote->push_refspec_nr > 1 ?
458 "es" : "");
459 for (i = 0; i < states.remote->push_refspec_nr; i++) {
460 struct refspec *spec = states.remote->push + i;
461 printf(" %s%s%s%s", spec->force ? "+" : "",
462 skip_prefix(spec->src, "refs/heads/"),
463 spec->dst ? ":" : "",
464 skip_prefix(spec->dst, "refs/heads/"));
465 }
466 }
467cleanup_states:
468 /* NEEDSWORK: free remote */
469 path_list_clear(&states.new, 0);
470 path_list_clear(&states.stale, 0);
471 path_list_clear(&states.tracked, 0);
472 }
473
474 return result;
475}
476
477static int update_one(struct remote *remote, void *priv)
478{
479 if (!remote->skip_default_update)
480 return fetch_remote(remote->name);
481 return 0;
482}
483
484static int update(int argc, const char **argv)
485{
486 int i;
487
488 if (argc < 2)
489 return for_each_remote(update_one, NULL);
490
491 for (i = 1; i < argc; i++)
492 if (fetch_remote(argv[i]))
493 return 1;
494 return 0;
495}
496
497static int get_one_entry(struct remote *remote, void *priv)
498{
499 struct path_list *list = priv;
500
501 path_list_append(remote->name, list)->util = remote->url_nr ?
502 (void *)remote->url[0] : NULL;
503 if (remote->url_nr > 1)
504 warning("Remote %s has more than one URL", remote->name);
505
506 return 0;
507}
508
509static int show_all(void)
510{
511 struct path_list list = { NULL, 0, 0 };
512 int result = for_each_remote(get_one_entry, &list);
513
514 if (!result) {
515 int i;
516
517 sort_path_list(&list);
518 for (i = 0; i < list.nr; i++) {
519 struct path_list_item *item = list.items + i;
520 printf("%s%s%s\n", item->path,
521 verbose ? "\t" : "",
522 verbose && item->util ?
523 (const char *)item->util : "");
524 }
525 }
526 return result;
527}
528
529int cmd_remote(int argc, const char **argv, const char *prefix)
530{
531 struct option options[] = {
532 OPT__VERBOSE(&verbose),
533 OPT_END()
534 };
535 int result;
536
537 argc = parse_options(argc, argv, options, builtin_remote_usage,
538 PARSE_OPT_STOP_AT_NON_OPTION);
539
540 if (argc < 1)
541 result = show_all();
542 else if (!strcmp(argv[0], "add"))
543 result = add(argc, argv);
544 else if (!strcmp(argv[0], "rm"))
545 result = rm(argc, argv);
546 else if (!strcmp(argv[0], "show"))
547 result = show_or_prune(argc, argv, 0);
548 else if (!strcmp(argv[0], "prune"))
549 result = show_or_prune(argc, argv, 1);
550 else if (!strcmp(argv[0], "update"))
551 result = update(argc, argv);
552 else {
553 error("Unknown subcommand: %s", argv[0]);
554 usage_with_options(builtin_remote_usage, options);
555 }
556
557 return result ? 1 : 0;
558}