Close

Czym jest Git LFS?


Git jest rozproszonym systemem kontroli wersji, co oznacza, że cała historia repozytorium jest przekazywana do klienta podczas procesu klonowania. W przypadku projektów zawierających duże pliki, a w szczególności takie, które są regularnie modyfikowane, to początkowe klonowanie może zająć ogromną ilość czasu, ponieważ klient musi pobrać wszystkie wersje każdego pliku. Git LFS (Large File Storage) to rozszerzenie Git opracowane przez Atlassian, GitHub i kilku innych współtwórców oprogramowania open source. Zmniejsza ono wpływ dużych plików na repozytorium dzięki stopniowemu pobieraniu potrzebnych wersji. Duże pliki są pobierane podczas procesu wyewidencjonowania, a nie podczas klonowania ani pobierania.

W tym celu Git LFS zastępuje duże pliki w repozytorium małymi plikami wskaźnika. Podczas normalnego użytkowania nigdy nie zobaczysz tych plików, ponieważ są one obsługiwane automatycznie przez Git LFS:

1. Po dodaniu pliku do repozytorium Git LFS zastępuje jego zawartość wskaźnikiem i zapisuje zawartość pliku w lokalnej pamięci podręcznej Git LFS.

Schemat git add
Bazy danych
materiały pokrewne

Jak przenieść pełne repozytorium Git

Logo Bitbucket
POZNAJ ROZWIĄZANIE

Poznaj środowisko Git z rozwiązaniem Bitbucket Cloud

2. Gdy wypychasz nowe commity na serwer, wszystkie pliki Git LFS, do których odwołują się nowo wypchnięte commity, są przesyłane z lokalnej pamięci podręcznej Git LFS do zdalnego magazynu Git LFS powiązanego z repozytorium Git.

Schemat git push

Po wyewidencjonowaniu zatwierdzenia zawierającego wskaźniki Git LFS są one zastępowane plikami z lokalnej pamięci podręcznej Git LFS lub pobierane ze zdalnego magazynu Git LFS.

Schemat git push

Git LFS zapewnia bezproblemową obsługę: w kopii roboczej zobaczysz tylko rzeczywistą zawartość pliku. Oznacza to, że możesz używać Git LFS bez zmiany istniejącego przepływu pracy Git. Po prostu wykonaj polecenie git checkout, zmodyfikuj plik, a następnie użyj poleceń git add i git commit. Operacje git clone i git pull będą znacznie szybsze, ponieważ pobierasz tylko wersje dużych plików, do których odwołują się commity, które faktycznie wyewidencjonujesz, a nie każdą wersję pliku, jaka kiedykolwiek istniała.

Aby korzystać z Git LFS, potrzebujesz hosta obsługującego tę funkcję, takiego jak Bitbucket Cloud lub Bitbucket Data Center. Użytkownicy repozytorium będą musieli mieć zainstalowanego klienta wiersza polecenia Git LFS lub klienta z graficznym interfejsem użytkownika obsługującego Git LFS, takiego jak Sourcetree. Ciekawostka: Steve Streeting, deweloper Atlassian, który stworzył Sourcetree, jest również głównym współautorem projektu Git LFS, więc Sourcetree i Git LFS bardzo dobrze ze sobą współpracują.

Instalowanie Git LFS


1. Istnieją trzy proste sposoby instalacji Git LFS:

a. Zainstaluj to narzędzie za pomocą ulubionego menedżera pakietów. Pakietygit-lfs są dostępne dla programów Homebrew, MacPorts, dnf i packagecloud.

b. Pobierz i zainstaluj Git LFS ze strony internetowej projektu.

c. Zainstaluj Sourcetree, darmowego klienta Git z graficznym interfejsem użytkownika, który jest dostarczany z Git LFS.

2. Przejdź do katalogu git-lfs i uruchom polecenie git lfs install, aby zainicjować Git LFS (możesz pominąć ten krok, jeśli zainstalowano Sourcetree):

