Git bisect: Paano makilala ang isang bug sa iyong code?

Ang artikulong ito sa git bisect, alamin kung paano nakakatulong ang utos na 'git bisect' sa pagtuklas ng unang masamang gumawa na nagpapakilala ng isang bug gamit ang binary search algorithm.

Ang aking code ay gumagana nang maayos hanggang kahapon, ngunit hanggang sa isang kamakailang paghila mula sa remote na imbakan ay sinira ang code !!!

Kung ikaw ay nasa isang katulad na sitwasyon at hindi alam anong pagbabago sinira ang code o sino sa maraming mga nag-ambag nagmamay-ari ito bug / tampok , pagkatapos ang git bisect ay ang iyong paraan palabas. Kaya, sa artikulong ito sa git bisect malalaman mo kung paano ang 'git bisect‘Utos ay dumating sa pagsagip sa pagtuklas ng unang masamang gumawa na nagpapakilala ng bug gamit ang binary search algorithm.

Ang mga paksang sakop sa artikulong ito ay ang mga sumusunod:





Bakit gagamit ng git bisect?

Walang duda sa katotohanan na may posibilidad kang lumikha ng isang bilang ng mga pangako para sa bawat menor de edad na pagbabago sa . Sa ganitong sitwasyon, ang pag-debug ng code ay nagiging isang nakakapagod na gawain, dahil kailangan mong manu-manong bumalik sa oras sa bawat solong rebisyon ng snapshot ng proyekto upang masubukan ang gumaganang code at makita ang bug. Ngayon, ito ay nakakakuha ng higit pa kumplikado kapag mayroon kang gawain ng iba upang siyasatin nang walang nangungunang punto, upang humiling din sa bawat isa na linisin ang kanilang sariling mga pagkakamali ay hindi rin masyadong posible.
Sa daan, maaari ka ring lumikha at magtapon ng isang bilang ng mga tampok na 'tampok' (o hotfix) sa proseso at magtatapos ng pag-aaksaya ng oras at pagsisikap habang lumihis mula sa pangunahing linya ng pag-unlad.



Kaya, upang maiwasan ang mga nasabing senaryo, maaari mong gamitin anggit bisectutos na hanapin ang masamang pagbabago ng proyekto (o snapshot) at kalaunan ayusin ito sagit balikanutos

Paano ang paghahanap ng 'git bisect'?



Utos na ito mga bisect (hinahati) ang iyong kasaysayan sa pagitan ng mabuti at ang masama mangako saklaw Itinuro nito ang iyong kasalukuyang proyekto estado sa a mid-range mangako snapshot. Ang git bisect na utos pagkatapos ay gumagalaw bawat gumawa ng id sa pagitan ng saklaw na ito habang humihinto sa bawat snapshot upang payagan kang subukan ang code . Kung ang bug ay mayroon, idineklara mo ang gumawa bilang masama, kung hindi bilang mabuti maliban kung natapos ang paghahanap.

Syntax

git bisect

Upang mas maunawaan ang git bisect, gumawa tayo ng isang proyekto na bubuo ng code para sa isang simpleng nabigasyon app na gagamitin sa isang kotse.

Paunang pag-set up ng proyekto

Upang lumikha ng isang proyekto na bubuo ng code para sa isang simpleng nabigasyon app na gagamitin sa isang kotse, maaari mong sundin ang mga hakbang sa ibaba:

Hakbang 1: Lumikha ng isang bagong direktoryo sa iyong $ HOME folder:

cd $ HOME mkdir my_nav_app

Hakbang 2: Mag-navigate sa bagong direktoryo:

cd $ my_nav_app

Hakbang 3: I-clone upang mai-download ang proyekto mula sa aking pahina sa GitHub:

git clone https://github.com/divyabhushan/my_nav_app.git

Ngayon, ipaalam sa amin na maunawaan ang mga direktoryo ng proyekto at layout ng mga file, tulad ng naka-print ng utos:ls -lTR

Source Code Layout - Git Bisect - Edureka

Susunod, tingnan natin ang journal ng kasaysayan ng proyekto upang matingnan ang mga ginawa kong paggawa upang mabuo ang code na ito-

Halimbawa, isang simpleng utos ng git log ang naglilimbag ng kasaysayan nang detalyado, subalit, nais kong medyo mai-format at ipasadya ang kasaysayan. Sa gayon, hayaan natin magtakda ng isang pangalan ng alyas - 'hist' gamit ang git alias utos tulad ng ipinakita sa ibaba:

git alias.hist 'log --pretty = format:'% C (dilaw)% h% Creset% ad | % C (berde)% s% Creset% C (pula)% d% Creset% C (asul) [% an] '--graph --decorate --date = maikli'

Ngayon, isasagawa ko ang tampok na pag-aayos ng bug na ito sa isang hiwalay na sangay, upang hindi makagambala sa pangunahing pag-unlad sa sangay na 'master'. Upang magawa iyon, sundin ang hanay ng mga utos sa ibaba:

  • Lumikha ng branch 'dev': [master] $git branch dev
  • Lumipat sa branch 'dev': $git checkout dev
  • Ilista ang mga tala ng kasaysayan: [dev] $go hist[Tandaan: Ginamit ang command na ‘alias’ dito]

Dagdag dito, na-highlight ko ang huling alam na mabuting pagbibigay na alam ko kung saan ang aking script ay gumana nang maayos sa inaasahang mga resulta sa kaso ng pagsubok, ang snapshot na ito ay naka-tag bilang v1.0.

Kaya, ngayong alam na natin ang ating huling mabubuting pagkakasundo, magpatuloy tayo sa artikulong ito sa 'git bisect' at subukan ang aplikasyon.

Subukan ang aplikasyon

Patakbuhin ang script bilang - $./scripts/myApplication.sh[unang pagsubok]



Malinaw, ang aking kasalukuyang estado ng proyekto ay nasa kamalian , at hindi ako sigurado kung anong pagbabago ang ginawa ko kung aling gumawa ang nagpakilala sa pagbabagong ito. Kaya, sa susunod sa artikulong ito sa git bisect, tingnan natin kung paano makilala ang masamang paggawa.

Pagkilala sa hindi magandang nagawa

Upang simulang mag-inspeksyon para sa masamang paggawa, susundin mo ang mga hakbang sa ibaba:

  • Simulan ang utos ng bisect :git bisect start
  • Nabanggit ang masamang gumawa ng id: git bisect bad HEADogit bisect c5b3ca8
  • Nabanggit ang huling kilalang-kilalang id na mainam: git bisect magandang v1.0ogit bisect 93859d8

Tinutulak nito ang saklaw ng kasaysayan ng gumawa nang humigit-kumulang sa pagitan ng mga mabubuti at masamang mga pangako na nagdadala sa amin sa gumawa id: f61a7e8

Samakatuwid, ang utos ay naka-check sa bersyon ng proyekto tulad ng sa id na ito. Ngayon, magpatuloy tayo at subukang muli ang aming aplikasyon.

Utusan na patakbuhin ang application : $./scripts/myApplication.sh[pagsubok sa pangalawang pagkakataon]


Dahil ang application pumasa sa paggawa na ito, ang pagsang-ayon na ito ay tiyak na hindi masamang mangako. Kaya, sa susunod, kailangan mong ipaalam ang pareho sa utos ng bisect bilang - $git bisect mabuti


Ngayon, magpapahigpit pa ito sa resulta ng paghahanap sa unang kalahati ng saklaw tulad ng ipinakita -


Subukan muli ang iyong aplikasyon - Command: $./scripts/myApplication.sh[pagsubok sa pangatlong beses]


Kaya, dahil nakakita kami ng isang error tulad ng nasa itaas, ito ay isang masamang gawin.

Ipaalam sa utos ng bisect, magpatakbo ng $git bisect masama


Na pinapaliit pa ng paghahanap at dinadala ka sa huling asul na nakapalibot sa gitnang rebisyon: a6ac769

Kaya, sinusubukan ko ang aking aplikasyon sa huling oras gamit ang parehong utos: $./scripts/myApplication.sh[pagsubok sa pang-apat na beses]

Ngayon, dahil nabigo muli ang application, masamang gumawa pa rin ito. Kaya't, patakbuhin ang sumusunod na utos:

Patakbuhin ang utos: git bisect masama

Hindi nakita ang masamang komit

Tinatapos nito ang huling huling natitira na gawin na masama-


Kaya alam mo na dito nabasag ang code. Anong sunod?

Maunawaan kung anong file ang nagkaroon ng bug

Sa kasong ito, bibigyan ka ng output ng kaunting impormasyon tungkol sa gumawa ng id , pangalan ng may akda , at ang petsa ng may akda kasama ang gumawa ng mensahe at ang landas nabago yun.

Kung nais mong i-debug pa kailangan mo basahin ang gumawa ng id object .

Utos: git show a6ac76994b3f6c7519204f910fc787b7928cf8ef

Basahin nito ang bagay na gumawa at mai-print ang log message at tekstuwal diff.

Maaari mo ring gamitin ang utos na 'git sisihin' upang pag-aralan kung paano at kung aling gumawa ang bawat linya ay binago ng sinumang may akda, patakbuhin ang utos bilang:git sisihin ang code / develop_nav.sh

Itigil ang paghahanap

Upang ihinto ang paghahanap, gamitin ang sumusunod na utos:

Utos: git bisect reset


Kaya, ang proseso ng bisection ay tumigil at ikaw ay bumalik sa sangay kung saan mo sinimulan ang paghahanap. Ngayon, ang susunod na hakbang ay upang ayusin o i-debug ang code.

Paano ayusin / i-debug ang code?

Sa gayon, mayroong isang pares ng mga workaround na maaari mong gawin upang ayusin ang kasalukuyang estado ng proyekto ngayong natukoy mo ang nakatuon na nagdala ng bug sa una.
Gayunpaman, kung binabago mo ang isang nakatuon sa a nakabahaging repository ito ay pinakamahusay na ibalik ang pagbabago gamit ang ‘ git balikan ‘Utos.

Gawain: Balikan ang mga pagbabagong nagawa ng hindi magandang nabanggit na nabanggit

Utos: git balikan ang a6ac769

Bilang isang resulta, ang pagbago ng mga pagbabagong ginawa ng paggawa na ito ay gumawa ng 2 bagay:

  • Tinanggal nito ang huling 3 idinagdag na mga linya (ipinahiwatig na berde) at idinagdag ang tinanggal na linya (ipinahiwatig na pula) pabalik. (baligtad ng a6ac769)
  • Nilikha ang isang labis na nakatuon sa impormasyong ibalik ang mensahe

'Ang revert command ay ginagawang mas madali upang subaybayan ang pagbabagong iyong ibinalik mula sa orihinal na'

Gamitin ang 'Ipakita' utos muli na basahin ang object id, tulad ng-

pag-uri-uriin int array c ++

Utos: git show 801f029

Ngayon, magpatuloy at subukan ang application. Maipatupad ito nang maayos.

Utos: $./scripts/myApplication.sh

Sa kaibahan, kung nais mong alisin ang hindi magandang gawing mula sa kasaysayan:

  • Maaari mong gamitin ang ‘ git reset 'Utos kasama ang--mahirap”Pagpipilian (kahit na hindi inirerekumenda sa isang nakabahaging repository).

  • Suriin ang isang naunang bersyon ng isang solong file gamit ang ‘git checkout'Utos kasama ang'-'Pagpipilian.

Dapat pansinin, gagawa lamang ito ng mga pagbabago sa iyong lokal na imbakan hanggang sa itulak mo ang mga pagbabago sa isang remote na imbakan. Dahil ang ilang mga pagbabago ay lumilikha ng bagong gumawa ng object id tulad ng sa aming kaso sa itaas sa mga ganitong kaso ang isang normal na pagtulak sa remote na imbakan ay tinanggihan dahil ang kasaysayan ay magkakaiba. Dapat mong gamitin ang ‘ git push 'Utos kasama ang'- lakas'Pagpipilian.

I-update ang sangay ng 'master'

Habang naayos ko ang bug sa aking sangay na 'dev', maaari ko na ngayong pagsamahin ang pagbabagong ito sa sangay na 'master' din-

  • lumipat sa 'master', utos:git checkout master
  • hilahin ang mga kamakailang pag-update mula sa 'pinagmulan / master' hanggang sa 'master', utos:git pull pinagmulan
  • pagsamahin ang mga pagbabago sa 'dev', utos:git merge higante

Gayunpaman, ang iyong pagsasama ay maaaring makabuo ng mga salungatan kung maraming mga pangako mula sa remote na imbakan. Malutas ang mga salungatan at magpatuloy sa pagsasama.
Sa wakas, itulak lamang ang matatag na 'master' na sangay na nangangako sa remote na imbakan habang nakukuha mo ang iyong maruming gawain (bug, mga tampok, pagpapahusay) na ginagawa lamang sa mga sanga ng tampok tulad ng 'dev' sa halimbawang ito.
Bukod dito, pinakamahusay na magpatibay ng isang lohikal istratehiyang sumasanga upang i-streamline at i-secure ang iyong git na proseso ng daloy ng trabaho.

Upang ibuod, ang 'git bisect' ay isang madaling gamiting at kapaki-pakinabang na utos na mabilis kilalanin ang gumawa ng id yan ipinakilala sa kasalanan sa iyong tumatakbo na code sa tulong ng isang malawak binary paghahanap sa pamamagitan ng lohikal naghahati ang gumawa ng mga tala sa kalahati sa pagitan ng mabuti at masama mangako saklaw . Upang tapusin, natutunan mong matukoy ang may maling gumawa at ibalik ang pagbabagong ginawa nito.

Bilang karagdagan, sa mga subcommand na 'mabuti' at 'masama' maaari mo ring gamitin ang mga term na tulad ng bago at luma upang ilarawan ang estado ng rebisyon. Maaari mong patakbuhin ang utos ng maraming beses sa pagpasa ng iba't ibang mga subcommand at rebisyon / gumawa ng mga id upang makilala ang iba't ibang mga id (she-1) id. Bilang kahalili, ang isang awtomatikong script ng pagsubok ay maaari ding patakbuhin upang mabuo ang sirang code gamit ang utos na ito. Gayundin, maghanap ng isang detalyadong paglalarawan ng utos na ito sa pamamagitan ng pagpapatakbogit bisect --tulongsa terminal. Kaya, mga taong kasama dito natapos namin ang artikulong ito sa Git Bisect.

Ang hangarin ng DevOps ay upang lumikha ng mas mahusay na kalidad na software nang mas mabilis at may higit na pagiging maaasahan habang inaanyayahan ang higit na komunikasyon at pakikipagtulungan sa pagitan ng mga koponan. Kung naintriga ka sa artikulong ito, c ano ba ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Ang kurso sa Edureka DevOps Certification Training ay tumutulong sa mga nag-aaral na maunawaan kung ano ang DevOps at makakuha ng kadalubhasaan sa iba't ibang mga proseso at tool ng DevOps tulad ng Puppet, Jenkins, Nagios, Ansible, Chef, Saltstack at GIT para sa pag-automate ng maraming mga hakbang sa SDLC.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng artikulong 'Git Bisect' at babalik kami sa iyo sa lalong madaling panahon.