В вашем локальном клоне вашего разветвленного репозитория вы можете добавить исходный репозиторий GitHub в качестве удаленного. (Пульты похожи на псевдонимы для URL-адресов репозиториев - например, origin.) Затем вы можете получить все ветки из этого вышестоящего репозитория и перенастроить свою работу, чтобы продолжить работу над исходной версией. Что касается команд, которые могут выглядеть так:

# 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

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

Если вы не хотите переписывать историю своей основной ветки (например, потому что ее могли клонировать другие люди), вам следует заменить последнюю команду на git merge upstream/master. Однако, чтобы сделать дальнейшие запросы на вытягивание как можно более чистыми, вероятно, лучше выполнить перебазирование.

Если вы переустановили свою ветку на upstream/master, вам может потребоваться принудительное нажатие, чтобы отправить ее в свой собственный разветвленный репозиторий на GitHub. Вы бы сделали это с помощью:

git push -f origin master

Вам нужно использовать -f только в первый раз после того, как вы переустановили.

С мая 2014 года появилась возможность обновлять форк прямо с GitHub. Это все еще работает по состоянию на сентябрь 2017 года, НО это приведет к грязной истории коммитов.

1. Откройте свою вилку на GitHub.
2. Щелкните Pull Requests.
3. Щелкните New Pull Request. По умолчанию GitHub сравнивает оригинал с вашей вилкой, и сравнивать нечего, если вы не вносили никаких изменений.
4. Если вы видите эту ссылку, нажмите переключение базы. В противном случае вручную установите раскрывающийся список base fork на свой форк, а head fork на восходящий поток. Теперь GitHub сравнит ваш форк с оригиналом, и вы должны увидеть все последние изменения.
5. Создайте пул-реквест и присвойте предсказуемое имя вашему пул-реквесту (например, Update from original).
6. Прокрутите вниз до Merge pull request, но пока ничего не нажимайте.

Теперь у вас есть три варианта, но каждый из них приведет к не совсем чистой истории коммитов.

1. По умолчанию создается уродливая фиксация слияния.
2. Если вы щелкните раскрывающийся список и выберите «Сжать и объединить», все промежуточные коммиты будут объединены в один. Чаще всего это то, чего вы не хотите.
3. Если вы нажмете Rebase and merge, все коммиты будут сделаны «с вами», исходные PR будут ссылаться на ваш PR, и GitHub отобразит This branch is X commits ahead, Y commits behind <original fork>.

Так что да, вы можете обновлять свое репо вместе с восходящим потоком, используя веб-интерфейс GitHub, но это испортит вашу историю коммитов. Вместо этого придерживайтесь командной строки - это легкий.

Вот официальный документ GitHub о синхронизации вилки:

Синхронизация вилки

Установка

Прежде чем вы сможете синхронизировать, вам нужно добавить пульт, который указывает на вышестоящий репозиторий. Возможно, вы сделали это, когда изначально разветвлялись.

Совет: при синхронизации вилки обновляется только локальная копия репозитория; он не обновляет ваш репозиторий на GitHub.

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

Синхронизации

Чтобы синхронизировать ваш репозиторий с восходящим потоком, необходимо выполнить два шага: сначала вы должны выполнить выборку с удаленного компьютера, затем вы должны объединить нужную ветку с вашей локальной веткой.

Получение

При извлечении из удаленного репозитория будут добавлены его ветки и их соответствующие коммиты. Они хранятся в вашем локальном репозитории в специальных ветках.

$ 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

Теперь у нас есть главная ветвь восходящего потока, хранящаяся в локальной ветке, восходящий / главный

$ 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

Слияние

Теперь, когда мы получили исходный репозиторий, мы хотим объединить его изменения в нашу локальную ветку. Это синхронизирует эту ветвь с восходящим потоком без потери наших локальных изменений.

$ 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

Если в вашей локальной ветке не было уникальных коммитов, git вместо этого выполнит «перемотку вперед»:

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

