freshlybakedca.ke
Git fork
1git-fetch(1)
2============
3
4NAME
5----
6git-fetch - Download objects and refs from another repository
7
8
9SYNOPSIS
10--------
11[verse]
12'git fetch' [<options>] [<repository> [<refspec>...]]
13'git fetch' [<options>] <group>
14'git fetch' --multiple [<options>] [(<repository> | <group>)...]
15'git fetch' --all [<options>]
16
17
18DESCRIPTION
19-----------
20Fetch branches and/or tags (collectively, "refs") from one or more
21other repositories, along with the objects necessary to complete their
22histories. Remote-tracking branches are updated (see the description
23of <refspec> below for ways to control this behavior).
24
25By default, any tag that points into the histories being fetched is
26also fetched; the effect is to fetch tags that
27point at branches that you are interested in. This default behavior
28can be changed by using the --tags or --no-tags options or by
29configuring remote.<name>.tagOpt. By using a refspec that fetches tags
30explicitly, you can fetch tags that do not point into branches you
31are interested in as well.
32
33'git fetch' can fetch from either a single named repository or URL,
34or from several repositories at once if <group> is given and
35there is a remotes.<group> entry in the configuration file.
36(See linkgit:git-config[1]).
37
38When no remote is specified, by default the `origin` remote will be used,
39unless there's an upstream branch configured for the current branch.
40
41The names of refs that are fetched, together with the object names
42they point at, are written to `.git/FETCH_HEAD`. This information
43may be used by scripts or other git commands, such as linkgit:git-pull[1].
44
45OPTIONS
46-------
47include::fetch-options.adoc[]
48
49include::pull-fetch-param.adoc[]
50
51--stdin::
52 Read refspecs, one per line, from stdin in addition to those provided
53 as arguments. The "tag <name>" format is not supported.
54
55include::urls-remotes.adoc[]
56
57
58CONFIGURED REMOTE-TRACKING BRANCHES[[CRTB]]
59-------------------------------------------
60
61You often interact with the same remote repository by
62regularly and repeatedly fetching from it. In order to keep track
63of the progress of such a remote repository, `git fetch` allows you
64to configure `remote.<repository>.fetch` configuration variables.
65
66Typically such a variable may look like this:
67
68------------------------------------------------
69[remote "origin"]
70 fetch = +refs/heads/*:refs/remotes/origin/*
71------------------------------------------------
72
73This configuration is used in two ways:
74
75* When `git fetch` is run without specifying what branches
76 and/or tags to fetch on the command line, e.g. `git fetch origin`
77 or `git fetch`, `remote.<repository>.fetch` values are used as
78 the refspecs--they specify which refs to fetch and which local refs
79 to update. The example above will fetch
80 all branches that exist in the `origin` (i.e. any ref that matches
81 the left-hand side of the value, `refs/heads/*`) and update the
82 corresponding remote-tracking branches in the `refs/remotes/origin/*`
83 hierarchy.
84
85* When `git fetch` is run with explicit branches and/or tags
86 to fetch on the command line, e.g. `git fetch origin master`, the
87 <refspec>s given on the command line determine what are to be
88 fetched (e.g. `master` in the example,
89 which is a short-hand for `master:`, which in turn means
90 "fetch the 'master' branch but I do not explicitly say what
91 remote-tracking branch to update with it from the command line"),
92 and the example command will
93 fetch _only_ the 'master' branch. The `remote.<repository>.fetch`
94 values determine which
95 remote-tracking branch, if any, is updated. When used in this
96 way, the `remote.<repository>.fetch` values do not have any
97 effect in deciding _what_ gets fetched (i.e. the values are not
98 used as refspecs when the command-line lists refspecs); they are
99 only used to decide _where_ the refs that are fetched are stored
100 by acting as a mapping.
101
102The latter use of the `remote.<repository>.fetch` values can be
103overridden by giving the `--refmap=<refspec>` parameter(s) on the
104command line.
105
106PRUNING
107-------
108
109Git has a default disposition of keeping data unless it's explicitly
110thrown away; this extends to holding onto local references to branches
111on remotes that have themselves deleted those branches.
112
113If left to accumulate, these stale references might make performance
114worse on big and busy repos that have a lot of branch churn, and
115e.g. make the output of commands like `git branch -a --contains
116<commit>` needlessly verbose, as well as impacting anything else
117that'll work with the complete set of known references.
118
119These remote-tracking references can be deleted as a one-off with
120either of:
121
122------------------------------------------------
123# While fetching
124$ git fetch --prune <name>
125
126# Only prune, don't fetch
127$ git remote prune <name>
128------------------------------------------------
129
130To prune references as part of your normal workflow without needing to
131remember to run that, set `fetch.prune` globally, or
132`remote.<name>.prune` per-remote in the config. See
133linkgit:git-config[1].
134
135Here's where things get tricky and more specific. The pruning feature
136doesn't actually care about branches, instead it'll prune local <-->
137remote-references as a function of the refspec of the remote (see
138`<refspec>` and <<CRTB,CONFIGURED REMOTE-TRACKING BRANCHES>> above).
139
140Therefore if the refspec for the remote includes
141e.g. `refs/tags/*:refs/tags/*`, or you manually run e.g. `git fetch
142--prune <name> "refs/tags/*:refs/tags/*"` it won't be stale remote
143tracking branches that are deleted, but any local tag that doesn't
144exist on the remote.
145
146This might not be what you expect, i.e. you want to prune remote
147`<name>`, but also explicitly fetch tags from it, so when you fetch
148from it you delete all your local tags, most of which may not have
149come from the `<name>` remote in the first place.
150
151So be careful when using this with a refspec like
152`refs/tags/*:refs/tags/*`, or any other refspec which might map
153references from multiple remotes to the same local namespace.
154
155Since keeping up-to-date with both branches and tags on the remote is
156a common use-case the `--prune-tags` option can be supplied along with
157`--prune` to prune local tags that don't exist on the remote, and
158force-update those tags that differ. Tag pruning can also be enabled
159with `fetch.pruneTags` or `remote.<name>.pruneTags` in the config. See
160linkgit:git-config[1].
161
162The `--prune-tags` option is equivalent to having
163`refs/tags/*:refs/tags/*` declared in the refspecs of the remote. This
164can lead to some seemingly strange interactions:
165
166------------------------------------------------
167# These both fetch tags
168$ git fetch --no-tags origin 'refs/tags/*:refs/tags/*'
169$ git fetch --no-tags --prune-tags origin
170------------------------------------------------
171
172The reason it doesn't error out when provided without `--prune` or its
173config versions is for flexibility of the configured versions, and to
174maintain a 1=1 mapping between what the command line flags do, and
175what the configuration versions do.
176
177It's reasonable to e.g. configure `fetch.pruneTags=true` in
178`~/.gitconfig` to have tags pruned whenever `git fetch --prune` is
179run, without making every invocation of `git fetch` without `--prune`
180an error.
181
182Pruning tags with `--prune-tags` also works when fetching a URL
183instead of a named remote. These will all prune tags not found on
184origin:
185
186------------------------------------------------
187$ git fetch origin --prune --prune-tags
188$ git fetch origin --prune 'refs/tags/*:refs/tags/*'
189$ git fetch <url-of-origin> --prune --prune-tags
190$ git fetch <url-of-origin> --prune 'refs/tags/*:refs/tags/*'
191------------------------------------------------
192
193OUTPUT
194------
195
196The output of "git fetch" depends on the transport method used; this
197section describes the output when fetching over the Git protocol
198(either locally or via ssh) and Smart HTTP protocol.
199
200The status of the fetch is output in tabular form, with each line
201representing the status of a single ref. Each line is of the form:
202
203-------------------------------
204 <flag> <summary> <from> -> <to> [<reason>]
205-------------------------------
206
207When using `--porcelain`, the output format is intended to be
208machine-parseable. In contrast to the human-readable output formats it
209thus prints to standard output instead of standard error. Each line is
210of the form:
211
212-------------------------------
213<flag> <old-object-id> <new-object-id> <local-reference>
214-------------------------------
215
216The status of up-to-date refs is shown only if the --verbose option is
217used.
218
219In compact output mode, specified with configuration variable
220fetch.output, if either entire `<from>` or `<to>` is found in the
221other string, it will be substituted with `*` in the other string. For
222example, `master -> origin/master` becomes `master -> origin/*`.
223
224flag::
225 A single character indicating the status of the ref:
226(space);; for a successfully fetched fast-forward;
227`+`;; for a successful forced update;
228`-`;; for a successfully pruned ref;
229`t`;; for a successful tag update;
230`*`;; for a successfully fetched new ref;
231`!`;; for a ref that was rejected or failed to update; and
232`=`;; for a ref that was up to date and did not need fetching.
233
234summary::
235 For a successfully fetched ref, the summary shows the old and new
236 values of the ref in a form suitable for using as an argument to
237 `git log` (this is `<old>..<new>` in most cases, and
238 `<old>...<new>` for forced non-fast-forward updates).
239
240from::
241 The name of the remote ref being fetched from, minus its
242 `refs/<type>/` prefix. In the case of deletion, the name of
243 the remote ref is "(none)".
244
245to::
246 The name of the local ref being updated, minus its
247 `refs/<type>/` prefix.
248
249reason::
250 A human-readable explanation. In the case of successfully fetched
251 refs, no explanation is needed. For a failed ref, the reason for
252 failure is described.
253
254EXAMPLES
255--------
256
257* Update the remote-tracking branches:
258+
259------------------------------------------------
260$ git fetch origin
261------------------------------------------------
262+
263The above command copies all branches from the remote `refs/heads/`
264namespace and stores them to the local `refs/remotes/origin/` namespace,
265unless the `remote.<repository>.fetch` option is used to specify a
266non-default refspec.
267
268* Using refspecs explicitly:
269+
270------------------------------------------------
271$ git fetch origin +seen:seen maint:tmp
272------------------------------------------------
273+
274This updates (or creates, as necessary) branches `seen` and `tmp` in
275the local repository by fetching from the branches (respectively)
276`seen` and `maint` from the remote repository.
277+
278The `seen` branch will be updated even if it does not fast-forward,
279because it is prefixed with a plus sign; `tmp` will not be.
280
281* Peek at a remote's branch, without configuring the remote in your local
282 repository:
283+
284------------------------------------------------
285$ git fetch git://git.kernel.org/pub/scm/git/git.git maint
286$ git log FETCH_HEAD
287------------------------------------------------
288+
289The first command fetches the `maint` branch from the repository at
290`git://git.kernel.org/pub/scm/git/git.git` and the second command uses
291`FETCH_HEAD` to examine the branch with linkgit:git-log[1]. The fetched
292objects will eventually be removed by git's built-in housekeeping (see
293linkgit:git-gc[1]).
294
295include::transfer-data-leaks.adoc[]
296
297CONFIGURATION
298-------------
299
300include::includes/cmd-config-section-all.adoc[]
301
302include::config/fetch.adoc[]
303
304BUGS
305----
306Using --recurse-submodules can only fetch new commits in submodules that are
307present locally e.g. in `$GIT_DIR/modules/`. If the upstream adds a new
308submodule, that submodule cannot be fetched until it is cloned e.g. by `git
309submodule update`. This is expected to be fixed in a future Git version.
310
311SEE ALSO
312--------
313linkgit:git-pull[1]
314
315GIT
316---
317Part of the linkgit:git[1] suite