Averigüe qué sucursal remota está rastreando una sucursal local

Ver también:
¿Cómo puedo ver qué ramas de Git están rastreando qué rama remota / aguas arriba?

¿Cómo puedo averiguar qué sucursal remota está rastreando una sucursal local?

¿Necesito analizar la git configsalida o hay un comando que haga esto por mí?

Aquí hay un comando que le brinda todas las ramas de seguimiento (configuradas para 'pull'), consulte:

$ git branch -vv
  main   aaf02f0 [main/master: ahead 25] Some other commit
* master add0a03 [jdsumsion/master] Some commit

Tiene que pasar por el SHA y cualquier mensaje de confirmación de envoltura larga, pero es rápido de escribir y obtengo las ramas de seguimiento alineadas verticalmente en la tercera columna.

Si necesita información sobre la configuración 'pull' y 'push' por rama, consulte la otra respuesta en git remote show origin.

Actualizar

A partir de la versión 1.8.5 de git, puede mostrar la rama ascendente con git statusygit status -sb

Dos opciones:

% git rev-parse --abbrev-ref --symbolic-full-name @{u}
origin/mainline

o

% git for-each-ref --format='%(upstream:short)' "$(git symbolic-ref -q HEAD)"
origin/mainline

Creo que git branch -avsolo te dice qué ramas tienes y en qué compromiso están, dejándote inferir qué ramas remotas están rastreando las ramas locales.

git remote show originle dice explícitamente qué ramas están rastreando qué ramas remotas. Aquí hay un ejemplo de salida de un repositorio con un solo commit y una rama remota llamada abranch:

$ git branch -av
* abranch                d875bf4 initial commit
  master                 d875bf4 initial commit
  remotes/origin/HEAD    -> origin/master
  remotes/origin/abranch d875bf4 initial commit
  remotes/origin/master  d875bf4 initial commit

versus

$ git remote show origin
* remote origin
  Fetch URL: /home/ageorge/tmp/d/../exrepo/
  Push  URL: /home/ageorge/tmp/d/../exrepo/
  HEAD branch (remote HEAD is ambiguous, may be one of the following):
    abranch
    master
  Remote branches:
    abranch tracked
    master  tracked
  Local branches configured for 'git pull':
    abranch merges with remote abranch
    master  merges with remote master
  Local refs configured for 'git push':
    abranch pushes to abranch (up to date)
    master  pushes to master  (up to date)

