Tüm Git dallarını getirme

Yaklaşık beş dal içeren bir Git deposunu klonladım. Ancak, yaptığımda git branchbunlardan sadece birini görüyorum:

$ git branch
* master

Tüm şubeleri git branch -agörmek için yapabileceğimi biliyorum , ancak tüm şubeleri nasıl yerel olarak çekerdim, bunu yaptığımda git branchaşağıdakileri gösterir?

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

Bunun gibi tüm uzaktan kumandalardan tüm dalları alabilirsiniz:

git fetch --all

Temelde bir güç hareketi .

fetchuzak şubelerin yerel kopyalarını güncelleştirir, böylece yerel şubeleriniz için her zaman güvenlidir AMA :

1. fetcholmaz güncellemek yerel şubesi (ki izlemek uzak dalları); yerel şubelerinizi güncellemek istiyorsanız yine de her şubeyi çekmeniz gerekiyor.

2. fetcholmaz oluşturmak (yerel şubesi izlemek uzak dalları), bu elle yapmak zorunda. Tüm uzak dalları listelemek istiyorsanız: git branch -a

Uzak dalları izleyen yerel dalları güncellemek için :

git pull --all

Ancak, bu hala yetersiz olabilir. Yalnızca uzak dalları izleyen yerel şubeleriniz için çalışır. Tüm uzak dalları izlemek için ÖNCE bu oneliner'ı çalıştırın git pull --all:

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

TL; DR versiyonu

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

(Çekme, tüm uzaktan kumandalardan tüm dalları getirir, ancak her zaman ilk önce sadece emin olmak için getiriyorum.)

İlk komutu yalnızca sunucuda yerel şubeleriniz tarafından izlenmeyen uzak dallar varsa çalıştırın.

PS AFAIK git fetch --allve git remote updateeşdeğerdir.

Kamil Szot'un , millet faydalı bulduğu yorumu .

Kullanmak zorunda kaldım:

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

çünkü kodunuz adlandırılmış yerel şubeler oluşturdu origin/branchnameve ben "refname 'origin / branchname' alıyorum.

Uzak dalları listelemek için:
git branch -r

Bunları yerel şubeler olarak kontrol edebilirsiniz:
git checkout -b LocalName origin/remotebranchname

Uzak dalları izleyen yerel şubeler oluşturmanız gerekecektir.

Yalnızca bir uzaktan kumandanız olduğunu varsayarsak origin, bu snippet tüm uzaktan izleme olanlar için yerel şubeler oluşturur:

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

Bundan sonra git fetch --all, uzak dalların tüm yerel kopyalarını güncelleyecektir.

Ayrıca, git pull --allyerel izleme şubelerinizi güncelleyecektir, ancak yerel taahhütlerinize ve 'birleştirme' yapılandırma seçeneğinin nasıl ayarlandığına bağlı olarak, bir birleştirme taahhüdü oluşturabilir, hızlı ileri veya başarısız olabilir.

Yaparsan:

git fetch origin

o zaman hepsi orada yerel olacak. Daha sonra şunları yaparsanız:

git branch -a

bunların uzaktan kumandalar / orijin / şube adı olarak listelendiğini görürsünüz. Onlar orada yerel olduğundan onlarla ne istersen yapabilirsin. Örneğin:

git diff origin/branch-name 

veya

git merge origin/branch-name

veya

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

$ git remote update
$ git pull --all

Bu, tüm dalların izlendiğini varsayar.

Eğer değillerse, bunu Bash'de kovabilirsiniz:

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

Ardından komutu çalıştırın.

Bash fordöngüsü benim için çalışmadı, ama tam olarak istediğim şeyi yaptı. Kökenimden gelen tüm şubeler yerel olarak aynı isimde yansıtıldı.

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

Aşağıdaki Mike DuPont'un yorumuna bakın. Ben bunu bir ayırma kafa modunda bırakılan bir Jenkins Server üzerinde yapmaya çalışıyordum.

Kullanın git fetch && git checkout RemoteBranchName.

Benim için çok iyi çalışıyor ...

Bir havuzu klonladığınızda, dalların tüm bilgileri gerçekten indirilir, ancak dallar gizlenir. Komutu ile

$ git branch -a

deponun tüm dallarını ve komutuyla gösterebilirsiniz.

$ git checkout -b branchname origin/branchname

daha sonra bunları teker teker manuel olarak "indirebilirsiniz".

Bununla birlikte, biraz daha karmaşık ve daha hızlı bir yol var, ancak biraz karmaşık. Bunu yapmak için üç adıma ihtiyacınız vardır:

1. İlk adım

   makinenizde yeni bir boş klasör oluşturun ve .git klasörünün aynadaki bir kopyasını depodan kopyalayın:

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

   my_repo_folder klasörü içindeki yerel depo hala boş, terminalden "ls -alt" komutuyla görebileceğiniz gizli bir .git klasörü var.

