Umgang mit einer großen Pull-Anfrage

Ich arbeite derzeit an einem Projekt mit einem Team, das einen Git-Workflow verwendet. Es ist ziemlich einfach, Master sollte sich in einem bereitstellbaren Zustand befinden und zum Erstellen von Features und Hotfixes werden Zweige verwendet. Wann immer wir ein Feature oder einen Bugfix fertiggestellt und getestet haben, übertragen wir diesen so schnell wie möglich auf Master. Die Idee ist, dass Zweige so klein wie möglich sein sollten, um das Zusammenführen mit dem Master zu vereinfachen. Wir haben die Richtlinie, dass sich jeder Code, der an den Master-Zweig gesendet wird, in einem bereitstellbaren Zustand befinden und die Tests bestehen soll.

Wir haben eine Situation, in der einer der Entwickler eine Menge Arbeit (im Wert von ein paar Monaten) an einem einzelnen Zweig geleistet hat und dieser Zweig noch nicht in den Master zurückgeführt wurde. Es gibt jetzt ein paar separate Funktionen und eine Reihe von Commits für diesen Zweig. Eigentlich hätte dieser Zweig schon ein paar Mal wieder zusammengeführt werden müssen, aber das war bisher noch nicht der Fall. Der Großteil des Codes befindet sich in einem guten Zustand mit Komponententests, die wieder in den Master integriert werden können. Die letzten Änderungen sollten jedoch nicht vorgenommen werden, da sie noch nicht abgeschlossen und nicht getestet wurden.

Was ist der beste Weg, um mit einer solchen Situation umzugehen, in der eine Niederlassung wirklich weit von den anderen entfernt ist? Wie können wir in Zukunft verhindern, dass Branchen eine sehr große Anzahl von Commits vom Master entfernen?

Lassen Sie den Entwickler, der ein paar Monate ohne Zusammenführung war, das Problem beheben. Vielleicht können sie einen großen Teil des Codes zusammenführen lassen, vielleicht können sie ein paar kleine Teile nach dem anderen zusammenführen lassen. In jedem Fall sollten sie die notwendigen Schritte unternehmen, um das Problem zu beheben, da sie es verursacht haben.

Was ist der beste Weg, um mit einer solchen Situation umzugehen, in der eine Niederlassung wirklich weit von den anderen entfernt ist?

Machen Sie sich im Allgemeinen keine Sorgen, es ist das Problem des anderen Entwicklers. Wenn zwei Zweige wirklich zu weit voneinander entfernt sind, um zusammengeführt zu werden, sind sie nicht mehr Teil desselben Projekts und Sie haben eine defacto-Verzweigung. Wenn es sich um ein Open Source-Projekt handelt, ist dies möglicherweise kein Problem.

Wenn dieser Entwickler wirklich brillant ist und sein Code besser / schlauer / wichtiger ist als der Rest des Teams, dann lohnt es sich, ihn zu Ihrem Problem zu machen. Ansonsten ist es nicht.

Um die wörtliche Frage zu beantworten: Der beste Weg, mit dieser Situation umzugehen, besteht darin, nicht in eine solche Situation zu geraten.

Wie können wir in Zukunft verhindern, dass Branchen eine sehr große Anzahl von Commits vom Master entfernen?

Stellen Sie sicher, dass jeder bemerkt, dass der Entwickler, der monatelang ohne Zusammenführung war, das von ihm verursachte Problem beheben muss. Stellen Sie sicher, dass jeder weiß, dass es einfacher ist, sich häufiger als selten auf Master einzulassen, da weniger Änderungen weniger Möglichkeiten für Konflikte bedeuten.

Stellen Sie sicher, dass die Benutzer wissen, dass sie vom Master abrufen können, um über die Änderungen anderer Benutzer auf dem Laufenden zu bleiben.

"Wenn Sie jeden Tag fusionieren, kommen Sie plötzlich nie an den Punkt, an dem Sie große Konflikte haben, die schwer zu lösen sind." - Linus Torvalds

Das Zitat stammt aus einem Vortrag, den er bei Google gehalten hat. Hier ist das Protokoll und hier ist das Video .

Wenn Sie ein Commit haben, von dem Sie wissen, dass dieses und alle vorherigen Commits gut getestet wurden und zusammengeführt werden sollten, verzweigen Sie einfach von diesem letzten guten Commit und führen Sie den neuen Zweig mit master zusammen.

Wenn Sie einige Commits haben, die Sie zusammenführen möchten, diese aber mit anderen Commits durchsetzt sind, die nicht produktionsbereit sind, sehe ich zwei Möglichkeiten:

1. Erstellen Sie einen neuen Zweig, und wählen Sie gute Commits aus, und verschmelzen Sie mit master.
2. Versuchen Sie, unerwünschte Commits nach oben zu verschieben (möglicherweise in einem neuen Zweig, nur um sicher zu gehen).

Versuchen Sie in Bezug auf Präventionsmethoden einige lustige Teamregeln zu definieren, wie "Einer, der nicht innerhalb einer Woche mit dem Meister verschmilzt, bestellt einen Monat lang Pizza".

Überprüfen Sie zunächst, ob es wirklich separate Commits gibt, die zusammengeführt oder ausgewählt werden können, wie von @Maciej Chalpuk vorgeschlagen. Wenn dies der Fall ist, ist die Situation wirklich nicht so schlimm, und ich würde mir in Zukunft keine allzu großen Sorgen machen.