$ git lfs install Git LFS initialized. 

Polecenie git lfs install należy uruchomić tylko raz. Po zainicjowaniu dla Twojego systemu Git LFS uruchomi się automatycznie po sklonowaniu repozytorium z zawartością Git LFS.

Tworzenie nowego repozytorium Git LFS


Aby utworzyć nowe repozytorium Git LFS, uruchom polecenie git lfs install po utworzeniu repozytorium:

# initialize Git
$ mkdir Atlasteroids
$ cd Atlasteroids
$ git init
Initialized empty Git repository in /Users/tpettersen/Atlasteroids/.git/
  
# initialize Git LFS
$ git lfs install
Updated pre-push hook.
Git LFS initialized.

Spowoduje to zainstalowanie specjalnego hooka Git do wstępnego wypychania w repozytorium, który będzie przesyłał pliki Git LFS na serwer podczas operacji git push.

Obsługa Git LFS jest automatycznie włączona dla wszystkich repozytoriów Bitbucket Cloud. W przypadku Bitbucket Data Center musisz włączyć Git LFS w ustawieniach repozytorium:

Bitbucket Git LFS

Po zainicjowaniu Git LFS dla repozytorium możesz określić, które pliki mają być śledzone, używając polecenia git lfs track.

Klonowanie istniejącego repozytorium Git LFS


Po zainstalowaniu Git LFS możesz sklonować repozytorium Git LFS jak zwykle za pomocą polecenia git clone. Pod koniec procesu klonowania Git sprawdzi domyślną gałąź (zwykle main), a wszystkie pliki Git LFS potrzebne do zakończenia procesu realizacji transakcji zostaną pobrane automatycznie. Przykład:

$ git clone git@bitbucket.org:tpettersen/Atlasteroids.git
Cloning into 'Atlasteroids'...
remote: Counting objects: 156, done.
remote: Compressing objects: 100% (154/154), done.
remote: Total 156 (delta 87), reused 0 (delta 0)
Receiving objects: 100% (156/156), 54.04 KiB | 31.00 KiB/s, done.
Resolving deltas: 100% (87/87), done.
Checking connectivity... done.
Downloading Assets/Sprites/projectiles-spritesheet.png (21.14 KB)
Downloading Assets/Sprites/productlogos_cmyk-spritesheet.png (301.96 KB)
Downloading Assets/Sprites/shuttle2.png (1.62 KB)
Downloading Assets/Sprites/space1.png (1.11 MB)
Checking out files: 100% (81/81), done.

W tym repozytorium są 4 pliki PNG śledzone przez Git LFS. Podczas uruchamiania polecenia git clone pliki Git LFS są pobierane pojedynczo, ponieważ pliki wskaźnika są wyewidencjonowane z repozytorium.

Przyspieszanie klonowania


Jeśli klonujesz repozytorium z dużą liczbą plików LFS, polecenie git lfs clone jest znacznie bardziej wydajne:

$ git lfs clone git@bitbucket.org:tpettersen/Atlasteroids.git
Cloning into 'Atlasteroids'...
remote: Counting objects: 156, done.
remote: Compressing objects: 100% (154/154), done.
remote: Total 156 (delta 87), reused 0 (delta 0)
Receiving objects: 100% (156/156), 54.04 KiB | 0 bytes/s, done.
Resolving deltas: 100% (87/87), done.
Checking connectivity... done.
Git LFS: (4 of 4 files) 1.14 MB / 1.15 MB

Zamiast pobierać pliki Git LFS pojedynczo, polecenie git lfs clone czeka na zakończenie operacji wyewidencjonowania, a następnie pobiera wsadowo wszystkie wymagane pliki Git LFS. Wykorzystuje w ten sposób równoległe pobieranie oraz radykalnie zmniejsza liczbę żądań HTTP i tworzonych procesów (co jest szczególnie ważne dla poprawy wydajności w systemie Windows).

