Come recuperare tutti i rami Git

Ho clonato un repository Git, che contiene circa cinque rami. Tuttavia, quando lo faccio git branchvedo solo uno di loro:

$ git branch
* master

So che posso fare git branch -aper vedere tutti i rami, ma come potrei tirare tutti i rami localmente, quindi quando lo faccio git branch, mostra quanto segue?

$ git branch
* master
* staging
* etc...

Puoi recuperare tutti i rami da tutti i telecomandi in questo modo:

git fetch --all

È fondamentalmente una mossa di potere .

fetchaggiorna le copie locali delle filiali remote, quindi è sempre sicuro per le filiali locali MA :

1. fetchnon aggiornerà le filiali locali (che tengono traccia delle filiali remote); se vuoi aggiornare le tue filiali locali devi comunque estrarre tutte le filiali.

2. fetchnon creerà filiali locali (che tengono traccia delle filiali remote), devi farlo manualmente. Se si desidera elencare tutti i rami remoti: git branch -a

Per aggiornare le filiali locali che tengono traccia delle filiali remote:

git pull --all

Tuttavia, questo può essere ancora insufficiente. Funzionerà solo per le filiali locali che tracciano filiali remote. Per tenere traccia di tutti i rami remoti, eseguire questo oneliner PRIMA git pull --all :

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done

TL; versione DR

git branch -r | grep -v '\->' | while read remote; do git branch --track "${remote#origin/}" "$remote"; done
git fetch --all
git pull --all

(Sembra che pull recuperi tutti i rami da tutti i telecomandi, ma cerco sempre prima solo per essere sicuro.)

Esegui il primo comando solo se sul server sono presenti filiali remote che non sono tracciate dalle filiali locali.

PS AFAIK git fetch --alle git remote updatesono equivalenti.

Il commento di Kamil Szot , che la gente ha trovato utile.

Ho dovuto usare:

for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done

perché il tuo codice ha creato filiali locali denominate origin/branchnamee ho ricevuto "refname 'origin / branchname' è ambiguo ogni volta che mi riferivo ad esso.

Per elencare le filiali remote:
git branch -r

Puoi verificarli come filiali locali con:
git checkout -b LocalName origin/remotebranchname

Sarà necessario creare filiali locali che tengono traccia delle filiali remote.

Supponendo che tu abbia un solo telecomando chiamato origin, questo frammento creerà filiali locali per tutti quelli di localizzazione remota:

