linux|n00b Linux für Ein- und Umsteiger

3Jan/131

Wie viele Wörter hat mein PDF-File?

Diese Frage stellte ich mir soeben selbst, als ich den aktuellen Umfang meiner Bachelorarbeit überprüfen wollte.

Glücklicherweise gab es schon viele vor mir mit dieser Frage. So fand ich schnell eine Lösung:
http://superuser.com/questions/221359/count-words-in-pdf-file

Dort heißt es:

[arvid@c64 ~]$ pdftotext path/to/my/file.pdf - | wc -w

Ausgabe im Terminal ist schließlich die Anzahl der Wörter. Und das war's auch schon.

Wieder mal ein Hoch auf Linux, welches bereits alle Probleme gelöst hat, die ich erst noch bekommen muss. :-)

4Mai/120

iPhone/iPod Touch mount-Fehler beheben

Was für eine schwere Geburt. Ich hatte lange Zeit das Problem, meinen iPod Touch nach Anschluss via USB-Kabel nicht mounten zu können. Ich erhielt stets die Fehlermeldung, dass es einen Zugriffsfehler (-5) gäbe. Der Terminal-Befehl ideviceinfo spuckte immer nur aus: "GNUTLS ERROR: A TLS packet with unexpected length was received."

Die nötigen Pakete waren installiert, aber kein Erfolg beim Einhängen des iPod. Hin und wieder habe ich nach einer Lösung gesucht, aber entweder habe ich immer nach falschen Stichworten gesucht oder die Lösung ist wirklich so versteckt gewesen.

Die Suche hat ein Ende.

Nun jedoch habe ich endlich die Lösung gefunden und sie ist denkbar einfach. Im Terminal ist lediglich Folgendes einzugeben und schon kann der iPod Touch eingehängt werden und gestattet den Zugriff z.B. via gtkpod.

[arvid@c64 ~]$ idevicepair unpair
SUCCESS: Unpaired with device <lange_nummer>
[arvid@c64 ~]$ idevicepair pair
SUCCESS: Paired with device <lange_nummer>
[arvid@c64 ~]$ idevicepair validate
SUCCESS: Validated pairing with device <lange_nummer>

Alles funktioniert jetzt wunderbar.

Das war's auch schon. Der Befehl ideviceinfo sollte nun bedeutend mehr ausgeben als die besagte Fehlermeldung.

[arvid@c64 ~]$ ideviceinfo
ActivationPublicKey: <laaanger_key>
ActivationState: Activated
[...]
WiFiAddress: <mac_adresse>
iTunesHasConnected: true
27Mai/110

Autovervollständigung für Terminal-Befehle

Die Autovervollständigung für Befehle im Terminal sollte bekannt sein (nur den Anfang eines Befehls eingeben und Tab-Taste drücken, ggf. 2x drücken, wenn der Befehl noch nicht eindeutig identifizierbar ist). Was z.B. unter Ubuntu von Haus aus klappt, aber nicht unter Fedora, ist die Autovervollständigung für die Befehls-Parameter bzw. für Unterbefehle.

Auf "If Not True Then False" findest du eine kurze Erläuterung sowie Installationsanleitung für bash-autocomplete, welches genau das bereinigt. Zu installieren ist lediglich bash-completion.

[arvid@c64 ~]$ sudo yum install bash-completion

Nützlich ist bash-autocompletion für mich insbesondere bei der Eingabe von Befehlen wie "svn <unterbefehl>" oder "sudo service httpd restart".

24Mai/110

Kleine Tool-Sammlung für das CLI

Jüngst erreichte mich folgender Link: Cool, but obscure unix tools. Dort findest du eine Reihe bunter Screenshots zu dem einen oder anderen bekannten und auch unbekannten Commandline-Tool. Nette Auflistung, wie ich finde.

4Sep/100

SVN ignore

Da die vor wenigen Wochen beschriebene SVN-Integration in den Nautilus keine Möglichkeit bietet, Dateien oder Verzeichnisse zu ignorieren, hilft nur noch ein Kommandozeilenbefehl.

Angenommen dein Projekt befindet sich unter SVN-Kontrolle und du hast ein Verzeichnis file_cache/ (unterhalb eines Verzeichnisses application/) sowie ein Verzeichnis logs/, so kannst du den Inhalt beider Verzeichnisse von der SVN-Kontrolle wie folgt ausschließen:

