]>
Commit | Line | Data |
---|---|---|
1 | git-clone(1) | |
2 | ============ | |
3 | ||
4 | NAME | |
5 | ---- | |
6 | git-clone - Clone a repository into a new directory | |
7 | ||
8 | ||
9 | SYNOPSIS | |
10 | -------- | |
11 | [verse] | |
12 | 'git clone' [--template=<template_directory>] | |
13 | [-l] [-s] [--no-hardlinks] [-q] [-n] [--bare] [--mirror] | |
14 | [-o <name>] [-b <name>] [-u <upload-pack>] [--reference <repository>] | |
15 | [--separate-git-dir <git dir>] | |
16 | [--depth <depth>] [--recursive|--recurse-submodules] [--] <repository> | |
17 | [<directory>] | |
18 | ||
19 | DESCRIPTION | |
20 | ----------- | |
21 | ||
22 | Clones a repository into a newly created directory, creates | |
23 | remote-tracking branches for each branch in the cloned repository | |
24 | (visible using `git branch -r`), and creates and checks out an | |
25 | initial branch that is forked from the cloned repository's | |
26 | currently active branch. | |
27 | ||
28 | After the clone, a plain `git fetch` without arguments will update | |
29 | all the remote-tracking branches, and a `git pull` without | |
30 | arguments will in addition merge the remote master branch into the | |
31 | current master branch, if any. | |
32 | ||
33 | This default configuration is achieved by creating references to | |
34 | the remote branch heads under `refs/remotes/origin` and | |
35 | by initializing `remote.origin.url` and `remote.origin.fetch` | |
36 | configuration variables. | |
37 | ||
38 | ||
39 | OPTIONS | |
40 | ------- | |
41 | --local:: | |
42 | -l:: | |
43 | When the repository to clone from is on a local machine, | |
44 | this flag bypasses the normal "git aware" transport | |
45 | mechanism and clones the repository by making a copy of | |
46 | HEAD and everything under objects and refs directories. | |
47 | The files under `.git/objects/` directory are hardlinked | |
48 | to save space when possible. This is now the default when | |
49 | the source repository is specified with `/path/to/repo` | |
50 | syntax, so it essentially is a no-op option. To force | |
51 | copying instead of hardlinking (which may be desirable | |
52 | if you are trying to make a back-up of your repository), | |
53 | but still avoid the usual "git aware" transport | |
54 | mechanism, `--no-hardlinks` can be used. | |
55 | ||
56 | --no-hardlinks:: | |
57 | Optimize the cloning process from a repository on a | |
58 | local filesystem by copying files under `.git/objects` | |
59 | directory. | |
60 | ||
61 | --shared:: | |
62 | -s:: | |
63 | When the repository to clone is on the local machine, | |
64 | instead of using hard links, automatically setup | |
65 | `.git/objects/info/alternates` to share the objects | |
66 | with the source repository. The resulting repository | |
67 | starts out without any object of its own. | |
68 | + | |
69 | *NOTE*: this is a possibly dangerous operation; do *not* use | |
70 | it unless you understand what it does. If you clone your | |
71 | repository using this option and then delete branches (or use any | |
72 | other git command that makes any existing commit unreferenced) in the | |
73 | source repository, some objects may become unreferenced (or dangling). | |
74 | These objects may be removed by normal git operations (such as `git commit`) | |
75 | which automatically call `git gc --auto`. (See linkgit:git-gc[1].) | |
76 | If these objects are removed and were referenced by the cloned repository, | |
77 | then the cloned repository will become corrupt. | |
78 | + | |
79 | Note that running `git repack` without the `-l` option in a repository | |
80 | cloned with `-s` will copy objects from the source repository into a pack | |
81 | in the cloned repository, removing the disk space savings of `clone -s`. | |
82 | It is safe, however, to run `git gc`, which uses the `-l` option by | |
83 | default. | |
84 | + | |
85 | If you want to break the dependency of a repository cloned with `-s` on | |
86 | its source repository, you can simply run `git repack -a` to copy all | |
87 | objects from the source repository into a pack in the cloned repository. | |
88 | ||
89 | --reference <repository>:: | |
90 | If the reference repository is on the local machine, | |
91 | automatically setup `.git/objects/info/alternates` to | |
92 | obtain objects from the reference repository. Using | |
93 | an already existing repository as an alternate will | |
94 | require fewer objects to be copied from the repository | |
95 | being cloned, reducing network and local storage costs. | |
96 | + | |
97 | *NOTE*: see the NOTE for the `--shared` option. | |
98 | ||
99 | --quiet:: | |
100 | -q:: | |
101 | Operate quietly. Progress is not reported to the standard | |
102 | error stream. This flag is also passed to the `rsync' | |
103 | command when given. | |
104 | ||
105 | --verbose:: | |
106 | -v:: | |
107 | Run verbosely. Does not affect the reporting of progress status | |
108 | to the standard error stream. | |
109 | ||
110 | --progress:: | |
111 | Progress status is reported on the standard error stream | |
112 | by default when it is attached to a terminal, unless -q | |
113 | is specified. This flag forces progress status even if the | |
114 | standard error stream is not directed to a terminal. | |
115 | ||
116 | --no-checkout:: | |
117 | -n:: | |
118 | No checkout of HEAD is performed after the clone is complete. | |
119 | ||
120 | --bare:: | |
121 | Make a 'bare' GIT repository. That is, instead of | |
122 | creating `<directory>` and placing the administrative | |
123 | files in `<directory>/.git`, make the `<directory>` | |
124 | itself the `$GIT_DIR`. This obviously implies the `-n` | |
125 | because there is nowhere to check out the working tree. | |
126 | Also the branch heads at the remote are copied directly | |
127 | to corresponding local branch heads, without mapping | |
128 | them to `refs/remotes/origin/`. When this option is | |
129 | used, neither remote-tracking branches nor the related | |
130 | configuration variables are created. | |
131 | ||
132 | --mirror:: | |
133 | Set up a mirror of the source repository. This implies `--bare`. | |
134 | Compared to `--bare`, `--mirror` not only maps local branches of the | |
135 | source to local branches of the target, it maps all refs (including | |
136 | remote-tracking branches, notes etc.) and sets up a refspec configuration such | |
137 | that all these refs are overwritten by a `git remote update` in the | |
138 | target repository. | |
139 | ||
140 | --origin <name>:: | |
141 | -o <name>:: | |
142 | Instead of using the remote name `origin` to keep track | |
143 | of the upstream repository, use `<name>`. | |
144 | ||
145 | --branch <name>:: | |
146 | -b <name>:: | |
147 | Instead of pointing the newly created HEAD to the branch pointed | |
148 | to by the cloned repository's HEAD, point to `<name>` branch | |
149 | instead. In a non-bare repository, this is the branch that will | |
150 | be checked out. | |
151 | ||
152 | --upload-pack <upload-pack>:: | |
153 | -u <upload-pack>:: | |
154 | When given, and the repository to clone from is accessed | |
155 | via ssh, this specifies a non-default path for the command | |
156 | run on the other end. | |
157 | ||
158 | --template=<template_directory>:: | |
159 | Specify the directory from which templates will be used; | |
160 | (See the "TEMPLATE DIRECTORY" section of linkgit:git-init[1].) | |
161 | ||
162 | --depth <depth>:: | |
163 | Create a 'shallow' clone with a history truncated to the | |
164 | specified number of revisions. A shallow repository has a | |
165 | number of limitations (you cannot clone or fetch from | |
166 | it, nor push from nor into it), but is adequate if you | |
167 | are only interested in the recent history of a large project | |
168 | with a long history, and would want to send in fixes | |
169 | as patches. | |
170 | ||
171 | --recursive:: | |
172 | --recurse-submodules:: | |
173 | After the clone is created, initialize all submodules within, | |
174 | using their default settings. This is equivalent to running | |
175 | `git submodule update --init --recursive` immediately after | |
176 | the clone is finished. This option is ignored if the cloned | |
177 | repository does not have a worktree/checkout (i.e. if any of | |
178 | `--no-checkout`/`-n`, `--bare`, or `--mirror` is given) | |
179 | ||
180 | --separate-git-dir=<git dir>:: | |
181 | Instead of placing the cloned repository where it is supposed | |
182 | to be, place the cloned repository at the specified directory, | |
183 | then make a filesytem-agnostic git symbolic link to there. | |
184 | The result is git repository can be separated from working | |
185 | tree. | |
186 | ||
187 | ||
188 | <repository>:: | |
189 | The (possibly remote) repository to clone from. See the | |
190 | <<URLS,URLS>> section below for more information on specifying | |
191 | repositories. | |
192 | ||
193 | <directory>:: | |
194 | The name of a new directory to clone into. The "humanish" | |
195 | part of the source repository is used if no directory is | |
196 | explicitly given (`repo` for `/path/to/repo.git` and `foo` | |
197 | for `host.xz:foo/.git`). Cloning into an existing directory | |
198 | is only allowed if the directory is empty. | |
199 | ||
200 | :git-clone: 1 | |
201 | include::urls.txt[] | |
202 | ||
203 | Examples | |
204 | -------- | |
205 | ||
206 | * Clone from upstream: | |
207 | + | |
208 | ------------ | |
209 | $ git clone git://git.kernel.org/pub/scm/.../linux-2.6 my2.6 | |
210 | $ cd my2.6 | |
211 | $ make | |
212 | ------------ | |
213 | ||
214 | ||
215 | * Make a local clone that borrows from the current directory, without checking things out: | |
216 | + | |
217 | ------------ | |
218 | $ git clone -l -s -n . ../copy | |
219 | $ cd ../copy | |
220 | $ git show-branch | |
221 | ------------ | |
222 | ||
223 | ||
224 | * Clone from upstream while borrowing from an existing local directory: | |
225 | + | |
226 | ------------ | |
227 | $ git clone --reference my2.6 \ | |
228 | git://git.kernel.org/pub/scm/.../linux-2.7 \ | |
229 | my2.7 | |
230 | $ cd my2.7 | |
231 | ------------ | |
232 | ||
233 | ||
234 | * Create a bare repository to publish your changes to the public: | |
235 | + | |
236 | ------------ | |
237 | $ git clone --bare -l /home/proj/.git /pub/scm/proj.git | |
238 | ------------ | |
239 | ||
240 | ||
241 | * Create a repository on the kernel.org machine that borrows from Linus: | |
242 | + | |
243 | ------------ | |
244 | $ git clone --bare -l -s /pub/scm/.../torvalds/linux-2.6.git \ | |
245 | /pub/scm/.../me/subsys-2.6.git | |
246 | ------------ | |
247 | ||
248 | GIT | |
249 | --- | |
250 | Part of the linkgit:git[1] suite |