Wie aktualisiere ich ein gegabeltes GitHub-Repository?

3606

Ich habe kürzlich ein Projekt gegabelt und mehrere Korrekturen vorgenommen. Ich habe dann eine Pull-Anfrage erstellt, die dann akzeptiert wurde.

Einige Tage später wurde eine weitere Änderung von einem anderen Mitwirkenden vorgenommen. Meine Gabel enthält diese Änderung also nicht.

Wie kann ich dieses Wechselgeld in meine Gabel bekommen? Muss ich meine Gabel löschen und neu erstellen, wenn ich weitere Änderungen vornehmen muss? Oder gibt es eine Update-Schaltfläche?

Lea Hayes
quelle
120
Dies kann auch über die Github-Benutzeroberfläche erfolgen. Ich möchte [diesem anderen Poster] [1] Anerkennung zollen. [1]: stackoverflow.com/a/21131381/728141
Mike Schroll
2
Ein weiterer guter Blog-Beitrag zu diesem Thema - Keeping A GitHub Fork Updated
Arup Rakshit
3
Gefunden dies in Github Hilfeartikeln
Pranav
2
Ist dies ein Duplikat von stackoverflow.com/questions/3903817/… ?
David Cary
Hier ist eine Video-Demo, die dies unter Verwendung von zwei Github-Konten tut. Youtube.com/watch?v=kpE0gTX4ycE
Lifebalance

Antworten:

3980

In Ihrem lokalen Klon Ihres gegabelten Repositorys können Sie das ursprüngliche GitHub-Repository als "Remote" hinzufügen. ("Fernbedienungen" sind wie Spitznamen für die URLs von Repositorys - originbeispielsweise eine.) Anschließend können Sie alle Zweige aus diesem Upstream-Repository abrufen und Ihre Arbeit neu starten, um die Arbeit an der Upstream-Version fortzusetzen. In Bezug auf Befehle, die wie folgt aussehen könnten:

# Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

# Fetch all the branches of that remote into remote-tracking branches,
# such as upstream/master:

git fetch upstream

# Make sure that you're on your master branch:

git checkout master

# Rewrite your master branch so that any commits of yours that
# aren't already in upstream/master are replayed on top of that
# other branch:

git rebase upstream/master

Wenn Sie den Verlauf Ihres Hauptzweigs nicht neu schreiben möchten (z. B. weil andere ihn möglicherweise geklont haben), sollten Sie den letzten Befehl durch ersetzen git merge upstream/master. Um jedoch weitere Pull-Anforderungen zu stellen, die so sauber wie möglich sind, ist es wahrscheinlich besser, die Basis neu zu erstellen.


Wenn Sie Ihren Zweig neu aufgebaut haben, müssen upstream/masterSie möglicherweise den Push erzwingen, um ihn in Ihr eigenes gegabeltes Repository auf GitHub zu verschieben. Das würdest du machen mit:

git push -f origin master

Sie müssen -fdas erste Mal erst verwenden, nachdem Sie die Basis neu festgelegt haben.

Mark Longair
quelle
94
Da Ihre Gabel nur auf Github vorhanden ist und Github keine Tools zum Zusammenführen über die Weboberfläche hat, ist die richtige Antwort, die Upstream-Zusammenführung lokal durchzuführen und die Änderungen zurück auf Ihre Gabel zu übertragen.
Tim Keating
29
Hier ist ein großartiges Tutorial, das ich über die Arbeit mit Github gefunden habe: gun.io/blog/how-to-github-fork-branch-and-pull-request
Tim Keating
50
Ein kurzer Hinweis: Anstatt Ihren eigenen Hauptzweig neu zu gründen, um sicherzustellen, dass Sie mit einem sauberen Zustand beginnen, sollten Sie wahrscheinlich an einem separaten Zweig arbeiten und daraus eine Pull-Anforderung stellen. Dies hält Ihren Master für zukünftige Zusammenführungen sauber und verhindert, dass Sie den Verlauf neu schreiben müssen, -fwodurch alle durcheinander gebracht werden, die Ihre Version hätten klonen können.
Mateusz Kowalczyk
11
Anstelle des Rebase-Befehls habe ich Folgendes verwendet: Auf git merge --no-ff upstream/masterdiese Weise sind Ihre Commits nicht mehr oben.
Steckdoserich
52
Ein weiterer Git-Fehler. Wenn dieses Tool die verteilte Zusammenarbeit unterstützen soll, warum ist es dann so schwierig, einen grundlegenden Workflow durchzuführen? 4 Millionen Menschen und 2200 Upvotes bedeuten, dass das Tool fehlgeschlagen ist. "Sie können das ursprüngliche GitHub-Repository als" Remote "hinzufügen - Warum muss man das überhaupt tun? Warum wird es nicht während der Gabelung gemacht? Was ist an diesem Tool so kaputt?
jww
740

