Como clonar todas as ramificações remotas no Git?
-
09-06-2019 - |
Pergunta
eu tenho um master
e um development
ramo, ambos empurrados para GitHub.Eu tenho clone
d, pull
ed, e fetch
ed, mas continuo incapaz de obter outra coisa senão o master
ramificar para trás.
Tenho certeza de que estou perdendo algo óbvio, mas li o manual e não estou sentindo nenhuma alegria.
Solução
Primeiro, clone um controle remoto Git repositório e cd afim disso:
$ git clone git://example.com/myproject
$ cd myproject
A seguir, observe as ramificações locais em seu repositório:
$ git branch
* master
Mas existem outros ramos escondidos no seu repositório!Você pode ver isso usando o -a
bandeira:
$ git branch -a
* master
remotes/origin/HEAD
remotes/origin/master
remotes/origin/v1.0-stable
remotes/origin/experimental
Se você quiser apenas dar uma olhada rápida em uma ramificação upstream, você pode conferir diretamente:
$ git checkout origin/experimental
Mas se quiser trabalhar nessa filial, você precisará criar uma filial de rastreamento local, o que é feito automaticamente por:
$ git checkout experimental
e você verá
Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'
Essa última linha confunde algumas pessoas:"Nova filial" - hein?O que isso realmente significa é que o branch é retirado do índice e criado localmente para você.O anterior linha é na verdade mais informativa, pois informa que a ramificação está sendo configurada para rastrear a ramificação remota, o que geralmente significa a ramificação origin/branch_name
Agora, se você observar suas filiais locais, verá o seguinte:
$ git branch
* experimental
master
Na verdade, você pode rastrear mais de um repositório remoto usando git remote
.
$ git remote add win32 git://example.com/users/joe/myproject-win32-port
$ git branch -a
* master
remotes/origin/HEAD
remotes/origin/master
remotes/origin/v1.0-stable
remotes/origin/experimental
remotes/win32/master
remotes/win32/new-widgets
Neste ponto, as coisas estão ficando muito loucas, então corra gitk
para ver o que está acontecendo:
$ gitk --all &
Outras dicas
Se você tiver muitas ramificações remotas que deseja buscar de uma vez, faça:
$ git pull --all
Agora você pode fazer check-out de qualquer branch conforme necessário, sem acessar o repositório remoto.
Esse Bash script me ajudou:
#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do
git branch --track "${branch##*/}" "$branch"
done
Ele criará ramificações de rastreamento para todas as ramificações remotas, exceto master (que você provavelmente obteve do comando clone original).Eu acho que você ainda pode precisar fazer um
git fetch --all
git pull --all
para ter certeza.
Um forro:
git branch -a | grep -v HEAD | perl -ne 'chomp($_); s|^\*?\s*||; if (m|(.+)/(.+)| && not $d{$2}) {print qq(git branch --track $2 $1/$2\n)} else {$d{$_}=1}' | csh -xfs
Como sempre:teste sua configuração antes de copiar rm -rf universo como o conhecemosOs créditos do one-liner vão para o usuário cfi
Usando o --mirror
opção parece copiar o remote
rastreando filiais corretamente.No entanto, ele configura o repositório como um repositório vazio, então você terá que transformá-lo novamente em um repositório normal posteriormente.
git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch
Você pode facilmente mudar para um branch sem usar a sintaxe sofisticada "git checkout -b somebranch origin/somebranch".Você pode simplesmente fazer:
git checkout somebranch
O Git fará automaticamente a coisa certa:
$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'
O Git verificará se existe um branch com o mesmo nome em exatamente um branch remoto e, se existir, ele o rastreará da mesma maneira como se você tivesse especificado explicitamente que é um branch remoto.Na página de manual git-checkout do Git 1.8.2.1:
Seu003Cbranch> não é encontrado, mas existe um ramo de rastreamento em exatamente um controle remoto (chameu003Cremote> ) com um nome correspondente, trate como equivalente a
$ git checkout -b <branch> --track <remote>/<branch>
A respeito de,
$ git checkout -b origem experimental/experimental
usando
$ git checkout -t origin/experimental
ou o mais detalhado, mas mais fácil de lembrar
$ git checkout --track origin/experimental
pode ser melhor, em termos de rastreamento de um repositório remoto.
A busca que você está fazendo deve obter todas as ramificações remotas, mas não criará ramificações locais para elas.Se você usar o gitk, deverá ver as ramificações remotas descritas como "remotes/origin/dev" ou algo semelhante.
Para criar uma filial local baseada em uma filial remota, faça algo como:
git checkout -b dev refs/remotes/origin/dev
Que deve retornar algo como:
Branch dev set up to track remote branch refs/remotes/origin/dev. Switched to a new branch "dev"
Agora, quando você estiver no branch dev, "git pull" atualizará seu desenvolvedor local para o mesmo ponto que o branch de desenvolvimento remoto.Observe que ele irá buscar todos os galhos, mas apenas puxará aquele em que você está para o topo da árvore.
Quando você faz "git clone git://location", todas as ramificações e tags são buscadas.
Para trabalhar em cima de uma ramificação remota específica, assumindo que seja a origem remota:
git checkout -b branch origin/branchname
Use apelidos.Embora não haja nenhuma linha nativa do Git, você pode definir a sua como
git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
e então use-o como
git clone-branches
Por que você só vê "mestre"
git clone
baixa todas as ramificações remotas, mas ainda as considera "remotas", mesmo que os arquivos estejam localizados em seu novo repositório.Há uma exceção a isso: o processo de clonagem cria uma ramificação local chamada “master” a partir da ramificação remota chamada “master”.Por padrão, git branch
mostra apenas filiais locais, e é por isso que você vê apenas "master".
git branch -a
mostra todos os ramos, incluindo filiais remotas.
Como obter filiais locais
Se você realmente deseja trabalhar em um branch, provavelmente desejará uma versão "local" dele.Para simplesmente criar filiais locais a partir de filiais remotas (sem verificá-los e, assim, alterar o conteúdo do seu diretório de trabalho), você pode fazer isso assim:
git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree
Neste exemplo, branchone
é o nome de uma filial local que você está criando com base em origin/branchone
;se você quiser criar filiais locais com nomes diferentes, você pode fazer o seguinte:
git branch localbranchname origin/branchone
Depois de criar uma filial local, você poderá vê-la com git branch
(lembre-se, você não precisa -a
para ver filiais locais).
Isso não é muito complicado, os passos muito simples e diretos são os seguintes;
git fetch origin
Isso trará todas as filiais remotas para o seu local.
git branch -a
Isso mostrará todas as filiais remotas.
git checkout --track origin/<branch you want to checkout>
Verifique se você está no branch desejado pelo seguinte comando;
git branch
A saída será assim;
*your current branch
some branch2
some branch3
Observe o sinal * que indica a ramificação atual.
Antes tarde do que nunca, mas aqui está a melhor maneira de fazer isso:
mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard
Neste ponto você tem uma cópia completa do repositório remoto com todas as suas ramificações (verifique com git branch
).Você pode usar --mirror
em vez de --bare
se o seu repositório remoto tiver controles remotos próprios.
Basta fazer isso:
$ git clone git://example.com/myproject
$ cd myproject
$ git checkout branchxyz
Branch branchxyz set up to track remote branch branchxyz from origin.
Switched to a new branch 'branchxyz'
$ git pull
Already up-to-date.
$ git branch
* branchxyz
master
$ git branch -a
* branchxyz
master
remotes/origin/HEAD -> origin/master
remotes/origin/branchxyz
remotes/origin/branch123
Veja bem, 'git clone git://example.com/myprojectt' busca tudo, até mesmo as ramificações, basta fazer o check-out e sua ramificação local será criada.
Você só precisa usar "git clone" para obter todas as ramificações.
git clone <your_http_url>
Mesmo que você veja apenas o branch master, você pode usar "git branch -a" para ver todos os ramos.
git branch -a
E você pode mudar para qualquer filial que já possua.
git checkout <your_branch_name>
Não se preocupe, pois depois de "git clone", você não precisará se conectar ao repositório remoto, "git branch -a" e "git checkout" poderão ser executados com sucesso quando você fechar seu wifi.Então está provado que quando você faz "git clone", ele já copiou todas as ramificações do repositório remoto.Depois disso, você não precisa do repositório remoto, seu local já possui todos os códigos das filiais.
A git clone
deve copiar todo o repositório.Tente cloná-lo e execute git branch -a
.Deve listar todos os ramos.Se você quiser mudar para o branch "foo" em vez de "master", use git checkout foo
.
Use minha ferramenta git_remote_branch (você precisa do Ruby instalado em sua máquina).Ele foi desenvolvido especificamente para facilitar a manipulação remota de filiais.
Cada vez que ele realiza uma operação em seu nome, ele a imprime em vermelho no console.Com o tempo, eles finalmente ficam no seu cérebro :-)
Se você não quiser que o grb execute comandos em seu nome, basta usar o recurso 'explicar'.Os comandos serão impressos em seu console em vez de executados para você.
Por fim, todos os comandos possuem aliases, para facilitar a memorização.
Observe que isso é software alfa ;-)
Aqui está a ajuda quando você executa grb help:
git_remote_branch version 0.2.6 Usage: grb create branch_name [origin_server] grb publish branch_name [origin_server] grb rename branch_name [origin_server] grb delete branch_name [origin_server] grb track branch_name [origin_server] Notes: - If origin_server is not specified, the name 'origin' is assumed (git's default) - The rename functionality renames the current branch The explain meta-command: you can also prepend any command with the keyword 'explain'. Instead of executing the command, git_remote_branch will simply output the list of commands you need to run to accomplish that goal. Example: grb explain create grb explain create my_branch github All commands also have aliases: create: create, new delete: delete, destroy, kill, remove, rm publish: publish, remotize rename: rename, rn, mv, move track: track, follow, grab, fetch
todas as respostas que vi aqui são válidas, mas existe uma maneira muito mais limpa de clonar um repositório e extrair todas as ramificações de uma vez.
Quando você clona um repositório, todas as informações das ramificações são baixadas, mas as ramificações ficam ocultas.Com o comando
$ git branch -a
você pode mostrar todos os ramos do repositório, e com o comando
$ git checkout -b branchname origin/branchname
você pode então “baixá-los” manualmente, um de cada vez.
No entanto, quando você deseja clonar um repositório com muitos ramos, todas as formas ilustradas acima são demoradas e tediosas em relação a uma forma muito mais limpa e rápida que irei mostrar, embora seja um pouco complicada.Você precisa de três etapas para fazer isso:
- Primeiro passo
crie uma nova pasta vazia em sua máquina e clone uma cópia espelhada da pasta .git do repositório:
$ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
$ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git
o repositório local dentro da pasta my_repo_folder ainda está vazio, há apenas uma pasta .git oculta agora que você pode ver com um comando "ls -alt" do terminal.
- Segundo passo
mude este repositório de um repositório vazio (vazio) para um repositório regular mudando o valor booleano "bare" das configurações do git para falso:
$ git config --bool core.bare false
- Terceiro passo
Pegue tudo que está dentro da pasta atual e crie todas as ramificações na máquina local, tornando este um repositório normal.
$ git reset --hard
Agora você pode simplesmente digitar o comando "git branch" e verá que todos os ramos foram baixados.
Esta é a maneira rápida de clonar um repositório git com todas as ramificações de uma vez, mas não é algo que você queira fazer para cada projeto dessa forma.
Olhando para uma das respostas à pergunta, percebi que é possível encurtá-la:
for branch in `git branch -r | grep -v 'HEAD\|master'`; do
git branch --track ${branch##*/} $branch;
done
Mas cuidado, se uma das filiais remotas for nomeada como, por exemplo.admin_master não será baixado!
Obrigado ao bigfish pela ideia original
A clonagem de um repositório local não funcionará com git clone e git fetch:muitas ramificações/tags permanecerão não buscadas.
Para obter um clone com todas as ramificações e tags.
git clone --mirror git://example.com/myproject myproject-local-bare-repo.git
Para obter um clone com todas as ramificações e tags, mas também com uma cópia de trabalho:
git clone --mirror git://example.com/myproject myproject/.git
cd myproject
git config --unset core.bare
git config receive.denyCurrentBranch updateInstead
git checkout master
OK, quando você clona seu repositório, você tem todas as ramificações lá...
Se você apenas fizer git branch
, eles ficam meio escondidos...
Então, se você quiser ver o nome de todos os ramos, basta adicionar --all
bandeira assim:
git branch --all
ou git branch -a
Se você apenas finalizar a compra na agência, terá tudo o que precisa.
Mas e se o branch for criado por outra pessoa após você clonar?
Neste caso, basta fazer:
git fetch
e verifique todos os ramos novamente ...
Se você gosta de buscar e finalizar a compra ao mesmo tempo, você pode fazer:
git fetch && git checkout your_branch_name
Criei também a imagem abaixo para você simplificar o que falei:
#!/bin/bash
for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
git branch --track ${branch#remotes/origin/} $branch
done
Esse código puxará todos os códigos de filiais remotas para o repositório local.
Para copiar e colar na linha de comando:
git checkout master ; remote=origin ; for brname in `git branch -r | grep $remote | grep -v master | grep -v HEAD | awk '{gsub(/^[^\/]+\//,"",$1); print $1}'`; do git branch -D $brname ; git checkout -b $brname $remote/$brname ; done ; git checkout master
Para mais legibilidade:
git checkout master ;
remote=origin ;
for brname in `
git branch -r | grep $remote | grep -v master | grep -v HEAD
| awk '{gsub(/^[^\/]+\//,"",$1); print $1}'
`; do
git branch -D $brname ;
git checkout -b $brname $remote/$brname ;
done ;
git checkout master
Isso vai:
- verifique master (para que possamos excluir o branch em que estamos)
- selecione remoto para finalizar a compra (altere para qualquer controle remoto que você tenha)
- percorrer todos os ramos do controle remoto, exceto master e HEAD
- excluir filial local (para que possamos verificar as filiais com atualização forçada)
- Confira ramificação do controle remoto
- confira mestre (só por fazer)
Eu precisava fazer exatamente o mesmo.Aqui está o meu Rubi roteiro.
#!/usr/bin/env ruby
local = []
remote = {}
# Prepare
%x[git reset --hard HEAD]
%x[git checkout master] # Makes sure that * is on master.
%x[git branch -a].each_line do |line|
line.strip!
if /origin\//.match(line)
remote[line.gsub(/origin\//, '')] = line
else
local << line
end
end
# Update
remote.each_pair do |loc, rem|
next if local.include?(loc)
%x[git checkout --track -b #{loc} #{rem}]
end
%x[git fetch]
Eu escrevi este pequeno Powershell funções para poder verificar todas as minhas ramificações git, que estão na origem remota.
Function git-GetAllRemoteBranches {
iex "git branch -r" <# get all remote branches #> `
| % { $_ -Match "origin\/(?'name'\S+)" } <# select only names of the branches #> `
| % { Out-Null; $matches['name'] } <# write does names #>
}
Function git-CheckoutAllBranches {
git-GetAllRemoteBranches `
| % { iex "git checkout $_" } <# execute ' git checkout <branch>' #>
}
Mais funções git podem ser encontradas em meu repositório de configurações do git
O Git geralmente (quando não especificado) busca todas as ramificações e/ou tags (refs, consulte: git ls-refs
) de um ou mais repositórios junto com os objetos necessários para completar seus históricos.Em outras palavras, ele busca os objetos que podem ser acessados pelos objetos que já foram baixados.Ver: O que git fetch
realmente faz?
Às vezes você pode ter ramificações/tags que não estão diretamente conectadas à atual, então git pull --all
/git fetch --all
não ajudará nesse caso, mas você pode listá-los por:
git ls-remote -h -t origin
e busque-os manualmente conhecendo os nomes das referências.
Então para pegue todos eles, tentar:
git fetch origin --depth=10000 $(git ls-remote -h -t origin)
O --depth=10000
O parâmetro pode ajudar se você reduziu o repositório.
Em seguida, verifique todas as suas filiais novamente:
git branch -avv
Se o item acima não ajudar, você precisará adicionar manualmente as ramificações ausentes à lista rastreada (pois elas se perderam de alguma forma):
$ git remote -v show origin
...
Remote branches:
master tracked
por git remote set-branches
como:
git remote set-branches --add origin missing_branch
então pode aparecer abaixo remotes/origin
depois de buscar:
$ git remote -v show origin
...
Remote branches:
missing_branch new (next fetch will store in remotes/origin)
$ git fetch
From github.com:Foo/Bar
* [new branch] missing_branch -> origin/missing_branch
Solução de problemas
Se você ainda não conseguir obter nada além do branch master, verifique o seguinte:
- Verifique seus controles remotos (
git remote -v
), por exemplo.- Valide isso
git config branch.master.remote
éorigin
. - Verifique se
origin
aponta para o URL correto por meio de:git remote show origin
(Veja isso publicar).
- Valide isso
Nenhuma dessas respostas foi suficiente, exceto que o usuário ninguém está no caminho certo.
Eu estava tendo problemas para mover um repositório de um servidor/sistema para outro.Quando clonei o repositório, ele criou apenas uma ramificação local para o master, portanto, quando enviei para o novo controle remoto, apenas a ramificação master foi enviada.
Então achei esses dois métodos MUITO úteis.Espero que eles ajudem outra pessoa.
Método 1:
git clone --mirror OLD_REPO_URL
cd new-cloned-project
mkdir .git
mv * .git
git config --local --bool core.bare false
git reset --hard HEAD
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo
Método 2:
git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
git clone OLD_REPO_URL
cd new-cloned-project
git clone-branches
git remote add newrepo NEW_REPO_URL
git push --all newrepo
git push --tags newrepo
Use comandos que você possa lembrar
Estou usando o Bitbucket, um serviço de hospedagem de repositório da Atlassian.Então tento seguir seus documentos.E isso funciona perfeitamente para mim.Com os seguintes comandos fáceis e curtos você pode verificar sua filial remota.
Primeiro, clone seu repositório e depois mude para a pasta de destino.E por último, mas não menos importante, buscar e finalizar a compra:
git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>
É isso.Aqui está um exemplo um pouco mais do mundo real:
git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop
Você encontrará informações detalhadas sobre os comandos nos documentos:Comando Clonar, Comando de busca, Comando de check-out
No início de 2017, a resposta neste comentário funciona:
git fetch <origin-name> <branch-name>
traz o galho para você.Embora isso não extraia todas as ramificações de uma vez, você pode executar isso individualmente por ramificação.
Aqui está outro comando curto de uma linha que cria ramificações locais para todas as filiais remotas:
(git branch -r | sed -n '/->/!s#^ origin/##p' && echo master) | xargs -L1 git checkout
Também funciona corretamente se o rastreamento de filiais locais já tiver sido criado.Você pode chamá-lo após o primeiro git clone
ou a qualquer momento depois.
Se você não precisa ter master
branch verificado após a clonagem, use
git branch -r | sed -n '/->/!s#^ origin/##p'| xargs -L1 git checkout
git clone --mirror
no repositório original funciona bem para isso.
git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin