Faire une branche Git existante suivre une branche distante?

Je sais comment créer une nouvelle branche qui suit les branches distantes, mais comment faire pour qu'une branche existante suive une branche distante?

Je sais que je peux simplement modifier le .git/configfichier, mais il semble qu'il devrait y avoir un moyen plus simple.

Étant donné une branche fooet une télécommande upstream:

Depuis Git 1.8.0:

git branch -u upstream/foo

Ou, si la branche locale foon'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

Depuis Git 1.7.0:

git branch --set-upstream foo upstream/foo

Remarques:

• Toutes les commandes ci-dessus amèneront la branche locale fooà suivre la branche foodistante à distance upstream.
• 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 d'une branche en amont échouera lorsqu'elle sera exécutée sur des télécommandes nouvellement créées qui n'ont pas déjà été récupérées. Dans ce cas, exécutez git fetch upstreamau préalable.

Voir aussi: Pourquoi dois-je faire `--set-upstream` tout le temps?

Vous pouvez effectuer les opérations suivantes (en supposant que vous êtes extrait sur le maître et que vous souhaitez effectuer une transmission vers un maître de branche distant):

Configurez la «télécommande» si vous ne l'avez pas déjà

git remote add origin ssh://...

Maintenant, configurez maître pour savoir pour suivre:

git config branch.master.remote origin
git config branch.master.merge refs/heads/master

Et poussez:

git push origin master

Je fais cela comme un effet secondaire de pousser avec l' -uoption comme dans

$ git push -u origin branch-name

L'option longue équivalente est --set-upstream.

La git-branchcommande comprend également --set-upstream, mais son utilisation peut être déroutante. La version 1.8.0 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 le dire git branch --set-upstream origin/master, mais cela indique à Git d'organiser la branche locale "origine / maître" pour s'intégrer à la branche actuellement extraite, ce qui est très peu probable ce que l'utilisateur voulait dire. L'option est déconseillée; utilisez plutôt la nouvelle option --set-upstream-to(avec une -uoption courte et douce ).

Supposons que vous ayez une foobranche locale et que vous souhaitiez qu'elle traite la branche par le 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' git_remote_branchoutil utile. Il propose des commandes simples pour créer, publier, supprimer, suivre et renommer des branches distantes. Une fonctionnalité intéressante est que vous pouvez demander à une grbcommande d'expliquer quelles commandes git elle 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 crois que dès Git 1.5.x, vous pouviez faire en sorte qu'une branche locale suive $BRANCHune branche distante origin/$BRANCH, comme ceci.

Étant donné que $BRANCHet origin/$BRANCHexistez et que vous avez pas vérifié $BRANCH(interrupteur immédiatement si vous avez), faites:

git branch -f --track $BRANCH origin/$BRANCH

