Git merge Hotfix-Zweig in Feature-Zweig einfügen

Question

Angenommen, wir haben die folgende Situation in Git:

1. Ein erstelltes Repository:

   mkdir GitTest2
   cd GitTest2
   git init

2. Einige Änderungen im master werden vorgenommen und committed:

   echo "Im Master" > file
   git commit -a -m "Initieller Commit"

3. Feature1 wird vom master abgezweigt und es wird daran gearbeitet:

   git branch feature1
   git checkout feature1
   echo "Feature1" > featureFile
   git commit -a -m "Commit für Feature1"

4. In der Zwischenzeit wird ein Bug im Master-Code entdeckt und ein hotfix-Zweig eingerichtet:

   git checkout master
   git branch hotfix1
   git checkout hotfix1

5. Der Bug wird im hotfix-Zweig behoben und wieder in den Master gemerged (eventuell nach einem Pull Request/Code-Review):

   echo "Bugfix" > bugfixFile
   git commit -a -m "Bugfix-Commit"
   git checkout master
   git merge --no-ff hotfix1

6. Die Entwicklung an Feature1 wird fortgesetzt:

   git checkout feature1

Angenommen, ich benötige den Hotfix in meinem Feature-Branch, vielleicht weil der Bug auch dort auftritt. Wie kann ich das erreichen, ohne die Commits in meinen Feature-Branch zu duplizieren?

Ich möchte verhindern, dass zwei neue Commits in meinem Feature-Branch landen, die keine Beziehung zur Feature-Implementierung haben. Dies scheint mir besonders wichtig zu sein, wenn ich Pull Requests verwende: Alle diese Commits werden auch im Pull Request enthalten sein und müssen erneut überprüft werden, obwohl dies bereits geschehen ist (da der Hotfix bereits im Master ist).

Ich kann kein git merge master --ff-only durchführen: "fatal: Es ist nicht möglich, einen Fast-Forward durchzuführen, Abbruch.", aber ich bin mir nicht sicher, ob mir das geholfen hat.

Answer 1

Wie fügen wir den Master-Zweig in den Feature-Zweig ein? Einfach:

git checkout feature1
git merge master

Es macht keinen Sinn, hier ein Fast-Forward-Merge zu erzwingen, da es nicht möglich ist. Du hast sowohl in den Feature-Zweig als auch in den Master-Zweig committet. Ein Fast-Forward ist jetzt unmöglich.

Schau dir GitFlow an. Es ist ein Branching-Modell für Git, dem du unbewusst bereits gefolgt bist. Es ist auch eine Erweiterung von Git, die einige Befehle für die neuen Arbeitsablaufschritte hinzufügt, die automatisch Dinge erledigen, die du sonst manuell machen müsstest.

Also, was hast du in deinem Arbeitsablauf richtig gemacht? Du hast zwei Zweige, mit denen du arbeiten kannst. Dein Feature1-Zweig ist im Grunde der "develop"-Zweig im GitFlow-Modell.

Du hast einen Hotfix-Zweig von Master abgezweigt und wieder zusammengeführt. Und jetzt steckst du fest.

Das GitFlow-Modell fordert dich auf, den Hotfix auch in den Entwicklungszeig zu mergen, der in deinem Fall "Feature1" ist.

Die richtige Antwort wäre also:

git checkout feature1
git merge --no-ff hotfix1

Dadurch werden alle Änderungen, die im Hotfix vorgenommen wurden, dem Feature-Zweig hinzugefügt, aber nur diese Änderungen. Sie könnten mit anderen Entwicklungsaufgaben im Zweig kollidieren, aber sie werden nicht mit dem Master-Zweig kollidieren, wenn du den Feature-Zweig letztendlich wieder in den Master mergst.

Sei sehr vorsichtig mit dem Rebasen. Rebase nur, wenn die Änderungen, die du gemacht hast, lokal in deinem Repository geblieben sind, z. B. hast du keine Zweige in ein anderes Repository gepusht. Rebasen ist ein großartiges Werkzeug, um deine lokalen Commits in eine nützliche Reihenfolge zu bringen, bevor du sie in die Welt hinausschiebst, aber ein Rebasen danach wird die Dinge für Git-Anfänger wie dich durcheinander bringen.

Answer 2

Sie sollten in der Lage sein, Ihren Branch auf master neu zu basieren:

git checkout feature1
git rebase master

Alle auftretenden Konflikte verwalten. Wenn Sie zu den Commits mit den Fehlerbehebungen (die bereits in master sind) gelangen, wird Git sagen, dass keine Änderungen vorgenommen wurden und dass sie möglicherweise bereits angewendet wurden. Sie setzen dann den Rebase fort (während Sie die Commits überspringen, die bereits in master sind) mit

git rebase --skip

Wenn Sie ein git log auf Ihrem Feature-Branch durchführen, sehen Sie den Bugfix-Commit nur einmal und im Master-Teil.