Ab Mai 2014 ist es möglich, eine Gabel direkt von GitHub aus zu aktualisieren. Dies funktioniert immer noch ab September 2017, ABER es wird zu einem schmutzigen Commit-Verlauf führen.

  1. Öffne deine Gabel auf GitHub.
  2. Klicken Sie auf Pull Requests.
  3. Klicken Sie auf New Pull Request. Standardmäßig vergleicht GitHub das Original mit Ihrer Gabel, und es sollte nichts zu vergleichen sein, wenn Sie keine Änderungen vorgenommen haben.
  4. Klicken switching the baseSie auf, wenn Sie diesen Link sehen. Andernfalls stellen Sie den base forkDropdown manuell auf Ihre Gabel und den head forkauf den Upstream ein. Jetzt vergleicht GitHub Ihre Gabel mit dem Original und Sie sollten die neuesten Änderungen sehen. Geben Sie hier die Bildbeschreibung ein
  5. Create pull requestund weisen Sie Ihrer Pull-Anfrage einen vorhersehbaren Namen zu (z Update from original. B. ).
  6. Scrollen Sie nach unten Merge pull request, aber klicken Sie noch nicht auf etwas.

Jetzt haben Sie drei Optionen, aber jede führt zu einem weniger sauberen Commit-Verlauf.

  1. Die Standardeinstellung erstellt ein hässliches Zusammenführungs-Commit.
  2. Wenn Sie auf die Dropdown-Liste klicken und "Squash and Merge" wählen, werden alle dazwischen liegenden Commits zu einem zusammengefasst. Dies ist meistens etwas, was Sie nicht wollen.
  3. Wenn Sie auf klicken Rebase and merge, werden alle Commits "mit" Ihnen gemacht, die ursprünglichen PRs werden mit Ihrer PR verknüpft und GitHub wird angezeigt This branch is X commits ahead, Y commits behind <original fork>.

Ja, Sie können Ihr Repo über die GitHub-Web-Benutzeroberfläche mit dem Upstream auf dem neuesten Stand halten. Dadurch wird jedoch Ihr Commit-Verlauf beeinträchtigt. Halten Sie sich stattdessen an die Befehlszeile - es ist einfach.

Lobzik
quelle
19
Das hat einmal großartig funktioniert. Beim zweiten Mal funktionierte dieser Vorgang nicht auf die gleiche Weise: Der Link "Switching the Base" wurde nicht angezeigt. Und wenn ich auf "Klicken, um eine Pull-Anfrage zu erstellen" klicke, wird eine PR im SOURCE-Repo erstellt. NICHT was ich wollte ..
Javadba
29
Funktioniert immer noch (Marchi 2015), obwohl der Link "Switching the Base" nicht mehr vorhanden ist. Sie müssen die Dropdown-Liste "Basis" so ändern, dass beide auf Ihre Gabel zeigen, und dann erhalten Sie die Aufforderung "Über Repos vergleichen", die Sie dorthin bringt, wo Sie möchten.
mluisbrown
8
April 2015. Funktioniert. Vielen Dank. Ich habe "Wechsel zur Basis" bekommen. Schritt 6 war jedoch "Pull-Anfrage erstellen" -> Kommentar eingeben -> "Pull-Anfrage erstellen". Am Ende steht 1 Commit vor dem Original.
Cartland
5
@cartland (oder andere) - ja, es heißt "Dieser Zweig ist 1 Commit vor ..." Ist das etwas, worüber man sich Sorgen machen muss? Ist es möglich, diese Nachricht loszuwerden?
RenniePet
11
Wäre es nicht besser, mit einem einfachen Update- oder Synchronisierungsknopf!
Transformator
457

Hier ist das offizielle Dokument von GitHub zum Synchronisieren einer Gabel :

Eine Gabel synchronisieren

Die Einrichtung

