Faire une twig Git existante suivre une twig distante?

Étant donné une twig foo et une télécommande en upstream :

À partir de Git 1.8.0:

 git branch -u upstream/foo 

Ou, si la twig locale foo n’est pas la twig actuelle:

 git branch -u upstream/foo foo 

Ou, si vous souhaitez 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 

A partir de Git 1.7.0:

 git branch --set-upstream foo upstream/foo 

Remarques:

Toutes les commandes ci-dessus entraîneront la twig locale foo à suivre les twigs distantes de l’ 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.

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

Vous pouvez faire ce qui suit (en supposant que vous êtes extrait sur le maître et que vous voulez transférer vers un maître de succursale distant):

Configurez la télécommande si vous ne l’avez pas déjà

 git remote add origin ssh://... 

Configurez maintenant le maître pour qu’il sache:

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

Et poussez:

 git push origin master 

Je le fais 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 être source de confusion. La version 1.8.0 modifie l’interface.

git branch --set-upstream est obsolète et peut être supprimé dans un avenir relativement éloigné. git branch [-u|--set-upstream-to] a été introduit avec un plus grand nombre d’arguments.

…

Il était tentant de dire que git branch --set-upstream origin/master , mais cela dit à Git de faire en sorte que la twig locale “origine / master” s’intègre à la twig actuellement extraite, ce qui est très improbable. L’option est obsolète; utilisez plutôt la nouvelle option --set-upstream-to (avec un raccourci-et-doux).

Supposons que vous ayez une twig foo locale et que vous souhaitiez qu’elle traite la twig avec le même nom que son amont. Faites cela 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 twigs distantes. Une fonctionnalité intéressante est que vous pouvez demander à une commande grb d’expliquer quelles commandes git elle doit exécuter.

 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 la réponse acceptée au travail:

 git remote add upstream  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 pourriez faire en sorte qu’une twig locale $BRANCH une origin/$BRANCH succursale distante origin/$BRANCH , comme ceci.

Étant donné que $BRANCH et origin/$BRANCH existent, et que vous n’avez pas encore sorti $BRANCH (changez si vous en avez), faites:

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

Cela recrée $BRANCH comme une twig de suivi. Le -f force la création malgré que $BRANCH existe déjà. --track est facultatif si les valeurs par défaut habituelles sont en place (c’est-à-dire que le paramètre git-config branch.autosetupmerge est true).

Notez que si origin/$BRANCH n’existe pas encore, vous pouvez le créer en plaçant votre $BRANCH local dans le référentiel distant avec:

 git push origin $BRANCH 

Suivi de la commande précédente pour promouvoir la twig locale dans une twig de suivi.

1- mettre à jour vos méta-données locales en utilisant: git fetch –all

2- montre vos twigs locales et distantes en utilisant: git branch -a , voir la capture d’écran suivante

3- passer à la twig cible, que vous voulez associer à la télécommande: en utilisant

git checkout branchName

Exemple :

4- Liez votre twig locale à une twig 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 courir:

 git config push.default tracking 

être capable de pousser sans problème

L’édition de .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 twigs distantes.

Si vous ne voulez pas utiliser 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 modifier le fichier .git/config , en tous cas.

Il existe bien sûr des moyens de suivre automatiquement une twig distante lors de l’utilisation de git checkout (en passant le drapeau --track , par exemple), mais ces commandes fonctionnent avec de nouvelles twigs, pas existantes.

Très court

 git branch --set-upstream yourLocalBranchName origin/develop 

Cela fera de yourLocalBranchName suivre la twig distante appelée develop .

Pour 1.6.x, vous pouvez utiliser l’outil git_remote_branch :

 grb track foo upstream 

Cela obligera Git à faire foo track en upstream/foo .

Ici, en utilisant github et git version 2.1.4 , faites simplement:

 $ 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 twigs: 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 twig locale:

 $ git branch * master <<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 

Voir? Maintenant, si vous venez de vérifier develp, cela fera la magie 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 de lancer 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

• Ou:

  git fetch && git checkout

Pour créer une nouvelle twig, nous pourrions utiliser la commande suivante

  git checkout --track -b exemple origine / exemple 

Pour que la twig déjà créée crée un lien entre distant puis depuis cette twig, utilisez la commande ci-dessous

  git branch -u origine / nom-twig-distante 

De manière quelque peu similaire, j’essayais d’append une twig de suivi à distance à une succursale existante, mais je n’avais pas access à ce référentiel distant sur le système sur lequel je voulais append cette twig de suivi à distance (car j’exporte fréquemment une copie de ce répertoire). repo via sneakernet vers un autre système ayant access à cette télécommande). J’ai trouvé qu’il n’y avait aucun moyen de forcer l’ajout d’une twig distante sur le local qui n’avait pas encore été récupéré (donc local ne savait pas que la twig 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 à append la nouvelle twig distante précédemment inconnue (sans aller chercher) en ajoutant un nouveau fichier principal à .git/refs/remotes/origin/remotebranchname , puis en copiant la référence (eyeballing était plus rapide que ça; -) du système avec access au référentiel d’origine au poste de travail (avec le référentiel local où j’ajoutais la twig distante).

Une fois cela fait, je pourrais alors utiliser git branch --set-upstream-to=origin/remotebranchname

J’utilise la commande suivante (Supposons que le nom de votre twig locale soit “nom-twig-local” et que le nom de la twig distante soit “nom-twig-distant”):

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

Si les deux twigs locale et distante portent le même nom, procédez comme suit:

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

Ce n’est pas une réponse directe à cette question, mais je voulais laisser une note ici à toute personne qui pourrait avoir le même problème que moi en essayant de configurer une twig en amont.

Méfiez-vous de push.default .

Avec les anciennes versions de git, la correspondance était par défaut, ce qui provoquerait un comportement très indésirable si vous aviez, par exemple:

Suivi de la twig “master” d’origine / master

Suivi de la twig distante “en amont” vers l’amont / le maître

Si vous essayez de “git push” sur la twig “upstream”, avec push.default, la correspondance de git essaiera automatiquement de fusionner la twig “master” en “upstream / master”, provoquant beaucoup de chaos.

Cela donne un comportement plus sain:

git config –global push.default en amont

ou simplement par:

passez à la twig 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 suit en exécutant:

  [za]$ git config -e 

Il est également intéressant de savoir cela, il montre quelles twigs sont suivies et lesquelles ne le sont pas. :

  [za]$ git remote show origin 

Cela fonctionnerait aussi

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