[arvid@C64 ~]$ cd devel/meinprojekt
[arvid@C64 meinprojekt]$ svn propset svn:ignore "*" application/file_cache/
[arvid@C64 meinprojekt]$ svn propset svn:ignore "*" logs/

Der svn-propset-Befehl erwartet als Parameter also ein Muster der zu ignorierenden Datei/en (im Beispiel ein Sternchen "*" für alle Dateien) gefolgt vom Zielverzeichnis, in dem sich die zu ignorierenden Dateien befinden.

Schließlich muss die Änderung noch ins Repository eingecheckt werden.

[arvid@C64 meinprojekt]$ svn ci -m "kommentar"

Gefunden habe ich diese kurze Hilfe im Übrigen hier: devcha-Blog.

3Sep/100

tar.gz – Wie war das noch gleich?

Viele (mich eingeschlossen) vergessen immer wieder, wie tar.gz-Dateien zu entpacken sind. Jedoch vorab an dieser Stelle nochmal ein ganz kurzer Exkurs zum Thema:

Was ist tar.gz überhaupt?

Zunächst muss man wissen, dass man es mit zwei verschiedenen Dateitypen zu tun hat. Zum Einen mit tar und zum Anderen mit gz. Klingt jetzt lapidar und überflüssig, ist aber eine wichtige Erkenntnis im Umgang mit tar.gz.

tar-Archiv

Das tar-Archiv -der geneigte Linux-Pro nennt es übrigens Tarball- ist grundsätzlich unkomprimiert. Es ist also in der Dateigröße nicht kleiner als die Original-Dateien, die in das Archiv eingepackt wurden. Ein Tarball ist lediglich eine Art Container, in den Dateien hineingeworfen werden können.

gz-Datei

Die Dateiendung .gz lässt auf ein sogenanntes gzip schließen. Ähnlich einem zip dient gzip der Kompression von Dateien (aber bitte nicht gzip mit zip verwechseln, das sind unterschiedliche Verfahren, sie basieren nur auf dem gleichen Algorithmus). Gzip kann allerdings nur eine einzelne Datei komprimieren. Und so erschließt sich langsam der Sinn hinter all den tar.gz-Dateien...

1 und 1 zusammenzählen

Dateien mit der Endung .tar.gz sind folglich eine Sammlung von Dateien als Tarball gespeichert und anschließend mit gzip komprimiert. Das ist auch schon alles.

Eine prima Veranschaulichung dessen findest du in der Wikipedia zum Thema tar. Ergänzend dazu sei noch der entsprechende Artikel zu gzip erwähnt.

Wie entpackt man das?

Kommen wir mal langsam zum Punkt. So gehts...

Der nicht ganz so kurze Weg

Entpacken lässt sich ein tar.gz wie folgt in zwei Schritten.
Zunächst ist das gzip zu dekomprimieren:

[arvid@C64 ~]$ gunzip deine-datei.tar.gz

Anschließend ist der bei der Dekompression entstandene Tarball auszupacken:

[arvid@C64 ~]$ tar xfv deine-datei.tar

Und damit ist deine-datei.tar.gz nun dekomprimiert uns ausgepackt. Fertig.

Der ganz kurze Weg

Beide Schritte in einem Rutsch abzuarbeiten, lässt sich mit dem Befehl tar und dem zusätzlichen Parameter -z erledigen:

[arvid@C64 ~]$ tar xfvz deine-datei.tar

Ein Aufruf des Befehls

[arvid@C64 ~]$ tar --help

offenbart uns -in der Konsolenausgabe zum Abschnitt "Kompressionsoptionen" gescrollt- sogar, welchen Nebeneffekt der neue Parameter hatte. Der tar-Befehl selbst lässt die Datei durch gunzip laufen, der manuelle Aufruf des gunzip-Befehls fällt daher weg.

Und wie verpackt man das?

Bevor ich noch weitere Infos abschreibe, möchte ich dich mal an folgenden Blog verweisen, auf dem das in aller Kürze zusammengefasst ist: tar.gz verpacken und entpacken auf miZine

21Aug/100

Viele Bilder auf einmal verkleinern

