Push Git local repo à nouveau à distance, y compris toutes les branches et les tags

J'ai un repo Git local que je voudrais pousser vers une nouvelle distance de pensions de titres (nouvelle marque pensions mis en place sur Beanstalk, si ce qui compte). Mon repo local a un peu de branches et de tags et je tiens à garder tout de mon histoire. Il ressemble en gros, j'ai juste besoin de faire un git push, mais qui ne télécharge que la branche master. Comment puis-je repousser tout si je reçois une réplique complète de mon local repo sur la télécommande?

InformationsquelleAutor Cory Imdieke | 2011-07-28

git

823

De pousser toutes vos succursales, utiliser (remplacer DISTANCE avec le nom de la télécommande, par exemple "origine"):
```
git push REMOTE '*:*'
git push REMOTE --all
```
De pousser tous les tags:
```
git push REMOTE --tags
```
Enfin, je pense que vous pouvez le faire en une seule commande avec:
```
git push REMOTE --mirror
```
Cependant, en plus --mirror, va également pousser vos télécommandes, de sorte que cela peut ne pas être exactement ce que vous voulez.
- --all au lieu de *:* semble plus sympathique
- Parfait de référence. Merci!
- mon dieu............. j'ai déchiré de l'ensemble de l'internet et j'ai découvert le ` --tous les ` interrupteur est AAAAALLLLLLLLLLLLLL j'avais besoin!
- Pour une raison que lors de l'utilisation de --miroir de ma région, les branches distantes sont répertoriés comme étant poussé mais ne fait pas apparaître dans mon repo. J'ai d'abord extraire tous les distants/succursales avant d'utiliser --miroir.
- Juste de noter que git push REMOTE --all retourné No refs in common and none specified; de ne rien faire., alors que git push REMOTE "*:* poussa toutes les branches à distance.
- Utiliser l'option --dry-run pour inspecter ce qui va se passer, dans le cas où vous avez "tmp" ou "fonction" branches localement et que vous n'avez pas vraiment envie de mettre à jour à DISTANCE
- Si la télécommande d'origine est toujours disponible, c'est une bonne idée de faire git clone --mirror old-remote-url; cd repo.git; git push --mirror new-remote-url.
- Sur windows je suis nécessaires à l'utilisation de ":" à la place.
- --miroir est génial! C'est ce que j'ai été à la recherche pour. Il vous permet de cloner à partir d'Un serveur et de pousser ensuite le tout à nouveau serveur B. --tous seulement localement, suivis des branches qui le rend facile de perdre du travail!
- Je ne savais pas que cela était possible jusqu'à présent. Tout ce temps je l'ai été faire un par un. Quelle merveilleuse solution.
- Aucune de ces options n'a fonctionné pour moi pour une raison quelconque.
- Vous me faites ressentir de la douleur. Pourquoi n'utilisez-vous pas "RemoteName" ou "origine" à la place de la vôtre "à DISTANCE".
- git push -u origin --mirror a fonctionné pour moi lors d'échange à partir d'une seule télécommande pour le prochain et l'obtention de toutes mes branches que je n'avais pas localement vérifié.
- La recommandation de @Jonno premier à utiliser l'option --dry-run est très intelligent. Un exemple de la douleur il peut vous aider à éviter: git push --miroir peut changer votre télécommande dans les moyens qui ne peut pas être annulée, une puissance rare dans git. (Voir le related extrait de la page de manuel --mirror [...] Newly created local refs will be pushed to the remote end, locally updated refs will be force updated on the remote end, and deleted refs will be removed from the remote end.)
- qu'entendez-vous par "pousser vos télécommandes"? quelles sont your remotes et pourquoi pourrait-il être une mauvaise chose?
- je ne suis pas sûr, mais il semble que git push REMOTE --all seulement la pousse des branches locales à DISTANCE, où git push REMOTE '*:*' pousse des branches locales et d'autres branches distantes de la télécommande. Encore une fois je ne suis pas sûr si je suis à la compréhension de ce droit, mais il y a certainement une différence entre --all et '*:*'
- git push REMOTE '*:*' semble pousser les balises de trop, alors qu'il ressemble à --all ne le fait pas.
- git push --ne PAS pousser les branches sur la télécommande d'origine (git branch-r), sauf s'ils sont extraits localement. Ce devrait être combinée avec la réponse ci-dessous pour avoir une réponse complète.
- Il est important de mentionner git push --follow-tags et git config --global push.followTags true. Plus de détails: stackoverflow.com/a/3745250/9638388
InformationsquelleAutor cmcginty
142

