remote - git remove branch




Come recuperare tutti i rami Git (16)

Ho clonato un repository Git, che contiene circa cinque rami. Tuttavia, quando faccio git branch ne vedo solo uno:

$ git branch
* master

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

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

Assicurati che tutte le diramazioni remote siano raggiungibili nel file .git/config .

In questo esempio, solo il ramo di origin/production è raggiungibile, anche se si prova a fare git fetch --all non succederà nulla, ma recuperando il ramo di production :

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

Questa riga deve essere sostituita da:

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

Quindi esegui git fetch ecc ...


Basato sulla risposta di Learath2, ecco cosa ho fatto dopo aver fatto git clone [...] e cd -ing 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.


Di solito non uso nient'altro che comandi come questo:

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

Una versione più breve:

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

Dopo aver clonato il repository principale, puoi eseguirlo

git fetch && git checkout <branchname>

Ecco qualcosa che considererei robusto:

  • Non aggiorna il tracciamento remoto per i rami esistenti
  • Non tenta di aggiornare HEAD per tracciare l' origin/HEAD
  • Consente telecomandi denominati diversi origin
  • Correttamente shell quotata
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 --all come passaggio -all a git pull passa questa opzione al fetch interno.

Credito a questa risposta


Ecco una versione Perl dell'unica macchina 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

Puoi eseguire il file di output come script di Shell, se lo desideri.

Abbiamo cancellato per errore il nostro repository del progetto Stash. Fortunatamente qualcuno aveva creato una forchetta proprio prima della perdita accidentale. Ho clonato la forcella al mio locale (ometterò i dettagli di come l'ho fatto). Una volta che ho avuto la forchetta completamente nel mio locale, ho eseguito un one-liner. Ho modificato l'URL del telecomando (origine nel mio caso) per puntare al repository di destinazione che stavamo recuperando per:

git remote set-url origin <remote-url>

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

git push --all origin

e noi eravamo di nuovo in affari.


Il bash for loop non funzionava per me, ma questo ha fatto esattamente quello che volevo. Tutti i rami dalla mia origine sono stati replicati come lo stesso nome localmente.

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

Modificato: vedi il commento di Mike DuPont sotto. Penso che stavo cercando di farlo su un server Jenkins che lo lascia in modalità staccata.


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

Per gli utenti Windows che utilizzano 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

Possiamo mettere tutti i nomi di branch o tag in un file temporaneo, quindi fare 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

Puoi recuperare tutti i rami per:

git fetch --all

o:

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

Il parametro --depth=10000 può essere d'aiuto se hai un repository non --depth=10000 .

Per tirare tutti i rami, usa:

git pull --all

Se sopra non funzionerà, quindi precedere il comando precedente con:

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

come remote.origin.fetch potrebbe supportare solo un ramo specifico durante il recupero, specialmente quando hai clonato il tuo repository con --single-branch . Controlla questo: git config remote.origin.fetch .

Dopodiché dovresti essere in grado di effettuare il checkout di qualsiasi filiale.

Guarda anche:

  • Come recuperare tutti i rami remoti?
  • Come clonare tutte le filiali remote in Git?

Per spostare tutti i rami sul telecomando, utilizzare:

git push --all

alla fine --mirror per rispecchiare tutti i ref.

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


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 possibile "scaricarli" manualmente uno alla volta.

Tuttavia, c'è un modo molto più pulito e veloce, 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.

  2. 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
    
  3. 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 è possibile clonare un repository git con tutti i rami contemporaneamente, ma non è qualcosa che si vuole fare per ogni singolo progetto in questo modo.


Se hai problemi con il recupero --all

quindi traccia il tuo ramo remoto

git checkout --track origine /% branchname%


Se siete qui alla ricerca di una soluzione per ottenere tutte le filiali e poi migrare tutto su un altro server Git, ho messo insieme il processo seguente. Se vuoi solo ottenere tutti i rami aggiornati 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>

Usa git fetch && git checkout RemoteBranchName .

Funziona molto bene per me ...


$ git remote update
$ git pull --all

Questo presuppone che tutti i rami siano tracciati.

Se non lo sono, puoi farlo in Bash:

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

Quindi esegui il comando.





git-branch