Совет: если вы хотите обновить свой репозиторий на GitHub, следуйте инструкциям здесь

Многие ответы приводят к тому, что вилка перемещается на одну фиксацию вперед по сравнению с родительским репозиторием. В этом ответе резюмируются шаги, найденные здесь, которые будут переместите вилку в тот же коммит, что и родительский.

1. Перейдите в каталог в свой локальный репозиторий.

   • Switch to master branch if you are not git checkout master

2. Добавить родительский объект в качестве удаленного репозитория, git remote add upstream <repo-location>

3. Проблема git fetch upstream

4. Проблема git rebase upstream/master

   • At this stage you check that commits what will be merged by typing git status

5. Проблема git push origin master

Для получения дополнительной информации об этих командах см. шаг 3 .

Если, как и я, вы никогда ничего не передаете непосредственно мастеру, что действительно должно быть, вы можете сделать следующее.

Из локального клона вашей вилки создайте свой вышестоящий пульт. Вам нужно сделать это только один раз:

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

Затем всякий раз, когда вы хотите догнать главную ветку вышестоящего репозитория, вам необходимо:

git checkout master
git pull upstream master

Предполагая, что вы никогда ничего не совершали на мастере, вы должны уже сделать это. Теперь вы можете отправить своего локального мастера на исходную удаленную вилку GitHub. Вы также можете переустановить свою ветку разработки на свой теперь обновленный локальный мастер.

После первоначальной настройки восходящего потока и проверки главного сервера все, что вам нужно сделать, это выполнить следующую команду, чтобы синхронизировать ваш главный сервер с восходящим потоком: git pull upstream master.

Предисловие: ваш форк является «источником», а репозиторий, из которого вы разветвлялись, - «восходящим потоком».

Предположим, вы уже клонировали вилку на свой компьютер с помощью такой команды:

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

Если это указано, вам нужно продолжить в следующем порядке:

1. Добавьте «апстрим» в свой клонированный репозиторий («origin»):

   git remote add upstream [email protected]:original_author/project_name.git
   

2. Получите коммиты (и ветки) из "восходящего потока":

   git fetch upstream
   

3. Переключитесь на "master" ветку вашей вилки ("origin"):

   git checkout master
   

4. Сохраните изменения в вашей "основной" ветке:

   git stash
   

5. Слейте изменения из «master» ветки «upstream» в «master» ветку вашего «origin»:

   git merge upstream/master
   

6. Разрешить конфликты слияния, если они есть, и зафиксировать слияние

   git commit -am "Merged from upstream"
   

7. Вставьте изменения в свою вилку

   git push
   

8. Верните свои спрятанные изменения (если есть)

   git stash pop
   

9. Готово! Поздравляю!

GitHub также предоставляет инструкции по этой теме: Синхронизация вилки

С ноября 2013 года в GitHub был открыт неофициальный запрос функции, в котором предлагалось добавить очень простой и интуитивно понятный метод для синхронизации локальной вилки с восходящим потоком:

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

Примечание. Поскольку запрос функции является неофициальным, также рекомендуется связаться с [email protected], чтобы добавить вашу поддержку для реализации такой функции. Вышеупомянутый неофициальный запрос функции может быть использован как доказательство заинтересованности в этой реализации.

На дату этого ответа у GitHub нет (или я должен сказать больше?) эта функция в веб-интерфейсе. Однако вы можете попросить [email protected] проголосовать за это.

Тем временем пользователь GitHub bardiharborow создал инструмент для этого: https://upriver.github.io/

Источник находится здесь: https://github.com/upriver/upriver.github.io

Если вы используете GitHub для Windows или Mac, то теперь у них есть возможность обновлять вилки одним щелчком мыши:

1. Выберите репозиторий в пользовательском интерфейсе.
2. Нажмите кнопку «Обновить от пользователя / ветви» вверху.

Есть способ сделать это из веб-приложения GitHub.

