2 #include "bundle-uri.h"
5 #include "object-store.h"
7 #include "run-command.h"
14 enum bundle_list_heuristic heuristic
;
16 } heuristics
[BUNDLE_HEURISTIC__COUNT
] = {
17 { BUNDLE_HEURISTIC_NONE
, ""},
18 { BUNDLE_HEURISTIC_CREATIONTOKEN
, "creationToken" },
21 static int compare_bundles(const void *hashmap_cmp_fn_data
,
22 const struct hashmap_entry
*he1
,
23 const struct hashmap_entry
*he2
,
26 const struct remote_bundle_info
*e1
=
27 container_of(he1
, const struct remote_bundle_info
, ent
);
28 const struct remote_bundle_info
*e2
=
29 container_of(he2
, const struct remote_bundle_info
, ent
);
31 return strcmp(e1
->id
, id
? (const char *)id
: e2
->id
);
34 void init_bundle_list(struct bundle_list
*list
)
36 memset(list
, 0, sizeof(*list
));
38 /* Implied defaults. */
39 list
->mode
= BUNDLE_MODE_ALL
;
42 hashmap_init(&list
->bundles
, compare_bundles
, NULL
, 0);
45 static int clear_remote_bundle_info(struct remote_bundle_info
*bundle
,
48 FREE_AND_NULL(bundle
->id
);
49 FREE_AND_NULL(bundle
->uri
);
50 FREE_AND_NULL(bundle
->file
);
51 bundle
->unbundled
= 0;
55 void clear_bundle_list(struct bundle_list
*list
)
60 for_all_bundles_in_list(list
, clear_remote_bundle_info
, NULL
);
61 hashmap_clear_and_free(&list
->bundles
, struct remote_bundle_info
, ent
);
65 int for_all_bundles_in_list(struct bundle_list
*list
,
69 struct remote_bundle_info
*info
;
70 struct hashmap_iter i
;
72 hashmap_for_each_entry(&list
->bundles
, &i
, info
, ent
) {
73 int result
= iter(info
, data
);
82 static int summarize_bundle(struct remote_bundle_info
*info
, void *data
)
85 fprintf(fp
, "[bundle \"%s\"]\n", info
->id
);
86 fprintf(fp
, "\turi = %s\n", info
->uri
);
88 if (info
->creationToken
)
89 fprintf(fp
, "\tcreationToken = %"PRIu64
"\n", info
->creationToken
);
93 void print_bundle_list(FILE *fp
, struct bundle_list
*list
)
102 case BUNDLE_MODE_ANY
:
106 case BUNDLE_MODE_NONE
:
111 fprintf(fp
, "[bundle]\n");
112 fprintf(fp
, "\tversion = %d\n", list
->version
);
113 fprintf(fp
, "\tmode = %s\n", mode
);
115 if (list
->heuristic
) {
117 for (i
= 0; i
< BUNDLE_HEURISTIC__COUNT
; i
++) {
118 if (heuristics
[i
].heuristic
== list
->heuristic
) {
119 printf("\theuristic = %s\n",
120 heuristics
[list
->heuristic
].name
);
126 for_all_bundles_in_list(list
, summarize_bundle
, fp
);
130 * Given a key-value pair, update the state of the given bundle list.
131 * Returns 0 if the key-value pair is understood. Returns -1 if the key
132 * is not understood or the value is malformed.
134 static int bundle_list_update(const char *key
, const char *value
,
135 struct bundle_list
*list
)
137 struct strbuf id
= STRBUF_INIT
;
138 struct remote_bundle_info lookup
= REMOTE_BUNDLE_INFO_INIT
;
139 struct remote_bundle_info
*bundle
;
140 const char *subsection
, *subkey
;
141 size_t subsection_len
;
143 if (parse_config_key(key
, "bundle", &subsection
, &subsection_len
, &subkey
))
146 if (!subsection_len
) {
147 if (!strcmp(subkey
, "version")) {
149 if (!git_parse_int(value
, &version
))
154 list
->version
= version
;
158 if (!strcmp(subkey
, "mode")) {
159 if (!strcmp(value
, "all"))
160 list
->mode
= BUNDLE_MODE_ALL
;
161 else if (!strcmp(value
, "any"))
162 list
->mode
= BUNDLE_MODE_ANY
;
168 if (!strcmp(subkey
, "heuristic")) {
170 for (i
= 0; i
< BUNDLE_HEURISTIC__COUNT
; i
++) {
171 if (heuristics
[i
].heuristic
&&
172 heuristics
[i
].name
&&
173 !strcmp(value
, heuristics
[i
].name
)) {
174 list
->heuristic
= heuristics
[i
].heuristic
;
179 /* Ignore unknown heuristics. */
183 /* Ignore other unknown global keys. */
187 strbuf_add(&id
, subsection
, subsection_len
);
190 * Check for an existing bundle with this <id>, or create one
194 hashmap_entry_init(&lookup
.ent
, strhash(lookup
.id
));
195 if (!(bundle
= hashmap_get_entry(&list
->bundles
, &lookup
, ent
, NULL
))) {
196 CALLOC_ARRAY(bundle
, 1);
197 bundle
->id
= strbuf_detach(&id
, NULL
);
198 hashmap_entry_init(&bundle
->ent
, strhash(bundle
->id
));
199 hashmap_add(&list
->bundles
, &bundle
->ent
);
203 if (!strcmp(subkey
, "uri")) {
206 bundle
->uri
= relative_url(list
->baseURI
, value
, NULL
);
210 if (!strcmp(subkey
, "creationtoken")) {
211 if (sscanf(value
, "%"PRIu64
, &bundle
->creationToken
) != 1)
212 warning(_("could not parse bundle list key %s with value '%s'"),
213 "creationToken", value
);
218 * At this point, we ignore any information that we don't
219 * understand, assuming it to be hints for a heuristic the client
220 * does not currently understand.
225 static int config_to_bundle_list(const char *key
, const char *value
, void *data
)
227 struct bundle_list
*list
= data
;
228 return bundle_list_update(key
, value
, list
);
231 int bundle_uri_parse_config_format(const char *uri
,
232 const char *filename
,
233 struct bundle_list
*list
)
236 struct config_options opts
= {
237 .error_action
= CONFIG_ERROR_ERROR
,
240 if (!list
->baseURI
) {
241 struct strbuf baseURI
= STRBUF_INIT
;
242 strbuf_addstr(&baseURI
, uri
);
245 * If the URI does not end with a trailing slash, then
246 * remove the filename portion of the path. This is
247 * important for relative URIs.
249 strbuf_strip_file_from_path(&baseURI
);
250 list
->baseURI
= strbuf_detach(&baseURI
, NULL
);
252 result
= git_config_from_file_with_options(config_to_bundle_list
,
256 if (!result
&& list
->mode
== BUNDLE_MODE_NONE
) {
257 warning(_("bundle list at '%s' has no mode"), uri
);
264 static char *find_temp_filename(void)
267 struct strbuf name
= STRBUF_INIT
;
269 * Find a temporary filename that is available. This is briefly
270 * racy, but unlikely to collide.
272 fd
= odb_mkstemp(&name
, "bundles/tmp_uri_XXXXXX");
274 warning(_("failed to create temporary file"));
280 return strbuf_detach(&name
, NULL
);
283 static int download_https_uri_to_file(const char *file
, const char *uri
)
286 struct child_process cp
= CHILD_PROCESS_INIT
;
287 FILE *child_in
= NULL
, *child_out
= NULL
;
288 struct strbuf line
= STRBUF_INIT
;
291 strvec_pushl(&cp
.args
, "git-remote-https", uri
, NULL
);
296 if (start_command(&cp
))
299 child_in
= fdopen(cp
.in
, "w");
305 child_out
= fdopen(cp
.out
, "r");
311 fprintf(child_in
, "capabilities\n");
314 while (!strbuf_getline(&line
, child_out
)) {
317 if (!strcmp(line
.buf
, "get"))
320 strbuf_release(&line
);
323 result
= error(_("insufficient capabilities"));
327 fprintf(child_in
, "get %s %s\n\n", uri
, file
);
332 if (finish_command(&cp
))
339 static int copy_uri_to_file(const char *filename
, const char *uri
)
343 if (starts_with(uri
, "https:") ||
344 starts_with(uri
, "http:"))
345 return download_https_uri_to_file(filename
, uri
);
347 if (skip_prefix(uri
, "file://", &out
))
351 return copy_file(filename
, uri
, 0);
354 static int unbundle_from_file(struct repository
*r
, const char *file
)
358 struct bundle_header header
= BUNDLE_HEADER_INIT
;
359 struct string_list_item
*refname
;
360 struct strbuf bundle_ref
= STRBUF_INIT
;
361 size_t bundle_prefix_len
;
363 if ((bundle_fd
= read_bundle_header(file
, &header
)) < 0)
367 * Skip the reachability walk here, since we will be adding
368 * a reachable ref pointing to the new tips, which will reach
369 * the prerequisite commits.
371 if ((result
= unbundle(r
, &header
, bundle_fd
, NULL
,
372 VERIFY_BUNDLE_QUIET
)))
376 * Convert all refs/heads/ from the bundle into refs/bundles/
377 * in the local repository.
379 strbuf_addstr(&bundle_ref
, "refs/bundles/");
380 bundle_prefix_len
= bundle_ref
.len
;
382 for_each_string_list_item(refname
, &header
.references
) {
383 struct object_id
*oid
= refname
->util
;
384 struct object_id old_oid
;
385 const char *branch_name
;
388 if (!skip_prefix(refname
->string
, "refs/heads/", &branch_name
))
391 strbuf_setlen(&bundle_ref
, bundle_prefix_len
);
392 strbuf_addstr(&bundle_ref
, branch_name
);
394 has_old
= !read_ref(bundle_ref
.buf
, &old_oid
);
395 update_ref("fetched bundle", bundle_ref
.buf
, oid
,
396 has_old
? &old_oid
: NULL
,
397 REF_SKIP_OID_VERIFICATION
,
398 UPDATE_REFS_MSG_ON_ERR
);
401 bundle_header_release(&header
);
405 struct bundle_list_context
{
406 struct repository
*r
;
407 struct bundle_list
*list
;
408 enum bundle_list_mode mode
;
414 * This early definition is necessary because we use indirect recursion:
416 * While iterating through a bundle list that was downloaded as part
417 * of fetch_bundle_uri_internal(), iterator methods eventually call it
418 * again, but with depth + 1.
420 static int fetch_bundle_uri_internal(struct repository
*r
,
421 struct remote_bundle_info
*bundle
,
423 struct bundle_list
*list
);
425 static int download_bundle_to_file(struct remote_bundle_info
*bundle
, void *data
)
428 struct bundle_list_context
*ctx
= data
;
430 if (ctx
->mode
== BUNDLE_MODE_ANY
&& ctx
->count
)
433 res
= fetch_bundle_uri_internal(ctx
->r
, bundle
, ctx
->depth
+ 1, ctx
->list
);
436 * Only increment count if the download succeeded. If our mode is
437 * BUNDLE_MODE_ANY, then we will want to try other URIs in the
438 * list in case they work instead.
444 * To be opportunistic as possible, we continue iterating and
445 * download as many bundles as we can, so we can apply the ones
446 * that work, even in BUNDLE_MODE_ALL mode.
451 struct bundles_for_sorting
{
452 struct remote_bundle_info
**items
;
457 static int append_bundle(struct remote_bundle_info
*bundle
, void *data
)
459 struct bundles_for_sorting
*list
= data
;
460 list
->items
[list
->nr
++] = bundle
;
465 * For use in QSORT() to get a list sorted by creationToken
466 * in decreasing order.
468 static int compare_creation_token_decreasing(const void *va
, const void *vb
)
470 const struct remote_bundle_info
* const *a
= va
;
471 const struct remote_bundle_info
* const *b
= vb
;
473 if ((*a
)->creationToken
> (*b
)->creationToken
)
475 if ((*a
)->creationToken
< (*b
)->creationToken
)
480 static int fetch_bundles_by_token(struct repository
*r
,
481 struct bundle_list
*list
)
484 int move_direction
= 0;
485 const char *creationTokenStr
;
486 uint64_t maxCreationToken
= 0, newMaxCreationToken
= 0;
487 struct bundle_list_context ctx
= {
492 struct bundles_for_sorting bundles
= {
493 .alloc
= hashmap_get_size(&list
->bundles
),
496 ALLOC_ARRAY(bundles
.items
, bundles
.alloc
);
498 for_all_bundles_in_list(list
, append_bundle
, &bundles
);
505 QSORT(bundles
.items
, bundles
.nr
, compare_creation_token_decreasing
);
508 * If fetch.bundleCreationToken exists, parses to a uint64t, and
509 * is not strictly smaller than the maximum creation token in the
510 * bundle list, then do not download any bundles.
512 if (!repo_config_get_value(r
,
513 "fetch.bundlecreationtoken",
514 &creationTokenStr
) &&
515 sscanf(creationTokenStr
, "%"PRIu64
, &maxCreationToken
) == 1 &&
516 bundles
.items
[0]->creationToken
<= maxCreationToken
) {
522 * Attempt to download and unbundle the minimum number of bundles by
523 * creationToken in decreasing order. If we fail to unbundle (after
524 * a successful download) then move to the next non-downloaded bundle
525 * and attempt downloading. Once we succeed in applying a bundle,
526 * move to the previous unapplied bundle and attempt to unbundle it
529 * In the case of a fresh clone, we will likely download all of the
530 * bundles before successfully unbundling the oldest one, then the
531 * rest of the bundles unbundle successfully in increasing order
534 * If there are existing objects, then this process may terminate
535 * early when all required commits from "new" bundles exist in the
536 * repo's object store.
539 while (cur
>= 0 && cur
< bundles
.nr
) {
540 struct remote_bundle_info
*bundle
= bundles
.items
[cur
];
543 * If we need to dig into bundles below the previous
544 * creation token value, then likely we are in an erroneous
545 * state due to missing or invalid bundles. Halt the process
546 * instead of continuing to download extra data.
548 if (bundle
->creationToken
<= maxCreationToken
)
553 * Not downloaded yet. Try downloading.
555 * Note that bundle->file is non-NULL if a download
556 * was attempted, even if it failed to download.
558 if (fetch_bundle_uri_internal(ctx
.r
, bundle
, ctx
.depth
+ 1, ctx
.list
)) {
559 /* Mark as unbundled so we do not retry. */
560 bundle
->unbundled
= 1;
562 /* Try looking deeper in the list. */
567 /* We expect bundles when using creationTokens. */
568 if (!is_bundle(bundle
->file
, 1)) {
569 warning(_("file downloaded from '%s' is not a bundle"),
575 if (bundle
->file
&& !bundle
->unbundled
) {
577 * This was downloaded, but not successfully
578 * unbundled. Try unbundling again.
580 if (unbundle_from_file(ctx
.r
, bundle
->file
)) {
581 /* Try looking deeper in the list. */
585 * Succeeded in unbundle. Retry bundles
586 * that previously failed to unbundle.
589 bundle
->unbundled
= 1;
591 if (bundle
->creationToken
> newMaxCreationToken
)
592 newMaxCreationToken
= bundle
->creationToken
;
597 * Else case: downloaded and unbundled successfully.
598 * Skip this by moving in the same direction as the
603 /* Move in the specified direction and repeat. */
604 cur
+= move_direction
;
608 * We succeed if the loop terminates because 'cur' drops below
609 * zero. The other case is that we terminate because 'cur'
610 * reaches the end of the list, so we have a failure no matter
611 * which bundles we apply from the list.
614 struct strbuf value
= STRBUF_INIT
;
615 strbuf_addf(&value
, "%"PRIu64
"", newMaxCreationToken
);
616 if (repo_config_set_multivar_gently(ctx
.r
,
617 "fetch.bundleCreationToken",
619 warning(_("failed to store maximum creation token"));
621 strbuf_release(&value
);
628 static int download_bundle_list(struct repository
*r
,
629 struct bundle_list
*local_list
,
630 struct bundle_list
*global_list
,
633 struct bundle_list_context ctx
= {
637 .mode
= local_list
->mode
,
640 return for_all_bundles_in_list(local_list
, download_bundle_to_file
, &ctx
);
643 static int fetch_bundle_list_in_config_format(struct repository
*r
,
644 struct bundle_list
*global_list
,
645 struct remote_bundle_info
*bundle
,
649 struct bundle_list list_from_bundle
;
651 init_bundle_list(&list_from_bundle
);
653 if ((result
= bundle_uri_parse_config_format(bundle
->uri
,
658 if (list_from_bundle
.mode
== BUNDLE_MODE_NONE
) {
659 warning(_("unrecognized bundle mode from URI '%s'"),
666 * If this list uses the creationToken heuristic, then the URIs
667 * it advertises are expected to be bundles, not nested lists.
668 * We can drop 'global_list' and 'depth'.
670 if (list_from_bundle
.heuristic
== BUNDLE_HEURISTIC_CREATIONTOKEN
) {
671 result
= fetch_bundles_by_token(r
, &list_from_bundle
);
672 global_list
->heuristic
= BUNDLE_HEURISTIC_CREATIONTOKEN
;
673 } else if ((result
= download_bundle_list(r
, &list_from_bundle
,
674 global_list
, depth
)))
678 clear_bundle_list(&list_from_bundle
);
683 * This limits the recursion on fetch_bundle_uri_internal() when following
686 static int max_bundle_uri_depth
= 4;
689 * Recursively download all bundles advertised at the given URI
690 * to files. If the file is a bundle, then add it to the given
691 * 'list'. Otherwise, expect a bundle list and recurse on the
692 * URIs in that list according to the list mode (ANY or ALL).
694 static int fetch_bundle_uri_internal(struct repository
*r
,
695 struct remote_bundle_info
*bundle
,
697 struct bundle_list
*list
)
700 struct remote_bundle_info
*bcopy
;
702 if (depth
>= max_bundle_uri_depth
) {
703 warning(_("exceeded bundle URI recursion limit (%d)"),
704 max_bundle_uri_depth
);
709 !(bundle
->file
= find_temp_filename())) {
714 if ((result
= copy_uri_to_file(bundle
->file
, bundle
->uri
))) {
715 warning(_("failed to download bundle from URI '%s'"), bundle
->uri
);
719 if ((result
= !is_bundle(bundle
->file
, 1))) {
720 result
= fetch_bundle_list_in_config_format(
721 r
, list
, bundle
, depth
);
723 warning(_("file at URI '%s' is not a bundle or bundle list"),
728 /* Copy the bundle and insert it into the global list. */
729 CALLOC_ARRAY(bcopy
, 1);
730 bcopy
->id
= xstrdup(bundle
->id
);
731 bcopy
->file
= xstrdup(bundle
->file
);
732 hashmap_entry_init(&bcopy
->ent
, strhash(bcopy
->id
));
733 hashmap_add(&list
->bundles
, &bcopy
->ent
);
736 if (result
&& bundle
->file
)
737 unlink(bundle
->file
);
742 * This loop iterator breaks the loop with nonzero return code on the
743 * first successful unbundling of a bundle.
745 static int attempt_unbundle(struct remote_bundle_info
*info
, void *data
)
747 struct repository
*r
= data
;
749 if (!info
->file
|| info
->unbundled
)
752 if (!unbundle_from_file(r
, info
->file
)) {
760 static int unbundle_all_bundles(struct repository
*r
,
761 struct bundle_list
*list
)
764 * Iterate through all bundles looking for ones that can
765 * successfully unbundle. If any succeed, then perhaps another
766 * will succeed in the next attempt.
768 * Keep in mind that a non-zero result for the loop here means
769 * the loop terminated early on a successful unbundling, which
770 * signals that we can try again.
772 while (for_all_bundles_in_list(list
, attempt_unbundle
, r
)) ;
777 static int unlink_bundle(struct remote_bundle_info
*info
, void *data
)
780 unlink_or_warn(info
->file
);
784 int fetch_bundle_uri(struct repository
*r
, const char *uri
,
788 struct bundle_list list
;
789 struct remote_bundle_info bundle
= {
794 init_bundle_list(&list
);
796 /* If a bundle is added to this global list, then it is required. */
797 list
.mode
= BUNDLE_MODE_ALL
;
799 if ((result
= fetch_bundle_uri_internal(r
, &bundle
, 0, &list
)))
802 result
= unbundle_all_bundles(r
, &list
);
806 *has_heuristic
= (list
.heuristic
!= BUNDLE_HEURISTIC_NONE
);
807 for_all_bundles_in_list(&list
, unlink_bundle
, NULL
);
808 clear_bundle_list(&list
);
809 clear_remote_bundle_info(&bundle
, NULL
);
813 int fetch_bundle_list(struct repository
*r
, struct bundle_list
*list
)
816 struct bundle_list global_list
;
819 * If the creationToken heuristic is used, then the URIs
820 * advertised by 'list' are not nested lists and instead
821 * direct bundles. We do not need to use global_list.
823 if (list
->heuristic
== BUNDLE_HEURISTIC_CREATIONTOKEN
)
824 return fetch_bundles_by_token(r
, list
);
826 init_bundle_list(&global_list
);
828 /* If a bundle is added to this global list, then it is required. */
829 global_list
.mode
= BUNDLE_MODE_ALL
;
831 if ((result
= download_bundle_list(r
, list
, &global_list
, 0)))
834 if (list
->heuristic
== BUNDLE_HEURISTIC_CREATIONTOKEN
)
835 result
= fetch_bundles_by_token(r
, list
);
837 result
= unbundle_all_bundles(r
, &global_list
);
840 for_all_bundles_in_list(&global_list
, unlink_bundle
, NULL
);
841 clear_bundle_list(&global_list
);
849 int bundle_uri_advertise(struct repository
*r
, struct strbuf
*value UNUSED
)
851 static int advertise_bundle_uri
= -1;
853 if (advertise_bundle_uri
!= -1)
856 advertise_bundle_uri
= 0;
857 repo_config_get_maybe_bool(r
, "uploadpack.advertisebundleuris", &advertise_bundle_uri
);
860 return advertise_bundle_uri
;
863 static int config_to_packet_line(const char *key
, const char *value
, void *data
)
865 struct packet_reader
*writer
= data
;
867 if (starts_with(key
, "bundle."))
868 packet_write_fmt(writer
->fd
, "%s=%s", key
, value
);
873 int bundle_uri_command(struct repository
*r
,
874 struct packet_reader
*request
)
876 struct packet_writer writer
;
877 packet_writer_init(&writer
, 1);
879 while (packet_reader_read(request
) == PACKET_READ_NORMAL
)
880 die(_("bundle-uri: unexpected argument: '%s'"), request
->line
);
881 if (request
->status
!= PACKET_READ_FLUSH
)
882 die(_("bundle-uri: expected flush after arguments"));
885 * Read all "bundle.*" config lines to the client as key=value
888 repo_config(r
, config_to_packet_line
, &writer
);
890 packet_writer_flush(&writer
);
896 * General API for {transport,connect}.c etc.
898 int bundle_uri_parse_line(struct bundle_list
*list
, const char *line
)
902 struct strbuf key
= STRBUF_INIT
;
905 return error(_("bundle-uri: got an empty line"));
907 equals
= strchr(line
, '=');
910 return error(_("bundle-uri: line is not of the form 'key=value'"));
911 if (line
== equals
|| !*(equals
+ 1))
912 return error(_("bundle-uri: line has empty key or value"));
914 strbuf_add(&key
, line
, equals
- line
);
915 result
= bundle_list_update(key
.buf
, equals
+ 1, list
);
916 strbuf_release(&key
);