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.
12 #include "parse-options.h"
13 #include "fetch-pack.h"
16 #include "tree-walk.h"
17 #include "unpack-trees.h"
18 #include "transport.h"
21 #include "pack-refs.h"
25 #include "run-command.h"
29 * - respect DB_ENVIRONMENT for .git/objects.
31 * Implementation notes:
32 * - dropping use-separate-remote and no-separate-remote compatibility
35 static const char * const builtin_clone_usage
[] = {
36 "git clone [options] [--] <repo> [<dir>]",
40 static int option_no_checkout
, option_bare
, option_mirror
;
41 static int option_local
, option_no_hardlinks
, option_shared
, option_recursive
;
42 static char *option_template
, *option_reference
, *option_depth
;
43 static char *option_origin
= NULL
;
44 static char *option_branch
= NULL
;
45 static char *option_upload_pack
= "git-upload-pack";
46 static int option_verbosity
;
47 static int option_progress
;
49 static struct option builtin_clone_options
[] = {
50 OPT__VERBOSITY(&option_verbosity
),
51 OPT_BOOLEAN(0, "progress", &option_progress
,
52 "force progress reporting"),
53 OPT_BOOLEAN('n', "no-checkout", &option_no_checkout
,
54 "don't create a checkout"),
55 OPT_BOOLEAN(0, "bare", &option_bare
, "create a bare repository"),
56 { OPTION_BOOLEAN
, 0, "naked", &option_bare
, NULL
,
57 "create a bare repository",
58 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
59 OPT_BOOLEAN(0, "mirror", &option_mirror
,
60 "create a mirror repository (implies bare)"),
61 OPT_BOOLEAN('l', "local", &option_local
,
62 "to clone from a local repository"),
63 OPT_BOOLEAN(0, "no-hardlinks", &option_no_hardlinks
,
64 "don't use local hardlinks, always copy"),
65 OPT_BOOLEAN('s', "shared", &option_shared
,
66 "setup as shared repository"),
67 OPT_BOOLEAN(0, "recursive", &option_recursive
,
68 "initialize submodules in the clone"),
69 OPT_BOOLEAN(0, "recurse-submodules", &option_recursive
,
70 "initialize submodules in the clone"),
71 OPT_STRING(0, "template", &option_template
, "template-directory",
72 "directory from which templates will be used"),
73 OPT_STRING(0, "reference", &option_reference
, "repo",
74 "reference repository"),
75 OPT_STRING('o', "origin", &option_origin
, "branch",
76 "use <branch> instead of 'origin' to track upstream"),
77 OPT_STRING('b', "branch", &option_branch
, "branch",
78 "checkout <branch> instead of the remote's HEAD"),
79 OPT_STRING('u', "upload-pack", &option_upload_pack
, "path",
80 "path to git-upload-pack on the remote"),
81 OPT_STRING(0, "depth", &option_depth
, "depth",
82 "create a shallow clone of that depth"),
87 static const char *argv_submodule
[] = {
88 "submodule", "update", "--init", "--recursive", NULL
91 static char *get_repo_path(const char *repo
, int *is_bundle
)
93 static char *suffix
[] = { "/.git", ".git", "" };
94 static char *bundle_suffix
[] = { ".bundle", "" };
98 for (i
= 0; i
< ARRAY_SIZE(suffix
); i
++) {
100 path
= mkpath("%s%s", repo
, suffix
[i
]);
101 if (is_directory(path
)) {
103 return xstrdup(make_nonrelative_path(path
));
107 for (i
= 0; i
< ARRAY_SIZE(bundle_suffix
); i
++) {
109 path
= mkpath("%s%s", repo
, bundle_suffix
[i
]);
110 if (!stat(path
, &st
) && S_ISREG(st
.st_mode
)) {
112 return xstrdup(make_nonrelative_path(path
));
119 static char *guess_dir_name(const char *repo
, int is_bundle
, int is_bare
)
121 const char *end
= repo
+ strlen(repo
), *start
;
125 * Strip trailing spaces, slashes and /.git
127 while (repo
< end
&& (is_dir_sep(end
[-1]) || isspace(end
[-1])))
129 if (end
- repo
> 5 && is_dir_sep(end
[-5]) &&
130 !strncmp(end
- 4, ".git", 4)) {
132 while (repo
< end
&& is_dir_sep(end
[-1]))
137 * Find last component, but be prepared that repo could have
138 * the form "remote.example.com:foo.git", i.e. no slash
139 * in the directory part.
142 while (repo
< start
&& !is_dir_sep(start
[-1]) && start
[-1] != ':')
146 * Strip .{bundle,git}.
149 if (end
- start
> 7 && !strncmp(end
- 7, ".bundle", 7))
152 if (end
- start
> 4 && !strncmp(end
- 4, ".git", 4))
157 struct strbuf result
= STRBUF_INIT
;
158 strbuf_addf(&result
, "%.*s.git", (int)(end
- start
), start
);
159 dir
= strbuf_detach(&result
, NULL
);
161 dir
= xstrndup(start
, end
- start
);
163 * Replace sequences of 'control' characters and whitespace
164 * with one ascii space, remove leading and trailing spaces.
168 int prev_space
= 1 /* strip leading whitespace */;
169 for (end
= dir
; *end
; ++end
) {
171 if ((unsigned char)ch
< '\x20')
182 if (out
> dir
&& prev_space
)
188 static void strip_trailing_slashes(char *dir
)
190 char *end
= dir
+ strlen(dir
);
192 while (dir
< end
- 1 && is_dir_sep(end
[-1]))
197 static void setup_reference(const char *repo
)
202 struct remote
*remote
;
203 struct transport
*transport
;
204 const struct ref
*extra
;
206 ref_git
= make_absolute_path(option_reference
);
208 if (is_directory(mkpath("%s/.git/objects", ref_git
)))
209 ref_git
= mkpath("%s/.git", ref_git
);
210 else if (!is_directory(mkpath("%s/objects", ref_git
)))
211 die("reference repository '%s' is not a local directory.",
214 ref_git_copy
= xstrdup(ref_git
);
216 add_to_alternates_file(ref_git_copy
);
218 remote
= remote_get(ref_git_copy
);
219 transport
= transport_get(remote
, ref_git_copy
);
220 for (extra
= transport_get_remote_refs(transport
); extra
;
222 add_extra_ref(extra
->name
, extra
->old_sha1
, 0);
224 transport_disconnect(transport
);
229 static void copy_or_link_directory(struct strbuf
*src
, struct strbuf
*dest
)
233 int src_len
, dest_len
;
236 dir
= opendir(src
->buf
);
238 die_errno("failed to open '%s'", src
->buf
);
240 if (mkdir(dest
->buf
, 0777)) {
242 die_errno("failed to create directory '%s'", dest
->buf
);
243 else if (stat(dest
->buf
, &buf
))
244 die_errno("failed to stat '%s'", dest
->buf
);
245 else if (!S_ISDIR(buf
.st_mode
))
246 die("%s exists and is not a directory", dest
->buf
);
249 strbuf_addch(src
, '/');
251 strbuf_addch(dest
, '/');
252 dest_len
= dest
->len
;
254 while ((de
= readdir(dir
)) != NULL
) {
255 strbuf_setlen(src
, src_len
);
256 strbuf_addstr(src
, de
->d_name
);
257 strbuf_setlen(dest
, dest_len
);
258 strbuf_addstr(dest
, de
->d_name
);
259 if (stat(src
->buf
, &buf
)) {
260 warning ("failed to stat %s\n", src
->buf
);
263 if (S_ISDIR(buf
.st_mode
)) {
264 if (de
->d_name
[0] != '.')
265 copy_or_link_directory(src
, dest
);
269 if (unlink(dest
->buf
) && errno
!= ENOENT
)
270 die_errno("failed to unlink '%s'", dest
->buf
);
271 if (!option_no_hardlinks
) {
272 if (!link(src
->buf
, dest
->buf
))
275 die_errno("failed to create link '%s'", dest
->buf
);
276 option_no_hardlinks
= 1;
278 if (copy_file_with_time(dest
->buf
, src
->buf
, 0666))
279 die_errno("failed to copy file to '%s'", dest
->buf
);
284 static const struct ref
*clone_local(const char *src_repo
,
285 const char *dest_repo
)
287 const struct ref
*ret
;
288 struct strbuf src
= STRBUF_INIT
;
289 struct strbuf dest
= STRBUF_INIT
;
290 struct remote
*remote
;
291 struct transport
*transport
;
294 add_to_alternates_file(src_repo
);
296 strbuf_addf(&src
, "%s/objects", src_repo
);
297 strbuf_addf(&dest
, "%s/objects", dest_repo
);
298 copy_or_link_directory(&src
, &dest
);
299 strbuf_release(&src
);
300 strbuf_release(&dest
);
303 remote
= remote_get(src_repo
);
304 transport
= transport_get(remote
, src_repo
);
305 ret
= transport_get_remote_refs(transport
);
306 transport_disconnect(transport
);
307 if (0 <= option_verbosity
)
312 static const char *junk_work_tree
;
313 static const char *junk_git_dir
;
314 static pid_t junk_pid
;
316 static void remove_junk(void)
318 struct strbuf sb
= STRBUF_INIT
;
319 if (getpid() != junk_pid
)
322 strbuf_addstr(&sb
, junk_git_dir
);
323 remove_dir_recursively(&sb
, 0);
326 if (junk_work_tree
) {
327 strbuf_addstr(&sb
, junk_work_tree
);
328 remove_dir_recursively(&sb
, 0);
333 static void remove_junk_on_signal(int signo
)
340 static struct ref
*wanted_peer_refs(const struct ref
*refs
,
341 struct refspec
*refspec
)
343 struct ref
*head
= copy_ref(find_ref_by_name(refs
, "HEAD"));
344 struct ref
*local_refs
= head
;
345 struct ref
**tail
= head
? &head
->next
: &local_refs
;
347 get_fetch_map(refs
, refspec
, &tail
, 0);
349 get_fetch_map(refs
, tag_refspec
, &tail
, 0);
354 static void write_remote_refs(const struct ref
*local_refs
)
358 for (r
= local_refs
; r
; r
= r
->next
) {
361 add_extra_ref(r
->peer_ref
->name
, r
->old_sha1
, 0);
364 pack_refs(PACK_REFS_ALL
);
368 int cmd_clone(int argc
, const char **argv
, const char *prefix
)
370 int is_bundle
= 0, is_local
;
372 const char *repo_name
, *repo
, *work_tree
, *git_dir
;
375 const struct ref
*refs
, *remote_head
;
376 const struct ref
*remote_head_points_at
;
377 const struct ref
*our_head_points_at
;
378 struct ref
*mapped_refs
;
379 struct strbuf key
= STRBUF_INIT
, value
= STRBUF_INIT
;
380 struct strbuf branch_top
= STRBUF_INIT
, reflog_msg
= STRBUF_INIT
;
381 struct transport
*transport
= NULL
;
382 char *src_ref_prefix
= "refs/heads/";
385 struct refspec
*refspec
;
386 const char *fetch_pattern
;
390 argc
= parse_options(argc
, argv
, prefix
, builtin_clone_options
,
391 builtin_clone_usage
, 0);
394 usage_msg_opt("Too many arguments.",
395 builtin_clone_usage
, builtin_clone_options
);
398 usage_msg_opt("You must specify a repository to clone.",
399 builtin_clone_usage
, builtin_clone_options
);
406 die("--bare and --origin %s options are incompatible.",
408 option_no_checkout
= 1;
412 option_origin
= "origin";
416 path
= get_repo_path(repo_name
, &is_bundle
);
418 repo
= xstrdup(make_nonrelative_path(repo_name
));
419 else if (!strchr(repo_name
, ':'))
420 die("repository '%s' does not exist", repo_name
);
423 is_local
= path
&& !is_bundle
;
424 if (is_local
&& option_depth
)
425 warning("--depth is ignored in local clones; use file:// instead.");
428 dir
= xstrdup(argv
[1]);
430 dir
= guess_dir_name(repo_name
, is_bundle
, option_bare
);
431 strip_trailing_slashes(dir
);
433 dest_exists
= !stat(dir
, &buf
);
434 if (dest_exists
&& !is_empty_dir(dir
))
435 die("destination path '%s' already exists and is not "
436 "an empty directory.", dir
);
438 strbuf_addf(&reflog_msg
, "clone: from %s", repo
);
443 work_tree
= getenv("GIT_WORK_TREE");
444 if (work_tree
&& !stat(work_tree
, &buf
))
445 die("working tree '%s' already exists.", work_tree
);
448 if (option_bare
|| work_tree
)
449 git_dir
= xstrdup(dir
);
452 git_dir
= xstrdup(mkpath("%s/.git", dir
));
456 junk_work_tree
= work_tree
;
457 if (safe_create_leading_directories_const(work_tree
) < 0)
458 die_errno("could not create leading directories of '%s'",
460 if (!dest_exists
&& mkdir(work_tree
, 0755))
461 die_errno("could not create work tree dir '%s'.",
463 set_git_work_tree(work_tree
);
465 junk_git_dir
= git_dir
;
467 sigchain_push_common(remove_junk_on_signal
);
469 setenv(CONFIG_ENVIRONMENT
, mkpath("%s/config", git_dir
), 1);
471 if (safe_create_leading_directories_const(git_dir
) < 0)
472 die("could not create leading directories of '%s'", git_dir
);
473 set_git_dir(make_absolute_path(git_dir
));
475 if (0 <= option_verbosity
)
476 printf("Cloning into %s%s...\n",
477 option_bare
? "bare repository " : "", dir
);
478 init_db(option_template
, INIT_DB_QUIET
);
481 * At this point, the config exists, so we do not need the
482 * environment variable. We actually need to unset it, too, to
483 * re-enable parsing of the global configs.
485 unsetenv(CONFIG_ENVIRONMENT
);
487 git_config(git_default_config
, NULL
);
491 src_ref_prefix
= "refs/";
492 strbuf_addstr(&branch_top
, src_ref_prefix
);
494 git_config_set("core.bare", "true");
496 strbuf_addf(&branch_top
, "refs/remotes/%s/", option_origin
);
499 strbuf_addf(&value
, "+%s*:%s*", src_ref_prefix
, branch_top
.buf
);
501 if (option_mirror
|| !option_bare
) {
502 /* Configure the remote */
503 strbuf_addf(&key
, "remote.%s.fetch", option_origin
);
504 git_config_set_multivar(key
.buf
, value
.buf
, "^$", 0);
508 strbuf_addf(&key
, "remote.%s.mirror", option_origin
);
509 git_config_set(key
.buf
, "true");
514 strbuf_addf(&key
, "remote.%s.url", option_origin
);
515 git_config_set(key
.buf
, repo
);
518 if (option_reference
)
519 setup_reference(git_dir
);
521 fetch_pattern
= value
.buf
;
522 refspec
= parse_fetch_refspec(1, &fetch_pattern
);
524 strbuf_reset(&value
);
527 refs
= clone_local(path
, git_dir
);
528 mapped_refs
= wanted_peer_refs(refs
, refspec
);
530 struct remote
*remote
= remote_get(option_origin
);
531 transport
= transport_get(remote
, remote
->url
[0]);
533 if (!transport
->get_refs_list
|| !transport
->fetch
)
534 die("Don't know how to clone %s", transport
->url
);
536 transport_set_option(transport
, TRANS_OPT_KEEP
, "yes");
539 transport_set_option(transport
, TRANS_OPT_DEPTH
,
542 transport_set_verbosity(transport
, option_verbosity
, option_progress
);
544 if (option_upload_pack
)
545 transport_set_option(transport
, TRANS_OPT_UPLOADPACK
,
548 refs
= transport_get_remote_refs(transport
);
550 mapped_refs
= wanted_peer_refs(refs
, refspec
);
551 transport_fetch_refs(transport
, mapped_refs
);
558 write_remote_refs(mapped_refs
);
560 remote_head
= find_ref_by_name(refs
, "HEAD");
561 remote_head_points_at
=
562 guess_remote_head(remote_head
, mapped_refs
, 0);
565 struct strbuf head
= STRBUF_INIT
;
566 strbuf_addstr(&head
, src_ref_prefix
);
567 strbuf_addstr(&head
, option_branch
);
569 find_ref_by_name(mapped_refs
, head
.buf
);
570 strbuf_release(&head
);
572 if (!our_head_points_at
) {
573 warning("Remote branch %s not found in "
574 "upstream %s, using HEAD instead",
575 option_branch
, option_origin
);
576 our_head_points_at
= remote_head_points_at
;
580 our_head_points_at
= remote_head_points_at
;
583 warning("You appear to have cloned an empty repository.");
584 our_head_points_at
= NULL
;
585 remote_head_points_at
= NULL
;
587 option_no_checkout
= 1;
589 install_branch_config(0, "master", option_origin
,
590 "refs/heads/master");
593 if (remote_head_points_at
&& !option_bare
) {
594 struct strbuf head_ref
= STRBUF_INIT
;
595 strbuf_addstr(&head_ref
, branch_top
.buf
);
596 strbuf_addstr(&head_ref
, "HEAD");
597 create_symref(head_ref
.buf
,
598 remote_head_points_at
->peer_ref
->name
,
602 if (our_head_points_at
) {
603 /* Local default branch link */
604 create_symref("HEAD", our_head_points_at
->name
, NULL
);
606 const char *head
= skip_prefix(our_head_points_at
->name
,
608 update_ref(reflog_msg
.buf
, "HEAD",
609 our_head_points_at
->old_sha1
,
610 NULL
, 0, DIE_ON_ERR
);
611 install_branch_config(0, head
, option_origin
,
612 our_head_points_at
->name
);
614 } else if (remote_head
) {
615 /* Source had detached HEAD pointing somewhere. */
617 update_ref(reflog_msg
.buf
, "HEAD",
618 remote_head
->old_sha1
,
619 NULL
, REF_NODEREF
, DIE_ON_ERR
);
620 our_head_points_at
= remote_head
;
623 /* Nothing to checkout out */
624 if (!option_no_checkout
)
625 warning("remote HEAD refers to nonexistent ref, "
626 "unable to checkout.\n");
627 option_no_checkout
= 1;
631 transport_unlock_pack(transport
);
632 transport_disconnect(transport
);
635 if (!option_no_checkout
) {
636 struct lock_file
*lock_file
= xcalloc(1, sizeof(struct lock_file
));
637 struct unpack_trees_options opts
;
642 /* We need to be in the new work tree for the checkout */
645 fd
= hold_locked_index(lock_file
, 1);
647 memset(&opts
, 0, sizeof opts
);
650 opts
.fn
= oneway_merge
;
651 opts
.verbose_update
= (option_verbosity
> 0);
652 opts
.src_index
= &the_index
;
653 opts
.dst_index
= &the_index
;
655 tree
= parse_tree_indirect(our_head_points_at
->old_sha1
);
657 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
658 unpack_trees(1, &t
, &opts
);
660 if (write_cache(fd
, active_cache
, active_nr
) ||
661 commit_locked_index(lock_file
))
662 die("unable to write new index file");
664 err
|= run_hook(NULL
, "post-checkout", sha1_to_hex(null_sha1
),
665 sha1_to_hex(our_head_points_at
->old_sha1
), "1",
668 if (!err
&& option_recursive
)
669 err
= run_command_v_opt(argv_submodule
, RUN_GIT_CMD
);
672 strbuf_release(&reflog_msg
);
673 strbuf_release(&branch_top
);
674 strbuf_release(&key
);
675 strbuf_release(&value
);