for b in `git branch -r | grep -v -- '->'`; do git branch --track ${b##origin/} $b; done

Successivamente, git fetch --allaggiornerà tutte le copie locali delle filiali remote.

Inoltre, git pull --allaggiornerà i rami di tracciamento locali, ma a seconda dei commit locali e del modo in cui è impostata l'opzione di configurazione "Unisci", potrebbe creare un commit di unione, avanzamento rapido o errore.

Se fate:

git fetch origin

allora saranno tutti lì a livello locale. Se poi esegui:

git branch -a

li vedrai elencati come telecomandi / origine / nome-ramo. Dal momento che sono lì a livello locale, puoi fare qualsiasi cosa tu voglia con loro. Per esempio:

git diff origin/branch-name 

o

git merge origin/branch-name

o

git checkout -b some-branch origin/branch-name

$ git remote update
$ git pull --all

Ciò presuppone che tutti i rami siano tracciati.

Se non lo sono, puoi sparare in Bash:

for remote in `git branch -r `; do git branch --track $remote; done

Quindi eseguire il comando.

Il forloop Bash non funzionava per me, ma questo ha fatto esattamente quello che volevo. Tutti i rami della mia origine rispecchiavano localmente lo stesso nome.

git checkout --detach
git fetch origin '+refs/heads/*:refs/heads/*'

Vedi il commento di Mike DuPont di seguito. Penso che stavo provando a farlo su un server Jenkins che lo lascia in modalità testa staccata.

Usa git fetch && git checkout RemoteBranchName.

Funziona molto bene per me ...

Quando si clona un repository, tutte le informazioni sui rami vengono effettivamente scaricate ma i rami vengono 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 possibile "scaricarli" manualmente uno alla volta.

Tuttavia, c'è un modo molto più pulito e veloce, anche se è un po 'complicato. Sono necessari tre passaggi per ottenere questo risultato:

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, ora c'è solo una cartella nascosta .git che puoi vedere con un comando "ls -alt" dal terminale.

2. Secondo passo

   cambia questo repository da un repository vuoto (bare) a un repository regolare impostando il valore booleano "bare" delle configurazioni git su false:

   $ git config --bool core.bare false
   

3. Terzo passo

   Prendi tutto ciò che si trova nella cartella corrente e crea tutti i rami sul computer locale, rendendolo quindi un normale repository.

   $ git reset --hard
   

Quindi ora puoi semplicemente digitare il comando git branche puoi vedere che tutti i rami sono stati scaricati.

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

Puoi recuperare tutti i rami:

git fetch --all

o:

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

^{Il --depth=10000parametro può essere utile se hai un repository con superficiale.}

Per tirare tutti i rami, utilizzare:

git pull --all

Se above non funziona, precede il comando precedente con:

git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

poiché remote.origin.fetchpotrebbe supportare solo un ramo specifico durante il recupero, specialmente quando hai clonato il tuo repository con --single-branch. Controllare questo: git config remote.origin.fetch.

Dopodiché dovresti essere in grado di verificare qualsiasi filiale.

Guarda anche:

• Come recuperare tutti i rami remoti?
• Come clonare tutti i rami remoti in Git?

Per inviare tutti i rami al telecomando, utilizzare:

git push --all

eventualmente --mirrorper rispecchiare tutti i riferimenti.

Se il tuo obiettivo è duplicare un repository, consulta: Duplicazione di un articolo di repository su GitHub.

Di solito non uso altro che comandi come questo:

git fetch origin
git checkout --track origin/remote-branch

Una versione un po 'più corta:

git fetch origin
git checkout -t origin/remote-branch

Credo che tu abbia clonato il repository da:

git clone https://github.com/pathOfrepository

Ora vai a quella cartella usando cd:

cd pathOfrepository

Se digiti git statuspuoi vedere tutto:

   On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working directory clean

Per vedere tutti i tipi di rami nascosti:

 git branch -a

Elencherà tutti i rami remoti.

Ora se vuoi fare il checkout su un ramo particolare, digita:

git checkout -b localBranchName origin/RemteBranchName

Se stai cercando una soluzione per ottenere tutte le filiali e quindi migrare tutto su un altro server Git, ho messo insieme il processo seguente. Se vuoi solo aggiornare tutti i rami localmente, fermati alla prima riga vuota.

git clone <ORIGINAL_ORIGIN>
git branch -r | awk -F'origin/' '!/HEAD|master/{print $2 " " $1"origin/"$2}' | xargs -L 1 git branch -f --track 
git fetch --all --prune --tags
git pull --all

git remote set-url origin <NEW_ORIGIN>
git pull
<resolve_any_merge_conflicts>
git push --all
git push --tags
<check_NEW_ORIGIN_to_ensure_it_matches_ORIGINAL_ORIGIN>

Dopo aver clonato il repository principale, puoi semplicemente eseguire

git fetch && git checkout <branchname>

Assicurarsi che tutti i rami remoti siano inseribili nel .git/configfile.

In questo esempio, origin/productionè possibile accedere solo al ramo, anche se si tenta di non fare git fetch --allnulla, se non recuperare il productionramo:

[origin]
fetch = +refs/heads/production:refs/remotes/origin/production

Questa riga dovrebbe essere sostituita da:

[origin]
fetch = +refs/heads/*:refs/remotes/origin/*

Quindi eseguire git fetchecc ...

Il looping non sembrava funzionare per me e volevo ignorare origin / master. Ecco cosa ha funzionato per me.

git branch -r | grep -v HEAD | awk -F'/' '{print $2 " " $1"/"$2}' | xargs -L 1 git branch -f --track

Dopo di che:

git fetch --all
git pull --all

Solo questi tre comandi otterranno tutti i rami:

git clone --mirror repo.git  .git     (gets just .git  - bare repository)

git config --bool core.bare false

git reset --hard

Perché nessuno risponde alla domanda dei ragazzi e spiega cosa sta succedendo?

1. Assicurati di tenere traccia di tutti i rami remoti (o di quelli che desideri monitorare) .
2. Aggiorna i tuoi rami locali per riflettere i rami remoti.

Traccia tutti i rami remoti:

Tieni traccia di tutti i rami esistenti nel repository remoto.

Fallo manualmente:

Sostituiresti <branch>con un ramo che viene visualizzato dall'output di git branch -r.

git branch -r
git branch --track <branch>

Fallo con uno script bash

for i in $(git branch -r | grep -vE "HEAD|master"); do git branch --track ${i#*/} $i; done

