Fazer um ramo Git existente rastrear um ramo remoto?

Você pode fazer o seguinte (assumindo que você está fora do master e quer empurrar para um branch master remoto):

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

git remote add origin ssh://...

Agora configura o mestre para saber seguir:

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

E empurre:

git push origin master

Faço isto como um efeito secundário de empurrar com a opção -ucomo em

$ git push -u origin branch-name

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

O comando git-branch também compreende --set-upstream, mas o seu uso pode ser confuso. a versão 1.8.0 modifica a interface.

git branch --set-upstream é obsoleto e pode ser removido num futuro relativamente distante. {[8] } foi introduzido com uma ordem de argumentos mais sÃ.

…

Era tentador dizer: isso diz ao Git para organizar o ramo local "origin / master" para se integrar com o ramo atualmente verificado, o que é altamente improvável o que o usuário quis dizer. A opção está desactualizada; utilize a nova opção --set-upstream-to (com uma opção curto-e-doce -u).

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

Ou apenas

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

Talvez encontres o git_remote_branch ferramenta útil. Ele oferece comandos simples para criar, publicar, apagar, rastrear e renomear ramos remotos. Uma boa característica é que você pode pedir a um comando grb para explicar quais comandos do git que 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 a resposta aceite ao trabalho:

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

Dado que $BRANCH e origin/$BRANCH Existem, e que ainda não saiu $BRANCH (Mude se já o fez), faça:

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

Nota, se origin/$BRANCH ainda não existe, você pode criá-lo empurrando o seu $BRANCH local para o repositório remoto com:

git push origin $BRANCH

Seguido pelo comando anterior para promover o ramo local em um ramo de rastreamento.

1 - actualize os seus meta-dados locais usando: git fetch --all

2-mostra os seus ramos remotos e locais usando: git branch-a , veja a seguinte imagem

3 - mude para o ramo alvo, que deseja ligar ao remoto: usando

Git checkout branchName

Exemplo:

4 - Ligue o seu ramo local a um ramo remoto usando:

Git branch -- set-upstream-to nameOfRemoteBranch

N. B : nomeofremotebranch: para copiar da saída do Passo 2 "git branch-r"

Exemplo de Utilização:

Certifica-te que corres :

git config push.default tracking

Para ser capaz de libertar os problemas

Editar {[[0]} é provavelmente a maneira mais fácil e mais rápida. É o que os comandos Git para lidar com ramificações remotas estão fazendo, de qualquer maneira.

Se você não quiser mexer com o arquivo à mão (e não é assim tão difícil de fazer), você pode sempre usar git config para fazê-lo...mas novamente, isso vai apenas editar o arquivo .git/config, de qualquer maneira.

Existem, é claro, formas de seguir automaticamente um ramo remoto ao usar git checkout (passando a bandeira --track, por exemplo), mas estes comandos funcionam com Novos ramos, não existentes.

Em muito curto

git branch --set-upstream yourLocalBranchName origin/develop

Isto fará com que o seu yourLocalBranchName Localize o ramo remoto chamado develop.

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

grb track foo upstream

Isso fará com que o Git Faça foo track upstream/foo.

$ git clone [email protected]:user/repo.git

E os comandos são fornecidos por itelsef, mesmo que não estejam ligados localmente:

$ git remote show origin

* remote origin
  Fetch URL: [email protected]:user/repo.git
  Push  URL: [email protected]: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)

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

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

Resumo. execute apenas estes 2 comandos:

$ git clone [email protected]:user/repo.git
$ git checkout develop

Usar a opção '--track '

• Após um git pull :

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

• Ou:

  git fetch && git checkout <branch-name>

Para criar um novo ramo, poderíamos usar o seguinte comando

 git checkout --track -b example origin/example 

 git branch -u origin/remote-branch-name

Em algo relacionado de maneira que eu estava tentando adicionar um rastreamento remoto ramo de um ramo já existente, mas não tem acesso ao repositório remoto no sistema onde eu queria acrescentar que de rastreamento remoto de ramo em (porque eu frequentemente exportar uma cópia do presente acordo de recompra via sneakernet para outro sistema que tem acesso a empurrar para que remota). Eu descobri que não havia maneira de forçar a adição de um branch remoto no local que ainda não tinha sido obtido (então local não sabia que o branch existia no remoto e eu teria o erro: {[[0]}).

No final, consegui adicionar o novo, anteriormente desconhecido ramo remoto (sem obter), adicionando um novo ficheiro head em {[[1]} e depois copiar o ref (a sobrancelha era mais rápida, lame como era ;-) do sistema com acesso ao repo de origem para a estação de trabalho (com o repo local onde estava a adicionar o ramo remoto).

USO o seguinte comando (suponha que o nome do seu ramo local seja "branch-name-local" e o nome do ramo remoto seja "branch-name-remote"):

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

Se ambos os ramos locais e remotos têm o mesmo nome, então faça o seguinte:

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

Cuidado com empurre.predefinição .

Com versões git mais antigas, o valor por omissão foi correspondência , o que causaria um comportamento muito indesejável se tivesse, por exemplo:

Local branch "master" tracking to origin / master

Se tentou " git push "quando estava no ramo" upstream", com push.a correspondência predefinida do git iria automaticamente tentar fundir o ramo local " master "em" upstream/master", causando um monte de caos.

Isto dá um comportamento mais são:

Git config -- global push.montante predefinido

Ou simplesmente por:

Mude para o ramo se já 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.

 [za]$ git push origin branch_name

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

 [za]$ git config -e

  [za]$ git remote show origin 

Isto também funcionaria

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