Давайте рассмотрим следующий пример.

Для начала откройте репо, которое вы хотите обновить.

Видно предупреждение

Эта ветка на 157 коммитов стоит за GoogleCloudPlatform: master.

Справа есть две кнопки Pull request и Compare. Нажмите Compare.

Так как сравнивать наверное не с чем, нажмите switching the base

Появится список всех изменений, и можно будет создать запрос на перенос, нажав кнопку Create pull request.

Дайте ему название, скажем, Обновить репо

И создайте запрос на перенос.

После создания запроса прокрутите вниз и нажмите Merge pull request.

Подтвердите слияние и все!

Фактически, можно создать ветку в своей вилке из любого коммита апстрима в браузере:

• Откройте https://github.com/<repo>/commits/<hash>, где репо - ваша вилка, а hash - полный хэш фиксации, который вы можете найти в веб-интерфейсе апстрима. Например, я могу открыть https://github.com/max630/linux/commits77bc03139d289d09d09d05d07d7d07d07d07d8d5 a>, что указывает на linux master как на время написания.
• Щелкните по кнопке «Дерево: ....».
• Введите имя новой ветки и нажмите Enter

Затем вы можете загрузить эту ветку в свой локальный клон, и вам не придется отправлять все эти данные обратно в GitHub, когда вы отправляете изменения поверх этой фиксации. Или используйте веб-интерфейс, чтобы что-то изменить в этой ветке.

Как это работает (это предположение, я не знаю, как именно это делает GitHub): вилки разделяют хранилище объектов и используют пространства имен для разделения пользовательских ссылок. Таким образом, вы можете получить доступ ко всем коммитам через ваш форк, даже если они не существовали на момент форкования.

Я обновляю свои разветвленные репозитории одной строкой:

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

Используйте это, если вы не хотите добавлять в свой проект еще одну удаленную конечную точку, как другие решения, размещенные здесь.

Следуйте приведенным ниже инструкциям. Я попробовал их, и это мне помогло.

Касса в вашем отделении

Синтаксис: git branch yourDevelopmentBranch
Пример: git checkout master

Получите ветку исходного репозитория, чтобы получить последний код

Синтаксис: git pull https://github.com/tastejs/awesome-app-ideas master
Пример: git pull https://github.com/ORIGINAL_OWNER/ORIGINAL_REPO.git BRANCH_NAME

В дополнение к этому ответу я искал способ обновить все удаленные ветки моего клонированного репо (origin) из ветвей восходящего потока за один раз. Вот как я это сделал.

Предполагается, что вы уже настроили восходящий удаленный доступ к исходному репозиторию (откуда был разветвлен origin) и синхронизировали его с git fetch upstream.

Затем запустите:

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

Первая часть этой команды перечисляет все заголовки в удаленном репо восходящего потока и удаляет SHA-1, за которым следует префикс имени ветки refs/heads/.

Затем для каждой из этих ветвей он подталкивает локальную копию ветки удаленного отслеживания восходящего потока (refs/remotes/upstream/<branch> на локальной стороне) непосредственно в удаленную ветвь в origin (refs/heads/<branch> на удаленной стороне ).

Любая из этих команд синхронизации веток может завершиться ошибкой по одной из двух причин: либо ветвь восходящего потока была переписана, либо вы отправили коммиты этой ветки в свою вилку. В первом случае, когда вы ничего не передали в ветку вилки, можно безопасно нажать принудительно (добавьте переключатель -f, т.е. git push -f в приведенную выше команду). В другом случае это нормально, поскольку ваша ветвь fork разошлась, и вы не можете ожидать, что команда sync будет работать, пока ваши коммиты не будут объединены обратно в upstream.

Приложение "Pull" - это автоматическое решение, которое можно настроить и забыть. Он синхронизирует ветвь по умолчанию вашей вилки с вышестоящим репозиторием.