Bevor Sie synchronisieren können, müssen Sie eine Fernbedienung hinzufügen, die auf das Upstream-Repository verweist. Möglicherweise haben Sie dies getan, als Sie ursprünglich gegabelt haben.

Tipp: Durch die Synchronisierung Ihrer Verzweigung wird nur Ihre lokale Kopie des Repositorys aktualisiert. Ihr Repository auf GitHub wird nicht aktualisiert.

$ git remote -v
# List the current remotes
origin  https://github.com/user/repo.git (fetch)
origin  https://github.com/user/repo.git (push)

$ git remote add upstream https://github.com/otheruser/repo.git
# Set a new remote

$ git remote -v
# Verify new remote
origin    https://github.com/user/repo.git (fetch)
origin    https://github.com/user/repo.git (push)
upstream  https://github.com/otheruser/repo.git (fetch)
upstream  https://github.com/otheruser/repo.git (push)

Synchronisieren

Es sind zwei Schritte erforderlich, um Ihr Repository mit dem Upstream zu synchronisieren: Zuerst müssen Sie von der Fernbedienung abrufen, dann müssen Sie den gewünschten Zweig mit Ihrem lokalen Zweig zusammenführen.

Holen

Durch das Abrufen aus dem Remote-Repository werden die Zweige und die entsprechenden Commits eingebunden. Diese werden in Ihrem lokalen Repository unter speziellen Zweigen gespeichert.

$ git fetch upstream
# Grab the upstream remote's branches
remote: Counting objects: 75, done.
remote: Compressing objects: 100% (53/53), done.
remote: Total 62 (delta 27), reused 44 (delta 9)
Unpacking objects: 100% (62/62), done.
From https://github.com/otheruser/repo
 * [new branch]      master     -> upstream/master

Wir haben jetzt den Hauptzweig des Upstreams in einem lokalen Zweig, Upstream / Master, gespeichert

$ git branch -va
# List all local and remote-tracking branches
* master                  a422352 My local commit
  remotes/origin/HEAD     -> origin/master
  remotes/origin/master   a422352 My local commit
  remotes/upstream/master 5fdff0f Some upstream commit

Zusammenführen

Nachdem wir das Upstream-Repository abgerufen haben, möchten wir seine Änderungen in unserer lokalen Niederlassung zusammenführen. Dadurch wird dieser Zweig mit dem Upstream synchronisiert, ohne dass unsere lokalen Änderungen verloren gehen.

$ git checkout master
# Check out our local master branch
Switched to branch 'master'

$ git merge upstream/master
# Merge upstream's master into our own
Updating a422352..5fdff0f
Fast-forward
 README                    |    9 -------
 README.md                 |    7 ++++++
 2 files changed, 7 insertions(+), 9 deletions(-)
 delete mode 100644 README
 create mode 100644 README.md

Wenn Ihre lokale Niederlassung keine eindeutigen Commits hatte, führt git stattdessen einen "Schnellvorlauf" durch:

$ git merge upstream/master
Updating 34e91da..16c56ad
Fast-forward
 README.md                 |    5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

Tipp: Wenn Sie Ihr Repository auf GitHub aktualisieren möchten, befolgen Sie die Anweisungen hier

Jumpnett
quelle
1
Dadurch wird meine lokale Gabel aktualisiert, aber auf meiner Gabel auf Github.com steht immer noch "43 Commits Behind". Ich musste Lobziks Technik verwenden, um eine Pull-Anfrage für mich zu erstellen, um die Master-Änderungen in meiner Github.com-Gabel zusammenzuführen.
Michael McGinnis
11
@MichaelMcGinnis Nach dem lokalen Zusammenführen müssten Sie Ihre Änderungen an github übertragen. git push origin master
Jumpnett
1
Könnte klug sein, mit zu schieben --follow-tags: stackoverflow.com/a/26438076/667847
kenny
1
Ich muss es für alle Zweige separat tun git merge upstream/master, dann git merge upstream/develop
auschecken
stackoverflow.com/a/14074925/470749 war für mich hilfreich, weil ich Permission denied (publickey). fatal: Could not read from remote repository.beim Versuch, von Facebooks Github-Konto Upstream abzurufen, etwas bekommen habe .
Ryan
98

