Como envio uma nova ramificação local para um repositório Git remoto e também a rastreio?

4307

Quero poder fazer o seguinte:

  1. Crie uma filial local com base em outra filial (remota ou local) (via git branchou git checkout -b)

  2. Envie a ramificação local para o repositório remoto (publicação), mas torne-a rastreável git pulle git pushfuncionará imediatamente.

Como faço isso?

Eu conheço o --set-upstreamGit 1.7, mas essa é uma ação pós-criação. Quero encontrar uma maneira de fazer uma alteração semelhante ao enviar a ramificação para o repositório remoto.

Roni Yaniv
fonte
72
apenas para apontar --set-a montante é u
Baiyan Huang
@BaiyanHuang obrigado por apontar isso. Initial Eu pensei que u significava untracked que não faz sentido para mim
Dmitry

Respostas:

6613

No Git 1.7.0 e posterior, você pode fazer o checkout de uma nova ramificação:

git checkout -b <branch>

Edite arquivos, adicione e confirme. Em seguida, pressione com a opção -u(abreviação de --set-upstream) :

git push -u origin <branch>

O Git configurará as informações de rastreamento durante o envio.

Daniel Ruoso
fonte
81
Também é importante notar que, se você já possui um ramo de rastreamento definido no ramo que está enviando e push.defaultestá definido como upstream, isso não fará o que você pensa que fará. Ele tentará empurrar o ramo de rastreamento existente. Use: git push -u origin mynewfeature:mynewfeatureou faça git branch --unset-upstreamprimeiro.
void.pointer
13
Para pessoas que usam o Git no Visual Studio: Na verdade, é isso que "Publicar ramificação" no Visual Studio. Depois de executar o git push com o parâmetro -u, finalmente posso ver minha ramificação conforme publicada na VS UI.
Puterdo Borato 19/03/2015
3
Git push-u origem <ramo> o mesmo que git push-u CABEÇA origem é (supondo que você tenha o ramo que você quer empurrar check-out?)
gymbrall
13
Precisamos da -uopção toda vez que colocamos a ramificação em seu controle remoto ou precisamos dela apenas na primeira vez?
Stephane
17
@ Stephanie Você só precisa de -uuma vez para iniciar o rastreamento. Depois é só usargit push
Todd
491

Se você não estiver compartilhando seu repositório com outras pessoas, isso é útil para enviar todas as suas ramificações para o controle remoto e --set-upstreamrastrear corretamente para você:

git push --all -u

(Não é exatamente o que o OP estava pedindo, mas essa linha é bastante popular)

Se você está compartilhando seu repositório com outras pessoas, essa não é uma forma muito boa, pois você irá entupi-lo com todos os seus ramos experimentais desonestos.

ErichBSchulz
fonte
14
e git pull --allpuxa tudo de volta para outro lugar? kewl
commonpike
1
Este comando configura o rastreamento para a ramificação correta sem a necessidade de enviar nada por push. Obrigado.
amey91
45
O Git permite cometer um ramo e não empurrá-lo por muito boas razões. Somente o uso do git push --all é como descartar uma parte da arquitetura do git. Se funcionar para você, está perfeitamente bem, ótimo, faça isso para sempre. Mas POR FAVOR, não recomende que outros evitem aprender git apenas porque é uma maneira rápida de fazer as coisas.
Federico Razzoli
4
Essa realmente não é a resposta certa e não é uma boa ferramenta a ser recomendada sem uma explicação real do que ela faz e quais são as implicações. Por favor, considere anotar esta resposta.
precisa saber é o seguinte
3
@Federico @akronymn Onde podemos encontrar os perigos de fazer git push --all -u?
user1823664
155

Antes da introdução de git push -u, não havia git pushopção para obter o que você deseja. Você precisava adicionar novas instruções de configuração.

Se você criar uma nova ramificação usando:

$ git checkout -b branchB
$ git push origin branchB:branchB

Você pode usar o git configcomando para evitar a edição direta do .git/configarquivo.

$ git config branch.branchB.remote origin
$ git config branch.branchB.merge refs/heads/branchB

Ou você pode editar manualmente o .git/configarquivo para obter informações de rastreamento para esse ramo.

[branch "branchB"]
    remote = origin
    merge = refs/heads/branchB
Lohrun
fonte
4
por vezes, a sua necessidade destegit push origin -u local_branch:remote_branch
Bruce Lee
127

Simplificando, para criar uma nova filial local , faça:

git branch <branch-name>

Para enviá-lo ao repositório remoto , faça:

git push -u origin <branch-name>
piyushmandovra
fonte
17
git branch <branch-name>e git checkout -b <branch-name>tanto criar um interruptor de ramo, mas check-out para o novo ramo
Robert
1
parênteses é apenas para mencionar que você deve substituir por qualquer nome de filial que deseja criar e enviar.
Piyushmandovra
é um ramo inexistente no controle remoto, e rejeitar comsrc branch-name does not match any
Adi Prasetyo
96