Посетите URL-адрес, нажмите зеленую кнопку «Установить» и выберите репозитории, в которых вы хотите включить автоматическую синхронизацию.

Ветка обновляется один раз в час непосредственно на GitHub, на вашем локальном компьютере вам нужно вытащить основную ветку, чтобы гарантировать синхронизацию вашей локальной копии.

GitHub теперь представил функцию для синхронизации вилки одним нажатием кнопки.

Перейдите к своей вилке, нажмите Fetch upstream, а затем нажмите Fetch and merge, чтобы напрямую синхронизировать вилку с родительским репозиторием.

Вы также можете нажать кнопку Compare, чтобы сравнить изменения перед объединением.

Ссылка: твит на GitHub

Если вы настроите свой upstream. Проконсультируйтесь с git remote -v, тогда этого будет достаточно.

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push

Когда вы клонировали свой разветвленный репозиторий, перейдите по пути к каталогу, в котором находится ваш клон, и к нескольким строкам в вашем терминале Git Bash.

$ 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

И вот вам хорошо идти. Все обновленные изменения в основном репозитории будут помещены в репозиторий вашей вилки.

Команда «fetch» ​​незаменима для поддержания актуальности проекта: только при выполнении «git fetch» ​​вы будете проинформированы об изменениях, которые ваши коллеги отправили на удаленный сервер.

Вы по-прежнему можете посетить здесь для получения дополнительных запросов.

Android Studio теперь научилась работать с репозиториями вилок GitHub (вам даже не нужно добавлять удаленный репозиторий «вверх по течению» с помощью консольной команды).

Откройте меню VCS → Git

И обратите внимание на два последних пункта всплывающего меню:

• Перебазируйте вилку GitHub

• Создать запрос на включение

Попробуйте их. Я использую первый для синхронизации моего локального репозитория. В любом случае ветки из родительского удаленного репозитория («апстрим») будут доступны в Android Studio после того, как вы нажмете «Rebase my GitHub fork», и вы сможете легко с ними работать.

(Я использую Android Studio 3.0 с плагинами «Git integration» и «GitHub».)

Это зависит от размера вашего репозитория и от того, как вы его разветвляли.

Если это довольно большой репозиторий, возможно, вы захотели управлять им особым образом (например, историей сброса). По сути, вы можете получить различия между текущей и исходной версиями, зафиксировать их, а затем вернуть вишню в мастер.

Попробуйте прочитать этот. В нем описывается, как работать с большими репозиториями Git и как размещать их с последними изменениями.

Я хотел бы добавить к @ krlmlr ответ.

Изначально у разветвленного репозитория есть одна ветка с именем: master. Если вы работаете над новой функцией или исправлением, вы обычно создаете новую ветку feature и вносите изменения.

Если вы хотите, чтобы разветвленный репозиторий синхронизировался с родительским репозиторием, вы можете настроить файл конфигурации (pull.yml) для Вытяните приложение (в ветке функций), например:

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

Это позволяет поддерживать ветвь master разветвленного репо в актуальном состоянии с родительским репо. Он обновляет ветвь feature разветвленного репо через ветвь master разветвленного репо путем их слияния. Это предполагает, что ветвь feature является ветвью по умолчанию, которая содержит файл конфигурации.

Здесь задействованы два mergemethods, один - hardreset, который помогает принудительно синхронизировать изменения в master ветви разветвленного репо с родительским репо, а другой метод - merge. Этот метод используется для объединения изменений, сделанных вами в ветке feature, и изменений, сделанных из-за принудительной синхронизации в ветке master. В случае конфликта слияния приложение для извлечения позволит вам выбрать следующий курс действий во время запроса на извлечение.

Вы можете прочитать об основных и расширенных конфигурациях и различных mergemethods здесь.

В настоящее время я использую эту конфигурацию в своем разветвленном репозитории здесь, чтобы убедиться, что запрашиваются улучшения здесь остается обновленным.

