Posts mit dem Label Git werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Git werden angezeigt. Alle Posts anzeigen

Sonntag, 24. Juli 2011

Versionskontrolle mit Git Teil 3: mit Änderungen umgehen

Nehmen wir an, man benutzt Git im Team. Obwohl man immer auf seinem eigenen Repository arbeitet muss man irgendwann wieder mit den anderen Teammitgliedern synchronisieren. Bei Git arbeitet man dabei besonders mit dem Konzept von Branches.
Die Hauptbranch in Git ist per Naming Convention der "master". Auch wenn ich nur an einem kleinen Feature arbeite lege ich mir sofort eine Branch an, die den Stand vom Master hat mit

git checkout -b myFeatureBranch

Auf dieser Branch arbeite ich weiter, mache Änderungen, commite sie oder lege sie ab. Statt Änderungen komplett zu verwerfen lege ich sie lieber ab, was man mit Git Stash machen kann. Wer weiß, vielleicht möchte ich sie ja doch später wieder hohlen.
git stash
legt die aktuellen Änderungen im Stash ab und setzt den Arbeitsstand zurück auf den letzten Commit. Stash ist mächtig, man kann den gesamten Stash durchsuchen und die verworfenen Stände zurückhohlen. Meist brauche ich aber nur
git stash pop
welches die letzte Änderung vom Stash holt. Ansonsten mache ich Commits mit meinen Änderungen.

Sollte das Feature nicht ganz so klein sein, muss man sich Gedanken machen, wie man die Branch auf dem Stand des Masters hält. Andere Team-Members pushen dort vielleicht Änderungen.  Arbeite ich alleine an meiner Branch gibt es das tolle Feature "Rebase" bei Git. Ziel ist am Ende der Entwicklung mein Feature in den Master zu mergen und zwar möglichst so, dass es bei Problemen leicht ausgebaut werden kann. Dafür ist es schön wenn bei Git log nicht jeder einzelne Commit den ich lokal gemacht habe auftaucht, sondern vielleicht einer: myNewFeature Featurenummer xyz oder so etwas. Rebase verändert die History und lässt mich Commits genau dort einfügen wo ich sie haben will. Ein regelmäßiges Rebase verhindert das Auflösen von Konflikten an Ende der Entwicklung. Um ein Rebase zu machen wechsle ich ich erstmal wieder auf den Master
git checkout master
und hohle mir die neuesten Änderungen
git pull
Nun ist der Master lokal auf dem neuesten Stand und ich kann wieder zur Branch wechseln mit
git checkout myNewFeature
Hier rufe ich nun
git rebase master
auf. Gibt es keine Konflikte habe ich damit erfolgreich ein Rebase ausgeführt. Was man bei Konflikten tun kann beschreibe ich in einem anderen Blog Post ;-)

Sonntag, 19. Juni 2011

Versionskontrolle mit Git Teil 2: Remote Repository auf dem File System

Git Teil 2: Remote

Git lokal zu benutzen ist praktisch um wieder zu eigenen älteren Versionen zurückzukehren. In der gemeinsamen Entwicklung im Team gibt es aber normalerweise irgendwo ein für alle Teammembers erreichbares Repository.
Technisch unterscheidet das gemeinsame und das lokale Repository ersteinmal gar nichts. Jeder Benutzer hat das vollständige Repository lokal und synchronisiert nur mit dem Remote Repository.

git pull

git fetch

hohlen den Stand von einem Remote Repository, während mit

git push

lokale Commits auf ein Remote Repository geschoben werden. Mit

git remote

greift man auf Remote Repositories zu

Damit das funktioniert braucht ihr aber erst ein Remote Repository. Legen wir eins auf einem File System an ( z.B. einem gemeinsamen Laufwerk ). Navigiert zu dem Laufwerk z.B. mit

cd /Volumes/Shared/Projects

, legt einen Ordner für das Projekt an mit

mkdir Demo
cd Demo

und legt ein leeres Repository an mit

git --bare init

Nun könnt ihr in euer eigentliches lokales Testprojekt gehen und mit

git remote add origin file:///Volumes/Shared/Projects/Demo

