4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>,
5 * 2008 Daniel Barkalow <barkalow@iabervon.org>
6 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
8 * Clone a repository into a different directory that does not yet exist.
11 #define USE_THE_INDEX_COMPATIBILITY_MACROS
15 #include "parse-options.h"
16 #include "fetch-pack.h"
19 #include "object-store.h"
21 #include "tree-walk.h"
22 #include "unpack-trees.h"
23 #include "transport.h"
26 #include "dir-iterator.h"
31 #include "run-command.h"
32 #include "connected.h"
34 #include "list-objects-filter-options.h"
38 * - respect DB_ENVIRONMENT for .git/objects.
40 * Implementation notes:
41 * - dropping use-separate-remote and no-separate-remote compatibility
44 static const char * const builtin_clone_usage
[] = {
45 N_("git clone [<options>] [--] <repo> [<dir>]"),
49 static int option_no_checkout
, option_bare
, option_mirror
, option_single_branch
= -1;
50 static int option_local
= -1, option_no_hardlinks
, option_shared
;
51 static int option_no_tags
;
52 static int option_shallow_submodules
;
54 static char *option_template
, *option_depth
, *option_since
;
55 static char *option_origin
= NULL
;
56 static char *remote_name
= NULL
;
57 static char *option_branch
= NULL
;
58 static struct string_list option_not
= STRING_LIST_INIT_NODUP
;
59 static const char *real_git_dir
;
60 static char *option_upload_pack
= "git-upload-pack";
61 static int option_verbosity
;
62 static int option_progress
= -1;
63 static int option_sparse_checkout
;
64 static enum transport_family family
;
65 static struct string_list option_config
= STRING_LIST_INIT_NODUP
;
66 static struct string_list option_required_reference
= STRING_LIST_INIT_NODUP
;
67 static struct string_list option_optional_reference
= STRING_LIST_INIT_NODUP
;
68 static int option_dissociate
;
69 static int max_jobs
= -1;
70 static struct string_list option_recurse_submodules
= STRING_LIST_INIT_NODUP
;
71 static struct list_objects_filter_options filter_options
;
72 static struct string_list server_options
= STRING_LIST_INIT_NODUP
;
73 static int option_remote_submodules
;
75 static int recurse_submodules_cb(const struct option
*opt
,
76 const char *arg
, int unset
)
79 string_list_clear((struct string_list
*)opt
->value
, 0);
81 string_list_append((struct string_list
*)opt
->value
, arg
);
83 string_list_append((struct string_list
*)opt
->value
,
84 (const char *)opt
->defval
);
89 static struct option builtin_clone_options
[] = {
90 OPT__VERBOSITY(&option_verbosity
),
91 OPT_BOOL(0, "progress", &option_progress
,
92 N_("force progress reporting")),
93 OPT_BOOL('n', "no-checkout", &option_no_checkout
,
94 N_("don't create a checkout")),
95 OPT_BOOL(0, "bare", &option_bare
, N_("create a bare repository")),
96 OPT_HIDDEN_BOOL(0, "naked", &option_bare
,
97 N_("create a bare repository")),
98 OPT_BOOL(0, "mirror", &option_mirror
,
99 N_("create a mirror repository (implies bare)")),
100 OPT_BOOL('l', "local", &option_local
,
101 N_("to clone from a local repository")),
102 OPT_BOOL(0, "no-hardlinks", &option_no_hardlinks
,
103 N_("don't use local hardlinks, always copy")),
104 OPT_BOOL('s', "shared", &option_shared
,
105 N_("setup as shared repository")),
106 { OPTION_CALLBACK
, 0, "recurse-submodules", &option_recurse_submodules
,
107 N_("pathspec"), N_("initialize submodules in the clone"),
108 PARSE_OPT_OPTARG
, recurse_submodules_cb
, (intptr_t)"." },
109 OPT_ALIAS(0, "recursive", "recurse-submodules"),
110 OPT_INTEGER('j', "jobs", &max_jobs
,
111 N_("number of submodules cloned in parallel")),
112 OPT_STRING(0, "template", &option_template
, N_("template-directory"),
113 N_("directory from which templates will be used")),
114 OPT_STRING_LIST(0, "reference", &option_required_reference
, N_("repo"),
115 N_("reference repository")),
116 OPT_STRING_LIST(0, "reference-if-able", &option_optional_reference
,
117 N_("repo"), N_("reference repository")),
118 OPT_BOOL(0, "dissociate", &option_dissociate
,
119 N_("use --reference only while cloning")),
120 OPT_STRING('o', "origin", &option_origin
, N_("name"),
121 N_("use <name> instead of 'origin' to track upstream")),
122 OPT_STRING('b', "branch", &option_branch
, N_("branch"),
123 N_("checkout <branch> instead of the remote's HEAD")),
124 OPT_STRING('u', "upload-pack", &option_upload_pack
, N_("path"),
125 N_("path to git-upload-pack on the remote")),
126 OPT_STRING(0, "depth", &option_depth
, N_("depth"),
127 N_("create a shallow clone of that depth")),
128 OPT_STRING(0, "shallow-since", &option_since
, N_("time"),
129 N_("create a shallow clone since a specific time")),
130 OPT_STRING_LIST(0, "shallow-exclude", &option_not
, N_("revision"),
131 N_("deepen history of shallow clone, excluding rev")),
132 OPT_BOOL(0, "single-branch", &option_single_branch
,
133 N_("clone only one branch, HEAD or --branch")),
134 OPT_BOOL(0, "no-tags", &option_no_tags
,
135 N_("don't clone any tags, and make later fetches not to follow them")),
136 OPT_BOOL(0, "shallow-submodules", &option_shallow_submodules
,
137 N_("any cloned submodules will be shallow")),
138 OPT_STRING(0, "separate-git-dir", &real_git_dir
, N_("gitdir"),
139 N_("separate git dir from working tree")),
140 OPT_STRING_LIST('c', "config", &option_config
, N_("key=value"),
141 N_("set config inside the new repository")),
142 OPT_STRING_LIST(0, "server-option", &server_options
,
143 N_("server-specific"), N_("option to transmit")),
144 OPT_SET_INT('4', "ipv4", &family
, N_("use IPv4 addresses only"),
145 TRANSPORT_FAMILY_IPV4
),
146 OPT_SET_INT('6', "ipv6", &family
, N_("use IPv6 addresses only"),
147 TRANSPORT_FAMILY_IPV6
),
148 OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options
),
149 OPT_BOOL(0, "remote-submodules", &option_remote_submodules
,
150 N_("any cloned submodules will use their remote-tracking branch")),
151 OPT_BOOL(0, "sparse", &option_sparse_checkout
,
152 N_("initialize sparse-checkout file to include only files at root")),
156 static const char *get_repo_path_1(struct strbuf
*path
, int *is_bundle
)
158 static char *suffix
[] = { "/.git", "", ".git/.git", ".git" };
159 static char *bundle_suffix
[] = { ".bundle", "" };
160 size_t baselen
= path
->len
;
164 for (i
= 0; i
< ARRAY_SIZE(suffix
); i
++) {
165 strbuf_setlen(path
, baselen
);
166 strbuf_addstr(path
, suffix
[i
]);
167 if (stat(path
->buf
, &st
))
169 if (S_ISDIR(st
.st_mode
) && is_git_directory(path
->buf
)) {
172 } else if (S_ISREG(st
.st_mode
) && st
.st_size
> 8) {
173 /* Is it a "gitfile"? */
176 int len
, fd
= open(path
->buf
, O_RDONLY
);
179 len
= read_in_full(fd
, signature
, 8);
181 if (len
!= 8 || strncmp(signature
, "gitdir: ", 8))
183 dst
= read_gitfile(path
->buf
);
191 for (i
= 0; i
< ARRAY_SIZE(bundle_suffix
); i
++) {
192 strbuf_setlen(path
, baselen
);
193 strbuf_addstr(path
, bundle_suffix
[i
]);
194 if (!stat(path
->buf
, &st
) && S_ISREG(st
.st_mode
)) {
203 static char *get_repo_path(const char *repo
, int *is_bundle
)
205 struct strbuf path
= STRBUF_INIT
;
209 strbuf_addstr(&path
, repo
);
210 raw
= get_repo_path_1(&path
, is_bundle
);
211 canon
= raw
? absolute_pathdup(raw
) : NULL
;
212 strbuf_release(&path
);
216 static char *guess_dir_name(const char *repo
, int is_bundle
, int is_bare
)
218 const char *end
= repo
+ strlen(repo
), *start
, *ptr
;
225 start
= strstr(repo
, "://");
232 * Skip authentication data. The stripping does happen
233 * greedily, such that we strip up to the last '@' inside
236 for (ptr
= start
; ptr
< end
&& !is_dir_sep(*ptr
); ptr
++) {
242 * Strip trailing spaces, slashes and /.git
244 while (start
< end
&& (is_dir_sep(end
[-1]) || isspace(end
[-1])))
246 if (end
- start
> 5 && is_dir_sep(end
[-5]) &&
247 !strncmp(end
- 4, ".git", 4)) {
249 while (start
< end
&& is_dir_sep(end
[-1]))
254 * Strip trailing port number if we've got only a
255 * hostname (that is, there is no dir separator but a
256 * colon). This check is required such that we do not
257 * strip URI's like '/foo/bar:2222.git', which should
258 * result in a dir '2222' being guessed due to backwards
261 if (memchr(start
, '/', end
- start
) == NULL
262 && memchr(start
, ':', end
- start
) != NULL
) {
264 while (start
< ptr
&& isdigit(ptr
[-1]) && ptr
[-1] != ':')
266 if (start
< ptr
&& ptr
[-1] == ':')
271 * Find last component. To remain backwards compatible we
272 * also regard colons as path separators, such that
273 * cloning a repository 'foo:bar.git' would result in a
274 * directory 'bar' being guessed.
277 while (start
< ptr
&& !is_dir_sep(ptr
[-1]) && ptr
[-1] != ':')
282 * Strip .{bundle,git}.
285 strip_suffix_mem(start
, &len
, is_bundle
? ".bundle" : ".git");
287 if (!len
|| (len
== 1 && *start
== '/'))
288 die(_("No directory name could be guessed.\n"
289 "Please specify a directory on the command line"));
292 dir
= xstrfmt("%.*s.git", (int)len
, start
);
294 dir
= xstrndup(start
, len
);
296 * Replace sequences of 'control' characters and whitespace
297 * with one ascii space, remove leading and trailing spaces.
301 int prev_space
= 1 /* strip leading whitespace */;
302 for (end
= dir
; *end
; ++end
) {
304 if ((unsigned char)ch
< '\x20')
315 if (out
> dir
&& prev_space
)
321 static void strip_trailing_slashes(char *dir
)
323 char *end
= dir
+ strlen(dir
);
325 while (dir
< end
- 1 && is_dir_sep(end
[-1]))
330 static int add_one_reference(struct string_list_item
*item
, void *cb_data
)
332 struct strbuf err
= STRBUF_INIT
;
333 int *required
= cb_data
;
334 char *ref_git
= compute_alternate_path(item
->string
, &err
);
341 _("info: Could not add alternate for '%s': %s\n"),
342 item
->string
, err
.buf
);
344 struct strbuf sb
= STRBUF_INIT
;
345 strbuf_addf(&sb
, "%s/objects", ref_git
);
346 add_to_alternates_file(sb
.buf
);
350 strbuf_release(&err
);
355 static void setup_reference(void)
358 for_each_string_list(&option_required_reference
,
359 add_one_reference
, &required
);
361 for_each_string_list(&option_optional_reference
,
362 add_one_reference
, &required
);
365 static void copy_alternates(struct strbuf
*src
, const char *src_repo
)
368 * Read from the source objects/info/alternates file
369 * and copy the entries to corresponding file in the
370 * destination repository with add_to_alternates_file().
371 * Both src and dst have "$path/objects/info/alternates".
373 * Instead of copying bit-for-bit from the original,
374 * we need to append to existing one so that the already
375 * created entry via "clone -s" is not lost, and also
376 * to turn entries with paths relative to the original
377 * absolute, so that they can be used in the new repository.
379 FILE *in
= xfopen(src
->buf
, "r");
380 struct strbuf line
= STRBUF_INIT
;
382 while (strbuf_getline(&line
, in
) != EOF
) {
384 if (!line
.len
|| line
.buf
[0] == '#')
386 if (is_absolute_path(line
.buf
)) {
387 add_to_alternates_file(line
.buf
);
390 abs_path
= mkpathdup("%s/objects/%s", src_repo
, line
.buf
);
391 if (!normalize_path_copy(abs_path
, abs_path
))
392 add_to_alternates_file(abs_path
);
394 warning("skipping invalid relative alternate: %s/%s",
398 strbuf_release(&line
);
402 static void mkdir_if_missing(const char *pathname
, mode_t mode
)
406 if (!mkdir(pathname
, mode
))
410 die_errno(_("failed to create directory '%s'"), pathname
);
411 else if (stat(pathname
, &st
))
412 die_errno(_("failed to stat '%s'"), pathname
);
413 else if (!S_ISDIR(st
.st_mode
))
414 die(_("%s exists and is not a directory"), pathname
);
417 static void copy_or_link_directory(struct strbuf
*src
, struct strbuf
*dest
,
418 const char *src_repo
)
420 int src_len
, dest_len
;
421 struct dir_iterator
*iter
;
423 struct strbuf realpath
= STRBUF_INIT
;
425 mkdir_if_missing(dest
->buf
, 0777);
427 iter
= dir_iterator_begin(src
->buf
, DIR_ITERATOR_PEDANTIC
);
430 die_errno(_("failed to start iterator over '%s'"), src
->buf
);
432 strbuf_addch(src
, '/');
434 strbuf_addch(dest
, '/');
435 dest_len
= dest
->len
;
437 while ((iter_status
= dir_iterator_advance(iter
)) == ITER_OK
) {
438 strbuf_setlen(src
, src_len
);
439 strbuf_addstr(src
, iter
->relative_path
);
440 strbuf_setlen(dest
, dest_len
);
441 strbuf_addstr(dest
, iter
->relative_path
);
443 if (S_ISLNK(iter
->st
.st_mode
))
444 die(_("symlink '%s' exists, refusing to clone with --local"),
445 iter
->relative_path
);
447 if (S_ISDIR(iter
->st
.st_mode
)) {
448 mkdir_if_missing(dest
->buf
, 0777);
452 /* Files that cannot be copied bit-for-bit... */
453 if (!fspathcmp(iter
->relative_path
, "info/alternates")) {
454 copy_alternates(src
, src_repo
);
458 if (unlink(dest
->buf
) && errno
!= ENOENT
)
459 die_errno(_("failed to unlink '%s'"), dest
->buf
);
460 if (!option_no_hardlinks
) {
461 strbuf_realpath(&realpath
, src
->buf
, 1);
462 if (!link(realpath
.buf
, dest
->buf
))
464 if (option_local
> 0)
465 die_errno(_("failed to create link '%s'"), dest
->buf
);
466 option_no_hardlinks
= 1;
468 if (copy_file_with_time(dest
->buf
, src
->buf
, 0666))
469 die_errno(_("failed to copy file to '%s'"), dest
->buf
);
472 if (iter_status
!= ITER_DONE
) {
473 strbuf_setlen(src
, src_len
);
474 die(_("failed to iterate over '%s'"), src
->buf
);
477 strbuf_release(&realpath
);
480 static void clone_local(const char *src_repo
, const char *dest_repo
)
483 struct strbuf alt
= STRBUF_INIT
;
484 get_common_dir(&alt
, src_repo
);
485 strbuf_addstr(&alt
, "/objects");
486 add_to_alternates_file(alt
.buf
);
487 strbuf_release(&alt
);
489 struct strbuf src
= STRBUF_INIT
;
490 struct strbuf dest
= STRBUF_INIT
;
491 get_common_dir(&src
, src_repo
);
492 get_common_dir(&dest
, dest_repo
);
493 strbuf_addstr(&src
, "/objects");
494 strbuf_addstr(&dest
, "/objects");
495 copy_or_link_directory(&src
, &dest
, src_repo
);
496 strbuf_release(&src
);
497 strbuf_release(&dest
);
500 if (0 <= option_verbosity
)
501 fprintf(stderr
, _("done.\n"));
504 static const char *junk_work_tree
;
505 static int junk_work_tree_flags
;
506 static const char *junk_git_dir
;
507 static int junk_git_dir_flags
;
512 } junk_mode
= JUNK_LEAVE_NONE
;
514 static const char junk_leave_repo_msg
[] =
515 N_("Clone succeeded, but checkout failed.\n"
516 "You can inspect what was checked out with 'git status'\n"
517 "and retry with 'git restore --source=HEAD :/'\n");
519 static void remove_junk(void)
521 struct strbuf sb
= STRBUF_INIT
;
524 case JUNK_LEAVE_REPO
:
525 warning("%s", _(junk_leave_repo_msg
));
530 /* proceed to removal */
535 strbuf_addstr(&sb
, junk_git_dir
);
536 remove_dir_recursively(&sb
, junk_git_dir_flags
);
539 if (junk_work_tree
) {
540 strbuf_addstr(&sb
, junk_work_tree
);
541 remove_dir_recursively(&sb
, junk_work_tree_flags
);
546 static void remove_junk_on_signal(int signo
)
553 static struct ref
*find_remote_branch(const struct ref
*refs
, const char *branch
)
556 struct strbuf head
= STRBUF_INIT
;
557 strbuf_addstr(&head
, "refs/heads/");
558 strbuf_addstr(&head
, branch
);
559 ref
= find_ref_by_name(refs
, head
.buf
);
560 strbuf_release(&head
);
565 strbuf_addstr(&head
, "refs/tags/");
566 strbuf_addstr(&head
, branch
);
567 ref
= find_ref_by_name(refs
, head
.buf
);
568 strbuf_release(&head
);
573 static struct ref
*wanted_peer_refs(const struct ref
*refs
,
574 struct refspec
*refspec
)
576 struct ref
*head
= copy_ref(find_ref_by_name(refs
, "HEAD"));
577 struct ref
*local_refs
= head
;
578 struct ref
**tail
= head
? &head
->next
: &local_refs
;
580 if (option_single_branch
) {
581 struct ref
*remote_head
= NULL
;
584 remote_head
= guess_remote_head(head
, refs
, 0);
588 remote_head
= copy_ref(find_remote_branch(refs
, option_branch
));
591 if (!remote_head
&& option_branch
)
592 warning(_("Could not find remote branch %s to clone."),
596 for (i
= 0; i
< refspec
->nr
; i
++)
597 get_fetch_map(remote_head
, &refspec
->items
[i
],
600 /* if --branch=tag, pull the requested tag explicitly */
601 get_fetch_map(remote_head
, tag_refspec
, &tail
, 0);
605 for (i
= 0; i
< refspec
->nr
; i
++)
606 get_fetch_map(refs
, &refspec
->items
[i
], &tail
, 0);
609 if (!option_mirror
&& !option_single_branch
&& !option_no_tags
)
610 get_fetch_map(refs
, tag_refspec
, &tail
, 0);
615 static void write_remote_refs(const struct ref
*local_refs
)
619 struct ref_transaction
*t
;
620 struct strbuf err
= STRBUF_INIT
;
622 t
= ref_transaction_begin(&err
);
626 for (r
= local_refs
; r
; r
= r
->next
) {
629 if (ref_transaction_create(t
, r
->peer_ref
->name
, &r
->old_oid
,
634 if (initial_ref_transaction_commit(t
, &err
))
637 strbuf_release(&err
);
638 ref_transaction_free(t
);
641 static void write_followtags(const struct ref
*refs
, const char *msg
)
643 const struct ref
*ref
;
644 for (ref
= refs
; ref
; ref
= ref
->next
) {
645 if (!starts_with(ref
->name
, "refs/tags/"))
647 if (ends_with(ref
->name
, "^{}"))
649 if (!has_object_file_with_flags(&ref
->old_oid
,
651 OBJECT_INFO_SKIP_FETCH_OBJECT
))
653 update_ref(msg
, ref
->name
, &ref
->old_oid
, NULL
, 0,
654 UPDATE_REFS_DIE_ON_ERR
);
658 static int iterate_ref_map(void *cb_data
, struct object_id
*oid
)
660 struct ref
**rm
= cb_data
;
661 struct ref
*ref
= *rm
;
664 * Skip anything missing a peer_ref, which we are not
665 * actually going to write a ref for.
667 while (ref
&& !ref
->peer_ref
)
669 /* Returning -1 notes "end of list" to the caller. */
673 oidcpy(oid
, &ref
->old_oid
);
678 static void update_remote_refs(const struct ref
*refs
,
679 const struct ref
*mapped_refs
,
680 const struct ref
*remote_head_points_at
,
681 const char *branch_top
,
683 struct transport
*transport
,
684 int check_connectivity
)
686 const struct ref
*rm
= mapped_refs
;
688 if (check_connectivity
) {
689 struct check_connected_options opt
= CHECK_CONNECTED_INIT
;
691 opt
.transport
= transport
;
692 opt
.progress
= transport
->progress
;
694 if (check_connected(iterate_ref_map
, &rm
, &opt
))
695 die(_("remote did not send all necessary objects"));
699 write_remote_refs(mapped_refs
);
700 if (option_single_branch
&& !option_no_tags
)
701 write_followtags(refs
, msg
);
704 if (remote_head_points_at
&& !option_bare
) {
705 struct strbuf head_ref
= STRBUF_INIT
;
706 strbuf_addstr(&head_ref
, branch_top
);
707 strbuf_addstr(&head_ref
, "HEAD");
708 if (create_symref(head_ref
.buf
,
709 remote_head_points_at
->peer_ref
->name
,
711 die(_("unable to update %s"), head_ref
.buf
);
712 strbuf_release(&head_ref
);
716 static void update_head(const struct ref
*our
, const struct ref
*remote
,
720 if (our
&& skip_prefix(our
->name
, "refs/heads/", &head
)) {
721 /* Local default branch link */
722 if (create_symref("HEAD", our
->name
, NULL
) < 0)
723 die(_("unable to update HEAD"));
725 update_ref(msg
, "HEAD", &our
->old_oid
, NULL
, 0,
726 UPDATE_REFS_DIE_ON_ERR
);
727 install_branch_config(0, head
, remote_name
, our
->name
);
730 struct commit
*c
= lookup_commit_reference(the_repository
,
732 /* --branch specifies a non-branch (i.e. tags), detach HEAD */
733 update_ref(msg
, "HEAD", &c
->object
.oid
, NULL
, REF_NO_DEREF
,
734 UPDATE_REFS_DIE_ON_ERR
);
737 * We know remote HEAD points to a non-branch, or
738 * HEAD points to a branch but we don't know which one.
739 * Detach HEAD in all these cases.
741 update_ref(msg
, "HEAD", &remote
->old_oid
, NULL
, REF_NO_DEREF
,
742 UPDATE_REFS_DIE_ON_ERR
);
746 static int git_sparse_checkout_init(const char *repo
)
748 struct strvec argv
= STRVEC_INIT
;
750 strvec_pushl(&argv
, "-C", repo
, "sparse-checkout", "init", NULL
);
753 * We must apply the setting in the current process
754 * for the later checkout to use the sparse-checkout file.
756 core_apply_sparse_checkout
= 1;
758 if (run_command_v_opt(argv
.v
, RUN_GIT_CMD
)) {
759 error(_("failed to initialize sparse-checkout"));
767 static int checkout(int submodule_progress
)
769 struct object_id oid
;
771 struct lock_file lock_file
= LOCK_INIT
;
772 struct unpack_trees_options opts
;
777 if (option_no_checkout
)
780 head
= resolve_refdup("HEAD", RESOLVE_REF_READING
, &oid
, NULL
);
782 warning(_("remote HEAD refers to nonexistent ref, "
783 "unable to checkout.\n"));
786 if (!strcmp(head
, "HEAD")) {
787 if (advice_detached_head
)
788 detach_advice(oid_to_hex(&oid
));
791 if (!starts_with(head
, "refs/heads/"))
792 die(_("HEAD not found below refs/heads!"));
795 /* We need to be in the new work tree for the checkout */
798 hold_locked_index(&lock_file
, LOCK_DIE_ON_ERROR
);
800 memset(&opts
, 0, sizeof opts
);
804 opts
.fn
= oneway_merge
;
805 opts
.verbose_update
= (option_verbosity
>= 0);
806 opts
.src_index
= &the_index
;
807 opts
.dst_index
= &the_index
;
808 init_checkout_metadata(&opts
.meta
, head
, &oid
, NULL
);
810 tree
= parse_tree_indirect(&oid
);
812 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
813 if (unpack_trees(1, &t
, &opts
) < 0)
814 die(_("unable to checkout working tree"));
818 if (write_locked_index(&the_index
, &lock_file
, COMMIT_LOCK
))
819 die(_("unable to write new index file"));
821 err
|= run_hook_le(NULL
, "post-checkout", oid_to_hex(&null_oid
),
822 oid_to_hex(&oid
), "1", NULL
);
824 if (!err
&& (option_recurse_submodules
.nr
> 0)) {
825 struct strvec args
= STRVEC_INIT
;
826 strvec_pushl(&args
, "submodule", "update", "--require-init", "--recursive", NULL
);
828 if (option_shallow_submodules
== 1)
829 strvec_push(&args
, "--depth=1");
832 strvec_pushf(&args
, "--jobs=%d", max_jobs
);
834 if (submodule_progress
)
835 strvec_push(&args
, "--progress");
837 if (option_verbosity
< 0)
838 strvec_push(&args
, "--quiet");
840 if (option_remote_submodules
) {
841 strvec_push(&args
, "--remote");
842 strvec_push(&args
, "--no-fetch");
845 if (option_single_branch
>= 0)
846 strvec_push(&args
, option_single_branch
?
848 "--no-single-branch");
850 err
= run_command_v_opt(args
.v
, RUN_GIT_CMD
);
857 static int git_clone_config(const char *k
, const char *v
, void *cb
)
859 if (!strcmp(k
, "clone.defaultremotename")) {
861 remote_name
= xstrdup(v
);
863 return git_default_config(k
, v
, cb
);
866 static int write_one_config(const char *key
, const char *value
, void *data
)
869 * give git_clone_config a chance to write config values back to the
870 * environment, since git_config_set_multivar_gently only deals with
873 int apply_failed
= git_clone_config(key
, value
, data
);
877 return git_config_set_multivar_gently(key
,
878 value
? value
: "true",
879 CONFIG_REGEX_NONE
, 0);
882 static void write_config(struct string_list
*config
)
886 for (i
= 0; i
< config
->nr
; i
++) {
887 if (git_config_parse_parameter(config
->items
[i
].string
,
888 write_one_config
, NULL
) < 0)
889 die(_("unable to write parameters to config file"));
893 static void write_refspec_config(const char *src_ref_prefix
,
894 const struct ref
*our_head_points_at
,
895 const struct ref
*remote_head_points_at
,
896 struct strbuf
*branch_top
)
898 struct strbuf key
= STRBUF_INIT
;
899 struct strbuf value
= STRBUF_INIT
;
901 if (option_mirror
|| !option_bare
) {
902 if (option_single_branch
&& !option_mirror
) {
904 if (starts_with(our_head_points_at
->name
, "refs/tags/"))
905 strbuf_addf(&value
, "+%s:%s", our_head_points_at
->name
,
906 our_head_points_at
->name
);
908 strbuf_addf(&value
, "+%s:%s%s", our_head_points_at
->name
,
909 branch_top
->buf
, option_branch
);
910 } else if (remote_head_points_at
) {
911 const char *head
= remote_head_points_at
->name
;
912 if (!skip_prefix(head
, "refs/heads/", &head
))
913 BUG("remote HEAD points at non-head?");
915 strbuf_addf(&value
, "+%s:%s%s", remote_head_points_at
->name
,
916 branch_top
->buf
, head
);
919 * otherwise, the next "git fetch" will
920 * simply fetch from HEAD without updating
921 * any remote-tracking branch, which is what
925 strbuf_addf(&value
, "+%s*:%s*", src_ref_prefix
, branch_top
->buf
);
927 /* Configure the remote */
929 strbuf_addf(&key
, "remote.%s.fetch", remote_name
);
930 git_config_set_multivar(key
.buf
, value
.buf
, "^$", 0);
934 strbuf_addf(&key
, "remote.%s.mirror", remote_name
);
935 git_config_set(key
.buf
, "true");
941 strbuf_release(&key
);
942 strbuf_release(&value
);
945 static void dissociate_from_references(void)
947 static const char* argv
[] = { "repack", "-a", "-d", NULL
};
948 char *alternates
= git_pathdup("objects/info/alternates");
950 if (!access(alternates
, F_OK
)) {
951 if (run_command_v_opt(argv
, RUN_GIT_CMD
|RUN_COMMAND_NO_STDIN
))
952 die(_("cannot repack to clean up"));
953 if (unlink(alternates
) && errno
!= ENOENT
)
954 die_errno(_("cannot unlink temporary alternates file"));
959 static int path_exists(const char *path
)
962 return !stat(path
, &sb
);
965 int cmd_clone(int argc
, const char **argv
, const char *prefix
)
967 int is_bundle
= 0, is_local
;
968 const char *repo_name
, *repo
, *work_tree
, *git_dir
;
969 char *path
, *dir
, *display_repo
= NULL
;
970 int dest_exists
, real_dest_exists
= 0;
971 const struct ref
*refs
, *remote_head
;
972 const struct ref
*remote_head_points_at
;
973 const struct ref
*our_head_points_at
;
974 struct ref
*mapped_refs
;
975 const struct ref
*ref
;
976 struct strbuf key
= STRBUF_INIT
;
977 struct strbuf branch_top
= STRBUF_INIT
, reflog_msg
= STRBUF_INIT
;
978 struct transport
*transport
= NULL
;
979 const char *src_ref_prefix
= "refs/heads/";
980 struct remote
*remote
;
981 int err
= 0, complete_refs_before_fetch
= 1;
982 int submodule_progress
;
984 struct strvec ref_prefixes
= STRVEC_INIT
;
986 packet_trace_identity("clone");
988 git_config(git_clone_config
, NULL
);
990 argc
= parse_options(argc
, argv
, prefix
, builtin_clone_options
,
991 builtin_clone_usage
, 0);
994 usage_msg_opt(_("Too many arguments."),
995 builtin_clone_usage
, builtin_clone_options
);
998 usage_msg_opt(_("You must specify a repository to clone."),
999 builtin_clone_usage
, builtin_clone_options
);
1001 if (option_depth
|| option_since
|| option_not
.nr
)
1003 if (option_single_branch
== -1)
1004 option_single_branch
= deepen
? 1 : 0;
1011 die(_("--bare and --origin %s options are incompatible."),
1014 die(_("--bare and --separate-git-dir are incompatible."));
1015 option_no_checkout
= 1;
1018 repo_name
= argv
[0];
1020 path
= get_repo_path(repo_name
, &is_bundle
);
1022 repo
= absolute_pathdup(repo_name
);
1023 else if (strchr(repo_name
, ':')) {
1025 display_repo
= transport_anonymize_url(repo
);
1027 die(_("repository '%s' does not exist"), repo_name
);
1029 /* no need to be strict, transport_set_option() will validate it again */
1030 if (option_depth
&& atoi(option_depth
) < 1)
1031 die(_("depth %s is not a positive number"), option_depth
);
1034 dir
= xstrdup(argv
[1]);
1036 dir
= guess_dir_name(repo_name
, is_bundle
, option_bare
);
1037 strip_trailing_slashes(dir
);
1039 dest_exists
= path_exists(dir
);
1040 if (dest_exists
&& !is_empty_dir(dir
))
1041 die(_("destination path '%s' already exists and is not "
1042 "an empty directory."), dir
);
1045 real_dest_exists
= path_exists(real_git_dir
);
1046 if (real_dest_exists
&& !is_empty_dir(real_git_dir
))
1047 die(_("repository path '%s' already exists and is not "
1048 "an empty directory."), real_git_dir
);
1052 strbuf_addf(&reflog_msg
, "clone: from %s",
1053 display_repo
? display_repo
: repo
);
1059 work_tree
= getenv("GIT_WORK_TREE");
1060 if (work_tree
&& path_exists(work_tree
))
1061 die(_("working tree '%s' already exists."), work_tree
);
1064 if (option_bare
|| work_tree
)
1065 git_dir
= xstrdup(dir
);
1068 git_dir
= mkpathdup("%s/.git", dir
);
1071 atexit(remove_junk
);
1072 sigchain_push_common(remove_junk_on_signal
);
1075 if (safe_create_leading_directories_const(work_tree
) < 0)
1076 die_errno(_("could not create leading directories of '%s'"),
1079 junk_work_tree_flags
|= REMOVE_DIR_KEEP_TOPLEVEL
;
1080 else if (mkdir(work_tree
, 0777))
1081 die_errno(_("could not create work tree dir '%s'"),
1083 junk_work_tree
= work_tree
;
1084 set_git_work_tree(work_tree
);
1088 if (real_dest_exists
)
1089 junk_git_dir_flags
|= REMOVE_DIR_KEEP_TOPLEVEL
;
1090 junk_git_dir
= real_git_dir
;
1093 junk_git_dir_flags
|= REMOVE_DIR_KEEP_TOPLEVEL
;
1094 junk_git_dir
= git_dir
;
1096 if (safe_create_leading_directories_const(git_dir
) < 0)
1097 die(_("could not create leading directories of '%s'"), git_dir
);
1099 if (0 <= option_verbosity
) {
1101 fprintf(stderr
, _("Cloning into bare repository '%s'...\n"), dir
);
1103 fprintf(stderr
, _("Cloning into '%s'...\n"), dir
);
1106 if (option_recurse_submodules
.nr
> 0) {
1107 struct string_list_item
*item
;
1108 struct strbuf sb
= STRBUF_INIT
;
1110 /* remove duplicates */
1111 string_list_sort(&option_recurse_submodules
);
1112 string_list_remove_duplicates(&option_recurse_submodules
, 0);
1115 * NEEDSWORK: In a multi-working-tree world, this needs to be
1116 * set in the per-worktree config.
1118 for_each_string_list_item(item
, &option_recurse_submodules
) {
1119 strbuf_addf(&sb
, "submodule.active=%s",
1121 string_list_append(&option_config
,
1122 strbuf_detach(&sb
, NULL
));
1125 if (option_required_reference
.nr
&&
1126 option_optional_reference
.nr
)
1127 die(_("clone --recursive is not compatible with "
1128 "both --reference and --reference-if-able"));
1129 else if (option_required_reference
.nr
) {
1130 string_list_append(&option_config
,
1131 "submodule.alternateLocation=superproject");
1132 string_list_append(&option_config
,
1133 "submodule.alternateErrorStrategy=die");
1134 } else if (option_optional_reference
.nr
) {
1135 string_list_append(&option_config
,
1136 "submodule.alternateLocation=superproject");
1137 string_list_append(&option_config
,
1138 "submodule.alternateErrorStrategy=info");
1142 init_db(git_dir
, real_git_dir
, option_template
, GIT_HASH_UNKNOWN
, NULL
,
1146 git_dir
= real_git_dir
;
1149 * additional config can be injected with -c, make sure it's included
1150 * after init_db, which clears the entire config environment.
1152 write_config(&option_config
);
1155 * re-read config after init_db and write_config to pick up any config
1156 * injected by --template and --config, respectively.
1158 git_config(git_clone_config
, NULL
);
1161 * apply the remote name provided by --origin only after this second
1162 * call to git_config, to ensure it overrides all config-based values.
1164 if (option_origin
!= NULL
)
1165 remote_name
= xstrdup(option_origin
);
1167 if (remote_name
== NULL
)
1168 remote_name
= xstrdup("origin");
1170 if (!valid_remote_name(remote_name
))
1171 die(_("'%s' is not a valid remote name"), remote_name
);
1175 src_ref_prefix
= "refs/";
1176 strbuf_addstr(&branch_top
, src_ref_prefix
);
1178 git_config_set("core.bare", "true");
1180 strbuf_addf(&branch_top
, "refs/remotes/%s/", remote_name
);
1183 strbuf_addf(&key
, "remote.%s.url", remote_name
);
1184 git_config_set(key
.buf
, repo
);
1187 if (option_no_tags
) {
1188 strbuf_addf(&key
, "remote.%s.tagOpt", remote_name
);
1189 git_config_set(key
.buf
, "--no-tags");
1193 if (option_required_reference
.nr
|| option_optional_reference
.nr
)
1196 if (option_sparse_checkout
&& git_sparse_checkout_init(dir
))
1199 remote
= remote_get(remote_name
);
1201 refspec_appendf(&remote
->fetch
, "+%s*:%s*", src_ref_prefix
,
1204 transport
= transport_get(remote
, remote
->url
[0]);
1205 transport_set_verbosity(transport
, option_verbosity
, option_progress
);
1206 transport
->family
= family
;
1208 path
= get_repo_path(remote
->url
[0], &is_bundle
);
1209 is_local
= option_local
!= 0 && path
&& !is_bundle
;
1212 warning(_("--depth is ignored in local clones; use file:// instead."));
1214 warning(_("--shallow-since is ignored in local clones; use file:// instead."));
1216 warning(_("--shallow-exclude is ignored in local clones; use file:// instead."));
1217 if (filter_options
.choice
)
1218 warning(_("--filter is ignored in local clones; use file:// instead."));
1219 if (!access(mkpath("%s/shallow", path
), F_OK
)) {
1220 if (option_local
> 0)
1221 warning(_("source repository is shallow, ignoring --local"));
1225 if (option_local
> 0 && !is_local
)
1226 warning(_("--local is ignored"));
1227 transport
->cloning
= 1;
1229 transport_set_option(transport
, TRANS_OPT_KEEP
, "yes");
1232 transport_set_option(transport
, TRANS_OPT_DEPTH
,
1235 transport_set_option(transport
, TRANS_OPT_DEEPEN_SINCE
,
1238 transport_set_option(transport
, TRANS_OPT_DEEPEN_NOT
,
1239 (const char *)&option_not
);
1240 if (option_single_branch
)
1241 transport_set_option(transport
, TRANS_OPT_FOLLOWTAGS
, "1");
1243 if (option_upload_pack
)
1244 transport_set_option(transport
, TRANS_OPT_UPLOADPACK
,
1245 option_upload_pack
);
1247 if (server_options
.nr
)
1248 transport
->server_options
= &server_options
;
1250 if (filter_options
.choice
) {
1252 expand_list_objects_filter_spec(&filter_options
);
1253 transport_set_option(transport
, TRANS_OPT_LIST_OBJECTS_FILTER
,
1255 transport_set_option(transport
, TRANS_OPT_FROM_PROMISOR
, "1");
1258 if (transport
->smart_options
&& !deepen
&& !filter_options
.choice
)
1259 transport
->smart_options
->check_self_contained_and_connected
= 1;
1262 strvec_push(&ref_prefixes
, "HEAD");
1263 refspec_ref_prefixes(&remote
->fetch
, &ref_prefixes
);
1265 expand_ref_prefix(&ref_prefixes
, option_branch
);
1266 if (!option_no_tags
)
1267 strvec_push(&ref_prefixes
, "refs/tags/");
1269 refs
= transport_get_remote_refs(transport
, &ref_prefixes
);
1272 int hash_algo
= hash_algo_by_ptr(transport_get_hash_algo(transport
));
1275 * Now that we know what algorithm the remote side is using,
1276 * let's set ours to the same thing.
1278 initialize_repository_version(hash_algo
, 1);
1279 repo_set_hash_algo(the_repository
, hash_algo
);
1281 mapped_refs
= wanted_peer_refs(refs
, &remote
->fetch
);
1283 * transport_get_remote_refs() may return refs with null sha-1
1284 * in mapped_refs (see struct transport->get_refs_list
1285 * comment). In that case we need fetch it early because
1286 * remote_head code below relies on it.
1288 * for normal clones, transport_get_remote_refs() should
1289 * return reliable ref set, we can delay cloning until after
1290 * remote HEAD check.
1292 for (ref
= refs
; ref
; ref
= ref
->next
)
1293 if (is_null_oid(&ref
->old_oid
)) {
1294 complete_refs_before_fetch
= 0;
1298 if (!is_local
&& !complete_refs_before_fetch
) {
1299 err
= transport_fetch_refs(transport
, mapped_refs
);
1304 remote_head
= find_ref_by_name(refs
, "HEAD");
1305 remote_head_points_at
=
1306 guess_remote_head(remote_head
, mapped_refs
, 0);
1308 if (option_branch
) {
1309 our_head_points_at
=
1310 find_remote_branch(mapped_refs
, option_branch
);
1312 if (!our_head_points_at
)
1313 die(_("Remote branch %s not found in upstream %s"),
1314 option_branch
, remote_name
);
1317 our_head_points_at
= remote_head_points_at
;
1321 die(_("Remote branch %s not found in upstream %s"),
1322 option_branch
, remote_name
);
1324 warning(_("You appear to have cloned an empty repository."));
1326 our_head_points_at
= NULL
;
1327 remote_head_points_at
= NULL
;
1329 option_no_checkout
= 1;
1331 const char *branch
= git_default_branch_name(0);
1332 char *ref
= xstrfmt("refs/heads/%s", branch
);
1334 install_branch_config(0, branch
, remote_name
, ref
);
1339 write_refspec_config(src_ref_prefix
, our_head_points_at
,
1340 remote_head_points_at
, &branch_top
);
1342 if (filter_options
.choice
)
1343 partial_clone_register(remote_name
, &filter_options
);
1346 clone_local(path
, git_dir
);
1347 else if (refs
&& complete_refs_before_fetch
) {
1348 err
= transport_fetch_refs(transport
, mapped_refs
);
1353 update_remote_refs(refs
, mapped_refs
, remote_head_points_at
,
1354 branch_top
.buf
, reflog_msg
.buf
, transport
,
1357 update_head(our_head_points_at
, remote_head
, reflog_msg
.buf
);
1360 * We want to show progress for recursive submodule clones iff
1361 * we did so for the main clone. But only the transport knows
1362 * the final decision for this flag, so we need to rescue the value
1363 * before we free the transport.
1365 submodule_progress
= transport
->progress
;
1367 transport_unlock_pack(transport
);
1368 transport_disconnect(transport
);
1370 if (option_dissociate
) {
1371 close_object_store(the_repository
->objects
);
1372 dissociate_from_references();
1375 junk_mode
= JUNK_LEAVE_REPO
;
1376 err
= checkout(submodule_progress
);
1380 strbuf_release(&reflog_msg
);
1381 strbuf_release(&branch_top
);
1382 strbuf_release(&key
);
1383 junk_mode
= JUNK_LEAVE_ALL
;
1385 strvec_clear(&ref_prefixes
);