Como atualizo um repositório bifurcado do GitHub?

3606

Recentemente, bifurquei um projeto e apliquei várias correções. Em seguida, criei uma solicitação de recebimento que foi aceita.

Alguns dias depois, outra alteração foi feita por outro colaborador. Portanto, meu garfo não contém essa alteração.

Como posso colocar essa alteração no meu garfo? Preciso excluir e recriar meu fork quando tiver mais alterações para contribuir? Ou existe um botão de atualização?

Lea Hayes
fonte
120
Isso também pode ser feito na interface do usuário do github. Eu gostaria de dar crédito [a este outro pôster] [1]. [1]: stackoverflow.com/a/21131381/728141
Mike Schroll
2
Outro bom post no blog sobre isso - Mantendo um
fork do
3
Encontrei isto no Github ajuda artigos: help.github.com/articles/syncing-a-fork
Pranav
2
Isso é uma duplicata do stackoverflow.com/questions/3903817/… ?
David Cary
Aqui está um vídeo de demonstração que faz isso usando dois github contas youtube.com/watch?v=kpE0gTX4ycE
lifebalance

Respostas:

3983

No seu clone local do seu repositório bifurcado, você pode adicionar o repositório original do GitHub como um "remoto". ("Remotes" são como apelidos para os URLs dos repositórios - originé um, por exemplo.) Em seguida, você pode buscar todas as ramificações desse repositório upstream e refazer o trabalho para continuar trabalhando na versão upstream. Em termos de comandos que podem se parecer com:

# 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

Se você não deseja reescrever o histórico de sua ramificação principal (por exemplo, porque outras pessoas podem ter clonado), substitua o último comando por git merge upstream/master. No entanto, para fazer solicitações de recebimento mais limpas possível, provavelmente é melhor refazer a recuperação.


Se você reformulou sua ramificação, upstream/masterpode ser necessário forçar o envio para enviá-lo para o seu próprio repositório bifurcado no GitHub. Você faria isso com:

git push -f origin master

Você só precisa usar -fa primeira vez depois de ter refeito.

Mark Longair
fonte
94
Como seu fork existe apenas no github, e o github não possui ferramentas para fazer mesclagens através da interface da web, a resposta certa é fazer a mesclagem upstream localmente e enviar as alterações de volta para o fork.
Tim Keating
29
Aqui é um ótimo tutorial que eu encontrei sobre o trabalho com github: gun.io/blog/how-to-github-fork-branch-and-pull-request
Tim Keating
50
Uma observação rápida de que, em vez de precisar refazer sua própria ramificação principal para garantir que você esteja começando com um estado limpo, provavelmente você deve trabalhar em uma ramificação separada e fazer uma solicitação de pull a partir disso. Isso mantém seu mestre limpo para futuras fusões e impede que você tenha que reescrever o histórico com o -fque atrapalha todo mundo que poderia ter clonado sua versão.
Mateusz Kowalczyk
11
Em vez do comando rebase, usei o seguinte: git merge --no-ff upstream/masterDessa forma, seus commits não estão mais no topo.
Steckdoserich 17/10/16
52
Outra falha do Git. Se essas ferramentas devem oferecer suporte à colaboração distribuída, por que é tão difícil executar um fluxo de trabalho básico? 4 milhões de pessoas e 2200 upvotes significam que a ferramenta falhou. "você pode adicionar o repositório GitHub original como uma 'remota' -? Por que um mesmo ter que fazer isso Por que não é feito durante a bifurcação que é tão quebrado sobre esta ferramenta?
JWW
740