Uma pequena variação das soluções já fornecidas aqui:

  1. Crie uma filial local com base em outra filial (remota ou local):

    git checkout -b branchname
    
  2. Envie a ramificação local para o repositório remoto (publicação), mas torne-a rastreável git pulle git pushfuncionará imediatamente

    git push -u origin HEAD
    

    O uso HEADé uma "maneira útil de enviar a ramificação atual para o mesmo nome no controle remoto". Fonte: https://git-scm.com/docs/git-push Nos termos do Git, HEAD (em maiúsculas) é uma referência à parte superior do ramo atual (árvore).

    A -uopção é apenas uma abreviação de --set-upstream. Isso adicionará uma referência de rastreamento upstream para a ramificação atual. você pode verificar isso procurando no seu arquivo .git / config:

    Digite a descrição da imagem aqui

bg17aw
fonte
2
Obrigado :) git push -u origin <branch-name>não estava funcionando para mim, mas utilizando HEAD, em vez de <branch-name>funcionou perfeitamente :)
Daniel Tonon
57

Eu simplesmente faço

git push -u origin localBranch:remoteBranchToBeCreated

sobre um projeto já clonado.

O Git cria um novo ramo chamado remoteBranchToBeCreatedsob meus commits que fiz localBranch.

Editar : isso altera o seu ramo local atual (possivelmente nomeado localBranch) a montante para origin/remoteBranchToBeCreated. Para corrigir isso, basta digitar:

git branch --set-upstream-to=origin/localBranch

Portanto, sua filial local atual agora é rastreada origin/localBranch.

Arda
fonte
1
Este é exatamente o que eu estava procurando ativamente
eli
git lança error: src refspec <new branch> does not match any.quando eu tento isso.
codeforester 06/07/19
1
Essa deve ser a resposta principal.
Aditya Abhas
30

Suponho que você já tenha clonado um projeto como:

git clone http://github.com/myproject.git
  1. Em sua cópia local, crie uma nova ramificação e confira:

    git checkout -b <newbranch>
    
  2. Supondo que você criou um "git bare --init" em seu servidor e criou o myapp.git, você deve:

    git remote add origin ssh://example.com/var/git/myapp.git
    git push origin master
    
  3. Depois disso, os usuários devem poder

    git clone http://example.com/var/git/myapp.git
    

NOTA: Suponho que você tenha seu servidor instalado e funcionando. Se não for, não funcionará. Um bom tutorial está aqui .

ADICIONADO

Adicione uma filial remota:

git push origin master:new_feature_name

Verifique se tudo está bom (busque a origem e liste as ramificações remotas):

git fetch origin
git branch -r

Crie uma filial local e acompanhe a filial remota:

git checkout -tb new_feature_name origin/new_feature_name

Atualize tudo:

git pull
VP.
fonte
1
De William script que eu ligado a faz sobre o mesmo com a opção adicional para apagar filiais remotas e algumas salvaguardas, também
Tobias KIENZLER
1
empurrar a ramificação local para o repositório remoto (publicação), mas torná-lo rastreável para que o git pull e o git push funcionem imediatamente. é o que o github faz automaticamente quando você envia seu código para o repositório :-)
VP.
1
Isso não responde à pergunta, o <newbranch> do repositório original não é rastreável (e é renomeado como <master> é o novo repositório clonado na etapa 3).
Lohrun
1
parece um exagero. que a git remote add originfazer a rastreável filial local? esse é o comando principal aqui?
Roni Yaniv
3
@Roni Yaniv: não git remote add originapenas registre um novo repositório remoto. É apenas um passo necessário antes de empurrar a sua filial para o repositório remoto (se você não quiser digitar todo o endereço de cada vez)
Lohrun
23

editar Desatualizado, basta usargit push -u origin $BRANCHNAME


Use as diversas ferramentas Gitgit publish-branch de William ( repositório gitorioso e clone ).

OK, não Ruby, então - ignorando as salvaguardas! - pegue as últimas três linhas do script e crie um script bash git-publish-branch:

#!/bin/bash
REMOTE=$1 # Rewrite this to make it optional...
BRANCH=$2
# Uncomment the following line to create BRANCH locally first
#git checkout -b ${BRANCH}
git push ${ORIGIN} ${BRANCH}:refs/heads/${BRANCH} &&
git config branch.${BRANCH}.remote ${REMOTE} &&
git config branch.${BRANCH}.merge refs/heads/${BRANCH}

Em seguida git-publish-branch REMOTENAME BRANCHNAME, execute , onde REMOTENAME geralmente é origem (você pode modificar o script para ter origem como padrão, etc ...)

