拉取所有 git 子模块的最新更改

Question

我们使用 git 子模块来管理几个大型项目，这些项目依赖于我们开发的许多其他库。 每个库都是一个单独的存储库，作为子模块引入依赖项目中。 在开发过程中，我们通常只想获取每个依赖子模块的最新版本。

如何提取所有 git 子模块的最新更改？

Answer 1

如果这是第一次您签出存储库，您需要首先使用--init：

git submodule update --init --recursive

对于git 1.8.2或更高版本，添加了选项 --remote 以支持更新到远程分支的最新提示：

git submodule update --recursive --remote

这具有尊重 .gitmodules 或 中指定的任何“非默认”分支的额外好处code>.git/config 文件（如果你碰巧有的话，默认是 origin/master，在这种情况下，这里的其他一些答案也可以工作）。

对于 git 1.7.3 或更高版本，您可以使用（但以下有关更新的问题仍然适用）：

git submodule update --recursive

或者：

git pull --recurse-submodules

如果您想将子模块拉到最新提交而不是当前提交，则存储库点到。

有关详细信息，请参阅 git-submodule(1)

Answer 2

git pull --recurse-submodules --jobs=10

git 在 1.8.5 中首次学习的功能。

直到 bug< /a> 是固定的，第一次你确实需要运行

git 子模块更新 --init --recursive

Answer 3

在 init 上运行以下命令：

git submodule update --init --remote --recursive

从 git repo 目录中运行，最适合我。

这将拉出所有最新的，包括子模块。

解释

git - the base command to perform any git command
    submodule - Inspects, updates and manages submodules.
        update - Update the registered submodules to match what the superproject
        expects by cloning missing submodules and updating the working tree of the
        submodules. The "updating" can be done in several ways depending on command
        line options and the value of submodule.<name>.update configuration variable.
            --init without the explicit init step if you do not intend to customize
            any submodule locations.
            --recursive is specified, this command will recurse into the registered
            submodules, and update any nested submodules within.

---

之后你可以运行：

git submodule update --recursive

从 git repo 目录中运行，最适合我。

这将拉出所有最新的，包括子模块。

Answer 4

注意：这是 2009 年的内容，当时可能不错，但现在有更好的选择。

我们使用它。 它称为 git-pup：

#!/bin/bash
# Exists to fully update the git repo that you are sitting in...

git pull && git submodule init && git submodule update && git submodule status

只需将其放在合适的 bin 目录（/usr/local/bin）中即可。 如果在 Windows 上，您可能需要修改语法才能使其工作:)

更新：

响应原作者关于拉入所有子模块的所有 HEAD 的评论 --这是一个好问题。

我非常确定 git 内部没有为此的命令。 为此，您需要确定子模块的 HEAD 到底是什么。 这可能很简单，比如说 master 是最新的分支，等等...

在此之后，创建一个简单的脚本来执行以下操作：

1. 检查 git 子模块状态对于“修改的”存储库。 输出行的第一个字符表明了这一点。 如果子存储库被修改，您可能不想继续。
2. 对于列出的每个存储库，cd 进入其目录并运行 git checkout master && git pull 。 检查是否有错误。
3. 最后，我建议您向用户打印一个显示，以指示子模块的当前状态——也许会提示他们添加所有内容并提交？

我想提一下，这种风格并不是 git 子模块的真正设计目的。 通常，您想说“LibraryX”的版本为“2.32”，并且将保持这种状态，直到我告诉它“升级”。

从某种意义上说，这就是您正在使用所描述的脚本所做的事情，但只是更加自动。 需要护理！

更新2：

如果您使用的是Windows平台，您可能需要考虑使用Python来实现脚本，因为它在这些领域非常强大。 如果您使用的是 unix/linux，那么我建议只使用 bash 脚本。

需要任何澄清吗？ 只需发表评论即可。

Answer 5

Henrik 走在正确的道路上。 git submodule foreach 命令可以执行任意 shell 脚本。 获取最新版本的两个选项可能是：

git submodule foreach git pull origin master

和：

git submodule foreach /path/to/some/cool/script.sh

这将迭代所有初始化子模块并运行给定的命令。

Answer 6

以下内容在 Windows 上对我有用。

git submodule init
git submodule update

Answer 7

对我来说，git 2.24.03，更新到 .gitmodules 中定义的远程分支的最新提交。

git submodule update --recursive --init

git submodule update --recursive --remote

git version 2.24.3 (Apple Git-128)

请注意：< /强>
有人这么说
git pull --recurse-submodules 与 git submodule update --recursive --remote 相同。 但根据我的测试， git pull --recurse-submodules 可能无法更新到 .gitmodules 中定义的远程分支的最新提交。

