Trasformare un ramo Git esistente in un ramo remoto?

So come creare un nuovo ramo che tiene traccia dei rami remoti, ma come faccio a fare in modo che un ramo esistente tenga traccia di un ramo remoto?

So che posso solo modificare il .git/configfile, ma sembra che ci dovrebbe essere un modo più semplice.

Dato un ramo fooe un telecomando upstream:

A partire da Git 1.8.0:

git branch -u upstream/foo

Oppure, se il ramo locale foonon è il ramo corrente:

git branch -u upstream/foo foo

Oppure, se ti piace digitare comandi più lunghi, questi sono equivalenti ai due precedenti:

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

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

A partire da Git 1.7.0:

git branch --set-upstream foo upstream/foo

Appunti:

• Tutti i comandi sopra citati faranno sì che il ramo locale tenga footraccia del ramo fooremoto da remoto upstream.
• La vecchia sintassi (1.7.x) è obsoleta a favore della nuova sintassi (1.8+). La nuova sintassi vuole essere più intuitiva e più facile da ricordare.
• La definizione di un ramo a monte non riuscirà quando verrà eseguita su telecomandi appena creati che non sono già stati recuperati. In tal caso, eseguire git fetch upstreamprima.

Vedi anche: Perché devo fare sempre "--set-upstream"?

È possibile effettuare le seguenti operazioni (presupponendo che sia stato eseguito il checkout sul master e si desideri eseguire il push su un master di filiale remoto):

Imposta il "telecomando" se non lo hai già

git remote add origin ssh://...

Ora configura master per sapere come tracciare:

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

E spingere:

git push origin master

Lo faccio come un effetto collaterale della spinta con l' -uopzione come in

$ git push -u origin branch-name

L'opzione lunga equivalente è --set-upstream.

Anche il git-branchcomando comprende --set-upstream, ma il suo uso può essere fonte di confusione. La versione 1.8.0 modifica l'interfaccia.

git branch --set-upstreamè obsoleto e potrebbe essere rimosso in un futuro relativamente distante. git branch [-u|--set-upstream-to]è stato introdotto con un ordine di argomentazioni più sano.

...

È stato allettante dirlo git branch --set-upstream origin/master, ma questo dice a Git di organizzare il ramo locale "origine / master" per integrarsi con il ramo attualmente estratto, il che è altamente improbabile sul significato dell'utente. L'opzione è obsoleta; usa invece la nuova opzione --set-upstream-to(con una breve e dolce -u).

Supponi di avere un fooramo locale e desideri che lo tratti con lo stesso nome dell'upstream. Fai in modo che ciò accada

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

o solo

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

Potresti trovare git_remote_branchutile lo strumento. Offre semplici comandi per creare, pubblicare, eliminare, tenere traccia e rinominare filiali remote. Una bella caratteristica è che puoi chiedere a un grbcomando di spiegare quali comandi git eseguirà.

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

In realtà per la risposta accettata al lavoro:

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

Credo che già in Git 1.5.x potresti trasformare una filiale locale in $BRANCHuna filiale remota origin/$BRANCH, come questa.

Dato che esistono $BRANCHed origin/$BRANCHesistono e al momento non hai effettuato il checkout $BRANCH(se non lo hai fatto, passa a)

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

Questo ricrea $BRANCHcome un ramo di tracciamento. Le -fforze la creazione nonostante $BRANCHesistano già. --trackè facoltativo se sono presenti i soliti valori predefiniti (ovvero, il parametro git-config branch.autosetupmergeè true).

Nota, se origin/$BRANCHnon esiste ancora, puoi crearlo spingendo il tuo locale $BRANCHnel repository remoto con:

git push origin $BRANCH

Seguito dal comando precedente per promuovere il ramo locale in un ramo di rilevamento.

1- aggiorna i tuoi metadati locali usando: git fetch --all

2- mostra le tue filiali remote e locali usando: git branch -a , vedi la seguente Schermata

3- passare al ramo di destinazione, che si desidera collegare al telecomando: utilizzando

git checkout branchName

esempio :

4- Collega la tua filiale locale a una filiale remota usando:

git branch --set-upstream-to nameOfRemoteBranch

NB: nameOfRemoteBranch : per copiare dall'output del passaggio 2 "git branch -r"

Esempio di utilizzo:

Assicurati di eseguire:

git config push.default tracking

per essere in grado di spingere senza problemi

La modifica .git/configè probabilmente il modo più semplice e veloce. Questo è ciò che fanno comunque i comandi Git per la gestione di filiali remote.