2. İkinci adım

   git yapılandırmalarının "bare" boolean değerini false olarak değiştirerek bu havuzu boş (çıplak) bir depodan normal bir depoya değiştirin:

   $ git config --bool core.bare false
   

3. Üçüncü adım

   Geçerli klasörün içindeki her şeyi alın ve yerel makinedeki tüm dalları oluşturun, bu nedenle bunu normal bir repo yapar.

   $ git reset --hard
   

Şimdi komutu yazabilirsiniz git branchve tüm dalların indirildiğini görebilirsiniz.

Bu, bir git deposunu tüm şubelerle aynı anda klonlamanın hızlı yoludur, ancak her bir proje için bu şekilde yapmak istediğiniz bir şey değildir.

Tüm şubeleri şu şekilde getirebilirsiniz:

git fetch --all

veya:

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

^{--depth=10000Eğer depo shallowed verdiyseniz parametre yardımcı olabilir.}

Tüm dalları çekmek için şunu kullanın:

git pull --all

Yukarıdakiler işe yaramazsa, yukarıdaki komuttan önce:

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

çünkü remote.origin.fetchgetirme sırasında yalnızca belirli bir dalı destekleyebilir, özellikle de depoyu klonladığında --single-branch. Bunu kontrol et:git config remote.origin.fetch .

Bundan sonra herhangi bir şubeyi kontrol edebilmelisiniz.

Ayrıca bakınız:

• Tüm uzak dalları nasıl getirebilirim?
• Git'teki tüm uzak dalları nasıl kopyalayabilirim?

Tüm dalları uzaktan kumandaya itmek için şunu kullanın:

git push --all

sonunda --mirrortüm referansları yansıtmak için.

Amacınız bir havuzu çoğaltmaksa, bakınız: GitHub'da bir depo makalesini çoğaltma .

Genellikle böyle komutlar dışında başka bir şey kullanmıyorum:

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

Biraz daha kısa bir versiyon:

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

Depoyu şu şekilde klonladığınıza inanıyorum:

git clone https://github.com/pathOfrepository

Şimdi cd'yi kullanarak o klasöre gidin:

cd pathOfrepository

Eğer yazarsanız git statushepsini görebilirsiniz:

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

Tüm gizli dal türlerini görmek için:

 git branch -a

Tüm uzak dalları listeleyecektir.

Şimdi herhangi bir dalda ödeme yapmak istiyorsanız sadece şunu yazın:

git checkout -b localBranchName origin/RemteBranchName

Burada tüm şubeleri almak ve daha sonra her şeyi başka bir Git sunucusuna geçirmek için bir çözüm arıyorsanız, aşağıdaki işlemi bir araya getirdim. Tüm şubelerin yerel olarak güncellenmesini istiyorsanız, ilk boş satırda durun.

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>

Ana depoyu klonladıktan sonra,

git fetch && git checkout <branchname>

Tüm uzak dalların içeri alınabildiğinden emin olun .git/config dosyada .

Bu örnekte, origin/productiondalı almaktan git fetch --allbaşka bir şey yapmaya çalışsanız bile , sadece şube alınabilir production:

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

Bu satır aşağıdaki ile değiştirilmelidir:

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

Sonra git fetchvb çalıştırın ...

Döngü benim için işe yaramadı ve ben kökeni / ustayı görmezden gelmek istedim. İşte benim için işe yarayan.

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

Daha sonra:

git fetch --all
git pull --all

Sadece bu üç komut tüm dalları alacak:

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

git config --bool core.bare false

git reset --hard

Neden kimse soruya cevap vermiyor ve neler olduğunu açıklamıyor?

1. Tüm uzak dalları (ya da hangisini izlemek istediğinizi) izlediğinizden emin olun .
2. Yerel şubelerinizi uzaktaki dalları yansıtacak şekilde güncelleyin.

Tüm uzak dalları izleyin:

Uzak depoda bulunan tüm dalları izleyin.

Manuel olarak yapın:

Yerine <branch>çıktısından görüntülenen bir dal ile değiştirirsiniz git branch -r.

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

Bir bash betiği ile yapın

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

Yerel bilgisayarınızdaki uzak dallar hakkındaki bilgileri güncelleme:

Bu, yerel deponuzda izlediğiniz uzak depodaki şubelerdeki güncelleştirmeleri alır. Bu, yerel şubelerinizi değiştirmez. Yerel git repo'nuz artık uzak repo şubelerinde olanların farkında. Bir örnek, uzak ana sunucuya yeni bir taahhüt aktarılmış olması, bir getirme işleminin yerel yöneticinizin 1 taahhüt tarafından geride kaldığı konusunda sizi uyaracağıdır.

git fetch --all

Yerel bilgisayarınızdaki uzak dallar hakkındaki bilgileri güncelleyin ve yerel şubeleri güncelleyin:

Uzaktan yerel şubeye kadar tüm şubeler için birleştirme ve ardından birleştirme yapar. Bir örnek, uzak ana sunucuya yeni bir taahhüt aktarılmış olması, çekme işleminin yerel repo'yu uzak daldaki değişiklikler hakkında güncelleyecek ve daha sonra bu değişiklikleri yerel dalınızla birleştirecektir. Bu, birleşme çatışmaları nedeniyle oldukça karışıklık yaratabilir.

git pull --all

Yeni bir repo kopyalamayı ve tüm uzak şubeler için yerel şubeler yapmayı yönetmek için küçük bir senaryo yazdım.

En son sürümü burada bulabilirsiniz :

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

Kullanmak için, sadece git bin dizininize kopyalayın (benim için, o C:\Program Files (x86)\Git\bin\git-cloneallzaman), o zaman komut satırında:

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

Her zamanki gibi klonlar, ancak tüm uzak dallar için yerel izleme dalları oluşturur.

Nasıl Uzaktan Git Takip Tüm Git Dalları Getirilir.

Bu test edilmiştir ve Windows 10'da Red Hat ve Git Bash üzerinde çalışmaktadır.

TLDR:

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

Açıklama:

Bir astar kontrol edilir ve daha sonra HEAD dışındaki tüm dalları getirir.

Uzaktan izleme dallarını listeler.

git branch -r

HEAD'ı yoksay.

grep -v ' -> '

Şube adını uzaktan kumandalardan çıkarın.

cut -d"/" -f2

Tek bir uzaktan kumandayı takip eden tüm şubeleri kontrol edin.

git checkout $branch

Teslim alınan şube için getir.

git fetch

Teknik olarak getirme yeni yerel şubeler için gerekli değildir.

Bu, fetchveyapull , hem yeni olan hem de uzak (lar) da değişiklik yapan şubelerde dallarda .

Sadece birleştirmeye hazırsanız çektiğinizden emin olun.

Test kurulumu

SSH URL'si olan bir depoya göz atın.

git clone git@repository.git

Önce

Yerel şubeleri kontrol edin.

$ git branch
* master

Komutları Yürüt

Bir astarı yürütün.

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

Sonra

Yerel şubelerin uzak şubeleri içerdiğini kontrol edin.

$ git branch
  cicd
  master
* preprod

PowerShell kullanan Windows kullanıcıları için:

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

İşte sağlam olduğunu düşündüğüm bir şey:

• Mevcut şubeler için uzaktan izlemeyi güncellemez
• İzlemek için güncelleme HEADyapmaya çalışmıyororigin/HEAD
• Şunlar dışında adlandırılmış uzaktan kumandalara izin verir: origin
• Uygun kabuk alıntı

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

Bu gerek yoktur git fetch --allaktarma gibi -allhiç git pullpaso iç için bu seçeneği fetch.

Bu cevaba teşekkür ederiz .

Kabul edilen cevapta verilen tek astarın Perl versiyonu:

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

İsterseniz çıktı dosyasını Shell betiği olarak çalıştırabilirsiniz.

Stash proje havuzumuzu yanlışlıkla sildik. Neyse ki birisi kazara kayıptan hemen önce bir çatal yaratmıştı. Çatalı yerelime klonladım (bunu nasıl yaptığımın ayrıntılarını atlayacak). Çatalları yerime tam olarak yerleştirdikten sonra, tek bir astar koştum. Uzaktan kumandanın URL'sini (benim durumumda başlangıç ​​noktası), kurtardığımız hedef depoya işaret edecek şekilde değiştirdim:

git remote set-url origin <remote-url>

Ve nihayet tüm dalları şu şekilde başlamaya itti:

git push --all origin

ve işimize geri döndük.

Tüm şube veya etiket adlarını geçici bir dosyaya koyabiliriz, ardından her ad / etiket için git pull yapabiliriz:

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

İle ilgili sorunlarınız varsa fetch --alluzak dalınızı izleyin:

git checkout --track origin/%branchname%

'Ölümcül:' origin / master 'adında bir şube zaten var. Hata mesajını önlemek için buna ihtiyacınız var:

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

Learath2'nin cevabına dayanarak , oluşturulan dizine yaptıktan git clone [...]ve yaptıktan sonra yaptığım şey cd:

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

Benim için çalıştı ama senin için işe yarayacağını bilemiyorum. Dikkatli ol.

git remote add origin https://yourBitbucketLink

git fetch origin

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

Şimdi yerel yourNewLocalBranchNamesenin requiredRemoteBranch.

Visual Studio Kullanıcıları için Package Manager konsolunda:

git şubesi | % {git yukarı akış getir; git merge akış yukarı / ana}

Birçok yolu denedim, sadece bu basit ve benim için çalışıyor.

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

Diğer adı ayarla: (en üstteki cevaba göre)

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'

Şimdi tüm şubeleri takip etmek için:

git track-all-branches