A partir de maio de 2014, é possível atualizar um fork diretamente do GitHub. Isso ainda funciona em setembro de 2017, mas levará a um histórico de confirmação sujo.

  1. Abra seu garfo no GitHub.
  2. Clique em Pull Requests.
  3. Clique em New Pull Request. Por padrão, o GitHub irá comparar o original com o seu fork, e não deve haver nada para comparar se você não tiver feito alterações.
  4. Clique switching the basese você vir esse link. Caso contrário, defina manualmente a caixa base forksuspensa para o garfo e head forkpara a montante. Agora o GitHub irá comparar seu fork com o original, e você deverá ver todas as alterações mais recentes. insira a descrição da imagem aqui
  5. Create pull requeste atribua um nome previsível à sua solicitação de recebimento (por exemplo, Update from original).
  6. Role para baixo até Merge pull request, mas não clique em nada ainda.

Agora você tem três opções, mas cada uma delas levará a um histórico de confirmação menos que limpo.

  1. O padrão criará uma confirmação de mesclagem feia.
  2. Se você clicar no menu suspenso e escolher "Squash e mesclagem", todas as confirmações intermediárias serão compactadas em uma. Isso geralmente é algo que você não deseja.
  3. Se você clicar em Rebase and merge, todas as confirmações serão feitas "com" você, os PRs originais serão vinculados ao seu PR e o GitHub será exibido This branch is X commits ahead, Y commits behind <original fork>.

Portanto, sim, você pode manter seu repo atualizado com o upstream usando a interface da web do GitHub, mas isso prejudicará seu histórico de consolidação. Atenha-se à linha de comando - é fácil.

lobzik
fonte
19
Isso funcionou muito bem uma vez. Na segunda vez em que esse processo não funcionou da mesma maneira: o link "Alternando a base" não apareceu. E quando eu clico em "Clique para criar uma solicitação de recebimento", ele cria um PR no repositório SOURCE. Não o que eu queria ..
javadba
29
Ainda funciona (março de 2015), apesar de o link "Alternar a base" não estar mais lá. Você precisa alterar o menu suspenso "Base" para que ambos aponte para o seu garfo e, em seguida, você receberá uma solicitação para "Comparar entre repos", que o levará aonde você deseja.
mluisbrown
8
Abril de 2015. Trabalhos. Obrigado. Eu recebi "Mudando para a base". No entanto, a etapa 6 foi "Criar solicitação de recebimento" -> insira comentário -> "Criar solicitação de recebimento". Termine com 1 confirmação antes do original.
cartland
5
@artland (ou outros) - sim, diz "Este ramo está 1 comprometido antes de ..." Isso é algo para se preocupar? É possível se livrar dessa mensagem?
RenniePet
11
não seria melhor, com um simples botão de atualização ou sincronização!
Transformador
457

Aqui está o documento oficial do GitHub sobre Sincronizando um fork :

Sincronizando um garfo

A configuração

Antes de sincronizar, você precisa adicionar um controle remoto que aponte para o repositório upstream. Você pode ter feito isso quando originalmente bifurcou.

Dica: Sincronizar seu fork apenas atualiza sua cópia local do repositório; ele não atualiza seu repositório no 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)

A sincronizar

Há duas etapas necessárias para sincronizar seu repositório com o upstream: primeiro você deve buscar no controle remoto e depois mesclar o ramo desejado no ramo local.

Buscando

A busca no repositório remoto trará suas ramificações e seus respectivos commits. Eles são armazenados no seu repositório local em ramificações especiais.

$ 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

Agora temos a ramificação principal do upstream armazenada em uma ramificação local, 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

Mesclando

Agora que buscamos o repositório upstream, queremos mesclar suas alterações em nossa filial local. Isso sincronizará esse ramo com o upstream, sem perder nossas alterações locais.

$ 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

Se sua ramificação local não tiver nenhum commit exclusivo, o git executará um "avanço rápido":

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

Dica: Se você deseja atualizar seu repositório no GitHub, siga as instruções aqui