Aggiorna le informazioni sulle filiali remote sul tuo computer locale:

In questo modo vengono recuperati gli aggiornamenti sulle filiali dal repository remoto che si sta monitorando nel repository locale. Ciò non altera le filiali locali. Il repository git locale ora è a conoscenza di ciò che è accaduto sui rami dei repository remoti. Un esempio potrebbe essere che un nuovo commit è stato inviato al master remoto, facendo un recupero ora ti avviserà che il tuo master locale è indietro di 1 commit.

git fetch --all

Aggiorna le informazioni sulle filiali remote sul tuo computer locale e aggiorna le filiali locali:

Esegue un recupero seguito da un'unione per tutti i rami dal ramo remoto a quello locale. Un esempio potrebbe essere che un nuovo commit è stato inviato al master remoto, facendo un pull aggiornerà il tuo repository locale sulle modifiche nel ramo remoto e poi le unirà nel tuo ramo locale. Questo può creare un bel casino a causa della fusione dei conflitti.

git pull --all

Ho scritto una piccola sceneggiatura per gestire la clonazione di un nuovo repository e creare filiali locali per tutte le filiali remote.

Puoi trovare l'ultima versione qui :

#!/bin/bash

# Clones as usual but creates local tracking branches for all remote branches.
# To use, copy this file into the same directory your git binaries are (git, git-flow, git-subtree, etc)

clone_output=$((git clone "$@" ) 2>&1)
retval=$?
echo $clone_output
if [[ $retval != 0 ]] ; then
    exit 1
fi
pushd $(echo $clone_output | head -1 | sed 's/Cloning into .\(.*\).\.\.\./\1/') > /dev/null 2>&1
this_branch=$(git branch | sed 's/^..//')
for i in $(git branch -r | grep -v HEAD); do
  branch=$(echo $i | perl -pe 's/^.*?\///')
  # this doesn't have to be done for each branch, but that's how I did it.
  remote=$(echo $i | sed 's/\/.*//')
  if [[ "$this_branch" != "$branch" ]]; then
      git branch -t $branch $remote/$branch
  fi
done
popd > /dev/null 2>&1

Per usarlo, basta copiarlo nella directory di git bin (per me, cioè C:\Program Files (x86)\Git\bin\git-cloneall), quindi, dalla riga di comando:

git cloneall [standard-clone-options] <url>

Clona come al solito, ma crea filiali di tracciamento locali per tutte le filiali remote.

Come recuperare tutti i rami Git Tracciamento di un singolo telecomando.

Questo è stato testato e funziona su Red Hat e Git Bash su Windows 10.

TLDR:

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Spiegazione:

L'unico liner verifica e quindi recupera tutti i rami tranne HEAD.

Elencare i rami di tracciamento remoto.

git branch -r

Ignora TESTA.

grep -v ' -> '

Rimuovere il nome della filiale dai telecomandi.

cut -d"/" -f2

Verifica tutti i rami che seguono un singolo telecomando.

git checkout $branch

Scarica per ramo estratto.

git fetch

Tecnicamente il recupero non è necessario per le nuove filiali locali.

Questo può essere usato per entrambi fetch opull rami che sono entrambi nuovi e hanno cambiamenti nei telecomandi.

Assicurati di tirare solo se sei pronto a unire.

Configurazione di prova

Dai un'occhiata a un repository con URL SSH.

git clone git@repository.git

Prima

Controlla le filiali in locale.

$ git branch
* master

Esegui comandi

Eseguire un solo liner.

for branch in `git branch -r|grep -v ' -> '|cut -d"/" -f2`; do git checkout $branch; git fetch; done;