Viele Antworten führen dazu, dass Ihr Fork One Commit vor dem übergeordneten Repository verschoben wird. Diese Antwort fasst die hier gefundenen Schritte zusammen, mit denen Sie Ihre Gabel auf das gleiche Commit wie das übergeordnete Element verschieben .

  1. Wechseln Sie in Ihr lokales Repository.

    • Wechseln Sie zum Hauptzweig, wenn Sie dies nicht tun git checkout master
  2. Fügen Sie das übergeordnete Element als Remote-Repository hinzu. git remote add upstream <repo-location>

  3. Problem git fetch upstream
  4. Problem git rebase upstream/master

    • In diesem Stadium überprüfen Sie durch Eingabe, ob festgeschrieben wird, was zusammengeführt wird git status
  5. Problem git push origin master

Weitere Informationen zu diesen Befehlen finden Sie in Schritt 3 .

Sahar Rabinoviz
quelle
13
@MT: Wo geben Sie diese Befehle ein? Der Kern der Frage ist, wie ich es verstehe, wie Sie Ihre persönliche GitHub- Gabel mit dem Hauptprojekt neu synchronisieren und dies alles von GitHub aus tun können . Mit anderen Worten, wie können Sie Ihren Remote-Fork ohne ein lokales Repository aktualisieren ?
John Y
4
@JohnY Wenn Sie GitHub verwenden, wird immer ein zusätzliches Commit erstellt. Sie müssen dies alles in einer Shell auf einem lokalen Repo tun, um dieses zusätzliche Commit zu vermeiden.
Jonathan Cross
49

Wenn Sie, wie ich, niemals etwas direkt dem Meister übertragen , was Sie wirklich sollten, können Sie Folgendes tun.

Erstellen Sie aus dem lokalen Klon Ihrer Gabel Ihre Upstream-Fernbedienung. Sie müssen das nur einmal tun:

git remote add upstream https://github.com/whoever/whatever.git

Wann immer Sie den Upstream-Repository-Hauptzweig einholen möchten, müssen Sie:

git checkout master
git pull upstream master

Angenommen, Sie haben selbst nie etwas für den Meister getan, sollten Sie bereits fertig sein. Jetzt können Sie Ihren lokalen Master auf Ihre ursprüngliche Remote-GitHub-Gabel schieben. Sie können Ihren Entwicklungszweig auch auf Ihrem jetzt aktuellen lokalen Master neu aufbauen.

Nach dem anfänglichen Upstream-Setup und dem Master-Checkout müssen Sie nur den folgenden Befehl ausführen, um Ihren Master mit dem Upstream zu synchronisieren: git pull upstream master .

Slion
quelle
48

Vorwort: Ihre Gabel ist der "Ursprung" und das Repository, aus dem Sie gegabelt haben, ist der "Upstream".

Nehmen wir an, Sie haben Ihre Gabel bereits mit einem Befehl wie diesem auf Ihren Computer geklont:

git clone [email protected]:your_name/project_name.git
cd project_name

Wenn dies angegeben ist, müssen Sie in dieser Reihenfolge fortfahren:

  1. Fügen Sie den "Upstream" zu Ihrem geklonten Repository hinzu ("Ursprung"):

    git remote add upstream [email protected]:original_author/project_name.git
    
  2. Holen Sie sich die Commits (und Zweige) aus dem "Upstream":

    git fetch upstream
    
  3. Wechseln Sie zum "Master" -Zweig Ihrer Gabel ("Ursprung"):

    git checkout master
    
  4. Verstecken Sie die Änderungen Ihres "Master" -Zweigs:

    git stash
    
  5. Führen Sie die Änderungen aus dem "Master" -Zweig des "Upstream" in den "Master" -Zweig Ihres "Ursprungs" ein:

    git merge upstream/master
    
  6. Lösen Sie etwaige Zusammenführungskonflikte und legen Sie Ihre Zusammenführung fest

    git commit -am "Merged from upstream"
    
  7. Schieben Sie die Änderungen an Ihre Gabel

    git push
    
  8. Holen Sie sich Ihre versteckten Änderungen zurück (falls vorhanden)

    git stash pop
    
  9. Du bist fertig! Herzliche Glückwünsche!

GitHub bietet auch Anweisungen zu diesem Thema: Synchronisieren einer Gabel