Se non vuoi fare confusione con il file a mano (e non è così difficile da fare), puoi sempre usarlo git configper farlo ... ma ancora una volta, questo sarà solo per modificare il .git/configfile.

Esistono, ovviamente, modi per tracciare automaticamente un ramo remoto quando si usa git checkout(passando la --trackbandiera, per esempio), ma questi comandi funzionano con nuovi rami, non con quelli esistenti.

In breve

git branch --set-upstream yourLocalBranchName origin/develop

Questo renderà la tua yourLocalBranchNametraccia chiamata la filiale remota develop.

Per 1.6.x, può essere fatto usando lo strumento git_remote_branch :

grb track foo upstream

Ciò farà sì che Git faccia la footraccia upstream/foo.

Uso il seguente comando (Supponiamo che il nome del tuo ramo locale sia "nome-ramo-locale" e il nome del ramo remoto sia "nome-ramo-remoto"):

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

Se le filiali locali e remote hanno lo stesso nome, procedi come segue:

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

Qui, usando githube git version 2.1.4, basta fare:

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

E i telecomandi provengono da itelsef, anche se non collegati a livello locale:

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

Ma ovviamente, ancora nessuna filiale locale:

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

Vedere? Ora se fai il checkout, farà automaticamente la magia:

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

Così facile!

Sommario. Basta eseguire questi 2 comandi:

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

Usa l'opzione '--track'

• Dopo un git pull:

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

• O:

  git fetch && git checkout <branch-name>

Per creare un nuovo ramo, potremmo usare il seguente comando

 git checkout --track -b esempio origine / esempio 

 git branch -u origin / remote-branch-name

Questa non è una risposta diretta a questa domanda, ma volevo lasciare una nota qui per chiunque possa avere lo stesso problema quando provo a configurare un ramo a monte.

Diffidare di push.default .

Con le versioni precedenti di git, il valore predefinito era corrispondente , il che causerebbe un comportamento molto indesiderato se, ad esempio:

Traccia "master" della filiale locale verso origin / master

Tracciamento "upstream" della diramazione remota verso upstream / master

Se si provasse a "git push" mentre si trovava sul ramo "upstream", con push.default corrispondente git proverebbe automaticamente a fondere il ramo locale "master" in "upstream / master", causando un sacco di caos.

Questo dà un comportamento più sano:

git config --global push.default a monte

In un modo un po 'correlato, stavo cercando di aggiungere un ramo di tracciamento remoto a un ramo esistente, ma non avevo accesso a quel repository remoto sul sistema in cui volevo aggiungere quel ramo di tracciamento remoto (perché esporto spesso una copia di questo repo tramite sneakernet su un altro sistema che ha accesso per spingere verso quel telecomando). Ho scoperto che non c'era modo di forzare l'aggiunta di un ramo remoto sul locale che non era stato ancora recuperato (quindi locale non sapeva che il ramo esisteva sul telecomando e avrei ricevuto l'errore:) the requested upstream branch 'origin/remotebranchname' does not exist.

Alla fine sono riuscito ad aggiungere il nuovo ramo remoto precedentemente sconosciuto (senza recuperare) aggiungendo un nuovo file head in .git/refs/remotes/origin/remotebranchnamee quindi copiando il ref (il bulbo oculare era il più veloce, zoppo com'era ;-) dal sistema con accesso all'origine repository sulla workstation (con il repository locale in cui stavo aggiungendo il ramo remoto).

Una volta fatto ciò, ho potuto quindi utilizzare git branch --set-upstream-to=origin/remotebranchname

o semplicemente da:

passa al ramo se non ci sei già dentro:

[za]$ git checkout branch_name

correre

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

e sei pronto a:

 [za]$ git push origin branch_name

Puoi sempre dare un'occhiata al file di configurazione per vedere cosa sta monitorando cosa eseguendo:

 [za]$ git config -e

È anche bello saperlo, mostra quali rami sono tracciati e quali no. :

  [za]$ git remote show origin 

Per chiunque, come me, desidera solo sincronizzare il nome della propria filiale locale con il nome della filiale remota, ecco un comodo comando:

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

Per evitare di ricordare cosa devi fare ogni volta che ricevi il messaggio:

Si prega di specificare con quale ramo si desidera unire. Vedi git-pull (1)
per i dettagli.
.....

È possibile utilizzare il seguente script che imposta l' origine come upstream per il ramo corrente cui ci si trova.

Nel mio caso non ho quasi mai impostato qualcos'altro oltre l'origine come upstream predefinito . Inoltre, mantengo quasi sempre lo stesso nome di filiale per la filiale locale e remota. Quindi mi segue:

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

Anche questo funzionerebbe

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