Git

Kohteesta Linux.fi
Loikkaa: valikkoon, hakuun
Git
Git-logo.svg
Käyttöliittymä teksti
Lisenssi GPLv2
Kotisivu git-scm.com

Git on hajautettu versionhallintajärjestelmä, jonka kehityksen aloitti Linus Torvalds Linuxin ytimen kehitystä varten. Se korvasi ytimen kehityksessä suljetun lähdekoodin BitKeeperin.

Perusperiaate[muokkaa]

Git on hajautettu versionhallintajärjestelmä mikä tarkoittaa sitä, että jokaisella käyttäjällä on käytössä paikallinen kopio versionhallinnasta. Käyttäjät tekevät omaan paikalliseen kopioonsa muutoksia ja lopulta liittävät (engl. merge) oman kehityshaaransa (engl. branch) projektin pääasialliseen versionhallintajärjestelmään.

Gitissä eri kehityshaarojen käyttäminen (esimerkiksi luominen, vertailu ja yhdistäminen) on helppoa ja ideana on, että isommista muutoksista luodaan oma kehityshaaransa. Kehityshaaroja voidaan muokata toisistaan riippumatta, ja lopulta esimerkiksi vakaasta kehityshaarasta haarautetussa epävakaassa kehityshaarassa tehty työ voidaan liittää takaisin vakaaseen haaraan työn valmistuttua.

Kehitystyö tapahtuu käytännössä viemällä muutoksia versionhallintaan eli tekemällä ns. commiteja (engl. commit, vakiintunutta suomennosta ei ole). Gitissä jokaiselle commitille luodaan yksilöllinen SHA-1-tunniste jolla siihen voidaan viitata. Tunnisteen avulla varmistetaan myös se, ettei tietokantaa voida vahingossa tai tahallaan korruptoida.

Käyttö[muokkaa]

Seuraavassa käydään läpi Gitin peruskäyttö esimerkin avulla luomalla esimerkkiprojektille "hello" versionhallintajärjestelmä.

Versionhallinnan käyttöönotto[muokkaa]

Luodaan ensin muutama tiedosto projektia varten: hello.c (C-kielinen lähdekoodi, ohjelma tulostaa ruudulle yhden rivin tekstiä, kääntyy komennolla gcc hello.c -o hello):

#include <stdio.h>
void main() {
    printf("Hei, maailma\n");
}

README:

Esimerkkiprojekti, jonka avulla opetellaan Gitin käyttöä

Seuraavaksi alustetaan Git ajamalla projektin hakemistossa komento

$ git init
Initialized empty Git repository in .git/

Kuten Git ilmoittaa, komento luo työhakemistoon piilotetun alihakemiston .git jonne Git tallentaa kaiken tarvitsemansa datan. Tämän hakemiston sisältöön ei tarvitse kiinnittää huomiota.

Tiedostojen lisääminen[muokkaa]

Seuraavaksi lisätään versionhallinnan piiriin alussa luodut tiedostot komennolla git add:

$ git add .

Piste tarkoittaa, että versionhallinnan piiriin lisätään kaikki hakemistossa olevat tiedostot. Yksittäisten tiedostojen lisääminen on myös mahdollista:

$ git add hello.c README

Nyt kun Git tietää, että tällaisia tiedostoja on muokattu, on aika tehdä ensimmäinen "commit", eli siirretään tiedostojen uusin tila versionhallintaan yhdeksi commitiksi:

$ git commit

Komento avaa ympäristömuuttujassa EDITOR määritettyyn tekstieditoriin tiedoston, jossa #-merkeillä alkavilla riveillä lyhyesti kuvattu tehtävät muutokset. Tässä tapauksessa ilmoitetaan uusista tiedostoista hello.c ja README. Tiedostoon voidaan kirjoittaa lyhyehkö lokiin tallentuva kuvaus tehdyistä muutoksista. Risuaidalla alkavat rivit eivät päädy kommenttiin. Kun kommentti on kirjoitettu suljetaan tekstieditori, jolloin muutokset viedään versionhalintaan eli tapahtuu commit:

Created initial commit 9c5cc04: Ensimmäinen commit
2 files changed, 5 insertions(+), 0 deletions(-)
create mode 100644 README
create mode 100644 hello.c

Nyt lokista nähdään, että projektiin on tehty yksi muokkaus:

$ git log
commit 9c5cc04010c91cf560e097c69e5c53f6a51d30ef
Author: Osku Ohjelmoija <osku@linux.fi>
Date:   Fri Oct 23 23:39:56 2009 +0300
   Ensimmäinen commit

Lokiin ilmestyvä nimi ja sähköpostiosoite voidaan asettaa komennoilla

$ git config --global user.name "Oma Nimi"
$ git config --global user.email oma@sähköposti.osoite

Tiedostojen muokkaaminen[muokkaa]

Nyt kun ensimmäinen commit on tehty voidaan alkaa kehittämään projektia jolloin näemme, miten Gitin kanssa toimitaan tiedostojen muuttuessa. Tiedosto hello.c ei ole standardin mukainen eikä se käänny suoritettavaksi ohjelmaksi. Korjataan tämä ongelma muuttamalla tiedosto hello.c muotoon

#include <stdio.h>
int main() {
    printf("Hei, maailma\n");
    return 0;
}

Tässä on siis muutettu toisella rivillä esiintyvä void muotoon int ja lisätty loppuun rivi return 0;.

Nyt tehdyt, vielä commit'oimattomat muutokset nähdään komennolla

$ git status
# On branch master
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#
#  	modified:   hello.c

Eli huomataan, että tiedostoa hello.c on muokattu mutta ei vielä commitoitu. Commit tehdään kertomalla Gitille ensin, että tiedostoa on muokattu, komennolla

$ git add hello.c

ja tekemällä commit tämän jälkeen kuten aluksi

$ git commit

Edellä olevat vaiheet voi myös yhdistää ja suorittaa yhdellä komennolla

$ git commit -a

joka commitoi kaikkiin tiedostoihin tehdyt muutokset.

Muokkaushistoria[muokkaa]

Muiden versionhallintaohjelmien tapaan Git mahdollistaa projektin etenemisen tutkimisen helposti monilla eri tavoilla. Jokaisesta commitista tehdään merkintä lokiin, joka näkyy komennolla

$ git log
commit 770194dd647d7f7ab11a96cfd47ea6cd42c19f3a
Author: Osku Ohjelmoija <osku@linux.fi>
Date:   Fri Oct 23 23:51:59 2009 +0300

   Korjaus
commit 9c5cc04010c91cf560e097c69e5c53f6a51d30ef
Author: Osku Ohjelmoija <osku@linux.fi>
Date:   Fri Oct 23 23:39:56 2009 +0300
   Ensimmäinen commit

Lokissa näkyy jokaiselle commitille yksilöllinen tunnistenumero, commitin tekijä, kellonaika jolloin commit tehtiin ja commitiin liittyvä kommentti. Jos loki on pitkä sitä voi selata nuolinäppäimillä tai näppäimillä j ja k ja selaamistilasta voi siirtyä takaisin komentoriville painamalla q-näppäintä. Käyttämällä valitsinta -p Git näyttää myös versioiden välillä tapahtuneet muutokset:

$ git log -p
-- (osa tulosteesta poistettu)
diff --git a/hello.c b/hello.c
index d1788b8..f4e5959 100644
--- a/hello.c
+++ b/hello.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
-void main() {
+int main() {
   printf("Hei, maailma\n");
+  return 0;
 }

Muutokset näytetään käyttäen diff-komennosta tuttua syntaksia.

Jokaisesta commitista on nähtävissä myös tarkempi yhteenveto komennolla

$ git log --stat --summary

Lokin voi katsoa myös esimerkiksi viimeisen kahden viikon ajalta komennolla

$ git log --since="2 weeks ago"

Haarat[muokkaa]

Haarat (engl. branch) ovat erillisinä kehityshaaroina eteneviä kehityspolkuja jotka lähtevät yhdestä tietystä commitista. Esimerkiksi ohjelmaa kehitettäessä voidaan luoda kokeellinen haara jossa tehdään radikaaleja muutoksia samalla kun ohjelman pääasialliseen kehityshaaraan tehdään maltillisempia muutoksia. Kun uudet muutokset on saatu onnistuneesti tehtyä valmiiksi kokeellisessa haarassa voidaan ne liittää (engl. merge) päähaaraan (tai johonkin toiseen haaraan). Git mahdollistaa eri haarojen monipuolisen käytön ja niitä voi huoletta käyttää runsaastikin.

Luodaan esimerkkiohjelmastamme uusi kokeellinen kehityshaara nimeltään testailu:

$ git branch testailu

Katsotaan tämän jälkeen, mitä haaroja on käytettävissä:

$ git branch
 * master
   testailu

Tähdellä (*) on merkattu tällä hetkellä aktiivisena oleva kehityshaara. master-haara luodaan aina automaattisesti oletuksena.

Siirrytään nyt uuteen kehityshaaraan komennolla

$ git checkout testailu
Switched to branch "testailu"

Tehdään tässä nyt radikaaleja muutoksia ohjelmaamme: hello.c:

#include <stdio.h>
int main() {
  printf("Päivää, maailma!!!!!111111\n");
  printf("Vierailepa osoitteessa http://linux.fi\n");
  return 0;
}

README:

Upea esimerkkiohjelma
v. 2.0!

Ja tehdään muutoksista uusi commit:

$ git commit -a -m "Ohjelman versio 2.0"

Huomaa, että tässä on käytetty valitsinta -a jolloin erillistä git add -komentoa ei tarvita. Lisäksi valitsimella -m asetetaan kommentti jolloin sitä ei kysytä erikseen.

Siirrytään seuraavaksi takaisin master-haaraan:

$ git checkout master
Switched to branch "master"

ja tehdään ohjelmaan pieni muutos tiedostoon hello.c. Huomaa, että git checkout latasi versionhallinnasta master-haaran sisällön joten äsken tekemämme muokkaukset eivät näy tiedostossa. Mikäli tiedostoihin olisi tehty muutoksia joita ei vielä ole commitoitu siirtyminen ei onnistu. Jos muutokset halutaan hylätä voidaan git checkout -komennolle antaa lisäksi valitsin -f.

Muutetaan tiedoston printf-rivi muotoon

printf("Terve maailma\n");

ja commitoidaan muutokset

$ git commit -a -m  "Hienosäädetään tekstiä"

Ajatellaan nyt, että ohjelmamme on kehittynyt siihen pisteeseen että on aika ottaa kokeellisessa testailu-haarassa tehdyt muokkaukset käyttöön. Niiden käyttöönotto onnistuu nyt helposti, sillä Git osaa yhdistää kaksi kehityshaaraa. Yhdistetään testailu-haara master-haaraan ajamalla komento

$ git merge testailu 
Auto-merged hello.c
CONFLICT (content): Merge conflict in hello.c
Automatic merge failed; fix conflicts and then commit the result.

joka yhdistää testailu-haaran aktiivisena olevaan haaraan (nyt master). Git osaa automaattisesti muuttaa README-tiedoston sisällön sillä siihen ei ole tehty muokkauksia testailu-haaran luomisen jälkeen. Sen sijaan molemmissa haaroissa on muokattu hello.c-tiedostoa samasta kohdasta, joten Git ei osaa päätellä, miten muokkaukset tulisi yhdistää. Tästä syystä automaattinen yhdistäminen epäonnistuu ja yhdistäminen jätetään käyttäjän harteille.

Yhdistäminen tapahtuu muokkaamalla nyt käsin tiedostoa hello.c josta löytyy rivit

<<<<<<< HEAD:hello.c
  printf("Terve maailma\n");
=======
  printf("Päivää, maailma!!!!!111111\n");
  printf("Vierailepa osoitteessa http://linux.fi\n");
>>>>>>> testailu:hello.c

Git on siis merkinnyt allekkain ristiriidassa olevan kohdan rivit ensin aktiivisesta haarasta ja tämän jälkeen liitettävästä haarasta. Toteamme, että teistailu-haaran ensimmäinen printf-rivi on järkyttävä, joten poistamme sen. Sen sijaan jätämme tietysti jäljelle linux.fin mainoksen. Lisäksi tiedostosta poistetaan käsin Gitin lisäämät ohjausrivit (========= yms.), jolloin tiedoston tämä osuus jää muotoon

 printf("Terve maailma\n");
 printf("Vierailepa osoitteessa http://linux.fi\n");

Siirretään muutokset versionhallintaan:

$ git commit -a -m "Yhdistetty kokeellisesta haarasta versio 2.0"
Created commit 82fef9e: Yhdistetty kokeellisesta haarasta versio 2.0

Nyt komennolla git log nähdään, että on kyseisen commitin yhteydessä on tapahtunut kahden haaran liittäminen, sillä commitin tunnistenumeron alapuolelle ilmestyy rivi

Merge: 040c39d... b2626d8...

Numero- ja kirjainyhdistelmät viittaavat tiettyyn commiteihin, joiden välillä liitos tapahtui (commitin tunnistenumerosta ilmoitetaan vain alkuosa jos se riittää yksilöimään commitin).

Kun luomallamme kehityshaaralla ei enää ole käyttöä, se voidaan poistaa komennolla

$ git branch -d testailu 
Deleted branch testailu.

Komento varmistaa, että haarassa tehty kehitystyö on liitetty johonkin toiseen haaraan. Jos muualle liittämätön haara halutaan tarkoituksella hylätä käytetään valitsinta -D:

$ git branch -D testailu

Tagit ja tunnisteet[muokkaa]

Kuten aiemmin huomattiin, jokaiseen commitiin viitataan yksilöllisellä mystisellä kirjain- ja numeroyhdistelmällä. Tämän lisäksi Git mahdollistaa tiettyjen commitien nimeämisen selväkielisillä tageilla. Esimerkiksi nimetään alussa ensimmäisen korjauksen jälkeen tehty commit nimelle "v1.0":

$ git tag v1.0 770194dd647d7f

Tässä 770194dd647d7f on alkuosa kyseiseen muokkauksen tunniste (ja luultavasti eroaa omassa järjestelmässäsi). Aina, kun Gitissä viitataan tiettyyn muokkaukseen sen tunnisteella, riittää kun kirjoittaa tunnisteen alkuosaa niin pitkälle, että se yksilöi tunnistenumeron versiohistoriasta.

Tagitetaan vastaavasti uusin commit versiolle 2.0:

$ git tag v2.0 

Kaikki määritetyt tagit saa listattua komennolla

$ git tag
v1.0
v2.0

Nyt voidaan esimerkiksi vertailla näiden kahden commitin välillä tapahtuneita muutoksia:

$ git diff v1.0 v2.0

Tässä voitaisiin toki käyttää tagien sijasta myös tunnisteita, mutta tagit selkeyttävät tilannetta. Nykyiseen tilanteeseen voi viitata "tagilla" HEAD, jolloin version 1.0 jälkeen tehdyt muutokset näkisi komennolla

$ git diff v1.0 HEAD

Kahden tilan välillä tapahtuneet commitit nähdään antamalla git log -komennolla parametrina alku- ja lopputila:

$ git log v1.0..v2.0

näyttäisi tagilla v1.0 merkityn tilan jälkeen tapahtuneet muutokset tagiin v2.0 asti.

Edellä esiteltiin eräänlainen tagi HEAD joka viittaa nykyiseen commitiin. Lisäksi voidaan käyttää merkintää ^, joka viittaa edeltäneeseen commitiin (esim. HEAD^ tai v1.0^), esimerkiksi

$ git diff v1.0^ v1.0

näyttäisi erot commitin v1.0 ja sitä edeltäneen commitin välillä. Vastaavasti kaksi commitia taaksepäin on ^^ jne. Yleisemmin voidaan käyttää merkintää ~numero, esimerkiksi HEAD~4 viittaa 4 commitia taaksepäin. Liitetyille (merge) commiteille löytyy useampia edeltäjiä, jolloin niitä merkitään esimerkiksi HEAD^1 ja HEAD^2.

Yleisesti kaikissa tapauksissa, joissa Gitille annettaisiin commitin tunniste, voidaan käyttää myös kyseiselle commitille merkattua tagia. Katsotaan esimerkiksi millaiseen commitiin asetettiin tagi v2.0:

$ git show v2.0

Tietyn tagin merkkaamasta commitista voidaan aloittaa myös uusi haara:

$ git branch vakaa v1.0

loisi uuden haaran nimellä vakaa siten, että haarasta löytyisi vain ne commitit, jotka on tehty tähän commitiin mennessä.

Kehityshaaran sisällä voidaan palata tiettyyn vanhaan commitiin komennolla git reset:

$ git reset --hard v1.0

palaisi valitussa haarassa tagin v1.0 osoittamaan commitiin. Tämä komento poistaa kaikki tehdyt commitit viitatun commitin jälkeen ja lisäksi paikallisesti tehdyt, versionhallintaan siirtämättömät muokkaukset. Tätä ei pidä käyttää julkisesti käytössä olevassa Git-varastossa. Sen sijaan on käytettävä komentoa git revert.

git merge ja git rebase[muokkaa]

Kopioiminen - Git yhteistyövälineenä[muokkaa]

Versionhallinnasta on eniten iloa tilanteessa, jossa useampi kehittäjä toimii saman projektin kimpussa. Oletetaan nyt, että äskeinen kehitystyö tapahtui hakemistossa /home/osku/projekti. Nyt toinen samalla koneella oleva käyttäjä haluaa osallistua kehitystyöhön. Tällöin hän voi hakea versionhallinnasta kopion itselleen komennolla git clone:

$ git clone /home/osku/projekti hello

Komento kopioi hakemistosta /home/osku/projekti löytyvän projektin Git-versionhallinnasta kopion hakemistoon hello. Jos kehityshaaraa ei erikseen mainita haetaan master-haara.

Kun toinen käyttäjä (tässä Elisa) on tehnyt haluamiaan muutoksia projektiin (commitoinut ne versionhallintaan hakemistossa /home/elisa/hello) hän voi ilmoittaa siitä Oskulle, joka voi hakea muutokset omaan kehityshaaraansa komennolla

$ git pull /home/elisa/hello master

Komento hakee parametrina annetusta hakemistosta löytyvästä versionhallinnasta master-kehityshaaran sisällön ja liittää sen aktiivisena olevaan kehityshaaraan. Jos paikalliseen kehityshaaraan ja etähaaraan (eli Elisan kehityshaaraan) välillä on päällekkäisiä muokkauksia jätetään ristiriidat käyttäjän ratkaistavaksi (kuten edellä käsiteltäessä kehityshaarojen yhdistämistä). Lopuksi git pull tekee muutoksista commitin nykyiseen haaraan.

Yleensä ulkoisen kehityshaaran liittäminen suoraan ei ole järkevää, vaan kannattaa ensin katsoa, minkälaisia muutoksia ollaan tekemässä. Tämä onnistuu hakemalla ulkoisen kehityshaaran muutokset komennolla git fetch, eli Osku voisi ajaa komennon

$ git fetch /home/elisa/hello master

eli git fetch -komennolle annetaan samat parametrit kuin git pull -komennolle.

Nyt muutokset on haettu mutta ei vielä siirretty versionhallintaan. Myöskään paikallisia tiedostoja ei ole muutettu mitenkään. Haettuun kehityshaaraan voidaan kuitenkin viitata tagilla FETCH_HEAD, jolloin nykyisen tilanteen (HEAD) ja haetun tilanteen erot nähtäisiin komennolla

$ git log -p HEAD..FETCH_HEAD

Jos muutokset näyttävät hyviltä, ne voidaan commitoida liittämällä FETCH_HEAD-haara aktiivisena olevaan haaraan komennolla

$ git merge FETCH_HEAD

Etäkoneilla sijaitseviin kehityshaaroihin voidaan luoda linkkejä komennolla git remote. Esimerkiksi Osku voisi luoda Elisan haaraan linkin elisa komennolla

$ git remote add elisa /home/elisa/hello

Tämän jälkeen muutokset voitaisiin hakea helposti komennolla

$ git fetch elisa

joka hakisi kaikkien Elisan kehityshaarojen sisällöt. Näihin haaroihin voitaisiin nyt viitata muodossa elisa/haaran_nimi, esimerkiksi elisa/master. Esimerkiksi erot nähtäisiin komennolla

$ git log -p HEAD..elisa/master

Ja haaran liittäminen nykyiseen haaraan onnistuisi komennolla

$ git merge elisa/master

Yksittäisen haaran (esim. master) voi hakea komennolla

$ git fetch elisa master

jolloin haettuun haaraan voi viitata tagilla FETCH_HEAD.

Elisa voi myös suoraan päivittää kehityshaaraansa Oskun haaraan tehdyt muutokset suoraan komennolla

$ git pull

Komennolle ei tarvitse antaa parametreja sillä git clone on tallentanut Gitin tietokantaan tiedon siitä, mistä alkuperäinen kopio on tehty. Jos versioiden välillä on ristiriitoja ei muutoksista tehdä commitia vaan ristiriidat jätetään käyttäjän ratkaistavaksi kuten git merge:n kanssa huomattiin. Kun ristiriidat on korjattu viedään muutokset versionhallintaan tavalliseen tapaan git commit -a -komennolla.

Voit luoda projektia varten palvelimelle oman tietovaraston (engl. repository) eli hakemiston, johon kukin kehittäjä voi tehdä omat muutoksensa itsenäisesti ilman, että täytyy pyytää erikseen muita kehittäjiä hakemaan tehdyt muutokset omasta kansiostasi. Tällainen paljas (engl. bare) tietovarasto luodaan kirjautumalla ensin palvelimelle ja antamalla esimerkiksi komennot

$ cd /opt/git
$ mkdir project.git
$ cd project.git
$ git --bare init

Siirrytään tämän jälkeen omalle koneelle projektin työhakemistoon. Jos työhakemistossa ei ole otettu git versiohallintaa käyttöön, niin tehdään se nyt ja lisätään sinne tarvittavat tiedostot (git init; git add .; git commit; ks.yllä). Luodaan linkki palvelimella olevaan hakemistoon. Esimerkiksi

$ git remote add origin ssh://user@gitserver/opt/git/project.git

Kaikilla kehittäjillä (user) pitää olla palvelimella (gitserver) pääsy , luku- ja kirjoitusoikeus kyseiseen hakemistoon. Tällöin kehittäjät voivat siirtää tekemänsä muutokset tietovarastoon komenolla

$ git push origin master

Kun projekti on siirretty git push komennolla palvelimelle, voivat muut kehittäjät liittyä siihen normaalisti komennolla

$ git clone ssh://user@gitserver/opt/git/project.git

Muiden kehittäjien ei tarvitse enää luoda linkkiä projektiin yllä olevalla tavalla koska clone luo sen origin nimellä automaattisesti. He siirtävät tekemänsä muokkaukset palvelimen tietovarastoon samalla git push komennolla. Mikäli useampi kehittäjä muokkaa tietovarastoa yhtä aikaa ja toinen kehittäjä on muokannut tietovarastoa sillä välin kun olet hakenut ja tehnyt omia muutoksiasi, pitää ennen git push komentoa antaa git pull, jolloin muiden tekemät muutokset liitetään omiin muutoksiisi ja mahdolliset ristiriidat ratkaistaan (ks. git pull yllä).

Paljas repository toimii myös projektin varmuuskopiona, mikäli oma työhakemistosi syystä tai toisesta tuhoutuu.

Graafisia Git-käyttöliittymiä[muokkaa]

Katso myös[muokkaa]

Aiheesta muualla[muokkaa]