Nasi programiści używają kombinacji systemów operacyjnych Windows i Unix. Dlatego dowiązania symboliczne utworzone na maszynach Unix stają się problemem dla programistów Windows. W systemie Windows (msysgit) dowiązanie symboliczne jest konwertowane na plik tekstowy ze ścieżką do pliku, na który wskazuje. Zamiast tego chciałbym przekonwertować dowiązanie symboliczne w rzeczywiste dowiązanie symboliczne Windows.

Mam ( zaktualizowane ) rozwiązanie tego problemu:

• Napisz skrypt po kasie, który będzie rekurencyjnie szukał plików tekstowych „dowiązanie symboliczne”.
• Zastąp je symlink Windows (używając mklink) o tej samej nazwie i rozszerzeniu co atrapa „symlink”
• Zignoruj ​​te dowiązanie symboliczne systemu Windows, dodając wpis do .git / info / exclude

Nie wdrożyłem tego, ale uważam, że jest to solidne podejście do tego problemu.

Pytania:

1. Jakie są wady tego podejścia?
2. Czy ten skrypt po wykonaniu transakcji jest nawet możliwy do wdrożenia? tj. czy mogę rekurencyjnie dowiedzieć się, jakie pliki git „symlink” tworzy git?
3. Czy ktoś już pracował nad takim skryptem?

Możesz znaleźć dowiązania symboliczne, szukając plików o trybie 120000, prawdopodobnie za pomocą tego polecenia:

git ls-files -s | awk '/120000/{print $4}'

Po wymianie linków zalecam oznaczanie ich jako niezmienionych git update-index --assume-unchangedzamiast wpisywania ich .git/info/exclude.

Zadałem to samo pytanie jakiś czas temu (nie tutaj, ogólnie) i znalazłem bardzo podobne rozwiązanie do propozycji OP. Najpierw udzielę bezpośrednich odpowiedzi na pytania 1 2 i 3, a następnie opublikuję rozwiązanie, z którego ostatecznie skorzystałem.

1. Rzeczywiście istnieje kilka wad proponowanego rozwiązania, głównie dotyczących zwiększonego potencjału zanieczyszczenia repozytorium lub przypadkowego dodania duplikatów plików, gdy są w stanie „dowiązania symbolicznego Windows”. (Więcej na ten temat w „ograniczeniach” poniżej.)
2. Tak, skrypt po wykonaniu transakcji jest możliwy do wdrożenia! Może nie jako dosłowny git checkoutkrok po kroku, ale poniższe rozwiązanie spełniło moje potrzeby na tyle dobrze, że dosłowny skrypt po przejściu do kasy nie był konieczny.
3. Tak!

Rozwiązanie:

Nasi programiści znajdują się w podobnej sytuacji co OP: mieszanka hostów Windows, Unix, repozytoriów i podmodułów z wieloma dowiązaniami symbolicznymi git oraz brak natywnej obsługi (jeszcze) w wersji MsysGit dla inteligentnej obsługi tych dowiązań symbolicznych na hostach Windows .

Dzięki Josh Lee za zwrócenie uwagi na fakt, że git zatwierdza dowiązania symboliczne ze specjalnym trybem pliku 120000. Dzięki tym informacjom można dodać kilka aliasów git, które pozwalają na tworzenie i manipulowanie dowiązaniami symbolicznymi git na hostach Windows.