Benny Neugebauer
quelle
1
Teilweise geholfen: Ist git remote add upstream [email protected]:original_author/project_name.gitnur ein Alias ​​für git remote add upstream https://github.com/original_author/project_name.git?
Wolf
2
Wolf , ich schätze, du weißt das inzwischen, aber für die Nachwelt ... Es ist das Format für ssh. help.github.com/articles/configuring-a-remote-for-a-fork
Brad Ellis
2
Vielen Dank. git stashund git stash popTeil sehr hilfreich
सत्यमेव जयते
Das hat funktioniert. Nach dem Zusammenführen von Git Upstream / Master schlug die automatische Zusammenführung aufgrund nicht zusammengeführter Pfade fehl, die ich ausführen musste. Git add -A, dann git commit -m "message", dann war es aktuell.
Highcenbug
45

Seit November 2013 gibt es eine inoffizielle Feature-Anfrage bei GitHub, in der sie gebeten werden, eine sehr einfache und intuitive Methode hinzuzufügen, um eine lokale Abzweigung mit dem Upstream synchron zu halten:

https://github.com/isaacs/github/issues/121

Hinweis: Da die Funktionsanforderung inoffiziell ist, ist es auch ratsam, Kontakt aufzunehmen [email protected], um Ihre Unterstützung für eine zu implementierende Funktion wie diese hinzuzufügen. Die obige inoffizielle Merkmalsanforderung könnte als Beweis für das Ausmaß des Interesses an der Umsetzung verwendet werden.

isedwards
quelle
23

Zum Datum dieser Antwort hat GitHub diese Funktion in der Weboberfläche nicht ( oder soll ich nicht mehr sagen? ). Sie können jedoch darum bitten [email protected], Ihre Stimme dafür hinzuzufügen.

In der Zwischenzeit hat der GitHub-Benutzer bardiharborow ein Tool dafür erstellt: https://upriver.github.io/

Quelle ist hier: https://github.com/upriver/upriver.github.io

Lucero
quelle
2
Obwohl ich das Tool für eine gute Idee halte, ist die Realität, dass es GEBROCHEN ist. Es wurden nur 20 Repos von meinem Konto geladen und sogar die Fußzeile leitet zu einer Website weiter, die nicht vorhanden ist. Wenn das behoben ist, werde ich ein großer Anwalt sein.
Sorin
2
Bis heute habe ich flussaufwärts erfolgreich eine Gabel mit dem Upstream-Repo synchronisiert, daher funktioniert es für meine Zwecke und ich werde es weiterhin verwenden.
NauticalMile
1
@sorin Diese 20 Repo / Branch-Beschränkung (jetzt sind es 30) stammt aus den Standard-Paging-Einstellungen von GitHub. Es müssen einige Anpassungen am Code vorgenommen werden, um dies zu handhaben.
Andreas
19

Wenn Sie GitHub für Windows oder Mac verwenden, haben sie jetzt eine Ein-Klick-Funktion zum Aktualisieren von Gabeln:

  1. Wählen Sie das Repository in der Benutzeroberfläche aus.
  2. Klicken Sie oben auf die Schaltfläche "Von Benutzer / Zweig aktualisieren".
Shital Shah
quelle
11

Tatsächlich ist es möglich, aus jedem Commit des Upstreams im Browser einen Zweig in Ihrem Fork zu erstellen:

  • Öffnen Sie https://github.com/<repo>/commits/<hash>, wobei Repo Ihre Abzweigung ist und Hash der vollständige Commit- Hash ist, den Sie in der Upstream-Weboberfläche finden. Zum Beispiel kann ich https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 öffnen , was auf linux masterden Zeitpunkt des Schreibens hinweist .
  • Klicken Sie auf die Schaltfläche "Baum: ....".
  • Geben Sie den Namen des neuen Zweigs ein und drücken Sie Enter

Geben Sie hier die Bildbeschreibung ein

Sie können diesen Zweig dann zu Ihrem lokalen Klon abrufen, und Sie müssen nicht alle Daten an GitHub zurücksenden, wenn Sie Änderungen zusätzlich zu diesem Commit übertragen. Oder verwenden Sie die Weboberfläche, um etwas in diesem Zweig zu ändern.

Wie es funktioniert (es ist eine Vermutung, ich weiß nicht genau, wie GitHub es macht): Gabeln teilen den Objektspeicher und verwenden Namespaces , um Benutzerreferenzen zu trennen. Sie können also über Ihre Gabel auf alle Commits zugreifen, auch wenn diese zum Zeitpunkt des Gabelns noch nicht vorhanden waren.