Cela recrée $BRANCHcomme une branche de suivi. La -fforce la création malgré $BRANCHdéjà existante. --trackest facultatif si les valeurs par défaut habituelles sont en place (c'est-à-dire que le paramètre git-config branch.autosetupmergeest vrai).

Remarque, s'il origin/$BRANCHn'existe pas encore, vous pouvez le créer en poussant votre local $BRANCHdans 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- Affichez vos succursales distantes et locales en utilisant: git branch -a , voir la capture d'écran suivante

3- passer à la branche cible que vous souhaitez relier à la télécommande: à l'aide

git checkout branchName

exemple :

4- Reliez votre succursale locale à une succursale distante en utilisant:

git branch --set-upstream-to nameOfRemoteBranch

NB: nameOfRemoteBranch : à copier depuis la sortie de l'étape 2 "git branch -r"

Exemple d'utilisation:

Assurez-vous de lancer:

git config push.default tracking

pouvoir pousser sans problème

L'édition .git/configest probablement le moyen le plus simple et le plus rapide. C'est ce que font de toute façon les commandes Git pour gérer les branches distantes.

Si vous ne voulez pas nettoyer le fichier à la main (et ce n'est pas si difficile à faire), vous pouvez toujours l'utiliser git configpour le faire ... mais encore une fois, cela ne fera que modifier le .git/configfichier, de toute façon.

Il existe bien sûr des moyens de suivre automatiquement une branche distante lors de son utilisation git checkout(en passant le --trackdrapeau, par exemple), mais ces commandes fonctionnent avec de nouvelles branches, pas celles existantes.

En très court

git branch --set-upstream yourLocalBranchName origin/develop

Cela fera de votre yourLocalBranchNamepiste 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 amènera Git à faire le foosuivi upstream/foo.

J'utilise la commande suivante (supposons que le nom de votre branche locale soit "nom-branche-local" et que le nom de la branche distante soit "nom-branche-distant"):

$ git branch --set-upstream-to=origin/branch-name-remote branch-name-local

Si les succursales locales et distantes ont le même nom, procédez comme suit:

$ git branch --set-upstream-to=origin/branch-name branch-name

Ici, en utilisant githubet git version 2.1.4, faites simplement:

$ git clone git@github.com: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: git@github.com:user/repo.git
  Push  URL: git@github.com: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 vérifier develp, il fera automatiquement la magie:

$ git checkout develop
Branch develop set up to track remote branch develop from origin.
Switched to a new branch 'develop'

Si facile!

Sommaire. Exécutez simplement ces 2 commandes:

$ git clone git@github.com:user/repo.git
$ git checkout develop

Utiliser 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 origin / remote-branch-name

Ce n'est pas une réponse directe à cette question, mais je voulais laisser une note ici pour toute personne qui pourrait avoir le même problème que moi lors de la tentative de configuration d'une branche en amont.

Méfiez-vous de push.default .

Avec les anciennes versions de git, la valeur par défaut correspondait , 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 en amont / maître

Si vous avez essayé de "git push" sur la branche "upstream", avec push.default, git essaierait automatiquement de fusionner la branche locale "master" en "upstream / master", provoquant beaucoup de chaos.

Cela donne un comportement plus sain d'esprit:

git config --global push.default en amont

D'une manière quelque peu liée, j'essayais d'ajouter une branche de suivi à distance à une branche existante, mais je n'avais pas accès à ce référentiel distant sur le système où je voulais ajouter cette branche de suivi à distance (car j'exporte fréquemment une copie de ce repo via sneakernet vers un autre système qui a accès pour pousser à 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 (donc le local ne savait pas que la branche existait sur la télécommande et j'obtiendrais l'erreur:) the requested upstream branch 'origin/remotebranchname' does not exist.

À la fin, j'ai réussi à ajouter la nouvelle branche distante auparavant inconnue (sans aller chercher) en ajoutant un nouveau fichier de tête à .git/refs/remotes/origin/remotebranchnamepuis en copiant la référence (le globe oculaire était le plus rapide, boiteux comme il l'était ;-) à partir du système avec accès à l'origine repo au poste de travail (avec le repo local où j'ajoutais la branche distante).

Une fois cela fait, je pourrais ensuite 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 jeter un œil au fichier de configuration pour voir ce qui suit quoi en exécutant:

 [za]$ git config -e

C'est aussi bien de le savoir, cela montre quelles branches sont suivies et lesquelles ne le sont pas. :

  [za]$ git remote show origin 

Pour toute personne qui, comme moi, veut 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)

Pour éviter de vous souvenir de ce que vous devez faire chaque fois que vous recevez le message:

Veuillez spécifier la branche avec laquelle vous souhaitez fusionner. Voir git-pull (1)
pour plus de détails.
.....

Vous pouvez utiliser le script suivant qui définit l' origine comme amont pour la branche actuelle dans laquelle vous vous trouvez.

Dans mon cas, je n'ai presque jamais défini autre chose que l'origine comme valeur par défaut en amont . De plus, je garde presque toujours le même nom de branche pour la branche locale et distante. Donc, ce qui me convient:

#!/bin/bash
# scriptname: git-branch-set-originupstream
current_branch="$(git branch | grep -oP '(?<=^\* )(.*)$')"
upstream="origin/$current_branch"
git branch -u "$upstream"

Cela fonctionnerait aussi

git branch --set-upstream-to=/< remote>/< branch> < localbranch>