Du möchtest hunderte von Fotos verkleinern, damit du sie zum Beispiel auf eine Homepage laden kannst oder Ähnliches? Verständlich, dass du auf keinen Fall jedes Bild einzeln mit einer Bildbearbeitung öffnen, es auf die gewünschte Größe verkleinern und schließlich speichern möchtest. Das kostet viel Zeit. Zum Glück gibt es GraphicsMagick, welches genau das für dich in einem einzigen Durchlauf (quasi Batch) erledigt.

GraphicsMagick findet seine Abstammung im fast ebenso mächtigen Tool ImageMagick und kann sehr viel mehr als nur Bilder verkleinern, aber beschränken wir uns an dieser Stelle auf das Verkleinern. Ich unterstelle einmal, dass das eines der gängigsten Anwendungsbeispiele sein könnte (zumindest auf mich trifft diese Aussage zu, auf dich vielleicht auch, weil du diesen Artikel ja gerade liest).

Lange Rede, kurzer Sinn - so geht's:

[arvid@C64 ~]$ cd verzeichnis-mit-bildern/
[arvid@C64 verzeichnis-mit-bildern]$ gm mogrify -resize 400x300 *.png

Also ab ins Verzeichnis, in dem sich die zu verkleinernden Fotos befinden und das GraphicsMagick-Utility "mogrify" aufrufen. Als Parameter die Größe angeben und zu guter Letzt ein Suchmuster für die Bilddateien, auf welche der Befehl angewendet werden soll. Das ist auch schon alles. Einfach, oder?

Wenn du ausschließlich Meta-Informationen aus den Bildern entfernen möchtest (z.B. im Foto gespeicherte Kameraeigenschaften), rufe folgenden Befehl auf:

[arvid@C64 verzeichnis-mit-bildern]$ gm mogrify *.png +profile "*"

Du kannst deinen Befehl auch noch wie folgt erweitern/verändern/optimieren:

  • beide Befehle zu einem Befehl zusammenfassen
  • die Resize-Angabe durch einen Prozentwert ersetzen, anstatt eine genaue Auflösung anzugeben
  • ggf. ein anderes Dateiformat angeben (neben PNG auch JPG/JPEG und viele andere)
[arvid@C64 verzeichnis-mit-bildern]$ gm mogrify -resize 50% *.jpg +profile "*"

Wie schon erwähnt, ist GraphicsMagick zu sehr viel mehr in der Lage als das hier. Es gibt tonnenweise andere Befehle und Befehlskombinationen. Hierfür lies dich am besten auf der offiziellen Homepage schlau oder suche nach weiteren Informationsquellen in der Suchmaschine deiner Wahl.

13Aug/100

SVN für eigenen Bedarf einrichten

SVN? Wofür?

Nicht nur für die Bewältigung größerer Aufgaben im Team, sondern auch für eigenes, lokales Arbeiten kann es manchmal sinnvoll sein, Dateien und Verzeichnisse zu versionieren.

Das trifft so ungefähr auf jede selbstständige Arbeit zu, bei der man Ergebnisse produziert, diese hin und wieder oder sogar stetig überarbeitet und für die man in der Lage sein möchte, den Entwicklungsprozess zu rekonstruieren und im Bedarfsfall Änderungen rückgängig zu machen. Das können z.B. Studienarbeiten, Programmierprojekte, aber auch gestalterische Tätigkeiten bei der Bildbearbeitung oder dergleichen sein.

Vor diesem Hintergrund möchte ich erläutern, wie man ein eigenes Subversion-Repository aufsetzt, mit dem Dateien unter Versionskontrolle gestellt werden können.

Vermerk zum Thema Sicherheit

Ich möchte ausdrücklich darauf hinweisen, dass die von mir geschilderte Vorgehensweise nur für den Gebrauch an einem Single-User-System geeignet ist, bei dem auf das SVN-Repository nicht über das Netzwerk zugegriffen werden soll. Ich belasse es bei Standard-Belegungen in den config-Files und Authentifizierungen lasse ich außen vor.

Mit anderen Worten gilt für diese Anleitung: Sicherheit weicht dem Komfort.

