Scal dwa repozytoria Git bez przerywania historii plików

Muszę połączyć dwa repozytoria Git z nowym, trzecim repozytorium. Znalazłem wiele opisów tego, jak to zrobić za pomocą scalania poddrzewa (na przykład odpowiedź Jakuba Narębskiego na temat Jak scalić dwa repozytoria Git? ) I przestrzeganie tych instrukcji w większości działa, z tym wyjątkiem, że kiedy zatwierdzam poddrzewo, scalam wszystkie pliki ze starych repozytoriów są zapisywane jako nowo dodane pliki. Widzę historię zatwierdzeń ze starych repozytoriów, kiedy to robię git log, ale jeśli to zrobię git log <file>, pokazuje tylko jedno zatwierdzenie dla tego pliku - scalanie poddrzewa. Sądząc po komentarzach do powyższej odpowiedzi, nie jestem sam widząc ten problem, ale nie znalazłem opublikowanych rozwiązań tego problemu.

Czy istnieje sposób scalenia repozytoriów i pozostawienia nienaruszonej historii poszczególnych plików?

Okazuje się, że odpowiedź jest znacznie prostsza, jeśli po prostu próbujesz skleić dwa repozytoria razem i sprawić, by wyglądało to tak od samego początku, zamiast zarządzać zewnętrzną zależnością. Musisz po prostu dodać piloty do swoich starych repozytoriów, połączyć je z nowym masterem, przenieść pliki i foldery do podkatalogu, zatwierdzić przeniesienie i powtórzyć dla wszystkich dodatkowych repozytoriów. Podmoduły, scalanie poddrzewa i fantazyjne rebazy mają na celu rozwiązanie nieco innego problemu i nie są odpowiednie do tego, co próbowałem zrobić.

Oto przykładowy skrypt Powershell do sklejenia dwóch repozytoriów:

# 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"

Oczywiście możesz zamiast tego połączyć old_b w old_a (który staje się nowym połączonym repozytorium), jeśli wolisz to zrobić - zmodyfikuj skrypt, aby pasował.

Jeśli chcesz również przenieść gałęzie funkcji w toku, użyj tego:

# 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

To jedyna nieoczywista część procesu - nie jest to scalanie poddrzewa, ale raczej argument na rzecz normalnego scalania rekurencyjnego, które mówi Gitowi, że zmieniliśmy nazwę celu i pomaga Gitowi poprawnie wszystko wyrównać.

Tutaj napisałem nieco bardziej szczegółowe wyjaśnienie .

Oto sposób, który nie przepisuje żadnej historii, więc wszystkie identyfikatory zatwierdzeń pozostaną ważne. W rezultacie pliki drugiego repozytorium znajdą się w podkatalogu.

1. Dodaj drugie repozytorium jako zdalne:

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

2. Upewnij się, że pobrałeś wszystkie zatwierdzenia Secondrepo:

   git fetch secondrepo
   

3. Utwórz oddział lokalny z drugiego oddziału repozytorium:

   git branch branchfromsecondrepo secondrepo/master
   

4. Przenieś wszystkie swoje pliki do podkatalogu:

   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. Scal drugą gałąź z gałęzią główną pierwszego repozytorium:

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

Twoje repozytorium będzie miało więcej niż jedno zatwierdzenie główne, ale to nie powinno stanowić problemu.

Minęło kilka lat i są dobrze oparte na dobrze ocenianych rozwiązaniach, ale chcę udostępnić moje, ponieważ było trochę inaczej, ponieważ chciałem połączyć 2 zdalne repozytoria w nowe bez usuwania historii z poprzednich repozytoriów.

1. Utwórz nowe repozytorium w Github.

   

2. Pobierz nowo utworzone repozytorium i dodaj stare zdalne repozytorium.

   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. Pobierz wszystkie pliki ze starego repozytorium, aby utworzyć nowy oddział.

   git fetch OldRepo
   git branch -a
   

   

4. W gałęzi master wykonaj scalenie, aby połączyć stare repozytorium z nowo utworzonym.

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

   

5. Utwórz nowy folder do przechowywania całej nowo utworzonej zawartości, która została dodana z OldRepo i przenieś swoje pliki do tego nowego folderu.

6. Na koniec możesz przesłać pliki z połączonych repozytoriów i bezpiecznie usunąć OldRepo z GitHub.

Mam nadzieję, że może to być przydatne dla każdego, kto zajmuje się łączeniem zdalnych repozytoriów.

proszę spojrzeć na korzystanie

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

połączyć dwie historie na wczesnym etapie życia.

Jeśli masz ścieżki, które się pokrywają, napraw je

git filter-branch --index-filter

podczas korzystania z dziennika upewnij się, że „trudniej znaleźć kopie”

git log -CC

w ten sposób znajdziesz wszelkie ruchy plików na ścieżce.

I okazało się, że rozwiązanie z @Flimm to do git aliastak (Dodane do moich ~/.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"

Ta funkcja sklonuje zdalne repozytorium do lokalnego katalogu repo:

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"
}

Jak używać:

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

Ogłoszenie. Ten skrypt może przepisać zatwierdzenia, ale zapisze wszystkich autorów i daty, oznacza to, że nowe zatwierdzenia będą miały kolejne skróty, a jeśli spróbujesz wypchnąć zmiany na zdalny serwer, będzie mógł to zrobić tylko za pomocą klucza wymuszenia, a także przepisać zatwierdzenia na serwerze. Zrób więc kopie zapasowe przed uruchomieniem.

Zysk!

Postępuj zgodnie z instrukcjami, aby osadzić jedno repo w innym repo, mając jedną historię git, łącząc obie historie git.

1. Sklonuj oba repozytoria, które chcesz scalić.

git clone [email protected]: użytkownik / rodzic-repo.git

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

2. Przejdź do repozytorium dzieci

cd child-repo /

3. uruchom poniższe polecenie, zamień ścieżkę my/new/subdir(3 wystąpienia) na strukturę katalogów, w której chcesz mieć repozytorium potomne.

git filter-branch --prune-empty --tree-filter 'if [! -e mój / nowy / podkatalog]; następnie mkdir -p mój / nowy / subdir git ls-tree - onlyname $ GIT_COMMIT | xargs -I pliki mv pliki mój / nowy / subdir fi '

4. Przejdź do repozytorium nadrzędnego

cd ../parent-repo/

5. Dodaj zdalne repozytorium nadrzędne, wskazując ścieżkę do repozytorium podrzędnego

git remote dodaj child-remote ../child-repo/

6. Pobierz repozytorium potomne

git fetch-child-remote

7. Połącz historie

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

Jeśli sprawdzisz teraz dziennik git w repozytorium nadrzędnym, powinien on zostać scalony. Możesz także zobaczyć znacznik wskazujący ze źródła zatwierdzenia.

Poniższy artykuł pomógł mi Osadzić jedno repo w innym repo, mając jedną historię git, łącząc obie historie git.

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

Mam nadzieję że to pomoże. Happy Coding!

Powiedzmy, że chcesz scalić repozytorium ado b(jestem zakładając się znajdują obok siebie):

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

Jeśli chcesz umieścić aw podkatalogu, wykonaj następujące czynności przed powyższymi poleceniami:

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

Do tego trzeba git-filter-repozainstalować ( filter-branchjest odradzane ).

Przykład połączenia 2 dużych repozytoriów i umieszczenia jednego z nich w podkatalogu: https://gist.github.com/x-yuri/9890ab1079cf4357d6f269d073fd9731

Więcej na ten temat tutaj .