PROSAGA码农传奇-git/gitflow/gitlib-为什么git在远程解析增量之前将对象写入远程

<div class =“post-text”itemprop =“text”>
  
    混帐
    
      可以
    
    确实，做对了：它可以问服务器
    
      你有blob吗？
       <code>
 H
 </code>
      ？
    
     对于一些哈希
     <code>
 H
 </code>
    ，如果服务器已经拥有它，请避免再次发送。
  
  
    不过，Git实际上并没有这么做。好吧，无论如何，通过一些措施“好”。 Git所做的是询问服务器是否具体
    
      提交
    
    。然后根据结果做出一些合理的，但不一定是100％准确的假设。这有时意味着不必要地发送对象。而且，并非完全偶然的是，实现推送的代码不会在您的代码之前按照您的说法执行。 （这是，我
    
      认为
    
    ，问题的根源，但我没有测试过。）
  
  
    不过，有些事情你可以做。让我们先来看看Git在做什么。
  
  <H3>
    细节
  </H3>
  <BLOCKQUOTE>
    
      当静态文件发生变化时，我检查分支“静态”，使用提交更改
       <code>
 --amend
 </code>
       标志，然后结帐分支“历史”和合并分支“静态”，强制更新分支“主”在远程过程结束时：
    
     <pre>
 <code>
 git checkout static
git add .
git commit --amend -m 'Add static files'

</code>
 </pre>
  </BLOCKQUOTE>
  
    此时，在您自己的存储库中，您有：
  
   <pre>
 <code>
 R [static@{1}]
 /
...--o--S <-- static

</code>
 </pre>
  
    （虽然实际上是
     <code>
 ...
 </code>
     部分是空的，并且
     <code>
 o
 </code>
     提交
     <code>
 A
 </code>
     下面）。
  
  
    承诺
     <code>
 R
 </code>
     曾经是最先进的那个
     <code>
 static
 </code>
    ;它已被推到一边了
     <code>
 S
 </code>
     作为新的提示
     <code>
 static
 </code>
    。这两个提交都存在于您自己的存储库中。
  
  <BLOCKQUOTE>
     <pre>
 <code>
 git push

</code>
 </pre>
  </BLOCKQUOTE>
  
    的
      你不是在做这一步。
    </强>
      因此，服务器还没有提交
     <code>
 S
 </code>
    。 （查看案例代码
     <code>
 asset
 </code>
    ，运行
     <code>
 add_static
 </code>
    ， 然后
     <code>
 make_master
 </code>
    ， 然后
     <code>
 git push --force
 </code>
    。该
     <code>
 make_master
 </code>
     step将当前分支设置为
     <code>
 master
 </code>
    所以
     <code>
 git push --force
 </code>
     推
    
      只要
    
     <code>
 master
 </code>
    。这就是为什么
     <code>
 git log --graph
 </code>
     输出没有显示
     <code>
 origin/static
 </code>
    。）如果你这样做，你需要
     <code>
 git push --force
 </code>
     这里。
  
  
    我们现在进行：
  
  <BLOCKQUOTE>
     <pre>
 <code>
 git checkout master
git reset --hard history
git merge -m "Merge branch 'static'" static

git push --force

</code>
 </pre>
  </BLOCKQUOTE>
  
    我们画画吧
    
      这个
    
     图表也是如此，包括前面的推..
     <code>
 master@{2}
 </code>
     （它的
     <code>
 @{2}
 </code>
     因为我们有两个干预事件：重置，然后合并）。此图表反映了内容
    
      您的
    
     存储库，看起来像这样：
  
   <pre>
 <code>
 R--------M <-- origin/master, master@{2}
 / /
A--o--o--L <-- history, origin/history, master@{1}
 \ \
 S--------N <-- master

</code>
 </pre>
  
    （承诺
     <code>
 R
 </code>
     有
     <code>
 static@{1}
 </code>
     标签，和
     <code>
 S
 </code>
     具有
     <code>
 static
 </code>
     和
     <code>
 origin/static
 </code>
    ;出于空间原因，我没有在图纸中包含这些标签。
  
  
    同时，服务器有这样的：
  
   <pre>
 <code>
 R--------M <-- master
 / /
A--o--o--L <-- history

