#!/bin/bash
ME=${0##*/}
 
# Ausgabe mit Pfadangabe
echo $0
# und ohne
echo $ME

# Aufruf
/var/run/whatever.sh 
 
# Ausgabe
/var/run/whatever.sh
whatever.sh

Danke Andi

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] gibt es dafür Pakete. 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

• 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

> 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

> 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/local/git/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/local/git/bin/git-upload-pack
        receivepack=/usr/local/git/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
   [branch "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

Ein Thema beim Erstellen von Shell Skripten ist der Umgang mit Prozessen. Wer schon mal mit einer Unix Shell Bekanntschaft gemacht hat, wird die Befehle ps und kill kennen, mit denen man sich eine Übersicht über laufende Prozesse verschafft, bzw. sie beendet. Vielleicht ist auch bekannt, dass man mit kill -9 einem Wunsch einen Prozess zu beenden Nachdruck verleihen kann.

Was weniger bekannt sein dürfte (zumindest mir bis vor kurzem nicht) ist, dass man mit kill -0 auch feststellen kann, ob ein Prozess noch läuft. Denn mit dem Befehl kill kann man einem Prozess auch Signale schicken, zu denen auch schon das vorhin erwähnte Signal 9 gehört.

Alles was man dazu benötigt ist die Prozess ID (pid). Diese erhält man über die Shell Variable $!. In Zeile 4 des Beipiels wird sie gleich mit dem Start eines Prozesses in einer Variablen abgespeichert. In der darauf folgenden Zeile wird dieser pid dann das Signal 0 über den Befehl kill gesendet.
Findet der Kernel diese pid in seiner Prozesstabelle erhält man als Returnwert 0, wenn nicht eine 1. So muss man nicht selbst umständlich in der Prozesstabelle suchen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#!/bin/bash
 
pid=""   
./longrun.sh & pid=$!
kill -0 $pid 2>/dev/null
 
if [ $? -eq 0 ]
then
   echo "existing process $pid"
else
   echo "no process with pid: $pid"
fi
 
exit 0

Links:
Beispiele für weitere Programmiersprachen

Warum dieses Kommando unter Linux und MacOs nicht vorhanden ist, ist mir schleierhaft, zumal es in der Version 8 der SuSE Linux Distribution meines Wissens noch enthalten war. Lang ist’s her. Wer den Grund weiß, möchte mich bitte in den Kommentaren erleuchten.

Doch wer auf den optionalen Parameter für die Darstellung der Verzeichnistiefe verzichten kann, dem kann geholfen werden. Eine Kombination des find und sed Kommandos versteckt in einem alias ergibt fast die gleiche Ausgabe auf der shell.

alias tree="find . -print | sed -e 's;[^/]*/;|____;g;s;____|; |;g'"

via:
macnotes.de – Baumansicht mit Tree

Denn meldet man sich über den Putty z.B auf einem Linux Server an, dessen Spracheinstellungen:

> locale
LANG=de_DE.UTF-8
LC_CTYPE="de_DE.UTF-8"
LC_NUMERIC="de_DE.UTF-8"
LC_TIME="de_DE.UTF-8"
LC_COLLATE="de_DE.UTF-8"
LC_MONETARY="de_DE.UTF-8"
LC_MESSAGES="de_DE.UTF-8"
LC_PAPER="de_DE.UTF-8"
LC_NAME="de_DE.UTF-8"
LC_ADDRESS="de_DE.UTF-8"
LC_TELEPHONE="de_DE.UTF-8"
LC_MEASUREMENT="de_DE.UTF-8"
LC_IDENTIFICATION="de_DE.UTF-8"
LC_ALL=

durchaus Umlaute unterstützen sollte, es aber dennoch nicht möglich ist, diese im Editor vi einzugeben, dann hat man doch ein Problem.

Schuld ist in diesem Fall aber weder der vi oder dessen größerer Bruder vim, sondern die Einstellungen vom Putty. Diese sollte man auch (über change settings -> Translation) auf UTF-8 umstellen.

Dann klappt es auch mit den Umlauten.

Vielleicht als erstes die Vorteile. Der vi ist auch heute nach 34 Jahren (und damit ist er leider jünger als ich ) auf jedem Unix basiertem Betriebssystem vorhanden und kann mehr als sein Windows Pendant Notepad, den man wie es der Name schon sagt, nur in Notlagen benutzen sollte.

Wo viel Sonne ist, da ist auch Schatten. So ist die Befehlssyntax des vi sehr komplex und auch die voneinander getrennten Befehls- und Eingabemodi tragen nicht unbedingt zu einer intiuitiven Bedienung bei.

Wenn wir schon bei den Stati sind – eigentlich sind es drei. Der Kommandozeilenmodus und wie schon erwähnt der Befehls- und der Eingabe/Änderungsmodus. In der folgenden Übersicht sind die Befehle aufgeführt, die den Wechsel zwischen diesen Stati erlaube:

Der Aufruf ist mit:

vi <Dateiname>

recht simpel. Die Befehls- oder Kommandosyntax ist dagegen recht komplex. Sie läßt sich aus meiner Sicht aber gut in die Kategorien allgemein und die Bearbeitung von Zeilen, Zeichen bzw. Wörtern zusammenfassen:

Eigentlich gibt es nur 2 Reaktionen auf den vi – entweder man liebt ihn oder man verflucht ihn. Passend dazu noch 2 kleine Zitate aus dem Wikipedia Artikel:

Vi – It’s small but smart.
(Vi – Es ist klein, aber schlau.) Chris Snowwhite

vi has two modes: beep constantly, and break everything
(vi hat zwei Betriebsarten: Pieps dauernd rum und mach alles kaputt) Unbekannter Autor

Wer es etwas komfortabler mag, sollte sich den vim (Vi IMproved) anschauen, der auf Linux Systemen den vi ablöst und den Schmerz etwas lindert.

Links:
Mindmap – vi Editor für Einsteiger (pdf)

Doch wie ermittelt man die Anzahl der Dateien in so einem Verzeichnis?

Ist die Windows Powershell installiert, ist dies mit folgendem Befehl möglich:

(Get-ChildItem D:\data).Count

Hat man noch XP und keine Powershell bietet sich Cygwin als Alternative an. Cygwin ist eine Implementierung von Unix Tools für Windows. Diejenigen von Euch, die wie ich lieber mit Unix basierten Systemen arbeiten, ziehen der Powershell die Bash sicherlich vor und ermitteln die Anzahl der Dateien auf diese Weise:

find /cygdrive/D/data -type f|wc -l

Schneller fertig, war in meinem Fall Cygwin. Noch ein Grund mehr sich dieses nützliche Tool zu installieren, wenn man schon mit Windows arbeiten muss. Ein Umstieg auf Linux oder MacOS wird dadurch auch leichter.

Quelle: aptgetupdate

via: aptgetupdate

Bei der Durchsicht der Liste, der 100 besten vim Befehle, habe ich wieder einmal viel gelernt über diesen Konsolen Editor, aber auch alt bekannte und lieb gewonnene Funktionen entdeckt. Meine absoluten Favoriten sind:

• :syntax on zum anschalten der Syntax Hervorhebung (syntax highlighting)
• die Befehle zum Einrücken von Code
  :set autoindent Einrücken anschalten
  :set smartindent intelligentes Einrücken anschalten
  :set shiftwidth=4 Definieren von 4 Leerzeichen als Einrückgröße
  ctrl-t, ctrl-d Ein/Ausrücken im insert mode
  >> Einrücken im Befehlsmode
  << Ausrücken im Befehlsmode
• Die Interaktion mit Unix
  :!pwd Ausführen vom “pwd” Unix Befehl und dann zum vim zurückkehren
  !!pwd Ausführen vom “pwd” Unix Befehl und das einfügen der Ausgabe in die Datei
  :sh temporärer Ausflug auf die Unix Shell
• :%s/old/new/g Ersetzen von “old” durch “new” in der gesamten Datei

Welche Editoren für die Konsole nutzt Ihr? Und falls der vim dabei ist, auf welche Befehle könntet ihr nicht verzichten?

Möchte man kein Geld ausgeben landet man schnell bei VNC und seinen Derivaten (wie z.B. UltraVnc).

Ich persönlich nutze für Windows ebenfalls Microsofts eigene Lösung RemoteDesktop, da sie in Sachen Performance die Nase klar vorn hat. Für einen Linux Desktop (übrigens KDE auch weil er schneller ist als Gnome) musste ich dann allerdings auf VNC zurückgreifen.

Unzufrieden über die Performance dieser Lösung, habe ich schon die ganze Zeit nach einer Alternative gesucht und sie jetzt mit FreeNX von NoMachine gefunden. FreeNX ist nicht nur performanter, sondern geht auch in der Server Version schonender mit den Systemresourcen um. In der kostenlosen Version ist FreeNX auf 3 gleichzeitige Benutzer beschränkt (was mir persönlich aber auch reicht).

Nach dem download (für Kubuntu stehen auf der nomachine Seite *.deb Pakete zur Verfügung), müssen die Pakete für den Server Betrieb (also auf dem Linux System, was den Desktop bereitstellen soll) in folgender Reihenfolge eingespielt werden:

> sudo dpkg -i nxclient_3.3.0-6_i386.deb
    ...
    Paket libaudiofile0 ist nicht installiert.
    ...
# Auflösen der Abhängigkeiten
> sudo aptitude safe-upgrade
> sudo dpkg -i nxnode_3.3.0-22_i386.deb
> sudo dpkg -i nxserver_3.3.0-27_i386.deb

Danach steht der Server sofort zur Verfügung und kann benutzt werden. Für weitergehende Konfigurationen solltet Ihr Euch die Installationsanmerkungen unter /usr/NX/share/documents/server/install-notices durchlesen (rtfm ).

Clients gibt es für Windows, Linux und MacOs. Sie lassen sich ebenso schmerzfrei installieren, wie der Serverteil. Im von mir benutzten Windows Client (den MacOs Client werde ich auch noch testen) kann man nach der Installation mittels eines Assistenten eine Verbindung zum Linux System aufbauen und dann sowohl den KDE (in seiner ganzen Schönheit) als auch einzelne Programme benutzen.

Andere Linux Desktops (wie Gnome oder XFCE) funktionieren natürlich genauso gut.

Links:
Wiki ubuntuusers.de: FreeNX