Warum? Ich hege derzeit kein Interesse, meine eigenen Entwicklungsarbeiten und meine Erzeugnisse für's Studium der Öffentlichkeit zugänglich zu machen. Deshalb beschränke ich mich beim Einrichten auf den Betrieb an einem lokalen System, auf das ohnehin nur ich Zugriff habe.

1. Installation

Zunächst solltest du SVN installieren (Paketname "subversion"). Zur Installation werden diverse Dienstprogramme mitgeliefert, von denen du auf jeden Fall auch svnadmin brauchen wirst. Im Terminal kannst du zum Beispiel mit den Befehlen

[arvid@C64 ~]$ which svn
/usr/bin/svn
[arvid@C64 ~]$ which svnadmin
/usr/bin/svnadmin

prüfen, ob die Installation erfolgreich war. Aber ich denke, da sollte es keine Probleme gegeben haben. Beide Befehle erzeugen im Übrigen lediglich eine kleine Ausgabe der Installationspfade für svn und svnadmin. Letzteres ist jenes Dienstprogramm, welches zum Konfigurieren des SVN-Repositories benötigt wird.

2. Vorüberlegungen

Bevor du loslegst, solltest du dir Gedanken darüber machen, wo du das SVN-Repository erstellen möchtest und vor Allem, wie du deine Verzeichnisstruktur organisieren möchtest. Einen kleinen Denkanstoß soll dir diesbezüglich der Abschnitt "Planung der Organisation Ihres Projektarchivs" aus dem SVN-Book bescheren.

Ich habe mich für folgendes Verzeichnislayout entschieden:

.
├── trunk
│   ├── devel
│   │   ├── meinprojekt
│   │   ├── nocheinrojekt
│   │   └── usw
│   ├── kreatief
│   │   ├── fotobearbeitung
│   │   ├── icons
│   │   └── usw
│   └── studium
│       └── usw
├── tags
└── branches

Unterhalb von trunk/ habe ich Verzeichnisse als Kategorien angelegt (devel/ für Develeopment bzw. Programmierung, kreatief/ für gestalterische Schaffensprozesse etc.). In die jeweiligen Kategorien pflege ich einzelne Projekte ein. Das kannst du allerdings vollkommen individuell halten, es gibt keine Vorschriften für die Ordnerstrukturen. Du kannst auch ganz auf die Einteilung in trunk, tags und branches sowie auf die Kategorien verzichten und zum Beispiel nur dein/e Projekt/e ins SVN-Repository stecken:

.
├── meinprojekt
├── nocheinrojekt
├── fotobearbeitung
├── icons
└── usw

Wie gesagt - das liegt ganz bei dir.

3. Verzeichnisstruktur anlegen

Um das Verzeichnislayout zu übernehmen, lege einfach ein paar Ordner in tmp/ an, wir werden sie in Kürze ins Repository übernehmen und dann wieder löschen.

[arvid@C64 ~]$ cd /tmp/
[arvid@C64 tmp]$ mkdir tmpsvn
[arvid@C64 tmp]$ mkdir tmpsvn/{trunk,tags,branches}
[arvid@C64 tmp]$ mkdir tmpsvn/trunk/{devel,kreatief,studium}

Die Projektverzeichnisse innerhalb der Kategorieverzeichnisse (wie zum Beispiel meinprojekt/ aus obiger Ordnerstruktur) lege ich nicht an, da das keine neuen Projekte sind, sondern welche, die bereits woanders gespeichert sind (das sind also schon bestehende Projekte, wir werden uns weiter unten darum kümmern). An dieser Stelle sollen uns die Kategorien genügen.

4. Repository anlegen und Struktur übernehmen

Auf ein Verzeichnis deiner Wahl erzeugst du nun mit svnadmin und dem Unterbefehl create ein neues SVN-Repository. Ich habe mich für ein Verzeichnis auf meiner externen USB-Festplatte entschieden:

[arvid@C64 tmp]$ svnadmin create /media/AUSSENPLADDE/SVN-REPO

Das Verzeichnis SVN-REPO/ wird automatisch angelegt und mit einigen notwendigen Ordnern und Dateien befüllt, die du auf keinen Fall löschen oder bearbeiten solltest (es sei denn, du weißt genau, was du tust). Jetzt kannst du die Verzeichnisstruktur übernehmen, die du eben noch unter tmp/ angelegt hast:

[arvid@C64 tmp]$ svn import tmpsvn file:///media/AUSSENPLADDE/SVN-REPO/ -m "initiales Verzeichnislayout für das SVN-Repository angelegt"
Hinzufügen     tmpsvn/trunk
Hinzufügen     tmpsvn/trunk/devel
Hinzufügen     tmpsvn/trunk/kreatief
Hinzufügen     tmpsvn/trunk/studium
Hinzufügen     tmpsvn/branches
Hinzufügen     tmpsvn/tags

Revision 1 übertragen.
[arvid@C64 tmp]$ rm -r tmpsvn/

Damit hast du bereits die allererste Revision erzeugt, als Kommentar (Parameter -m = message) hast du einen kurzen Text angegeben, der das Ganze beschreibt. Im Anschluss löscht du das temporär angelegte Verzeichnis tmpsvn/.

5. Repository auschecken

Wechsle in dein Home-Verzeichnis oder in ein anderes, wenn du deine Projektdaten nicht im Home-Verzeichnis haben möchtest und führe dann den SVN Checkout-Befehl aus:

[arvid@C64 tmp]$ cd ~
[arvid@C64 ~]$ svn co file:///media/AUSSENPLADDE/SVN-REPO/trunk/devel
Ausgecheckt, Revision 1.

Also ich beschränke mich demnach nur auf das Auschecken der Kategorie "devel" für meine Development-Projekte. Du solltest devel durch deine Kategorie oder den Namen deines Projektes austauschen, ggf. auch trunk/ weglassen (je nachdem, für welches Verzeichnislayout du dich entschieden hast). In deinem Homeverzeichnis wird nun devel/ angelegt, dort hinein kopieren wir gleich unsere Projekte aus den alten Devel-Verzeichnissen, in denen es noch keine Verionskontrolle gab.

6. Projektdaten kopieren und dem Repository hinzufügen

Wie ich schon geschrieben habe, möchte ich kein neues Projekt beginnen, sondern ein bestehendes ins SVN-Repository übertragen. Wenn du das genauso machen möchtest, dann kopiere einfach deinen Projektordner aus dem alten devel-Verzeichnis ins neue, welches wir gerade eben ausgecheckt haben.

[arvid@C64 ~]$ cp -R altes_devel_ohne_svn/meinprojekt/ devel/

Damit befindet sich meinprojekt/ jetzt unter devel/. Ein kurzer Test zeigt, dass der Kopiervorgang geklappt hat, aber dass SVN noch nichts damit anzufangen weiß (beachte das Fragezeichen an erster Stelle der Ausgabe):

[arvid@C64 ~]$ svn status devel/
?       devel/meinprojekt

Du musst also noch SVN mitteilen, dass da etwas Neues ist, was du gerne dem SVN-Repository hinzufügen möchtest:

[arvid@C64 ~]$ cd devel
[arvid@C64 devel]$ svn add meinprojekt/
A         meinprojekt
A         meinprojekt/public
A         meinprojekt/public/index.php
A         meinprojekt/public/js
A         meinprojekt/public/js/swfobject-2.2.js
A         meinprojekt/public/js/common.js
A         meinprojekt/public/js/jquery-1.4.min.js
A         meinprojekt/public/js/common.functions.js
A         meinprojekt/public/js/admin
       <..... usw. .....>

Es folgen je nach Projektgröße einige oder viele Dateien mit dem Präfix A, welcher nichts anderes bedeuted als "Added", also dem SVN hinzugefügt (aber noch nicht dem Repository!). Was nun noch fehlt, ist das Einchecken, auch Commit genannt:

[arvid@C64 devel]$ svn ci -m "meinprojekt ins Repository eingepflegt"
Hinzufügen     meinprojekt
Hinzufügen     meinprojekt/application
Hinzufügen     meinprojekt/application/Bootstrap.php
Hinzufügen     meinprojekt/application/configs
Hinzufügen     meinprojekt/application/configs/application.ini
Hinzufügen     meinprojekt/application/configs/preferences.ini
Hinzufügen     meinprojekt/application/controllers
       <..... usw. .....>
Hinzufügen     meinprojekt/public/js/swfobject-2.2.js
Übertrage Daten .........................................
Revision 2 übertragen.

