featured Archives - demaya.de

Man muss ja schon ein gewisses Faible für Manpages haben um so richtig mit Ihnen zurecht zu kommen. Es gibt sehr viele gute Manpages, aber auch einige miserable Exemplare. Diese Lücke schließt meiner Meinung nach cheat. Ich kann nur für mich sprechen, aber Beispiele bringen mich 10 mal weiter, als trockene Theorie. Cheat bietet eine stattliche Anzahl an Beispielen, die einfach in die bestehende Landschaft integriert werden können. Ein ‚cheat -l‘ bietet dann eine Auswahl an Befehlen, für die es Cheatsheets gibt. Mit einem ‚cheat tar‘ könnte man unter Umständen das nächste mal die Bombe entschärfen:

user@pc ~/ $ cheat tar
# To extract an uncompressed archive:
tar -xvf /path/to/foo.tar

# To create an uncompressed archive:
tar -cvf /path/to/foo.tar /path/to/foo/

# To extract a .gz archive:
tar -xzvf /path/to/foo.tgz

# To create a .gz archive:
tar -czvf /path/to/foo.tgz /path/to/foo/

# To list the content of an .gz archive:
tar -ztvf /path/to/foo.tgz

# To extract a .bz2 archive:
tar -xjvf /path/to/foo.tgz

# To create a .bz2 archive:
tar -cjvf /path/to/foo.tgz /path/to/foo/

# To list the content of an .bz2 archive:
tar -jtvf /path/to/foo.tgz

# To create a .gz archive and exclude all jpg,gif,... from the tgz
tar czvf /path/to/foo.tgz --exclude=\*.{jpg,gif,png,wmv,flv,tar.gz,zip} /path/to/foo/

Cheat installieren

Installieren lässt sich Cheat, indem man das git-Repository klont und anschließend die setup.py ausführt:

git clone https://github.com/chrisallenlane/cheat.git
cd cheat
sudo python setup.py install

Ich für meinen Teil habe das Repository geforkt und anschließend unter meinem ~/bin abgelegt. So kann ich die Cheatsheets auch mal anpassen und u.U. Pullrequests senden um meine Arbeit zu teilen. Der geneigte Archlinux User kann sich aus dem AUR bedienen.

Sonstiges

Cheat lässt sich über diverse Variablen konfigurieren. Somit lassen sich z.B. auch Rezept- oder Notizdatenbanken aufbauen (alternatives Verzeichnis mit Rezept- / Notiznamen als Dateinamen).

Wer kennt das nicht? Die schönen aliase oder die vimrc mal wieder nicht auf dem Server/PC/Notebook/Raspberry Pi vorhanden. Gerade wenn man öfter mal was auf X Rechnern testet, bekommt man häufig von der Shell gesagt, dass es den Befehl gar nicht gibt… eben weil die ganzen Dotfiles fehlen und der Mensch ein Gewohnheitstier ist (‚ll‘ tippt sich einfach schneller als ‚ls -l‘). Mir ging es immer so, dass ich pro Maschine zusammengeschusterte Dotfiles hatte. Und es fehlt immer etwas. Eben auch, weil das passende zentrale Management fehlt.

GitHub does dotfiles

GitHub hat als Einführung eine eigene Seite für die „Punktfiles“ online. Hier finden sich verschiedene Tools, Bootstraps und Beispiele, wie man seine Dotfiles verwalten kann. Unter anderem seien genannt: homesick, fresh,… Was mich abschreckte ist die Komplexität, die für eine relativ einfache Sache benötigt wird. Ja: die Tools können echt viel, aber ich hole mir viel Code ins Boot.

Mit ein paar Zeilen Code immer up to date bleiben

Zum Glück fand ich einen Blogeintrag von Michael Smalley, der sehr übersichtlich und verständlich erklärt, wie man sein eigenes Skript und GitHub-Repository aufsetzen kann. Aufbauend auf diese Anleitung habe ich mir zwei Shellskripts unter ~/.dotfiles angelegt.

#!/bin/bash
############################
# Init-Script
# This script creates symlinks from the home directory to any desired dotfiles in ~/.dotfiles
############################

########## Variables

dir=~/.dotfiles                    # dotfiles directory
olddir=~/.dotfiles_old             # old dotfiles backup directory
files=`ls -1 $dir/__*`    # list of files/folders to symlink in homedir

##########

# create dotfiles_old in homedir
echo "Creating $olddir for backup of any existing dotfiles in ~"
mkdir -p $olddir
echo "...done"