</code>
 </pre>
  
    这是事情变得有趣的地方。客户端现在必须确定要发送的对象。它通过启动与服务器的对话来实现。它始于：
    
      我想送你
       <code>
 N
 </code>
      ;你有没有
       <code>
 N
 </code>
      ？
    
      当然，服务器没有提交
     <code>
 N
 </code>
     因为你刚刚做到了。
  
  
    由于服务器拒绝，客户说：
    
      然后我需要你
       <code>
 N
 </code>
      的父母
       <code>
 L
 </code>
       和
       <code>
 S
 </code>
      ;你有那些吗？
    
      当然，他们确实有
     <code>
 L
 </code>
    ， 但不是
     <code>
 S
 </code>
    。客户现在知道要发送
     <code>
 N
 </code>
     和
     <code>
 S
 </code>
    ，并且服务器具有与之关联的所有对象
     <code>
 L
 </code>
     - 并且，自服务器上的历史记录
    
      不
    
     浅，链中的所有物体都从中到达
     <code>
 L
 </code>
     回到
     <code>
 A
 </code>
    。
  
  
    客户端现在询问服务器是否有
     <code>
 S
 </code>
    的父母
     <code>
 A
 </code>
    ，或假设它是因为
     <code>
 A
 </code>
     是...的祖先
     <code>
 L
 </code>
    ;无论哪种方式，它最终意识到服务器确实有
     <code>
 A
 </code>
    。
  
  
    客户端现在假设服务器具有服务器提到的所有提交中的所有对象。它使
    
      没有
    假设提交
     <code>
 R
 </code>
     存在于服务器上，因为没有提到
     <code>
 R
 </code>
     在has / want协议交换中。所以它打包了所有的对象
     <code>
 S
 </code>
    ，并发送它们。服务器重新打包，发现大多数blob都是冗余的，并且有效地忽略了冗余blob。
  
  <H3>
    你能做些什么，第1部分
  </H3>
  
    处理此问题的一种方法是继续在服务器上设置与commit相对应的标签
     <code>
 R
 </code>
     （在前一步）。也就是说，添加一个
     <code>
 git push --force origin static
 </code>
    ， 以便
     <code>
 origin
 </code>
     有标签
     <code>
 static
 </code>
     指向
     <code>
 R
 </code>
    。
  
  
    然后，当他们发送新的提交时
     <code>
 master
 </code>
    ，一定要告诉他们更新
    
      都
    
     <code>
 static
 </code>
    
      和
    
     <code>
 master
 </code>
    ：
  
   <pre>
 <code>
 git push --force origin static master

</code>
 </pre>
  
    要么：
  
   <pre>
 <code>
 git push origin +static:static +master:master

</code>
 </pre>
  
    （这些意思相同 - refspec上的加号设置特定refspec的强制标志，在这种情况下，我喜欢显式，但你可以使用你喜欢的任何语法）。
  
  
    现在服务器将具有：
  
   <pre>
 <code>
 ...........<-- static
 .
 R--------M <-- master
 / /
A--o--o--L <-- history

</code>
 </pre>
  
    并将宣传其事实
     <code>
 refs/heads/static
 </code>
     表示提交
     <code>
 R
 </code>
    。客户端需要此信息用于其预推钩（无论它是否实际运行任何预推钩）。因此，当客户端发送新的提交时，它将提供发送
     <code>
 S
 </code>
     （用于更新
     <code>
 static
 </code>
     并且因为它在更新的历史中
     <code>
 master
 </code>
    ）和
     <code>
 N
 </code>
     （用于更新
     <code>
 master
 </code>
    ）
    
      但
    
    ，这次它可以告诉服务器了
     <code>
 R
 </code>
    。它
    
      应该
    
     只能发送一个新的blob。
  
  
    （我不确定
    
      将
    
     这样做，但它应该很容易测试。）
  
  
    请注意，同时执行这两个操作非常重要，因为只要服务器接受即可
     <code>
 S
 </code>
     就像它一样
     <code>
 static
 </code>
     和
     <code>
 N
 </code>
     就像它一样
     <code>
 master
 </code>
    ，它将垃圾收集两者
     <code>
 M
 </code>
     和
     <code>
 R
 </code>
    。 （服务器通常没有启用reflog，并且所有这些对象都在包文件中，因此不受松散对象的14天宽限期的限制。）
  
  <H3>
    你能做些什么，第2部分
  </H3>
  
    另一个选择是停止重写历史记录。您可能不喜欢此选项，因为静态资产对象会随着时间的推移而累积，从而使存储库大小膨胀。但这也将完全消除问题，因为现在客户端将正确理解服务器的历史记录。
  
  
    从某种意义上说，历史重写是导致问题的：客户做出了
    
      假设
    
     服务器没有任何static-assets-objects
    
      因为
    
     该分支上的每个新提交与除root提交之外的任何内容完全无关
     <code>
 A
 </code>
    。这种假设是“安全的”，因为它只会导致发送额外的对象。它节省了很多
    
      时间
    
     因为枚举每次提交后面的所有树和blob对象都非常慢 - 只需说：
    
      啊啊，服务器有这个提交，所以 - 除了由浅层移植引入的复杂性，我们在这里将忽略它 - 它具有通过这个提交及其历史隐含的所有对象。
    
      客户端几乎不必提供任何哈希ID，因为服务器很快就会响应
    
      是的我已经有了那个
    
    ，并终止遍历该图的那一部分。如果服务器有
     <code>
 L
 </code>
    它以前拥有一切
     <code>
 L
 </code>
     太。如果有的话
     <code>
 R
 </code>
    它以前拥有一切
     <code>
 R
 </code>
    。
  
  
    好吧，我应该修改一下：它
    
      将
    
     节省了大量的时间，除了你重写历史记录以便客户永远不会
    
      问
    
     关于
     <code>
 R
 </code>
    。所有对象的完整枚举虽然很慢，但可能比从提交中重新发送大多数对象更快
     <code>
 R
 </code>
    。它肯定会节省一些带宽。但对于大多数正常情况，以及没有进行大量重写的Git历史记录，以Git枚举提交和公正的方式执行此操作会更快
    
      假设
    
     关于这些提交背后的树木和blob的事情。
  
</DIV>