Is het mogelijk om slechts een deel van een git-project te klonen?

git clone https://github.com/PhantomX/slackbuilds.git 

Je zult uiteindelijk de hele geschiedenis downloaden, dus ik zie er niet veel voordeel in, maar jij kan specifieke onderdelen afrekenen met een “sparse” checkout. Onder vermelding van dit Stack Overflow-bericht :

De stappen om een sparse clone zijn als volgt:

mkdir <repo> cd <repo> git init git remote add -f origin <url> 

Dit creëert een lege repository met je remote, en haalt alle objecten op maar checkt ze niet uit. do:

git config core.sparseCheckout true 

Nu moet u definiëren welke bestanden / mappen u daadwerkelijk wilt uitchecken. Dit doet u door ze op te nemen in .git/info/sparse-checkout, bijvoorbeeld:

 echo "some/dir/" >> .git/info/sparse-checkout echo "another/sub/tree" >> .git/info/sparse-checkout  

Last but not least, update je lege repo met de status van de afstandsbediening:

git pull origin master 

Misschien wil je de uitgebreide tutorial en je zou waarschijnlijk de officiële documentatie voor sparse checkout moeten lezen.

Misschien is het beter om ook een oppervlakkige kloon te gebruiken. In plaats van de git pull commando eerder gegeven, probeer:

git pull --depth=1 origin master 

Reacties

• Ik krijg error: Sparse checkout leaves no entry on working directory nadat ik een git pull heb uitgevoerd nadat ik de wijziging heb aangebracht in core.sparseCheckout en .git/info/sparse-checkout
• Correctie: git init; git remote ... stel gewoon dingen in, er wordt niets gedownload. Het hele punt van sparse is om alleen objecten te krijgen waarin je geïnteresseerd bent.
• @vonbrand dat ‘ is wat de -f optie is voor: ” Met -f optie, git fetch < naam > wordt onmiddellijk uitgevoerd nadat de externe informatie is ingesteld. ”
• Na git remote add -f origin <url> is git nog steeds de hele repo aan het downloaden . In mijn geval wil ik ‘ geen tijd besteden aan wachten, zelfs als het niet ‘ de volledige opslagplaats afrekent.
• Bij sparse checkout definiëren we wat we willen uitchecken, maar is er een manier om een paar mappen uit te sluiten en de rest te bekijken?

git clone --filter van git 2.19 werkt nu op GitHub (getest 2020-09 -18, git 2.25.1)

Deze optie is toegevoegd samen met een update van het remote protocol, en het voorkomt echt dat objecten worden gedownload van de server.

Bijv. om alleen objecten te klonen die nodig zijn voor d1 van deze opslagplaats: https://github.com/cirosantilli/test-git-partial-clone Ik kan doen:

git clone \ --depth 1 \ --filter=blob:none \ --no-checkout \ https://github.com/cirosantilli/test-git-partial-clone \ ; cd test-git-partial-clone git checkout master -- d1 

De kloonopdracht verkrijgt alleen:

• een enkel commit-object met de tip van de master branch
• alle 4 boomobjecten van de repository:
  • map op het hoogste niveau van commit
  • de drie mappen d1, d2, master

Vervolgens haalt het checkout commando alleen de ontbrekende blobs (bestanden) op van de server:

• d1/a
• d1/b

Nog beter, later zal GitHub waarschijnlijk beginnen met het ondersteunen van:

 --filter=blob:none \ --filter=tree:0 \ 

waarbij --filter=tree:0 van Git 2.20 de onnodig clone ophalen van alle boomobjecten, en toestaan dat het wordt uitgesteld naar checkout. Maar op mijn 2020-09-18-test mislukt dat met:

fatal: invalid filter-spec "combine:blob:none+tree:0" 

vermoedelijk omdat het --filter=combine: samengestelde filter ( toegevoegd in Git 2.24, geïmpliceerd door meerdere --filter) is nog niet geïmplementeerd.

Ik heb geobserveerd welke objecten werden opgehaald met:

