Das Versionierungstool Git steht schon lange auf meiner Liste der Dinge, die ich mir mal anschauen will. Momentan nutze ich noch subversion. Doch während man mit subversion Änderungen nur in einem zentralen Repository speichern kann, bietet Git dezentrale Repositories, die auf Bedarf gegen ein zentrales Repository gemerged werden können.

Doch vor der Nutzung kommt zuerst die Installation. Sicherlich kann man Git auch aus den Quellen übersetzen, aber sowohl für Linux [1] als auch für den Mac [2] (bis snow leopard) gibt es dafür Pakete. Bei neueren Mac OSX Versionen ist Git Bestandteil von xcode und den xcode developer tools. Die ersten Schritte sind in diesen beiden deutschen Tutorials [3] [4] erläutert. Ein ausführliches deutsches Tutorial gibt es von der Stanford Uni [5].

Scenario

Mein Scenario ist folgendes:

• ein zentrales Repository auf meinem Mac mini (der mir als Server dient)
• ein dezentrales Repository auf meinem Mac mini (wenn ich mal davor sitze)
• ein dezentrales Repository auf meinem Kubuntu Laptop (für unterwegs)

Am Anfang steht das Projekt, das man mit Git versionieren möchte. Das Terminal ist des Entwicklers liebster Freund und deswegen ist der volle Funktionsumfang von Git auch nur dort adressierbar (eine Eclipse Integration gibt es natürlich auch [6]). Aber ein Schritt nach dem anderen.

Schritt 1: bestehendes Projekt mit Git versionieren

Zuerst sollte man Git den eigenen Namen und eine Email Adresse bekanntgeben. Git benutzt diese Informationen später in den Versionskommentaren.

git config --global user.name "Gero Klinkmann"
git config --global user.email me@example.com

Dann kann man sein erstes Git Repository mit git init ersellen. Bei mir liegt es auf dem Mac mini, auf dem im nächsten Schritt auch das zentrale Repository entstehen soll.

cd ~/workspace/testGroovy
git init
git add .
git commit

Die Befehle sprechen für sich. Beim commit öffnet sich der vi Editor, damit man einen Kommentar für den jeweiligen Stand hinzufügen kann. Die Befehlssyntax des vi ist nicht gerade intuitiv, von daher für alle, die sie nicht kennen, kurz die notwendigen Befehle um den Kommentar hinzuzufügen:

• [i] Wechsel in den Insert Modus.
• Kommentar schreiben.
• [esc] Wechsel in den Befehls Modus.
• [:wq] Speichen und Beenden des vi.

Schritt 2: zentrales Git Repository anlegen

Das eben erstellte Repository ist dann das dezentrale Repository auf dem Mac. Der Clone davon wird über das Argument bare zum zentralen Repository auf dem Mac.

mkdir  ~/git
cd ~/workspace/testGroovy
git clone --bare .git ~/git/testGroovy.git

Schritt 3: zentrales Git Repository clonen

Auf dem Linux Laptop soll ja ein dezentrales Repository entstehen. Dafür ist es notwendig, das zentrale Repository auf dem Mac zu klonen. Beide Rechner sind über ssh verbunden. Weiterhin wird beim Clonen das git-upload-pack (und zwar das von dem Rechner, wo das zentrale Repository liegt – bei mir also vom Mac) benötigt.
Um Problemen, wie bash: git-upload-pack: command not found vorzubeugen, sollte man den Ort (bei mir ist es /usr/local/git/bin/git-upload-pack) beim Clone Kommando mit angeben.

cd  ~/projekte
git clone --upload-pack /usr/bin/git-upload-pack
   ssh://username@server/full/remote/path/to/testGroovy.git testGroovy

Damit man das nicht ständig beachten muss, kann man das auch in der Git Konfigurationsdatei hinterlegen.

> cd  ~/projekte/testGroovy
> vi .git/config
   [remote "origin"]
        fetch = +refs/heads/*:refs/remotes/origin/*
        url = ssh://username@server/full/remote/path/to/testGroovy.git
        uploadpack=/usr/bin/git-upload-pack
        receivepack=/usr/bin/git-receive-pack

Schritt 4: vom lokalen zum zentralen Repository

Änderungen an den Sourcen werden zuerst im lokalen Repository über git commit -a versioniert. Auch bei diesem commit öffnet sich der vi Editor für einen Versionskommentar. Mit git push werden die Änderungen des lokalen Repositories dem zentralen Repository mitgeteilt.

cd ~/projekte/testGroovy
git commit -a
git push

Schritt 5: lokales und zentrales Repository auf einem Server

Begonnen hatte ich mit einem lokalen Repository auf meinem Mac. Über git clone –bar wurde ein zusätzliches zentrales Repository erstellt. Doch noch gibt es keine Verbindung zwischen den beiden. Dies geschieht durch einen Eintrag in der Git Konfigurationsdatei des lokalen Repositories.

cd ~/workspace/testGroovy
vi .git/config
   ...
   # Verbindung zum zentralen Repository
   [remote "origin"]
        fetch = +refs/heads/*:refs/remotes/origin/*
        url = /full/path/to/git/testGroovy.git

   [bbranch "master"]
        remote = origin
        merge = refs/heads/master

Fazit:
Ein bisschen Konfiguration ist schon notwendig, wenn man mit Git zentrale und dezentrale Repositories gleichsam nutzen möchte. Für diesen Aufwand bekommt man aber ein sehr leistungsfähiges, stabiles und performantes Versionierungssystem, das nicht auf eine Verbindung zu einem zentralen Repository angewiesen ist.

Links:
[1] git-core – Core Pakete für Ubuntu
[2] git-osx-installer – Google Code Projekt
[3] kurzes deutsches Git Tutorial – auf interaktionsdesigner.de
[4] kurzes deutsches Git Tutorial – auf online-tutorials.net
[5] ausführliches deutsches Git Tutorial – der Stanford Uni
[6] EGit – Eclipse Plugin für Git