Come clonare tutte le filiali remote in Git?

Ho un master e un ramo di development , entrambi spinti a GitHub . Ho clone , pull e fetch , ma non riesco a ottenere altro che il ramo master .

Sono sicuro che mi manca qualcosa di ovvio, ma ho letto il manuale e non mi sembra affatto una gioia.

In primo luogo, clonare un repository Git remoto e cd in esso:

 $ git clone git://example.com/myproject $ cd myproject 

Quindi, guarda le filiali locali nel tuo repository:

 $ git branch * master 

Ma ci sono altri rami nascosti nel tuo repository! Puoi vederli usando il flag -a :

 $ git branch -a * master remotes/origin/HEAD remotes/origin/master remotes/origin/v1.0-stable remotes/origin/experimental 

Se vuoi dare una rapida occhiata a un ramo upstream, puoi verificarlo direttamente:

 $ git checkout origin/experimental 

Ma se vuoi lavorare su quel ramo, dovrai creare un ramo di localizzazione locale che viene eseguito automaticamente da:

 $ git checkout experimental 

e vedrai

 Branch experimental set up to track remote branch experimental from origin. Switched to a new branch 'experimental' 

Quest’ultima riga lancia alcune persone: “Nuovo ramo” – eh? Ciò che significa in realtà è che il ramo è preso dall’indice e creato localmente per te. La riga precedente è in realtà più informativa in quanto ti dice che il ramo è stato impostato per tracciare il ramo remoto, che di solito significa il ramo origine / ramo_name

Ora, se guardi le tue filiali locali, questo è ciò che vedrai:

 $ git branch * experimental master 

È ansible tenere traccia di più di un repository remoto utilizzando 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 

A questo punto, le cose stanno diventando piuttosto pazzesche, quindi esegui gitk per vedere cosa sta succedendo:

 $ gitk --all & 

Se hai molte filiali remote che vuoi recuperare subito, fai:

 $ git pull --all 

Ora è ansible effettuare il checkout di qualsiasi filiale in base alle necessità, senza colpire il repository remoto.

Questo script di Bash mi ha aiutato:

 #!/bin/bash for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)$'); do git branch --track "${branch##*/}" "$branch" done 

Creerà rami di rilevamento per tutti i rami remoti, ad eccezione del master (che probabilmente hai ottenuto dal comando clone originale). Penso che potresti ancora aver bisogno di fare un

 git fetch --all git pull --all 

per essere sicuro.

Un rivestimento : 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 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 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 Come al solito: prova nel tuo setup prima di copiare l’universo rm -rf come lo conosciamo

Crediti per one-liner vai a utente cfi

L’ --mirror dell’opzione --mirror sembra copiare correttamente i rami di tracciamento remote . Tuttavia, imposta il repository come un repository nuda, quindi è necessario ripristinarlo in un repository normale in seguito.

 git clone --mirror path/to/original path/to/dest/.git cd path/to/dest git config --bool core.bare false git checkout anybranch 

Riferimento: Git FAQ: Come posso clonare un repository con tutte le filiali tracciate in remoto?

È ansible passare facilmente a un ramo senza utilizzare la syntax di “git checkout -b somebranch origin / somebranch”. Puoi solo fare:

 git checkout somebranch 

Git farà automaticamente la cosa giusta:

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

Git controllerà se un ramo con lo stesso nome esiste esattamente in un remoto, e se lo fa, lo tiene traccia nello stesso modo in cui lo hai specificato esplicitamente che si tratta di un ramo remoto. Dalla pagina man di Git-checkout di Git 1.8.2.1:

Se non viene trovato ma esiste un ramo di tracciamento esattamente in un remoto (chiamatelo ) con un nome corrispondente, considerare come equivalente a

 $ git checkout -b  --track / 

Per quanto riguarda,

$ git checkout -b origine sperimentale / sperimentale

utilizzando

 $ git checkout -t origin/experimental 

o il più verboso ma più facile da ricordare

 $ git checkout --track origin/experimental 

potrebbe essere migliore, in termini di monitoraggio di un repository remoto.

Il recupero che stai facendo dovrebbe ottenere tutti i rami remoti, ma non creerà per loro rami locali. Se usi gitk, dovresti vedere i rami remoti descritti come “remotes / origin / dev” o qualcosa di simile.

Per creare un ramo locale basato su un ramo remoto, fai qualcosa come:

  git checkout -b dev refs / remotes / origin / dev 