Wenn jedoch in der Realität mehrere Features gleichzeitig in einem Zweig und innerhalb derselben Commits entwickelt wurden, wird es viel schwieriger, mit diesen umzugehen. Glücklicherweise ist die Verhinderungsmethode eingebaut: Der Entwickler muss die Änderungen für jedes Feature in separate Zweige aufteilen und Anforderungen abrufen, bevor sie zusammengeführt werden. Sie erhalten sowohl Ihre atomaren Zusammenführungen als auch den Entwickler davon abhalten, dies zu tun die Zukunft.

Die eigentliche Trennung der Merkmale erfolgt vollständig manuell. Erstellen Sie neue Verzweigungen von master und kopieren Sie alle Änderungen aus der Megazweig, die damit zusammenhängen. Kompilieren Sie das Feature, testen Sie es, drücken Sie es und geben Sie eine Pull-Anfrage ab. Je weniger sich die Codeänderungen vermischen, desto einfacher wird es. Wenn er für alle eine einzige Methode gehackt hat, nun, viel Spaß. Er wird es nicht wieder tun.

Hier ist eine einfache Lösung.

Verfolgen Sie die Features, die diese Person implementiert hat, und rufen Sie jedes Commit für diesen Zweig auf, der pro Feature aktualisiert wurde. Nehmen Sie dieses Commit und führen Sie es mit dem Master-Repo zusammen.

Lassen Sie mich dies in Form eines Beispiels aufschlüsseln.

Es sei: Zweig A der Zweig des Masters Zweig A + = Zweig A + neues Merkmal 1 Zweig A ++ = Zweig A + neues Merkmal 2 und so weiter und so fort

Was Sie tun müssen, ist, zurück zu gehen: Zweig A +

Nehmen Sie Zweig A + und verschmelzen Sie ihn mit Master.

Gehen Sie nun zu Zweig A ++ und führen Sie es mit (Master + Zweig A +) zusammen.

Wiederholen Sie diesen Vorgang, bis Sie den endgültigen Zweig A + ... + erreicht haben, der stabil ist.

Diese Methode mag zunächst nicht intuitiv klingen, aber wenn Sie jedes einzelne neue Feature einzeln mit dem Master zusammenführen, können Sie problemlos zwischen den Master-Zweigen " pro hinzugefügtem Feature " wechseln.

Wie können wir in Zukunft verhindern, dass Branchen eine sehr große Anzahl von Commits vom Master entfernen?

Ich denke, meine obige Lösung gibt an, welche zukünftige Methode Sie anwenden sollten. Entscheiden Sie sich für eine Methode pro Feature oder pro Task für jeden Zweig.

Ich würde vorschlagen, einen Ansatz von:

Pre-Master und Master

Meister: Finale / Produktionsebene. Wird nicht oft geändert. Wird immer als stabil angesehen

Pre-Master: Der Bereich, in dem ein neues Feature zu vorhandenem Code hinzugefügt wird. Wurde gründlich getestet, um mit vorhandener Codebasis zu arbeiten, und ist der Ort, an dem andere Zweige nach einer Implementierung neuer Funktionen suchen können.

Sie sollten auch versuchen, Funktionen zu bündeln und das Versions-Targeting zu erreichen.

Versions-Targeting: Geben Sie eine beliebige Nummer an, die als Platzhalter für den Hauptzweig fungiert. "In V1.0.0 werden wir X-, Y- und Z-Funktionen erreichen wollen. In V1.0.0 stehen auch alle folgenden Funktionen zur Verfügung: ..."

Durch die Pflege einer Version gegen Master kann dies auch eine Möglichkeit sein, "Master" jederzeit stabil und produktionsbereit zu halten.

Das Problem der großen Pull-Anfrage zu beheben, ist eine Sache, und es gibt einige gute Antworten dazu. Wenn Sie sich jedoch mit weit veralteten Branchen befassen, sollten Sie Ihre Prozesse für den Umgang mit Teamarbeit überdenken.

Wenn Sie in einem Agile- oder SCRUM-Framework arbeiten, sollte sich das Team wirklich fragen, warum das Feature im Rahmen der Iteration / des Sprints nicht abgeschlossen und zusammengeführt wurde. Wenn es "zu groß" war, um in eine Iteration zu passen, hätte es in kleinere Stücke zerlegt werden müssen.

Es stellt sich auch die Frage der Code-Inhaberschaft: Besitzen einzelne Entwickler innerhalb Ihres Teams ihre eigene Arbeit oder arbeitet das gesamte Team zusammen, um sicherzustellen, dass die Aufgaben erledigt sind?

Bei den obigen Ausführungen wird natürlich davon ausgegangen, dass sich Ihr Team in einer Art Unternehmensstruktur befindet. Wenn dies ein Open-Source-Projekt mit freiwilligen Mitarbeitern ist, ist das eine andere Geschichte. Im Allgemeinen haben solche Projekte eine lockerere Kontrolle über Arbeitsabläufe, aber die Verantwortung für die Generierung akzeptabler Pull-Anforderungen liegt häufiger bei den einzelnen Mitwirkenden.

In vielerlei Hinsicht wird dies zu einer Prozessfrage. Möglicherweise umfasst Ihr erforderlicher Prozess die regelmäßige Überprüfung (wöchentlich? Monatlich?) Auf langfristige, nicht zusammengeschlossene Zweigniederlassungen. Einige Tools erleichtern die visuelle Überprüfung. Besuchen Sie zB auf Github den Link "Zweige" und es wird angezeigt, wie weit vor / hinter jedem Zweig ist.