Operacje ściągnięcia kodu i wyewidencjonowania


Podobnie jak w przypadku klonowania, możesz wykonać operację ściągnięcia kodu z repozytorium Git LFS, używając polecenia git pull. Wszystkie potrzebne pliki Git LFS zostaną pobrane w ramach automatycznego procesu wyewidencjonowania po zakończeniu operacji ściągnięcia kodu:

$ git pull
Updating 4784e9d..7039f0a
Downloading Assets/Sprites/powerup.png (21.14 KB)
Fast-forward
 Assets/Sprites/powerup.png      |    3 +
 Assets/Sprites/powerup.png.meta | 4133 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 4136 insertions(+)
 create mode 100644 Assets/Sprites/projectiles-spritesheet.png
 create mode 100644 Assets/Sprites/projectiles-spritesheet.png.meta

Do pobrania zawartości Git LFS nie są potrzebne żadne specjalne polecenia. Jeśli jednak wyewidencjonowanie nie powiedzie się z nieoczekiwanego powodu, możesz pobrać brakującą zawartość Git LFS dla bieżącego commitu za pomocą polecenia git lfs pull:

$ git lfs pull
Git LFS: (4 of 4 files) 1.14 MB / 1.15 MB

Przyspieszanie operacji ściągnięcia kodu


Podobnie jak git lfs clone, polecenie git lfs pull pobiera pliki Git LFS wsadowo. Jeśli wiesz, że duża liczba plików zmieniła się od ostatniej operacji ściągnięcia kodu, możesz wyłączyć automatyczne pobieranie Git LFS podczas wyewidencjonowania, a następnie wsadowo pobrać zawartość Git LFS za pomocą polecenia git lfs pull. W tym celu możesz nadpisać konfigurację Git, używając opcji -c podczas wywoływania polecenia git pull:

$ git -c filter.lfs.smudge= -c filter.lfs.required=false pull && git lfs pull

Ponieważ wymaga to sporo pisania, warto utworzyć prosty alias Git , aby wykonać operację wsadowego ściągania kodu Git i Git LFS:

$ git config --global alias.plfs "\!git -c filter.lfs.smudge= -c filter.lfs.required=false pull && git lfs pull"
$ git plfs

Znacznie poprawi to wydajność, gdy będzie trzeba pobrać dużą liczbę plików Git LFS (szczególnie w systemie Windows).

Śledzenie plików za pomocą Git LFS


Po dodaniu nowego typu dużego pliku do repozytorium musisz poinformować Git LFS, że ma być śledzony, określając wzorzec za pomocą polecenia git lfs track:

$ git lfs track "*.ogg"
Tracking *.ogg

Cudzysłowy wokół "*.ogg" są ważne. Pominięcie ich spowoduje rozszerzenie symbolu wieloznacznego przez powłokę, a poszczególne wpisy zostaną utworzone dla każdego pliku z rozszerzeniem .ogg w bieżącym katalogu:

# probably not what you want
$ git lfs track *.ogg
Tracking explode.ogg
Tracking music.ogg
Tracking phaser.ogg

Wzorce obsługiwane przez Git LFS są takie same jak te obsługiwane przez .gitignore. Na przykład:

# track all .ogg files in any directory
$ git lfs track "*.ogg"
  
# track files named music.ogg in any directory
$ git lfs track "music.ogg"
  
# track all files in the Assets directory and all subdirectories
$ git lfs track "Assets/"
  
# track all files in the Assets directory but *not* subdirectories
$ git lfs track "Assets/*"
  
# track all ogg files in Assets/Audio
$ git lfs track "Assets/Audio/*.ogg"
  
# track all ogg files in any directory named Music
$ git lfs track "**/Music/*.ogg"
  
# track png files containing "xxhdpi" in their name, in any directory
$ git lfs track "*xxhdpi*.png