git verify-pack -v .git/objects/pack/*.pack 

zoals vermeld op: https://stackoverflow.com/questions/7348698/git-how-to-list-all-objects-in-the-database/18793029#18793029 Het geeft me geen super duidelijke indicatie van wat elk object precies is, maar er staat wel het type van elk object (commit, tree, blob), en aangezien er zo weinig objecten in die minimale opslagplaats zijn, kan ik ondubbelzinnig afleiden wat elk object is.

git rev-list --objects --all produceerde duidelijkere uitvoer met paden voor boom / blobs, maar het haalt helaas enkele objecten op wanneer ik het uitvoer, wat het moeilijk maakt om te bepalen wat werd er wanneer opgehaald, laat me weten of iemand een beter commando heeft.

TE DOEN vind GitHub-aankondiging die zegt wanneer ze het begonnen te ondersteunen. https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/ van 17-01-2020 vermeldt al --filter blob:none.

git sparse-checkout

I denk dat dit commando bedoeld is om een instellingenbestand te beheren dat zegt ” Ik geef alleen om deze substructuren ” zodat toekomstige commandos alleen die substructuren. Maar het is een beetje moeilijk om zeker te zijn, omdat de huidige documentatie een beetje … schaars is 😉

Het verhindert op zichzelf niet het ophalen van blobs.

Als dit begrip correct is, dan zou dit een goede aanvulling zijn op git clone --filter hierboven beschreven, aangezien het onbedoeld ophalen van meer objecten zou voorkomen als je van plan bent git-bewerkingen uit te voeren in de gedeeltelijk gekloonde opslagplaats .

Toen ik Git 2.25.1 probeerde:

git clone \ --depth 1 \ --filter=blob:none \ --no-checkout \ https://github.com/cirosantilli/test-git-partial-clone \ ; cd test-git-partial-clone git sparse-checkout init 

werkte het niet omdat de init heeft eigenlijk alle objecten opgehaald.

Echter, in Git 2.28 heeft het de objecten niet opgehaald zoals gewenst. Maar als ik dat doe:

git sparse-checkout set d1 

d1 wordt niet opgehaald en uitgecheckt, ook al zegt dit expliciet should: https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/ # sparse-checkout-and-gedeeltelijke-klonen Met disclaimer:

Houd in de gaten of de partiële kloonfunctie algemeen beschikbaar wordt [1].

[1]: GitHub evalueert deze functie nog steeds intern terwijl deze is ingeschakeld op een select aantal repositories (inclusief het voorbeeld dat in dit bericht wordt gebruikt). Naarmate de functie stabiliseert en rijpt, houden we u op de hoogte van de voortgang.

Dus ja, het is gewoon te moeilijk om zeker te zijn bij de moment, mede dankzij het plezier dat GitHub een gesloten bron is. Maar laten we het in de gaten houden.

Commando-uitsplitsing

De server moet worden geconfigureerd met:

git config --local uploadpack.allowfilter 1 git config --local uploadpack.allowanysha1inwant 1 

Commando-uitsplitsing:

• --filter=blob:none slaat alle blobs over, maar haalt nog steeds alle boomobjecten

• --filter=tree:0 slaat de onnodige bomen over: https://www.spinics.net/lists/git/msg342006.html

• --depth 1 impliceert al --single-branch, zie ook: https://stackoverflow.com/questions/1778088/how-to-clone-a-single-branch-in-git

• file://$(path) is vereist om git clone protocol shenanigans te overwinnen: https://stackoverflow.com/questions/47307578/how-to-shallow-clone-a-local-git-repository-with-a-relative-path

• --filter=combine:FILTER1+FILTER2 is de syntaxis om meerdere filters te gebruiken op een keer proberen om --filter door te geven om de een of andere reden mislukt met: ” meerdere filterspecificaties kunnen niet worden gecombineerd “. Dit is toegevoegd in Git 2.24 op e987df5fe62b8b29be4cdcdeb3704681ada2b29e ” list-objects-filter: implementeer samengestelde filters ”

  Bewerken: op Git 2.28 zie ik experimenteel dat --filter=FILTER1 --filter FILTER2 ook hetzelfde effect heeft, aangezien GitHub combine: nog niet implementeert vanaf 2020-09- 18 en klaagt fatal: invalid filter-spec "combine:blob:none+tree:0". TODO geïntroduceerd in welke versie?

Het formaat van --filter is gedocumenteerd op man git-rev-list.

Documenten in Git-structuur:

• https://github.com/git/git/blob/v2.19.0/Documentation/technical/partial-clone.txt
• https://github.com/git/git/blob/v2.19.0/Documentation/rev-list-options.txt#L720
• https://github.com/git/git/blob/v2.19.0/t/t5616-partial-clone.sh

Test het lokaal

Het volgende script genereert reproduceerbaar de https://github.com/cirosantilli/test-git-partial-clone repository lokaal, doet een lokale kloon en observeert wat er werd gekloond:

#!/usr/bin/env bash set -eu list-objects() ( git rev-list --all --objects echo "master commit SHA: $(git log -1 --format="%H")" echo "mybranch commit SHA: $(git log -1 --format="%H")" git ls-tree master git ls-tree mybranch | grep mybranch git ls-tree master~ | grep root ) # Reproducibility. export GIT_COMMITTER_NAME="a" export GIT_COMMITTER_EMAIL="a" export GIT_AUTHOR_NAME="a" export GIT_AUTHOR_EMAIL="a" export GIT_COMMITTER_DATE="2000-01-01T00:00:00+0000" export GIT_AUTHOR_DATE="2000-01-01T00:00:00+0000" rm -rf server_repo local_repo mkdir server_repo cd server_repo # Create repo. git init --quiet git config --local uploadpack.allowfilter 1 git config --local uploadpack.allowanysha1inwant 1 # First commit. # Directories present in all branches. mkdir d1 d2 printf "d1/a" > ./d1/a printf "d1/b" > ./d1/b printf "d2/a" > ./d2/a printf "d2/b" > ./d2/b # Present only in root. mkdir "root" printf "root" > ./root/root git add . git commit -m "root" --quiet # Second commit only on master. git rm --quiet -r ./root mkdir "master" printf "master" > ./master/master git add . git commit -m "master commit" --quiet # Second commit only on mybranch. git checkout -b mybranch --quiet master~ git rm --quiet -r ./root mkdir "mybranch" printf "mybranch" > ./mybranch/mybranch git add . git commit -m "mybranch commit" --quiet echo "# List and identify all objects" list-objects echo # Restore master. git checkout --quiet master cd .. # Clone. Don"t checkout for now, only .git/ dir. git clone --depth 1 --quiet --no-checkout --filter=blob:none "file://$(pwd)/server_repo" local_repo cd local_repo # List missing objects from master. echo "# Missing objects after --no-checkout" git rev-list --all --quiet --objects --missing=print echo echo "# Git checkout fails without internet" mv ../server_repo ../server_repo.off ! git checkout master echo echo "# Git checkout fetches the missing directory from internet" mv ../server_repo.off ../server_repo git checkout master -- d1/ echo echo "# Missing objects after checking out d1" git rev-list --all --quiet --objects --missing=print 

GitHub stroomopwaarts .

Uitvoer in Git v2.19.0:

# List and identify all objects c6fcdfaf2b1462f809aecdad83a186eeec00f9c1 fc5e97944480982cfc180a6d6634699921ee63ec 7251a83be9a03161acde7b71a8fda9be19f47128 62d67bce3c672fe2b9065f372726a11e57bade7e b64bf435a3e54c5208a1b70b7bcb0fc627463a75 d1 308150e8fddde043f3dbbb8573abb6af1df96e63 d1/a f70a17f51b7b30fec48a32e4f19ac15e261fd1a4 d1/b 84de03c312dc741d0f2a66df7b2f168d823e122a d2 0975df9b39e23c15f63db194df7f45c76528bccb d2/a 41484c13520fcbb6e7243a26fdb1fc9405c08520 d2/b 7d5230379e4652f1b1da7ed1e78e0b8253e03ba3 master 8b25206ff90e9432f6f1a8600f87a7bd695a24af master/master ef29f15c9a7c5417944cc09711b6a9ee51b01d89 19f7a4ca4a038aff89d803f017f76d2b66063043 mybranch 1b671b190e293aa091239b8b5e8c149411d00523 mybranch/mybranch c3760bb1a0ece87cdbaf9a563c77a45e30a4e30e a0234da53ec608b54813b4271fbf00ba5318b99f root 93ca1422a8da0a9effc465eccbcb17e23015542d root/root master commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec mybranch commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec 040000 tree b64bf435a3e54c5208a1b70b7bcb0fc627463a75 d1 040000 tree 84de03c312dc741d0f2a66df7b2f168d823e122a d2 040000 tree 7d5230379e4652f1b1da7ed1e78e0b8253e03ba3 master 040000 tree 19f7a4ca4a038aff89d803f017f76d2b66063043 mybranch 040000 tree a0234da53ec608b54813b4271fbf00ba5318b99f root # Missing objects after --no-checkout ?f70a17f51b7b30fec48a32e4f19ac15e261fd1a4 ?8b25206ff90e9432f6f1a8600f87a7bd695a24af ?41484c13520fcbb6e7243a26fdb1fc9405c08520 ?0975df9b39e23c15f63db194df7f45c76528bccb ?308150e8fddde043f3dbbb8573abb6af1df96e63 # Git checkout fails without internet fatal: "/home/ciro/bak/git/test-git-web-interface/other-test-repos/partial-clone.tmp/server_repo" does not appear to be a git repository fatal: Could not read from remote repository. Please make sure you have the correct access rights and the repository exists. # Git checkout fetches the missing directory from internet remote: Enumerating objects: 1, done. remote: Counting objects: 100% (1/1), done. remote: Total 1 (delta 0), reused 0 (delta 0) Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done. remote: Enumerating objects: 1, done. remote: Counting objects: 100% (1/1), done. remote: Total 1 (delta 0), reused 0 (delta 0) Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done. # Missing objects after checking out d1 ?8b25206ff90e9432f6f1a8600f87a7bd695a24af ?41484c13520fcbb6e7243a26fdb1fc9405c08520 ?0975df9b39e23c15f63db194df7f45c76528bccb 

Conclusies: alle blobs van buiten d1/ ontbreken. Bijv.0975df9b39e23c15f63db194df7f45c76528bccb, wat d2/b is, is er niet na het uitchecken van d1/a.

Merk op dat root/root en mybranch/mybranch ook ontbreken, maar --depth 1 verbergt dat voor de lijst met ontbrekende bestanden. Als je --depth 1 verwijdert, worden ze weergegeven in de lijst met ontbrekende bestanden.

Ik heb een droom

Deze functie kan een revolutie teweegbrengen in Git.

Stel je voor dat je alle codebasis van je onderneming hebt in een enkele opslagplaats zonder lelijke tools van derden, zoals repo .

Stel je voor dat enorme blobs direct in de repo opslaat zonder lelijke extensies van derden .

Stel je voor dat GitHub per bestand / map metadata zoals sterren en machtigingen, zodat je al je persoonlijke spullen onder één opslagplaats kunt opslaan.

Stel je voor dat submodules werden op precies dezelfde manier behandeld als gewone mappen : vraag gewoon een boom-SHA aan en een DNS-achtig mechanisme lost uw verzoek op , kijk eerst naar je lokale ~/.git , dan eerst naar servers die dichterbij komen (de mirror / cache van uw bedrijf) en eindigen op GitHub.

Probeer dit:

svn export https://github.com/PhantomX/slackbuilds/trunk/${directory} 

Reacties

• Dit is de eenvoudigste manier. Het downloadt niet alle opslagplaatsen. Merk op dat we de /trunk moeten toevoegen en /tree/master moeten verwijderen. Meer hier
• Bedankt! Ik wil gewoon een map van de opslagplaats klonen en niet alle mappen in een opslagplaats. En deze werkt echt voor mij.

werkende oplossing:

jij moet je de compressie uitschakelen:

git config --global core.compression 0 

dan moet je ondiepe kloon gebruiken

git clone --depth=1 <url> 

dan is de belangrijkste stap om naar je gekloonde project te cd-en

cd <shallow cloned project dir> 

open nu de kloon, stap voor stap

git fetch --depth=N, with increasing N 

bijv.

git fetch --depth=4 

dan,

git fetch --depth=100 

dan,

git fetch --depth=500 

u kunt kiezen hoeveel stappen u wilt door deze N te vervangen,

en tenslotte alle resterende revisies downloaden gebruiken,

git fetch --unshallow 

stemmen als het je helpt 🙂

Hiermee wordt een specifieke map gekloond en wordt alle geschiedenis verwijderd die er niets mee te maken heeft.

git clone --single-branch -b {branch} [email protected]:{user}/{repo}.git git filter-branch --subdirectory-filter {path/to/folder} HEAD git remote remove origin git remote add origin [email protected]:{user}/{new-repo}.git git push -u origin master 

Reacties

• Hiermee wordt nog steeds de hele geschiedenis gekloond (--depth=1 om te vermijden), en alle andere mappen (??? vermijden?).

Voor GitHub-opslagplaatsen kun je elke sub klonen -mappen van elke GitHub-repository (bij elke referentie) met https://github.com/HR/github-clone

Reacties

• Helaas is dit niet geschikt voor Dockerfile-scenarios omdat het de volledige Python als een afhankelijkheid zou binnenhalen om het slechts één keer te gebruiken tijdens het bouwen van de image.

Ik zal antwoorden met specifieke beperkingen waarmee ik te maken kreeg.

• In VSO was SSH uitgeschakeld door beveiliging, dus kon git archive niet gebruiken. Alleen PAT / CredentialProvider werd ondersteund.
• Onze branch had enorme code, dus git clone zou zelf minimaal 15 minuten duren.

Dit is wat ik deed:

1. Eenmalig handmatig proces: maak in de VSO-gebruikersinterface een nieuw remote branch zeg “emptyBranch” die nul bestanden heeft (alle zijn verwijderd).
2. git clone --depth=1 --single-branch --branch emptyBranch <remote> (vrij snel)
3. git checkout <branchToSyncTo> <directoryToSyncTo> (checkt alleen een specifieke map uit)