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




remover repositorio remoto git (16)

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

Se você não quer mexer com o arquivo manualmente (e não é tão difícil de fazer), você sempre pode usar o git config para fazer isso ... mas novamente, isso vai apenas editar o arquivo .git/config , de qualquer forma.

Existem, é claro, maneiras de rastrear automaticamente uma ramificação remota ao usar o git checkout (passando o sinalizador --track , por exemplo), mas esses comandos funcionam com novas ramificações, não com as existentes.

Eu sei como fazer uma nova ramificação que rastreia ramificações remotas, mas como faço uma ramificação existente rastrear uma ramificação remota?

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


Você pode achar útil a ferramenta git_remote_branch . Ele oferece comandos simples para criar, publicar, excluir, rastrear e renomear filiais remotas. Uma característica interessante é que você pode pedir um comando grb para explicar que 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

Em muito curto

git branch --set-upstream yourLocalBranchName origin/develop

Isso fará com que seu yourLocalBranchName rastreie o ramo remoto chamado develop .


Acredito que, logo no Git 1.5.x, você poderia fazer com que uma filial local $BRANCH uma origin/$BRANCH filial remota origin/$BRANCH , desta forma.

Dado que $BRANCH e origin/$BRANCH existem, e você não está atualmente com $BRANCH (troque se tiver), faça:

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

Isso recria o $BRANCH como uma ramificação de rastreamento. O -f força a criação apesar do $BRANCH já existir. --track é opcional se os padrões usuais estiverem no lugar (ou seja, o parâmetro git-config branch.autosetupmerge é true).

Observe que, se a origin/$BRANCH não existir ainda, você poderá criá-la, empurrando seu $BRANCH local para o repositório remoto com:

git push origin $BRANCH

Seguido pelo comando anterior para promover a filial local em uma ramificação de rastreamento.


1- atualize seus metadados locais usando: git fetch --all

2- mostre suas filiais remotas e locais usando: git branch -a , veja o seguinte Screenshot

3- alternar para o ramo alvo, que você deseja vincular ao remoto: usando

git check-out branchName

exemplo:

4- Vincule sua filial local a uma ramificação remota usando:

git branch --set-upstream-to nameOfRemoteBranch

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

Exemplo de uso:


Você pode fazer o seguinte (supondo que tenha feito check-out no mestre e deseja enviar a um mestre de filial remoto):

Configure o 'remoto' se você não o tiver

git remote add origin ssh://...

Agora configure o mestre para saber para rastrear:

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

E empurre:

git push origin master

Aqui, usando o github e git version 2.1.4 , basta fazer:

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

E os controles remotos vêm pelo itelsef, mesmo que não estejam vinculados 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)

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

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

Vejo? Agora, se você fizer o checkout, 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. Apenas execute estes dois comandos:

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

Eu faço isso como um efeito colateral de empurrar com a opção -u como em

$ git push -u origin branch-name

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

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

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

Era tentador dizer git branch --set-upstream origin/master , mas isso diz ao Git para organizar a ramificação local "origin / master" para integrar com a ramificação atualmente registrada, 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 short-and-sweet -u ).

Digamos que você tenha um branch foo local e queira que ele trate o branch com o mesmo nome de seu branch upstream. 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

Certifique-se de executar:

git config push.default tracking

ser capaz de empurrar sem problemas


Use a opção '--track'

  • Depois de 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 example origin/example 
Para o ramo já criado para criar link entre remoto, em seguida, a partir desse ramo use o comando abaixo

 git branch -u origin/remote-branch-name


De fato para a resposta aceita 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 um branch foo e um upstream remoto:

A partir do Git 1.8.0:

git branch -u upstream/foo

Ou, se o branch local foo não for o branch atual:

git branch -u upstream/foo foo

Ou, se você gosta de digitar comandos mais longos, eles 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 o branch local foo rastreie branch remoto foo de upstream remoto. A sintaxe antiga (1.7.x) está obsoleta em favor da nova sintaxe (1.8+). A nova sintaxe é destinada a ser mais intuitiva e fácil de lembrar.

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


Isso também funcionaria

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

Para o 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 foo acompanhar upstream/foo .


Esta não é uma resposta direta a esta pergunta, mas eu gostaria de deixar uma nota aqui para qualquer pessoa que possa estar tendo o mesmo problema que eu ao tentar configurar um branch upstream.

Desconfie de push.default .

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

Ramificação local "mestre" de rastreamento para origem / mestre

Rastreio "upstream" da ramificação remota para upstream / master

Se você tentou "git push" quando estava na ramificação "upstream", com o comando push.default matching git tentava automaticamente mesclar a ramificação local "master" em "upstream / master", causando um monte de caos.

Isso dá um comportamento mais sensato:

git config --global push.default upstream







git-branch