Faire une branche Git existante suivre une branche distante?
Je sais comment créer une nouvelle branche qui suit les branches distantes, mais comment puis-je faire en sorte qu'une branche existante suive une branche distante?
Je sais que je peux simplement éditer le fichier .git/config, mais il me semble qu’il devrait exister un moyen plus simple.
Étant donné une branche foo et une télécommande upstream:
À partir de Git 1.8.0:
git branch -u upstream/foo
Ou, si la branche locale foo n'est pas la branche actuelle:
git branch -u upstream/foo foo
Ou, si vous aimez taper des commandes plus longues, celles-ci sont équivalentes aux deux précédentes:
git branch --set-upstream-to=upstream/foo
git branch --set-upstream-to=upstream/foo foo
À partir de Git 1.7.0:
git branch --set-upstream foo upstream/foo
Notes:
- Toutes les commandes ci-dessus obligeront la branche locale
fooà suivre la branche distantefooà partir de la télécommandeupstream. - L'ancienne syntaxe (1.7.x) est déconseillée au profit de la nouvelle syntaxe (1.8+). La nouvelle syntaxe se veut plus intuitive et plus facile à mémoriser.
- La définition de l'amont échouera avec les télécommandes nouvellement créées qui n'ont pas été extraites. Dans ce cas, exécutez
git fetch upstreamau préalable.
Voir aussi: Pourquoi ai-je besoin de faire `--set-upstream` tout le temps?
Vous pouvez effectuer les opérations suivantes (en supposant que vous soyez extrait sur le maître et que vous souhaitiez passer à un maître de branche distant):
Configurez la 'télécommande' si vous ne l'avez pas déjà
git remote add Origin ssh://...
Configurez maintenant maître pour savoir suivre:
git config branch.master.remote Origin
git config branch.master.merge refs/heads/master
Et pousser:
git Push Origin master
Je fais cela comme un effet secondaire de pousser avec l'option -u comme dans
$ git Push -u Origin branch-name
L'option longue équivalente est --set-upstream.
La commande git-branch comprend également --set-upstream, mais son utilisation peut prêter à confusion. Version 1.8. modifie l'interface.
git branch --set-upstreamest obsolète et peut être supprimé dans un avenir relativement lointain.git branch [-u|--set-upstream-to]a été introduit avec un ordre d'arguments plus sain.…
Il était tentant de dire
git branch --set-upstream Origin/master, mais cela dit à Git de faire en sorte que la branche locale "Origin/master" soit intégrée à la branche actuellement extraite, ce qui est très peu probable de la signification de l'utilisateur. L'option est obsolète. utilisez plutôt la nouvelle option--set-upstream-to(avec un raccourci-doux-u).
Supposons que vous ayez une branche locale foo et que vous souhaitiez qu'elle traite la branche du même nom que son amont. Faites que cela se produise avec
$ git branch foo
$ git branch --set-upstream-to=Origin/foo
ou juste
$ git branch --set-upstream-to=Origin/foo foo
Vous pourriez trouver l’outil git_remote_branch utile. Il offre des commandes simples pour créer, publier, supprimer, suivre et renommer des branches distantes. Une fonctionnalité intéressante est que vous pouvez demander à une commande grb d'expliquer les commandes git qu'il exécuterait.
_grb explain create my_branch github
# git_remote_branch version 0.3.0
# List of operations to do to create a new remote branch and track it locally:
git Push github master:refs/heads/my_branch
git fetch github
git branch --track my_branch github/my_branch
git checkout my_branch
_En fait, pour que la réponse acceptée fonctionne:
git remote add upstream <remote-url>
git fetch upstream
git branch -f --track qa upstream/qa
# OR:
git branch --set-upstream qa upstream/qa
Je pense que dès Git 1.5.x, une branche locale $BRANCH devrait suivre une branche distante Origin/$BRANCH, comme celle-ci.
Étant donné que $BRANCH et Origin/$BRANCH existent et que vous n'avez pas encore extrait $BRANCH (changez de position si vous en avez), effectuez les actions suivantes:
git branch -f --track $BRANCH Origin/$BRANCH
Ceci recrée $BRANCH en tant que branche de suivi. Le -f force la création alors que $BRANCH existe déjà. --track est facultatif si les valeurs par défaut habituelles sont en place (en d'autres termes, le paramètre git-config branch.autosetupmerge est true).
Remarque, si Origin/$BRANCH n'existe pas encore, vous pouvez le créer en poussant votre $BRANCH dans le référentiel distant avec:
git Push Origin $BRANCH
Suivi de la commande précédente pour promouvoir la branche locale en une branche de suivi.
1- mettez à jour vos méta-données locales en utilisant: git fetch --all
2- montrez vos branches distantes et locales en utilisant: git branch -a , voir la capture d'écran suivante
3- Passez à la branche cible que vous souhaitez lier avec la télécommande: en utilisant
git checkout branchName
exemple :
4- Liez votre agence locale à une agence distante en utilisant:
git branch --set-upstream-to nameOfRemoteBranch
N.B: nameOfRemoteBranch : pour copier depuis la sortie de l'étape 2 "git branch -r"
Exemple d'utilisation:
Assurez-vous de courir:
git config Push.default tracking
être capable de pousser sans problème
Éditer .git/config est probablement le moyen le plus simple et le plus rapide. C'est ce que font les commandes Git pour gérer les branches distantes, de toute façon.
Si vous ne voulez pas gâcher le fichier à la main (et ce n'est pas si difficile à faire), vous pouvez toujours utiliser git config pour le faire ... mais encore une fois, cela va simplement éditer le .git/config fichier, de toute façon.
Il existe bien sûr des moyens de suivre automatiquement une branche distante lorsqu’on utilise git checkout (en passant le drapeau --track, par exemple), mais ces commandes fonctionnent avec new branches, pas ceux existants.
En très court
git branch --set-upstream yourLocalBranchName Origin/develop
Ainsi, votre yourLocalBranchName suivra la branche distante appelée develop.
Pour 1.6.x, cela peut être fait en utilisant l’outil git_remote_branch :
grb track foo upstream
Cela obligera Git à faire foo piste upstream/foo.
J'utilise la commande suivante (supposons que votre nom de branche locale soit "branche-nom-local" et que le nom de branche distante soit "branche-nom-distant"):
$ git branch --set-upstream-to=Origin/branch-name-remote branch-name-local
Si les branches locale et distante portent le même nom, procédez comme suit:
$ git branch --set-upstream-to=Origin/branch-name branch-name
Ici, en utilisant github et git version 2.1.4, faites juste:
$ git clone [email protected]:user/repo.git
Et les télécommandes viennent par itelsef, même si elles ne sont pas liées localement:
$ git remote show Origin
* remote Origin
Fetch URL: [email protected]:user/repo.git
Push URL: [email protected]:user/repo.git
HEAD branch: master
Remote branches:
develop tracked <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
master tracked
Local branch configured for 'git pull':
master merges with remote master
Local ref configured for 'git Push':
master pushes to master (up to date)
Mais bien sûr, toujours pas de branche locale:
$ git branch
* master <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
Voir? Maintenant, si vous venez de valider votre commande develp, la magie s’effectuera automatiquement:
$ git checkout develop
Branch develop set up to track remote branch develop from Origin.
Switched to a new branch 'develop'
Si facile!
Résumé. Il suffit d’exécuter ces 2 commandes:
$ git clone [email protected]:user/repo.git
$ git checkout develop
Utilisez l'option '--track'
Après un
git pull:git checkout --track <remote-branch-name>Ou:
git fetch && git checkout <branch-name>
Pour créer une nouvelle branche, nous pourrions utiliser la commande suivante
git checkout --track -b exemple Origine/exemple
git branch -u Origine/nom-branche-distante
Ce n'est pas une réponse directe à cette question, mais je voulais laisser une note ici à toute personne susceptible d'avoir le même problème que moi lors de la configuration d'une branche en amont.
Méfiez-vous de Push.default.
Avec les anciennes versions de git, la valeur par défaut était matching, ce qui provoquerait un comportement très indésirable si vous avez, par exemple:
Suivi "maître" de la succursale locale vers l’origine/le maître
Suivi "amont" de la branche distante vers l'amont/maître
Si vous avez essayé de "git Push" lorsque vous êtes sur la branche "amont", avec correspondance Push.default, git tentera automatiquement de fusionner la branche locale "maître" en "amont/maître", ce qui entraînera beaucoup de chaos.
Cela donne un comportement plus sain:
git config --global Push.default en amont
D'une manière assez similaire, j'essayais d'ajouter une branche de suivi distante à une branche existante, mais je n'avais pas accès à ce référentiel distant sur le système sur lequel je voulais ajouter cette branche de suivi distante (car j'exporte souvent une copie de ce fichier). repo via Sneakernet vers un autre système ayant l’accès à Push vers cette télécommande). J'ai trouvé qu'il n'y avait aucun moyen de forcer l'ajout d'une branche distante sur le local qui n'avait pas encore été récupérée (le local ne savait donc pas que la branche existait déjà et j'obtiendrais l'erreur: the requested upstream branch 'Origin/remotebranchname' does not exist).
En fin de compte, j’ai réussi à ajouter la nouvelle branche distante (jusque-là inconnue), auparavant inconnue, en ajoutant un nouveau fichier de tête sous .git/refs/remotes/Origin/remotebranchname, puis en copiant l’arbitre (le regard était plus rapide, aussi boiteux qu’il était ;-) du système avec accès au référentiel d’origine sur le poste de travail (avec le référentiel local où j’ajoutais la branche distante).
Une fois cela fait, je pourrais alors utiliser git branch --set-upstream-to=Origin/remotebranchname
ou simplement par:
passez à la branche si vous n'y êtes pas déjà:
[za]$ git checkout branch_name
courir
[za]$ git branch --set-upstream Origin branch_name
Branch Origin set up to track local branch brnach_name by rebasing.
et vous êtes prêt à:
[za]$ git Push Origin branch_name
Vous pouvez toujours regarder le fichier de configuration pour voir ce qui est suivi, en lançant:
[za]$ git config -e
C'est bien aussi de savoir cela, il montre quelles branches sont suivies et lesquelles ne le sont pas. :
[za]$ git remote show Origin
Pour ceux qui, comme moi, souhaitent simplement synchroniser le nom de votre branche locale avec le nom de la branche distante, voici une commande pratique:
git branch -u Origin/$(git rev-parse --abbrev-ref HEAD)