Actualización: Bueno, ¡han pasado varios años desde que publiqué esto! Para mi propósito específico de comparar HEAD con aguas arriba, ahora uso@{u} , que es un atajo que se refiere a HEAD de la rama de seguimiento de aguas arriba. (Ver https://git-scm.com/docs/gitrevisions#gitrevisions-emltbranchnamegtupstreamemegemmasterupstreamememuem ).

Respuesta original: También me he encontrado con este problema. A menudo uso múltiples controles remotos en un solo repositorio, y es fácil olvidar cuál es el seguimiento de su rama actual. Y a veces es útil saber eso, como cuando quieres ver tus confirmaciones locales a través de git log remotename/branchname..HEAD.

Todo esto se almacena en las variables de configuración de git, pero no tiene que analizar la salida de configuración de git. Si invoca git config seguido del nombre de una variable, solo imprimirá el valor de esa variable, no se requiere análisis. Con eso en mente, aquí hay algunos comandos para obtener información sobre la configuración de seguimiento de su sucursal actual:

LOCAL_BRANCH=`git name-rev --name-only HEAD`
TRACKING_BRANCH=`git config branch.$LOCAL_BRANCH.merge`
TRACKING_REMOTE=`git config branch.$LOCAL_BRANCH.remote`
REMOTE_URL=`git config remote.$TRACKING_REMOTE.url`

En mi caso, dado que solo estoy interesado en averiguar el nombre de mi control remoto actual, hago esto:

git config branch.`git name-rev --name-only HEAD`.remote

Las sucursales locales y sus controles remotos.

git branch -vv 

Todas las ramas y controles remotos de seguimiento.

git branch -a -vv

Vea dónde las ramas locales están configuradas explícitamente para push y pull.

git remote show {remote_name}

Esto le mostrará la rama en la que se encuentra:

$ git branch -vv

Esto mostrará solo la rama actual en la que se encuentra:

$ git for-each-ref --format='%(upstream:short)' $(git symbolic-ref -q HEAD)

por ejemplo:

myremote/mybranch

Puede encontrar la URL del control remoto que utiliza la rama actual con la que se encuentra:

$ git remote get-url $(git for-each-ref --format='%(upstream:short)' $(git symbolic-ref -q HEAD)|cut -d/ -f1)

por ejemplo:

https://github.com/someone/somerepo.git

Puede usar git checkout, es decir, "verifique la rama actual". Este es un no-op con efectos secundarios para mostrar la información de seguimiento, si existe, para la rama actual.

$ git checkout 
Your branch is up-to-date with 'origin/master'.

No sé si esto cuenta como analizar la salida de git config, pero esto determinará la URL del control remoto que el maestro está rastreando:

$ git config remote. $ (git config branch.master.remote) .url

Otra forma

git status -b --porcelain

Esto te dará

## BRANCH(...REMOTE)
modified and untracked files

Otra forma simple es usar

cat .git/config en un repositorio git

Esto enumerará los detalles de las sucursales locales.

Otro método (gracias osse), si solo quieres saber si existe o no:

if git rev-parse @{u} > /dev/null 2>&1
then
  printf "has an upstream\n"
else
  printf "has no upstream\n"
fi

git branch -vv | grep 'BRANCH_NAME'

git branch -vv : Esta parte mostrará todas las sucursales locales junto con su sucursal aguas arriba.

grep 'BRANCH_NAME' : Filtrará la rama actual de la lista de ramas.

git branch -r -vv

enumerará todas las ramas, incluso las remotas.

Enumera sucursales locales y remotas:

$ git branch -ra

Salida:

  feature/feature1
  feature/feature2
  hotfix/hotfix1
* master
  remotes/origin/HEAD -> origin/master
  remotes/origin/develop
  remotes/origin/master

La salida v2 de git-status porcelain (legible por máquina) se ve así:

$ git status -b --porcelain=v2
# branch.oid d0de00da833720abb1cefe7356493d773140b460
# branch.head the-branch-name
# branch.upstream gitlab/the-branch-name
# branch.ab +2 -2

Y para obtener la rama solo aguas arriba:

$ git status -b --porcelain=v2 | grep -m 1 "^# branch.upstream " | cut -d " " -f 3-
gitlab/the-branch-name

Si la rama no tiene flujo ascendente, el comando anterior producirá una salida vacía (o fallará set -o pipefail).

Si desea encontrar el flujo ascendente para cualquier rama (en lugar de solo en la que se encuentra), aquí hay una pequeña modificación a la respuesta de @ cdunn2001:

git rev-parse --abbrev-ref --symbolic-full-name YOUR_LOCAL_BRANCH_NAME@{upstream}

Eso le dará el nombre de la sucursal remota para la sucursal local nombrada YOUR_LOCAL_BRANCH_NAME.

Puedes probar esto:

git remote show origin | grep "branch_name"

branch_name necesita ser reemplazado con su sucursal

Yo uso este alias

git config --global alias.track '!sh -c "
if [ \$# -eq 2 ]
 then
   echo \"Setting tracking for branch \" \$1 \" -> \" \$2;
   git branch --set-upstream \$1 \$2;
 else
   git for-each-ref --format=\"local: %(refname:short) <--sync--> remote: %(upstream:short)\" refs/heads && echo --URLs && git remote -v;
fi  
" -'

entonces

git track

tenga en cuenta que el script también se puede usar para configurar el seguimiento.

Más alias geniales en https://github.com/orefalo/bash-profiles

Uso EasyGit (también conocido como "por ejemplo") como una envoltura súper liviana en la parte superior (o al costado de) Git. EasyGit tiene un subcomando de "información" que le brinda todo tipo de información súper útil, incluida la rama de seguimiento remoto de las sucursales actuales. Aquí hay un ejemplo (donde el nombre actual de la sucursal es "foo"):

pknotz @ s883422: (foo) ~ / workspace / bd
$ eg info
Compromisos totales: 175
Repositorio local: .git
Repositorios remotos nombrados: (nombre -> ubicación)
  origen -> git: //sahp7577/home/pknotz/bd.git
Sucursal actual: foo
  Suma de verificación criptográfica (sha1sum): bd248d1de7d759eb48e8b5ff3bfb3bb0eca4c5bf
  Depósito predeterminado de extracción / inserción: origen
  Opciones predeterminadas de extracción / inserción:
    branch.foo.remote = origen
    branch.foo.merge = refs / heads / aal_devel_1
  Número de contribuyentes: 3
  Número de archivos: 28
  Número de directorios: 20
  Tamaño de archivo más grande, en bytes: 32473 (pygooglechart-0.2.0 / COPYING)
  Compromete: 62

Mejorando esta respuesta , se me ocurrieron estos .gitconfigalias:

branch-name = "symbolic-ref --short HEAD"
branch-remote-fetch = !"branch=$(git branch-name) && git config branch.\"$branch\".remote || echo origin #"
branch-remote-push  = !"branch=$(git branch-name) && git config branch.\"$branch\".pushRemote || git config remote.pushDefault || git branch-remote-fetch #"
branch-url-fetch = !"remote=$(git branch-remote-fetch) && git remote get-url        \"$remote\" #"  # cognizant of insteadOf
branch-url-push  = !"remote=$(git branch-remote-push ) && git remote get-url --push \"$remote\" #"  # cognizant of pushInsteadOf

Si estás usando Gradle,

def gitHash = new ByteArrayOutputStream()
    project.exec {
        commandLine 'git', 'rev-parse', '--short', 'HEAD'
        standardOutput = gitHash
    }

def gitBranch = new ByteArrayOutputStream()
    project.exec {
        def gitCmd = "git symbolic-ref --short -q HEAD || git branch -rq --contains "+getGitHash()+" | sed -e '2,\$d'  -e 's/\\(.*\\)\\/\\(.*\\)\$/\\2/' || echo 'master'"
        commandLine "bash", "-c", "${gitCmd}"
        standardOutput = gitBranch
    }

El siguiente comando se referirá a la bifurcación actual de origen remoto.

git remote -v

Para agregar una ruta remota,

git remote add origin nombre_ruta