Te wzorce są względne w stosunku do katalogu, w którym uruchomiono polecenie git lfs track. Aby wszystko uprościć, najlepiej jest uruchomić polecenie git lfs track w katalogu głównym repozytorium. Warto pamiętać, że negatywnych wzorców (obsługiwanych przez .gitignore) nie można używać w przypadku Git LFS.

Po uruchomieniu polecenia git lfs track zauważysz nowy plik o nazwie .gitattributes w katalogu, w którym uruchomiono polecenie. Plik .gitattributes jest mechanizmem Git do wiązania specjalnych zachowań z określonymi wzorcami plików. Git LFS automatycznie tworzy lub aktualizuje pliki .gitattributes, aby powiązać śledzone wzorce plików z filtrem Git LFS. Jednak będzie trzeba samodzielnie zatwierdzić wszelkie zmiany w pliku .gitattributes w repozytorium:

$ git lfs track "*.ogg"
Tracking *.ogg
  
$ git add .gitattributes
  
$ git diff --cached
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..b6dd0bb
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+*.ogg filter=lfs diff=lfs merge=lfs -text
  
$ git commit -m "Track ogg files with Git LFS"

Aby ułatwić obsługę, najłatwiej jest przechowywać wszystkie wzorce Git LFS w jednym pliku .gitattributes, zawsze uruchamiając polecenie git lfs track z katalogu głównego repozytorium. Można jednak wyświetlić listę wszystkich wzorców, które są aktualnie śledzone przez Git LFS (i pliki .gitattributes zawierające ich definicje), przez wywołanie polecenia git lfs track bez argumentów:

$ git lfs track
Listing tracked paths
    *.stl (.gitattributes)
    *.png (Assets/Sprites/.gitattributes)
    *.ogg (Assets/Audio/.gitattributes)

Śledzenie określonego wzorca za pomocą Git LFS można zatrzymać, usuwając odpowiedni wiersz z pliku .gitattributes lub uruchamiając polecenie git lfs untrack:

$ git lfs untrack "*.ogg"
Untracking *.ogg
$ git diff
diff --git a/.gitattributes b/.gitattributes
index b6dd0bb..e69de29 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +0,0 @@
-*.ogg filter=lfs diff=lfs merge=lfs -text

Po uruchomieniu polecenia git lfs untrack trzeba samodzielnie zatwierdzić zmiany w pliku .gitattributes jeszcze raz.

Zatwierdzanie i wypychanie


Operacje zatwierdzania i ściągnięcia kodu można wykonywać w repozytorium zawierającym zawartość Git LFS. Jeśli dokonano zmian w plikach śledzonych przez Git LFS, podczas przesyłania zawartości Git LFS na serwer pojawią się dodatkowe dane wyjściowe polecenia git push:

$ git push
Git LFS: (3 of 3 files) 4.68 MB / 4.68 MB                                                                                               
Counting objects: 8, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (8/8), done.
Writing objects: 100% (8/8), 1.16 KiB | 0 bytes/s, done.
Total 8 (delta 1), reused 0 (delta 0)
To git@bitbucket.org:tpettersen/atlasteroids.git
   7039f0a..b3684d3  main -> main

Jeśli przesyłanie plików LFS z jakiegoś powodu nie powiedzie się, operacja wypychania zostanie przerwana i będzie można bezpiecznie spróbować ponownie. Podobnie jak w przypadku Git, zawartość w magazynie Git LFS jest adresowalna, czyli przechowywana przy użyciu klucza, który jest skrótem SHA-256 samej zawartości. Oznacza to, że ponowne przesyłanie plików Git LFS na serwer jest zawsze bezpieczne — nie można przypadkowo zastąpić zawartości pliku Git LFS niewłaściwą wersją.

Przenoszenie repozytorium Git LFS między hostami


Aby przenieść repozytorium Git LFS od jednego dostawcy usług hostingowych do innego, można użyć kombinacji poleceń git lfs fetch i git lfs push, podając parametr --all opcja.

