Slow Git Fetch'i mõistmine suurtes hoidlates teist korda

Miks võtab teine ​​Giti toomine suurtes hoidlates kauem aega?

Massiivsete hoidlate haldamine on tarkvaraarenduses tüüpiline ülesanne, eriti pikaajaliste projektide puhul, mida on pidevalt arendatud. Hoidla tõhusa haldamise keerukus Giti käskudega nagu git tuua suureneb hoidla laienedes. On tavaline, et arendajad ootavad pikka initsiaali git tuua, seega tekitab segadust, kui teine ​​toomine toimub oodatust palju aeglasemalt.

Kui hoidlas ei ole esimese ja teise toomise vahel muudatusi toimunud, muutub see olukord palju segasemaks. Gigabaidise Giti ajalooga projekti puhul võib siiski olla pikk teostusaeg, pannes arendajad mõtlema, miks see nii juhtub. Selles stsenaariumis töötamine CI/CD torujuhtmetega, nagu Jenkins, võib muuta jõudluse ebakorrapärasused üsna oluliseks.

Kui hoidlas ei ole esimese ja teise toomise vahel muudatusi toimunud, muutub see olukord palju segasemaks. Hiiglaslik projekt, mis sisaldab gigabaiti Giti ajalugu, võib siiski näidata pikaleveninud täitmisaega, pannes insenerid mõtlema, miks see juhtus. Selles stsenaariumis töötamine CI/CD torujuhtmetega, nagu Jenkins, võib muuta jõudluse ebakorrapärasused üsna oluliseks.

Selles artiklis uurime nende aeglaste laadimiste põhjuseid suurtes hoidlates. Uurime ka mõningaid viise, kuidas vältida suurte Git-objektide korduvat allalaadimist, mis kiirendab ja parandab teie laadimist.

Git Fetch'i optimeerimine suurte hoidlate jaoks: selgitus

Eelnevalt antud skriptid on mõeldud tegelema ebaefektiivsusega, mis ilmneb git tuua käske antakse suurtes hoidlates. Ehkki hoidlas pole suuri muudatusi tehtud, ilmnevad need ebaefektiivsused tavaliselt pärast esmast toomist, kui Git laadib kogemata alla suured pakifailid. Skriptid kasutavad argumente nagu --sügavus=1 ja -- ploomid piirata sissekannete ajalugu ja eemaldada aegunud viited, et minimeerida tarbetuid allalaadimisi. Kiiruse ja tõhususe säilitamine on pideva integratsiooni (CI) keskkondades (nt Jenkins) töötamisel kriitilise tähtsusega, seetõttu on see eriti oluline.

Esimene skript on kirjutatud bashi keeles ja on sellega seotud ülesannete täitmisel väga kasulik git tuua automatiseerimine. Pärast kohalikku hoidla kataloogi navigeerimist väljastab see käsku toomine optimaalsete parameetritega, näiteks --silte pole et vältida tarbetute siltide toomist ja -- jõudu tagamaks, et kohalik hoidla ja kaugjuhtimispult on täielikult sünkroonitud. See skript lisab ka -- ploomid suvand, mis aitab hoida hoidla puhtana, eemaldades viited enam mitteolemasolevatele kaugharudele. Nende täiustuste abil saavutatakse kiirem täitmiskiirus, vähendades hangitud andmete kogumahtu.

Kohandatavamat võimalust pakub teine ​​skript, mis on kirjutatud Pythonis. Rohkem juhtimist ja vigade käsitlemist on võimalik, kuna Giti toomise käsk käivitatakse Pythoni skriptis, kasutades subprocess.run() funktsiooni. Kui taastamiskäsk tuleb kaasata suuremasse süsteemi, näiteks CI/CD torujuhtmesse, on see eriti kasulik. Probleemide silumise või toomise õnnestumise kontrollimise teeb lihtsaks Pythoni skript, mis salvestab toomiskutse väljundi ja logib kõik vead. Samuti on seda lahendust lihtsam skaleerida keerukamate automatiseeritud tegevuste jaoks, kuna Pythoni skriptimine on toetatud.

Lõpuks viib viimane lähenemine läbi Giti toomise, kasutades Node.js-i. Edastatavate andmete hulka saab oluliselt vähendada, kasutades seda skripti, mis keskendub teatud harude toomisele. Kasutades "+refs/heads/*:refs/remotes/origin/*" filiaalide märkimiseks veenduge, et alla laaditakse ainult vajalikud viited. Tõhususe edasiseks optimeerimiseks on see strateegia eriti kasulik stsenaariumide puhul, kus arendajad soovivad värskendusi ainult teatud harude kohta. Kuna Node.js on asünkroonne, saab see protsess töötada teisi protsesse takistamata, mistõttu on see ideaalne reaalajas rakenduste jaoks.

#!/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()

Suurte pakettfailide mõju uurimine Git Fetch kiirusele

Üks vähemtuntud põhjuseid git tuua Teisel käitamisel kauem kuluv aeg on seotud sellega, et Git käsitleb suuri hoidlaid, nimelt pakifaile. Pakifailid, mis on tihendatud objektide kogumid, nagu commits, puud ja plekid, on Giti jaoks tõhus viis hoidla andmete salvestamiseks. Kuigi see säästab ruumi, võib see tuua kaasa viivitusi, eriti kui suurpakettfaile laaditakse alla sagedamini kui vaja. Need paketifailid võivad muutuda väga suureks ja põhjustada pikki allalaadimisaegu, kui hoidla aja jooksul suureneb, nagu see võib juhtuda projekti puhul, mida on arendatud mitu aastat.

Oluline on mõista, kuidas Git kasutab konkreetseid lippe laadimisprotsesside optimeerimiseks, et seda probleemi vältida. Näiteks tuuakse ainult uusim sissekandmise ajalugu, kui --sügavus=1 Kasutatav suvand piirab toomist madalale koopiale. Sellegipoolest, kui Git leiab harudes erinevusi või muudatusi, võib ta teatud asjaoludel siiski otsustada suure paketifaili alla laadida. Isegi suuremate hoidlauuenduste puudumisel võib see juhtuda ja tekitada inseneride seas segadust.

Kasutades git fetch -- plune tarbetute harude ja viidete eemaldamine on täiendav viis vananenud kaugharude kustutamiseks. Saate järsult lühendada laadimisaega, kui puhastate hoidlat regulaarselt ja veenduge, et tuuakse ainult asjakohased andmed. Pideva integreerimise/pideva arenduse (CI/CD) seadistustes, kus korduvad toomised võivad takistada ehitamise kiirust ja arenduse tõhusust, on see väga kasulik.