¿Hacer que una rama Git existente rastree una rama remota?

Sé cómo hacer una nueva sucursal que rastrea sucursales remotas, pero ¿cómo hago para que una sucursal existente rastree una sucursal remota?

Sé que puedo editar el .git/configarchivo, pero parece que debería haber una manera más fácil.

Dada una rama fooy un control remoto upstream:

A partir de Git 1.8.0:

git branch -u upstream/foo

O, si la rama local foono es la rama actual:

git branch -u upstream/foo foo

O, si desea escribir comandos más largos, estos son equivalentes a los dos anteriores:

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

Notas:

• Todos los comandos anteriores harán que la rama local rastree la rama fooremota foodesde la remota upstream.
• La sintaxis anterior (1.7.x) está en desuso a favor de la nueva sintaxis (1.8+). La nueva sintaxis pretende ser más intuitiva y más fácil de recordar.
• La definición de una rama ascendente fallará cuando se ejecute contra controles remotos recién creados que aún no se han recuperado. En ese caso, corre de git fetch upstreamantemano.

Ver también: ¿Por qué necesito hacer `--set-upstream` todo el tiempo?

Puede hacer lo siguiente (suponiendo que esté desprotegido en el maestro y desee pasar a un maestro de sucursal remoto):

Configure el 'control remoto' si aún no lo tiene

git remote add origin ssh://...

Ahora configure master para saber rastrear:

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

Y empujar:

git push origin master

Hago esto como un efecto secundario de presionar con la -uopción como en

$ git push -u origin branch-name

La opción larga equivalente es --set-upstream .

El git-branchcomando también comprende --set-upstream, pero su uso puede ser confuso. La versión 1.8.0 modifica la interfaz.

git branch --set-upstream está en desuso y puede eliminarse en un futuro relativamente lejano. git branch [-u|--set-upstream-to]ha sido introducido con un orden más racional de argumentos.

...

Fue tentador decirlo git branch --set-upstream origin/master, pero eso le dice a Git que organice la rama local "origen / maestro" para que se integre con la rama actualmente desprotegida, lo cual es muy poco probable a qué se refería el usuario. La opción está en desuso; use la nueva opción --set-upstream-to(con una -uopción corta y dulce ) en su lugar.

Supongamos que tiene una foosucursal local y desea que trate a la sucursal con el mismo nombre que en sentido ascendente. Haz que esto suceda con

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

o solo

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

Puede encontrar la git_remote_branchherramienta útil. Ofrece comandos simples para crear, publicar, eliminar, rastrear y renombrar sucursales remotas. Una buena característica es que puedes pedirle a un grbcomando que explique qué comandos git ejecutaría.

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 realidad, para que la respuesta aceptada funcione:

git remote add upstream <remote-url>
git fetch upstream
git branch -f --track qa upstream/qa
# OR:
git branch --set-upstream qa upstream/qa

Creo que ya en Git 1.5.x podría hacer una sucursal local $BRANCH rastreara una sucursal remota origin/$BRANCH, como esta.

Teniendo en cuenta eso $BRANCHy origin/$BRANCHexiste, y actualmente no ha desprotegido $BRANCH(cámbielo si lo ha hecho), haga lo siguiente:

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

Esto se recrea $BRANCHcomo una rama de seguimiento. Las -ffuerzas de la creación a pesar de $BRANCHexistir ya. --trackes opcional si los valores predeterminados habituales están establecidos (es decir, el parámetro git-configbranch.autosetupmerge es verdadero).

Tenga en cuenta que si origin/$BRANCHaún no existe, puede crearlo empujando su local $BRANCHal repositorio remoto con:

git push origin $BRANCH

Seguido por el comando anterior para promover la rama local en una rama de seguimiento.

1- actualiza tus metadatos locales usando: git fetch --todos

2- muestra tus sucursales remotas y locales usando: git branch -a , mira la siguiente captura de pantalla

3- cambia a la rama de destino que deseas vincular con el control remoto: usando

git checkout branchName

ejemplo:

4- Vincula tu sucursal local a una sucursal remota usando:

git branch --set-upstream-to nameOfRemoteBranch

NB: nameOfRemoteBranch : para copiar desde la salida del paso 2 "git branch -r"

Ejemplo de uso:

Asegúrate de ejecutar:

git config push.default tracking

para poder empujar sin problemas

La edición .git/configes probablemente la forma más fácil y rápida. De todos modos, eso es lo que hacen los comandos Git para manejar ramas remotas.

Si no quiere manipular el archivo a mano (y no es tan difícil de hacer), siempre puede usarlo git config... pero, de nuevo, eso solo va a editar el .git/configarchivo, de todos modos.

