Comment cloner toutes les branches distantes dans Git?
-
09-06-2019 - |
Question
J'ai un maître
et une branche development
, tous deux poussés vers GitHub . J'ai clone
d, pull
ed, et fetch
ed, mais je ne peux obtenir rien d'autre que le master
branche arrière.
Je suis sûr qu'il me manque quelque chose d'évident, mais j'ai lu le manuel et je ne ressens aucune joie.
La solution
Commencez par cloner un référentiel Git distant et cd dans celui-ci:
$ git clone git://example.com/myproject
$ cd myproject
Ensuite, examinez les branches locales de votre référentiel:
$ git branch
* master
Mais il y a d'autres branches cachées dans votre référentiel! Vous pouvez les voir en utilisant le drapeau -a
:
$ git branch -a
* master
remotes/origin/HEAD
remotes/origin/master
remotes/origin/v1.0-stable
remotes/origin/experimental
Si vous souhaitez simplement jeter un coup d'œil sur une branche en amont, vous pouvez le vérifier directement:
$ git checkout origin/experimental
Mais si vous souhaitez travailler sur cette branche, vous devez créer une branche de suivi locale automatiquement créée par:
$ git checkout experimental
et vous verrez
Branch experimental set up to track remote branch experimental from origin.
Switched to a new branch 'experimental'
Cette dernière ligne renvoie certaines personnes: " Nouvelle branche " - hein? Cela signifie réellement que la branche est extraite de l'index et créée localement pour vous. La ligne précédente est en réalité plus informative, car elle indique que la branche est en train d'être configurée pour suivre la branche distante, ce qui signifie généralement la branche origine / nom de la branche
Maintenant, si vous regardez vos succursales locales, voici ce que vous verrez:
$ git branch
* experimental
master
Vous pouvez réellement suivre plusieurs référentiels distants à l'aide de 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
À ce stade, les choses deviennent assez folles. Lancez gitk
pour voir ce qui se passe:
$ gitk --all &
Autres conseils
Si vous souhaitez récupérer simultanément plusieurs branches distantes, procédez comme suit:
$ git pull --all
Vous pouvez maintenant extraire n'importe quelle branche à votre guise, sans toucher au référentiel distant.
Ce script Bash m'a aidé à sortir:
#!/bin/bash
for branch in $(git branch --all | grep '^\s*remotes' | egrep --invert-match '(:?HEAD|master)
Il créera des branches de suivi pour toutes les branches distantes, à l'exception de la branche principale (que vous avez probablement obtenue avec la commande de clonage d'origine). Je pense que vous pourriez encore avoir besoin de faire un
git fetch --all
git pull --all
pour en être sûr.
Un liner : branche git -a | grep -v HEAD | perl -ne 'chomp ($ _); s | ^ \ *? \ s * ||; if (m | (. +) / (. +) | & amp; & amp; & amp; not $ d {$ 2}) {print qq (branche git - piste $ 2 $ 1 / $ 2 \ n)} sinon {$ d {$ _} = 1} '| csh -xfs
Comme d’habitude: testez dans votre configuration avant de copier l’univers rm -rf tel que nous le connaissons
Crédits pour one-liner aller à l'utilisateur cfi
); do
git branch --track "${branch##*/}" "$branch"
done
Il créera des branches de suivi pour toutes les branches distantes, à l'exception de la branche principale (que vous avez probablement obtenue avec la commande de clonage d'origine). Je pense que vous pourriez encore avoir besoin de faire un
<*>pour en être sûr.
Un liner :
branche git -a | grep -v HEAD | perl -ne 'chomp ($ _); s | ^ \ *? \ s * ||; if (m | (. +) / (. +) | & amp; & amp; & amp; not $ d {$ 2}) {print qq (branche git - piste $ 2 $ 1 / $ 2 \ n)} sinon {$ d {$ _} = 1} '| csh -xfs
Comme d’habitude: testez dans votre configuration avant de copier l’univers rm -rf tel que nous le connaissonsCrédits pour one-liner aller à l'utilisateur cfi
L'utilisation de l'option - mirror
semble copier correctement les branches de suivi à distance
.
Cependant, il configure le référentiel en tant que référentiel nu. Vous devez donc le reconvertir ensuite en référentiel normal.
git clone --mirror path/to/original path/to/dest/.git
cd path/to/dest
git config --bool core.bare false
git checkout anybranch
Référence: Git FAQ: comment puis-je cloner un référentiel? avec toutes les branches suivies à distance?
Vous pouvez facilement basculer vers une branche sans utiliser les options fantaisistes "git checkout -b une origine / une branche". syntaxe. Vous pouvez juste faire:
git checkout somebranch
Git fera automatiquement ce qu'il faut:
$ git checkout somebranch
Branch somebranch set up to track remote branch somebranch from origin.
Switched to a new branch 'somebranch'
Git vérifiera si une branche du même nom existe dans exactement une télécommande et si c'est le cas, il la suivra de la même manière que si vous aviez explicitement spécifié qu'il s'agissait d'une branche distante. Dans la page de manuel git-checkout de Git 1.8.2.1:
Si < branche > est introuvable mais il existe une branche de suivi dans exactement une télécommande (appelez-la < remote >) avec un nom correspondant, traitez-la comme équivalent à
$ git checkout -b <branch> --track <remote>/<branch>
En ce qui concerne,
$ git checkout -b origine expérimentale / expérimentale
en utilisant
$ git checkout -t origin/experimental
ou le plus bavard mais plus facile à retenir
$ git checkout --track origin/experimental
pourrait être meilleur, en termes de suivi d'un référentiel distant.
L'extraction que vous effectuez doit obtenir toutes les branches distantes, mais ne crée pas de branches locales pour elles. Si vous utilisez gitk, les branches distantes doivent être décrites comme suit: "télécommandes / origine / dev". ou quelque chose de similaire.
Pour créer une branche locale basée sur une branche distante, procédez comme suit:
git checkout -b dev refs/remotes/origin/dev
Ce qui devrait retourner quelque chose comme:
Branch dev set up to track remote branch refs/remotes/origin/dev. Switched to a new branch "dev"
Maintenant, lorsque vous êtes sur la branche dev, " git pull " mettra à jour votre dev local au même point que la branche dev distante. Notez que toutes les branches seront récupérées, mais ne tirez que celle que vous avez sur le haut de l'arbre.
Lorsque vous faites "git clone git: // location", toutes les branches et les balises sont récupérées.
Pour pouvoir travailler sur une branche distante spécifique, en supposant qu'il s'agisse de la télécommande d'origine:
git checkout -b branch origin/branchname
Utilisez des alias. Bien qu’il n’y ait pas de one-liners Git natifs, vous pouvez définir le vôtre comme
git config --global alias.clone-branches '! git branch -a | sed -n "/\/HEAD /d; /\/master$/d; /remotes/p;" | xargs -L1 git checkout -t'
puis utilisez-le comme
git clone-branches
Pourquoi vous ne voyez que le "maître"
git clone
télécharge toutes les branches distantes distantes mais les considère toujours comme "distantes", même si les fichiers se trouvent dans votre nouveau référentiel. Il existe une exception à cette règle: le processus de clonage crée une branche locale appelée "maître". de la branche distante appelée "maître". Par défaut, branche git
affiche uniquement les branches locales. C’est pourquoi vous ne voyez que "maître".
branche git -a
affiche toutes les branches, y compris les branches distantes .
Comment obtenir des branches locales
Si vous souhaitez réellement travailler sur une branche, vous souhaiterez probablement un "local". version de celui-ci. Pour créer simplement des branches locales à partir de branches distantes (sans les extraire et donc modifier le contenu de votre répertoire de travail) , procédez comme suit:
git branch branchone origin/branchone
git branch branchtwo origin/branchtwo
git branch branchthree origin/branchthree
Dans cet exemple, branchone
est le nom d'une branche locale que vous créez en fonction de origin / branchone
; Si vous souhaitez plutôt créer des branches locales avec des noms différents, procédez comme suit:
git branch localbranchname origin/branchone
Une fois que vous avez créé une branche locale, vous pouvez la voir avec branche git
(rappelez-vous que vous n'avez pas besoin de -a
pour afficher les branches locales).
Ce n’est pas trop compliqué, les étapes les plus simples et les plus simples sont les suivantes;
origine de l'extraction git
Ceci amènera toutes les branches distantes chez votre local.
branche git -a
Ceci vous montrera toutes les branches distantes.
git checkout - suivez le chemin / / branche que vous souhaitez commander >
Vérifiez si vous vous trouvez dans la branche souhaitée à l'aide de la commande suivante:
git branch
La sortie ressemblera à ceci;
*your current branch
some branch2
some branch3
Notez le signe * qui indique la branche actuelle.
Mieux vaut tard que jamais, mais voici le meilleur moyen de le faire:
mkdir repo
cd repo
git clone --bare path/to/repo.git .git
git config --unset core.bare
git reset --hard
À ce stade, vous avez une copie complète du référentiel distant avec toutes ses branches (vérifiez avec branche git
). Vous pouvez utiliser - mirror
au lieu de - bare
si votre référentiel distant a ses propres télécommandes.
Faites ceci:
$ 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
Vous voyez, 'git clone git: //example.com/myprojectt' récupère tout, même les branches, il vous suffit de les commander, votre branche locale sera alors créée.
Vous devez uniquement utiliser " git clone " pour obtenir toutes les branches.
git clone <your_http_url>
Même si vous ne voyez que la branche master, vous pouvez utiliser " git branch -a " pour voir toutes les branches.
git branch -a
Et vous pouvez passer à n’importe quelle branche que vous avez déjà.
git checkout <your_branch_name>
Ne vous inquiétez pas après avoir cliqué sur "git clone", vous n'avez pas besoin de vous connecter au référentiel distant, "git branch -a". et " git checkout " peut être exécuté avec succès lorsque vous fermez votre wifi. Il est donc prouvé que lorsque vous faites "git clone", il a déjà copié toutes les branches du référentiel distant. Après cela, vous n'avez plus besoin du référentiel distant, votre section locale possède déjà tous les codes des branches.
Un git clone
est censé copier le référentiel entier. Essayez de le cloner, puis exécutez git branch -a
. Il devrait énumérer toutes les branches. Si vous souhaitez alors basculer vers la branche " foo " au lieu de "maître", utilisez git checkout foo
.
Utiliser mon outil git_remote_branch ( vous avez besoin de Ruby installé sur votre machine). Il a été spécialement conçu pour faciliter la manipulation des branches distantes.
Chaque fois qu’il effectue une opération pour vous, il l’imprime en rouge sur la console. Au fil du temps, ils restent finalement dans votre cerveau: -)
Si vous ne voulez pas que grb exécute des commandes en votre nom, utilisez simplement la fonction "expliquer". Les commandes seront imprimées sur votre console au lieu d’être exécutées pour vous.
Enfin, toutes les commandes ont des alias pour faciliter la mémorisation.
Notez qu'il s'agit du logiciel alpha ; -)
Voici l'aide lorsque vous exécutez 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
Toutes les réponses que j'ai vues ici sont valables, mais il existe un moyen beaucoup plus simple de cloner un référentiel et de tirer toutes les branches à la fois.
Lorsque vous clonez un référentiel, toutes les informations des branches sont effectivement téléchargées mais les branches sont masquées. Avec la commande
$ git branch -a
vous pouvez afficher toutes les branches du référentiel, et avec la commande
$ git checkout -b branchname origin/branchname
vous pouvez alors " télécharger " manuellement les un à la fois.
Cependant, lorsque vous souhaitez cloner un repo avec beaucoup de branches, toutes les manières illustrées ci-dessus sont longues et fastidieuses en ce qui concerne une manière beaucoup plus propre et plus rapide que je vais montrer, bien que ce soit un peu compliqué. Vous avez besoin de trois étapes pour y parvenir:
- Première étape
créez un nouveau dossier vide sur votre ordinateur et clonez une copie miroir du dossier .git à partir du référentiel:
$ cd ~/Desktop && mkdir my_repo_folder && cd my_repo_folder
$ git clone --mirror https://github.com/planetoftheweb/responsivebootstrap.git .git
le référentiel local à l'intérieur du dossier my_repo_folder est toujours vide, il ne reste plus qu'un dossier .git caché, que vous pouvez voir avec un " ls -al " commande du terminal.
- Deuxième étape
changez ce référentiel d’un référentiel vide à un référentiel normal en basculant la valeur booléenne " nue " des configurations git à false:
$ git config --bool core.bare false
- troisième étape
Prenez tout ce qui se trouve dans le dossier actuel et créez toutes les branches sur la machine locale, ce qui en fait un référentiel normal.
$ git reset --hard
Vous pouvez donc maintenant taper la commande " git branch " et vous pouvez voir que toutes les branches sont téléchargées.
C’est le moyen rapide par lequel vous pouvez cloner un référentiel git avec toutes les branches à la fois, mais ce n’est pas quelque chose que vous voulez faire de la sorte pour chaque projet.
En regardant l'une des réponses à la question, j'ai remarqué qu'il était possible de la raccourcir:
for branch in `git branch -r | grep -v 'HEAD\|master'`; do
git branch --track ${branch##*/} $branch;
done
Mais attention, si l’une des branches distantes est nommée par exemple. admin_master, il ne sera pas téléchargé!
Merci à bigfish pour son idée originale
Le clonage à partir d'un dépôt local ne fonctionnera pas avec git clone & amp; git fetch: beaucoup de branches / tags resteront non-récupérés.
Pour obtenir un clone avec toutes les branches et tous les tags.
git clone --mirror git://example.com/myproject myproject-local-bare-repo.git
Pour obtenir un clone avec toutes les branches et tous les tags, mais aussi avec une copie de travail:
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, lorsque vous clonez votre référentiel, vous y avez toutes les branches ...
Si vous ne faites que git branch
, ils sont en quelque sorte cachés ...
Donc, si vous souhaitez voir le nom de toutes les branches, ajoutez simplement - tout
comme ceci:
branche git - tout
ou branche git -a
Si vous ne faites que passer à la succursale, vous aurez tout ce dont vous avez besoin.
Mais qu'en est-il de la branche créée par quelqu'un d'autre après votre clonage?
Dans ce cas, il suffit de faire:
git fetch
et vérifiez à nouveau toutes les branches ...
Si vous souhaitez aller chercher et commander en même temps, vous pouvez faire:
git fetch & amp; & amp; git checkout your_branch_name
Vous avez également créé l'image ci-dessous pour simplifier ce que j'ai dit:
#!/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
Ces codes vont extraire tous les codes de branches distantes vers le dépôt local.
Pour copier-coller dans la ligne de commande:
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
Pour plus de lisibilité:
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
Cela va:
- consultez le maître (afin que nous puissions supprimer la branche sur laquelle nous nous trouvons)
- sélectionnez la télécommande pour passer à la caisse (remplacez-la par votre télécommande)
- parcourez toutes les branches de la télécommande, sauf maître et HEAD.
- supprimer une succursale locale (afin que nous puissions consulter les branches mises à jour de force)
- vérifier la branche de la télécommande
- consultez maître (pour le plaisir de le lire)
Je devais faire exactement la même chose. Voici mon 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]
J'ai écrit cette petite Powershell pour pouvoir extraire toutes mes branches git qui se trouvent sur la télécommande d'origine.
Function git-GetAllRemoteBranches {
iex "git branch -r" <# get all remote branches #> `
| % { J'ai écrit cette petite Powershell pour pouvoir extraire toutes mes branches git qui se trouvent sur la télécommande d'origine.
<*>
Vous trouverez d'autres fonctions git à l'adresse mes paramètres git. repo
-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 J'ai écrit cette petite Powershell pour pouvoir extraire toutes mes branches git qui se trouvent sur la télécommande d'origine.
<*>
Vous trouverez d'autres fonctions git à l'adresse mes paramètres git. repo
" } <# execute ' git checkout <branch>' #>
}
Vous trouverez d'autres fonctions git à l'adresse mes paramètres git. repo
Généralement, quand Git (non spécifié) récupère toutes les branches et / ou balises (réfs, voir: git ls-refs
) dans un ou plusieurs autres référentiels ainsi que les objets nécessaires pour compléter leur historique. En d'autres termes, il récupère les objets accessibles par les objets déjà téléchargés. Voir: Que fait vraiment git fetch
?
Parfois, vous pouvez avoir des branches / balises qui ne sont pas directement connectées à l'actuel. Ainsi, git pull --all
/ git fetch --all
ne le fera pas. aider dans ce cas, mais vous pouvez les lister par:
git ls-remote -h -t origin
et récupérez-les manuellement en connaissant les noms des références.
Pour les récupérer tous , essayez:
git fetch origin --depth=10000 $(git ls-remote -h -t origin)
Le paramètre - depth = 10000
peut vous aider si vous avez un référentiel peu profond.
Vérifiez à nouveau toutes vos branches:
git branch -avv
Si ce qui précède ne vous aide pas, vous devez ajouter manuellement les branches manquantes à la liste suivie (car elles se sont en quelque sorte égarées):
$ git remote -v show origin
...
Remote branches:
master tracked
par git set-branches distants
comme:
git remote set-branches --add origin missing_branch
afin qu'il puisse apparaître sous télécommandes / origine
après la récupération:
$ 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
Dépannage
Si vous ne pouvez toujours obtenir rien d'autre que la branche principale, vérifiez les éléments suivants:
- Vérifiez vos télécommandes (
git remote -v
), par exemple.- Vérifiez que
git config branch.master.remote
estorigine
. - Vérifiez si
origine
pointe vers la bonne URL via:origine de l'émission distante git
(voir ceci message ).
- Vérifiez que
Aucune de ces réponses ne le coupe, sauf que l'utilisateur n'est sur la bonne voie.
J'avais du mal à déplacer un dépôt d'un serveur / système à un autre. Lorsque j'ai cloné le référentiel, il n'a créé qu'une branche locale pour le maître. Ainsi, lorsque j'ai poussé vers la nouvelle télécommande, seule la branche maître a été poussée.
J'ai donc trouvé ces deux méthodes TRÈS utiles. J'espère qu'ils aident quelqu'un d'autre.
Méthode 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éthode 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
Utilisez des commandes dont vous vous souviendrez
J'utilise Bitbucket, un service d'hébergement de référentiel d'Atlassian. Alors j'essaie de suivre leurs docs. Et cela fonctionne parfaitement pour moi. Avec les commandes simples et courtes suivantes, vous pouvez vérifier votre succursale distante.
Commencez par cloner votre référentiel, puis accédez au dossier de destination. Et le dernier mais non le moindre, aller chercher et commander:
git clone <repo> <destination_folder>
cd <destination_folder>
git fetch && git checkout <branch>
C'est ça. Voici un petit exemple plus réaliste:
git clone https://username@bitbucket.org/team/repository.git project_folder
cd project_folder
git fetch && git checkout develop
Vous trouverez des informations détaillées sur les commandes dans la documentation: Commande de clonage , Commande Fetch , Commande Checkout
À partir de début 2017, la réponse dans ce commentaire fonctionne:
git chercher
désactive la branche. Bien que cela ne tire pas toutes les branches à la fois, vous pouvez exécuter cette opération individuellement par branche.
Voici une autre commande courte à une ligne qui crée des branches locales pour toutes les branches distantes:
(git branch -r | sed -n '/->/!s#^ origin/##p' && echo master) | xargs -L1 git checkout
Cela fonctionne également correctement si le suivi des branches locales est déjà créé.
Vous pouvez l’appeler après le premier git clone
ou à tout moment ultérieurement.
Si vous n'avez pas besoin d'avoir la branche master
extraite après le clonage, utilisez
git branch -r | sed -n '/->/!s#^ origin/##p'| xargs -L1 git checkout
git clone --mirror
sur le référentiel d'origine fonctionne bien pour cela.
git clone --mirror /path/to/original.git
git remote set-url origin /path/to/new-repo.git
git push -u origin