Chapters ▾ 2nd Edition

2.5 Grunderna i Git - Arbeta med fjärrkodförråd

Arbeta med fjärrkodförråd

För att kunna samarbeta i ett Git-projekt behöver du veta hur du hanterar fjärrkodförråd. Fjärrkodförråd är versioner av ditt projekt som finns någonstans på nätet eller i ett nätverk. Du kan ha flera, och var och en är i regel antingen skrivskyddad eller läs/skriv för dig. Att samarbeta innebär att hantera dessa fjärrkodförråd och att skicka och uppdatera data till och från dem när du behöver dela arbete. Att hantera fjärrkodförråd innefattar att lägga till nya, ta bort sådana som inte längre är giltiga, hantera fjärrgrenar och markera dem som spårade eller inte, och mycket mer. I det här avsnittet går vi igenom några av dessa färdigheter.

Notera
Fjärrkodförråd kan ligga på din lokala maskin

Det är fullt möjligt att du arbetar mot ett fjärrkodförråd som i praktiken ligger på samma värddator som du själv. Ordet "fjärr" betyder inte nödvändigtvis att kodförrådet ligger någon annanstans på nätet, bara att det finns på en annan plats. Arbetet med ett sådant fjärrkodförråd använder ändå samma standardkommandon för att uppdatera och skicka.

Visa dina fjärrkodförråd

För att se vilka fjärrservrar du har konfigurerade kan du köra git remote. Det listar kortnamnen för varje fjärrkodförråd du har angivit. Om du har klonat ett kodförråd bör du åtminstone se origin – det är standardnamnet Git ger servern du klonade från:

$ git clone https://github.com/schacon/ticgit
Cloning into 'ticgit'...
remote: Reusing existing pack: 1857, done.
remote: Total 1857 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1857/1857), 374.35 KiB | 268.00 KiB/s, done.
Resolving deltas: 100% (772/772), done.
Checking connectivity... done.
$ cd ticgit
$ git remote
origin

Du kan också ange -v, vilket visar de URL:er Git har sparat för varje kortnamn när den läser och skriver mot fjärrkodförrådet:

$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)

Om du har fler än ett fjärrkodförråd listas alla. Ett kodförråd med flera fjärrkodförråd för att arbeta med flera medarbetare kan till exempel se ut så här:

$ cd grit
$ git remote -v
bakkdoor  https://github.com/bakkdoor/grit (fetch)
bakkdoor  https://github.com/bakkdoor/grit (push)
cho45     https://github.com/cho45/grit (fetch)
cho45     https://github.com/cho45/grit (push)
defunkt   https://github.com/defunkt/grit (fetch)
defunkt   https://github.com/defunkt/grit (push)
koke      git://github.com/koke/grit.git (fetch)
koke      git://github.com/koke/grit.git (push)
origin    git@github.com:mojombo/grit.git (fetch)
origin    git@github.com:mojombo/grit.git (push)

Det betyder att vi kan uppdatera bidrag från alla dessa ganska enkelt. Vi kan också ha rättigheter att skicka till en eller flera av dem, men det ser vi inte här.

Notera att fjärrkodförråden använder olika protokoll; vi går igenom detta mer i Konfigurera Git på en server.

Lägga till fjärrkodförråd

Vi har nämnt och visat hur git clone implicit lägger till fjärrkodförrådet origin åt dig. Så här lägger du till ett nytt fjärrkodförråd explicit. För att lägga till ett nytt Git-fjärrkodförråd med ett kortnamn du enkelt kan använda, kör git remote add <kortnamn> <url>:

$ git remote
origin
$ git remote add pb https://github.com/paulboone/ticgit
$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)
pb	https://github.com/paulboone/ticgit (fetch)
pb	https://github.com/paulboone/ticgit (push)

Nu kan du använda pb på kommandoraden i stället för hela URL:en. Om du till exempel vill uppdatera all information som Paul har men som du inte har lokalt kan du köra git fetch pb:

$ git fetch pb
remote: Counting objects: 43, done.
remote: Compressing objects: 100% (36/36), done.
remote: Total 43 (delta 10), reused 31 (delta 5)
Unpacking objects: 100% (43/43), done.
From https://github.com/paulboone/ticgit
 * [new branch]      master     -> pb/master
 * [new branch]      ticgit     -> pb/ticgit

Pauls master-gren är nu tillgänglig lokalt som pb/master – du kan sammanfoga den med någon av dina grenar eller ta ut en lokal gren på den punkten om du vill inspektera den. Vi går igenom vad grenar är och hur du använder dem mer i Git-grenar.

Uppdatera och dra från fjärrkodförråd

Som du nyss såg kan du uppdatera data från fjärrprojekt med:

$ git fetch <remote>

Kommandot går till fjärrprojektet och uppdaterar all data som du ännu inte har. Efter detta har du referenser till alla grenar från fjärrkodförrådet som du kan sammanfoga eller inspektera när som helst.

Om du klonar ett kodförråd lägger kommandot automatiskt till fjärrkodförrådet under namnet "origin". git fetch origin uppdaterar allt nytt arbete som har skickats till fjärrkodförrådet sedan du klonade (eller senast uppdaterade data). Det är viktigt att förstå att git fetch bara uppdaterar data till ditt lokala kodförråd – det slår inte automatiskt ihop den med ditt arbete eller ändrar den gren du jobbar på. Du måste manuellt införliva ändringarna när du är redo.

Om din nuvarande gren är inställd på att spåra en fjärrgren (se nästa avsnitt och Git-grenar för mer information) kan du använda git pull för att dra och därefter sammanfoga ändringarna i din aktuella gren. Det kan vara ett enklare arbetsflöde; normalt gör git clone att din lokala master-gren spårar motsvarande gren i fjärrkodförrådet (standardnamnet i fjärrkodförrådet behöver inte vara master). git pull drar data från servern du ursprungligen klonade från och försöker automatiskt sammanfoga ändringarna i den gren du jobbar på.

Skicka till fjärrkodförråd

När du har ett projekt du vill dela behöver du skicka det uppströms. Kommandot är enkelt: git push <fjärrnamn> <gren>. Om du vill skicka din master-gren till din origin-server (kloning ställer normalt in båda) kör du detta för att skicka dina incheckningar:

$ git push origin master

Kommandot fungerar bara om du klonade från en server där du har skrivrättigheter och om ingen annan har skickat ändringar samtidigt. Om någon annan skickar upp ändringar före dig blir din sändning avvisad. Du måste då uppdatera deras arbete först och införliva det innan du kan skicka. Se Git-grenar för mer om hur du skickar till fjärrservrar.

Inspektera ett fjärrkodförråd

Om du vill se mer information om ett specifikt fjärrkodförråd kan du använda git remote show <remote>. Om du kör detta med till exempel origin får du något i stil med:

$ git remote show origin
* remote origin
  Fetch URL: https://github.com/schacon/ticgit
  Push  URL: https://github.com/schacon/ticgit
  HEAD branch: master
  Remote branches:
    master                               tracked
    dev-branch                           tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

Det listar URL för fjärrkodförrådet samt information om spårade grenar. Kommandot berättar också att om du står på master-grenen och kör git pull så slås ändringarna ihop med master-grenen på fjärrkodförrådet efter att den dragits in. Det listar dessutom alla fjärrreferenser som uppdaterats.

Det här är ett vanligt och enkelt exempel. När du använder Git mer kommer git remote show att ge mer information:

$ git remote show origin
* remote origin
  URL: https://github.com/my-org/complex-project
  Fetch URL: https://github.com/my-org/complex-project
  Push  URL: https://github.com/my-org/complex-project
  HEAD branch: master
  Remote branches:
    master                           tracked
    dev-branch                       tracked
    markdown-strip                   tracked
    issue-43                         new (next fetch will store in remotes/origin)
    issue-45                         new (next fetch will store in remotes/origin)
    refs/remotes/origin/issue-11     stale (use 'git remote prune' to remove)
  Local branches configured for 'git pull':
    dev-branch merges with remote dev-branch
    master     merges with remote master
  Local refs configured for 'git push':
    dev-branch                     pushes to dev-branch                     (up to date)
    markdown-strip                 pushes to markdown-strip                 (up to date)
    master                         pushes to master                         (up to date)

Kommandot visar också vilken gren som skickas automatiskt när du kör git push och står på en viss gren. Det visar även vilka fjärrgrenar du inte har, vilka som tagits bort på servern och flera lokala grenar som automatiskt kan sammanfoga med sin spårade gren när du kör git pull.

Byta namn på och ta bort fjärrkodförråd

Du kan köra git remote rename för att byta namn på ett fjärrkodförråd. Om du till exempel vill byta namn på pb till paul kan du göra det så här:

$ git remote rename pb paul
$ git remote
origin
paul

Detta ändrar även alla dina spårade grennamn. Det du tidigare refererade till som pb/master heter nu paul/master.

Om du vill ta bort ett fjärrkodförråd av någon anledning – du har flyttat servern, använder den inte längre eller en tidigare medarbetare har slutat – kan du använda git remote remove eller git remote rm:

$ git remote remove paul
$ git remote
origin

När du tar bort en referens på detta sätt tas även alla spårade grenar och konfigurationsinställningar som hörde till fjärrkodförrådet bort.