Scopri quale filiale remota sta seguendo una filiale locale

Vedi anche:
Come posso vedere quali rami Git stanno monitorando quale ramo remoto / upstream?

Come posso sapere quale filiale remota sta seguendo una filiale locale?

Devo analizzare l' git configoutput o c'è un comando che lo farebbe per me?

Ecco un comando che ti dà tutti i rami di tracciamento (configurato per 'pull'), vedi:

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

Devi passare in rassegna SHA e tutti i messaggi di commit a capo lungo, ma è veloce da digitare e ottengo i rami di tracciamento allineati verticalmente nella terza colonna.

Se hai bisogno di informazioni su entrambe le configurazioni 'pull' e 'push' per ramo, vedi l'altra risposta git remote show origin.

Aggiornare

A partire dalla versione 1.8.5 di git è possibile mostrare il ramo upstream con git statusegit status -sb

Due scelte:

% 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

Penso che git branch -avti dica solo in quali rami hai e in quale impegno si trovano, lasciandoti a dedurre quali rami remoti stanno seguendo i rami locali.

git remote show originti dice esplicitamente quali rami stanno monitorando quali rami remoti. Ecco un esempio di output da un repository con un singolo commit e un ramo remoto chiamato 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

contro

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

Aggiornamento: Beh, sono passati diversi anni da quando l'ho pubblicato! Per il mio scopo specifico di confrontare HEAD con l'upstream, ora uso @{u}, che è una scorciatoia che si riferisce all'HEAD del ramo di tracciamento dell'upstream. (Vedi https://git-scm.com/docs/gitrevisions#gitrevisions-emltbranchnamegtupstreamemegemmasterupstreamememuem ).

Risposta originale: ho riscontrato anche questo problema. Uso spesso più telecomandi in un unico repository, ed è facile dimenticare quale è il tuo ramo attuale su cui sta monitorando. E a volte è utile saperlo, ad esempio quando si desidera guardare i propri impegni locali tramite git log remotename/branchname..HEAD.

Tutto questo materiale è archiviato nelle variabili git config, ma non è necessario analizzare l'output di git config. Se invochi git config seguito dal nome di una variabile, stamperà semplicemente il valore di quella variabile, non è necessario alcun analisi. Tenendo presente ciò, ecco alcuni comandi per ottenere informazioni sulla configurazione di tracciamento della filiale corrente:

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`

Nel mio caso, poiché sono interessato solo a scoprire il nome del mio telecomando attuale, lo faccio:

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

Le filiali locali e i loro telecomandi.

git branch -vv 

Tutti i rami e i telecomandi di tracciamento.

git branch -a -vv

Scopri dove i rami locali sono esplicitamente configurati per push e pull.

git remote show {remote_name}

Questo ti mostrerà il ramo in cui ti trovi:

$ git branch -vv

Questo mostrerà solo l'attuale ramo in cui ti trovi:

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

per esempio:

myremote/mybranch

Puoi scoprire l'URL del telecomando utilizzato dal ramo corrente con cui ti trovi:

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

per esempio:

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

È possibile utilizzare git checkout, ad esempio "controlla il ramo corrente". Questa è una no-op con effetti collaterali per mostrare le informazioni di tracciamento, se esistenti, per il ramo corrente.

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

Non so se questo conta come l'analisi dell'output di git config, ma questo determinerà l'URL del telecomando che il master sta monitorando:

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

Ancora un altro modo

git status -b --porcelain

Questo ti darà

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

Un altro modo semplice è usare

cat .git/config in un repository git

Questo elencherà i dettagli per le filiali locali

Un altro metodo (grazie osse), se vuoi solo sapere se esiste o meno:

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 : Questa parte mostrerà tutte le filiali locali insieme alla loro filiale a monte.

grep 'BRANCH_NAME' : Filtrerà il ramo corrente dall'elenco dei rami.

git branch -r -vv

elencherà tutti i rami incluso il telecomando.

Elenca le filiali locali e remote:

$ git branch -ra

Produzione:

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

L'output v2 di porcellana git-status (leggibile dalla macchina) è simile al seguente:

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

E per ottenere il ramo solo a monte:

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

Se il ramo non ha upstream, il comando sopra produrrà un output vuoto (o fallirà con set -o pipefail).

Se vuoi trovare l'upstream per qualsiasi ramo (al contrario di quello su cui ti trovi), ecco una leggera modifica alla risposta di @ cdunn2001:

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

Questo ti darà il nome del ramo remoto per il ramo locale chiamato YOUR_LOCAL_BRANCH_NAME.

Puoi provare questo:

git remote show origin | grep "branch_name"

branch_name deve essere sostituito con il tuo ramo

Uso questo 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  
" -'

poi

git track

si noti che lo script può essere utilizzato anche per configurare il tracciamento.

Altri fantastici alias su https://github.com/orefalo/bash-profiles

Uso EasyGit (aka "ad esempio") come un involucro super leggero sopra (o lungo il lato) di Git. EasyGit ha un sottocomando "info" che fornisce tutti i tipi di informazioni super utili, incluso l'attuale ramo di tracciamento remoto delle filiali. Ecco un esempio (in cui l'attuale nome del ramo è "pippo"):

pknotz @ s883422: (pippo) ~ / workspace / bd
$ ad es. informazioni
Totale impegni: 175
Repository locale: .git
Repository remoti nominati: (nome -> posizione)
  origine -> git: //sahp7577/home/pknotz/bd.git
Filiale attuale: foo
  Checkum crittografico (sha1sum): bd248d1de7d759eb48e8b5ff3bfb3bb0eca4c5bf
  Repository pull / push predefinito: origine
  Opzioni pull / push predefinite:
    branch.foo.remote = origin
    branch.foo.merge = refs / heads / aal_devel_1
  Numero di partecipanti: 3
  Numero di file: 28
  Numero di directory: 20
  Dimensione file più grande, in byte: 32473 (pygooglechart-0.2.0 / COPYING)
  Impegni: 62

Migliorando su questa risposta , ho trovato questi .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

Se stai 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
    }

Il seguente comando farà riferimento al fork corrente di origine remota

git remote -v

Per aggiungere un percorso remoto,

git remote aggiungi origine nome_percorso