max630
quelle
2
Das ist toll! Dies vermeidet das völlig sinnlose Hochladen dieser Commits auf Github.
Rotsor
9

Befolgen Sie die folgenden Schritte. Ich habe es versucht und es hat mir geholfen.

Kasse zu Ihrer Filiale

Syntax: git branch yourDevelopmentBranch
Beispiel: git checkout master

Ziehen Sie den Quell-Repository-Zweig, um den neuesten Code abzurufen

Syntax: git pull https://github.com/tastejs/awesome-app-ideas master
Beispiel: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

Venkat.R
quelle
1
Wenn Sie GitHub verwenden, möchten Sie Ihre Änderungen möglicherweise auch in Ihren GitHub-Zweig übertragen. git push HttpsForYourForkOfTheRepo BRANCH_NAME
user3731622
9

Ich aktualisiere meine gegabelten Repos mit dieser einen Zeile:

git pull https://github.com/forkuser/forkedrepo.git branch

Verwenden Sie diese Option, wenn Sie Ihrem Projekt keinen weiteren Remote-Endpunkt hinzufügen möchten, wie andere hier veröffentlichte Lösungen.

R. Bravo
quelle
2
Gibt es Einschränkungen dafür? dh gilt dies nur für Fälle, in denen Sie seit dem letzten Update keine Commits, Zusammenführungen, Pull-Anforderungen hinzugefügt oder Pull-Anforderungen in den Upstream zusammengeführt haben?
LightCC
1
Es funktioniert wie ein normaler Zug von einem entfernten Zweig. Wenn Sie X-Commits für Ihr lokales Repo durchgeführt haben und jetzt Y-Commits hinter dem ursprünglichen Repo stehen, werden die Y-Commits in Ihre lokale Niederlassung gebracht und Sie erhalten wahrscheinlich einige Konflikte, die Sie lösen müssen.
R.Bravo
1
@LightCC Dies unterscheidet sich nicht vom Ziehen von einer zuvor hinzugefügten Fernbedienung, außer dass Sie keine Fernbedienung hinzugefügt haben . Der Nachteil ist also, dass Sie jedes Mal die vollständige Repository-URL eingeben müssen, wenn Sie möchten pull.
März 2377
1
Dies ist eine perfekte Lösung, wenn Sie nicht viele Male aus dem ursprünglichen Repo ziehen müssen oder das gegabelte Projekt relativ einfach ist.
AxeEffect
7

Als Ergänzung zu dieser Antwort suchte ich nach einer Möglichkeit, alle entfernten Zweige meines geklonten Repos ( Ursprungs ) von vorgelagerten Zweigen auf einmal zu aktualisieren . So habe ich es gemacht.

Dies setzt voraus, dass Sie bereits eine Upstream- Fernbedienung konfiguriert haben, die auf das Quell-Repository zeigt (von dem der Ursprung stammt), und diese mit synchronisiert haben git fetch upstream.

Dann renne:

for branch in $(git ls-remote --heads upstream|sed 's#^.*refs/heads/##'); do git push origin refs/remotes/upstream/$branch:refs/heads/$branch; done

Der erste Teil dieses Befehls listet alle Köpfe im Upstream- Remote-Repo auf und entfernt den SHA-1, gefolgt vom refs/heads/Präfix des Zweignamens.

Anschließend wird für jeden dieser Zweige die lokale Kopie des vorgelagerten Fernverfolgungszweigs ( refs/remotes/upstream/<branch>auf der lokalen Seite) direkt an den entfernten Zweig am Ursprung ( refs/heads/<branch>auf der entfernten Seite) gesendet.

Jeder dieser Verzweigungssynchronisierungsbefehle kann aus einem von zwei Gründen fehlschlagen: Entweder wurde der Upstream- Zweig neu geschrieben, oder Sie haben Commits für diesen Zweig an Ihre Verzweigung gesendet. Im ersten Fall, in dem Sie dem Zweig Ihrer Gabel nichts zugewiesen haben, können Sie sicher kräftig drücken (Fügen Sie den Schalter -f hinzu , dh git push -fim obigen Befehl). Im anderen Fall ist dies normal, da Ihr Gabelzweig auseinander gegangen ist und Sie nicht erwarten können, dass der Synchronisierungsbefehl funktioniert, bis Ihre Commits wieder in den Upstream zusammengeführt wurden .

