git-push
(1)
名称
git-push - Update remote refs along with associated objects
用法概要
git push [--all | --mirror | --tags] [-n | --dry-run] [--receive-pack=<git-receive-pack>]
[--repo=<repository>] [-f | --force] [-v | --verbose] [-u | --set-upstream]
[<repository> [<refspec>...]]
描述
Git Manual GIT-PUSH(1)
NAME
git-push - Update remote refs along with associated objects
SYNOPSIS
git push [--all | --mirror | --tags] [-n | --dry-run] [--receive-pack=<git-receive-pack>]
[--repo=<repository>] [-f | --force] [-v | --verbose] [-u | --set-upstream]
[<repository> [<refspec>...]]
DESCRIPTION
Updates remote refs using local refs, while sending objects
necessary to complete the given refs.
You can make interesting things happen to a repository every
time you push into it, by setting up hooks there. See
documentation for git-receive-pack(1).
OPTIONS
<repository>
The "remote" repository that is destination of a push
operation. This parameter can be either a URL (see the
section GIT URLS below) or the name of a remote (see the
section REMOTES below).
<refspec>...
The format of a <refspec> parameter is an optional plus
+, followed by the source ref <src>, followed by a colon
:, followed by the destination ref <dst>. It is used to
specify with what <src> object the <dst> ref in the
remote repository is to be updated.
The <src> is often the name of the branch you would want
to push, but it can be any arbitrary "SHA-1 expression",
such as master~4 or HEAD (see gitrevisions(5)).
The <dst> tells which ref on the remote side is updated
with this push. Arbitrary expressions cannot be used
here, an actual ref must be named. If :<dst> is omitted,
the same ref as <src> will be updated.
The object referenced by <src> is used to update the
<dst> reference on the remote side, but by default this
is only allowed if the update can fast-forward <dst>. By
having the optional leading +, you can tell git to
update the <dst> ref even when the update is not a
fast-forward. This does not attempt to merge <src> into
<dst>. See EXAMPLES below for details.
tag <tag> means the same as
refs/tags/<tag>:refs/tags/<tag>.
Pushing an empty <src> allows you to delete the <dst>
Git 1.7.9.2 Last change: 02/22/2012 1
Git Manual GIT-PUSH(1)
ref from the remote repository.
The special refspec : (or +: to allow non-fast-forward
updates) directs git to push "matching" branches: for
every branch that exists on the local side, the remote
side is updated if a branch of the same name already
exists on the remote side. This is the default operation
mode if no explicit refspec is found (that is neither on
the command line nor in any Push line of the
corresponding remotes file---see below).
--all
Instead of naming each ref to push, specifies that all
refs under refs/heads/ be pushed.
--mirror
Instead of naming each ref to push, specifies that all
refs under refs/ (which includes but is not limited to
refs/heads/, refs/remotes/, and refs/tags/) be mirrored
to the remote repository. Newly created local refs will
be pushed to the remote end, locally updated refs will
be force updated on the remote end, and deleted refs
will be removed from the remote end. This is the default
if the configuration option remote.<remote>.mirror is
set.
-n, --dry-run
Do everything except actually send the updates.
--porcelain
Produce machine-readable output. The output status line
for each ref will be tab-separated and sent to stdout
instead of stderr. The full symbolic names of the refs
will be given.
--delete
All listed refs are deleted from the remote repository.
This is the same as prefixing all refs with a colon.
--tags
All refs under refs/tags are pushed, in addition to
refspecs explicitly listed on the command line.
--receive-pack=<git-receive-pack>, --exec=<git-receive-pack>
Path to the git-receive-pack program on the remote end.
Sometimes useful when pushing to a remote repository
over ssh, and you do not have the program in a directory
on the default $PATH.
-f, --force
Usually, the command refuses to update a remote ref that
is not an ancestor of the local ref used to overwrite
Git 1.7.9.2 Last change: 02/22/2012 2
Git Manual GIT-PUSH(1)
it. This flag disables the check. This can cause the
remote repository to lose commits; use it with care.
--repo=<repository>
This option is only relevant if no <repository> argument
is passed in the invocation. In this case, git push
derives the remote name from the current branch: If it
tracks a remote branch, then that remote repository is
pushed to. Otherwise, the name "origin" is used. For
this latter case, this option can be used to override
the name "origin". In other words, the difference
between these two commands
git push public #1
git push --repo=public #2
is that #1 always pushes to "public" whereas #2 pushes
to "public" only if the current branch does not track a
remote branch. This is useful if you write an alias or
script around git push.
-u, --set-upstream
For every branch that is up to date or successfully
pushed, add upstream (tracking) reference, used by
argument-less git-pull(1) and other commands. For more
information, see branch.<name>.merge in git-config(1).
--thin, --no-thin
These options are passed to git-send-pack(1). A thin
transfer significantly reduces the amount of sent data
when the sender and receiver share many of the same
objects in common. The default is --thin.
-q, --quiet
Suppress all output, including the listing of updated
refs, unless an error occurs. Progress is not reported
to the standard error stream.
-v, --verbose
Run verbosely.
--progress
Progress status is reported on the standard error stream
by default when it is attached to a terminal, unless -q
is specified. This flag forces progress status even if
the standard error stream is not directed to a terminal.
--recurse-submodules=check
Check whether all submodule commits used by the
revisions to be pushed are available on a remote
tracking branch. Otherwise the push will be aborted and
the command will exit with non-zero status.
Git 1.7.9.2 Last change: 02/22/2012 3
Git Manual GIT-PUSH(1)
GIT URLS
In general, URLs contain information about the transport
protocol, the address of the remote server, and the path to
the repository. Depending on the transport protocol, some of
this information may be absent.
Git natively supports ssh, git, http, https, ftp, ftps, and
rsync protocols. The following syntaxes may be used with
them:
o ssh://[user@]host.xz[:port]/path/to/repo.git/
o git://host.xz[:port]/path/to/repo.git/
o http[s]://host.xz[:port]/path/to/repo.git/
o ftp[s]://host.xz[:port]/path/to/repo.git/
o rsync://host.xz/path/to/repo.git/
An alternative scp-like syntax may also be used with the ssh
protocol:
o [user@]host.xz:path/to/repo.git/
The ssh and git protocols additionally support ~username
expansion:
o ssh://[user@]host.xz[:port]/~[user]/path/to/repo.git/
o git://host.xz[:port]/~[user]/path/to/repo.git/
o [user@]host.xz:/~[user]/path/to/repo.git/
For local repositories, also supported by git natively, the
following syntaxes may be used:
o /path/to/repo.git/
o file:///path/to/repo.git/
These two syntaxes are mostly equivalent, except when
cloning, when the former implies --local option. See git-
clone(1) for details.
When git doesn't know how to handle a certain transport
protocol, it attempts to use the remote-<transport> remote
helper, if one exists. To explicitly request a remote
helper, the following syntax may be used:
o <transport>::<address>
Git 1.7.9.2 Last change: 02/22/2012 4
Git Manual GIT-PUSH(1)
where <address> may be a path, a server and path, or an
arbitrary URL-like string recognized by the specific remote
helper being invoked. See git-remote-helpers(1) for details.
If there are a large number of similarly-named remote
repositories and you want to use a different format for them
(such that the URLs you use will be rewritten into URLs that
work), you can create a configuration section of the form:
[url "<actual url base>"]
insteadOf = <other url base>
For example, with this:
[url "git://git.host.xz/"]
insteadOf = host.xz:/path/to/
insteadOf = work:
a URL like "work:repo.git" or like
"host.xz:/path/to/repo.git" will be rewritten in any context
that takes a URL to be "git://git.host.xz/repo.git".
If you want to rewrite URLs for push only, you can create a
configuration section of the form:
[url "<actual url base>"]
pushInsteadOf = <other url base>
For example, with this:
[url "ssh://example.org/"]
pushInsteadOf = git://example.org/
a URL like "git://example.org/path/to/repo.git" will be
rewritten to "ssh://example.org/path/to/repo.git" for
pushes, but pulls will still use the original URL.
REMOTES
The name of one of the following can be used instead of a
URL as <repository> argument:
o a remote in the git configuration file: $GIT_DIR/config,
o a file in the $GIT_DIR/remotes directory, or
o a file in the $GIT_DIR/branches directory.
All of these also allow you to omit the refspec from the
Git 1.7.9.2 Last change: 02/22/2012 5
Git Manual GIT-PUSH(1)
command line because they each contain a refspec which git
will use by default.
Named remote in configuration file
You can choose to provide the name of a remote which you had
previously configured using git-remote(1), git-config(1) or
even by a manual edit to the $GIT_DIR/config file. The URL
of this remote will be used to access the repository. The
refspec of this remote will be used by default when you do
not provide a refspec on the command line. The entry in the
config file would appear like this:
[remote "<name>"]
url = <url>
pushurl = <pushurl>
push = <refspec>
fetch = <refspec>
The <pushurl> is used for pushes only. It is optional and
defaults to <url>.
Named file in $GIT_DIR/remotes
You can choose to provide the name of a file in
$GIT_DIR/remotes. The URL in this file will be used to
access the repository. The refspec in this file will be used
as default when you do not provide a refspec on the command
line. This file should have the following format:
URL: one of the above URL format
Push: <refspec>
Pull: <refspec>
Push: lines are used by git push and Pull: lines are used by
git pull and git fetch. Multiple Push: and Pull: lines may
be specified for additional branch mappings.
Named file in $GIT_DIR/branches
You can choose to provide the name of a file in
$GIT_DIR/branches. The URL in this file will be used to
access the repository. This file should have the following
format:
<url>#<head>
<url> is required; #<head> is optional.
Depending on the operation, git will use one of the
following refspecs, if you don't provide one on the command
line. <branch> is the name of this file in $GIT_DIR/branches
Git 1.7.9.2 Last change: 02/22/2012 6
Git Manual GIT-PUSH(1)
and <head> defaults to master.
git fetch uses:
refs/heads/<head>:refs/heads/<branch>
git push uses:
HEAD:refs/heads/<head>
OUTPUT
The output of "git push" depends on the transport method
used; this section describes the output when pushing over
the git protocol (either locally or via ssh).
The status of the push is output in tabular form, with each
line representing the status of a single ref. Each line is
of the form:
<flag> <summary> <from> -> <to> (<reason>)
If --porcelain is used, then each line of the output is of
the form:
<flag> \t <from>:<to> \t <summary> (<reason>)
The status of up-to-date refs is shown only if --porcelain
or --verbose option is used.
flag
A single character indicating the status of the ref:
(space)
for a successfully pushed fast-forward;
+
for a successful forced update;
-
for a successfully deleted ref;
*
for a successfully pushed new ref;
!
for a ref that was rejected or failed to push; and
Git 1.7.9.2 Last change: 02/22/2012 7
Git Manual GIT-PUSH(1)
=
for a ref that was up to date and did not need
pushing.
summary
For a successfully pushed ref, the summary shows the old
and new values of the ref in a form suitable for using
as an argument to git log (this is <old>..<new> in most
cases, and <old>...<new> for forced non-fast-forward
updates).
For a failed update, more details are given:
rejected
Git did not try to send the ref at all, typically
because it is not a fast-forward and you did not
force the update.
remote rejected
The remote end refused the update. Usually caused by
a hook on the remote side, or because the remote
repository has one of the following safety options
in effect: receive.denyCurrentBranch (for pushes to
the checked out branch), receive.denyNonFastForwards
(for forced non-fast-forward updates),
receive.denyDeletes or receive.denyDeleteCurrent.
See git-config(1).
remote failure
The remote end did not report the successful update
of the ref, perhaps because of a temporary error on
the remote side, a break in the network connection,
or other transient error.
from
The name of the local ref being pushed, minus its
refs/<type>/ prefix. In the case of deletion, the name
of the local ref is omitted.
to
The name of the remote ref being updated, minus its
refs/<type>/ prefix.
reason
A human-readable explanation. In the case of
successfully pushed refs, no explanation is needed. For
a failed ref, the reason for failure is described.
NOTE ABOUT FAST-FORWARDS
When an update changes a branch (or more in general, a ref)
that used to point at commit A to point at another commit B,
it is called a fast-forward update if and only if B is a
Git 1.7.9.2 Last change: 02/22/2012 8
Git Manual GIT-PUSH(1)
descendant of A.
In a fast-forward update from A to B, the set of commits
that the original commit A built on top of is a subset of
the commits the new commit B builds on top of. Hence, it
does not lose any history.
In contrast, a non-fast-forward update will lose history.
For example, suppose you and somebody else started at the
same commit X, and you built a history leading to commit B
while the other person built a history leading to commit A.
The history looks like this:
B
/
---X---A
Further suppose that the other person already pushed changes
leading to A back to the original repository you two
obtained the original commit X.
The push done by the other person updated the branch that
used to point at commit X to point at commit A. It is a
fast-forward.
But if you try to push, you will attempt to update the
branch (that now points at A) with commit B. This does not
fast-forward. If you did so, the changes introduced by
commit A will be lost, because everybody will now start
building on top of B.
The command by default does not allow an update that is not
a fast-forward to prevent such loss of history.
If you do not want to lose your work (history from X to B)
nor the work by the other person (history from X to A), you
would need to first fetch the history from the repository,
create a history that contains changes done by both parties,
and push the result back.
You can perform "git pull", resolve potential conflicts, and
"git push" the result. A "git pull" will create a merge
commit C between commits A and B.
B---C
/ /
---X---A
Updating A with the resulting merge commit will fast-forward
and your push will be accepted.
Git 1.7.9.2 Last change: 02/22/2012 9
Git Manual GIT-PUSH(1)
Alternatively, you can rebase your change between X and B on
top of A, with "git pull --rebase", and push the result
back. The rebase will create a new commit D that builds the
change between X and B on top of A.
B D
/ /
---X---A
Again, updating A with this commit will fast-forward and
your push will be accepted.
There is another common situation where you may encounter
non-fast-forward rejection when you try to push, and it is
possible even when you are pushing into a repository nobody
else pushes into. After you push commit A yourself (in the
first picture in this section), replace it with "git commit
--amend" to produce commit B, and you try to push it out,
because forgot that you have pushed A out already. In such a
case, and only if you are certain that nobody in the
meantime fetched your earlier commit A (and started building
on top of it), you can run "git push --force" to overwrite
it. In other words, "git push --force" is a method reserved
for a case where you do mean to lose history.
EXAMPLES
git push
Works like git push <remote>, where <remote> is the
current branch's remote (or origin, if no remote is
configured for the current branch).
git push origin
Without additional configuration, works like git push
origin :.
The default behavior of this command when no <refspec>
is given can be configured by setting the push option of
the remote.
For example, to default to pushing only the current
branch to origin use git config remote.origin.push HEAD.
Any valid <refspec> (like the ones in the examples
below) can be configured as the default for git push
origin.
git push origin :
Push "matching" branches to origin. See <refspec> in the
OPTIONS section above for a description of "matching"
branches.
Git 1.7.9.2 Last change: 02/22/2012 10
Git Manual GIT-PUSH(1)
git push origin master
Find a ref that matches master in the source repository
(most likely, it would find refs/heads/master), and
update the same ref (e.g. refs/heads/master) in origin
repository with it. If master did not exist remotely, it
would be created.
git push origin HEAD
A handy way to push the current branch to the same name
on the remote.
git push origin master:satellite/master dev:satellite/dev
Use the source ref that matches master (e.g.
refs/heads/master) to update the ref that matches
satellite/master (most probably
refs/remotes/satellite/master) in the origin repository,
then do the same for dev and satellite/dev.
git push origin HEAD:master
Push the current branch to the remote ref matching
master in the origin repository. This form is convenient
to push the current branch without thinking about its
local name.
git push origin master:refs/heads/experimental
Create the branch experimental in the origin repository
by copying the current master branch. This form is only
needed to create a new branch or tag in the remote
repository when the local name and the remote name are
different; otherwise, the ref name on its own will work.
git push origin :experimental
Find a ref that matches experimental in the origin
repository (e.g. refs/heads/experimental), and delete
it.
git push origin +dev:master
Update the origin repository's master branch with the
dev branch, allowing non-fast-forward updates. This can
leave unreferenced commits dangling in the origin
repository. Consider the following situation, where a
fast-forward is not possible:
o---o---o---A---B origin/master
\
X---Y---Z dev
The above command would change the origin repository to
A---B (unnamed branch)
/
o---o---o---X---Y---Z master
Git 1.7.9.2 Last change: 02/22/2012 11
Git Manual GIT-PUSH(1)
Commits A and B would no longer belong to a branch with
a symbolic name, and so would be unreachable. As such,
these commits would be removed by a git gc command on
the origin repository.
GIT
Part of the git(1) suite
ATTRIBUTES
See attributes(5) for descriptions of the following
attributes:
+---------------+--------------------------+
|ATTRIBUTE TYPE | ATTRIBUTE VALUE |
+---------------+--------------------------+
|Availability | developer/versioning/git |
+---------------+--------------------------+
|Stability | Uncommitted |
+---------------+--------------------------+
NOTES
This software was built from source available at
https://java.net/projects/solaris-userland. The original
community source was downloaded from http://git-
core.googlecode.com/files/git-1.7.9.2.tar.gz
Further information about this software can be found on the
open source community website at http://git-scm.com/.
Git 1.7.9.2 Last change: 02/22/2012 12