jumpnett
fonte
1
Isso atualiza meu fork local, mas meu fork no Github.com ainda diz "43 confirmado para trás". Eu tive que usar a técnica do lobzik para criar uma solicitação de pull para mesclar as alterações principais no meu fork do Github.com.
Michael McGinnis
11
@MichaelMcGinnis Depois de mesclar localmente, você teria que enviar as alterações para o github. git push origin master
22815 jumpnett
1
Pode ser inteligente para empurrar com --follow-tags: stackoverflow.com/a/26438076/667847
Kenny
1
Eu tenho que fazê-lo para todos os ramos separadamente git merge upstream/master, então confira a desenvolver ramo e fazergit merge upstream/develop
Sobi
stackoverflow.com/a/14074925/470749 foi útil para mim, porque eu estava conseguindo Permission denied (publickey). fatal: Could not read from remote repository.ao tentar buscar na conta Github do Facebook a montante.
Ryan
98

Muitas respostas acabam movendo seu fork um commit à frente do repositório pai. Esta resposta resume as etapas encontradas aqui, que moverão seu fork para o mesmo commit que o pai .

  1. Mude o diretório para o seu repositório local.

    • Mude para o ramo principal se não estiver git checkout master
  2. Adicione o pai como um repositório remoto, git remote add upstream <repo-location>

  3. Questão git fetch upstream
  4. Questão git rebase upstream/master

    • Nesta fase, você verifica se confirma o que será mesclado digitando git status
  5. Questão git push origin master

Para mais informações sobre estes comandos, consulte o passo 3 .

Sahar Rabinoviz
fonte
13
@ MT: Onde você insere esses comandos? A essência da questão, como eu a entendo, é como ressincronizar seu fork pessoal do GitHub com o projeto principal e fazer tudo isso no GitHub . Em outras palavras, como você pode atualizar seu fork remoto sem um repositório local?
John Y
4
@JohnY O uso do GitHub sempre cria um commit extra. Você precisa fazer tudo isso em um shell em um repositório local para evitar essa confirmação extra.
Jonathan Cruz
49

Se, como eu, você nunca comprometer nada diretamente com o mestre , o que realmente deveria, pode fazer o seguinte.

No clone local do seu fork, crie seu controle remoto upstream. Você só precisa fazer isso uma vez:

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

Então, sempre que você quiser acompanhar a ramificação principal do repositório upstream, precisará:

git checkout master
git pull upstream master

Supondo que você nunca tenha cometido nada a seu respeito, você já deve ter feito isso. Agora você pode enviar seu mestre local para o seu fork remoto do GitHub de origem. Você também pode refazer sua ramificação de desenvolvimento em seu mestre local agora atualizado.

Após a configuração inicial do upstream e a verificação do master, tudo o que você precisa fazer é executar o seguinte comando para sincronizar seu master com o upstream: git pull upstream master .

Slion
fonte
48

Prefácio: sua bifurcação é a "origem" e o repositório de onde você partiu é o "upstream".

Vamos supor que você já clonou seu fork no computador com um comando como este:

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

Se isso for fornecido, você precisará continuar nesta ordem:

  1. Adicione o "upstream" ao seu repositório clonado ("origem"):

    git remote add upstream [email protected]:original_author/project_name.git
    
  2. Busque as confirmações (e ramificações) no "upstream":

    git fetch upstream
    
  3. Mude para o ramo "principal" do seu fork ("origem"):

    git checkout master
    
  4. Esconda as alterações do seu ramo "mestre":

    git stash
    
  5. Mesclar as alterações do ramo "mestre" do "upstream" no ramo "mestre" da sua "origem":

    git merge upstream/master
    
  6. Resolver conflitos de mesclagem, se houver, e confirmar sua mesclagem

    git commit -am "Merged from upstream"
    
  7. Coloque as alterações no garfo

    git push
    
  8. Volte suas alterações ocultas (se houver)

    git stash pop
    
  9. Você Terminou! Parabéns!

O GitHub também fornece instruções para este tópico: Sincronizando um fork

Benny Neugebauer
fonte
1
Ajudado em parte: é git remote add upstream [email protected]:original_author/project_name.gitapenas um apelido para git remote add upstream https://github.com/original_author/project_name.git?
Lobo
2
Lobo , acho que você já sabe disso, mas para a posteridade ... É o formato para ssh. help.github.com/articles/configuring-a-remote-for-a-fork #
Brad Ellis
2
Muito obrigado. git stashe git stash popparte muito útil
सत्यमेव जयते
Isso funcionou. Após o git merge upstream / master, a mesclagem automática falhou devido a caminhos não mesclados que eu tive que executar git add -A e git commit -m "message", e estava atualizado.
highcenbug
45

