Einfache Möglichkeit, die neuesten Git-Submodule zu ziehen

Wir verwenden Git-Submodule, um einige große Projekte zu verwalten, die von vielen anderen von uns entwickelten Bibliotheken abhängig sind. Jede Bibliothek ist ein separates Repo, das als Submodul in das abhängige Projekt gebracht wird. Während der Entwicklung möchten wir oft nur die neueste Version jedes abhängigen Submoduls herunterladen.

Hat git einen eingebauten Befehl, um dies zu tun? Wenn nicht, wie wäre es mit einer Windows-Batchdatei oder ähnlichem, die dies kann?

Wenn Sie zum ersten Mal ein Repo auschecken, müssen Sie es --initzuerst verwenden:

git submodule update --init --recursive

Für Git 1.8.2 oder höher wurde die Option --remotehinzugefügt, um die Aktualisierung auf die neuesten Tipps für Remote-Zweige zu unterstützen:

git submodule update --recursive --remote

Dies hat den zusätzlichen Vorteil, dass alle in den .gitmodulesoder .git/config-Dateien angegebenen "Nicht-Standard" -Zweige berücksichtigt werden (wenn Sie zufällig einen haben, ist der Standard "Ursprung / Master". In diesem Fall würden auch einige der anderen Antworten hier funktionieren).

Für Git 1.7.3 oder höher können Sie Folgendes verwenden (aber die folgenden Fallstricke zeigen an, welches Update noch gilt):

git submodule update --recursive

oder:

git pull --recurse-submodules

Wenn Sie Ihre Submodule auf die neuesten Commits anstatt auf das aktuelle Commit ziehen möchten, zeigt das Repo auf.

Siehe Git-Submodul (1) für Details

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

Ein Feature-Git, das zuerst in 1.8.5 gelernt wurde.

Bis der Fehler behoben ist, müssen Sie zum ersten Mal ausführen

git submodule update --init --recursive

Führen Sie auf init den folgenden Befehl aus:

git submodule update --init --recursive

funktioniert aus dem git repo verzeichnis am besten für mich.

Dadurch werden alle neuesten Modelle einschließlich Submodule abgerufen.

Erklärt

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.

Danach können Sie einfach ausführen:

git submodule update --recursive

funktioniert aus dem git repo verzeichnis am besten für mich.

Dadurch werden alle neuesten Modelle einschließlich Submodule abgerufen.

Hinweis: Dies ist aus dem Jahr 2009 und war damals vielleicht gut, aber jetzt gibt es bessere Optionen.

Wir nutzen dies. Es heißt 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

Legen Sie es einfach in ein geeignetes bin-Verzeichnis (/ usr / local / bin). Unter Windows müssen Sie möglicherweise die Syntax ändern, damit es funktioniert :)

Aktualisieren:

Als Antwort auf den Kommentar des ursprünglichen Autors zum Einziehen aller KÖPFE aller Submodule - das ist eine gute Frage.

Ich bin mir ziemlich sicher, dass gites intern keinen Befehl dafür gibt. Dazu müssten Sie herausfinden, was HEAD wirklich für ein Submodul ist. Das könnte so einfach sein, als würde man sagen, es mastersei der aktuellste Zweig usw.

Erstellen Sie anschließend ein einfaches Skript, das Folgendes ausführt:

1. Suchen Sie git submodule statusnach "geänderten" Repositorys. Das erste Zeichen der Ausgabezeilen zeigt dies an. Wenn ein Sub-Repo geändert wird, möchten Sie möglicherweise NICHT fortfahren.
2. CD für jedes aufgelistete Repo in sein Verzeichnis legen und ausführen git checkout master && git pull. Auf Fehler prüfen.
3. Am Ende schlage ich vor, dass Sie dem Benutzer eine Anzeige drucken, um den aktuellen Status der Submodule anzuzeigen. Fordern Sie ihn möglicherweise auf, alle hinzuzufügen und festzuschreiben.

Ich möchte erwähnen, dass dieser Stil nicht wirklich das ist, wofür Git-Submodule entwickelt wurden. Normalerweise möchten Sie sagen, dass "LibraryX" die Version "2.32" hat und so bleibt, bis ich ihm sage, dass er "upgraden" soll.

In gewisser Weise machen Sie das mit dem beschriebenen Skript, aber nur automatischer. Vorsicht ist geboten!

Update 2:

Wenn Sie sich auf einer Windows-Plattform befinden, sollten Sie Python verwenden, um das Skript zu implementieren, da es in diesen Bereichen sehr leistungsfähig ist. Wenn Sie unter Unix / Linux arbeiten, empfehle ich nur ein Bash-Skript.

Benötigen Sie Klarstellungen? Schreibe einfach einen Kommentar.

Henrik ist auf dem richtigen Weg. Der Befehl 'foreach' kann ein beliebiges Shell-Skript ausführen. Zwei Optionen, um die neuesten zu ziehen, könnten sein:

git submodule foreach git pull origin master

und,

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

Dadurch werden alle initialisierten Submodule durchlaufen und die angegebenen Befehle ausgeführt.

Folgendes hat bei mir unter Windows funktioniert.

git submodule init
git submodule update

Bearbeiten :