Dopo

Verifica che le filiali locali includano filiali remote.

$ git branch
  cicd
  master
* preprod

Per utenti Windows che usano PowerShell:

git branch -r | ForEach-Object {
    # Skip default branch, this script assumes
    # you already checked-out that branch when cloned the repo
    if (-not ($_ -match " -> ")) {
        $localBranch = ($_ -replace "^.*?/", "")
        $remoteBranch = $_.Trim()
        git branch --track "$localBranch" "$remoteBranch"
    }
}
git fetch --all
git pull --all

Ecco qualcosa che considererei robusto:

• Non aggiorna il monitoraggio remoto per le filiali esistenti
• Non tenta di aggiornare HEADper tenere tracciaorigin/HEAD
• Consente telecomandi denominati diversi da origin
• Shell correttamente citato

for b in $(git branch -r --format='%(refname:short)'); do
  [[ "${b#*/}" = HEAD ]] && continue
  git show-ref -q --heads "${b#*/}" || git branch --track "${b#*/}" "$b";
done
git pull --all

Non è necessario git fetch --allil passaggio -alla git pullpassa questa opzione all'internofetch .

Ringraziamo questa risposta .

Ecco una versione Perl del one-liner fornita nella risposta accettata:

git branch -r | perl -e 'while(<>) {chop; my $remote = $_; my ($local) = ($remote =~ /origin\/(.*)/); print "git branch --track $local $remote\n";}' > some-output-file

Se lo desideri, puoi eseguire il file di output come script Shell.

Abbiamo cancellato il nostro repository del progetto Stash per caso. Fortunatamente qualcuno aveva creato un fork proprio prima della perdita accidentale. Ho clonato il fork al mio locale (tralascerò i dettagli di come l'ho fatto). Una volta che ho avuto la forchetta completamente nel mio locale, ho fatto funzionare una linea. Ho modificato l'URL del telecomando (origine nel mio caso) per puntare al repository di destinazione in cui ci stavamo ripristinando:

git remote set-url origin <remote-url>

E infine ha spinto tutti i rami all'origine in questo modo:

git push --all origin

e siamo tornati in affari.

Possiamo mettere tutti i nomi di ramo o tag in un file temporaneo, quindi eseguire git pull per ogni nome / tag:

git branch -r | grep origin | grep -v HEAD| awk -F/ '{print $NF}' > /tmp/all.txt
git tag -l >> /tmp/all.txt
for tag_or_branch in `cat /tmp/all.txt`; do git checkout $tag_or_branch; git pull origin $tag_or_branch; done

Se hai problemi con fetch --allquindi traccia il tuo ramo remoto:

git checkout --track origin/%branchname%

Per evitare il messaggio di errore "fatale: esiste già un ramo chiamato" origine / master ".

git branch -r | grep -v '\->'  | grep -v `git branch | awk '/\*/ { print $2; }'`| while read remote; do git branch --track "${remote#origin/}" "$remote"; done

Sulla base della risposta di Learath2, ecco cosa ho fatto dopo aver fatto git clone [...]e cdinserito nella directory creata:

git branch -r | grep -v master | awk {print\$1} | sed 's/^origin\/\(.*\)$/\1 &/' | xargs -n2 git checkout -b

Ha funzionato per me ma non posso sapere che funzionerà per te. Stai attento.

git remote add origin https://yourBitbucketLink

git fetch origin

git checkout -b yourNewLocalBranchName origin/requiredRemoteBranch (use tab :D)

Ora a livello locale sei yourNewLocalBranchNametuo requiredRemoteBranch.

Per gli utenti di Visual Studio, sulla console di Package Manager:

ramo git | % {git fetch upstream; git merge upstream / master}

Ho provato molti modi, solo questo è semplice e funziona per me.

for branch in $(git ls-remote -h git@<your_repository>.git | awk '{print $2}' | sed 's:refs/heads/::')
do
  git checkout "$branch"
  git pull
done

Imposta alias: (basato sulla risposta principale)

git config --global alias.track-all-branches '!git fetch --all && for remote in `git branch -r`; do git branch --track ${remote#origin/} $remote; done && git fetch --all'

Ora per tracciare tutti i rami:

git track-all-branches