Desde novembro de 2013, foi aberto um pedido não oficial de recursos com o GitHub para solicitar que eles adicionassem um método muito simples e intuitivo para manter uma bifurcação local sincronizada com o upstream:

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

Nota: Como a solicitação de recurso não é oficial, também é recomendável entrar [email protected]em contato para adicionar seu suporte para que um recurso como esse seja implementado. A solicitação não oficial de recurso acima pode ser usada como evidência da quantidade de interesse nisso sendo implementada.

isedwards
fonte
23

Na data desta resposta, o GitHub não possui ( ou devo dizer não? ) Esse recurso na interface da web. Você pode, no entanto, pedir [email protected]para adicionar seu voto para isso.

Enquanto isso, o usuário do GitHub bardiharborow criou uma ferramenta para fazer exatamente isso: https://upriver.github.io/

A fonte está aqui: https://github.com/upriver/upriver.github.io

Lucero
fonte
2
Embora eu ache a ferramenta uma boa idéia, a realidade é que QUEBRAU. Ele carregou apenas 20 repositórios da minha conta e até o rodapé é redirecionado para um site que não existe. Se isso for corrigido, serei um grande defensor.
sorin
2
A partir de hoje, usei o upriver com êxito para sincronizar um fork com o repositório upstream, portanto está funcionando para meus propósitos e continuarei a usá-lo.
NauticalMile
1
@sorin Essa limitação de 20 repo / branch (em vez disso, são 30 agora) vem das configurações de paginação padrão do GitHub. É necessário que haja algumas adaptações no código para lidar com isso.
Andreas
19

Se você estiver usando o GitHub para Windows ou Mac, agora eles têm um recurso de um clique para atualizar os garfos:

  1. Selecione o repositório na interface do usuário.
  2. Clique no botão "Atualizar do usuário / filial" na parte superior.
Shital Shah
fonte
11

Na verdade, é possível criar uma ramificação no seu fork a partir de qualquer confirmação do upstream no navegador:

  • Abra https://github.com/<repo>/commits/<hash>, em que o repositório é sua bifurcação e o hash é um hash de confirmação completo, que você pode encontrar na interface da Web upstream. Por exemplo, eu posso abrir https://github.com/max630/linux/commits/0aa0313f9d576affd7747cc3f179feb097d28990 , que aponta linux mastercomo hora da escrita.
  • Clique no botão "Árvore: ....".
  • Digite o nome da nova ramificação e pressione Enter

Digite a descrição da imagem aqui

Você pode buscar esse ramo no seu clone local e não precisará enviar todos esses dados de volta ao GitHub quando enviar edições por cima desse commit. Ou use a interface da web para alterar algo nesse ramo.

Como funciona (é um palpite, não sei exatamente como o GitHub faz isso): os garfos compartilham o armazenamento de objetos e usam espaços de nome para separar as referências dos usuários. Assim, você pode acessar todos os commits através do seu fork, mesmo que eles não existissem no momento da bifurcação.

max630
fonte
2
Isso é ótimo! Isso evita o upload totalmente inútil desses commit no github.
Rotsor 13/03/19
9

Siga os passos abaixo. Eu tentei e isso me ajudou.

Finalizar compra na sua filial

Sintaxe: git branch yourDevelopmentBranch
Exemplo: git checkout master

Puxe a ramificação do repositório de origem para obter o código mais recente

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

Venkat.R
fonte
1
Se você estiver usando o GitHub, também poderá enviar as alterações para sua ramificação do GitHub. git push HttpsForYourForkOfTheRepo BRANCH_NAME
user3731622
9

Eu atualizo meus repositórios bifurcados com esta linha:

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

