Git推错误'[远程拒绝]主 – >主(分支当前已检出)’


Git push error '[remote rejected] master -> master (branch is currently checked out)'

昨天，我发布了一个关于如何将Git存储库从我的一台机器克隆到另一台机器的问题，我怎样才能从另一台机器上"克隆"？

我现在能够成功地将Git存储库从我的源(192.168.1.2)克隆到我的目标(192.168.1.1)。

但是，当我对文件，git commit -a -m"test"和git push进行编辑时，我在目的地(192.168.1.1)上收到此错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
git push                                                
[email protected]'s password:
Counting objects: 21, done.
Compressing objects: 100% (11/11), done.
Writing objects: 100% (11/11), 1010 bytes, done.
Total 11 (delta 9), reused 0 (delta 0)
error: refusing to update checked out branch: refs/heads/master
error: By default, updating the current branch in a non-bare repository
error: is denied, because it will make the index and work tree inconsistent
error: with what you pushed, and will require 'git reset --hard' to match
error: the work tree to HEAD.
error:
error: You can set 'receive.denyCurrentBranch' configuration variable to
error: 'ignore' or 'warn' in the remote repository to allow pushing into
error: its current branch; however, this is not recommended unless you
error: arranged to update its work tree to match what you pushed in some
error: other way.
error:
error: To squelch this message and still keep the default behaviour, set
error: 'receive.denyCurrentBranch' configuration variable to 'refuse'.
To git+ssh://[email protected]/media/LINUXDATA/working
! [remote rejected] master -> master (branch is currently checked out)
error: failed to push some refs to 'git+ssh://[email protected]/media/LINUXDATA/working'

我正在使用两个不同版本的Git(远程为1.7，本地机器为1.5)。 这是一个可能的原因吗？

相关讨论

您可以简单地将远程存储库转换为裸存储库(裸存储库中没有工作副本 - 该文件夹仅包含实际的存储库数据)。

在远程存储库文件夹中执行以下命令：

1
git config --bool core.bare true

然后删除该文件夹中除.git以外的所有文件。然后，您将能够执行git push到远程存储库而不会出现任何错误。

相关讨论

我开始学习Git时，我遇到了同样的错误。其他一些答案显然不适合Git的新手！

(我将使用非技术术语来理解这个想法。)无论如何，发生的事情是你有两个存储库，一个是你最初创建的原始版本，另一个是你刚刚制作的工作版。

现在，您在工作存储库中并使用"主"分支。但是，您也恰好在原始存储库中"登录"到同一个"主"分支。既然你已经在原版中"登录"了，Git担心你可能会陷入困境，因为你可能正在研究原版并搞砸了。因此，您需要返回原始存储库并执行"git checkout someotherbranch"，现在您可以毫无问题地推送。

我希望这有帮助。

相关讨论

错误消息描述了发生的情况。如果检出该分支，更多现代版本的Git拒绝通过推送更新分支。

