Fazer uma ramificação Git existente rastrear uma ramificação remota?

Sei como criar uma nova ramificação que rastreia ramificações remotas, mas como faço para que uma ramificação existente rastreie uma ramificação remota?

Eu sei que posso apenas editar o .git/configarquivo, mas parece que deve haver uma maneira mais fácil.

Dada uma ramificação fooe um controle remoto upstream:

A partir do Git 1.8.0:

git branch -u upstream/foo

Ou, se a ramificação local foonão for a ramificação atual:

git branch -u upstream/foo foo

Ou, se você deseja digitar comandos mais longos, estes são equivalentes aos dois acima:

git branch --set-upstream-to=upstream/foo

git branch --set-upstream-to=upstream/foo foo

A partir do Git 1.7.0:

git branch --set-upstream foo upstream/foo

Notas:

• Todos os comandos acima farão com que a filial local foorastreie a filial fooremota upstream.
• A sintaxe antiga (1.7.x) foi preterida em favor da nova sintaxe (1.8+). A nova sintaxe pretende ser mais intuitiva e fácil de lembrar.
• A definição de uma ramificação upstream falhará quando executada em controles remotos recém-criados que ainda não foram buscados. Nesse caso, execute git fetch upstreamantecipadamente.

Veja também: Por que eu preciso fazer o `--set-upstream` o tempo todo?

Você pode fazer o seguinte (supondo que você fez check-out no master e deseja enviar para um master de filial remota):

Configure o 'remoto' se ainda não o tiver

git remote add origin ssh://...

Agora configure o mestre para saber como rastrear:

git config branch.master.remote origin
git config branch.master.merge refs/heads/master

E empurre:

git push origin master

Faço isso como um efeito colateral de pressionar com a -uopção como em

$ git push -u origin branch-name

A opção longa equivalente é --set-upstream.

O git-branchcomando também entende --set-upstream, mas seu uso pode ser confuso. A versão 1.8.0 modifica a interface.

git branch --set-upstreamestá obsoleto e pode ser removido em um futuro relativamente distante. git branch [-u|--set-upstream-to]foi introduzido com uma ordem mais séria de argumentos.

...

Era tentador dizer git branch --set-upstream origin/master, mas isso diz ao Git para organizar a ramificação local "origem / mestre" para integrar-se à ramificação com check-out atualmente, o que é altamente improvável o que o usuário quis dizer. A opção está obsoleta; use a nova opção --set-upstream-to(com um pequeno e doce -u).

Digamos que você tenha uma foofilial local e queira que ela trate a filial com o mesmo nome que a montante. Faça isso acontecer com

$ git branch foo
$ git branch --set-upstream-to=origin/foo

ou apenas

$ git branch --set-upstream-to=origin/foo foo

Você pode achar a git_remote_branchferramenta útil. Oferece comandos simples para criar, publicar, excluir, rastrear e renomear filiais remotas. Um recurso interessante é que você pode pedir a um grbcomando para explicar quais comandos git ele executaria.

grb explain create my_branch github
# git_remote_branch version 0.3.0

# List of operations to do to create a new remote branch and track it locally:
git push github master:refs/heads/my_branch
git fetch github
git branch --track my_branch github/my_branch
git checkout my_branch

Na verdade, para que a resposta aceita funcione:

git remote add upstream <remote-url>
git fetch upstream
git branch -f --track qa upstream/qa
# OR:
git branch --set-upstream qa upstream/qa

Acredito que já no Git 1.5.x você poderia fazer uma filial local $BRANCHrastrear uma filial remota origin/$BRANCH, como esta.

Dado isso $BRANCHe origin/$BRANCHexiste, e você não fez o check-out no momento $BRANCH(mude se tiver), faça:

git branch -f --track $BRANCH origin/$BRANCH

Isso recria $BRANCHcomo um ramo de rastreamento. As -fforças a criação apesar de $BRANCHjá existir. --tracké opcional se os padrões usuais estiverem em vigor (ou seja, o parâmetro git-config branch.autosetupmergeé verdadeiro).

Observe que, se origin/$BRANCHainda não existir, você poderá criá-lo colocando seu local $BRANCHno repositório remoto com:

git push origin $BRANCH

Seguido pelo comando anterior para promover a filial local em uma filial de rastreamento.

1- atualize seus meta-dados locais usando: git fetch --all

2- mostre suas filiais remotas e locais usando: git branch -a , veja a seguinte captura de tela

3- alterne para o ramo de destino que você deseja vincular ao controle remoto: usando

git checkout branchName

exemplo:

4- Conecte sua filial local a uma filial remota usando:

git branch --set-upstream-to nameOfRemoteBranch

NB: nameOfRemoteBranch : para copiar da saída da etapa 2 "git branch -r"

Exemplo de uso:

Certifique-se de executar:

git config push.default tracking

ser capaz de empurrar sem problemas

A edição .git/configé provavelmente a maneira mais fácil e rápida. É o que os comandos do Git para lidar com ramificações remotas estão fazendo, de qualquer maneira.

Se você não quiser mexer com o arquivo manualmente (e não é tão difícil de fazer), você sempre pode usá git config-lo ... mas, novamente, isso vai editar o .git/configarquivo de qualquer maneira.