Use isso se não desejar adicionar outro ponto de extremidade remoto ao seu projeto, como outras soluções postadas aqui.

R.Bravo
fonte
2
Existem limitações nisso? isto é, aplica-se apenas aos casos em que você não adicionou confirmações, mesclagens, solicitações pull ou teve solicitações pull mescladas no upstream desde a última atualização?
LightCC
1
funciona como um puxão normal de um ramo remoto. Se você fez X confirma em seu repo local e agora você é Y confirma por trás do repo original, ele trará os Y confirma para sua filial local e, provavelmente, causará alguns conflitos a serem resolvidos.
R.Bravo
1
@LightCC Isso não é diferente de extrair de um controle remoto adicionado anteriormente, exceto pelo fato de você não ter adicionado um controle remoto . Portanto, a desvantagem é que você precisará inserir a URL do repositório completo toda vez que desejar pull.
Marc.2377
1
Essa é uma solução perfeita se você não precisar retirar várias vezes do repositório original ou se o projeto forjado for relativamente simples.
AxeEffect 28/04
7

Como complemento para esta resposta, eu estava procurando uma maneira de atualizar todos os ramos remotos do meu repositório clonado ( origem ) a partir dos ramos upstream de uma só vez. Foi assim que eu fiz.

Isso pressupõe que você já configurou um apontador remoto upstream no repositório de origem (de onde a origem foi bifurcada) e o sincronizou git fetch upstream.

Então corra:

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

A primeira parte deste comando lista todas as cabeças no repositório remoto upstream e remove o SHA-1 seguido pelo refs/heads/prefixo do nome da ramificação.

Em seguida, para cada uma dessas ramificações, ele envia a cópia local da ramificação de rastreamento remoto upstream ( refs/remotes/upstream/<branch>no lado local) diretamente para a ramificação remota na origem ( refs/heads/<branch>no lado remoto).

Qualquer um desses comandos de sincronização de ramificação pode falhar por um de dois motivos: a ramificação upstream foi reescrita ou você enviou as confirmações nessa ramificação para o seu fork. No primeiro caso em que você não comprometeu nada com o ramo no garfo, é seguro pressionar com força (adicione a opção -f ; ou seja, git push -fno comando acima). No outro caso, isso é normal, pois sua ramificação de bifurcação divergiu e você não pode esperar que o comando sync funcione até que suas confirmações tenham sido mescladas novamente no upstream .

Thomas Guyot-Sionnest
fonte
6

O aplicativo "Pull" é uma solução de configuração e esquecimento automática. Ele sincronizará a ramificação padrão do seu fork com o repositório upstream.

Visite o URL, clique no botão verde "Instalar" e selecione os repositórios em que deseja ativar a sincronização automática.

A ramificação é atualizada uma vez por hora diretamente no GitHub, na sua máquina local, você precisa puxar a ramificação principal para garantir que sua cópia local esteja sincronizada.

krlmlr
fonte
2
Observe que, com a configuração básica, você pode perder as alterações feitas no seu repositório bifurcado. Para manter as alterações, configure um arquivo de configuração e especifique a mergemethod. Mais sobre isso aqui
Saurabh P Bhandari
1
Observei que a configuração básica envia solicitações pull e as mescla (ao contrário do que está indicado na documentação). Isso é um pouco chato, mas resolve o problema de perda de dados?
precisa saber é o seguinte
4

O Android Studio agora aprendeu a trabalhar com os repositórios de bifurcações do GitHub (você nem precisa adicionar repositório remoto "upstream" pelo comando do console).

Abrir menu VCSGit

E preste atenção nos dois últimos itens do menu pop-up:

  • Rebase my fork GitHub

  • Criar solicitação de recebimento

Tente eles. Eu uso o primeiro para sincronizar meu repositório local. De qualquer forma, as ramificações do repositório remoto pai ("upstream") ficarão acessíveis no Android Studio depois que você clicar em "Rebase my fork do GitHub" e poderá operar com elas facilmente.

