Faire en sorte qu'une branche Git existante suive une branche distante?

vous pouvez faire ce qui suit (en supposant que vous êtes coché sur le master et que vous voulez passer à un master de branche distant):

configurer la télécommande si vous ne l'avez pas déjà

git remote add origin ssh://...

Maintenant configurer le maître de savoir à suivre:

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

et push:

git push origin master

je le fais comme un effet secondaire de la poussée avec l'option -u comme dans

$ git push -u origin branch-name

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

la commande git-branch comprend aussi --set-upstream , mais son utilisation peut prêter à confusion. Version 1.8.0 modifie l'interface.

git branch --set-upstream est déprécié et peut être supprimé dans un avenir relativement lointain. git branch [-u|--set-upstream-to] a été introduit avec un ordre plus sain des arguments.

...

il était tentant de dire git branch --set-upstream origin/master , mais cela dit à Git d'organiser la branche locale" origine/master " pour s'intégrer avec la branche actuellement vérifiée, ce qui est très peu probable ce que l'utilisateur voulait dire. L'option est dépréciée; utilisez plutôt la nouvelle option --set-upstream-to (avec une option courte et douce -u ).

dites que vous avez une branche locale foo et veulent qu'elle traite la branche du même nom que son amont. Faites-le 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 caractéristique intéressante est que vous pouvez demander à une commande grb 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 la réponse acceptée au travail:

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 pouvez faire une branche locale $BRANCH suivre une branche distante origin/$BRANCH , comme ceci.

étant donné que $BRANCH et origin/$BRANCH existent, et que vous n'avez pas encore coché $BRANCH (switch away si vous avez), faites:

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

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

Note, si origin/$BRANCH n'existe pas encore, vous pouvez le créer en poussant votre $BRANCH local dans le dépôt distant avec:

git push origin $BRANCH

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

1 - Mettez à jour vos métadonnées locales en utilisant: git fetch --all

2-montrez vos branches distantes et locales en utilisant: branche git-a , voir la capture d'écran suivante

3 - passez à la branche cible que vous souhaitez lié avec le à distance: en utilisant

git checkout branchName

exemple:

4 - relier votre branche locale à une branche distante en utilisant:

git branch --set-upstream-to nameOfRemoteBranch

N. B: nameOfRemoteBranch : copier à partir de la sortie de l'étape 2 "git branch-r "

exemple d'utilisation:

assurez-vous d'exécuter:

git config push.default tracking

pour être en mesure 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.

si vous ne voulez pas le muck avec 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, ça va juste éditer le fichier .git/config , de toute façon.

il y a, bien sûr, des moyens de suivre automatiquement une branche distante en utilisant git checkout (par passer le drapeau --track , par exemple), mais ces commandes fonctionnent avec les branches new , pas avec les branches existantes.

en très court

git branch --set-upstream yourLocalBranchName origin/develop

votre yourLocalBranchName tracera la branche distante appelée develop .

pour 1.6.x, il peut être fait en utilisant le git_remote_branch outil:

grb track foo upstream

qui fera que Git fera foo track upstream/foo .

ici, en utilisant github et git version 2.1.4 , faites juste:

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

et télécommandes viennent d'itelsef, même si elles ne sont pas relié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 payer develp, il 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 D'exécuter ces 2 commandes:

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

"--track " Option

• 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 example origin/example 

 git branch -u origin/remote-branch-name

d'une manière un peu similaire, j'essayais d'ajouter une branche de suivi à distance à une branche existante, mais je n'avais pas accès à ce dépôt à distance sur le système où je voulais ajouter cette branche de suivi à distance sur (parce que j'exporte souvent une copie de ce rapport via sneakernet à un autre système qui a l'accès de pousser sur cette télécommande). J'ai trouvé qu'il n'y avait aucun moyen de forcer l'ajout d'une branche éloignée sur le local qui n'avait pas encore été trouvé (donc local ne savait pas que la branche existe 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, jusqu'alors inconnue (sans la récupérer) en ajoutant un nouveau fichier principal à .git/refs/remotes/origin/remotebranchname et en copiant ensuite le ref (eyeballing was quickest, lame as it was ;-) à partir du système avec accès à l'origine repo à la station de travail (avec le repo local où j'ajoutais la branche distante activée).

une fois que cela a été fait, je pourrais alors utiliser git branch --set-upstream-to=origin/remotebranchname

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

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

si les deux branches locales et éloignées ont le même nom, alors faites juste ce qui suit:

$ git branch --set-upstream-to=origin/branch-name 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 en essayant de configurer une branche amont.

méfiez-vous de push.par défaut .

avec des versions plus anciennes de git, la valeur par défaut était correspondant à , ce qui provoquerait un comportement très indésirable si vous avez, par exemple:

Local de la branche "master" suivi jusqu'à l'origine / maître

à Distance "en amont", suivi en amont/master

si vous avez essayé de" git push "sur la branche" upstream", avec push.la correspondance par défaut git tenterait automatiquement de fusionner la branche locale "master" en "upstream/master", provoquant un grand chaos.

Cela donne plus de sane comportement:

git config -- global push.par défaut en amont

ou simplement par:

passez à la succursale si vous n'y êtes pas déjà:

[za]$ git checkout branch_name

exécuter

[za]$ git branch --set-upstream origin branch_name
Branch origin set up to track local branch brnach_name by rebasing.

et vous prêt à :

 [za]$ git push origin branch_name

vous pouvez toujours jeter un oeil au fichier de configuration pour voir ce qui suit ce qui en exécutant:

 [za]$ git config -e

il est également agréable de savoir cela, il montre quelles branches sont suivies et celles qui ne le sont pas. :

  [za]$ git remote show origin 

Ce serait trop de travail

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