Dans les cas comme moi, vous avez acquis une mise en pension et sont maintenant de commutation de la télécommande d'origine vers un autre repo, un nouveau vide...

Donc, vous avez votre pension et toutes les branches à l'intérieur, mais vous avez encore besoin pour passer à la caisse ceux des branches pour le git push --all commande à fait pousser ceux qui sont trop.

Vous devriez faire avant de vous pousser:
```
for remote in `git branch -r | grep -v master `; do git checkout --track $remote ; done
```
Suivie par
```
git push --all
```
- C'est très utile, comme je l'ai eu à la caisse toutes les branches manuellement. Ce sera bon pour la prochaine fois.
- Étrangement, git push '*:*' poussé toutes les branches. git push -all juste poussé le maître. Je transporte des pensions à partir de github pour bitbucket.
- Au lieu de vérifier chaque direction générale, vous devriez simplement faire "git branch --piste $à distance". En grand repos de vérifier une vieille branche prend parfois
- J'ai dû faire une petite modification pour que cela fonctionne: --track remotes/$remote au lieu de --track $remote. Voici la ligne de commande complète: for remote in `git branch -r | grep -v master `; do git checkout --track remotes/$remote ; done
- Merci, ça fonctionne pour moi, la réponse ci-dessus ne fonctionnent pas ainsi.
- git push --all œuvres. je vous remercie.
- J'ai permis à la branche principale(s) par la suppression de grep -v master. J'ai commencé avec un nu-repo, et certaines pensions de titres ont plusieurs branches d'un master dans leur nom (c'est à dire maître-après).
- J'ai trouvé cette question comme un résultat de la tentative de synchronisation à distance deux référentiels ont été clones de retour ensemble. Mon équipe a déménagé à partir de github pour gitlab alors que le travail a soudainement été introduit pendant la période de transition qui s'appuient sur notre ancien github CI pipeline. Après que le travail a conclu, nous voulions essentiellement importer un deuxième temps, à partir de github pour gitlab sans perdre notre gitlab progrès. Cela a mieux fonctionné pour moi que l'on a accepté la réponse.
InformationsquelleAutor Daniel
86

Ici est une autre de prendre sur la même chose qui a fonctionné mieux pour la situation dans laquelle j'étais. Il résout le problème où vous avez plus d'une seule télécommande, voudrais cloner toutes les branches éloignées source à distance destination mais sans avoir pour toutes les vérifier au préalable.

(Le problème que j'ai eu avec Daniel solution, c'est qu'il refuserait à la caisse d'un suivi de la direction générale de la source à distance si j'avais déjà vérifié déjà, c'est à dire, il ne serait pas de mise à jour de ma branche locale avant la poussée)
```
git push destination +refs/remotes/source/*:refs/heads/*
```
Note:
Si vous n'êtes pas à l'aide directe de la CLI, vous devez échapper à la astérisques:

