Fusionner deux référentiels Git sans casser l'historique des fichiers

J'ai besoin de fusionner deux référentiels Git dans un troisième référentiel flambant neuf. J'ai trouvé de nombreuses descriptions de la façon de procéder en utilisant une fusion de sous-arborescence (par exemple la réponse de Jakub Narębski sur Comment fusionner deux référentiels Git? ) Et en suivant ces instructions fonctionne principalement, sauf que lorsque je valide la sous-arborescence, fusionne tous les fichiers des anciens référentiels sont enregistrés en tant que nouveaux fichiers ajoutés. Je peux voir l'historique des validations des anciens référentiels quand je le fais git log, mais si je le fais, git log <file>il ne montre qu'une seule validation pour ce fichier - la fusion des sous-arbres. À en juger par les commentaires sur la réponse ci-dessus, je ne suis pas le seul à voir ce problème mais je n'ai trouvé aucune solution publiée pour le résoudre.

Existe-t-il un moyen de fusionner les référentiels et de laisser l'historique des fichiers individuels intact?

Il s'avère que la réponse est beaucoup plus simple si vous essayez simplement de coller deux référentiels ensemble et de faire en sorte que ce soit comme ça tout au long plutôt que de gérer une dépendance externe. Il vous suffit d'ajouter des télécommandes à vos anciens référentiels, de les fusionner avec votre nouveau maître, de déplacer les fichiers et dossiers dans un sous-répertoire, de valider le déplacement et de répéter pour tous les référentiels supplémentaires. Les sous-modules, les fusions de sous-arbres et les rebases sophistiqués sont destinés à résoudre un problème légèrement différent et ne conviennent pas à ce que j'essayais de faire.

Voici un exemple de script Powershell pour coller deux référentiels ensemble:

# Assume the current directory is where we want the new repository to be created
# Create the new repository
git init

# Before we do a merge, we have to have an initial commit, so we'll make a dummy commit
git commit --allow-empty -m "Initial dummy commit"

# Add a remote for and fetch the old repo
git remote add -f old_a <OldA repo URL>

# Merge the files from old_a/master into new/master
git merge old_a/master --allow-unrelated-histories

# Move the old_a repo files and folders into a subdirectory so they don't collide with the other repo coming later
mkdir old_a
dir -exclude old_a | %{git mv $_.Name old_a}

# Commit the move
git commit -m "Move old_a files into subdir"

# Do the same thing for old_b
git remote add -f old_b <OldB repo URL>
git merge old_b/master --allow-unrelated-histories
mkdir old_b
dir –exclude old_a,old_b | %{git mv $_.Name old_b}
git commit -m "Move old_b files into subdir"

Évidemment, vous pouvez plutôt fusionner old_b dans old_a (qui devient le nouveau référentiel combiné) si vous préférez le faire - modifier le script en fonction.

Si vous souhaitez également ajouter des branches de fonctionnalités en cours, utilisez ceci:

# Bring over a feature branch from one of the old repos
git checkout -b feature-in-progress
git merge -s recursive -Xsubtree=old_a old_a/feature-in-progress

C'est la seule partie non évidente du processus - ce n'est pas une fusion de sous-arborescence, mais plutôt un argument pour la fusion récursive normale qui indique à Git que nous avons renommé la cible et qui aide Git à tout aligner correctement.

J'ai écrit une explication un peu plus détaillée ici .

Voici un moyen qui ne réécrit aucun historique, donc tous les ID de validation resteront valides. Le résultat final est que les fichiers du second dépôt se retrouveront dans un sous-répertoire.

1. Ajoutez le deuxième dépôt en tant que télécommande:

   cd firstgitrepo/
   git remote add secondrepo username@servername:andsoon
   

2. Assurez-vous d'avoir téléchargé tous les commits de secondrepo:

   git fetch secondrepo
   

3. Créez une branche locale à partir de la deuxième branche du référentiel:

   git branch branchfromsecondrepo secondrepo/master
   

4. Déplacez tous ses fichiers dans un sous-répertoire:

   git checkout branchfromsecondrepo
   mkdir subdir/
   git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} subdir/
   git commit -m "Moved files to subdir/"
   

5. Fusionnez la deuxième branche dans la branche principale du premier dépôt:

   git checkout master
   git merge --allow-unrelated-histories branchfromsecondrepo
   

Votre référentiel aura plus d'un commit racine, mais cela ne devrait pas poser de problème.

Quelques années se sont écoulées et il existe des solutions bien votées mais je veux partager la mienne car elle était un peu différente parce que je voulais fusionner 2 référentiels distants en un nouveau sans supprimer l'historique des référentiels précédents.

1. Créez un nouveau référentiel dans Github.

   

2. Téléchargez le référentiel nouvellement créé et ajoutez l'ancien référentiel distant.

   git clone https://github.com/alexbr9007/Test.git
   cd Test
   git remote add OldRepo https://github.com/alexbr9007/Django-React.git
   git remote -v
   

3. Récupère tous les fichiers de l'ancien référentiel pour créer une nouvelle branche.

   git fetch OldRepo
   git branch -a
   

   

4. Dans la branche principale, effectuez une fusion pour combiner l'ancien référentiel avec le nouveau créé.

   git merge remotes/OldRepo/master --allow-unrelated-histories
   

   

