Use the asyncronous function infrastructure in builtin-fetch-pack.c.
[git/git.git] / builtin-fetch-pack.c
1 #include "cache.h"
2 #include "refs.h"
3 #include "pkt-line.h"
4 #include "commit.h"
5 #include "tag.h"
6 #include "exec_cmd.h"
7 #include "pack.h"
8 #include "sideband.h"
9 #include "fetch-pack.h"
10 #include "run-command.h"
11
12 static int transfer_unpack_limit = -1;
13 static int fetch_unpack_limit = -1;
14 static int unpack_limit = 100;
15 static struct fetch_pack_args args;
16
17 static const char fetch_pack_usage[] =
18 "git-fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
19 static const char *uploadpack = "git-upload-pack";
20
21 #define COMPLETE (1U << 0)
22 #define COMMON (1U << 1)
23 #define COMMON_REF (1U << 2)
24 #define SEEN (1U << 3)
25 #define POPPED (1U << 4)
26
27 /*
28 * After sending this many "have"s if we do not get any new ACK , we
29 * give up traversing our history.
30 */
31 #define MAX_IN_VAIN 256
32
33 static struct commit_list *rev_list;
34 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
35
36 static void rev_list_push(struct commit *commit, int mark)
37 {
38 if (!(commit->object.flags & mark)) {
39 commit->object.flags |= mark;
40
41 if (!(commit->object.parsed))
42 parse_commit(commit);
43
44 insert_by_date(commit, &rev_list);
45
46 if (!(commit->object.flags & COMMON))
47 non_common_revs++;
48 }
49 }
50
51 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
52 {
53 struct object *o = deref_tag(parse_object(sha1), path, 0);
54
55 if (o && o->type == OBJ_COMMIT)
56 rev_list_push((struct commit *)o, SEEN);
57
58 return 0;
59 }
60
61 /*
62 This function marks a rev and its ancestors as common.
63 In some cases, it is desirable to mark only the ancestors (for example
64 when only the server does not yet know that they are common).
65 */
66
67 static void mark_common(struct commit *commit,
68 int ancestors_only, int dont_parse)
69 {
70 if (commit != NULL && !(commit->object.flags & COMMON)) {
71 struct object *o = (struct object *)commit;
72
73 if (!ancestors_only)
74 o->flags |= COMMON;
75
76 if (!(o->flags & SEEN))
77 rev_list_push(commit, SEEN);
78 else {
79 struct commit_list *parents;
80
81 if (!ancestors_only && !(o->flags & POPPED))
82 non_common_revs--;
83 if (!o->parsed && !dont_parse)
84 parse_commit(commit);
85
86 for (parents = commit->parents;
87 parents;
88 parents = parents->next)
89 mark_common(parents->item, 0, dont_parse);
90 }
91 }
92 }
93
94 /*
95 Get the next rev to send, ignoring the common.
96 */
97
98 static const unsigned char* get_rev(void)
99 {
100 struct commit *commit = NULL;
101
102 while (commit == NULL) {
103 unsigned int mark;
104 struct commit_list* parents;
105
106 if (rev_list == NULL || non_common_revs == 0)
107 return NULL;
108
109 commit = rev_list->item;
110 if (!(commit->object.parsed))
111 parse_commit(commit);
112 commit->object.flags |= POPPED;
113 if (!(commit->object.flags & COMMON))
114 non_common_revs--;
115
116 parents = commit->parents;
117
118 if (commit->object.flags & COMMON) {
119 /* do not send "have", and ignore ancestors */
120 commit = NULL;
121 mark = COMMON | SEEN;
122 } else if (commit->object.flags & COMMON_REF)
123 /* send "have", and ignore ancestors */
124 mark = COMMON | SEEN;
125 else
126 /* send "have", also for its ancestors */
127 mark = SEEN;
128
129 while (parents) {
130 if (!(parents->item->object.flags & SEEN))
131 rev_list_push(parents->item, mark);
132 if (mark & COMMON)
133 mark_common(parents->item, 1, 0);
134 parents = parents->next;
135 }
136
137 rev_list = rev_list->next;
138 }
139
140 return commit->object.sha1;
141 }
142
143 static int find_common(int fd[2], unsigned char *result_sha1,
144 struct ref *refs)
145 {
146 int fetching;
147 int count = 0, flushes = 0, retval;
148 const unsigned char *sha1;
149 unsigned in_vain = 0;
150 int got_continue = 0;
151
152 for_each_ref(rev_list_insert_ref, NULL);
153
154 fetching = 0;
155 for ( ; refs ; refs = refs->next) {
156 unsigned char *remote = refs->old_sha1;
157 struct object *o;
158
159 /*
160 * If that object is complete (i.e. it is an ancestor of a
161 * local ref), we tell them we have it but do not have to
162 * tell them about its ancestors, which they already know
163 * about.
164 *
165 * We use lookup_object here because we are only
166 * interested in the case we *know* the object is
167 * reachable and we have already scanned it.
168 */
169 if (((o = lookup_object(remote)) != NULL) &&
170 (o->flags & COMPLETE)) {
171 continue;
172 }
173
174 if (!fetching)
175 packet_write(fd[1], "want %s%s%s%s%s%s%s\n",
176 sha1_to_hex(remote),
177 (multi_ack ? " multi_ack" : ""),
178 (use_sideband == 2 ? " side-band-64k" : ""),
179 (use_sideband == 1 ? " side-band" : ""),
180 (use_thin_pack ? " thin-pack" : ""),
181 (args.no_progress ? " no-progress" : ""),
182 " ofs-delta");
183 else
184 packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
185 fetching++;
186 }
187 if (is_repository_shallow())
188 write_shallow_commits(fd[1], 1);
189 if (args.depth > 0)
190 packet_write(fd[1], "deepen %d", args.depth);
191 packet_flush(fd[1]);
192 if (!fetching)
193 return 1;
194
195 if (args.depth > 0) {
196 char line[1024];
197 unsigned char sha1[20];
198 int len;
199
200 while ((len = packet_read_line(fd[0], line, sizeof(line)))) {
201 if (!prefixcmp(line, "shallow ")) {
202 if (get_sha1_hex(line + 8, sha1))
203 die("invalid shallow line: %s", line);
204 register_shallow(sha1);
205 continue;
206 }
207 if (!prefixcmp(line, "unshallow ")) {
208 if (get_sha1_hex(line + 10, sha1))
209 die("invalid unshallow line: %s", line);
210 if (!lookup_object(sha1))
211 die("object not found: %s", line);
212 /* make sure that it is parsed as shallow */
213 parse_object(sha1);
214 if (unregister_shallow(sha1))
215 die("no shallow found: %s", line);
216 continue;
217 }
218 die("expected shallow/unshallow, got %s", line);
219 }
220 }
221
222 flushes = 0;
223 retval = -1;
224 while ((sha1 = get_rev())) {
225 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
226 if (args.verbose)
227 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
228 in_vain++;
229 if (!(31 & ++count)) {
230 int ack;
231
232 packet_flush(fd[1]);
233 flushes++;
234
235 /*
236 * We keep one window "ahead" of the other side, and
237 * will wait for an ACK only on the next one
238 */
239 if (count == 32)
240 continue;
241
242 do {
243 ack = get_ack(fd[0], result_sha1);
244 if (args.verbose && ack)
245 fprintf(stderr, "got ack %d %s\n", ack,
246 sha1_to_hex(result_sha1));
247 if (ack == 1) {
248 flushes = 0;
249 multi_ack = 0;
250 retval = 0;
251 goto done;
252 } else if (ack == 2) {
253 struct commit *commit =
254 lookup_commit(result_sha1);
255 mark_common(commit, 0, 1);
256 retval = 0;
257 in_vain = 0;
258 got_continue = 1;
259 }
260 } while (ack);
261 flushes--;
262 if (got_continue && MAX_IN_VAIN < in_vain) {
263 if (args.verbose)
264 fprintf(stderr, "giving up\n");
265 break; /* give up */
266 }
267 }
268 }
269 done:
270 packet_write(fd[1], "done\n");
271 if (args.verbose)
272 fprintf(stderr, "done\n");
273 if (retval != 0) {
274 multi_ack = 0;
275 flushes++;
276 }
277 while (flushes || multi_ack) {
278 int ack = get_ack(fd[0], result_sha1);
279 if (ack) {
280 if (args.verbose)
281 fprintf(stderr, "got ack (%d) %s\n", ack,
282 sha1_to_hex(result_sha1));
283 if (ack == 1)
284 return 0;
285 multi_ack = 1;
286 continue;
287 }
288 flushes--;
289 }
290 return retval;
291 }
292
293 static struct commit_list *complete;
294
295 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
296 {
297 struct object *o = parse_object(sha1);
298
299 while (o && o->type == OBJ_TAG) {
300 struct tag *t = (struct tag *) o;
301 if (!t->tagged)
302 break; /* broken repository */
303 o->flags |= COMPLETE;
304 o = parse_object(t->tagged->sha1);
305 }
306 if (o && o->type == OBJ_COMMIT) {
307 struct commit *commit = (struct commit *)o;
308 commit->object.flags |= COMPLETE;
309 insert_by_date(commit, &complete);
310 }
311 return 0;
312 }
313
314 static void mark_recent_complete_commits(unsigned long cutoff)
315 {
316 while (complete && cutoff <= complete->item->date) {
317 if (args.verbose)
318 fprintf(stderr, "Marking %s as complete\n",
319 sha1_to_hex(complete->item->object.sha1));
320 pop_most_recent_commit(&complete, COMPLETE);
321 }
322 }
323
324 static void filter_refs(struct ref **refs, int nr_match, char **match)
325 {
326 struct ref **return_refs;
327 struct ref *newlist = NULL;
328 struct ref **newtail = &newlist;
329 struct ref *ref, *next;
330 struct ref *fastarray[32];
331
332 if (nr_match && !args.fetch_all) {
333 if (ARRAY_SIZE(fastarray) < nr_match)
334 return_refs = xcalloc(nr_match, sizeof(struct ref *));
335 else {
336 return_refs = fastarray;
337 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
338 }
339 }
340 else
341 return_refs = NULL;
342
343 for (ref = *refs; ref; ref = next) {
344 next = ref->next;
345 if (!memcmp(ref->name, "refs/", 5) &&
346 check_ref_format(ref->name + 5))
347 ; /* trash */
348 else if (args.fetch_all &&
349 (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
350 *newtail = ref;
351 ref->next = NULL;
352 newtail = &ref->next;
353 continue;
354 }
355 else {
356 int order = path_match(ref->name, nr_match, match);
357 if (order) {
358 return_refs[order-1] = ref;
359 continue; /* we will link it later */
360 }
361 }
362 free(ref);
363 }
364
365 if (!args.fetch_all) {
366 int i;
367 for (i = 0; i < nr_match; i++) {
368 ref = return_refs[i];
369 if (ref) {
370 *newtail = ref;
371 ref->next = NULL;
372 newtail = &ref->next;
373 }
374 }
375 if (return_refs != fastarray)
376 free(return_refs);
377 }
378 *refs = newlist;
379 }
380
381 static int everything_local(struct ref **refs, int nr_match, char **match)
382 {
383 struct ref *ref;
384 int retval;
385 unsigned long cutoff = 0;
386
387 track_object_refs = 0;
388 save_commit_buffer = 0;
389
390 for (ref = *refs; ref; ref = ref->next) {
391 struct object *o;
392
393 o = parse_object(ref->old_sha1);
394 if (!o)
395 continue;
396
397 /* We already have it -- which may mean that we were
398 * in sync with the other side at some time after
399 * that (it is OK if we guess wrong here).
400 */
401 if (o->type == OBJ_COMMIT) {
402 struct commit *commit = (struct commit *)o;
403 if (!cutoff || cutoff < commit->date)
404 cutoff = commit->date;
405 }
406 }
407
408 if (!args.depth) {
409 for_each_ref(mark_complete, NULL);
410 if (cutoff)
411 mark_recent_complete_commits(cutoff);
412 }
413
414 /*
415 * Mark all complete remote refs as common refs.
416 * Don't mark them common yet; the server has to be told so first.
417 */
418 for (ref = *refs; ref; ref = ref->next) {
419 struct object *o = deref_tag(lookup_object(ref->old_sha1),
420 NULL, 0);
421
422 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
423 continue;
424
425 if (!(o->flags & SEEN)) {
426 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
427
428 mark_common((struct commit *)o, 1, 1);
429 }
430 }
431
432 filter_refs(refs, nr_match, match);
433
434 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
435 const unsigned char *remote = ref->old_sha1;
436 unsigned char local[20];
437 struct object *o;
438
439 o = lookup_object(remote);
440 if (!o || !(o->flags & COMPLETE)) {
441 retval = 0;
442 if (!args.verbose)
443 continue;
444 fprintf(stderr,
445 "want %s (%s)\n", sha1_to_hex(remote),
446 ref->name);
447 continue;
448 }
449
450 hashcpy(ref->new_sha1, local);
451 if (!args.verbose)
452 continue;
453 fprintf(stderr,
454 "already have %s (%s)\n", sha1_to_hex(remote),
455 ref->name);
456 }
457 return retval;
458 }
459
460 static int sideband_demux(int fd, void *data)
461 {
462 int *xd = data;
463
464 close(xd[1]);
465 return recv_sideband("fetch-pack", xd[0], fd, 2);
466 }
467
468 static void setup_sideband(int fd[2], int xd[2], struct async *demux)
469 {
470 if (!use_sideband) {
471 fd[0] = xd[0];
472 fd[1] = xd[1];
473 return;
474 }
475 /* xd[] is talking with upload-pack; subprocess reads from
476 * xd[0], spits out band#2 to stderr, and feeds us band#1
477 * through demux->out.
478 */
479 demux->proc = sideband_demux;
480 demux->data = xd;
481 if (start_async(demux))
482 die("fetch-pack: unable to fork off sideband demultiplexer");
483 close(xd[0]);
484 fd[0] = demux->out;
485 fd[1] = xd[1];
486 }
487
488 static int get_pack(int xd[2], char **pack_lockfile)
489 {
490 struct async demux;
491 int fd[2];
492 const char *argv[20];
493 char keep_arg[256];
494 char hdr_arg[256];
495 const char **av;
496 int do_keep = args.keep_pack;
497 struct child_process cmd;
498
499 setup_sideband(fd, xd, &demux);
500
501 memset(&cmd, 0, sizeof(cmd));
502 cmd.argv = argv;
503 av = argv;
504 *hdr_arg = 0;
505 if (!args.keep_pack && unpack_limit) {
506 struct pack_header header;
507
508 if (read_pack_header(fd[0], &header))
509 die("protocol error: bad pack header");
510 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
511 ntohl(header.hdr_version), ntohl(header.hdr_entries));
512 if (ntohl(header.hdr_entries) < unpack_limit)
513 do_keep = 0;
514 else
515 do_keep = 1;
516 }
517
518 if (do_keep) {
519 if (pack_lockfile)
520 cmd.out = -1;
521 *av++ = "index-pack";
522 *av++ = "--stdin";
523 if (!args.quiet && !args.no_progress)
524 *av++ = "-v";
525 if (args.use_thin_pack)
526 *av++ = "--fix-thin";
527 if (args.lock_pack || unpack_limit) {
528 int s = sprintf(keep_arg,
529 "--keep=fetch-pack %d on ", getpid());
530 if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
531 strcpy(keep_arg + s, "localhost");
532 *av++ = keep_arg;
533 }
534 }
535 else {
536 *av++ = "unpack-objects";
537 if (args.quiet)
538 *av++ = "-q";
539 }
540 if (*hdr_arg)
541 *av++ = hdr_arg;
542 *av++ = NULL;
543
544 cmd.in = fd[0];
545 cmd.git_cmd = 1;
546 if (start_command(&cmd))
547 die("fetch-pack: unable to fork off %s", argv[0]);
548 close(fd[1]);
549 if (do_keep && pack_lockfile)
550 *pack_lockfile = index_pack_lockfile(cmd.out);
551
552 if (finish_command(&cmd))
553 die("%s failed", argv[0]);
554 if (use_sideband && finish_async(&demux))
555 die("error in sideband demultiplexer");
556 return 0;
557 }
558
559 static struct ref *do_fetch_pack(int fd[2],
560 int nr_match,
561 char **match,
562 char **pack_lockfile)
563 {
564 struct ref *ref;
565 unsigned char sha1[20];
566
567 get_remote_heads(fd[0], &ref, 0, NULL, 0);
568 if (is_repository_shallow() && !server_supports("shallow"))
569 die("Server does not support shallow clients");
570 if (server_supports("multi_ack")) {
571 if (args.verbose)
572 fprintf(stderr, "Server supports multi_ack\n");
573 multi_ack = 1;
574 }
575 if (server_supports("side-band-64k")) {
576 if (args.verbose)
577 fprintf(stderr, "Server supports side-band-64k\n");
578 use_sideband = 2;
579 }
580 else if (server_supports("side-band")) {
581 if (args.verbose)
582 fprintf(stderr, "Server supports side-band\n");
583 use_sideband = 1;
584 }
585 if (!ref) {
586 packet_flush(fd[1]);
587 die("no matching remote head");
588 }
589 if (everything_local(&ref, nr_match, match)) {
590 packet_flush(fd[1]);
591 goto all_done;
592 }
593 if (find_common(fd, sha1, ref) < 0)
594 if (!args.keep_pack)
595 /* When cloning, it is not unusual to have
596 * no common commit.
597 */
598 fprintf(stderr, "warning: no common commits\n");
599
600 if (get_pack(fd, pack_lockfile))
601 die("git-fetch-pack: fetch failed.");
602
603 all_done:
604 return ref;
605 }
606
607 static int remove_duplicates(int nr_heads, char **heads)
608 {
609 int src, dst;
610
611 for (src = dst = 0; src < nr_heads; src++) {
612 /* If heads[src] is different from any of
613 * heads[0..dst], push it in.
614 */
615 int i;
616 for (i = 0; i < dst; i++) {
617 if (!strcmp(heads[i], heads[src]))
618 break;
619 }
620 if (i < dst)
621 continue;
622 if (src != dst)
623 heads[dst] = heads[src];
624 dst++;
625 }
626 return dst;
627 }
628
629 static int fetch_pack_config(const char *var, const char *value)
630 {
631 if (strcmp(var, "fetch.unpacklimit") == 0) {
632 fetch_unpack_limit = git_config_int(var, value);
633 return 0;
634 }
635
636 if (strcmp(var, "transfer.unpacklimit") == 0) {
637 transfer_unpack_limit = git_config_int(var, value);
638 return 0;
639 }
640
641 return git_default_config(var, value);
642 }
643
644 static struct lock_file lock;
645
646 static void fetch_pack_setup(void)
647 {
648 static int did_setup;
649 if (did_setup)
650 return;
651 git_config(fetch_pack_config);
652 if (0 <= transfer_unpack_limit)
653 unpack_limit = transfer_unpack_limit;
654 else if (0 <= fetch_unpack_limit)
655 unpack_limit = fetch_unpack_limit;
656 did_setup = 1;
657 }
658
659 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
660 {
661 int i, ret, nr_heads;
662 struct ref *ref;
663 char *dest = NULL, **heads;
664
665 nr_heads = 0;
666 heads = NULL;
667 for (i = 1; i < argc; i++) {
668 const char *arg = argv[i];
669
670 if (*arg == '-') {
671 if (!prefixcmp(arg, "--upload-pack=")) {
672 args.uploadpack = arg + 14;
673 continue;
674 }
675 if (!prefixcmp(arg, "--exec=")) {
676 args.uploadpack = arg + 7;
677 continue;
678 }
679 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
680 args.quiet = 1;
681 continue;
682 }
683 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
684 args.lock_pack = args.keep_pack;
685 args.keep_pack = 1;
686 continue;
687 }
688 if (!strcmp("--thin", arg)) {
689 args.use_thin_pack = 1;
690 continue;
691 }
692 if (!strcmp("--all", arg)) {
693 args.fetch_all = 1;
694 continue;
695 }
696 if (!strcmp("-v", arg)) {
697 args.verbose = 1;
698 continue;
699 }
700 if (!prefixcmp(arg, "--depth=")) {
701 args.depth = strtol(arg + 8, NULL, 0);
702 continue;
703 }
704 if (!strcmp("--no-progress", arg)) {
705 args.no_progress = 1;
706 continue;
707 }
708 usage(fetch_pack_usage);
709 }
710 dest = (char *)arg;
711 heads = (char **)(argv + i + 1);
712 nr_heads = argc - i - 1;
713 break;
714 }
715 if (!dest)
716 usage(fetch_pack_usage);
717
718 ref = fetch_pack(&args, dest, nr_heads, heads, NULL);
719 ret = !ref;
720
721 while (ref) {
722 printf("%s %s\n",
723 sha1_to_hex(ref->old_sha1), ref->name);
724 ref = ref->next;
725 }
726
727 return ret;
728 }
729
730 struct ref *fetch_pack(struct fetch_pack_args *my_args,
731 const char *dest,
732 int nr_heads,
733 char **heads,
734 char **pack_lockfile)
735 {
736 int i, ret;
737 int fd[2];
738 struct child_process *conn;
739 struct ref *ref;
740 struct stat st;
741
742 fetch_pack_setup();
743 memcpy(&args, my_args, sizeof(args));
744 if (args.depth > 0) {
745 if (stat(git_path("shallow"), &st))
746 st.st_mtime = 0;
747 }
748
749 conn = git_connect(fd, (char *)dest, uploadpack,
750 args.verbose ? CONNECT_VERBOSE : 0);
751 if (heads && nr_heads)
752 nr_heads = remove_duplicates(nr_heads, heads);
753 ref = do_fetch_pack(fd, nr_heads, heads, pack_lockfile);
754 close(fd[0]);
755 close(fd[1]);
756 ret = finish_connect(conn);
757
758 if (!ret && nr_heads) {
759 /* If the heads to pull were given, we should have
760 * consumed all of them by matching the remote.
761 * Otherwise, 'git-fetch remote no-such-ref' would
762 * silently succeed without issuing an error.
763 */
764 for (i = 0; i < nr_heads; i++)
765 if (heads[i] && heads[i][0]) {
766 error("no such remote ref %s", heads[i]);
767 ret = 1;
768 }
769 }
770
771 if (!ret && args.depth > 0) {
772 struct cache_time mtime;
773 char *shallow = git_path("shallow");
774 int fd;
775
776 mtime.sec = st.st_mtime;
777 #ifdef USE_NSEC
778 mtime.usec = st.st_mtim.usec;
779 #endif
780 if (stat(shallow, &st)) {
781 if (mtime.sec)
782 die("shallow file was removed during fetch");
783 } else if (st.st_mtime != mtime.sec
784 #ifdef USE_NSEC
785 || st.st_mtim.usec != mtime.usec
786 #endif
787 )
788 die("shallow file was changed during fetch");
789
790 fd = hold_lock_file_for_update(&lock, shallow, 1);
791 if (!write_shallow_commits(fd, 0)) {
792 unlink(shallow);
793 rollback_lock_file(&lock);
794 } else {
795 close(fd);
796 commit_lock_file(&lock);
797 }
798 }
799
800 if (ret)
801 ref = NULL;
802
803 return ref;
804 }