Por supuesto, hay formas de rastrear automáticamente una rama remota cuando se usa git checkout(pasando la --trackbandera, por ejemplo), pero estos comandos funcionan con ramas nuevas , no existentes.

En muy corto

git branch --set-upstream yourLocalBranchName origin/develop

Esto hará que su yourLocalBranchNamepista sea la rama remota llamada develop.

Para 1.6.x, se puede hacer usando la herramienta git_remote_branch :

grb track foo upstream

Eso hará que Git haga un fooseguimiento upstream/foo.

Uso el siguiente comando (supongamos que el nombre de su sucursal local es "nombre-sucursal-local" y el nombre de la sucursal remota es "nombre-sucursal-remoto"):

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

Si las ramas locales y remotas tienen el mismo nombre, simplemente haga lo siguiente:

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

Aquí, usando githubygit version 2.1.4 , simplemente haz:

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

Y los controles remotos vienen por sí mismos, incluso si no están vinculados localmente:

$ 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)

Pero, por supuesto, todavía no hay sucursal local:

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

¿Ver? Ahora, si acaba de finalizar el desarrollo, hará la magia automáticamente:

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

¡Tan fácil!

Resumen. Simplemente ejecute estos 2 comandos:

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

Use la opción '--track'

• Después de un git pull:

  git checkout --track <remote-branch-name>

• O:

  git fetch && git checkout <branch-name>

Para crear una nueva rama, podríamos usar el siguiente comando

 git checkout --track -b ejemplo origen / ejemplo 

 git branch -u origin / remote-branch-name

Esta no es una respuesta directa a esta pregunta, pero quería dejar una nota aquí para cualquiera que pueda tener el mismo problema que yo al intentar configurar una rama ascendente.

Tenga cuidado con push.default .

Con versiones anteriores de git, el valor predeterminado era la coincidencia , lo que causaría un comportamiento muy indeseable si tiene, por ejemplo:

Sucursal local "master" que sigue al origen / master

Rastreo remoto "ascendente" de seguimiento a ascendente / maestro

Si trató de "git push" cuando estaba en la rama "aguas arriba", con push.default match git intentaría fusionar automáticamente la rama local "master" en "upstream / master", causando mucho caos.

Esto da un comportamiento más sensato:

git config - global push.default upstream

De alguna manera relacionada, estaba tratando de agregar una rama de seguimiento remoto a una rama existente, pero no tenía acceso a ese repositorio remoto en el sistema donde quería agregar esa rama de seguimiento remoto (porque con frecuencia exporto una copia de este repo a través de sneakernet a otro sistema que tenga acceso para enviar a ese control remoto). Descubrí que no había forma de forzar la adición de una rama remota en el local que aún no se había obtenido (por lo que local no sabía que la rama existía en el remoto y obtendría el error:) the requested upstream branch 'origin/remotebranchname' does not exist.

Al final, logré agregar la nueva rama remota, previamente desconocida (sin recuperar) agregando un nuevo archivo de encabezado en .git/refs/remotes/origin/remotebranchnamey luego copiando la referencia (la observación fue más rápida, aburrida como era ;-) desde el sistema con acceso al origen repositorio a la estación de trabajo (con el repositorio local donde estaba agregando la rama remota).

Una vez hecho eso, podría usar git branch --set-upstream-to=origin/remotebranchname

o simplemente por:

cambia a la rama si aún no estás en ella:

[za]$ git checkout branch_name

correr

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

y listo para:

 [za]$ git push origin branch_name

Puede alawys echar un vistazo al archivo de configuración para ver qué está rastreando qué ejecutando:

 [za]$ git config -e

También es bueno saber esto, muestra qué ramas se rastrean y cuáles no. :

  [za]$ git remote show origin 

Para cualquiera que, como yo, solo quiera sincronizar el nombre de su sucursal local con el nombre de la sucursal remota, aquí hay un comando útil:

git branch -u origin/$(git rev-parse --abbrev-ref HEAD)

Para evitar recordar lo que debe hacer cada vez que recibe el mensaje:

Especifique con qué rama desea fusionarse. Ver git-pull (1)
para más detalles.
.....

Puede usar el siguiente script que establece el origen como ascendente para la rama actual en la que se encuentra.

En mi caso, casi nunca configuro otra cosa que no sea origen como el flujo ascendente predeterminado . También casi siempre mantengo el mismo nombre de sucursal para sucursal local y remota. Entonces lo siguiente me queda bien:

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

Esto también funcionaría

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