Invia il repository Git locale al nuovo telecomando, inclusi tutti i rami e i tag

Ho un repository Git locale che vorrei spingere in un nuovo repository remoto (repository nuovissimo impostato su Beanstalk, se questo è importante).
Il mio repository locale ha alcuni rami e tag e vorrei conservare tutta la mia cronologia.

Sembra che in pratica devo solo fare un git push, ma che carica solo il masterramo.

Come posso inviare tutto in modo da ottenere una replica completa del mio repository locale sul telecomando?

Per spingere tutti i tuoi rami , usa uno dei due (sostituisci REMOTO con il nome del telecomando, ad esempio "origine"):

git push REMOTE '*:*'
git push REMOTE --all

Per inviare tutti i tag :

git push REMOTE --tags

Infine, penso che puoi farlo tutto in un solo comando con:

git push REMOTE --mirror

Tuttavia, inoltre --mirror, spingerai anche i tuoi telecomandi, quindi questo potrebbe non essere esattamente quello che vuoi.

Nel caso come me, hai acquistato un repository e ora stai passando l'origine remota a un repository diverso, uno nuovo vuoto ...

Quindi hai il tuo repository e tutti i rami all'interno, ma devi comunque controllare quei rami perché il git push --allcomando spinga effettivamente anche quelli.

Dovresti farlo prima di spingere:

for remote in `git branch -r | grep -v master `; do git checkout --track $remote ; done

Seguito da

git push --all

Ecco un'altra versione della stessa cosa che ha funzionato meglio per la situazione in cui mi trovavo. Risolve il problema in cui hai più di un telecomando, vorrebbe clonare tutti i rami da remoto sourcea remoto destinationma senza doverli controllare tutti in anticipo.

(Il problema che ho avuto con la soluzione di Daniel era che si sarebbe rifiutato di effettuare il checkout di un ramo di monitoraggio dal sourcetelecomando se lo avessi già verificato in precedenza, ovvero, non aggiornerebbe il mio ramo locale prima del push)

