Ich habe kürzlich ein Projekt gegabelt und mehrere Korrekturen vorgenommen. Ich habe dann eine Pull-Anfrage erstellt, die dann angenommen 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 diese Änderung in meine Gabel bekommen? Muss ich meinen Zweig löschen und neu erstellen, wenn ich weitere Änderungen vornehmen möchte? Oder gibt es einen Update-Button?
In Ihrem lokalen Klon Ihres Forked-Repository können Sie das ursprüngliche GitHub-Repository als "Remote" hinzufügen. ("Remotes" sind wie Spitznamen für die URLs von Repositorys - Origin
ist zum Beispiel einer.) Dann können Sie alle Zweige aus diesem Upstream-Repository abrufen und Ihre Arbeit neu strukturieren, um mit der Upstream-Version fortzufahren. 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 Master-Zweigs nicht neu schreiben möchten (z. B. weil andere ihn geklont haben könnten), sollten Sie den letzten Befehl durch git merge upstream/master
ersetzen. Um jedoch weitere Pull-Anforderungen zu erstellen, die so sauber wie möglich sind, ist es wahrscheinlich besser, einen Rebase durchzuführen.
Wenn Sie Ihren Zweig auf upstream/master
umbasiert haben, müssen Sie möglicherweise den Push erzwingen, um ihn in Ihr eigenes Forked-Repository auf GitHub zu verschieben. Das würdest du machen mit:
git Push -f Origin master
Sie müssen den -f
nur beim ersten Mal nach dem Neustart verwenden.
Ab Mai 2014 ist es möglich, einen Fork direkt von GitHub aus zu aktualisieren. Dies funktioniert noch ab September 2017, , ABER es wird zu einem Dirty Commit-Verlauf führen.
Update from original
).Jetzt haben Sie drei Möglichkeiten, aber jede führt zu einem nicht sauberen Festschreibungsverlauf.
This branch is X commits ahead, Y commits behind <original fork>
anzeigen.Also ja, Sie können Ihr Repo über die GitHub-Web-Benutzeroberfläche mit dem Upstream auf dem neuesten Stand halten, aber dadurch wird Ihr Commit-Verlauf beeinträchtigt. Halten Sie sich an die Befehlszeile stattdessen - es ist einfach.
Hier ist GitHubs offizielles Dokument zum Thema Synchronisieren einer Gabel :
Gabel synchronisieren
Die Einrichtung
Bevor Sie synchronisieren können, müssen Sie eine Fernbedienung hinzufügen, die auf das Upstream-Repository verweist. Sie haben dies möglicherweise getan, als Sie ursprünglich gegabelt haben.
Tipp: Durch das Synchronisieren Ihres Fork 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)
Synchronisierung
Es sind zwei Schritte erforderlich, um Ihr Repository mit dem Upstream zu synchronisieren: Zuerst müssen Sie von der Remote-Site abrufen und dann den gewünschten Zweig in Ihrem lokalen Zweig zusammenführen.
Holen
Beim Abrufen aus dem Remote-Repository werden die zugehörigen 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 die Hauptniederlassung des Upstreams in einer lokalen Niederlassung, 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
Viele Antworten führen dazu, dass Sie Ihren Fork um einen Commit vor dem übergeordneten Repository verschieben. Diese Antwort fasst die gefundenen Schritte zusammen hier , mit denen Sie Ihren Fork auf das gleiche Commit wie den übergeordneten verschieben.
Wechseln Sie in Ihr lokales Repository.
git checkout master
sind.Fügen Sie das übergeordnete Repository als Remote-Repository hinzu, git remote add upstream <repo-location>
.
git fetch upstream
Ausgabe git rebase upstream/master
git status
eingeben.Ausgabe git Push Origin master
Weitere Informationen zu diesen Befehlen finden Sie unter Schritt .
Seit November 2013 ist eine inoffizielle Feature-Anfrage bei GitHub eingegangen, 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, sollten Sie sich auch an [email protected]
wenden, um Ihre Unterstützung für die Implementierung einer solchen Funktion hinzuzufügen. Die obige inoffizielle Merkmalsanfrage könnte als Beweis für das Ausmaß des Interesses an der Implementierung verwendet werden.
Vorwort: Ihre Abzweigung ist der "Ursprung" und das Repository, aus dem Sie abzweigen, ist der "Upstream".
Nehmen wir an, Sie haben bereits Ihre Gabel mit einem Befehl wie dem folgenden 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:
Fügen Sie den "Upstream" zu Ihrem geklonten Repository hinzu ("Origin"):
git remote add upstream [email protected]:original_author/project_name.git
Holen Sie sich die Commits (und Zweige) aus dem "Upstream":
git fetch upstream
Wechseln Sie zum "Master" -Zweig Ihrer Gabel ("Origin"):
git checkout master
Verstecken Sie die Änderungen Ihres "Master" -Zweigs:
git stash
Führen Sie die Änderungen aus dem "Master" -Zweig des "Upstream" in den "Master" -Zweig Ihres "Origin" ein:
git merge upstream/master
Lösen Sie Zusammenführungskonflikte, falls vorhanden, und übernehmen Sie die Zusammenführung
git commit -am "Merged from upstream"
Schieben Sie die Änderungen an Ihre Gabel
git Push
Erhalten Sie Ihre verwahrten Änderungen zurück (falls vorhanden)
git stash pop
Sie sind fertig! Herzliche Glückwünsche!
GitHub enthält auch Anweisungen zu diesem Thema: Synchronisieren einer Gabel
Wenn Sie, wie ich, niemals etwas direkt an den Meister übergeben, was Sie wirklich tun sollten, können Sie Folgendes tun.
Erstellen Sie aus dem lokalen Klon Ihrer Abzweigung Ihre Upstream-Fernbedienung. Das müssen Sie nur einmal machen:
git remote add upstream https://github.com/whoever/whatever.git
Wann immer Sie sich mit dem Upstream-Repository-Master-Zweig in Verbindung setzen möchten, müssen Sie Folgendes tun:
git checkout master
git pull upstream master
Angenommen, Sie haben noch nie etwas für den Meister getan, sollten Sie dies bereits tun. Jetzt können Sie Ihren lokalen Master an Ihre Origin-Remote-GitHub-Gabel senden. Sie können Ihren Entwicklungszweig auch auf Ihrem jetzt aktuellen lokalen Master aufbauen.
Nach dem anfänglichen Upstream-Setup und der Master-Prüfung müssen Sie nur noch den folgenden Befehl ausführen, um Ihren Master mit dem Upstream zu synchronisieren: git pull upstream master.
Zum Zeitpunkt der Beantwortung dieser Frage hat GitHub diese Funktion in der Weboberfläche nicht ( oder soll ich nicht länger sagen? ). Sie können jedoch [email protected]
bitten, Ihre Stimme dafür hinzuzufügen.
In der Zwischenzeit hat der GitHub-Benutzer bardiharborow ein Tool erstellt, um genau dies zu tun: https://upriver.github.io/ =
Quelle ist hier: https://github.com/upriver/upriver.github.io
Wenn Sie GitHub für Windows verwenden, haben sie jetzt eine Ein-Klick-Funktion zum Aktualisieren von Gabeln:
Tatsächlich ist es möglich, aus einem Commit des Upstreams im Browser einen Zweig in Ihrem Fork zu erstellen:
https://github.com/<repo>/commits/<hash>
, wobei repo deine Gabel ist und hash ist ein voller Hash von Commit, den Sie im Upstream-Webinterface finden. Zum Beispiel kann ich https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d2899 öffnen, was zum Zeitpunkt des Schreibens auf linux
master
verweist.Sie können diese Verzweigung dann auf Ihren lokalen Klon übertragen und müssen nicht alle Daten an GitHub zurückschreiben, wenn Sie die Änderungen zusätzlich zu diesem Commit übertragen. Oder verwenden Sie das Webinterface, um etwas in diesem Zweig zu ändern.
Wie es funktioniert (es ist eine Vermutung, ich weiß nicht, wie genau GitHub es tut): Forks teilen den Objektspeicher und verwenden Namespaces , um die Referenzen der Benutzer zu trennen. So können Sie über Ihre Gabel auf alle Commits zugreifen, auch wenn sie zum Zeitpunkt des Gabelns noch nicht vorhanden waren.
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
Quell-Repository-Zweig ziehen, um den neuesten Code zu erhalten
Syntax: git pull https://github.com/tastejs/awesome-app-ideas master
Beispiel: Git Pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME
Als Ergänzung zu dieser Antwort suchte ich nach einer Möglichkeit, alle entfernten Zweige meines geklonten Repos ( Origin ) von Upstream zu aktualisieren. ) Äste auf einmal. So habe ich es gemacht.
Dies setzt voraus, dass Sie bereits einen Upstream Remote-Verweis auf das Quell-Repository konfiguriert haben (von dem Ursprung abgeleitet wurde) und diesen 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-Repository auf und entfernt das SHA-1, gefolgt vom Zweignamen-Präfix refs/heads/
.
Dann wird für jeden dieser Zweige die lokale Kopie des Upstream- Remote-Tracking-Zweigs (refs/remotes/upstream/<branch>
auf lokaler Seite) direkt zum Remote-Zweig auf Ursprung (refs/heads/<branch>
auf der Remote-Seite).
Jeder dieser Verzweigungssynchronisationsbefehle kann aus einem von zwei Gründen fehlschlagen: Entweder wurde die Upstream-Verzweigung umgeschrieben, oder Sie haben Commits für diese Verzweigung an Ihren Fork gesendet. In dem ersten Fall, in dem Sie dem Zweig auf Ihrer Gabel nichts zugewiesen haben, ist es sicher, gewaltsam zu drücken (Fügen Sie den Schalter - f hinzu, d. H. git Push -f
im obigen Befehl). In dem anderen Fall ist dies normal, da Ihr Fork Branch auseinander gegangen ist und Sie nicht damit rechnen können, dass der Sync-Befehl funktioniert, bis Ihre Commits wieder mit upstream zusammengeführt wurden.
Ich aktualisiere meine gespaltenen 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.
Android Studio hat nun gelernt, mit GitHub-Fork-Repositorys zu arbeiten (Sie müssen nicht einmal "Upstream" -Remote-Repository per Konsolenbefehl hinzufügen).
Menü öffnen VCS → Git
Und achten Sie auf die beiden letzten Popup-Menüpunkte:
Meine GitHub-Gabel neu starten
Pull-Anfrage erstellen
Versuch sie. Ich verwende den ersten, um mein lokales Repository zu synchronisieren. Auf jeden Fall können Sie in Android Studio auf die Zweige aus dem übergeordneten Remote-Repository ("Upstream") zugreifen, nachdem Sie auf "Meine GitHub-Verzweigung neu starten" geklickt haben, und Sie können problemlos mit ihnen arbeiten.
(Ich benutze Android Studio 3.0 mit "Git Integration" und "GitHub" Plugins.)
Wenn Sie Ihr Forked-Repository geklont haben, wechseln Sie zum 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 schon kann es losgehen. Alle aktualisierten Änderungen im Haupt-Repository werden in Ihr Fork-Repository übertragen.
Der Befehl "fetch" ist unabdingbar, um in einem Projekt auf dem neuesten Stand zu bleiben: Nur wenn Sie einen "git fetch" ausführen, werden Sie über die Änderungen informiert, die Ihre Kollegen auf den Remote-Server übertragen haben.
Sie können immer noch hier für weitere Fragen besuchen
Das hängt von der Größe Ihres Repository 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. Ablageprotokoll). Grundsätzlich können Sie Unterschiede zwischen der aktuellen und der vorgelagerten Version feststellen, diese festschreiben und dann zum Master zurückkehren.
Versuchen Sie zu lesen dieses . Es wird beschrieben, wie Sie mit großen Git-Repositorys umgehen und diese mit den neuesten Änderungen aktualisieren.
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
Es gibt zwei wichtige Dinge, um ein Forked-Repository immer für immer auf dem neuesten Stand zu halten.
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 der von Ihnen eingegebene Code dann in Ihrem Master Ihres Forked-Repositorys gespeichert wird, wenn Sie es mit dem Upstream aktualisieren. Auf diese Weise ist 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 automatisch aktualisiert .
Dies kann mit cron erfolgen. Hier ist ein Beispielcode für Linux.
$ crontab -e
fügen Sie diesen Code in den crontab file
ein, um den Job stündlich auszuführen.
0 * * * * sh ~/cron.sh
dann erstelle das cron.sh
Skript und eine Git Interaktion mit ssh-agent = und/oder erwarten wie unten
#!/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 Forked-Repository. Von Zeit zu Zeit wird immer diese Benachrichtigung angezeigt:
Dieser Zweig ist gerade mit
<upstream>
: master .