Answer 8

第一次

克隆和初始化子模块

git clone [email protected]:speedovation/kiwi-resources.git resources
git submodule init

休息

在开发期间只需拉取和更新子模块

git pull --recurse-submodules  && git submodule update --recursive

将 Git 子模块更新到源上的最新提交

git submodule foreach git pull origin master

首选方式应低于

git submodule update --remote --merge

注意：最后两个命令具有相同的行为

Answer 9

编辑：

在评论中（philfreo）指出需要最新版本。 如果有任何嵌套子模块需要使用最新版本：

git submodule foreach --recursive git pull

-----下面过时的评论-----

这不是官方的方法吗？

git submodule update --init

我每次都用它。 到目前为止没有问题。

编辑：

我刚刚发现您可以使用：

git submodule foreach --recursive git submodule update --init 

这也会递归地提取所有子模块，即依赖项。

Answer 10

由于子模块的默认分支可能不是 master，这就是我自动执行完整 Git 子模块升级的方法：

git submodule init
git submodule update
git submodule foreach 'git fetch origin; git checkout $(git rev-parse --abbrev-ref HEAD); git reset --hard origin/$(git rev-parse --abbrev-ref HEAD); git submodule update --recursive; git clean -dfx'

Answer 11

我不知道从哪个版本的 git 开始它就可以工作，但这就是您正在寻找的：

git submodule update --recursive

我也将它与 git pull 一起使用来更新根存储库：

git pull && git submodule update --recursive

Answer 12

上面的答案很好，但是我们使用 git-hooks 来使这更容易，但事实证明在 git 2.14 中，您可以设置 git config submodule.recurse 设置为 true，以便在拉取到 git 存储库时更新子模块。

然而，如果它们位于分支上，这将产生推送所有子模块更改的副作用，但如果您已经需要该行为，则这可以完成这项工作。

可以通过使用以下方法来完成：

git config submodule.recurse true

Answer 13

根据从远程提取每个子模块的“最新”代码的现有答案来澄清一些事情。

如果“latest”表示已签入的子模块指针，则务必使用：

git submodule update --recursive
  - or -
git pull --recurse-submodules --jobs=X

如果“latest”表示最新的ma​​in，那么这样的事情就可以工作：

git submodule foreach "git checkout main && git pull"

不幸的是，这意味着没有“--jobs”选项，所以我们不能并行运行它。 我见过的最接近并行运行的方法是使用 pfs python 代码。

Answer 14

我经常使用这个命令，到目前为止它有效。

git pull
git submodule foreach --recursive git checkout master
git submodule foreach --recursive git pull

希望这更快。

Answer 15

正如抗毒的答案<中所述/a>，一个简单的 git submodule foreach --recursive git pull 就足够了。

弗朗西斯·培根的答案< /a> 注释 git pull --recurse-submodules 可能有所不同。

您可以使用详细选项进行测试并查看发生了什么：

git pull -v --recurse-submodules

但为此，您将需要 Git 2.40（2023 年第一季度）。

“git pull -v --recurse-submodules “^(man) 尝试将 -v 传递给底层 git 子模块更新^(man)，哪个不明白请求并被拒绝：Git 2.40（2023 年第一季度）已更正此问题。

请参阅 提交 6f65f84（2022 年 12 月 10 日），作者：Sven Strickroth (csware)。
^{（由 Junio C Hamano -- gitster -- 合并于 提交 b3b9e5c，2022 年 12 月 28 日）}

子模块：接受-v< /code> 更新命令

^{签字人：Sven Strickroth}

自a56771a（“builtin/pull：尊重子模块中的详细程度设置", 2018-01-25, Git v2.17.0-rc0 -- 合并 列于 第 3 批)，“git pull -v --recurse-submodules"< sup>(man) 将 -v 传播到子模块命令，但由于后一个命令不理解该选项，因此失败。

教授“git 子模块更新"(man) 接受修复它的选项。




不再有“呕吐”（即显示用法 'git submodule foreach [--quiet] [--recursive] [--] '），因为 -v< /code> 是 git 子模块的未知选项。

Answer 16

适用于 Windows 的 Git 2.6.3：

git submodule update --rebase --remote

Answer 17

从存储库的顶层：

git submodule foreach git checkout develop
git submodule foreach git pull

这会将所有分支切换为开发并拉取最新版本

Answer 18

我通过改编 gahooa 的 上面的答案：

将其与git集成[alias] ...

如果您的父项目在.gitmodules中有类似的内容:

[submodule "opt/submodules/solarized"]
    path = opt/submodules/solarized
    url = [email protected]:altercation/solarized.git
[submodule "opt/submodules/intellij-colors-solarized"]
    path = opt/submodules/intellij-colors-solarized
    url = [email protected]:jkaving/intellij-colors-solarized.git

在你的 .gitconfig 中添加类似的内容

[alias]
    updatesubs = "!sh -c \"git submodule init && git submodule update && git submodule status\" "

然后更新你的子模块，运行：

git updatesubs

我有一个 示例位于我的环境设置存储库 。

Answer 19

您现在需要做的就是一个简单的 git checkout

只需确保通过此全局配置启用它： git config --global submodule.recurse true

Answer 20

以下是从所有 git 存储库中提取的命令行，无论它们是否是子模块：

ROOT=$(git rev-parse --show-toplevel 2> /dev/null)
find "$ROOT" -name .git -type d -execdir git pull -v ';'

如果您在顶级 git 存储库中运行它，则可以将 "$ROOT" 替换为 .。

Answer 21

我编写了这个简单的 shell 脚本，它对我来说效果很好。

#!/bin/bash

#git init
git init

#git clone repo including submodules
git clone --recurse-submodules https://github.com/username/project.git

#change directory -repo
cd project

#update the remote ie tag/commits
git submodule update --remote

#add commit 
git commit -a -m "commit in submodule"

#git push 
git push -u origin 

Answer 22

备注：不是太简单的方法，但可行，并且有其独特的优点。

如果只想克隆存储库的 HEAD 版本以及其所有子模块的 HEAD（即签出“trunk”），那么可以使用以下Lua 脚本。 有时，简单的命令 git submodule update --init --recursive --remote --no-fetch --depth=1 可能会导致不可恢复的 git 错误。 在这种情况下，需要清理 .git/modules 目录的子目录，并使用 git clone --separate-git-dir 命令手动克隆子模块。 唯一的复杂性是找出子模块的 URL、.git 目录的路径以及子模块在超级项目树中的路径。

备注：该脚本仅针对 https://github.com/boostorg/boost.git 存储库进行测试。 它的特点是：所有子模块托管在同一主机上，并且 .gitmodules 仅包含相对的 URL。

-- mkdir boost ; cd boost ; lua ../git-submodules-clone-HEAD.lua https://github.com/boostorg/boost.git .
local module_url = arg[1] or 'https://github.com/boostorg/boost.git'
local module = arg[2] or module_url:match('.+/([_%d%a]+)%.git')
local branch = arg[3] or 'master'
function execute(command)
    print('# ' .. command)
    return os.execute(command)
end
-- execute('rm -rf ' .. module)
if not execute('git clone --single-branch --branch master --depth=1 ' .. module_url .. ' ' .. module) then
    io.stderr:write('can\'t clone repository from ' .. module_url .. ' to ' .. module .. '\n')
    return 1
end
-- cd $module ; git submodule update --init --recursive --remote --no-fetch --depth=1
execute('mkdir -p ' .. module .. '/.git/modules')
assert(io.input(module .. '/.gitmodules'))
local lines = {}
for line in io.lines() do
    table.insert(lines, line)
end
local submodule
local path
local submodule_url
for _, line in ipairs(lines) do
    local submodule_ = line:match('^%[submodule %"([_%d%a]-)%"%]
)
    if submodule_ then
        submodule = submodule_
        path = nil
        submodule_url = nil
    else
        local path_ = line:match('^%s*path = (.+)
)
        if path_ then
            path = path_
        else
            submodule_url = line:match('^%s*url = (.+)
)
        end
        if submodule and path and submodule_url then
            -- execute('rm -rf ' .. path)
            local git_dir = module .. '/.git/modules/' .. path:match('^.-/(.+)
)
            -- execute('rm -rf ' .. git_dir)
            execute('mkdir -p $(dirname "' .. git_dir .. '")')
            if not execute('git clone --depth=1 --single-branch --branch=' .. branch .. ' --separate-git-dir ' .. git_dir .. ' ' .. module_url .. '/' .. submodule_url .. ' ' .. module .. '/' .. path) then
                io.stderr:write('can\'t clone submodule ' .. submodule .. '\n')
                return 1
            end
            path = nil
            submodule_url = nil
        end
    end
end

Answer 23

我认为你必须编写一个脚本来做到这一点。 老实说，我可能会安装 python 来执行此操作，以便您可以使用 os.walk cd 到每个目录并发出适当的命令。 使用 python 或其他脚本语言（而不是批处理）可以让您轻松添加/删除子项目，而无需修改脚本。