git push destination +refs/remotes/source/*:refs/heads/*

Nota: se non si utilizza l'interfaccia della riga di comando diretta, è necessario uscire dagli asterischi:

git push destination +refs/remotes/source/\*:refs/heads/\*

• @mattalxndr

questo spingerà tutti i rami in remoto sourceverso un ramo principale destination, eventualmente facendo una spinta non in avanti veloce. Devi ancora inviare i tag separatamente.

Questo è il modo più conciso che ho trovato, a condizione che la destinazione sia vuota. Passare a una cartella vuota e quindi:

# Note the period for cwd >>>>>>>>>>>>>>>>>>>>>>>> v
git clone --bare https://your-source-repo/repo.git .
git push --mirror https://your-destination-repo/repo.git

Sostituire https://...per file:///your/repoecc a seconda dei casi.

La manpage di git-pushmerita una lettura. In combinazione con questo sito web ho scritto quanto segue nel mio .git/config:

[remote "origin"]
    url = …
    fetch = …
    push = :
    push = refs/tags/*

Il push = :mezzo "invia qualsiasi ramo" corrispondente "(ovvero rami che già esistono nel repository remoto e hanno una controparte locale)", mentre push = refs/tags/*significa "invia tutti i tag".

Quindi ora devo solo correre git pushper spingere tutti i rami corrispondenti e tutti i tag.

Sì, questo non è esattamente ciò che l'OP voleva (tutti i rami da spingere devono già esistere sul lato remoto), ma potrebbe essere utile per coloro che trovano questa domanda mentre cercano su Google "come faccio a spingere rami e tag allo stesso tempo".

Nel mio caso ciò che ha funzionato è stato.

git push origin --all

Mirroring di un repository

Crea un clone nudo del repository.

git clone --bare https://github.com/exampleuser/old-repository.git

Mirror-push nel nuovo repository.

cd old-repository.git
git push --mirror https://github.com/exampleuser/new-repository.git

Rimuovere il repository locale temporaneo creato nel passaggio 1.

cd ..
rm -rf old-repository.git

Mirroring di un repository che contiene oggetti Git Large File Storage

Crea un clone nudo del repository. Sostituisci il nome utente di esempio con il nome della persona o dell'organizzazione proprietaria del repository e sostituisci il nome del repository di esempio con il nome del repository che desideri duplicare.

git clone --bare https://github.com/exampleuser/old-repository.git

Passare al repository appena clonato.

cd old-repository.git

Estrai gli oggetti Git Large File Storage del repository.

git lfs fetch --all

Mirror-push nel nuovo repository.

git push --mirror https://github.com/exampleuser/new-repository.git

Invia gli oggetti Git Large File Storage del repository al tuo mirror.

git lfs push --all https://github.com/exampleuser/new-repository.git

Rimuovere il repository locale temporaneo creato nel passaggio 1.

cd ..
rm -rf old-repository.git

Le istruzioni sopra riportate provengono dalla Guida di Github: https://help.github.com/articles/duplicating-a-repository/

Ho trovato sopra le risposte hanno ancora alcune cose poco chiare, che fuorviano gli utenti. Innanzitutto, è sicuro che git push new_origin --alle git push new_origin --mirrornon può duplicare tutti i rami di origine, ma duplica solo i tuoi rami esistenti locali sul tuo new_origin.

Di seguito sono riportati due metodi utili che ho testato:

1, duplicato dal clone repo nudo. git clone --bare origin_url, quindi inserisci la cartella e, in git push new_origin_url --mirrorquesto modo, puoi anche utilizzare git clone --mirror origin_urlentrambi --baree --mirrorscaricare un repository nudo, escluso lo spazio di lavoro. si prega di fare riferimento a questo

2, Se hai un repository git usando git clone, il che significa che hai un repository nudo e un'area di lavoro git, puoi usare git remote add new_origin new_origin_url, e poi git push new_origin +refs/remotes/origin/\*:refs/heads/\*, e poigit push new_origin --tags

In questo modo, otterrai un ramo di testa in più, che non ha senso.

Per inviare rami e tag (ma non telecomandi):

git push origin 'refs/tags/*' 'refs/heads/*'

Ciò equivarrebbe a combinare le opzioni --tagse --allper git push, che git non sembra consentire.

Basato sulla risposta di @Daniel, ho fatto:

for remote in \`git branch | grep -v master\`
do 
    git push -u origin $remote
done

Ho scoperto che nessuno di questi sembrava funzionare correttamente per me. Sentiti libero di infiammarlo a morte, ma per qualche motivo non è riuscito a far funzionare correttamente le altre opzioni.

Il risultato atteso era un repository "clonato" su un altro telecomando (ovvero da Github a un altro provider):

• Tutti i rami vengono creati sul nuovo telecomando
• Tutta la cronologia delle filiali viene creata sul nuovo telecomando
  • (questo è mancato su ogni soluzione che ho provato)
• Tutti i tag vengono creati sul nuovo telecomando
• La fonte si sposta (un dato)
• Non distruttivo (dando una pausa all'opzione --mirror)

Il problema principale che stavo vedendo era che tutti i rami remoti non venivano ricreati nel nuovo telecomando. Se un comando ha funzionato, il nuovo telecomando non aveva la cronologia del ramo (ovvero facendo un comando git checkout branch; git lognon mostrava i commit del ramo previsti).

Ho notato che git checkout -b branchnameNON è lo stesso di git checkout branchname(essendo quest'ultimo ciò di cui avevo bisogno). Ho notato git checkout --track branchnameche non sembra estrarre la storia del ramo.

La mia soluzione (basata su PowerShell):

Function Git-FetchRemoteBranches {
$originalbranch = (git symbolic-ref HEAD).split("/")[-1]

Foreach ($entry in (git branch -r)) {

If ($entry -like "*->*") {
  $branch = $entry.split("->")[2].split("/")[1]
}
  else {$branch = $entry.split("/")[1]}

Write-Host "--Trying git checkout " -NoNewline
Write-Host "$branch" -Foreground Yellow

git checkout $branch

Remove-Variable branch -Force

""}

#Switch back to original branch, if needed
If ( ((git symbolic-ref HEAD).split("/")[-1]) -ne $originalbranch) {
"Switching back to original branch"
git checkout $originalbranch
Remove-Variable originalbranch -Force
}
}

git clone http://remoterepo
cd remoterepo
Git-FetchRemoteBranches
git remote add newremote
git push newremote --all
git push newremote --tags #Not sure if neeeded, but added for good measure

Il comando seguente spingerà tutti i rami ( inclusi quelli che non hai mai estratto ma presenti nel tuo repository git, li puoi vederegit branch -a )

git push origin '*:*'

NOTA: questo comando è utile quando si esegue la migrazione del servizio di controllo versione ( ovvero la migrazione da Gitlab a GitHub )

Stavo passando da un servizio di controllo versione a un altro e avevo bisogno di clonare tutti i repository, inclusi tutti i rami, i tag e la cronologia.

Per ottenere sopra ho fatto il prossimo:

• checkout manuale di tutti i rami nel repository locale (script per il checkout di tutti mostrati di seguito),
• git push origin '*:*'

Script .sh utilizzato per il checkout di tutti i rami nel repository locale:

for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master `; do
   git branch --track ${branch#remotes/origin/} $branch
done