git push destination +refs/remotes/source/\*:refs/heads/\*
- @mattalxndr
ce sera le pousser toutes les branches de distance source à la tête de la branche dans destination, éventuellement faire un non-avance rapide push. Vous devrez pousser des balises séparément.
- +1 Cela a fonctionné pour moi, le clonage d'un remote à l'autre. Merci!
- J'ai dû échapper à la astérisques: git push destination +refs/remotes/source/\*:refs/heads/\*
- Une brillante solution la distance de clonage problème, merci.
- Pour moi, cette plaie jusqu'à pousser une branche appelée TÊTE, je ne pense pas intentionnel dans ce scénario.
- Excellente réponse. Je n'ai cependant avoir des problèmes avec refs/remotes/source/* correspondant à la tags sous-nom, qui a ensuite créé distance les branches avec des noms comme tags/version-1.0 dans la cible-référentiel, qui devaient ensuite être nettoyés. Ce problème est peut-être un de mes télécommandes, je ne sais pas.
- Cette réponse a été extrêmement utile pour moi. La seule mention dans le git-pousser(1) page de manuel de cette utilisation de l'astérisque est dans un tout petit exemple pour la --prune option.
- Excellente réponse, bien différent de l'habitude, --mirror paramètre tout le monde recommande. Fonctionne parfaitement pour les scénarios où vous voulez juste pour garder synchronisés deux télécommandes pour l'automatisation ou à des fins de vérification.
- C'est une super réponse utile! Merci monsieur!
- parfait! exactement ce que je recherche! Merci!
InformationsquelleAutor Pieter Breed
13

