• 10.7 Git 内部原理 - 维护与数据恢复
    • 维护与数据恢复
      • 维护
      • 数据恢复
      • 移除对象

    10.7 Git 内部原理 - 维护与数据恢复

    维护与数据恢复

    有的时候，你需要对仓库进行清理 - 使它的结构变得更紧凑，或是对导入的仓库进行清理，或是恢复丢失的内容。这个小节将会介绍这些情况中的一部分。

    维护

    Git 会不定时地自动运行一个叫做 “auto gc” 的命令。大多数时候，这个命令并不会产生效果。然而，如果有太多松散对象（不在包文件中的对象）或者太多包文件，Git 会运行一个完整的 git gc 命令。“gc” 代表垃圾回收，这个命令会做以下事情：收集所有松散对象并将它们放置到包文件中，将多个包文件合并为一个大的包文件，移除与任何提交都不相关的陈旧对象。

    可以像下面一样手动执行自动垃圾回收：

    1. $ git gc --auto

    就像上面提到的，这个命令通常并不会产生效果。大约需要 7000 个以上的松散对象或超过 50 个的包文件才能让 Git 启动一次真正的 gc 命令。你可以通过修改 gc.auto 与 gc.autopacklimit 的设置来改动这些数值。

    gc 将会做的另一件事是打包你的引用到一个单独的文件。假设你的仓库包含以下分支与标签：

    1. $ find .git/refs -type f
    2. .git/refs/heads/experiment
    3. .git/refs/heads/master
    4. .git/refs/tags/v1.0
    5. .git/refs/tags/v1.1

    如果你执行了 git gc 命令，refs 目录中将不会再有这些文件。为了保证效率 Git 会将它们移动到名为 .git/packed-refs 的文件中，就像这样：

    1. $ cat .git/packed-refs
    2. # pack-refs with: peeled fully-peeled
    3. cac0cab538b970a37ea1e769cbbde608743bc96d refs/heads/experiment
    4. ab1afef80fac8e34258ff41fc1b867c702daa24b refs/heads/master
    5. cac0cab538b970a37ea1e769cbbde608743bc96d refs/tags/v1.0
    6. 9585191f37f7b0fb9444f35a9bf50de191beadc2 refs/tags/v1.1
    7. ^1a410efbd13591db07496601ebc7a059dd55cfe9

    如果你更新了引用，Git 并不会修改这个文件，而是向 refs/heads 创建一个新的文件。为了获得指定引用的正确 SHA-1 值，Git 会首先在 refs 目录中查找指定的引用，然后再到 packed-refs 文件中查找。所以，如果你在 refs 目录中找不到一个引用，那么它或许在 packed-refs 文件中。

    注意这个文件的最后一行，它会以 ^ 开头。这个符号表示它上一行的标签是附注标签，^ 所在的那一行是附注标签指向的那个提交。

    数据恢复

    在你使用 Git 的时候，你可能会意外丢失一次提交。通常这是因为你强制删除了正在工作的分支，但是最后却发现你还需要这个分支；亦或者硬重置了一个分支，放弃了你想要的提交。如果这些事情已经发生，该如何找回你的提交呢？

    下面的例子将硬重置你的测试仓库中的 master 分支到一个旧的提交，以此来恢复丢失的提交。首先，让我们看看你的仓库现在在什么地方：

    1. $ git log --pretty=oneline
    2. ab1afef80fac8e34258ff41fc1b867c702daa24b modified repo a bit
    3. 484a59275031909e19aadb7c92262719cfcdf19a added repo.rb
    4. 1a410efbd13591db07496601ebc7a059dd55cfe9 third commit
    5. cac0cab538b970a37ea1e769cbbde608743bc96d second commit
    6. fdf4fc3344e67ab068f836878b6c4951e3b15f3d first commit

    现在，我们将 master 分支硬重置到第三次提交：

    1. $ git reset --hard 1a410efbd13591db07496601ebc7a059dd55cfe9
    2. HEAD is now at 1a410ef third commit
    3. $ git log --pretty=oneline
    4. 1a410efbd13591db07496601ebc7a059dd55cfe9 third commit
    5. cac0cab538b970a37ea1e769cbbde608743bc96d second commit
    6. fdf4fc3344e67ab068f836878b6c4951e3b15f3d first commit

    现在顶部的两个提交已经丢失了 - 没有分支指向这些提交。你需要找出最后一次提交的 SHA-1 然后增加一个指向它的分支。窍门就是找到最后一次的提交的 SHA-1 - 但是估计你记不起来了，对吗？

    最方便，也是最常用的方法，是使用一个名叫 git reflog 的工具。当你正在工作时，Git 会默默地记录每一次你改变 HEAD 时它的值。每一次你提交或改变分支，引用日志都会被更新。引用日志（reflog）也可以通过 git update-ref 命令更新，我们在 Git 引用 有提到使用这个命令而不是是直接将 SHA-1 的值写入引用文件中的原因。你可以在任何时候通过执行 git reflog 命令来了解你曾经做过什么：

    1. $ git reflog
    2. 1a410ef HEAD@{0}: reset: moving to 1a410ef
    3. ab1afef HEAD@{1}: commit: modified repo.rb a bit
    4. 484a592 HEAD@{2}: commit: added repo.rb

    这里可以看到我们已经检出的两次提交，然而并没有足够多的信息。为了使显示的信息更加有用，我们可以执行 git log -g，这个命令会以标准日志的格式输出引用日志。

    1. $ git log -g
    2. commit 1a410efbd13591db07496601ebc7a059dd55cfe9
    3. Reflog: HEAD@{0} (Scott Chacon <schacon@gmail.com>)
    4. Reflog message: updating HEAD
    5. Author: Scott Chacon <schacon@gmail.com>
    6. Date:   Fri May 22 18:22:37 2009 -0700
    8.         third commit
    10. commit ab1afef80fac8e34258ff41fc1b867c702daa24b
    11. Reflog: HEAD@{1} (Scott Chacon <schacon@gmail.com>)
    12. Reflog message: updating HEAD
    13. Author: Scott Chacon <schacon@gmail.com>
    14. Date:   Fri May 22 18:15:24 2009 -0700
    16.        modified repo.rb a bit

    看起来下面的那个就是你丢失的提交，你可以通过创建一个新的分支指向这个提交来恢复它。例如，你可以创建一个名为 recover-branch 的分支指向这个提交（ab1afef）：

    1. $ git branch recover-branch ab1afef
    2. $ git log --pretty=oneline recover-branch
    3. ab1afef80fac8e34258ff41fc1b867c702daa24b modified repo a bit
    4. 484a59275031909e19aadb7c92262719cfcdf19a added repo.rb
    5. 1a410efbd13591db07496601ebc7a059dd55cfe9 third commit
    6. cac0cab538b970a37ea1e769cbbde608743bc96d second commit
    7. fdf4fc3344e67ab068f836878b6c4951e3b15f3d first commit

    不错，现在有一个名为 recover-branch 的分支是你的 master 分支曾经指向的地方，再一次使得前两次提交可到达了。接下来，假设你丢失的提交因为某些原因不在引用日志中 - 我们可以通过移除 recover-branch 分支并删除引用日志来模拟这种情况。现在前两次提交又不被任何分支指向了：

    1. $ git branch -D recover-branch
    2. $ rm -Rf .git/logs/

    由于引用日志数据存放在 .git/logs/ 目录中，现在你已经没有引用日志了。这时该如何恢复那次提交？一种方式是使用 git fsck 实用工具，将会检查数据库的完整性。如果使用一个 —full 选项运行它，它会向你显示出所有没有被其他对象指向的对象：

    1. $ git fsck --full
    2. Checking object directories: 100% (256/256), done.
    3. Checking objects: 100% (18/18), done.
    4. dangling blob d670460b4b4aece5915caf5c68d12f560a9fe3e4
    5. dangling commit ab1afef80fac8e34258ff41fc1b867c702daa24b
    6. dangling tree aea790b9a58f6cf6f2804eeac9f0abbe9631e4c9
    7. dangling blob 7108f7ecb345ee9d0084193f147cdad4d2998293

    在这个例子中，你可以在 “dangling commit” 后看到你丢失的提交。现在你可以用和之前相同的方法恢复这个提交，也就是添加一个指向这个提交的分支。

    移除对象

    Git 有很多很棒的功能，但是其中一个特性会导致问题，git clone 会下载整个项目的历史，包括每一个文件的每一个版本。如果所有的东西都是源代码那么这很好，因为 Git 被高度优化来有效地存储这种数据。然而，如果某个人在之前向项目添加了一个大小特别大的文件，即使你将这个文件从项目中移除了，每次克隆还是都要强制的下载这个大文件。之所以会产生这个问题，是因为这个文件在历史中是存在的，它会永远在那里。

    当你迁移 Subversion 或 Perforce 仓库到 Git 的时候，这会是一个严重的问题。因为这些版本控制系统并不下载所有的历史文件，所以这种文件所带来的问题比较少。如果你从其他的版本控制系统迁移到 Git 时发现仓库比预期的大得多，那么你就需要找到并移除这些大文件。

    警告：这个操作对提交历史的修改是破坏性的。它会从你必须修改或移除一个大文件引用最早的树对象开始重写每一次提交。如果你在导入仓库后，在任何人开始基于这些提交工作前执行这个操作，那么将不会有任何问题 - 否则，你必须通知所有的贡献者他们需要将他们的成果变基到你的新提交上。

    为了演示，我们将添加一个大文件到测试仓库中，并在下一次提交中删除它，现在我们需要找到它，并将它从仓库中永久删除。首先，添加一个大文件到仓库中：

    1. $ curl https://www.kernel.org/pub/software/scm/git/git-2.1.0.tar.gz > git.tgz
    2. $ git add git.tgz
    3. $ git commit -m 'add git tarball'
    4. [master 7b30847] add git tarball
    5.  1 file changed, 0 insertions(+), 0 deletions(-)
    6.  create mode 100644 git.tgz

    哎呀 - 其实这个项目并不需要这个巨大的压缩文件。现在我们将它移除：

    1. $ git rm git.tgz
    2. rm 'git.tgz'
    3. $ git commit -m 'oops - removed large tarball'
    4. [master dadf725] oops - removed large tarball
    5.  1 file changed, 0 insertions(+), 0 deletions(-)
    6.  delete mode 100644 git.tgz

    现在，我们执行 gc 来查看数据库占用了多少空间：

    1. $ git gc
    2. Counting objects: 17, done.
    3. Delta compression using up to 8 threads.
    4. Compressing objects: 100% (13/13), done.
    5. Writing objects: 100% (17/17), done.
    6. Total 17 (delta 1), reused 10 (delta 0)

    你也可以执行 count-objects 命令来快速的查看占用空间大小：

    1. $ git count-objects -v
    2. count: 7
    3. size: 32
    4. in-pack: 17
    5. packs: 1
    6. size-pack: 4868
    7. prune-packable: 0
    8. garbage: 0
    9. size-garbage: 0

    size-pack 的数值指的是你的包文件以 KB 为单位计算的大小，所以你大约占用了 5MB 的空间。在最后一次提交前，使用了不到 2KB - 显然，从之前的提交中移除文件并不能从历史中移除它。每一次有人克隆这个仓库时，他们将必须克隆所有的 5MB 来获得这个微型项目，只因为你意外地添加了一个大文件。现在来让我们彻底的移除这个文件。

    首先你必须找到它。在本例中，你已经知道是哪个文件了。但是假设你不知道；该如何找出哪个文件或哪些文件占用了如此多的空间？如果你执行 git gc 命令，所有的对象将被放入一个包文件中，你可以通过运行 git verify-pack 命令，然后对输出内容的第三列（即文件大小）进行排序，从而找出这个大文件。你也可以将这个命令的执行结果通过管道传送给 tail 命令，因为你只需要找到列在最后的几个大对象。

    1. $ git verify-pack -v .git/objects/pack/pack-29…69.idx \
    2.   | sort -k 3 -n \
    3.   | tail -3
    4. dadf7258d699da2c8d89b09ef6670edb7d5f91b4 commit 229 159 12
    5. 033b4468fa6b2a9547a70d88d1bbe8bf3f9ed0d5 blob   22044 5792 4977696
    6. 82c99a3e86bb1267b236a4b6eff7868d97489af1 blob   4975916 4976258 1438

    你可以看到这个大对象出现在返回结果的最底部：占用 5MB 空间。为了找出具体是哪个文件，可以使用 rev-list 命令，我们在 指定特殊的提交信息格式 中曾提到过。如果你传递 —objects 参数给 rev-list 命令，它就会列出所有提交的 SHA-1、数据对象的 SHA-1 和与它们相关联的文件路径。可以使用以下命令来找出你的数据对象的名字：

    1. $ git rev-list --objects --all | grep 82c99a3
    2. 82c99a3e86bb1267b236a4b6eff7868d97489af1 git.tgz

    现在，你只需要从过去所有的树中移除这个文件。使用以下命令可以轻松地查看哪些提交对这个文件产生改动：

    1. $ git log --oneline --branches -- git.tgz
    2. dadf725 oops - removed large tarball
    3. 7b30847 add git tarball

    现在，你必须重写 7b30847 提交之后的所有提交来从 Git 历史中完全移除这个文件。为了执行这个操作，我们要使用 filter-branch 命令，这个命令在 重写历史 中也使用过：

    1. $ git filter-branch --index-filter \
    2.   'git rm --ignore-unmatch --cached git.tgz' -- 7b30847^..
    3. Rewrite 7b30847d080183a1ab7d18fb202473b3096e9f34 (1/2)rm 'git.tgz'
    4. Rewrite dadf7258d699da2c8d89b09ef6670edb7d5f91b4 (2/2)
    5. Ref 'refs/heads/master' was rewritten

    —index-filter 选项类似于在 重写历史 中提到的的 —tree-filter 选项，不过这个选项并不会让命令将修改在硬盘上检出的文件，而只是修改在暂存区或索引中的文件。

    你必须使用 git rm —cached 命令来移除文件，而不是通过类似 rm file 的命令 - 因为你需要从索引中移除它，而不是磁盘中。还有一个原因是速度 - Git 在运行过滤器时，并不会检出每个修订版本到磁盘中，所以这个过程会非常快。如果愿意的话，你也可以通过 —tree-filter 选项来完成同样的任务。git rm 命令的 —ignore-unmatch 选项告诉命令：如果尝试删除的模式不存在时，不提示错误。最后，使用 filter-branch 选项来重写自 7b30847 提交以来的历史，也就是这个问题产生的地方。否则，这个命令会从最旧的提交开始，这将会花费许多不必要的时间。

    你的历史中将不再包含对那个文件的引用。不过，你的引用日志和你在 .git/refs/original 通过 filter-branch 选项添加的新引用中还存有对这个文件的引用，所以你必须移除它们然后重新打包数据库。在重新打包前需要移除任何包含指向那些旧提交的指针的文件：

    1. $ rm -Rf .git/refs/original
    2. $ rm -Rf .git/logs/
    3. $ git gc
    4. Counting objects: 15, done.
    5. Delta compression using up to 8 threads.
    6. Compressing objects: 100% (11/11), done.
    7. Writing objects: 100% (15/15), done.
    8. Total 15 (delta 1), reused 12 (delta 0)

    让我们看看你省了多少空间。

    1. $ git count-objects -v
    2. count: 11
    3. size: 4904
    4. in-pack: 15
    5. packs: 1
    6. size-pack: 8
    7. prune-packable: 0
    8. garbage: 0
    9. size-garbage: 0

    打包的仓库大小下降到了 8K，比 5MB 好很多。可以从 size 的值看出，这个大文件还在你的松散对象中，并没有消失；但是它不会在推送或接下来的克隆中出现，这才是最重要的。如果真的想要删除它，可以通过有 —expire 选项的 git prune 命令来完全地移除那个对象：

    1. $ git prune --expire now
    2. $ git count-objects -v
    3. count: 0
    4. size: 0
    5. in-pack: 15
    6. packs: 1
    7. size-pack: 8
    8. prune-packable: 0
    9. garbage: 0
    10. size-garbage: 0

    prev | next

    原文: https://git-scm.com/book/zh/v2/Git-%E5%86%85%E9%83%A8%E5%8E%9F%E7%90%86-%E7%BB%B4%E6%8A%A4%E4%B8%8E%E6%95%B0%E6%8D%AE%E6%81%A2%E5%A4%8D