Make git-remote a builtin
[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);
390
391 read_branches();
392 got_states = get_ref_states(ref, &states);
393 if (got_states)
394 result = error("Error getting local info for '%s'",
395 states.remote->name);
396
397 if (prune) {
398 struct strbuf buf;
399
400 strbuf_init(&buf, 0);
401 for (i = 0; i < states.stale.nr; i++) {
402 strbuf_reset(&buf);
403 strbuf_addf(&buf, "refs/remotes/%s/%s", *argv,
404 states.stale.items[i].path);
405 result |= delete_ref(buf.buf, NULL);
406 }
407
408 strbuf_release(&buf);
409 goto cleanup_states;
410 }
411
412 printf("* remote %s\n URL: %s\n", *argv,
413 states.remote->url_nr > 0 ?
414 states.remote->url[0] : "(no URL)");
415
416 for (i = 0; i < branch_list.nr; i++) {
417 struct path_list_item *branch = branch_list.items + i;
418 struct branch_info *info = branch->util;
419 int j;
420
421 if (!info->merge.nr || strcmp(*argv, info->remote))
422 continue;
423 printf(" Remote branch%s merged with 'git pull' "
424 "while on branch %s\n ",
425 info->merge.nr > 1 ? "es" : "",
426 branch->path);
427 for (j = 0; j < info->merge.nr; j++)
428 printf(" %s", info->merge.items[j].path);
429 printf("\n");
430 }
431
432 if (got_states)
433 continue;
434 strbuf_init(&buf, 0);
435 strbuf_addf(&buf, " New remote branch%%s (next fetch will "
436 "store in remotes/%s)", states.remote->name);
437 show_list(buf.buf, &states.new);
438 strbuf_release(&buf);
439 show_list(" Stale tracking branch%s (use 'git remote prune')",
440 &states.stale);
441 show_list(" Tracked remote branch%s",
442 &states.tracked);
443
444 if (states.remote->push_refspec_nr) {
445 printf(" Local branch%s pushed with 'git push'\n ",
446 states.remote->push_refspec_nr > 1 ?
447 "es" : "");
448 for (i = 0; i < states.remote->push_refspec_nr; i++) {
449 struct refspec *spec = states.remote->push + i;
450 printf(" %s%s%s%s", spec->force ? "+" : "",
451 skip_prefix(spec->src, "refs/heads/"),
452 spec->dst ? ":" : "",
453 skip_prefix(spec->dst, "refs/heads/"));
454 }
455 }
456cleanup_states:
457 /* NEEDSWORK: free remote */
458 path_list_clear(&states.new, 0);
459 path_list_clear(&states.stale, 0);
460 path_list_clear(&states.tracked, 0);
461 }
462
463 return result;
464}
465
466static int update_one(struct remote *remote, void *priv)
467{
468 if (!remote->skip_default_update)
469 return fetch_remote(remote->name);
470 return 0;
471}
472
473static int update(int argc, const char **argv)
474{
475 int i;
476
477 if (argc < 2)
478 return for_each_remote(update_one, NULL);
479
480 for (i = 1; i < argc; i++)
481 if (fetch_remote(argv[i]))
482 return 1;
483 return 0;
484}
485
486static int get_one_entry(struct remote *remote, void *priv)
487{
488 struct path_list *list = priv;
489
490 path_list_append(remote->name, list)->util = remote->url_nr ?
491 (void *)remote->url[0] : NULL;
492 if (remote->url_nr > 1)
493 warning("Remote %s has more than one URL", remote->name);
494
495 return 0;
496}
497
498static int show_all(void)
499{
500 struct path_list list = { NULL, 0, 0 };
501 int result = for_each_remote(get_one_entry, &list);
502
503 if (!result) {
504 int i;
505
506 sort_path_list(&list);
507 for (i = 0; i < list.nr; i++) {
508 struct path_list_item *item = list.items + i;
509 printf("%s%s%s\n", item->path,
510 verbose ? "\t" : "",
511 verbose && item->util ?
512 (const char *)item->util : "");
513 }
514 }
515 return result;
516}
517
518int cmd_remote(int argc, const char **argv, const char *prefix)
519{
520 struct option options[] = {
521 OPT__VERBOSE(&verbose),
522 OPT_END()
523 };
524 int result;
525
526 argc = parse_options(argc, argv, options, builtin_remote_usage,
527 PARSE_OPT_STOP_AT_NON_OPTION);
528
529 if (argc < 1)
530 result = show_all();
531 else if (!strcmp(argv[0], "add"))
532 result = add(argc, argv);
533 else if (!strcmp(argv[0], "rm"))
534 result = rm(argc, argv);
535 else if (!strcmp(argv[0], "show"))
536 result = show_or_prune(argc, argv, 0);
537 else if (!strcmp(argv[0], "prune"))
538 result = show_or_prune(argc, argv, 1);
539 else if (!strcmp(argv[0], "update"))
540 result = update(argc, argv);
541 else {
542 error("Unknown subcommand: %s", argv[0]);
543 usage_with_options(builtin_remote_usage, options);
544 }
545
546 return result ? 1 : 0;
547}