(Eu uso o Android Studio 3.0 com os plugins "integração Git" e "GitHub".)

Digite a descrição da imagem aqui

alexshr
fonte
4

Quando você clonou seu repositório bifurcado, vá para o caminho do diretório em que seu clone reside e as poucas linhas no seu 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

E aí você está pronto para ir. Todas as alterações atualizadas no repositório principal serão enviadas para o repositório do fork.

O comando "buscar" é indispensável para manter-se atualizado em um projeto: somente ao executar uma "busca por git" você será informado sobre as alterações que seus colegas fizeram no servidor remoto.

Você ainda pode visitar aqui para mais consultas

Prateek Chanda
fonte
4

Se você configurar seu upstream. Verifique com git remote -v, então isso será suficiente.

git fetch upstream
git checkout master
git merge --no-edit upstream/master
git push
prosti
fonte
2

Isso depende do tamanho do seu repositório e de como você o bifurcou.

Se é um repositório bastante grande, você pode querer gerenciá-lo de uma maneira especial (por exemplo, histórico de descargas). Basicamente, você pode obter diferenças entre as versões atual e upstream, enviá-las e depois voltar ao master.

Tente ler este . Ele descreve como lidar com grandes repositórios Git e como atualizá-los com as alterações mais recentes.

s0nicYouth
fonte
2

Gostaria de adicionar uma resposta à @ krlmlr .

Inicialmente, o repositório bifurcada tem uma filial chamada: master. Se você estiver trabalhando em um novo recurso ou correção, geralmente criará uma nova ramificação featuree fará as alterações.

Se você deseja que o repositório bifurcado esteja sincronizado com o repositório pai, você pode configurar um arquivo de configuração ( pull.yml) para o aplicativo Pull ( na ramificação do recurso ), assim:

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

Isso mantém a masterramificação do repositório bifurcado atualizada com o repositório pai. Ele mantém a featureramificação do repositório bifurcado atualizada por meio da masterramificação do repositório bifurcado, mesclando o mesmo. Isso pressupõe que a featureramificação é a ramificação padrão que contém o arquivo de configuração.

Aqui mergemethodsestão dois em jogo, um é o hardresetque ajuda a forçar alterações de sincronização na masterramificação do repositório bifurcado com o repositório pai e o outro método merge. Este método é usado para mesclar as alterações feitas por você na featureramificação e as alterações causadas pela força da sincronização na masterramificação. Em caso de conflito de mesclagem, o aplicativo pull permitirá que você escolha o próximo curso de ação durante a solicitação de pull.

Você pode ler sobre configurações básicas e avançadas e várias mergemethods aqui .

Atualmente, estou usando essa configuração no meu repositório bifurcado aqui para garantir que um aprimoramento solicitado aqui permaneça atualizado.

Saurabh P Bhandari
fonte
1

Há duas coisas principais em manter um repositório bifurcado sempre atualizado para sempre.

1. Crie as ramificações a partir do mestre da forquilha e faça as alterações lá .

Portanto, quando sua solicitação de recebimento for aceita, você poderá excluir com segurança a ramificação, pois seu código contribuído ficará no mestre de seu repositório bifurcado quando você a atualizar com o upstream. Por isso, seu mestre estará sempre em boas condições para criar uma nova ramificação para fazer outra alteração.

2. Crie um trabalho agendado para o mestre da bifurcação atualizar automaticamente .

Isso pode ser feito com o cron . Aqui está um exemplo de código, se você o faz no linux.

$ crontab -e

coloque esse código em crontab filepara executar o trabalho a cada hora.

0 * * * * sh ~/cron.sh

crie o cron.sharquivo de script e uma interação git com o ssh-agent e / ou espere como abaixo

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

Verifique seu repositório bifurcado. Periodicamente, sempre mostrará esta notificação:

Este ramo é igual a <upstream>: master .

insira a descrição da imagem aqui

Chetabahana
fonte
0

Use estes comandos (no caso de sorte)

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
Do Nhu Vy
fonte