5. Créez un nouveau dossier pour stocker tout le nouveau contenu créé qui a été ajouté à partir de OldRepo et déplacez ses fichiers dans ce nouveau dossier.

6. Enfin, vous pouvez télécharger les fichiers à partir des dépôts combinés et supprimer en toute sécurité OldRepo de GitHub.

J'espère que cela peut être utile pour toute personne confrontée à la fusion de référentiels distants.

s'il vous plaît jeter un oeil à l'aide

git rebase --root --preserve-merges --onto

pour relier deux histoires au début de leur vie.

Si vous avez des chemins qui se chevauchent, corrigez-les avec

git filter-branch --index-filter

lorsque vous utilisez le journal, assurez-vous de "trouver des copies plus

git log -CC

de cette façon, vous trouverez tous les mouvements de fichiers dans le chemin.

J'ai transformé la solution de @Flimm ceci en un git aliascomme ça (ajouté à mon ~/.gitconfig):

[alias]
 mergeRepo = "!mergeRepo() { \
  [ $# -ne 3 ] && echo \"Three parameters required, <remote URI> <new branch> <new dir>\" && exit 1; \
  git remote add newRepo $1; \
  git fetch newRepo; \
  git branch \"$2\" newRepo/master; \
  git checkout \"$2\"; \
  mkdir -vp \"${GIT_PREFIX}$3\"; \
  git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} \"${GIT_PREFIX}$3\"/; \
  git commit -m \"Moved files to '${GIT_PREFIX}$3'\"; \
  git checkout master; git merge --allow-unrelated-histories --no-edit -s recursive -X no-renames \"$2\"; \
  git branch -D \"$2\"; git remote remove newRepo; \
}; \
mergeRepo"

Cette fonction clone le repo distant dans le répertoire repo local:

function git-add-repo
{
    repo="$1"
    dir="$(echo "$2" | sed 's/\/$//')"
    path="$(pwd)"

    tmp="$(mktemp -d)"
    remote="$(echo "$tmp" | sed 's/\///g'| sed 's/\./_/g')"

    git clone "$repo" "$tmp"
    cd "$tmp"

    git filter-branch --index-filter '
        git ls-files -s |
        sed "s,\t,&'"$dir"'/," |
        GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
        mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
    ' HEAD

    cd "$path"
    git remote add -f "$remote" "file://$tmp/.git"
    git pull "$remote/master"
    git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master"
    git remote remove "$remote"
    rm -rf "$tmp"
}

Comment utiliser:

cd current/package
git-add-repo https://github.com/example/example dir/to/save

Remarquer. Ce script peut réécrire les validations, mais enregistrera tous les auteurs et toutes les dates, cela signifie que les nouvelles validations auront un autre hachage, et si vous essayez de pousser les modifications sur le serveur distant, il ne pourra le faire qu'avec la touche de force, il réécrira également les validations sur le serveur. Veuillez donc faire des sauvegardes avant de lancer.

Profit!

Suivez les étapes pour intégrer un référentiel dans un autre référentiel, en ayant un seul historique git en fusionnant les deux historiques git.

1. Clonez les deux référentiels que vous souhaitez fusionner.

git clone [email protected]: utilisateur / parent-repo.git

git clone [email protected]: user / child-repo.git

2. Aller au repo enfant

cd repo-enfant /

3. exécutez la commande ci-dessous, remplacez le chemin d'accès my/new/subdir(3 occurrences) par la structure de répertoires où vous souhaitez avoir le dépôt enfant.

git filter-branch --prune-empty --tree-filter 'if [! -e mon / nouveau / sous-répertoire]; puis mkdir -p mon / nouveau / sous-répertoire git ls-tree --name-only $ GIT_COMMIT | xargs -I files mv files my / new / subdir fi '

4. Aller au dépôt parent

cd ../parent-repo/

5. Ajouter une télécommande au référentiel parent, pointant le chemin vers le référentiel enfant

git remote ajouter child-remote ../child-repo/

6. Récupérer le repo enfant

git fetch child-remote

7. Fusionner les histoires

git merge --allow-unrelated-histories child-remote / master

Si vous vérifiez le journal git dans le référentiel parent maintenant, il devrait fusionner les validations du référentiel enfant. Vous pouvez également voir la balise indiquant la source de validation.

L'article ci-dessous m'a aidé à intégrer un référentiel dans un autre référentiel, à avoir un seul historique git en fusionnant les deux historiques git.

http://ericlathrop.com/2014/01/combining-git-repositories/

J'espère que cela t'aides. Codage heureux!

Dites que vous souhaitez fusionner dépôt adans b(je suppose qu'ils sont situés à côté de l'autre):

cd b
git remote add a ../a
git fetch a
git merge --allow-unrelated-histories a/master
git remote remove a

Si vous souhaitez placer adans un sous-répertoire, procédez comme suit avant les commandes ci-dessus:

cd a
git filter-repo --to-subdirectory-filter a
cd ..

Pour cela, vous devez git-filter-repoinstaller ( filter-branchest déconseillé ).

Un exemple de fusion de 2 grands référentiels, en plaçant l'un d'entre eux dans un sous-répertoire: https://gist.github.com/x-yuri/9890ab1079cf4357d6f269d073fd9731

Plus d'informations ici .