Antrą kartą suprantame „Slow Git Fetch“ didelėse saugyklose

Kodėl antrasis „Git“ gavimas užtrunka ilgiau didelėse saugyklose?

Didžiulių saugyklų valdymas yra tipiška programinės įrangos kūrimo užduotis, ypač ilgalaikiams projektams, kurie buvo nuolat tobulinami. Veiksmingo saugyklos valdymo sudėtingumas naudojant tokias Git komandas kaip git atnešti didėja, kai plečiasi saugykla. Įprasta, kad kūrėjai numato ilgą inicialą git atnešti, todėl glumina, kai antrasis gavimas vyksta daug lėčiau, nei tikėtasi.

Kai tarp pirmojo ir antrojo gavimo saugykloje nebuvo jokių pakeitimų, ši situacija tampa daug sudėtingesnė. Didelis projektas, turintis gigabaitų „Git“ istorijos, vis tiek gali užtrukti ilgai, todėl kūrėjams kyla klausimas, kodėl taip nutinka. Šiame scenarijuje dirbant su CI / CD konvejeriais, tokiais kaip Jenkins, veikimo sutrikimai gali būti gana svarbūs.

Kai tarp pirmojo ir antrojo gavimo saugykloje nebuvo jokių pakeitimų, ši situacija tampa daug sudėtingesnė. Didžiulis projektas, turintis gigabaitus Git istorijos, vis dėlto gali parodyti užsitęsusį vykdymo laiką, todėl inžinieriai gali susimąstyti, kodėl taip atsitiko. Šiame scenarijuje dirbant su CI / CD konvejeriais, tokiais kaip Jenkins, veikimo sutrikimai gali būti gana svarbūs.

Šiame straipsnyje mes ištirsime šių lėtų gavimo didelėse saugyklose priežastis. Taip pat išnagrinėsime keletą būdų, kaip neleisti pakartotinai atsisiųsti didelių „Git“ objektų, nes tai pagreitins ir pagerins gavimą.

„Git Fetch“ optimizavimas didelėms saugykloms: paaiškinimas

Anksčiau pateikti scenarijai yra skirti susidoroti su neefektyvumu, kuris atsiranda tada git atnešti komandos vykdomos didelėse saugyklose. Nors saugykloje nebuvo atlikta jokių didelių pakeitimų, šie neefektyvumai paprastai išryškėja po pirminio gavimo, kai „Git“ netyčia atsisiunčia didelių paketų failus. Scenarijai naudoja tokius argumentus kaip --gylis=1 ir -- slyva apriboti įsipareigojimų istoriją ir pašalinti pasenusias nuorodas, siekiant sumažinti nereikalingų atsisiuntimų skaičių. Greitis ir efektyvumas yra labai svarbūs dirbant nuolatinės integracijos (CI) aplinkoje, pvz., Jenkins, todėl tai ypač svarbu.

Pirmasis scenarijus parašytas Bash kalba ir yra labai naudingas atliekant pareigas, susijusias su git atnešti automatizavimas. Nuėjus į vietinės saugyklos katalogą, ji išduoda komandą „Ftch“ su optimaliais parametrais, pvz., --be žymų kad nebūtų gautos nereikalingos žymos ir -- jėga užtikrinti, kad vietinė saugykla ir nuotolinio valdymo pultas būtų visiškai sinchronizuojami. Šis scenarijus taip pat prideda -- slyva parinktis, kuri padeda išlaikyti saugyklą švarią pašalindama nuorodas į nebeegzistuojančias nutolusias šakas. Dėl šių patobulinimų pasiekiamas greitesnis vykdymo greitis, nes sumažėja bendras gautų duomenų dydis.

Labiau pritaikomą parinktį siūlo antrasis scenarijus, parašytas Python. Galima daugiau valdyti ir valdyti klaidas, nes komanda „Git Fetch“ vykdoma iš Python scenarijaus naudojant subprocess.run() funkcija. Kai komandą gauti reikia įtraukti į didesnę sistemą, pvz., CI/CD konvejerį, tai ypač naudinga. Derinti problemas arba patikrinti, ar gavimas buvo sėkmingas, palengvina Python scenarijus, kuris įrašo iškvietimo iškvietimo išvestį ir registruoja visas klaidas. Taip pat lengviau pritaikyti šį sprendimą sudėtingesnei automatizuotai veiklai, nes palaikomas Python scenarijus.