# change to the dotfiles directory
echo "Changing to the $dir directory"
cd $dir
echo "...done"

# move any existing dotfiles in homedir to dotfiles_old directory, then create symlinks 
for file in $files; do
    basename=`basename $file`
    targetname=`echo $basename | sed 's/__//'`
    echo "Moving any existing dotfiles from ~ to $olddir"
    mv ~/.$targetname $olddir/
    echo "Creating symlink to $file in home directory."
    ln -s $dir/$basename ~/.$targetname
done

Dieses Skript erledigt das Backup von „alten“ Dotfiles auf einer neuen Maschine und verlinkt jeweils die im Verzeichnis liegenden Dateien (jeweils mit Prefix „__“). Ich habe mich für diese Variante entschieden, da man relativ einfach neue Dateien integrieren kann. Mit einem „git init“ und dem Hinzufügen der Dateien per „git add $filename“ baut man sich ziemlich schnell sein „dotfiles“-Repository zusammen. Zu dem init-Skript habe ich mir noch ein Skript angelegt, dass nur die lokale Verlinkung übernimmt.

#!/bin/bash
############################
# 
# This script creates symlinks from the home directory to any desired dotfiles in ~/.dotfiles
############################

########## Variables

dir=~/.dotfiles                    # dotfiles directory
files=`ls -1 $dir/__*`    # list of files/folders to symlink in homedir

##########
# change to the dotfiles directory

# move any existing dotfiles in homedir to dotfiles_old directory, then create symlinks 
for file in $files; do
    basename=`basename $file`
    targetname=`echo $basename | sed 's/__//'`
    echo "Creating symlink to $file in home directory."
    ln -s $dir/$basename ~/.$targetname
done

Meine erste Datei war die .vimrc. Also habe ich mir mit vim eine neue Datei unter .dotfiles angelegt, die den Namen __vimrc bekommt. Nachdem ich diese Datei gefüllt hatte, konnte ich mit „init.sh“ die Datei installieren. Es wird im Homeverzeichnis ein Link auf die Datei unter .dotfiles/__vimrc angelegt. Siehe auch:

user@pc ~ $ ll .dotfiles/__vimrc 
-rw-r--r-- 1 user user 1,3K Feb 21 17:32 .dotfiles/__vimrc
user@pc ~ $ ll .vimrc
lrwxrwxrwx 1 user user 30 Feb 16 00:07 .vimrc -> /home/user/.dotfiles/__vimrc

Der Inhalt der vimrc wird absofort immer über .dotfiles/__vimrc verwaltet und im Git-Repository gesichert. Da ich nicht der Git-Profi bin, habe ich mich hier sehr stark an die oben genannte Anleitung gehalten.

Updaten und aktuell halten

Änderungen werden mit einem einfachen „git commit -a“ in das lokale Repository eingecheckt. Sobald man diese Änderungen zu GitHub übertragen möchte, kann man dies mit „git push origin master“ machen. Voraussetzung hierfür ist, dass man die Schritte von Michael zur Einrichtung durchgeführt hat. Einen neuen Rechner kann man dann per „git clone git://github.com/<usernameongit>/dotfiles.git“ aktivieren. Nachdem man seine Skripte ausführbar gemacht hat, kann man man mit „init.sh“ seine Dotfiles installieren. Sollte sich das GitHub Repository in der Zwischenzeit geändert haben, kann man mit einem „git pull“ die aktuellste Version von GitHub ziehen.

Fazit

Für mich hat diese Vorgehensweise zweierlei Vorteile: ich werde so langsam aber sich mit git etwas warm. Weiterhin kann ich nun auf meinem PC, meinem Notebook und auf meinem Raspberry Pi die gleichen Dotfiles verwenden ohne manuell irgendwas durch die Gegend kopieren zu müssen. Veränderungen werden automatisch versioniert und können gezielt zurück geholt werden. Ich hoffe ich konnte Euer Interesse wecken und Ihr könnt mit meinen Infos etwas anfangen. Mein Dotfiles Repo findet sich unter: https://github.com/demaya/dotfiles und wartet nur darauf, von Euch geforked zu werden 🙂

demaya.de

alles über Computer, Linux, Agile und Ausbildung der Ausbilder

Alle Artikel mit dem Schlagwort ‘featured’

25 AEVO Prüfungsfragen die in einem AdA-Fachgespräch immer gefragt werden

Cheat: Beispiele als Ergänzung zu Manpages