在两个非裸存储库之间工作的最简单方法是

  • 总是通过拉(或获取和合并)更新存储库，或者，如果必须，

  • 通过推送到单独的分支(导入分支)，然后将该分支合并到远程计算机上的主分支中。

    • 这种限制的原因是推送操作仅在远程Git存储库上运行，它无法访问索引和工作树。因此，如果允许，对已签出分支的推送会将HEAD更改为与远程存储库上的索引和工作树不一致。

    这样就很容易意外地提交撤消所有推送更改的更改，并且很难区分尚未提交的任何本地更改以及新HEAD，索引和工作树之间的差异这是由推动HEAD引起的。

    相关讨论

    摘要

    您无法推送到存储库的一个已检出分支，因为它会以最可能以数据和历史记录丢失而结束的方式弄乱该存储库的用户。但是您可以推送到同一存储库的任何其他分支。

    由于裸存储库从未检出任何分支，因此您始终可以推送到裸存储库的任何分支。

    根据您的需求，有多种解决方案。

    解决方案1：使用裸露的Repostiory

    如建议的那样，如果在一台计算机上，您不需要工作目录，则可以移至裸存储库。为避免弄乱存储库，您只需克隆它：

    1
    2
    3
    machine1$ cd ..
    machine1$ mv repo repo.old
    machine1$ git clone --bare repo.old repo

    现在，您可以将所有想要的地址推送到与以前相同的地址。

    解决方案2：推送到未签出的分支

    但是如果您需要检查远程上的代码，那么您可以使用特殊分支来推送。假设您在本地存储库中调用了远程origin，并且您在分支主服务器上。然后你可以做到

    1
    machine2$ git push origin master:master+machine2

    然后，当您在origin远程仓库中时，需要合并它：

    1
    machine1$ git merge master+machine2

    尸检的问题

    签出分支时，提交将添加一个新的提交，当前分支的头部作为其父级，并将分支的头部移动为新的提交。

    所以

    1
    2
    3
    A ← B
        ↑
    [HEAD,branch1]

    变

    1
    2
    3
    A ← B ← C
            ↑
        [HEAD,branch1]

    但是如果有人可以推送到中间的那个分支，那么用户就可以使用git调用的分离头模式：

    1
    2
    3
    A ← B ← X
        ↑   ↑
    [HEAD] [branch1]

    现在用户不再在branch1中，没有明确要求签出另一个分支。更糟糕的是，用户现在在任何分支之外，任何新的提交都只是悬空：

    1
    2
    3
    4
    5
    6
    7
          [HEAD]
            ↓
            C
          ↙
    A ← B ← X
            ↑
           [branch1]

    假设，如果在这一点上，用户检出另一个分支，那么这个悬空提交就成了Git垃圾收集器的公平游戏。

    相关讨论

    您可以通过编辑目标服务器上的.git/config来解决此"限制"。添加以下内容以允许将git存储库推送到即使它被"签出"：

    1
    2
    [receive]
    denyCurrentBranch = warn

    要么

    1
    2
    [receive]
    denyCurrentBranch = false

    第一个将允许推动，同时警告可能会弄乱分支，而第二个将静静地允许它。

    这可以用于将代码"部署"到不用于编辑的服务器。这不是最好的方法，而是快速部署代码的方法。

    相关讨论

    我喜欢在远程盒子上仍然有一个可用的存储库的想法，但我喜欢使用：而不是虚拟分支。

    1
    git checkout --detach

    这似乎是Git的一个非常新的特性 - 我使用的是git版本1.7.7.4。

    相关讨论

    git config --local receive.denyCurrentBranch updateInstead

    https://github.com/git/git/blob/v2.3.0/Documentation/config.txt#L2155

    在服务器存储库中使用它，如果没有未经跟踪的覆盖，它也会更新工作树。

    如VonC在评论中提到的那样，它被添加到Git 2.3中。

    我编译了Git 2.3并尝试了一下。样品用法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    git init server
    cd server
    touch a
    git add .
    git commit -m 0
    git config --local receive.denyCurrentBranch updateInstead

    cd ..
    git clone server local
    cd local
    touch b
    git add .
    git commit -m 1
    git push origin master:master

    cd ../server
    ls

    输出：

    1
    2
    a
    b

    是的，b被推了！

    相关讨论

    我遇到过同样的问题。对我来说，我使用Git push将代码移动到我的服务器上。我从不更改服务器端的代码，所以这是安全的。

    在存储库中，您正在推送键入：

    1
    git config receive.denyCurrentBranch ignore

    这将允许您在存储库工作副本时更改存储库。

    运行Git push后，转到远程计算机并键入：

    1
    git checkout -f

    这将使您推送的更改反映在远程计算机的工作副本中。

    请注意，如果您在要推送的工作副本中进行更改，这并不总是安全的。

    相关讨论

    您可以重新创建服务器存储库并从本地分支主服务器推送到服务器主服务器。

    在您的远程服务器上：

    1
    2
    3
    mkdir myrepo.git
    cd myrepo.git
    git init --bare

    好的，来自您当地的分支机构：

    1
    git push origin master:master
    相关讨论

    你可能做了什么导致这个：

    当你去敲一个小程序时就会发生这种事情。你即将改变已经有效的东西，所以你施放了你永久无法解决的3级法术：

    1
    machine1:~/proj1> git init

    然后你开始添加/提交。但是，然后，项目开始变得更加复杂，你想从另一台计算机(如你的家用电脑或笔记本电脑)上工作，所以你做了类似的事情

    1
    machine2:~> git clone ssh://machine1/~/proj1

    它克隆，一切看起来都很好，所以你从machine2处理你的代码。

    然后......你试图从机器2推送你的提交，你会在标题中收到警告信息。

    这条消息的原因是因为您从中提取的git repo有点仅用于machine1上的该文件夹。你可以很好地克隆它，但推动可能会导致问题。在两个不同位置管理代码的"正确"方式是使用"裸"repo，就像已经建议的那样。一个裸仓库不是为了在其中完成任何工作而设计的，它旨在协调来自多个来源的提交。这就是为什么评价最高的答案建议在git config --bool core.bare true之后删除.git文件夹以外的所有文件/文件夹。

    澄清最受欢迎的答案：对该答案的许多评论都说"我没有从机器1中删除非.git文件，我仍然能够从机器2提交"。那就对了。但是，那些其他文件现在完全与git repo"脱离"了。在那里尝试git status，你应该看到类似"致命的东西：这个操作必须在工作树中运行"。因此，删除文件的建议不是因为machine2的提交将起作用;这样你就不会感到困惑，并认为git仍在跟踪这些文件。但是，如果您仍想处理machine1上的文件，删除文件是一个问题，不是吗？

    那么，你应该怎么做？

    取决于你计划在机器1和机器2上工作多少...

    如果您已完成从machine1开发并将所有开发都移至machine2 ...只需按照评分最高的答案建议：git config --bool core.bare true然后，可选地，从该文件夹中删除.git以外的所有文件/文件夹因为它们没有被攻击并且可能引起混乱。

    如果您在machine2上的工作只是一次性的事情，而且您不需要继续在那里开发......那么就不要费心去做一个简单的回购;只需ftp / rsync / scp / etc.您的文件来自机器* 2 *在机器上的文件* 1 *，从机器* 1 *提交/推送，然后从机器* 2 *删除文件。其他人建议创建一个分支，但我认为如果你只是想将你在一次性基础上进行的一些开发合并到另一台机器上，那就太麻烦了。

    如果您需要继续在machine1和machine2上进行开发......那么您需要正确设置。您需要将您的仓库转换为裸仓，然后您需要在machine1上复制它以供您工作。可能最快的方法是做

    1
    2
    3
    4
    5
    6
    machine1:~/proj1> git config --bool core.bare true
    machine1:~/proj1> mv .git/ ../proj1.git
    machine1:~/proj1> cd ..
    machine1:~> rm -rf proj1
    machine1:~> git clone proj1.git
    machine1:~> cd proj1

    非常重要：因为你已经将repo的位置从proj1移动到proj1.git，你需要在machine2上的.git / config文件中更新它。之后，您可以从machine2提交更改。最后，我尝试将我的裸存储库放在一个中心位置，远离我的工作树(即不要将'proj1.git'放在与'proj1'相同的父文件夹中)。我建议你这样做，但我想让上面的步骤尽可能简单。

    相关讨论

    通过一些设置步骤，您可以使用单线程轻松地将更改部署到您的网站

    1
    git push production

    这很简单，你不需要登录远程服务器并做任何事情。请注意，如果您不将生产结帐用作工作分支，这将最有效！ (OP的工作范围略有不同，我认为@Robert Gould的解决方案很好地解决了这个问题。这个解决方案更适合部署到远程服务器。)

    首先，您需要在Webroot之外的服务器上的某个位置设置裸存储库。

    1
    2
    3
    mkdir mywebsite.git
    cd mywebsite.git
    git init --bare

    然后创建文件hooks/post-receive：

    1
    2
    #!/bin/sh
    GIT_WORK_TREE=/path/to/webroot/of/mywebsite git checkout -f

    并使文件可执行：

    1
    chmod +x hooks/post-receive

    在您的本地机器上

    1
    2
    git remote add production [email protected]:mywebsite.git
    git push production +master:refs/heads/master

    搞定！现在，将来您可以使用git push production来部署您的更改！

    这个解决方案归功于http://sebduggan.com/blog/deploy-your-website-changes-using-git/。在那里查看有关正在发生的事情的更详细说明。

    相关讨论

    你应该只是推到一个裸存储库。裸存储库是没有签出分支的存储库。如果你要cd到一个裸存储库目录，你只能看到.git目录的内容。

    相关讨论

    你有3个选择

  • 再拉一次：

    1
    git pull; git push

  • 推入不同的分支：

    1
    git push origin master:foo

    并将其合并到远程(通过git或pull-request)

    1
    git merge foo

  • 强制它(除非你故意通过rebase更改提交，否则不推荐)：

    1
    git push origin master -f

    如果仍然拒绝，请在远程存储库上禁用denyCurrentBranch：

    1
    git config receive.denyCurrentBranch ignore
    • 相关讨论

    实际上，将远程设置为非签出分支就足够了。在另一个分支中检出您的遥控器后，您可以推送。

    检查目标项目中的.git/config：

    1
    2
    3
    4
    5
    6
    7
    8
    $ cat .git/config
    [core]
        repositoryformatversion = 0
        filemode = true
        bare = false
        logallrefupdates = true
    [receive]
        denyCurrentBranch = updateInstead

    如果core. bare为false，则可以将其设置为true：

    1
    $ git config core.bare true

    然后在本地推送到远程：

    1
    git push remote_repo   // suppose the destination repo is remote_repo

    它会成功，在remote_repo中你可以检查git版本。

    1
    2
    3
    4
    $ git log -1
    commit 0623b1b900ef7331b9184722a5381bbdd2d935ba
    Author: aircraft < [email protected]>
    Date:   Thu May 17 21:54:37 2018 +0800

    现在你不能在你的"工作区"中使用git：

    1
    2
    $ git status
    fatal: This operation must be run in a work tree

    你应该将bare.bare设置为false。

    1
    $ git config core.bare false

    我在使用Git同步我的Android手机和笔记本电脑上的存储库时遇到了同样的问题。正如@CharlesBailey建议的那样，我的解决方案是做一次拉动而不是推动。

    Android存储库上的git push origin master对我来说失败了，因为推送了一个非正常的存储库+工作副本的错误消息@ hap497。

    笔记本电脑存储库中的git pull droid master和工作副本对我有用。当然，你需要先运行类似git remote add droid /media/KINGSTON4GB/notes_repo/的东西。

    较旧版本的Git曾经允许推送到非裸存储库的当前检出的分支。

    事实证明这是一个令人困惑的事情。所以他们添加了你看到的警告信息，这也非常令人困惑。

    如果第一个存储库只是充当服务器，那么将其转换为裸存储库，因为其他答案建议并完成它。

    但是，如果您需要在两个正在使用的repos之间使用共享分支，则可以通过以下设置实现它

    Repo1 - 将充当服务器并且还用于开发

    Repo2 - 仅用于开发

    设置Repo1如下

    创建一个分支以共享工作。

    1
    git branch shared_branch

    为了安全起见，您还应该创建一个$(REPO).git / hooks / update来拒绝对shared_branch以外的任何更改，因为您不希望人们捣乱您的私有分支。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    repo1/.git/hooks  (GIT_DIR!)$ cat update
    #!/bin/sh
    refname="$1"
    oldrev="$2"
    newrev="$3"

    if ["${refname}" !="refs/heads/shared_branch" ]
    then
       echo"You can only push changes to shared_branch, you cannot push to ${refname}"
       exit 1
    fi

    现在在repo1中创建一个本地分支，您将在其中执行实际工作。

    1
    2
    3
    git checkout -b my_work --track shared_branch
    Branch my_work set up to track local branch shared_branch.
    Switched to a new branch 'my_work'

    (可能需要git config --global push.default upstream才能使git push工作)

    现在你可以创建repo2了

    1
    2
    git clone path/to/repo1 repo2
    git checkout shared_branch

    此时，您可以将repo1和repo2设置为在repo1中从shared_branch推送和拉出的本地分支上工作，而无需担心该错误消息或工作目录在repo1中不同步。无论您使用哪种正常工作流程都应该有效

    这是一个测试，你可以看看bare服务器的工作原理：

    想象一下，您有一个工作站和一个托管了实时站点的服务器，并且您希望不时更新此站点(这也适用于两个开发人员通过裸中间人来回发送他们的工作的情况)。

    初始化

    在本地计算机上创建一个目录并在其中创建cd，然后执行以下命令：

    1
    2
    3
    4
    # initialization
    git init --bare server/.git
    git clone server content
    git clone server local
  • 首先，创建一个裸server目录(注意结尾处的.git)。此目录仅用作存储库文件的容器。
  • 然后将服务器存储库克隆到新创建的content目录。这是您的实时/生产目录，它将由您的服务器软件提供。
  • 前两个目录驻留在您的服务器上，第三个目录是工作站上的本地目录。

    • 工作流程

    现在这里是基本的工作流程：

  • 输入local目录，创建一些文件并提交它们。最后将它们推送到服务器：

    1
    2
    3
    # create crazy stuff
    git commit -av
    git push origin master

  • 现在进入content目录并更新服务器的内容：

    1
    git pull

  • 重复1-2。这里content可能是另一个可以推送到服务器的开发人员，而local可能会从他那里拉出来。

    • 好的，如果你想要一个普通的远程存储库，那么创建一个额外的分支并检查它。将其推入一个分支(未检出)并将其与从本地推送后当前处于活动状态的分支合并。

    例如，在远程服务器上：

    1
    2
    git branch dev
    git checkout dev

    在本地设置：

    1
    git push

    在远程服务器上：

    1
    git merge dev

    最好的方法是：

    1
    2
    3
    mkdir ..../remote
    cd ..../remote
    git clone --bare .../currentrepo/

    这将克隆存储库，但它不会在.../remote中创建任何工作副本。如果你看一下遥控器，你会看到一个名为currentrepo.git的目录，这可能是你想要的。

    然后从您当地的Git存储库：

    1
    git remote add remoterepo ..../remote/currentrepo.git

    进行更改后，您可以：

    1
    git push remoterepo master

    我发现可能对其他人有用的文章是Git在5分钟内完成的。

    我在Git版本控制下有一个Xcode项目，我想要推送到DC中的虚拟分布式以太网(VDE)。 VDE运行Centos 5。

    我读到的关于Git的文章都没有谈到裸存储库。这一切听起来都很简单，直到我尝试了我认为应该很容易从SVN背景来的东西。

    这里建议使远程存储库工作。对我的要求更好的是将Xcode项目克隆到projectname.git，将其复制到远程服务器;然后推动神奇地工作。下一步将是让Xcode推送没有关于提交的错误，但是现在我可以从终端进行操作。

    所以：

    1
    2
    3
    cd /tmp (or another other directory on your system)<br/>
    git clone --bare /xcode-project-directory projectname.git<br/>
    scp -r projectname.git [email protected]:repos/<br/>

    在Xcode中提交后，要从Xcode项目中推送更改：

    1
    2
    cd /xcode-project-directory<br/>
    git push [email protected]:repos/projectname.git<br/>

    我确信有更平滑更复杂的方法来做到这一点，但至少这是有效的。一切都很清楚，这里有一些澄清：
    /xcode-project-directory是存储xcode项目的目录。它可能是/Users/Your_Name/Documents/Project_Name。
    projectname实际上是项目的名称，但它可以是您关注的任何内容。你会的，Git不关心。

    要使用scp，您需要在远程服务器上拥有允许SSH访问的用户帐户。任何运行自己的服务器的人都会有这个。如果您正在使用共享主机等，那么您可能会失败。

    remotehost.com是远程主机的名称。您可以轻松使用其IP地址。为了进一步说明我使用SSH密钥在远程主机上使用Gitosis，所以当我推送时我不会被提示输入密码。文章Hosting Git Repositories，Easy(and Secure)Way告诉你如何设置所有这些。

    使用它将它推送到远程上游分支为我解决了这个问题：

    1
    git push <remote> master:origin/master

    遥控器无法访问上游仓库，因此这是获取最新更改的好方法

    相关讨论

    我相信大多数观看这个问题的人都会停在前两个巨大的答案，但我仍然想提供我的解决方案。

    遇到所描述的错误时，我有一个Eclipse + EGit Web项目设置。帮助我的只是使用GitHub应用程序，它似乎神奇地解决了这个问题。虽然EGit总是拒绝推送，但GitHub桌面应用程序只会耸耸肩并推动我的改变。也许它更优雅地处理多登录情况。

    我刚刚在Heroku上使用部署git存储库遇到了这个问题。

    我不知道为什么Heroku有一个非裸存储库，但作为一种解决方法，我能够重置远程存储库，并重新上传。

    你不应该使用Heroku的存储库副本作为你唯一的git存储库进行协作，但为了以防万一，我会清楚地说：除非你确定你的存储库的完整副本安全地存储在除了以外的地方，否则不要这样做。 Heroku的。执行重置将删除存储库内容。

    重置：

  • 如果您还没有安装Heroku工具带(包含命令行客户端)。

  • 如果你还没有安装heroku-repo插件。

    1
    heroku plugins:install https://github.com/heroku/heroku-repo.git

  • 执行重置，删除存储库并创建一个新的空存储库

    1
    heroku repo:reset

  • 像往常一样推到你的Heroku遥控器;它会重新上传一切。

    • 相关讨论

    比如，创建空(裸)存储库后，您需要更改远程服务器上的配置文件

    1
    root@development:/home/git/repository/my-project# cat config

    在那里你会看到

    1
    2
    3
    4
    5
    [core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true

    你将这个裸到假为真，我删除了logallrefupdates = true(不确定它的使用！)

    至

    1
    2
    3
    4
    [core]
    repositoryformatversion = 0
    filemode = true
    bare = true

    您可以测试以下内容

    1
    2
    3
    4
    5
    $ git remote show origin
    * remote origin
    Fetch URL: my-portal@development:/home/XYZ/repository/XYZ
    Push  URL: my-portal@development:/home/XYZ/repository/XYZ
    HEAD branch: (unknown)

    如果您无法推动，将显示此HEAD分支:(未知)。因此，如果HEAD分支是未知的，则应将bare更改为true，并且在推送成功后，您可以重用

    1
    git remote show origin

    你会看到的

    1
     HEAD branch: master

    我不得不在现有的裸存储库中重新运行git --init，这在裸存储库树中创建了一个.git目录 - 我意识到在那里键入git status之后。我删除了，一切都很好:)

    (所有这些答案都很棒，但就我而言，这是完全不同的(据我所知)，如上所述。)

    对我来说工作解决方案是：

    ON REMOTE：

    1
    git checkout -b some_tmp_name

    在本地：

    1
    git push

    ON REMOTE：

    1
    2
    git checkout master
    git branch -d some_tmp_name

    但这不是真正的解决方案，它只是解决方法。

    相关讨论

    以防有人发现它有用。对我来说这是一个git服务器权限问题。我从开始检查项目并推送一个简单的文件，然后我得到了"推送被拒绝：推送到源/主被拒绝"

    使用Git，两个常规(非裸)存储库无法直接来回推送/拉取文件。必须有一个中间裸存储库。显然，这有点像已婚夫妇有一个孩子，这对夫妇正在离婚。父母不会互相交谈，但他们会通过孩子进行交流。

    因此，您有一个存储库，将此存储库克隆到裸存储库，然后将其克隆到第三个存储库。第一个和第三个可以通过第二个存储库(裸存储库)交换信息。我想这是有道理的，因为您不希望有人在未经您同意的情况下将内容检查到您的存储库中，因为这可能会导致合并冲突等。

    所以，这是一个例子：

    在PC上，在?/ workspace中

    1
    2
    3
    4
    5
    6
    7
    git init
    echo"line 1"> afile.txt
    git add .
    git commit -m ‘initial import’
    git clone --bare . ../remote-repository.git
    git remote add origin ../remote-repository.git
    git push --set-upstream origin master

    在笔记本电脑上，?/ workspace(不要做git init等)

    1
    git clone //LJZ-DELLPC/remote-repository.git/ .

    //然后进行各种提交，然后推送它们：

    1
    2
    3
    4
    echo"line 2"> afile.txt
    git add afile.txt
    git commit -m 'added line 2'
    git push

    然后回到PC上，在?/ workspace中

    1
    git pull

    //然后进行各种提交，然后推送它们：

    1
    git push

    在笔记本上
    git pull

    等等..

    这是一个绝对具体的例子，在一台机器上，直接从命令窗口复制，这样我们就知道没有任何步骤被遗漏，它确实有效，等等：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    lylez@LJZ-DELLPC ~
    $ cd gitdir
    /home/lylez/gitdir

    lylez@LJZ-DELLPC ~/gitdir
    $ ls

    lylez@LJZ-DELLPC ~/gitdir
    $ mkdir repo1

    lylez@LJZ-DELLPC ~/gitdir
    $ cd repo1
    /home/lylez/gitdir/repo1

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git init
    Initialized empty Git repository in /home/lylez/gitdir/repo1/.git/

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ echo"line 1"> afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git add afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git commit -m 'initial import'
    [master (root-commit) f407e12] initial import
     1 file changed, 1 insertion(+)
     create mode 100644 afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git clone --bar . ../repo1-bare-clone
    Cloning into bare repository '../repo1-bare-clone'...
    done.

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git remote add origin ../repo1-bare-clone

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git push --set-upstream origin master
    Branch master set up to track remote branch master from origin.
    Everything up-to-date

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ cd ..

    lylez@LJZ-DELLPC ~/gitdir
    $ ls
    repo1  repo1-bare-clone

    lylez@LJZ-DELLPC ~/gitdir
    $ mkdir repo1-remote

    lylez@LJZ-DELLPC ~/gitdir
    $ cd repo1-remote
    /home/lylez/gitdir/repo1-remote

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ git clone ../repo1-bare-clone .
    Cloning into '.'...
    done.

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ ls
    afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ cat afile.txt
    line 1

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ echo"line 2">> afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ git add afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ git commit -m 'added line 2'
    [master 5ad31e0] added line 2
     1 file changed, 1 insertion(+)

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ git push
    Counting objects: 3, done.
    Writing objects: 100% (3/3), 260 bytes | 0 bytes/s, done.
    Total 3 (delta 0), reused 0 (delta 0)
    To /home/lylez/gitdir/repo1-remote/../repo1-bare-clone
       f407e12..5ad31e0  master -> master

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ cd ../repo1

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ ls
    afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ cat afile.txt
    line 1

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git pull
    remote: Counting objects: 3, done.
    remote: Total 3 (delta 0), reused 0 (delta 0)
    Unpacking objects: 100% (3/3), done.
    From ../repo1-bare-clone
       f407e12..5ad31e0  master     -> origin/master
    Updating f407e12..5ad31e0
    Fast-forward
     afile.txt | 1 +
     1 file changed, 1 insertion(+)

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ cat afile.txt
    line 1
    line 2

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ echo"line 3">> afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git add afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git commit -m 'added line 3'
    [master 3fa569e] added line 3
     1 file changed, 1 insertion(+)

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ git push
    Counting objects: 3, done.
    Writing objects: 100% (3/3), 265 bytes | 0 bytes/s, done.
    Total 3 (delta 0), reused 0 (delta 0)
    To ../repo1-bare-clone
       5ad31e0..3fa569e  master -> master

    lylez@LJZ-DELLPC ~/gitdir/repo1
    $ cd ../repo1-remote/

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ ls
    afile.txt

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ cat afile.txt
    line 1
    line 2

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ git pull
    remote: Counting objects: 3, done.
    remote: Total 3 (delta 0), reused 0 (delta 0)
    Unpacking objects: 100% (3/3), done.
    From /home/lylez/gitdir/repo1-remote/../repo1-bare-clone
       5ad31e0..3fa569e  master     -> origin/master
    Updating 5ad31e0..3fa569e
    Fast-forward
     afile.txt | 1 +
     1 file changed, 1 insertion(+)

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ cat afile.txt
    line 1
    line 2
    line 3

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    $ git --version
    git version 2.1.1

    lylez@LJZ-DELLPC ~/gitdir/repo1-remote
    相关讨论

    我的解决方案(使用中)

  • 在远程服务器上签出"master"
  • 在"dev"分支上本地工作
  • 将更改推送到远程开发
  • 将dev合并到远程的master上

    • 答对了