Galiausiai, galutinis metodas atlieka „Git“ gavimą naudojant Node.js. Perduodamų duomenų kiekis gali būti žymiai sumažintas naudojant šį scenarijų, kuriame daugiausia dėmesio skiriama tam tikrų šakų gavimui. Naudojant "+refs/heads/*:refs/remotes/origin/*" Norėdami nurodyti filialus, įsitikinkite, kad atsisiunčiamos tik būtinos nuorodos. Siekiant dar labiau optimizuoti efektyvumą, ši strategija ypač naudinga tais atvejais, kai kūrėjai nori atnaujinti tik konkrečias šakas. Kadangi Node.js yra asinchroninis, šis procesas gali veikti netrukdydamas kitiems procesams, todėl jis puikiai tinka realaus laiko programoms.

#!/bin/bash
# Bash script to improve Git fetch efficiency by avoiding unnecessary pack downloads
# This solution ensures only required refs are fetched
REPO_URL="git@code.wexx.com:ipc/hj_app.git"
LOCAL_REPO_DIR="/path/to/local/repo"
cd $LOCAL_REPO_DIR || exit
# Fetch only the refs that have changed
git fetch --prune --no-tags --force --progress $REPO_URL
# Check the status of the fetch
if [ $? -eq 0 ]; then echo "Fetch successful"; else echo "Fetch failed"; fi

import subprocess
import os
# Function to run a Git fetch command and handle output
def git_fetch(repo_path, repo_url):
    os.chdir(repo_path)
    command = ["git", "fetch", "--prune", "--no-tags", "--force", "--depth=1", repo_url]
    try:
        result = subprocess.run(command, capture_output=True, text=True)
        if result.returncode == 0:
            print("Fetch completed successfully")
        else:
            print(f"Fetch failed: {result.stderr}")
    except Exception as e:
        print(f"Error: {str(e)}")

const { exec } = require('child_process');
const repoUrl = "git@code.wexx.com:ipc/hj_app.git";
const repoDir = "/path/to/local/repo";
# Function to fetch only a single branch
const fetchBranch = (branch) => {
  exec(`cd ${repoDir} && git fetch --no-tags --force ${repoUrl} ${branch}`, (err, stdout, stderr) => {
    if (err) {
      console.error(\`Error: ${stderr}\`);
    } else {
      console.log(\`Fetched ${branch} successfully: ${stdout}\`);
    }
  });
};
# Fetching a specific branch to optimize performance
fetchBranch('refs/heads/main');

import unittest
from fetch_script import git_fetch
class TestGitFetch(unittest.TestCase):
    def test_successful_fetch(self):
        result = git_fetch('/path/to/repo', 'git@code.wexx.com:ipc/hj_app.git')
        self.assertIsNone(result)
    def test_failed_fetch(self):
        result = git_fetch('/invalid/path', 'git@code.wexx.com:ipc/hj_app.git')
        self.assertIsNotNone(result)
if __name__ == '__main__':
    unittest.main()

„Big Pack“ failų poveikio „Git Fetch“ greičiui tyrimas

Viena iš mažiau žinomų priežasčių git atnešti Ilgesnis antrasis paleidimas yra susijęs su Git tvarkymu su didelėmis saugyklomis, ty paketų failais. Pack failai, kurie yra suspausti objektų, pvz., commits, medžių ir blobų, rinkiniai, yra veiksmingas būdas Git saugoti saugyklos duomenis. Nors tai taupo vietą, gali užtrukti gavimas, ypač jei didelės pakuotės failai atsisiunčiami dažniau nei būtina. Šie paketų failai gali tapti labai dideli ir sukelti ilgą gavimo laiką, kai saugykla laikui bėgant didėja, kaip tai gali būti projekte, kuris buvo kuriamas keletą metų.

Labai svarbu suprasti, kaip „Git“ naudoja konkrečias vėliavėles, kad optimizuotų gavimo procesus, kad būtų išvengta šios problemos. Pavyzdžiui, gaunama tik naujausia įvykdymo istorija, kai --gylis=1 Naudojama parinktis apriboja gavimą iki seklios kopijos. Nepaisant to, jei „Git“ aptinka šakų skirtumų ar pakeitimų, konkrečiomis aplinkybėmis jis vis tiek gali nuspręsti atsisiųsti nemažą paketo failą. Net jei nėra didelių saugyklos atnaujinimų, tai gali įvykti ir sukelti painiavą tarp inžinierių.

Naudojant git fetch --slyva pašalinti nereikalingas šakas ir nuorodas yra papildomas būdas padėti išvalyti pasenusias nutolusias šakas. Galite drastiškai sutrumpinti gavimo laiką, reguliariai išvalydami saugyklą ir užtikrindami, kad būtų gauti tik svarbūs duomenys. Tai labai naudinga naudojant nuolatinio integravimo / nuolatinio tobulinimo (CI / CD) sąrankas, kai pasikartojantys gavimas gali trukdyti kurti greitį ir kūrimo efektyvumą.