Предполагая, что ваша вилка https://github.com/me/foobar, а исходный репозиторий - https://github.com/someone/foobar

1. Посетите https://github.com/me/foobar/compare/master...someone:master

2. Если вы видите зеленый текст Able to merge, нажмите Создать запрос на перенос.

3. На следующей странице прокрутите страницу вниз и нажмите Запрос на включение слияния и Подтвердить слияние.

Есть две основные вещи, чтобы постоянно обновлять разветвленный репозиторий.

1. Создайте ветви из мастера вилки и внесите в них изменения.

Поэтому, когда ваш запрос на вытягивание принят, вы можете безопасно удалить ветку, поскольку ваш добавленный код будет жить в вашем главном хранилище вашего разветвленного репозитория, когда вы обновите его с помощью восходящего потока. Благодаря этому ваш мастер всегда будет в чистом состоянии, чтобы создать новую ветку для внесения еще одного изменения.

2. Создайте запланированное задание для мастера вилки, чтобы выполнять обновление автоматически.

Это можно сделать с помощью cron. Вот пример кода, если вы делаете это в Linux.

$ crontab -e

поместите этот код в crontab file для ежечасного выполнения задания.

0 * * * * sh ~/cron.sh

затем создайте файл сценария cron.sh и взаимодействие с git с помощью ssh-agent и / или ожидайте, как показано ниже

#!/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`

Проверьте свой разветвленный репозиторий. Время от времени он всегда будет показывать это уведомление:

Эта ветка есть даже с <upstream>: master.

Используйте эти команды (в удачном случае)

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

rm -rf oldrepository
git clone ...

Могут быть более тонкие варианты, но это единственный способ убедиться, что мой локальный репозиторий совпадает с исходным.

Попробуйте это, нажмите Fetch upstream, чтобы синхронизировать ваше разветвленное репо с восходящим мастером.

Если вы используете GitHub Desktop, вы можете легко сделать это всего за 6 шагов (на самом деле всего 5).

Как только вы откроете Github Desktop и выберете свой репозиторий,

1. Перейти на вкладку История
2. Щелкните по строке поиска. Он покажет вам все доступные ветки (включая восходящие ветки из родительского репозитория).
3. Выберите соответствующую восходящую ветвь (это будет восходящая / основная ветвь для синхронизации главной ветки)
4. (НЕОБЯЗАТЕЛЬНО) Он покажет вам все коммиты в восходящей ветке. Вы можете щелкнуть любую фиксацию, чтобы увидеть изменения.
5. Щелкните Объединить в master / branch-name в зависимости от вашей активной ветви.
6. Подождите, пока GitHub Desktop сотворит чудеса.

В качестве примера ознакомьтесь с приведенным ниже GIF-файлом:

Удалите удаленного разработчика со страницы github

затем примените эти команды:

1) git branch -D dev
2) git fetch upstream
3) git checkout master
4) git fetch upstream && git fetch upstream --prune && git rebase upstream/master && git push -f origin master
5) git checkout -b dev
6) git push origin dev
7) git fetch upstream && git fetch upstream --prune && git rebase upstream/dev && 8) git push -f origin dev

Если вы хотите, чтобы ваши форки GitHub были в актуальном состоянии с соответствующими восходящими потоками, также существует эта пробная программа специально для GitHub: https://probot.github.io/apps/pull/, который выполняет свою работу. Вам нужно будет разрешить установку в своей учетной записи, и это будет поддерживать ваши вилки в актуальном состоянии.

Как обновить разветвленное репо на локальном компьютере?

Сначала проверьте свой пульт / мастер

git remote -v

У вас должен быть origin и upstream. Например:

origin  https://github.com/your___name/kredis.git (fetch)
origin  https://github.com/your___name/kredis.git (push)
upstream    https://github.com/rails/kredis.git (fetch)
upstream    https://github.com/rails/kredis.git (push)

После этого перейдите на главную:

git checkout main

и слить из апстрима в основной:

git merge upstream/main