Thomas Guyot-Sionnest
quelle
6

Die "Pull" App ist eine automatische Lösung zum Einrichten und Vergessen. Der Standardzweig Ihrer Gabel wird mit dem Upstream-Repository synchronisiert.

Besuchen Sie die URL, klicken Sie auf die grüne Schaltfläche "Installieren" und wählen Sie die Repositorys aus, in denen Sie die automatische Synchronisierung aktivieren möchten.

Der Zweig wird einmal pro Stunde direkt auf GitHub aktualisiert. Auf Ihrem lokalen Computer müssen Sie den Hauptzweig ziehen, um sicherzustellen, dass Ihre lokale Kopie synchron ist.

krlmlr
quelle
2
Bitte beachten Sie, dass Sie mit der Grundeinstellung die in Ihrem gegabelten Repository vorgenommenen Änderungen verlieren können. Um die Änderungen beizubehalten, richten Sie eine Konfigurationsdatei ein und geben Sie a an mergemethod. Mehr dazu hier
Saurabh P Bhandari
1
Ich habe festgestellt, dass das grundlegende Setup Pull-Anforderungen sendet und zusammenführt (im Gegensatz zu den Angaben in der Dokumentation). Dies ist etwas ärgerlich, löst aber das Datenverlustproblem?
krlmlr
4

Android Studio hat jetzt gelernt, mit GitHub-Fork-Repositorys zu arbeiten (Sie müssen nicht einmal das "Upstream" -Remote-Repository per Konsolenbefehl hinzufügen).

Öffnen Sie das Menü VCSGit

Beachten Sie auch die beiden letzten Popup-Menüpunkte:

  • Rebase meine GitHub Gabel

  • Pull-Anfrage erstellen

Versuch sie. Ich verwende das erste, um mein lokales Repository zu synchronisieren. Auf jeden Fall können Sie auf die Zweige des übergeordneten Remote-Repositorys ("Upstream") in Android Studio zugreifen, nachdem Sie auf "Rebase my GitHub fork" geklickt haben, und Sie können problemlos mit ihnen arbeiten.

(Ich verwende Android Studio 3.0 mit den Plugins "Git Integration" und "GitHub".)

Geben Sie hier die Bildbeschreibung ein

alexshr
quelle
4

Wenn Sie Ihr gegabeltes Repository geklont haben, wechseln Sie zu dem Verzeichnispfad, in dem sich Ihr Klon befindet, und zu den wenigen Zeilen in Ihrem Git Bash Terminal.

$ cd project-name

$ git remote add upstream https://github.com/user-name/project-name.git
 # Adding the upstream -> the main repo with which you wanna sync

$ git remote -v # you will see the upstream here 

$ git checkout master # see if you are already on master branch

$ git fetch upstream

Und los geht's. Alle aktualisierten Änderungen im Haupt-Repository werden in Ihr Fork-Repository übertragen.

Der Befehl "Abrufen" ist unverzichtbar, um in einem Projekt auf dem neuesten Stand zu bleiben: Nur wenn Sie einen "Git-Abruf" durchführen, werden Sie über die Änderungen informiert, die Ihre Kollegen auf den Remote-Server übertragen haben.

Sie können hier noch weitere Fragen stellen

Prateek Chanda
quelle
4

Wenn Sie Ihren Upstream einstellen. Überprüfen Sie mit git remote -v, dann wird dies ausreichen.

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push
Prosti
quelle
2

Das hängt von der Größe Ihres Repositorys ab und davon, wie Sie es gegabelt haben.

Wenn es sich um ein ziemlich großes Repository handelt, möchten Sie es möglicherweise auf besondere Weise verwalten (z. B. Drop-Verlauf). Grundsätzlich können Sie Unterschiede zwischen aktuellen und vorgelagerten Versionen feststellen, diese festschreiben und dann zum Master zurückkehren.

Versuchen Sie, dieses zu lesen . Es wird beschrieben, wie große Git-Repositorys behandelt und mit den neuesten Änderungen vorgelagert werden.

s0nicYouth
quelle
2

Ich möchte die Antwort von @ krlmlr ergänzen .

Anfänglich hat das gegabelte Repository einen Zweig mit dem Namen : master. Wenn Sie an einer neuen Funktion oder einem Fix arbeiten, erstellen Sie im Allgemeinen einen neuen Zweig featureund nehmen die Änderungen vor.