La page de manuel pour git-push est intéressant à lire. Combiné avec ce site internet j'ai écrit ce qui suit dans mon .git/config:
```
[remote "origin"]
    url = …
    fetch = …
    push = :
    push = refs/tags/*
```
La push = : signifie "pousser" adéquation entre les branches (c'est à dire des branches qui existent déjà dans le dépôt distant et ont un homologue local)", tandis que push = refs/tags/* signifie "pousser tous les tags".

Donc je n'ai plus qu'à exécuter git push de pousser tous les branches et de toutes les balises.

Oui, ce n'est pas tout à fait ce que l'OP voulait (toutes les branches de pousser doit déjà exister sur le côté distant), mais pourrait être utile pour ceux qui trouvent cette question alors que googler "comment faire pousser des branches et des tags à la même temps".

InformationsquelleAutor scy
11

C'est la plus concise moyen que j'ai trouvé, à condition que la destination est vide. Basculer vers un dossier vide et ensuite:
```
# Note the period for cwd >>>>>>>>>>>>>>>>>>>>>>>> v
git clone --bare https://your-source-repo/repo.git .
git push --mirror https://your-destination-repo/repo.git
```
Substitut https://... pour file:///your/repo etc. comme appropriée.

InformationsquelleAutor ta.speot.is
9

Dans mon cas, ce qui a fonctionné a été.
```
git push origin --all
```
- Simple et facile. Il fonctionne! origin est l'alias d'URL distante dépôt Git.
InformationsquelleAutor nomulex
7

Miroir d'un référentiel

Créer un nu-clone du dépôt.
```
git clone --bare https://github.com/exampleuser/old-repository.git
```
Miroir-pousser vers le nouveau référentiel.
```
cd old-repository.git
git push --mirror https://github.com/exampleuser/new-repository.git
```
Enlever les locaux temporaires de dépôt que vous avez créé à l'étape 1.
```
cd ..
rm -rf old-repository.git
```
Miroir d'un référentiel qui contient Git Gros Fichier de Stockage des objets

Créer un nu-clone du dépôt. Remplacer l'exemple de nom d'utilisateur avec le nom de la personne ou de l'organisation qui possède le référentiel, et de remplacer le dépôt d'exemple nom avec le nom du dépôt que vous souhaitez dupliquer.
```
git clone --bare https://github.com/exampleuser/old-repository.git
```
Naviguer vers le dépôt que vous avez cloné.
```
cd old-repository.git
```
Tirer dans le dépôt Git du Grand Stockage de Fichiers objets.
```
git lfs fetch --all
```
Miroir-pousser vers le nouveau référentiel.
```
git push --mirror https://github.com/exampleuser/new-repository.git
```
Pousser le dépôt Git du Gros Fichier de Stockage des objets à votre miroir.
```
git lfs push --all https://github.com/exampleuser/new-repository.git
```
Enlever les locaux temporaires de dépôt que vous avez créé à l'étape 1.
```
cd ..
rm -rf old-repository.git
```
Instruction ci-dessus vient de Github Aider: https://help.github.com/articles/duplicating-a-repository/
- Tandis que ceci peut théoriquement répondre à la question, il serait préférable pour inclure l'essentiel des éléments de réponse ici, et de fournir le lien de référence. Voir ici pour des instructions sur la façon d'écrire mieux "lien" basée sur les réponses. Merci!
InformationsquelleAutor Michał Zalewski
4

J'ai trouvé des réponses ci-dessus ont encore certaines choses pas claires, ce qui va induire les utilisateurs en erreur. Tout d'abord, Il est sûr que l' git push new_origin --all et git push new_origin --mirror ne peut pas dupliquer toutes les branches d'origine, il vient de se dupliquer vos locaux existait branches de votre new_origin.

Ci-dessous deux méthodes que j'ai testées:

1,en double par clone nu repo.git clone --bare origin_url, ensuite, entrez dans le dossier, et git push new_origin_url --mirror.De cette manière, vous pouvez également utiliser git clone --mirror origin_url, à la fois --bareet --mirror va télécharger un nu repo,pas y compris l'espace de travail. veuillez vous référer cette

2,Si vous avez un repo git en utilisant git clone, ce qui signifie que vous avez à nu repo git espace de travail, vous pouvez utiliser git remote add new_origin new_origin_url, puis git push new_origin +refs/remotes/origin/\*:refs/heads/\*,puis git push new_origin --tags

De cette manière, vous obtiendrez un extra à la tête de la branche, qui ne font pas sens.

InformationsquelleAutor yanzi1225627
2

À pousser des branches et des tags (mais pas les télécommandes):
```
git push origin 'refs/tags/*' 'refs/heads/*'
```
Ce serait l'équivalent de la combinaison de la --tags et --all options pour git push, qui git ne semble pas le permettre.
- Est-il une option supplémentaire pour pousser à partir d'une autre télécommande ? Par exemple avec +refs/remotes/source/*
InformationsquelleAutor CEL
2

Basée à @Daniel réponse que j'ai fait:
```
for remote in \`git branch | grep -v master\`
do 
    git push -u origin $remote
done
```
- Encore mieux, | grep -v master peut être remplacé par | sed 's/\*//' (je suis en supposant que vous avez exclus master pour éviter les vilaines petites * qui est ajouté à la branche sélectionnée) qui vous permet d'inclure master et éviter tout problème lors de la master n'est pas sélectionnée de la branche. Aussi désolé pour necroposting, c'est juste que cette réponse m'a aidé aujourd'hui et je voulais partager ma modification, si cela peut aider les autres dans ma position...
InformationsquelleAutor Arthur Julião
1

J'ai trouvé qu'aucun de ces semblait fonctionner correctement pour moi. Se sentir libre de cette flamme à la mort, mais pour une raison quelconque n'a pas pu obtenir d'autres options pour fonctionner correctement.

Résultat attendu était un repo "cloné" à l'autre à distance (c'est à dire à partir de Github à un autre fournisseur):
- Toutes les branches sont créées sur la nouvelle télécommande
- Tous l'histoire de la branche sont créés sur la nouvelle télécommande
  - (ce qui a été raté pour chaque solution, j'ai essayé)
- Toutes les balises sont créés sur la nouvelle télécommande
- Source se déplace sur (un)
- Non destructif (donner une pause à l' --miroir option)
Le problème majeur que je voyais était soit toutes les branches distantes de ne pas obtenir recréé dans la nouvelle télécommande. Si une commande n', la nouvelle télécommande n'a pas l'histoire de la branche (c'est à dire faire un git checkout branch; git log ne pas montrer les attendus de la branche s'engage).

J'ai remarqué git checkout -b branchname n'est PAS le même que git checkout branchname (le dernier étant ce dont j'avais besoin). Je remarque git checkout --track branchname ne semble pas tirer de l'histoire de la branche.

Ma Solution (powershell base):
```
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
```
InformationsquelleAutor PotatoFarmer

Vous devez vous connecter pour publier un commentaire.