Przykład przenoszenia wszystkich repozytoriów Git i Git LFS ze zdalnej lokalizacji o nazwie github do zdalnej lokalizacji o nazwie bitbucket 😉:

# create a bare clone of the GitHub repository
$ git clone --bare git@github.com:kannonboy/atlasteroids.git
$ cd atlasteroids
  
# set up named remotes for Bitbucket and GitHub
$ git remote add bitbucket git@bitbucket.org:tpettersen/atlasteroids.git
$ git remote add github git@github.com:kannonboy/atlasteroids.git
  
# fetch all Git LFS content from GitHub
$ git lfs fetch --all github
 
# push all Git and Git LFS content to Bitbucket
$ git push --mirror bitbucket
$ git lfs push --all bitbucket

Pobieranie dodatkowej historii Git LFS


Git LFS zazwyczaj pobiera tylko pliki potrzebne w przypadku commitów, które są faktycznie wyewidencjonowane lokalnie. Za pomocą polecenia git lfs fetch --recent można jednak wymusić pobranie dodatkowej zawartości przez Git LFS dla innych ostatnio zmodyfikowanych gałęzi:

$ git lfs fetch --recent
Fetching main
Git LFS: (0 of 0 files, 14 skipped) 0 B / 0 B, 2.83 MB skipped                                                                           Fetching recent branches within 7 days
Fetching origin/power-ups
Git LFS: (8 of 8 files, 4 skipped) 408.42 KB / 408.42 KB, 2.81 MB skipped
Fetching origin/more-music
Git LFS: (1 of 1 files, 14 skipped) 1.68 MB / 1.68 MB, 2.83 MB skipped

Jest to przydatne do wsadowego pobierania nowej zawartości Git LFS (np. gdy wychodzisz na lunch) lub jeśli planujesz przejrzeć pracę członków zespołu i nie będziesz mieć później możliwości pobrania zawartości z powodu ograniczonej łączności z Internetem. Możesz na przykład uruchomić polecenie git lfs fetch --recent przed wejściem na pokład samolotu.

Git LFS uważa każdą gałąź lub tag zawierający commity mające mniej niż 7 dni za najnowsze. Możesz skonfigurować liczbę dni uznawanych za najnowsze, ustawiając właściwość lfs.fetchrecentrefsdays:

# download Git LFS content for branches or tags updated in the last 10 days
$ git config lfs.fetchrecentrefsdays 10

Domyślnie polecenie git lfs fetch --recent pobierze tylko zawartość Git LFS commitu na końcu ostatniej gałęzi lub tagu.

git lfs - git lfs fetch --recent

Możesz jednak skonfigurować Git LFS do pobierania zawartości wcześniejszych commitów z ostatnich gałęzi i tagów, konfigurując właściwość lfs.fetchrecentcommitsdays:

# download the latest 3 days of Git LFS content for each recent branch or tag
$ git config lfs.fetchrecentcommitsdays 3

Używaj tego ustawienia ostrożnie. Jeśli masz często zmieniające się gałęzie, może to spowodować pobranie ogromnej ilości danych. Może to być jednak przydatne, jeśli chcesz przejrzeć częściowe zmiany w gałęzi, wybrane commity w różnych gałęziach lub zmienić historię.

git lfs - git lfs fetch --recent commits

Jak opisywaliśmy w temacie Przenoszenie repozytorium Git LFS między hostami można pobrać całą zawartość repozytorium Git LFS przy użyciu polecenia git lfs fetch --all:

$ git lfs fetch --all
Scanning for all objects ever referenced...
✔ 23 objects found                                                                                                                      
Fetching objects...
Git LFS: (9 of 9 files, 14 skipped) 2.06 MB / 2.08 MB, 2.83 MB skipped

Usuwanie lokalnych plików Git LFS


Pliki z lokalnej pamięci podręcznej Git LFS możesz usunąć za pomocą polecenia git lfs prune:

$ git lfs prune
✔ 4 local objects, 33 retained                                                                                                         
Pruning 4 files, (2.1 MB)
✔ Deleted 4 files

Spowoduje to usunięcie wszystkich lokalnych plików Git LFS, które są stare. Stary plik to dowolny plik, do którego nie odwołuje się:

  • aktualnie wyewidencjonowany commit;
  • commit, który nie został jeszcze wypchnięty (do lokalizacji źródłowej lub dowolnej ustawionej dla lfs.pruneremotetocheck);
  • najnowszy commit.

Domyślny ostatni commit to dowolny commit utworzony w ciągu ostatnich 10 dni. Jest to obliczane przez dodanie:

  • wartość właściwości lfs.fetchrecentrefsdays omówionej w sekcji Pobieranie dodatkowej historii Git LFS (która domyślnie wynosi 7) do
  • wartości właściwości lfs.pruneoffsetdays (która domyślnie wynosi 3).
git lfs prune

Przesunięcie oczyszczania można skonfigurować tak, aby zawartość Git LFS była przechowywana przez dłuższy czas:

# don't prune commits younger than four weeks (7 + 21)
$ git config lfs.pruneoffsetdays 21

W przeciwieństwie do wbudowanego systemu usuwania zbędnych elementów Git zawartość Git LFS nie jest przycinana automatycznie, więc regularne uruchamianie polecenia git lfs prune jest dobrym pomysłem, jeśli chcesz zmniejszyć rozmiar repozytorium lokalnego.

Aby sprawdzić, jaki wpływ będzie miała operacja oczyszczania, użyj polecenia git lfs prune --dry-run:

$ git lfs prune --dry-run
✔ 4 local objects, 33 retained                                                                                                         
4 files would be pruned (2.1 MB)

Obiekty Git LFS, które zostaną wyczyszczone, można sprawdzić przy użyciu polecenia git lfs prune --verbose --dry-run:

$ git lfs prune --dry-run --verbose
✔ 4 local objects, 33 retained                                                                                                         
4 files would be pruned (2.1 MB)
 * 4a3a36141cdcbe2a17f7bcf1a161d3394cf435ac386d1bff70bd4dad6cd96c48 (2.0 MB)
 * 67ad640e562b99219111ed8941cb56a275ef8d43e67a3dac0027b4acd5de4a3e (6.3 KB)
 * 6f506528dbf04a97e84d90cc45840f4a8100389f570b67ac206ba802c5cb798f (1.7 MB)
 * a1d7f7cdd6dba7307b2bac2bcfa0973244688361a48d2cebe3f3bc30babcf1ab (615.7 KB)

Długie łańcuchy szesnastkowe w danych wyjściowych trybu --verbose to skróty SHA-256 (znane również jako identyfikatory obiektów lub OID) obiektów Git LFS, które mają zostać usunięte. Aby dowiedzieć się więcej o obiektach, które zostaną usunięte, możesz użyć technik opisanych w sekcji Znajdowanie ścieżek lub commitów zawierających odwołania do obiektu Git LFS.

Jako dodatkową kontrolę bezpieczeństwa, możesz użyć opcji --verify-remote, aby sprawdzić, czy zdalny magazyn Git LFS zawiera kopię obiektów Git LFS przed ich usunięciem:

$ git lfs prune --verify-remote
✔ 16 local objects, 2 retained, 12 verified with remote                                                                                             
Pruning 14 files, (1.7 MB)
✔ Deleted 14 files

Sprawia to, że proces usuwania jest znacznie wolniejszy, ale daje pewność, że wszelkie oczyszczone obiekty można odzyskać z serwera. Opcję --verify-remote można włączyć na stałe dla systemu, konfigurując globalnie właściwość lfs.pruneverifyremotealways:

$ git config --global lfs.pruneverifyremotealways true 