In den Kommentaren wurde (von philfreo ) darauf hingewiesen, dass die neueste Version erforderlich ist. Wenn verschachtelte Submodule in der neuesten Version vorhanden sein müssen:

git submodule foreach --recursive git pull

----- Veralteter Kommentar unten -----

Ist das nicht der offizielle Weg, es zu tun?

git submodule update --init

Ich benutze es jedes Mal. Bisher keine Probleme.

Bearbeiten:

Ich habe gerade festgestellt, dass Sie verwenden können:

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

Dadurch werden auch alle Submodule, dh Abhängigkeiten, rekursiv abgerufen.

Da es vorkommen kann, dass der Standardzweig Ihrer Submodule nicht master lautet, automatisiere ich auf diese Weise die vollständigen Git-Submodul-Upgrades:

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'

Erstes Mal

Submodul klonen und initialisieren

git clone git@github.com:speedovation/kiwi-resources.git resources
git submodule init

Sich ausruhen

Während der Entwicklung einfach das Submodul ziehen und aktualisieren

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

Aktualisieren Sie das Git-Submodul auf das neueste Commit für den Ursprung

git submodule foreach git pull origin master

Der bevorzugte Weg sollte unten sein

git submodule update --remote --merge

Hinweis: Die letzten beiden Befehle haben dasselbe Verhalten

Ich weiß nicht, seit welcher Version von Git dies funktioniert, aber das ist es, wonach Sie suchen:

git submodule update --recursive

Ich benutze es auch git pull, um das Root-Repository zu aktualisieren:

git pull && git submodule update --recursive

Die obigen Antworten sind gut, wir haben jedoch Git-Hooks verwendet, um dies zu vereinfachen. Es stellt sich jedoch heraus, dass Sie in Git 2.14git config submodule.recurse den Wert true festlegen können , damit Submodule aktualisiert werden können, wenn Sie in Ihr Git-Repository ziehen.

Dies hat den Nebeneffekt, dass alle Änderungen an Submodulen, die Sie haben, verschoben werden, wenn sie sich in Zweigen befinden. Wenn Sie dieses Verhalten jedoch bereits benötigen, kann dies den Job erledigen.

Kann durchgeführt werden mit:

git config submodule.recurse true

Git für Windows 2.6.3 :

git submodule update --rebase --remote

Von der obersten Ebene im Repo:

git submodule foreach git checkout develop
git submodule foreach git pull

Dadurch werden alle Zweige auf die Entwicklung und den neuesten Stand umgestellt

Ich habe dies getan , indem ich die Antwort von Gahooa oben angepasst habe :

Integriere es mit einem Git [alias]...

Wenn Ihr übergeordnetes Projekt Folgendes hat .gitmodules:

[submodule "opt/submodules/solarized"]
    path = opt/submodules/solarized
    url = git@github.com:altercation/solarized.git
[submodule "opt/submodules/intellij-colors-solarized"]
    path = opt/submodules/intellij-colors-solarized
    url = git@github.com:jkaving/intellij-colors-solarized.git

Fügen Sie so etwas in Ihre .gitconfig ein

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

Führen Sie dann zum Aktualisieren Ihrer Submodule Folgendes aus:

git updatesubs

Ich habe ein Beispiel dafür in meinem Umgebungs-Setup-Repo .

Alles was Sie jetzt tun müssen, ist eine einfache git checkout

Stellen Sie einfach sicher, dass Sie es über diese globale Konfiguration aktivieren: git config --global submodule.recurse true

Hier ist die Befehlszeile, mit der Sie aus allen Git-Repositorys abrufen können, ob es sich um Submodule handelt oder nicht:

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

Wenn Sie es in Ihrem Top-git - Repository ausgeführt wird , können Sie ersetzen "$ROOT"in ..

Ich denke, Sie müssen ein Skript schreiben, um dies zu tun. Um ehrlich zu sein, könnte ich installieren Python es so zu tun , dass Sie verwenden können , os.walkum cdzu jedem Verzeichnis und die entsprechenden Befehle erteilen. Wenn Sie Python oder eine andere Skriptsprache als Batch verwenden, können Sie problemlos Unterprojekte hinzufügen / entfernen, ohne das Skript ändern zu müssen.

Bemerkung: nicht allzu einfach, aber praktikabel und es hat seine eigenen einzigartigen Profis.

Wenn man nur die HEADRevision eines Repositorys und nur HEADs aller seiner Submodule klonen möchte (dh "Trunk" auschecken), kann man das folgende Lua- Skript verwenden. Manchmal git submodule update --init --recursive --remote --no-fetch --depth=1kann ein einfacher Befehl zu einem nicht behebbaren gitFehler führen. In diesem Fall muss das Unterverzeichnis des .git/modulesVerzeichnisses bereinigt und das Submodul manuell mit dem git clone --separate-git-dirBefehl geklont werden . Die einzige Komplexität besteht darin, die URL , den Pfad des .gitVerzeichnisses des Submoduls und den Pfad des Submoduls im Superprojektbaum herauszufinden .

Anmerkung: Das Skript wird nur gegen das https://github.com/boostorg/boost.gitRepository getestet . Seine Besonderheiten: Alle Submodule werden auf demselben Host gehostet und .gitmodulesenthalten nur relative URLs .

-- 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