Wenn Sie möchten, dass das gegabelte Repository mit dem übergeordneten Repository synchronisiert ist, können Sie eine Konfigurationsdatei ( pull.yml) für die Pull-App ( im Feature-Zweig ) wie folgt einrichten :

version: "1"
rules:
  - base: feature
    upstream: master
    mergeMethod: merge
  - base: master
    upstream: parent_repo:master
    mergeMethod: hardreset

Dies hält den masterZweig des gegabelten Repos mit dem übergeordneten Repo auf dem neuesten Stand. Es hält den featureZweig des gegabelten Repos über den masterZweig des gegabelten Repos auf dem neuesten Stand, indem es zusammengeführt wird. Dies setzt voraus, dass der featureZweig der Standardzweig ist, der die Konfigurationsdatei enthält.

Hier sind zwei mergemethodsim Spiel, eine hardresethilft dabei, Synchronisierungsänderungen im masterZweig des gegabelten Repos mit dem übergeordneten Repo zu erzwingen, und die andere Methode ist merge. Diese Methode wird verwendet, um von Ihnen in der featureVerzweigung vorgenommene Änderungen und Änderungen, die aufgrund der erzwungenen Synchronisierung in der masterVerzweigung vorgenommen wurden, zusammenzuführen. Im Falle eines Zusammenführungskonflikts können Sie mit der Pull-App die nächste Vorgehensweise während der Pull-Anforderung auswählen.

Sie können über grundlegende und erweiterte Konfigurationen lesen und verschiedene mergemethods hier .

Ich verwende diese Konfiguration derzeit in meinem gegabelten Repo hier , um sicherzustellen, dass eine hier angeforderte Verbesserung auf dem neuesten Stand bleibt.

Saurabh P Bhandari
quelle
1

Es gibt zwei wichtige Dinge, um ein gegabeltes Repository immer für immer zu aktualisieren.

1. Erstellen Sie die Zweige vom Gabelmaster und nehmen Sie dort Änderungen vor .

Wenn Ihre Pull-Anfrage akzeptiert wird, können Sie den Zweig sicher löschen, da Ihr beigetragener Code dann in Ihrem Master Ihres gegabelten Repositorys gespeichert wird, wenn Sie ihn mit dem Upstream aktualisieren. Auf diese Weise befindet sich Ihr Master immer in einem sauberen Zustand, um einen neuen Zweig für eine weitere Änderung zu erstellen.

2. Erstellen Sie einen geplanten Job, damit der Gabelmaster die Aktualisierung automatisch durchführt .

Dies kann mit cron erfolgen . Hier ist ein Beispielcode, wenn Sie es unter Linux tun.

$ crontab -e

Setzen Sie diesen Code auf crontab file, um den Job stündlich auszuführen.

0 * * * * sh ~/cron.sh

Erstellen Sie dann die cron.shSkriptdatei und eine Git-Interaktion mit ssh-agent und / oder erwarten Sie wie folgt

#!/bin/sh
WORKDIR=/path/to/your/dir   
REPOSITORY=<name of your repo>
MASTER="[email protected]:<username>/$REPOSITORY.git"   
[email protected]:<upstream>/<name of the repo>.git  

cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent` && expect ~/.ssh/agent && ssh-add -l
git clone $MASTER && cd $REPOSITORY && git checkout master
git remote add upstream $UPSTREAM && git fetch --prune upstream
if [ `git rev-list HEAD...upstream/master --count` -eq 0 ]
then
    echo "all the same, do nothing"
else
    echo "update exist, do rebase!"
    git reset --hard upstream/master
    git push origin master --force
fi
cd $WORKDIR && rm -rf $REPOSITORY
eval `ssh-agent -k`

Überprüfen Sie Ihr gegabeltes Repository. Von Zeit zu Zeit wird immer diese Benachrichtigung angezeigt:

Dieser Zweig ist gerade mit <upstream>: master .

Geben Sie hier die Bildbeschreibung ein

Chetabahana
quelle
0

Verwenden Sie diese Befehle (im Glück)

git remote -v
git pull
git fetch upstream
git checkout master
git merge upstream/master --no-ff
git add .
git commit -m"Sync with upstream repository."
git push -v
Mach Nhu Vy
quelle