Tobias Kienzler
fonte
1
isso pressupõe que eu tenho o ruby ​​instalado. sem essa sorte. alguma outra ideia?
Roni Yaniv 04/04
2
o script ruby ​​chama git pushe git configcomando. Eu usei o código do script para editar minha resposta. Você pode usar essas informações para criar um pequeno script de shell que seja útil para você.
Lohrun
1
As diversas ferramentas git de William parecem ter se movido (esse link está morto). Um link de trabalho é: gitorious.org/willgit
Mike D
1
O link de "William" foi quebrado novamente; nova ligação parece ser git-wt-commit.rubyforge.org
ScottJ
22

Para criar uma nova ramificação ramificando-se de uma ramificação existente

git checkout -b <new_branch>

e empurre esse novo ramo para repositório usando

git push -u origin <new_branch>

Isso cria e envia todas as confirmações locais para uma ramificação remota recém-criada origin/<new_branch>

cptjack
fonte
12

Para a versão GitLab anterior à 1.7, use:

git checkout -b name_branch

(name_branch, ex: master)

Para enviá-lo ao repositório remoto, faça:

git push -u origin name_new_branch

(name_new_branch, exemplo: feature)

Fadid
fonte
9

Criei um alias para que sempre que eu criar uma nova ramificação, ela enviará e rastreará a ramificação remota de acordo. Coloquei o seguinte pedaço no .bash_profilearquivo:

# Create a new branch, push to origin and track that remote branch
publishBranch() {
  git checkout -b $1
  git push -u origin $1
}
alias gcb=publishBranch

Uso : basta digitar gcb thuy/do-sth-koolcom thuy/do-sth-koolé o meu novo nome de filial.

Thuy Trinh
fonte
4

Com base nas respostas aqui, envolvi esse processo como um script Bash simples, que também poderia ser usado como um alias do Git.

A adição importante para mim é que isso me pede para executar testes de unidade antes de confirmar e passa no nome da filial atual por padrão.

$ git_push_new_branch.sh

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch           -> Displays prompt reminding you to run unit tests
  git_push_new_branch OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

git_push_new_branch.sh

function show_help()
{
  IT=$(cat <<EOF

  Have you run your unit tests yet? If so, pass OK or a branch name, and try again

  usage: git_push_new_branch {OK|BRANCH_NAME}

  e.g.

  git_push_new_branch.sh           -> Displays prompt reminding you to run unit tests
  git_push_new_branch.sh OK        -> Pushes the current branch as a new branch to the origin
  git_push_new_branch.sh MYBRANCH  -> Pushes branch MYBRANCH as a new branch to the origin

  )
  echo "$IT"
  exit
}

if [ -z "$1" ]
then
  show_help
fi

CURR_BRANCH=$(git rev-parse --abbrev-ref HEAD)
if [ "$1" == "OK" ]
then
  BRANCH=$CURR_BRANCH
else
  BRANCH=${1:-$CURR_BRANCH}
fi

git push -u origin $BRANCH
Brad Parks
fonte
2

Você pode fazer isso em duas etapas:

1. Use o checkoutpara criar a ramificação local:

git checkout -b yourBranchName

Trabalhe com sua filial como quiser.

2. Use o pushcomando para criar automaticamente a ramificação e enviar o código ao repositório remoto:

git push -u origin yourBanchName

Existem várias maneiras de fazer isso, mas acho que dessa maneira é realmente simples.

Javier C.
fonte
0

Para maior flexibilidade, você pode usar um comando Git personalizado . Por exemplo, crie o seguinte script Python em algum lugar no seu $PATHsob o nome git-publishe torne-o executável:

#!/usr/bin/env python3

import argparse
import subprocess
import sys


def publish(args):
    return subprocess.run(['git', 'push', '--set-upstream', args.remote, args.branch]).returncode


def parse_args():
    parser = argparse.ArgumentParser(description='Push and set upstream for a branch')
    parser.add_argument('-r', '--remote', default='origin',
                        help="The remote name (default is 'origin')")
    parser.add_argument('-b', '--branch', help='The branch name (default is whatever HEAD is pointing to)',
                        default='HEAD')
    return parser.parse_args()


def main():
    args = parse_args()
    return publish(args)


if __name__ == '__main__':
    sys.exit(main())

Então git publish -h , mostrará as informações de uso:

usage: git-publish [-h] [-r REMOTE] [-b BRANCH]

Push and set upstream for a branch

optional arguments:
  -h, --help            show this help message and exit
  -r REMOTE, --remote REMOTE
                        The remote name (default is 'origin')
  -b BRANCH, --branch BRANCH
                        The branch name (default is whatever HEAD is pointing to)
Eugene Yarmash
fonte