1. Tworzenie dowiązań symbolicznych git w systemie Windows

   git config --global alias.add-symlink '!'"$(cat <<'ETX'
   __git_add_symlink() {
     if [ $# -ne 2 ] || [ "$1" = "-h" ]; then
       printf '%b\n' \
           'usage: git add-symlink <source_file_or_dir> <target_symlink>\n' \
           'Create a symlink in a git repository on a Windows host.\n' \
           'Note: source MUST be a path relative to the location of target'
       [ "$1" = "-h" ] && return 0 || return 2
     fi
   
     source_file_or_dir=${1#./}
     source_file_or_dir=${source_file_or_dir%/}
   
     target_symlink=${2#./}
     target_symlink=${target_symlink%/}
     target_symlink="${GIT_PREFIX}${target_symlink}"
     target_symlink=${target_symlink%/.}
     : "${target_symlink:=.}"
   
     if [ -d "$target_symlink" ]; then
       target_symlink="${target_symlink%/}/${source_file_or_dir##*/}"
     fi
   
     case "$target_symlink" in
       (*/*) target_dir=${target_symlink%/*} ;;
       (*) target_dir=$GIT_PREFIX ;;
     esac
   
     target_dir=$(cd "$target_dir" && pwd)
   
     if [ ! -e "${target_dir}/${source_file_or_dir}" ]; then
       printf 'error: git-add-symlink: %s: No such file or directory\n' \
           "${target_dir}/${source_file_or_dir}" >&2
       printf '(Source MUST be a path relative to the location of target!)\n' >&2
       return 2
     fi
   
     git update-index --add --cacheinfo 120000 \
         "$(printf '%s' "$source_file_or_dir" | git hash-object -w --stdin)" \
         "${target_symlink}" \
       && git checkout -- "$target_symlink" \
       && printf '%s -> %s\n' "${target_symlink#$GIT_PREFIX}" "$source_file_or_dir" \
       || return $?
   }
   __git_add_symlink
   ETX
   )"
   

   Zastosowanie: git add-symlink <source_file_or_dir> <target_symlink>gdzie argument odpowiadający plikowi źródłowemu lub katalogowi musi mieć postać ścieżki względem docelowego dowiązania symbolicznego. Możesz użyć tego aliasu w taki sam sposób, jak zwykle ln.

   Np. Drzewo repozytorium:

   dir/
   dir/foo/
   dir/foo/bar/
   dir/foo/bar/baz      (file containing "I am baz")
   dir/foo/bar/lnk_file (symlink to ../../../file)
   file                 (file containing "I am file")
   lnk_bar              (symlink to dir/foo/bar/)
   

   Można go utworzyć w systemie Windows w następujący sposób:

   git init
   mkdir -p dir/foo/bar/
   echo "I am baz" > dir/foo/bar/baz
   echo "I am file" > file
   git add -A
   git commit -m "Add files"
   git add-symlink ../../../file dir/foo/bar/lnk_file
   git add-symlink dir/foo/bar/ lnk_bar
   git commit -m "Add symlinks"
   

2. Zamiana dowiązań symbolicznych git na dowiązania twarde NTFS + połączenia

   git config --global alias.rm-symlinks '!'"$(cat <<'ETX'
   __git_rm_symlinks() {
     case "$1" in (-h)
       printf 'usage: git rm-symlinks [symlink] [symlink] [...]\n'
       return 0
     esac
     ppid=$$
     case $# in
       (0) git ls-files -s | grep -E '^120000' | cut -f2 ;;
       (*) printf '%s\n' "$@" ;;
     esac | while IFS= read -r symlink; do
       case "$symlink" in
         (*/*) symdir=${symlink%/*} ;;
         (*) symdir=. ;;
       esac
   
       git checkout -- "$symlink"
       src="${symdir}/$(cat "$symlink")"
   
       posix_to_dos_sed='s_^/\([A-Za-z]\)_\1:_;s_/_\\\\_g'
       doslnk=$(printf '%s\n' "$symlink" | sed "$posix_to_dos_sed")
       dossrc=$(printf '%s\n' "$src" | sed "$posix_to_dos_sed")
   
       if [ -f "$src" ]; then
         rm -f "$symlink"
         cmd //C mklink //H "$doslnk" "$dossrc"
       elif [ -d "$src" ]; then
         rm -f "$symlink"
         cmd //C mklink //J "$doslnk" "$dossrc"
       else
         printf 'error: git-rm-symlink: Not a valid source\n' >&2
         printf '%s =/=> %s  (%s =/=> %s)...\n' \
             "$symlink" "$src" "$doslnk" "$dossrc" >&2
         false
       fi || printf 'ESC[%d]: %d\n' "$ppid" "$?"
   
       git update-index --assume-unchanged "$symlink"
     done | awk '
       BEGIN { status_code = 0 }
       /^ESC\['"$ppid"'\]: / { status_code = $2 ; next }
       { print }
       END { exit status_code }
     '
   }
   __git_rm_symlinks
   ETX
   )"
   
   git config --global alias.rm-symlink '!git rm-symlinks'  # for back-compat.
   

   Stosowanie:

   git rm-symlinks [symlink] [symlink] [...]
   

   Ten alias może usuwać dowiązania symboliczne git jeden po drugim lub naraz za jednym zamachem. Dowiązania symboliczne zostaną zastąpione dowiązaniami stałymi NTFS (w przypadku plików) lub połączeniami NTFS (w przypadku katalogów). Zaletą używania hardlinks + skrzyżowań nad „prawdziwymi” dowiązaniami symbolicznymi NTFS jest to, że podwyższone uprawnienia UAC nie są wymagane do ich utworzenia.

   Aby usunąć dowiązania symboliczne z podmodułów, po prostu użyj wbudowanej obsługi git do iteracji nad nimi:

   git submodule foreach --recursive git rm-symlinks
   

   Ale w przypadku każdego takiego drastycznego działania miło jest mieć odwrócenie ...

3. Przywracanie dowiązań symbolicznych git w systemie Windows

   git config --global alias.checkout-symlinks '!'"$(cat <<'ETX'
   __git_checkout_symlinks() {
     case "$1" in (-h)
       printf 'usage: git checkout-symlinks [symlink] [symlink] [...]\n'
       return 0
     esac
     case $# in
       (0) git ls-files -s | grep -E '^120000' | cut -f2 ;;
       (*) printf '%s\n' "$@" ;;
     esac | while IFS= read -r symlink; do
       git update-index --no-assume-unchanged "$symlink"
       rmdir "$symlink" >/dev/null 2>&1
       git checkout -- "$symlink"
       printf 'Restored git symlink: %s -> %s\n' "$symlink" "$(cat "$symlink")"
     done
   }
   __git_checkout_symlinks
   ETX
   )"
   
   git config --global alias.co-symlinks '!git checkout-symlinks'
   

   Użycie git checkout-symlinks [symlink] [symlink] [...]:, które się cofa git rm-symlinks, skutecznie przywracając repozytorium do jego naturalnego stanu (z wyjątkiem zmian, które powinny pozostać nienaruszone).

   A dla podmodułów:

   git submodule foreach --recursive git checkout-symlinks
   

4. Ograniczenia:

   • Katalogi / pliki / dowiązania symboliczne ze spacjami na ścieżkach powinny działać. Ale karty czy nowe linie? YMMV… (Rozumiem przez to: nie rób tego, ponieważ to nie zadziała.)

   • Jeśli ty lub inni zapomnicie, git checkout-symlinkszanim zrobicie coś o potencjalnie szerokich konsekwencjach, np git add -A. Lokalne repozytorium może skończyć się zanieczyszczonym stanem.

     Korzystając z naszego „przykładowego repozytorium” sprzed:

     echo "I am nuthafile" > dir/foo/bar/nuthafile
     echo "Updating file" >> file
     git add -A
     git status
     # On branch master
     # Changes to be committed:
     #   (use "git reset HEAD <file>..." to unstage)
     #
     #       new file:   dir/foo/bar/nuthafile
     #       modified:   file
     #       deleted:    lnk_bar           # POLLUTION
     #       new file:   lnk_bar/baz       # POLLUTION
     #       new file:   lnk_bar/lnk_file  # POLLUTION
     #       new file:   lnk_bar/nuthafile # POLLUTION
     #
     

     Ups ...

     Z tego powodu fajnie jest dołączyć te aliasy jako kroki do wykonania dla użytkowników systemu Windows przed i po zbudowaniu projektu, a nie po kasie lub przed wypchnięciem. Ale każda sytuacja jest inna. Te aliasy były dla mnie na tyle przydatne, że prawdziwe rozwiązanie po przejściu do kasy nie było konieczne.

Mam nadzieję, że to pomaga!

Bibliografia:

http://git-scm.com/book/en/Git-Internals-Git-Objects

http://technet.microsoft.com/en-us/library/cc753194

Ostatnia aktualizacja: 13.03.2019

• Zgodność z POSIX (no cóż, z wyjątkiem tych mklinkwywołań, oczywiście) - koniec z bashizmami !
• Obsługiwane są katalogi i pliki ze spacjami.
• Zerowe i niezerowe kody statusu wyjścia (odpowiednio dla pomyślnego zakończenia / niepowodzenia żądanego polecenia) są teraz poprawnie zachowane / zwrócone.
• add-symlinkAlias działa teraz podobnie ln (1) i może być używany z dowolnym katalogu w repozytorium, a nie tylko katalogu głównego repozytorium.
• rm-symlinkPs (pojedyncza) został zastąpiony przez rm-symlinksalias (mnoga), który obecnie przyjmuje wiele argumentów (lub żadnych parametrów w ogóle, która znajduje wszystkich dowiązania przez repozytorium, jak poprzednio), dla selektywnego przekształcenia symlinki git w NTFS hardlinki + węzłów .
• checkout-symlinksAlias została zaktualizowana, aby zaakceptować wiele argumentów (lub wcale, == wszystko) do selektywnego odwrócenia wspomnianych przekształceń.

Uwaga końcowa: podczas gdy testowałem ładowanie i uruchamianie tych aliasów przy użyciu Bash 3.2 (a nawet 3.1) dla tych, którzy nadal mogą utknąć na tak starożytnych wersjach z wielu powodów, pamiętaj, że wersje tak stare jak te są znane ze względu na parser robaki. Jeśli wystąpią problemy podczas próby zainstalowania któregokolwiek z tych aliasów, pierwszą rzeczą, na którą powinieneś zwrócić uwagę, jest aktualizacja powłoki (w przypadku Bash sprawdź wersję za pomocą CTRL + X, CTRL + V). Alternatywnie, jeśli próbujesz je zainstalować, wklejając je do emulatora terminala, możesz mieć więcej szczęścia wklejając je do pliku i zamiast tego, np. Jako

. ./git-win-symlinks.sh

Powodzenia!

Najnowsza wersja git scm (testet 2.11.1) umożliwia włączanie dowiązań symbolicznych. Ale musisz ponownie sklonować repozytorium za pomocą dowiązań symbolicznych git clone -c core.symlinks=true <URL>. Musisz uruchomić to polecenie z uprawnieniami administratora. Możliwe jest również tworzenie dowiązań symbolicznych w systemie Windows za pomocą mklink. Sprawdź wiki .

Powinien zostać zaimplementowany w msysgit, ale są dwie wady:

• Łącza symboliczne są dostępne tylko w systemie Windows Vista i nowszych (nie powinno to stanowić problemu w 2011 r., A jednak tak jest ...), ponieważ starsze wersje obsługują tylko połączenia katalogów.
• (duży) Microsoft uważa, że ​​dowiązania symboliczne stanowią zagrożenie bezpieczeństwa, dlatego domyślnie mogą je tworzyć tylko administratorzy. Będziesz musiał podnieść uprawnienia procesu git lub użyć fstool, aby zmienić to zachowanie na każdej maszynie, na której pracujesz.

Przeprowadziłem szybkie wyszukiwanie i nad tym trwają prace, patrz problem 224 .

tak więc, jak zmieniło się w GIT od czasu opublikowania wielu odpowiedzi tutaj, są prawidłowe instrukcje, aby linki symboliczne działały poprawnie w systemie Windows od

SIERPIEŃ 2018

1. Upewnij się, że git jest zainstalowany z obsługą dowiązań symbolicznych

2. Powiedz Bashowi, aby tworzył dowiązania twarde zamiast dowiązań symbolicznych

EDYCJA - (folder git) /etc/bash.bashrc

DODAJ DO DOLNEJ - MSYS=winsymlinks:nativestrict

3. Ustaw git config, aby używał dowiązań symbolicznych

git config core.symlinks true

lub

git clone -c core.symlinks=true <URL>

UWAGA: Próbowałem dodać to do globalnej konfiguracji git iw tej chwili nie działa dla mnie, więc polecam dodanie tego do każdego repo ...

4. wyciągnij repozytorium

UWAGA: Jeśli nie włączyłeś trybu programisty w najnowszej wersji systemu Windows 10, musisz uruchomić bash jako administrator, aby utworzyć dowiązania symboliczne

5. Zresetuj wszystkie dowiązania symboliczne (opcjonalnie) Jeśli masz istniejące repozytorium lub korzystasz z submodułów, może się okazać, że dowiązania symboliczne nie są tworzone poprawnie, więc aby odświeżyć wszystkie dowiązania symboliczne w repozytorium, możesz uruchomić te polecenia.

find -type l -delete
git reset --hard

UWAGA: spowoduje to zresetowanie wszelkich zmian od ostatniego zatwierdzenia, więc upewnij się, że dokonałeś pierwszego

Krótka odpowiedź: są teraz ładnie obsługiwane, jeśli możesz włączyć tryb programisty.

Od https://blogs.windows.com/buildingapps/2016/12/02/symlinks-windows-10/

Teraz w Windows 10 Creators Update użytkownik (z uprawnieniami administratora) może najpierw włączyć tryb programisty, a następnie każdy użytkownik na komputerze może uruchomić polecenie mklink bez podnoszenia konsoli wiersza poleceń.

Co spowodowało tę zmianę? Dostępność i użycie dowiązań symbolicznych to wielka sprawa dla współczesnych programistów:

Wiele popularnych narzędzi programistycznych, takich jak git i menedżery pakietów, np. Npm, rozpoznaje i utrzymuje dowiązania symboliczne odpowiednio podczas tworzenia repozytoriów lub pakietów. Gdy te repozytoria lub pakiety są następnie przywracane gdzie indziej, dowiązania symboliczne są również przywracane, zapewniając, że miejsce na dysku (i czas użytkownika) nie zostanie zmarnowane.

Łatwo przeoczyć wszystkie pozostałe ogłoszenia „Aktualizacja twórcy”, ale jeśli włączysz tryb programisty, możesz tworzyć dowiązania symboliczne bez podwyższonych uprawnień. Być może będziesz musiał ponownie zainstalować git i upewnić się, że obsługa dowiązań symbolicznych jest włączona, ponieważ nie jest to domyślnie.

Odpowiedź 2020

1. Włącz „tryb programisty” w systemie Windows 10 - daje mklink uprawnienia
2. Upewnij się, że dowiązania symboliczne są włączone w git
   • git config --global core.symlinks true
   • lub zaznacz pole wyboru podczas instalowania msysgit

Zmiana gałęzi wymusi odtworzenie brakujących dowiązań symbolicznych.

Uważaj, obsługa Symlinks w systemie Windows w przypadku niektórych innych klientów Git nie jest pełna. Zwłaszcza GitKraken.

Sugeruję, abyś nie używał dowiązań symbolicznych w repozytorium ”. Przechowuj rzeczywistą treść w repozytorium, a następnie umieść dowiązania symboliczne na zewnątrz repozytorium, które wskazują na treść.

Powiedzmy, że używasz repozytorium, aby porównać hosting swojej witryny na * nix z hostingiem na win. Przechowuj zawartość w swoim repozytorium ”, powiedzmy, /httpRepoContenta c:\httpRepoContentten folder jest synchronizowany przez GIT, SVN itp.

Następnie zastąp folder zawartości serwera WWW ( /var/wwwic:\program files\web server\www {nazwy nie mają tak naprawdę znaczenia, edytuj, jeśli musisz}) symbolicznym łączem do treści w repozytorium ”. Serwery WWW zobaczą zawartość jako „we właściwym” miejscu, ale możesz użyć kontroli źródła.

Jednakże, jeśli musisz użyć dowiązań symbolicznych w repo ', musisz spojrzeć na coś w rodzaju skryptu zatwierdzania przed / po zatwierdzeniu. Wiem, że możesz ich używać do robienia rzeczy, takich jak na przykład analizowanie plików kodu za pomocą formatera, więc powinna istnieć możliwość konwersji dowiązań symbolicznych między platformami.

jeśli ktoś zna dobre miejsce, aby dowiedzieć się, jak wykonywać te skrypty dla typowych kontrolek źródłowych, SVN GIT MG, to proszę dodać komentarz.

Dla tych, którzy używają CygWin na Vista, Win7 lub nowszym, natywne gitpolecenie może tworzyć „właściwe” dowiązania symboliczne rozpoznawane przez aplikacje Windows, takie jak Android Studio . Musisz tylko ustawić CYGWINzmienną środowiskową, aby zawierała winsymlinks:nativelub winsymlinks:nativestrictjako taka:

export CYGWIN="$CYGWIN winsymlinks:native"

Wadą tego (i istotną w tym przypadku) jest to, że powłoka CygWin musi być „Uruchomiona jako administrator”, aby mieć uprawnienia systemu operacyjnego wymagane do tworzenia tego rodzaju dowiązań symbolicznych. Jednak po ich utworzeniu nie są wymagane specjalne uprawnienia do korzystania z nich. O ile nie zostaną one zmienione w repozytorium przez innego programistę, od tej gitpory będzie działać poprawnie z normalnymi uprawnieniami użytkownika.

Osobiście używam tego tylko do dowiązań symbolicznych, które są nawigowane przez aplikacje Windows (tj. Nie-CygWin) z powodu tej dodatkowej trudności.

Aby uzyskać więcej informacji na temat tej opcji, zobacz to SO pytanie: Jak zrobić symboliczne łącze z cygwin w Windows 7

Oto skrypt wsadowy do konwersji dowiązań symbolicznych w repozytorium, tylko dla plików, na podstawie odpowiedzi Josha Lee. Skrypt z dodatkowym sprawdzeniem uprawnień administratora znajduje się na stronie https://gist.github.com/Quazistax/8daf09080bf54b4c7641 .

@echo off
pushd "%~dp0"
setlocal EnableDelayedExpansion

for /f "tokens=3,*" %%e in ('git ls-files -s ^| findstr /R /C:"^120000"') do (
     call :processFirstLine %%f
)
REM pause
goto :eof

:processFirstLine
@echo.
@echo FILE:    %1

dir "%~f1" | find "<SYMLINK>" >NUL && (
  @echo FILE already is a symlink
  goto :eof
)

for /f "usebackq tokens=*" %%l in ("%~f1") do (
  @echo LINK TO: %%l

  del "%~f1"
  if not !ERRORLEVEL! == 0 (
    @echo FAILED: del
    goto :eof
  )

  setlocal
  call :expandRelative linkto "%1" "%%l"
  mklink "%~f1" "!linkto!"
  endlocal
  if not !ERRORLEVEL! == 0 (
    @echo FAILED: mklink
    @echo reverting deletion...
    git checkout -- "%~f1"
    goto :eof
  )

  git update-index --assume-unchanged "%1"
  if not !ERRORLEVEL! == 0 (
    @echo FAILED: git update-index --assume-unchanged
    goto :eof
  )
  @echo SUCCESS
  goto :eof
)
goto :eof

:: param1 = result variable
:: param2 = reference path from which relative will be resolved
:: param3 = relative path
:expandRelative
  pushd .
  cd "%~dp2"
  set %1=%~f3
  popd
goto :eof

Cały czas korzystam z łączy sym między katalogiem głównym dokumentu a katalogiem git repo. Lubię je rozdzielać. W systemie Windows używam opcji mklink / j. Wygląda na to, że skrzyżowanie pozwala gitowi zachowywać się normalnie:

>mklink /j <location(path) of link> <source of link>

na przykład:

>mklink /j c:\gitRepos\Posts C:\Bitnami\wamp\apache2\htdocs\Posts

Szukałem łatwego rozwiązania problemu z unixowymi dowiązaniami symbolicznymi w systemie Windows. Dziękujemy bardzo za powyższe aliasy Git. Istnieje jedna drobna optymalizacja, którą można wykonać w linkach rm-symlink, aby nie usuwała plików w folderze docelowym w przypadku przypadkowego uruchomienia aliasu po raz drugi. Zwróć uwagę na nowy warunek if w pętli, aby upewnić się, że plik nie jest już linkiem do katalogu przed uruchomieniem logiki.

git config --global alias.rm-symlinks '!__git_rm_symlinks(){
for symlink in $(git ls-files -s | egrep "^120000" | cut -f2); do
    *if [ -d "$symlink" ]; then
      continue
    fi*
    git rm-symlink "$symlink"
    git update-index --assume-unchanged "$symlink"
done
}; __git_rm_symlinksenter 

Jedną z prostych sztuczek, których używamy, jest po prostu połączenie git add --alldwa razy z rzędu.

Na przykład nasze wywołania skryptów zatwierdzania systemu Windows 7:

$ git add --all
$ git add --all

Pierwszy dodatek traktuje link jako tekst i dodaje foldery do usunięcia.

Drugi dodatek poprawnie przegląda link i cofa usunięcie poprzez przywrócenie plików.

Jest mniej elegancki niż niektóre inne proponowane rozwiązania, ale jest prostą poprawką do niektórych naszych starszych środowisk, w których dodano dowiązania symboliczne.