É claro que existem maneiras de rastrear automaticamente uma ramificação remota ao usar git checkout(passando a --trackbandeira, por exemplo), mas esses comandos funcionam com novas ramificações, não as existentes.

Em muito curto

git branch --set-upstream yourLocalBranchName origin/develop

Isso fará com que você yourLocalBranchNamerastreie o ramo remoto chamado develop.

No 1.6.x, isso pode ser feito usando a ferramenta git_remote_branch :

grb track foo upstream

Isso fará com que o Git faça o foorastreamento upstream/foo.

Eu uso o seguinte comando (suponha que o nome da filial local seja "branch-name-local" e o nome da filial remota seja "branch-name-remote"):

$ git branch --set-upstream-to=origin/branch-name-remote branch-name-local

Se as ramificações local e remota tiverem o mesmo nome, faça o seguinte:

$ git branch --set-upstream-to=origin/branch-name branch-name

Aqui, usando githube git version 2.1.4, basta fazer:

$ git clone git@github.com:user/repo.git

E os controles remotos vêm por si só, mesmo que não estejam vinculados localmente:

$ git remote show origin

* remote origin
  Fetch URL: git@github.com:user/repo.git
  Push  URL: git@github.com:user/repo.git
  HEAD branch: master
  Remote branches:
    develop tracked         <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    master  tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

Mas é claro, ainda não há filial local:

$ git branch
* master                  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Vejo? Agora, se você fizer o check-out develp, ele fará a mágica automaticamente:

$ git checkout develop
Branch develop set up to track remote branch develop from origin.
Switched to a new branch 'develop'

Tão fácil!

Resumo. Basta executar estes 2 comandos:

$ git clone git@github.com:user/repo.git
$ git checkout develop

Use a opção '--track'

• Após um git pull:

  git checkout --track <remote-branch-name>

• Ou:

  git fetch && git checkout <branch-name>

Para criar uma nova ramificação, poderíamos usar o seguinte comando

 git checkout --track -b exemplo origem / exemplo 

 git branch -u origin / remote-branch-name

Esta não é uma resposta direta a esta pergunta, mas gostaria de deixar uma nota aqui para qualquer pessoa que esteja com o mesmo problema que eu ao tentar configurar uma ramificação upstream.

Desconfie de push.default .

Nas versões mais antigas do git, o padrão era correspondente , o que causaria um comportamento muito indesejável se você tivesse, por exemplo:

Rastreamento "mestre" da filial local até a origem / mestre

Rastreamento remoto "upstream" da ramificação para upstream / master

Se você tentar "git push" quando estiver no ramo "upstream", com a correspondência push.default, o git tentará mesclar automaticamente o branch local "master" em "upstream / master", causando muito caos.

Isso fornece um comportamento mais sensato:

git config --global push.default upstream

De uma maneira um pouco relacionada, eu estava tentando adicionar uma ramificação de rastreamento remoto a uma ramificação existente, mas não tinha acesso a esse repositório remoto no sistema em que desejava adicionar essa ramificação de rastreamento remoto (porque geralmente exporto uma cópia deste repo via sneakernet para outro sistema que tenha acesso para enviar para esse controle remoto). Descobri que não havia como forçar a adição de uma ramificação remota no local que ainda não havia sido buscada (o local não sabia que a ramificação existia no remoto e eu receberia o erro the requested upstream branch 'origin/remotebranchname' does not exist:).

No final, consegui adicionar a nova ramificação remota desconhecida anteriormente (sem buscar) adicionando um novo arquivo de cabeçalho em .git/refs/remotes/origin/remotebranchnamee depois copiando o ref (o globo ocular era mais rápido, mais coxo ;-) do sistema com acesso à origem repo para a estação de trabalho (com o repo local em que eu estava adicionando a filial remota).

Feito isso, eu poderia usar git branch --set-upstream-to=origin/remotebranchname

ou simplesmente por:

mude para o ramo se você ainda não estiver nele:

[za]$ git checkout branch_name

corre

[za]$ git branch --set-upstream origin branch_name
Branch origin set up to track local branch brnach_name by rebasing.

e você está pronto para:

 [za]$ git push origin branch_name

Você já pode dar uma olhada no arquivo de configuração para ver o que está rastreando o que, executando:

 [za]$ git config -e

Também é bom saber disso, mostra quais ramificações são rastreadas e quais não são. :

  [za]$ git remote show origin 

Para quem, como eu, apenas deseja sincronizar o nome da sua filial local com o nome da filial remota, aqui está um comando útil:

git branch -u origin/$(git rev-parse --abbrev-ref HEAD)

Para evitar lembrar o que você precisa fazer sempre que receber a mensagem:

Especifique com qual filial você deseja mesclar. Veja git-pull (1)
para detalhes.
.....

Você pode usar o seguinte script que define a origem como upstream para a ramificação atual você está.

No meu caso, quase nunca defini outra coisa senão a origem como o upstream padrão . Também quase sempre mantenho o mesmo nome de filial para filial local e remota. Então, o seguinte me cabe:

#!/bin/bash
# scriptname: git-branch-set-originupstream
current_branch="$(git branch | grep -oP '(?<=^\* )(.*)$')"
upstream="origin/$current_branch"
git branch -u "$upstream"

Isso também funcionaria

git branch --set-upstream-to=/< remote>/< branch> < localbranch>