Quale dovrebbe restituire qualcosa come:

  Branch dev set up per tracciare remote branch refs / remotes / origin / dev.
 Passato a un nuovo ramo "dev" 

Ora, quando sei sul ramo dev, “git pull” aggiornerà il tuo dev locale allo stesso punto del ramo dev remoto. Nota che recupererà tutti i rami, ma tirerà solo quello che sei in cima all’albero.

Quando esegui “git clone git: // location”, vengono recuperati tutti i rami e i tag.

Per lavorare su uno specifico ramo remoto, supponendo che sia il telecomando di origine:

 git checkout -b branch origin/branchname 

Usa alias. Sebbene non ci siano one-liner Git nativi, puoi definire il tuo come

 git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t' 

e quindi usarlo come

 git clone-branches 

Questo non è troppo complicato, molto semplice e semplici passi sono i seguenti;

git fetch origin Ciò porterà tutti i rami remoti al tuo locale.

git branch -a Questo ti mostrerà tutte le filiali remote.

git checkout --track origin/

Verificare se ci si trova nella diramazione desiderata con il seguente comando;

 git branch 

L’output piacerà a questo;

 *your current branch some branch2 some branch3 

Si noti il ​​segno * che indica il ramo corrente.

Perché vedi solo “maestro”

git clone scarica tutte le filiali remote remote ma le considera comunque “remote”, anche se i file si trovano nel nuovo repository. C’è un’eccezione a questa, che è che il processo di clonazione crea un ramo locale chiamato “master” dal ramo remoto chiamato “master”. Per impostazione predefinita, git branch mostra solo i rami locali, motivo per cui viene visualizzato solo “master”.

git branch -a mostra tutti i rami, inclusi i rami remoti .


Come ottenere filiali locali

Se in realtà vuoi lavorare su un ramo, probabilmente vorrai una versione “locale” di esso. Per creare semplicemente filiali locali da filiali remote (senza verificarle e quindi modificare il contenuto della directory di lavoro) , puoi fare così:

 git branch branchone origin/branchone git branch branchtwo origin/branchtwo git branch branchthree origin/branchthree 

In questo esempio, branchone è il nome di un ramo locale che stai creando in base origin/branchone ; se invece vuoi creare filiali locali con nomi diversi, puoi farlo:

 git branch localbranchname origin/branchone 

Una volta creato un ramo locale, puoi vederlo con git branch (ricorda, non è necessario -a vedere i rami locali).

Meglio tardi che mai, ma ecco il modo migliore per farlo:

 mkdir repo cd repo git clone --bare path/to/repo.git .git git config --unset core.bare git reset --hard 

A questo punto hai una copia completa del repository remoto con tutte le sue filiali (verifica con git branch ). È ansible utilizzare --mirror anziché --bare se il repository remoto ha i propri telecomandi.

Basta fare questo:

 $ 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 

Vedete, ‘git clone git: //example.com/myprojectt’ recupera tutto, anche i rami, basta controllarli, quindi verrà creato il ramo locale.

Un git clone dovrebbe copiare l’intero repository. Prova a clonarlo, quindi esegui git branch -a . Dovrebbe elencare tutti i rami. Se poi vuoi passare al ramo “foo” invece di “master”, usa git checkout foo .

Devi solo usare “git clone” per ottenere tutti i rami.

 git clone  

Anche se vedi solo il ramo principale, puoi usare “git branch -a” per vedere tutti i rami.

 git branch -a 

E puoi passare a qualsiasi ramo che hai già.

 git checkout  

Non preoccuparti che dopo aver “clonato” non sia necessario connettersi con il repository remoto, “git branch -a” e “git checkout” possono essere eseguiti correttamente quando si chiude il wifi. Quindi è dimostrato che quando fai “git clone”, ha già copiato tutti i rami dal repository remoto. Dopodiché, non hai bisogno del repository remoto, il tuo locale ha già tutti i codici dei rami.

Usa il mio strumento git_remote_branch (hai bisogno di Ruby installato sul tuo computer). È stato progettato appositamente per rendere le manipolazioni di branch remote estremamente facili.

Ogni volta che esegue un’operazione a tuo nome, la stampa in rosso sulla console. Nel corso del tempo, si attaccano finalmente al tuo cervello 🙂

Se non vuoi eseguire comandi a tuo nome, usa la funzione ‘spiega’. I comandi verranno stampati sulla tua console invece che eseguiti per te.

Infine, tutti i comandi hanno alias, per facilitare la memorizzazione.

Si noti che questo è un software Alpha 😉