Erst der Check-In-Befehl überträgt die Dateien zum Repository. Wieder hast du mit dem Parameter -m einen Kommentar angegeben. Und wieder folgt eine Liste mit all den Dateien, die du eben noch dem SVN bekannt gemacht hast. Durch das Einchecken hast du die nächste Revision erzeugt.

7. Prüfen

Du kannst nun testen, ob das Schiff wirklich sicher den Hafen erreicht hat, indem du dir einfach den SVN-Log ansiehst. Hierfür mache zuerst ein Update, anschließend lasse dir die Logs anzeigen:

[arvid@C64 devel]$ svn up
Revision 2.
[arvid@C64 devel]$ svn log
------------------------------------------------------------------------
r2 | arvid | 2010-07-20 10:44:53 +0200 (Di, 20. Jul 2010) | 1 Zeile

meinprojekt ins Repository eingepflegt
------------------------------------------------------------------------
r1 | arvid | 2010-07-20 10:07:16 +0200 (Di, 20. Jul 2010) | 1 Zeile

initiales Verzeichnislayout für das SVN-Repository angelegt
------------------------------------------------------------------------

Du siehst mit dem Log-Befehl die letzten Revisionen (neueste immer oben) inklusive der Kommentare. Offenbar verlief alles nach Plan.

8. Zusammenfassung

Die eigentliche "Magie" des Ganzen liegt in den Abschnitten 3 und 4, in denen gezeigt wird, wie du Verzeichnisstrukturen anlegst und diese in das neu erzeugte Repository übernimmst.

Alles andere danach sollte dir eventuell bereits vertraut sein, wenn du ein geübter SVN-User bist. Die Abschnitte 5 bis 7 lassen sich auch mit beliebigen Frontend-SVN-Clients erledigen, wie zum Beispiel mit einem im Nautilus integrierten SVN-Client.

Weitere Infos

Sieh dir die folgenden Seiten an, denen ich ebenfalls einige Informationen entnommen habe. Vielleicht helfen sie dir noch ein bisschen mehr für's Verständnis:

svnadmin create D:\repository\myproject
2Aug/100

Verzeichnisübersicht mit tree

Übersicht eines Verzeichnisbaumes gefällig? Erlabe dich an den Ergüssen des Befehles tree:

[arvid@C64 ~]$ tree -d

Eine Beispielausgabe könnte wie folgt aussehen, wobei der Punkt (".") für das Verzeichnis steht, aus welchem heraus der tree-Befehl ausgeführt wird (in diesem Falle das Home-Verzeichnis des Users arvid):

.
├── verzeichnis
│   ├── unterverzeichnis
│   │   ├── unterunterverzeichnis
│   │   ├── noch eins
│   │   └── das dritte unterunterdingens
│   ├── wieder ein unterverzeichnis
│   │   ├── jetzt wirds langsam bunt
│   │   ├── ich denke
│   │   └── du hast spätestens
│   └── an dieser stelle
│       └── begriffen
├── was der befehl tree
└── macht

Ist dir die Ausgabe zu groß, kannst du sie einschränken durch den Parameter -L.

[arvid@C64 ~]$ tree -d -L 2

Hierbei käme zum Beispiel jene Ausgabe raus:

.
├── verzeichnis
│   ├── unterverzeichnis
│   ├── wieder ein unterverzeichnis
│   └── an dieser stelle
├── was der befehl tree
└── macht

Der Parameter -d sorgt im Übrigen dafür, dass ausschließlich Verzeichnisse im Baum ausgegeben werden, Dateien werden ignoriert. Ohne Angabe von -d würden also auch Dateien angezeigt werden.
Der Parameter -L mit dem folgenden Wert 2 beschränkt den Verzeichnisparser auf die Tiefe 2 (L steht hier für Level). Also Unterverzeichnisse werden nur dann in die Ausgabe eingeschlossen, wenn sie bis zu 2 Verzeichnisebenen tiefer liegen als das Wurzelverzeichnis, von dem aus "gezählt" wird (im Beispiel ist es das Home-Verzeichnis).

Von der Usage-Hilfe kannst du dich mit weiteren Möglichkeiten für Parametereingaben berieseln lassen:

[arvid@C64 ~]$ tree --help