das Remote Repository hinzufügen. Ein

git push origin master

spielt euren Stand in das Remote Repository. Nun kann jeder Benutzer das Repository clonen mit

git clone file:///Volumes/Shared/Projects/Demo

Samstag, 14. Mai 2011

Versionskontrolle mit Git Teil 1

Versionskontrolle mit Git Teil 1

Einen lokalen Integrationserver zu haben und seinen Build mit Maven oder Ant wie in den Posts ab Continuous Integration Teil 1 beschrieben zu automatisieren ist eine tolle Sache. Richtig sinnvoll wird beides dann, wenn man in einem Team an einem Projekt arbeitet und sicherstellen möchte, dass dieses Projekt immer funktioniert (oder zumindest kompiliert).
Ein Versionskontrollsystem, bzw. Versionsverwaltung (auch mit SCM - source code manager - abgekürzt) hilft dem Einzelnen Versionen des Source Codes zu verwalten, besonders aber einem Team an gleichen Dateien zu arbeiten und die Änderungen zusammen zu bringen.

Es gibt eine ganze Reihe von verschiedenen System, die man als Entwickler-Team nutzen kann:
  1. Git
  2. Mercurial
  3. SVN
  4. CVS
sind wohl die am Moment populärsten. Ein großer Unterschied zwischen Git und Mercurial zu SVN und CVS ist, dass die Ersteren verteilte Systeme sind. Jeder User hat das gesamte Repository bei sich auf dem Rechner. Bei SVN und CVS gibt es hingegen ein zentrales Repository normalerweise auf einem (Web)Server.
Git hat den großen Vorteil, dass man selbst ohne Webserver, z.B. auf einem gemeinsamen Laufwerk, ein Repository zum Synchronisieren mit dem Team nutzen kann. Damit kann man ohne großen Aufwand in einem kleinen Projekt (z.B. zu zweit) eine vernünftige Versionskontrolle machen und auch ein CI System an Git anbinden.
Starten mit Git
Zuerst muss man Git installieren. Github ist nicht nur ein Gitserver, der umsonst für Open Source Projekte ist, sie haben auch eine sehr gute Hilfe.
Für das Installieren von Git unter Windows kann man sich an dem Github Tutorial orientieren. Die Schritte mit dem SSH Key kann man weglassen, wenn man nicht Github oder einen anderen Server bei dem man sich authentifizieren muss nutzen möchte. Der Installer/Gui für Git unter Windows msysgit ist aber auch sehr einfach ohne Tutorial zu installieren. Einfach herunterladen und starten.
Nach der Installation von Git unter Windows könnt ihr einfach im Explorer zu einem neuen Ordner browsen, mit der rechten Maustaste auf den Projektordner klicken und "Git GUI Here" wählen. Im Menü kann man dann "Create New Repository wählen" und den Pfad zum Projektordner angeben. Nachdem Anlegen des Repositories gebt ihr am besten über "Edit" und "Settings" Namen und Email an damit ihr das nicht bei jedem "push" machen müsst.
Ich benutze bei Git eher eine Shell als ein grafisches Tool. Mit msysgit könnt ihr einfach auf "Git Bash here" klicken und ihr bekommt eine Shell im richtigen Verzeichnis.
Nun legt einfach mal eine Datei namens readme.txt an. Dort kann man sein Projekt beschreiben. Git weiß nun noch nicht, dass es diese Datei verwalten soll. Gebt in eure Shell
git status
Dann sollte ihr eine Rückmeldung bekommen, dass readme.txt noch nicht getrackt wird. Mit
git add readme.txt
stellt ihr die Datei unter Versionskontrolle. Mit
git commit readme.txt -m "add readme"
macht ihr einen Commit, ihr stellt einen bestimmten Stand in euer Repository ein. Nun ändert einfach mal die readme.txt und schreibt "Erste Versuch mit Git" hinein und speichert das Ganze. Wenn ihr nun auf der Shell
git diff
eingebt, seht ihr den Unterschied von dem aktuellen Stand zum letzten Commit. Nun commited die Änderungen. Mit
git log
könnt ihr euch die letzten Commits angucken.