Ecco l’aiuto quando esegui grb help:

 git_remote_branch versione 0.2.6

   Uso:

   grb crea branch_name [origine_server] 

   grb pubblica branch_name [origine_server] 

   grb rinomina branch_name [origine_server] 

   grb delete branch_name [origine_server] 

   grb track branch_name [origine_server] 



   Gli appunti:
   - Se origin_server non è specificato, viene assunto il nome 'origine' 
     (predefinito di Git)
   - La funzionalità rename rinomina il ramo corrente

   Spiega il meta-comando: puoi anche anteporre qualsiasi comando con 
 parola chiave 'spiega'.  Invece di eseguire il comando, git_remote_branch 
 semplicemente visualizzerà l'elenco di comandi che è necessario eseguire per eseguire 
 quell'objective.

   Esempio: 
     grb spiegare creare
     grb explain crea my_branch github

   Tutti i comandi hanno anche alias:
   creare: creare, nuovo
   elimina: elimina, distruggi, elimina, rimuovi, rm
   pubblicare: pubblicare, remotizzare
   rinomina: rinomina, rn, mv, sposta
   traccia: traccia, segui, afferra, recupera

tutte le risposte che ho visto qui sono valide, ma c’è un modo molto più pulito per clonare un repository e tirare tutti i rami contemporaneamente.

Quando cloni un repository tutte le informazioni dei rami vengono effettivamente scaricate ma i rami sono nascosti. Con il comando

 $ git branch -a 

puoi mostrare tutti i rami del repository e con il comando

 $ git checkout -b branchname origin/branchname 

è quindi ansible “scaricarli” manualmente uno alla volta.


Tuttavia, quando si vuole clonare un repository con un sacco di rami tutti i modi illustrati sopra sono lunghi e noiosi rispetto a un modo molto più pulito e veloce che mostrerò, anche se è un po ‘complicato. Hai bisogno di tre passaggi per realizzare questo:

  1. Primo passo

crea una nuova cartella vuota sul tuo computer e clona una copia speculare della cartella .git dal repository:

 $ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder $ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git 

il repository locale all’interno della cartella my_repo_folder è ancora vuoto, c’è solo una cartella .git nascosta ora che puoi vedere con un comando “ls -alt” dal terminale.

  1. Secondo passo

commuta questo repository da un repository vuoto (nudo) ad un repository regolare cambiando il valore booleano “bare” delle configurazioni git su false:

 $ git config --bool core.bare false 
  1. Terzo passo

Prendi tutto ciò che è all’interno della cartella corrente e crea tutti i rami sulla macchina locale, quindi rendilo un normale repo.

 $ git reset --hard 

Quindi ora puoi semplicemente digitare il comando “git branch” e puoi vedere che tutti i rami sono stati scaricati.

Questo è il modo rapido in cui è ansible clonare un repository git con tutti i rami contemporaneamente, ma non è qualcosa che si vuole fare per ogni singolo progetto in questo modo.