Możesz też włączyć zdalną weryfikację tylko dla repozytorium kontekstowego, pomijając opcję --global w powyższym poleceniu.

Usuwanie zdalnych plików Git LFS z serwera


Klient wiersza poleceń Git LFS nie obsługuje czyszczenia plików na serwerze, więc sposób ich usunięcia zależy od dostawcy usług hostingowych.

W Bitbucket Cloud możesz przeglądać i usuwać pliki Git LFS za pomocą opcji [Repository Settings > Git LFS]:

Bitbucket Cloud — usuwanie plików lfs z serwera

Należy pamiętać, że każdy plik Git LFS jest indeksowany przy użyciu skrótu SHA-256 OID. Ścieżki odwołujące się do poszczególnych plików nie są widoczne w interfejsie użytkownika. Wynika to z tego, że w wielu różnych commitach może być wiele różnych ścieżek, które mogą odnosić się do danego obiektu, więc ich szukanie byłoby bardzo powolne.

Aby ustalić, co faktycznie zawiera dany plik Git LFS, masz trzy opcje:

  • Spójrz na obraz podglądu pliku i typ pliku w lewej kolumnie interfejsu użytkownika Bitbucket Git LFS.
  • Pobierz plik za pomocą odnośnika znajdującego się w prawej kolumnie interfejsu użytkownika Bitbucket Git LFS. Wyszukaj commity odwołujące się do OID SHA-256 obiektu Git LFS, jak omówiono w następnej sekcji.

Znajdowanie ścieżek lub commitów zawierających odwołania do obiektu Git LFS


Jeśli masz identyfikator OID SHA-256 Git LFS, możesz ustalić, które commity się do niego odwołują, używając polecenia git log --all -p -S :

$ git log --all -p -S 3b6124b8b01d601fa20b47f5be14e1be3ea7759838c1aac8f36df4859164e4cc
commit 22a98faa153d08804a63a74a729d8846e6525cb0
Author: Tim Pettersen <tpettersen@atlassian.com>
Date:   Wed Jul 27 11:03:27 2016 +1000
 
    Projectiles and exploding asteroids
 
diff --git a/Assets/Sprites/projectiles-spritesheet.png
new file mode 100755
index 0000000..49d7baf
--- /dev/null
+++ b/Assets/Sprites/projectiles-spritesheet.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b6124b8b01d601fa20b47f5be14e1be3ea7759838c1aac8f36df4859164e4cc
+size 21647

To wywołanie polecenia git log generuje poprawkę (-p) z commitów w każdej gałęzi (--all), która dodaje lub usuwa wiersz (-S) zawierający określony ciąg (OID SHA-256 Git LFS).

Łatka pokazuje commit i ścieżkę do obiektu LFS, a także użytkownika, który go dodał, i czas zatwierdzenia. Możesz po prostu wyewidencjonować commit, a Git LFS w razie potrzeby pobierze plik i umieści go w kopii roboczej.

Jeśli podejrzewasz, że dany obiekt Git LFS znajduje się w bieżącym wskaźniku HEAD lub w określonej gałęzi, możesz użyć polecenia git grep, aby znaleźć ścieżkę pliku, która się do niego odwołuje:

# find a particular object by OID in HEAD
$ git grep 3b6124b8b01d601fa20b47f5be14e1be3ea7759838c1aac8f36df4859164e4cc HEAD
HEAD:Assets/Sprites/projectiles-spritesheet.png:oid sha256:3b6124b8b01d601fa20b47f5be14e1be3ea7759838c1aac8f36df4859164e4cc
  
# find a particular object by OID on the "power-ups" branch
$ git grep e88868213a5dc8533fc9031f558f2c0dc34d6936f380ff4ed12c2685040098d4 power-ups
power-ups:Assets/Sprites/shield2.png:oid sha256:e88868213a5dc8533fc9031f558f2c0dc34d6936f380ff4ed12c2685040098d4