Für eine ausführlichere Diskussion werfen Sie einen Blick in die Git-Buchdokumentation zu git rebase (https://git-scm.com/docs/git-rebase), die genau diesen Anwendungsfall abdeckt.

\================ Bearbeitung für zusätzlichen Kontext ====================

Diese Antwort wurde speziell für die Frage von @theomega gegeben und berücksichtigt seine spezielle Situation. Beachten Sie diesen Teil:

Ich möchte verhindern [...] Commits auf meinem Feature-Branch, die keine Beziehung zur Feature-Implementierung haben.

Das Neu-Basieren seines privaten Branches auf master ist genau das, was dieses Ergebnis hervorbringen wird. Im Gegensatz dazu würde das Zusammenführen von master in seinen Branch genau das tun, was er explizit nicht möchte: einen Commit hinzufügen, der nicht mit der Feature-Implementierung verbunden ist, an der er über seinen Branch arbeitet.

Um die Benutzer anzusprechen, die den Fragetitel lesen, über den eigentlichen Inhalt und Kontext der Frage hinwegsehen und dann nur die oberste Antwort lesen, ohne sich zu überlegen, ob sie immer auf ihren (unterschiedlichen) Anwendungsfall zutrifft, erlauben Sie mir zu erklären:

• Rebasen Sie nur private Branches (d.h. Branches, die nur in Ihrem lokalen Repository existieren und nicht mit anderen geteilt wurden). Ein Rebasen gemeinsam genutzter Branches würde die Kopien anderer Personen "zerstören".
• Wenn Sie Änderungen aus einem Branch (ob es sich um master oder einen anderen Branch handelt) in einen öffentlichen Branch integrieren möchten (z. B. haben Sie den Branch gepusht, um eine Pull-Anfrage zu öffnen, aber es gibt jetzt Konflikte mit master, und Sie müssen Ihren Branch aktualisieren, um diese Konflikte zu lösen) müssen Sie sie zusammenführen (z. B. mit git merge master wie in der Antwort von @Sven).
• Sie können auch Branches in Ihre lokalen privaten Branches zusammenführen, wenn dies Ihre Präferenz ist, aber beachten Sie, dass dies zu "fremden" Commits in Ihrem Branch führen wird.

Zuletzt, wenn Sie mit der Tatsache unzufrieden sind, dass diese Antwort nicht am besten zu Ihrer Situation passt, obwohl sie es für @theomega tut, wird ein Kommentar unten nicht besonders hilfreich sein: Ich kontrolliere nicht, welche Antwort ausgewählt wird, nur @theomega tut das.

Answer 3

git merge

Sie können die folgenden Schritte befolgen

1. Zusammenführen des origin/master-Zweigs mit dem feature-Zweig

# Schritt 1: Wechseln zu Zweig master und aktualisieren aller Commits
$ git checkout master
$ git pull

# Schritt 2: Wechseln zum Zielseil und Aktualisieren der Commits
$ git checkout feature
$ git pull

# Schritt 3: master zu feature (aktuell ist feature-Zweig) zusammenführen
$ git merge master

---

2. Zusammenführen des feature-Zweigs mit dem origin/master-Zweig

origin/master ist der entfernte Master-Zweig, während master der lokale Master-Zweig ist

$ git checkout master
$ git pull origin/master

$ git merge feature
$ git push origin/master

Answer 4

Basierend auf diesem Artikel sollten Sie:

• Neuen Branch erstellen, der auf der neuen Version von master basiert

  git branch -b newmaster

• Ihren alten Feature-Branch in den neuen mergen

  git checkout newmaster

• Konflikte im neuen Feature-Branch lösen

Die ersten beiden Befehle können zu git checkout -b newmaster kombiniert werden.

Auf diese Weise bleibt Ihre Historie klar, da Sie keine Rückmischungen benötigen. Und Sie müssen nicht so vorsichtig sein, da Sie kein Git-Rebase durchführen müssen.

Answer 5

Ich füge meine Antwort hinzu, ähnlich zu anderen, aber vielleicht wird sie am schnellsten zu lesen und umzusetzen sein.

HINWEIS: Rebase ist in diesem Fall nicht erforderlich.

Annehmen, ich habe ein repo1 und zwei Branches master und dev-user.

dev-user ist ein Branch, der zu einem bestimmten Stand des master gemacht wurde.

Angenommen, sowohl dev-user als auch master entwickeln sich weiter.

Irgendwann möchte ich, dass dev-user alle Commits von master erhält.

Wie mache ich das?

Zuerst gehe ich in den Stammordner meines Repositorys

cd name_of_the_repository

dann

git checkout master 
git pull 
git checkout dev-user
git pull
git merge master 
git push 

Ich hoffe, dass dies jemand anderem in der gleichen Situation hilft.