Guardando una delle risposte alla domanda ho notato che è ansible accorciarlo:

 for branch in `git branch -r | grep -v 'HEAD\|master'`; do git branch --track ${branch##*/} $branch; done 

Ma attenzione, se uno dei rami remoti è chiamato come admin_master, non verrà scaricato!

Grazie a Big Fish per l’idea originale

OK, quando cloni il tuo repository, hai tutti i rami lì …

Se fai solo un git branch , sono un po ‘nascosti …

Quindi se vuoi vedere tutti i nomi dei rami, semplicemente aggiungi --all flag come questo:

git branch --all o git branch -a

Se fai il checkout alla filiale, ottieni tutto ciò di cui hai bisogno.

Ma che ne dici se il ramo creato da qualcun altro dopo aver clonato?

In questo caso, basta fare:

git fetch

e controlla di nuovo tutti i rami …

Se ti piace recuperare e ritirare allo stesso tempo, puoi fare:

git fetch && git checkout your_branch_name

Anche creato l’immagine qui sotto per voi per semplificare quello che ho detto:

git branch --all per ottenere tutti i rami

Per copia-incolla nella riga di 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 

Per maggiore leggibilità:

 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 

Questo sarà:

  1. controlla master (in modo che possiamo eliminare il ramo su cui ci troviamo)
  2. seleziona il remoto per il checkout (cambialo in qualsiasi telecomando tu disponga)
  3. attraversa tutti i rami del telecomando tranne master e HEAD
    1. cancella il ramo locale (in modo che possiamo controllare i rami aggiornati alla forza)
    2. controlla la filiale dal telecomando
  4. controlla master (per il gusto di farlo)

Basato sulla risposta di VonC .

 #!/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 

Questo codice estrae tutto il codice di filiali remote al repository locale.

Dovevo fare esattamente lo stesso. Ecco il mio script Ruby .

 #!/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] 

La clonazione da un repository locale non funzionerà con git clone e git fetch: molti rami / tag rimarranno non aggiornati.

Per ottenere un clone con tutti i rami e tag.

 git clone --mirror git://example.com/myproject myproject-local-bare-repo.git 

Per ottenere un clone con tutti i rami e tag ma anche con una copia funzionante:

 git clone --mirror git://example.com/myproject myproject/.git cd myproject git config --unset core.bare git config receive.denyCurrentBranch updateInstead git checkout master 

Ho scritto questa piccola funzione di Powershell per poter eseguire il checkout di tutti i miei rami git, che sono di origine 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 ' #> } 

Altre funzioni git possono essere trovate sul mio repository di impostazioni git

Usa i comandi che puoi ricordare

Sto usando Bitbucket, un servizio di hosting di repository di Atlassian. Quindi provo a seguire i loro documenti. E questo funziona perfettamente per me. Con i seguenti comandi semplici e brevi puoi controllare la tua filiale remota.

Per prima cosa clonare il repository, quindi passare alla cartella di destinazione. E, ultimo ma non meno importante, recupera e verifica:

 git clone   cd  git fetch && git checkout  

Questo è tutto. Ecco un esempio più realistico del mondo:

 git clone https://[email protected]/team/repository.git project_folder cd project_folder git fetch && git checkout develop 

Troverai informazioni dettagliate sui comandi nei documenti: comando clona , comando recupero , comando checkout

Git usually (when not specified) fetches all branches and/or tags (refs, see: git ls-refs ) from one or more other repositories along with the objects necessary to complete their histories. In other words it fetches the objects which are reachable by the objects that are already downloaded. See: What does git fetch really do?

Sometimes you may have branches/tags which aren’t directly connected to the current one, so git pull --all / git fetch --all won’t help in that case, but you can list them by:

 git ls-remote -h -t origin 

and fetch them manually by knowing the ref names.

So to fetch them all , try:

 git fetch origin --depth=10000 $(git ls-remote -h -t origin) 

The --depth=10000 parameter may help if you’ve shallowed repository.

Then check all your branches again:

 git branch -avv 

If above won’t help, you need to add missing branches manually to the tracked list (as they got lost somehow):

 $ git remote -v show origin ... Remote branches: master tracked 

by git remote set-branches like:

 git remote set-branches --add origin missing_branch 

so it may appear under remotes/origin after fetch:

 $ 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 

Risoluzione dei problemi

If you still cannot get anything other than the master branch, check the followings:

  • Double check your remotes ( git remote -v ), eg
    • Validate that git config branch.master.remote is origin .
    • Check if origin points to the right URL via: git remote show origin (see this post ).

As of early 2017, the answer in this comment works:

git fetch brings the branch down for you. While this doesn’t pull all branches at once, you can singularly execute this per-branch.

None of these answers cut it, except user nobody is on the right track.

I was having trouble with moving a repo from one server/system to another. When I cloned the repo, it only created a local branch for master so when I pushed to the new remote, only master branch was pushed.

So I found these two methods VERY useful. Hope they help someone else.

Metodo 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 

Metodo 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 

Here is another short one-liner command which creates local branches for all remote branches:

 (git branch -r | sed -n '/->/!s#^ origin/##p' && echo master) | xargs -L1 git checkout 

It works also properly if tracking local branches are already created. You can call it after the first git clone or any time later.

If you do not need to have master branch checked out after cloning, use

 git branch -r | sed -n '/->/!s#^ origin/##p'| xargs -L1 git checkout 

I’m going to add my 2 cents here because I got here trying to find out how to pull down a remote branch I had deleted locally. Origin was not mine, and I didn’t want to go through the hassle of re-cloning everything

Questo ha funzionato per me:

assuming you need to recreate the branch locally:

 git checkout -b recreated-branch-name git branch -a (to list remote branches) git rebase remotes/remote-origin/recreated-branch-name 

So if I forked from gituser/master to sjp and then branched it to sjp/mynewbranch it would look like this:

 $ git checkout -b mynewbranch $ git branch -a master remotes/sjp/master remotes/sjp/mynewbranch $ git fetch (habit to always do before) $ git rebase remotes/sjp/mynewbranch