Wskaźnik HEAD lub rozszerzenie Power-Up można zastąpić dowolnym odwołaniem, commitem lub drzewem zawierającym obiekt Git LFS.

Uwzględnianie/wykluczanie plików Git LFS


W niektórych sytuacjach może być konieczne pobranie tylko podzbioru dostępnej zawartości Git LFS dla konkretnego commitu. Na przykład podczas konfigurowania kompilacji ciągłej integracji do uruchamiania testów jednostkowych może być potrzebny tylko kod źródłowy, więc warto wykluczyć duże pliki, które nie są konieczne do kompilacji kodu.

Wzorzec lub podkatalog można wykluczyć przy użyciu polecenia git lfs fetch -X (lub --exclude):

$ git lfs fetch -X "Assets/**" 

Alternatywnie możesz dołączyć tylko określony wzorzec lub podkatalog. Na przykład inżynier dźwięku może pobrać tylko pliki ogg i wav, używając polecenia git lfs fetch -I (lub —include):

$ git lfs fetch -I "*.ogg,*.wav" 

Jeśli połączysz uwzględnienia i wykluczenia, pobierane będą tylko pliki, które pasują do wzorca dołączania i nie pasują do wzorca wykluczenia. Na przykład aby pobrać wszystko z katalogu Assets oprócz plików gif, użyj takiego polecenia:

$ git lfs fetch -I "Assets/**" -X "*.gif" 

Wyklucza i uwzględnia obsługę tych samych wzorców co git lfs track i .gitignore. Możesz określić te wzorce jako stałe dla konkretnego repozytorium, ustawiając właściwości lfs.fetchinclude i lfs.fetchexclude:

$ git config lfs.fetchinclude "Assets/**"
$ git config lfs.fetchexclude "*.gif"

Ustawienia te można również zastosować do każdego repozytorium w systemie, dodając opcję --global.

Blokowanie plików Git LFS


Niestety nie ma łatwego sposobu na rozwiązanie konfliktów związanych ze scalaniem plików binarnych. Dzięki blokowaniu plików Git LFS możesz zablokować pliki według rozszerzenia lub nazwy pliku i zapobiegać nadpisywaniu plików binarnych podczas scalania.

Aby skorzystać z funkcji blokowania plików LFS, musisz najpierw wskazać usłudze Git, jaki typ plików można zablokować. W poniższym przykładzie flaga „--lockable” jest dołączana do polecenia „git lfs track”, które przechowuje pliki PSD w LFS i oznacza je jako blokowane.

$ git lfs track "*.psd" --lockable

Następnie dodaj następujące elementy do pliku.gitattributes:

*.psd filter=lfs diff=lfs merge=lfs -text lockable

Przygotowując się do wprowadzenia zmian w pliku LFS, użyjesz polecenia lock, aby zarejestrować plik jako zablokowany na serwerze Git.

$ git lfs lock images/foo.psd
Locked images/foo.psd

Gdy nie potrzebujesz już blokady plików, możesz ją usunąć za pomocą polecenia unlock w Git LFS.

$ git lfs unlock images/foo.psd

Blokady plików Git LFS mogą być nadpisywane, podobnie jak git push, przy użyciu flagi --force. Nie należy używać flagi --force, nie mając pewności co do podejmowanych działań.

$ git lfs unlock images/foo.psd --force

Udostępnij ten artykuł
Następny temat

Zalecane lektury

Dodaj te zasoby do zakładek, aby dowiedzieć się więcej na temat rodzajów zespołów DevOps lub otrzymywać aktualności na temat metodyki DevOps w Atlassian.

Ludzie współpracujący przy ścianie pełnej narzędzi

Blog Bitbucket

Ilustracja DevOps

Ścieżka szkoleniowa DevOps

Demonstracje funkcji z ekspertami Atlassian

Zobacz, jak Bitbucket Cloud współpracuje z Atlassian Open DevOps

Zapisz się do newslettera DevOps

Thank you for signing up