Groovy Skills International

Konfiguration für Dovecot-Version 2.4 formatieren

2025-10-14T00:00:00+02:00

Dovecot Version 2.4 verwendet für die Konfiguration andere Direktiven¹ als die Vorgängerversionen. Eine Paket-Aktualisierung könnte den Benutzer mit der Notwendigkeit zur Anpassung überraschen.

Insbesondere wenn man den Mailzusteller weitestgehend mit Standardwerten konfiguriert hat um ihn als lokalen Mailspeicher zu betreiben ², kann man mit wenigen Änderungen an der Beispiel-Konfiguration den Betrieb wieder aufnehmen:

Bisherige Konfiguration sichern

cd /etc/dovecot
mv dovecot.conf "dovecot.conf_$(date +%Y%m%d)"
mv conf.d "conf.d_$(date +%Y%m%d)"

Neue Konfiguration zusammenstellen

cp /usr/share/examples/dovecot/dovecot.conf .
echo 'ssl = no' >> /etc/dovecot/dovecot.conf
echo '' >> /etc/dovecot/dovecot.conf
echo 'listen = 127.0.0.1' >> /etc/dovecot/dovecot.conf

SET_MAIL_HOME='s|^mail_home = .*|mail_home = /home/%{user}|g'
SET_MAIL_DRIVER='s|^mail_driver = .*|mail_driver = maildir|g'
SET_MAIL_PATH='s|^mail_path = .*|mail_path = ~/.Maildir|g'
SET_MAIL_UID='s|^mail_uid = .*|mail_uid = %{user}|g'
SET_MAIL_GID='s|^mail_gid = .*|mail_gid = %{user}|g'

sed -i "$SET_MAIL_HOME ; $SET_MAIL_DRIVER ; $SET_MAIL_PATH ; $SET_MAIL_UID ; $SET_MAIL_GID" /etc/dovecot/dovecot.conf

DISABLE_LMTP='s|^\( *lmtp\) |#\1 |g'
sed -i "$DISABLE_LMTP" /etc/dovecot/dovecot.conf

DISABLE_SSL='s|^\( *cert_file\) .*|\1 = /dev/null|g  ;  s|^\( *key_file\) .*|\1 = /dev/null|g'
sed -i "$DISABLE_SSL" /etc/dovecot/dovecot.conf

Neue Konfiguration validieren

doveconf -c /etc/dovecot/dovecot.conf -x

Werden keine Fehler gemeldet, sollte Dovecot nach dem Neustart des Dienstes wieder einsatzfähig sein.

Inhalt der dovecot.conf

Zum Vergleich sei hier noch die Datei /etc/dovecot/dovecot.conf nach der Aufbereitung durch obige Befehle gezeigt:

dovecot_config_version = 2.4.1
dovecot_storage_version = 2.4.1
!include_try conf.d/*.conf
protocols {
  imap = yes
}
mail_home = /home/%{user}
mail_driver = maildir
mail_path = ~/.Maildir
mail_uid = %{user}
mail_gid = %{user}
namespace inbox {
  inbox = yes
  separator = /
}
passdb pam {
}
ssl_server {
  cert_file = /dev/null
  key_file = /dev/null
}
ssl = no
listen = 127.0.0.1

¹ All Dovecot Settings [Version 2.4.1]

² Groovy-Skills Artikel: Dovecot als lokalen Mailspeicher konfigurieren

Libreboot-Bootreihenfolge festlegen (Beispiel IBM X200)

2025-08-11T00:00:00+02:00

WICHTIG: Dieser Beitrag ist in seiner Entwurffassung veröffentlicht und dient vorrangig als Unterstützung bei der autonomen Lösungssuche durch den Leser. Der Beitrag erfüllt nicht die üblichen Qualitätsstandards dieses Blogs und erfordert damit ein tieferes Verständnis der Zusammenhänge. Falsch angewendete Befehle können zu unerwünschten Problemen wie Datenverlust führen oder gar irreparable Defekte verursachen.

The easiest way to find the available boot methods is to look for “Searching bootorder for” in the SeaBIOS debug output.
- https://seabios.org/Runtime_config#Configuring_boot_order (web-archive)

if .. you get an error related to /dev/mem access, you should reboot with iomem=relaxed kernel parameter before running flashprog
On NetBSD and OpenBSD systems, the equivalent to iomem=relaxed in this case is kernel.securelevel=-1;
- https://libreboot.org/docs/install/devmem.html#devmem-access-error

Liste der Bootgeräte aus SeaBIOS-Log lesen

SeaBIOS has the ability to output diagnostic messages.
On coreboot these messages are generally written to the “cbmem” console (CONFIG_DEBUG_COREBOOT).
One can obtain the cbmem tool from the coreboot repository and run “cbmem -c” to view the SeaBIOS diagnostic messages.
- https://seabios.org/Debugging#Diagnostic_information

cbmem -c | grep '^Searching bootorder' |sort|uniq > /tmp/mybootlist.txt

Hinweis: Bei US-Keyboard-Layouts befindet sich Zirkumflex (^) auf Umschalt+6.

Liste der Bootgeräte nach Bedarf ordnen

${EDITOR:-vi} /tmp/mybootlist.txt

Aktuelle Firmware sichern

You should still make several dumps, even if you’re flashing internally, to ensure that you get the same checksums. Check each dump using sha1sum
- https://libreboot.org/docs/install/#howto-readwriteerase-the-boot-flash

flashrom -p internal -r ~/dump.bin

Firmware-ROM herunterladen

There are two possible flash chip sizes for the X200: 4MiB (32Mbit) or 8MiB (64Mbit). This can be identified by the type of flash chip below the palmrest: 4MiB is SOIC-8, 8MiB is SOIC-16.
- https://libreboot.org/docs/install/x200.html#open-source-biosuefi-firmware

Beispiellink zu Firmware: https://mirrors.mit.edu/libreboot/stable/20241206/roms/libreboot-20241206rev11_x200_4mb.tar.xz

Firmware-ROM entpacken (tar xvf ...)
Gewünschte ROM nach /tmp kopieren: (cp ...corebootfb.rom /tmp/)

Liste der Boot-Geräte in Firmware-ROM einfügen

Kommando cbfstool aus Paket coreboot-utils

cbfstool corebootfb.rom add -f mybootlist.txt -n bootorder -t raw
cbfstool corebootfb.rom print

BIOS mit modifizierter Firmware flashen

Kommando flashrom aus Paket fwupd

flashrom -p internal -c "MX25L3205(A)" -w /tmp/corebootfb.com

coreboot-Leichtgewichte: StarBook, Lemur Pro, NovaCostum V54

2024-11-09T00:00:00+01:00

Die Kaufentscheidung für ein leichtgewichtiges Laptop kann nach wie vor schnell getroffen werden, denn während coreboot eine Grundvoraussetzung für jeden sicheren Computer darstellt, scheinen aktuell lediglich drei Marken konkurrenzfähige coreboot-Notebooks anzubieten:

System76 (US) mit dem Lemur Pro
StarLabs (UK) mit dem StarBook
NovaCostum (NL) mit dem V54

Schnellübersicht

Die Tabelle zeigt die Eckdaten der drei 14-Zoller:

	StarBook	Lemur Pro	NovaCostum V54
Gewicht [kg]	1.40	1.00	1.60
Höhe [cm]	1.80	1.70	1.80
Breite [cm]	32.63	31.20	31.70
Tiefe [cm]	22.04	22.30	23.50
Display	16:9 / 2160p	16:10 / 1200p	16:10 / 1800p
nits [cd/m²]	625	400	300
CPU (max)	U7 165H	U7 155U	U7 155H
RAM (min-max):	32 – 96	8 – 56	8 – 96
Festplatten (max)	1	2	2

Gewicht sowie Endpreis hängen von der gewählten Ausstattung ab. Bei jedem Anbieter gibt es auch eine schwächere CPU-Option.

Dovecot als lokalen Mailspeicher konfigurieren

2024-09-26T00:00:00+02:00

Achtung: Diese Anleitung gilt nur bis Dovecot-Version 2.3. Ab Version 2.4 wurde das Format der Konfigurationsdateien geändert.

E-Mail Programme verwalten lokale Nachrichten für gewöhnlich selbst. Das kann zu sehr spezifischen Fehlern führen und zeitaufwendige Migrationen notwendig machen, sollte man einst das Werkzeug wechseln wollen.

Um eine langfristige Unabhängigkeit von der Software und eine flexible Handhabung zu sichern, kann man einen dedizierten IMAP-Dienst zur Nachrichtenverwaltung konfigurieren.

Das erlaubt es, die gewohnte E-Mail Umgebung weiter zu verwenden, während man gleichzeitig die hohen Qualitätsansprüche eines spezialisierten Diensts geltend macht.

Nach Installation – xbps-install -Su dovecot in Void Linux – ist der Konfigurationsaufwand für den Dovecot IMAP-Dienst überraschend gering:

Lokale Nutzung definieren

# Dienst nur via localhost anbieten
SET_LISTEN='s|^#listen = .*|listen = 127.0.0.1|g'
sed -i_$(date +%Y%m%d) "$SET_LISTEN" \
        /etc/dovecot/dovecot.conf

# ~/.Maildir als Mailverzeichnis verwenden
SET_MAIL_LOCATION='s|^#mail_location = .*|mail_location = maildir:~/.Maildir|g'
sed -i_$(date +%Y%m%d) "$SET_MAIL_LOCATION" \
        /etc/dovecot/conf.d/10-mail.conf

# SSL deaktivieren
SET_SSL='s|^ssl = .*|ssl = no|g'
sed -i_$(date +%Y%m%d) "$SET_SSL" \
        /etc/dovecot/conf.d/10-ssl.conf

Authentifizierungsmethode festlegen

## Variante 1: Passwortabfrage deaktivieren
#[ -f /etc/dovecot/conf.d/auth-static.conf.ext ] ||
#        cp /usr/share/examples/dovecot/conf.d/auth-static.conf.ext /etc/dovecot/conf.d/auth-static.conf.ext 
#SET_INCLUDE='s|^#!include auth-static.conf.ext|!include auth-static.conf.ext|g'
#sed -i_$(date +%Y%m%d) "$SET_INCLUDE" \
        /etc/dovecot/conf.d/10-auth.conf

# Variante 2: Zugriff per Linux-Passwort authorisieren
[ -f /etc/dovecot/conf.d/auth-system.conf.ext ] ||
        cp /usr/share/examples/dovecot/conf.d/auth-system.conf.ext /etc/dovecot/conf.d/auth-system.conf.ext
SET_INCLUDE='s|^#!include auth-system.conf.ext|!include auth-system.conf.ext|g'
sed -i_$(date +%Y%m%d) "$SET_INCLUDE" \
        /etc/dovecot/conf.d/10-auth.conf

Variante 1 ermöglicht allen Benutzern Zugriff auf sämtliche E-Mails (!). Sie sollte nur nach gründlicher Analyse der Sicherheits-Anforderungen in Betracht gezogen werden, kann aber bei Linux-Distribution interessant sein, welche im Grundsystem kein PAM beinhalten. Das ist beispielsweise bei Alpine Linux der Fall.

Variante 2 nutzt PAM um beim Mailabruf die Eingabe des lokalen Linux-Benutzerpassworts anzufordern.

Sobald man Dovecot-Dienst aktiviert und gestartet hat – in Void-Linux per sudo ln -s /etc/service/dovecot /var/service/dovecot – kann man im E-Mail Programmen den IMAP-Abruf einrichten. Als Server gibt man dafür localhost an. Benutzername und Passwort entsprechen den Daten des Linux-Benutzers.

Android auf SHIFT6mq parallel zu postmarketOS installieren

2023-12-08T00:00:00+01:00

Dies ist Artikel 4 zur Einrichtung eines SHIFT6mq mit postmarketOS. Weitere Artikel der Serie sind in den Fußnoten verlinkt.¹ ² ³

Parallel zu postmarketOS kann auf dem SHIFT6mq (Codename: axolotl) ein zweites Betriebssystem installiert werden.

Da im Rahmen des ersten Artikels¹ dieser Serie Slot A für Linux genutzt wurde, wird nun hier erläutert, wie man Android in Slot B schreibt.

Voraussetzungen

Das Telefon muss per USB mit dem Linux-PC verbunden sein.
Um auf das Telefon zugreifen zu können, muss das Benutzerkonto des PC’s über die nötigen Rechte verfügen. In Void-Linux sollte diese Anforderung durch Mitgliedschaft in der Gruppe plugdev erfüllt sein: sudo usermod -aG plugdev $USER

ShiftOS-L herunterladen

(PC)

Als Android wird die Variante “ShiftOS-L” von downloads.shiftphones.com/axolotl verwendet.

# Diese beiden Konstanten setzen
ARCHIV=SHIFT6MQ.SOS.3.10.L.20231025-RELEASE-LIGHT-OTA.zip
PRUEFSUMME=0fccccee11eaa2cbec2c8e50256561b2f9480081dd12ca62dc803bfdc19af3e7

# Archiv herunterladen und prüfen
curl -OC - https://downloads.shiftphones.com/builds/$ARCHIV
sha256sum $ARCHIV | grep -Fw $PRUEFSUMME || \
        echo 'Unerwartete Prüfsumme! Abbrechen!' >&2

ShiftOS-L installieren

Um Android in Slot B zu schreiben, muss der Bootloader auf Slot A eingestellt sein.

Obwohl das Aufspielen des Systems im Recovery-Modus erfolgt, beginnt dieser Abschnitt mit der Wahl des Slots und daher im Bootloader-Modus.

Gegenüberliegenden Slot aktivieren

(Modus: Bootloader)

Für folgenden Ablauf startet man den Bootloader durch Drücken von “Lauter” (also VolUp) während man das Telefon (via Power) einschaltet.

fastboot --set-active=a
fastboot getvar current-slot 2>&1 | \
        grep 'current-slot: a$' || \
        echo 'Fehler: Falscher Slot aktiv!' >&2

fastboot reboot recovery

Nach erfolgreichem Ausführen der Befehle sollte das Telefon auf Slot A eingestellt und im Recovery-Modus gestartet sein.

Android-System schreiben

(Modus: Recovery)

Den Recovery-Modus kann man auch aktivieren indem man “Leiser” (also VolDown) gedrückt hält während man das Telefon (via Power) einschaltet.

Dort wählt man dann den Menüpunkt “Apply update from ADB” und führt am PC folgenden Befehl aus. Der Vorgang dauert zirka drei Minuten:

adb sideload $ARCHIV

Übrigens werden so auch Updates eingespielt.

Android-System starten

(Modus: Bootloader)

Abschließend wählt man im Recovery-Modus den Menüpunkt “Reboot to bootloader” und aktiviert Slot B um das nun dort installierte ShiftOS-L zu starten:

fastboot --set-active=b
fastboot reboot

Gratulation! An dieser Stelle sollte Android/ShiftOS-L gestartet sein!

[optional] Android Updater deaktivieren

(Modus: Android)

Ist später ein Update verfügbar, zeigt Android eine Notifikation und bietet die Möglichkeit es herunter zu laden. Weil die Aktualisierung den durch postmarketOS belegten Slot benötigen würde, schlägt ein darauffolgender Installationsversuch allerdings fehl.

Der Update-Hinweis kann also irreführend sein, weshalb es sinnvoll sein kann, ihn zu deaktivieren:

Einstellungen > Apps & Benachrichtigungen > ALLE [] APPS ANZEIGEN
Kebab-Menü (die drei vertikalen Punkte ··· rechts oben) > System-Apps anzeigen
“Updater” am End der Liste wählen > DEAKTIVIEREN > APP DEAKTIVIEREN

¹ Artikel 1 der Serie: postmarketOS auf SHIFT6mq Smartphone installieren

² Artikel 2 der Serie: Platz aus Android-Benutzerpartition für postmarketOS freigeben

³ Artikel 3 der Serie: Bootloader-Firmware des SHIFT6mq Smartphones aktualisieren

⁴ Artikel 4 (dieser)

Bootloader-Firmware des SHIFT6mq Smartphones aktualisieren

2023-12-07T00:00:00+01:00

Dies ist Artikel 3 zur Einrichtung eines SHIFT6mq mit postmarketOS. Weitere Artikel der Serie sind in den Fußnoten verlinkt.¹ ²

Grundsätzlich sollte das Werkzeug fwupd in postmarketOS den Bootloader automatisch aktualisieren⁶. Da dies bei einem SHIFT6mq im Auslieferzustand (Bootloader-Version 3.6.20220211) jedoch ausblieb, wird hier die Durchführung eines manuellen Updates beschrieben.

Ein aktueller Bootloader ermöglicht vor Allem das Umschalten zwischen den installierten Betriebssystemen.

Voraussetzungen für die Einrichtung

Das Telefon muss per USB mit dem Linux-PC verbunden sein.
Am PC müssen fastboot sowie 7zip vorhanden sein. Unter Void Linux werden sie beispielsweise via xbps-install -Su android-tools 7zip installiert.

Bootloader herunterladen und entpacken

(PC)

Verfügbare Bootloader-Versionen stehen auf der Seite des Linux Vendor Firmware Service bereit.

Diese beiden Konstanten referenzieren die zum Zeitpunkt des Verfassens aktuelle Version und können bei Bedarf angepasst werden. (Die angegebene Prüfsumme wurde für diesen Artikel lokal ermittelt.)

# Diese Konstanten setzen
CAB_DATEI=d316238f79ceb89ce415716641f50b92ef10f3c47f747572d5a976f2932db2dc-abl_5.0.20221224.cab
PRUEFSUMME=b75a6818a48422d0f6d3b2ff7e4f9794e51fe8f9ae8c04a47702a0426144d5ef

# Archiv laden und prüfen
curl -LOC - https://fwupd.org/downloads/$CAB_DATEI
sha256sum $CAB_DATEI | grep -Fw $PRUEFSUMME || \
        echo 'Unerwartete Prüfsumme! Abbrechen!' >&2

# Archiv entpacken
7z x $CAB_DATEI

Bootloader aufspielen

(Modus: Bootloader)

An dieser Stelle startet man das Telefon wieder im Bootloader-Modus, indem man beim Einschalten des Telefons (via Power) gleichzeitig “Lauter” (also VolUp) gedrückt hält.

# Abbild-Dateiname bestimmen 
cab_name=${CAB_DATEI#*-}
img_datei=${cab_name%%.cab}.img

# Abbild zu Telefon laden
fastboot flash abl $img_datei reboot bootloader

Umschalten der Boot-Slots ermöglichen

Dieser Befehl aktiviert die beiden Bootloader-Menüelemente “Activate slot _a” sowie “Activate slot _b”⁷:

fastboot oem enable-developer-mode
fastboot reboot bootloader

Gratulation! Nun sollte man ab sofort im Bootloader-Menü und ohne PC einen Boot-Slot auswählen und das dortige Betriebssystem direkt starten können.

¹ Artikel 1 der Serie: postmarketOS auf SHIFT6mq Smartphone installieren

² Artikel 2 der Serie: Platz aus Android-Benutzerpartition für postmarketOS freigeben

³ Artikel 3 (dieser)

⁴ Artikel 4 der Serie: Android auf SHIFT6mq parallel zu postmarketOS installieren

⁶ Shift Forum: Bootloader-Aktualisierung per fwupd

⁷ Shift Forum: OEM Entwicklermodus

Platz aus Android-Benutzerpartition für postmarketOS freigeben

2023-12-06T00:00:00+01:00

Dies ist Artikel 2 der Serie zur Einrichtung eines SHIFT6mq mit postmarketOS. Um die hier beschriebenen Schritte ausführen zu können, muss postmarketOS am Telefon entsprechend des ersten Artikels¹ lauffähig installiert sein. (Weitere Artikel der Serie sind in den Fußnoten verlinkt.³)

Ausgangssituation

Die Android “userdata”-Partition belegt standardmäßig den Großteil des Speicherplatzes. Beim SHIFT6mq sind das rund 107 GB welche postmarketOS vorenthalten bleiben.

Um das zu ändern, soll der Bereich verkleinert und Platz für eine Linux-kompatible Partition geschaffen werden.

Warnung: Etwaige bestehende Dateien gehen dabei verloren oder werden beschädigt.

Android-Benutzerpartition verkleinern

(Modus: postmarketOS)

Der Speicherplatz kann grundsätzlich frei auf die beiden Betriebssysteme verteilt werden. Möchte man Android nur im Notfall nutzen, sollten 2 GB für eigene Dateien ausreichen.

# Diese Konstante setzen
NEWSIZE_IN_GB=2

Unter Berücksichtigung der gewünschten neuen Größe ermitteln die folgenden Befehle die neue Konfiguration und ändern die bestehende Partition entsprechend ab.

# Vorgehen absichern
set -u

# "userdata"-Partition finden
userdata_entry=`echo print | doas parted /dev/sda | grep -w ' userdata$'`
userdata_number=`echo $userdata_entry | awk '{ print $1 }'`

# Anfangs- und neuen Endpunkt der Partition bestimmen
partition_start=`echo $userdata_entry | awk '{ print $2 }' | cut -dG -f1`
partition_end=`echo $partition_start + $NEWSIZE_IN_GB | bc`

printf '\n%s\n\nPartition %s wurde als userdata erkannt.\n' \
       "$userdata_entry" "$userdata_number"
printf '\nSie wird auf auf den Bereich %sGB - %sGB konfiguriert.\n' \
       "$partition_start" "$partition_end"

# Neue Größe setzen
doas parted /dev/sda resizepart $userdata_number ${partition_end}GB

An diesem Punkt sollte doas fdisk -l /dev/sda bereits die neue Größe für die Partition anzeigen.

Die Anleitung geht davon aus, dass man erst in einem späteren Schritt ein neues Android installiert. Möchte man ein bestehendes weiter nutzen, muss im Recovery-Modus ein Factory-Reset durchgeführt werden, damit es diese Änderung erkennt.

Zusätzliche Partition erstellen

(Modus: postmarketOS)

Unmittelbar auf die nun verkleinerte “userdata”-Partition soll die neue Partition für postmarketOS folgen.

Diese Schritte beziehen sich auf zuvor gesetzte Variablen. Es muss daher die bisher genutzte Kommandozeile weiter verwendet werden.

# Vorgehen absichern
set -u

# Anfangs- und neuen Endpunkt der Partition bestimmen
next_number=$((userdata_number + 1))
next_partition_start="$partition_end"
disk_end=`printf 'unit GB\nprint' | doas parted /dev/sda | sed -n "/^Disk/ s|^Disk .*: \(.*\)GB|\1|p"`

doas parted /dev/sda mkpart sda${next_number} ext4 ${next_partition_start}GB ${disk_end}GB

Dateisystem einrichten

Dem Ansatz “Grundsätzlich-Sicher” getreu, wird das Dateisystem mit Verschlüsselung konfiguriert:

# Vorgehen absichern
set -u

# Namen und Pfade bestimmen
disk=/dev/sda${next_number}
name=${disk##*/}
keyfile=/root/${name}.lukskey

# Verschlüsseltes Dateisystem erstellen
doas dd if=/dev/urandom of="$keyfile" bs=1024 count=2 && doas chmod 400 "$keyfile" 
doas cryptsetup luksFormat "$disk" "$keyfile"
doas cryptsetup luksOpen "$disk" "$name" --key-file="$keyfile"
doas mkfs.ext4 -m 2 "/dev/mapper/$name"

Dateisystem bei Systemstart automatisch einhängen

In postmarketOS bestimmt dmcrypt welche Geräte beim Systemstart entschlüsselt werden⁶.

printf "\n\ntarget=%s\nsource='%s'\nkey='%s'\n\n" "$name" "$disk" "$keyfile" | \
     doas tee -a /etc/conf.d/dmcrypt
echo "/dev/mapper/$name  /media/floppy   ext4 nofail,defaults      0 0" | \
     doas tee -a /etc/fstab
doas rc-update add dmcrypt boot

# Dateisystem sofort einhängen
doas mount /media/floppy

Gratulation! Ab hier kann die neue Partition unter /media/floppy genutzt werden.
(“floppy” bietet sich als Einhängepunkt an, da er in Alpine-Systemen bereits besteht und wohl nie anderwärtig gebraucht werden wird.)

[optional] Alternative Entschlüsselung ermöglichen

Der bisherige Ablauf hinterlegt einen Zufallsschlüssel (in /root/).
Geht dieser verloren, werden sämtliche Daten unbrauchbar.

Mit folgendem Kommando kann man zusätzlich ein Passwort setzen, das unabhängig vom generierten Schlüssel Zugriff zu den Daten ermöglicht:

doas cryptsetup luksAddKey $disk --key-file $keyfile

¹ Artikel 1 der Serie: postmarketOS auf SHIFT6mq Smartphone installieren

² Artikel 2 (dieser)

³ Artikel 3 der Serie: Bootloader-Firmware des SHIFT6mq Smartphones aktualisieren

⁴ Artikel 4 der Serie: Android auf SHIFT6mq parallel zu postmarketOS installieren

⁶ wiki.alpinelinux.org/wiki/LVM_on_LUKS
Alpine-Wiki: “Mounting additional encrypted filesystems at boot”

postmarketOS auf SHIFT6mq Smartphone installieren

2023-12-05T00:00:00+01:00

Dies ist Artikel 1 zur Einrichtung eines SHIFT6mq mit postmarketOS. Weitere Artikel der Serie sind in den Fußnoten verlinkt.² ³

Das SHIFT6mq ist zum Zeitpunkt des Verfassens dieser Anleitung eines der leistungsfähigsten für postmarketOS geeigneten Mobiltelefone.

Zwar fehlt einerseits noch die Unterstützung⁶ für diverse Hardwarekomponenten wie Kamera oder GPS, andererseits schafft man sich mit einem echten Linux-Telefon maximale Flexibilität – die Grundlage für hocheffiziente Abläufe.

Ziele: Privatsphäre und Multi-Boot

Bei dieser Anleitung ist darauf geachtet, dass das Telefon niemals mit dem Internet zu verbinden, bevor es von potentiell verräterischer Software befreit ist.

Damit soll vermieden werden, dass etwaige Gegenstellen das Telefon mit dem initialen Standort und somit einem bestimmten Personenkreis verknüpfen (beispielsweise durch Verknüpfen der IMEI⁷ mit der IP).

Installiert wird in eine der beiden “Superpartitionen”, sodass in der anderen ein anderes Betriebssystem wie zum Beispiel ein AOSP-Android⁸ den benötigten Platz finden kann.

Warnung: Das bestehende System wird restlos entfernt und die Benutzerdaten gehen verloren.

Warnung: Android OTA-Updates benötigen einen ungenutzten Slot zur Installation neuer Versionen.⁹ Da postmarketOS diesen belegen wird, können Updates dann nur noch manuell (per PC/USB) durchgeführt werden. Details werden in einem Folgeartikel erläutert.⁴

Voraussetzungen

Ausgegangen wird von einem SHIFT6mq in Werkszustand, mit vorinstalliertem und funktionstüchtigem Android (“ShiftOS”).
Das Telefon muss per USB mit dem Linux-PC verbunden sein.
Am PC müssen pmbootstrap, fastboot sowie 7zip vorhanden sein. Unter Void Linux werden sie beispielsweise via xbps-install -Su pmbootstrap android-tools 7zip installiert.

Wo relevant ist am Beginn jedes Abschnitts erwähnt in welchem Modus sich das Telefon befinden muss. Dies dient lediglich der Orientierung, da es bei Befolgen der Anweisungen ohnehin zu jedem Zeitpunkt im jeweils korrekten Zustand ist.

postmarketOS für SHIFT6mq konfigurieren

(PC)

Zuerst erstellt man am Linux-Rechner ein postmarketOS Installationsabbild:

Umgebung aktualisieren

Dieser Schritt stellt sicher, dass man mit einer aktuellen Umgebung arbeitet.

pmbootstrap pull
pmbootstrap status

Konfiguration des Abbilds definieren

Im diesem Schritt muss als Vendor shift und ls Device codename axolotl eingestellt werden.

pmbootstrap init

Hackern sei sxmo-de-sway als User interface empfohlen. Diese, sowie die übrigen Optionen können den eigenen Bedürfnissen angepasst oder auf den vorgegebenen Einstellungen belassen werden.

Um Probleme beim Erstellen des Abbildes zu vermeiden, sei von der Angabe von Extra packages abgeraten. Zusätzliche Pakete sollten besser später im laufenden System hinzugefügt werden.

Abbild für verschlüsseltes System generieren

Jedes System sollte grundsätzlich verschlüsselt erstellt werden. Damit erspart man sich spätestens bei Weitergabe des Geräts Kopfzerbrechen über etwaige verbliebene Daten.

pmbootstrap install --fde
pmbootstrap shutdown

Per shutdown löst man vorübergehende Mounts der pmbootstrap-Umgebung.

Bootloader entsperren

(Modus: Android)

Im vorinstallierten Android System “ShiftOS” erlaubt man das Entsperren des Bootloaders:

Entwicker-Modus aktivieren
Einstellungen > Über das Telefon > “Build-Nummer” sieben mal berühren
Erlaubnis zum Entsperren des Bootloaders erteilen
Einstellungen > System > Erweitert > Entwickleroptionen > “Erweiterter Neustart” sowie “OEM-Entsperrung” aktivieren
Bootloader starten
Den Ausschaltknopf lange drücken und “Neu starten” > Bootloader wählen
Entsperrung durchführen
Vom PC aus den Unlock-Befehl an das Telefon senden:
fastboot flashing unlock

postmarketOS aufspielen

Ist aus dem vorigen Schritt noch der Bootloader-Modus aktiv, wechselt man nun in den Fastboot-Modus:

Es sollte ausreichen, am PC den Befehl fastboot reboot fastboot zu geben.
Alternativ hält man beim Einschalten des Telefons (via Power) gleichzeitig “Lauter” (also VolUp) gedrückt.
Bei neueren Bootloader-Versionen kann man den entsprechenden Menüpunkt zum direkten Wechsel zu Fastboot nutzen.

Installationsslot auswählen

(Modus: Fastboot)

Es stehen zwei Slots zur Verfügung. PostmarketOS wird in Slot A installiert. Ein neues Android kann später in Slot B geladen werden. Wie eingangs erwähnt, geht das bestehende Android-System im nächsten Schritt allerdings verloren!

fastboot --set-active=a
fastboot reboot fastboot
fastboot getvar current-slot 2>&1 | \
        grep 'current-slot: a$' || \
        echo 'Fehler: Falscher Slot aktiv!' >&2

Boot- und System-Partition des Telefons bespielen

(Modus: Fastboot)

# Vorgang dauert rund 76 Sekunden
pmbootstrap flasher flash_rootfs --partition system_a
# Vorgang dauert rund 31 Sekunden
pmbootstrap flasher flash_kernel --partition boot_a
fastboot reboot bootloader
# Vorgang dauert rund 26 Sekunden
fastboot erase dtbo_a
fastboot reboot fastboot

Laut Wiki¹ “steht die dtbo-Partition mit dem Mainline-Kernel in Konflikt” und wird daher hier gelöscht.

Gesamten Slot A für postmarketOS nutzbar machen

(Modus: Fastboot)

Einige Partitionen innerhalb eines Slots werden lediglich von Android-Systemen genutzt und sind für Linux-Systeme irrelevant.

Indem man sie löscht, kann der dadurch freigegebene Speicherplatz für die postmarketOS root-Partition von zirka 2 GiB (2128609280 bytes) auf rund 4.5 GiB (4813467648 bytes) erweitern.

Die folgenden Befehle könnten auf einem technisch abweichenden System unerwartete Auswirkungen haben und sollten daher erst ausgeführt werden, wenn man die einzelnen Schritte versteht. Da diese Änderungen von anderen unabhängig sind, können sie auch jederzeit nachträglich vorgenommen werden.

# Zurück in den Fastboot-Modus wechseln
fastboot reboot fastboot

# Gesamt-verfügbare Größe ermitteln
slot='a'
filter=":product_$slot:|:system_$slot:|:vendor_$slot:|:system_ext_$slot:"
matches=`fastboot getvar all 2>&1 | grep -E "$filter"`
sizes_hex=`echo "$matches" | sed -n '/partition-size/ s#.*partition-size.*:0x##p' | tr '\n' '+'`
sum_decimal=`echo "ibase=16; ${sizes_hex} 0" | bc`

printf 'Relevante Partitionen:\n\n%s\n\n' "$matches"
printf 'Die Root-Partiton wird auf %s Bytes erweitert.\n' "$sum_decimal"

# Unnötige Partitionen löschen
for p in product vendor system_ext ; do fastboot delete-logical-partition "${p}_${slot}" ; done
fastboot resize-logical-partition system_${slot} $sum_decimal

# Neue Größe ausgeben und postmarketOS starten
fastboot getvar all 2>&1 | grep " partition-size:system_${slot}:"
fastboot reboot

Dateisystem auf neue Größe ausweiten

(Modus: postmarketOS)

Abschließend muss per SSH oder in einem Terminalfenster direkt in postmarketOS das Dateisystem auf die Nutzung der neuen Partitionsgröße eingestellt werden:

df -h /dev/mapper/root
doas resize2fs /dev/mapper/root
df -h /dev/mapper/root

Gratulation! An dieser Stelle hat man ein funktionstüchtiges Linux-Telefon das man nach Belieben weiter gestalten kann.

Ausblick

Weitere Artikel zum Thema werden unter Anderem erläutern, wie man über die Benutzer-Partition noch mehr Platz für postmarketOS bereit stellt⁴, ein freies Android parallel zu postmarketOS installiert (“Dualboot”) oder Android-Applikationen direkt in postmarketOS ausführt.

Smartphones können Zeitfresser sein. Eine Hoffnung die ich in postmarketOS setze ist, dass es langfristig auch im mobilen Bereich eine minimalistische Nutzung ermöglicht und somit dazu beiträgt Smartphones in den Hintergrund zu bringen. Menschen sind wichtiger als Maschinen.

An dieser Stelle vielen Dank an Alex von Shift für die klaren Hinweise, welche die optimale Konfiguration des SHIFT6mq für diesen Artikel deutlich vereinfacht haben!

¹ Artikel 1 (dieser)

² Artikel 2 der Serie: Platz aus Android-Benutzerpartition für postmarketOS freigeben

³ Artikel 3 der Serie: Bootloader-Firmware des SHIFT6mq Smartphones aktualisieren

⁴ Artikel 4 der Serie: Android auf SHIFT6mq parallel zu postmarketOS installieren

⁶ SHIFT6mq im postmarketOS-Wiki

⁷ RFC-7254: IMEI

⁸ Android Open Source Project

⁹ AOSP: A/B (seamless) system updates

Bildschirmausgabe einer libvirt/QEMU-Instanz als Video aufnehmen

2023-10-08T00:00:00+02:00

Von einer KVM/QEMU Virtuellen Maschine kann zu beliebigem Zeitpunkt eine Bilddatei des aktuellen Bildschirminhalts angefordert werden.

Diese Anleitung erklärt wie man via libvirt/virsh diese Bilder in regelmäßigen Abständen speichert und diese dann zu einem Video kombiniert.

Am System müssen bc, convert sowie bc vorhanden sein. Unter Void Linux installiert man die entsprechenden Pakete beispielsweise via xbps-install -Su ImageMagick ffmpeg bc.

Umgebung definieren

Diese Konstanten müssen im Verlauf der gesamten Anleitung korrekt gesetzt sein.

VM=name_der_virtuellen_maschine
BILDER_PRO_SEKUNDE=5

Bildschirmfotos regelmäßig abspeichern

DIR=`mktemp --tmpdir --directory $VM-screenrecording-XXX`
IMG=`mktemp --tmpdir $VM-current-XXX.ppm`
VERZOEGERUNG=`echo "scale=2 ; 1/$BILDER_PRO_SEKUNDE"  | bc`

echo 'Aufnahme ...'
echo '(Strg-C zum Beenden)'
while :; do
        virsh qemu-monitor-command $VM --hmp screendump "$IMG" >/dev/null
        if [ -s $IMG ] ; then
                convert "$IMG" "$DIR/`date +%s.%N`.jpg" && rm "$IMG"
                sleep $VERZOEGERUNG
        else
                echo "Fehler: $IMG ist leer" >&2
        fi
done

Bilder in eine Videodatei zusammenführen

ffmpeg -v error -pattern_type glob -codec copy \
        -framerate $BILDER_PRO_SEKUNDE \
        -i "$DIR/*.jpg" "$DIR/$VM.mkv" 
        && rm -R "$DIR/"*.jpg && echo "$DIR/$VM.mkv"

Tor-Dienst auf autorisierte Clients begrenzen

2023-10-02T00:00:00+02:00

Dienste die man im Tor-Netzwerk bereit stellt, können bei Bedarf ausschließlich autorisierten Gegenstellen verfügbar gemacht werden.

Alle Befehle dieser Anleitung werden am Client-Rechner ausgeführt. Einerseits vereinfacht dies die Erläuterungen, andererseits wird vermieden den privaten Schlüssel an weiteren Orten zwischen zu speichern.

Voraussetzungen

Es wird davon ausgegangen, dass SSH-Zugriffe zum Server als root möglich sind.
Der versteckte Dienst muss bereits am Server eingerichtet und aktiv sein (siehe HiddenServiceDir in /etc/tor/torrc).
Am Client muss PyNaCl vorhanden sein. Unter Void Linux wird es beispielsweise via xbps-install -Su python3-pynacl installiert.
Am Client muss der Befehl openbsd-nc vorhanden sein. Unter Void Linux installiert man das entsprechende Paket beispielsweise via xbps-install -Su openbsd-netcat.

Umgebung definieren

Diese Konstanten müssen im Verlauf der gesamten Anleitung korrekt gesetzt sein.

# Diese Konstanten entsprechend der eigenen Umgebung deklarieren
SERVER=203.0.113.2
TOR_SERVICE_PATH=/var/lib/tor/hidden_service
NETCAT_CMD="openbsd-nc -X 5 -x 127.0.0.1:9050 %h %p"

# Die Werte dieser Konstanten werden vom Server geholt
SERVERNAME=`ssh root@${SERVER} hostname`
ONION=`ssh root@${SERVER} cat ${TOR_SERVICE_PATH}/hostname`

Schlüsselpaar generieren

Zum Generieren des Schlüsselpaars wird ein einfaches Python-Skript verwendet, dessen Inhalt zumindest auf verdächtige Auffälligkeiten geprüft werden sollte.

# Skript laden
curl -O https://raw.githubusercontent.com/pastly/python-snippits/7ea7cb7fd3fea47dcf723edec2e52775aee43b0a/src/tor/x25519-gen.py

# Inhalt des Skripts zur Überprüfung ausgeben
cat x25519-gen.py

# Schlüssel generieren und einlesen
TMP=`mktemp --tmpdir keypair-XXX`
python ./x25519-gen.py | sed 's#\: *#=#g' > "$TMP"
. "$TMP" && rm -f "$TMP"

# Schlüssel prüfen
echo "$public"  | grep -E '.{52}' >/dev/null ||
    echo "Öffentlicher Schlüssel '$public' ungültig!" >&2
echo "$private" | grep -E '.{52}' >/dev/null ||
    echo "Privater Schlüssel '$private' ungültig!" >&2

Öffentlichen Schlüssel zu Server kopieren

echo "descriptor:x25519:$public" |
    ssh root@${SERVER} tee "$TOR_SERVICE_PATH/authorized_clients/$HOST.auth"

Privaten Schlüssel am Client hinterlegen

CAUTH_PATH=/var/lib/tor/onion_auth
sudo mkdir -p "$CAUTH_PATH"
echo "${ONION%%.onion}:descriptor:x25519:$private" |
    sudo tee "$CAUTH_PATH"/$SERVERNAME.auth_private

echo "ClientOnionAuthDir $CAUTH_PATH" |
    sudo tee /etc/tor/torrc

Vorgenommene Änderungen in Tor übernehmen

Wichtig: Man sollte eine neue Konfiguration sehr vorsichtig übernehmen. Schränkt man hier beispielsweise den Zugang zu SSH-über-Tor ein, sollte sicher gestellt sein, dass auch von Tor unabhängig eine SSH-Verbindung aufgebaut werden kann.

Test vor dem Einschränken

Da vor dem Neustart der Dienste die Client Authorization noch inaktiv ist, muss die Verbindung an dieser Stelle noch möglich sein.

ssh -o ProxyCommand="$NETCAT_CMD" root@${ONION} &&
    echo 'OK: Verbindung ist wie erwartet noch möglich!'

Server-Konfiguration neu laden

Der Befehl hierzu hängt von der verwendeten Diensteverwaltung ab.

# Beispiel: Server mit Alpine Linux / OpenRC
ssh root@${SERVER} service tor reload

Test nach dem Einschränken

Da der Server nun bereits auf autorisierte Gegenstellen begrenzt ist, muss an dieser Stelle jeder Verbindungsversuch scheitern:

ssh -o ProxyCommand="$NETCAT_CMD" root@${ONION} ||
    echo 'OK: Verbindungsaufbau ist wie erwartet fehlgeschlagen!'

Client-Konfiguration neu laden

Der Befehl hierzu hängt von der verwendeten Diensteverwaltung ab.

# Beispiel: Client mit Void Linux / Runit
sudo sv reload tor

Test nach Aktivieren des Client-Schlüssels

Da sich der Client dem Server gegenüber nun ordnungsgemäß authentifiziert, muss an dieser Stelle die Verbindung wieder möglich sein:

ssh -o ProxyCommand="$NETCAT_CMD" root@${ONION} &&
    echo 'OK: Verbindung ist wie erwartet wieder möglich!'

Quellen

Tor Project: Client Authorization

Debian LXC-Container in Void Linux einrichten

2023-09-25T00:00:00+02:00

Lediglich der erste Punkt, die Installation der Pakete, ist Void-Linux-spezifisch. Der weitere Ablauf sollte auch ohne Anpassungen auf andere Linux-Distributionen übertragbar sein.

Erforderliche Pakete installieren

lxc sowie debootstrap können in Void Linux wie folgt installiert werden:

xbps-install -Su lxc debootstrap

Umgebung definieren

Diese Variablen müssen in jedem Schritt des folgenden Ablaufs gesetzt sein:

# Diese Konstanten anpassen
NAME=sid
MIRROR=http://ftp.cz.debian.org/debian/
CHROOT=/var/lib/lxc/$NAME/rootfs

Root-Dateisystem erstellen

mkdir -p "$CHROOT"
debootstrap --arch amd64 "$NAME" "$CHROOT" "$MIRROR"

Hostname setzen und und fstab initialisieren

echo "$NAME" > "$CHROOT/etc/hostname"
echo 'tmpfs /tmp tmpfs defaults,nosuid,nodev 0 0' > "$CHROOT/etc/fstab"

LXC-Konfiguration schreiben

cat >> "$CHROOT/../config" << EOF
    lxc.uts.name = $NAME
    lxc.rootfs.path = dir:/var/lib/lxc/$NAME/rootfs
    lxc.start.auto = 1

    # "Secure" mounting
    lxc.mount.auto = proc:mixed sys:ro cgroup:mixed

    # Make container unpriviledged
    # (may not be desired if it's services will require full system-access)
    lxc.idmap = u 0 1000000 65536
    lxc.idmap = g 0 1000000 65536
EOF

[optional] Netzwerkkonfiguration ergänzen

Dieser Abschnitt dient als Beispiel und muss den eigenen Anforderungen entsprechend angepasst werden.

cat >> "$CHROOT/../config" << EOF
    # x's will be replaced by random values
    lxc.net.0.hwaddr = xx:xx:xx:xx:xx:xx
    lxc.net.0.type = veth
    lxc.net.0.flags = up
    lxc.net.0.link = br0
    lxc.net.0.ipv4.address = 192.168.1.111/24
    lxc.net.0.ipv4.gateway = 192.168.1.1
EOF

Container starten und betreten

lxc-start "$NAME"
lxc-attach "$NAME" -- /bin/bash

Ab hier kann nun mit dem Debian-System wie gewohnt gearbeitet werden.

FreeBSD-Jails auf neue Version aktualisieren

2023-07-03T00:00:00+02:00

FreeBSD-Jails können mittlerweile nicht nur sehr einfach auf ein aktuelles Patchlevel gebracht, sondern auch auf neue Major-Versionen aktualisiert werden.

Damit der Erfolg der einzelnen Vorgänge nicht von der Stabilität der SSH-Verbindung abhängt, sollten die folgenden Befehle in screen (oder tmux) ausgeführt werden.

Umgebung definieren

Sämtliche Befehle werden im Hostsystem gegeben. Die meisten verwenden die Variable JAILNAME, welche daher entsprechend gesetzt sein muss:

JAILNAME=

Dienste finden und stoppen

Kritische Dienste der Jail sollten deaktiviert werden.

Eine Auflistung erhält man via “iocage exec $JAILNAME service -e”. Einzelne Dienste kann man dann mittels “iocage exec $JAILNAME service $SERVICE stop” beenden.

Jail aktualisieren

Der update-Befehl bringt die Jail auf das aktuelle Patchlevel.

Das darauf folgende upgrade aktualisiert die Jail auf ein neues Release. Es weist auf Änderungen hin und fordert den Nutzer zu deren Prüfung und Bestätigung auf.

# Diese Variable auf die gewünschte Version setzen
RELEASE=13.2

iocage update $JAILNAME
iocage upgrade -r $RELEASE $JAILNAME

Pakete innerhalb der Jail aktualisieren

Bei größeren Versionsschritten kann “pkg bootstrap” erforderlich werden, dessen Ausführung generell unproblematisch sein sollte.

iocage exec $JAILNAME pkg bootstrap -f
iocage update $JAILNAME --pkgs

Jail neu starten

iocage restart $JAILNAME

Quellen

How to Update & Upgrade True/FreeNas Jails

Nachträglich Pakete in resflash-OpenBSD hinzufügen

2023-04-12T00:00:00+02:00

System in “Rohzustand” versetzen

Paket suchen (pkg_info -Q <name>)
Prozesse finden die Mountpunkte belegen
for dir in /etc /var ; do find $dir -exec sh -c ' fuser $0 ' {} \; 2>&1 | sed -n 's#$.*: ..*$#\1#p' ; done
Gefundene Prozesse beenden – Beispiel:
rcctl ls started | grep -v sshd | xargs rcctl stop
/etc und /var aushängen
umount /etc /var (evtl mit -f)
Root-Pfad temporär schreibbar machen
mount -o rw /

Nachträglich Pakete installieren

Anstatt hier die installurl-Datei zu schreiben, kann auch PKG_PATH gesetzt werden. Allerdings ist dann die Syntax eine andere.

Benötigt man Software für eine ältere OpenBSD-Version, wird man vielleicht auf einem Spiegelserver in der Liste auf https://www.openbsd.org/ftp.html fündig.

Beispielsweise stellte https://ftp.halifax.rwth-aachen.de/pub/OpenBSD noch am 16.11.2022 Pakete für OpenBSD 6.9 bereit. http://mirror.junda.nl/pub/OpenBSD/ hielt noch am 30.05.2024 Pakete für Version 7.2 bereit.

Mirror als Installationsquelle angeben
echo https://cdn.openbsd.org/pub/OpenBSD > /etc/installurl
Nameserver setzen
echo nameserver 9.9.9.9 > /etc/resolv.conf
Neues Paket hinzufügen
pkg_add vim--no_x11
[optional] Alle bereits installierten Paketen aktualisieren
pkg_add -u
Ursprünglichen Konfigurationszustand wiederherstellen
rm /etc/installurl /etc/resolv.conf

Wichtig: Fügt pkg_add einen neuen Benutzer hinzu, muss auch /cfg/etc/master.passwd entsprechend aktualisiert werden.
Gleiches gilt für /cfg/etc/passwd, fern diese existiert:

mount /cfg
for f in master.passwd passwd ; do
        sdiff /cfg/etc/$f /etc/$f -o /tmp/$f 
        cat /tmp/$f > /cfg/etc/$f 
done
umount /cfg

System neu starten

Um resflash-konformen Betrieb wieder aufzunehmen:

reboot

OpenBSD i386 in libvirt QEMU/KVM lauffähig installieren

2023-04-11T00:00:00+02:00

I/O der i386-Architekturvariante von OpenBSD ist in QEMU/KVM derart langsam, dass es quasi unmöglich ist, das System zu benutzen.

In diesem Artikel wird das Problem durch Deaktivieren der Kernel-Funktionen mpbios sowie acpimadt umgangen.¹

Die Anleitung kann auch als Referenz für Installationen der x86_64-Variante genutzt werden. In diesem Fall kann – und sollte – auf den Workaround verzichtet werden. Das System funktioniert ohne ihn einwandfrei.

Umgebung definieren

Diese Variablen müssen in jedem Schritt des folgenden Ablaufs gesetzt sein:

VERSION=7.3
#ARCH=amd64
ARCH=i386
CDROM_PATH=/var/lib/libvirt/images/pool
v=$(echo $VERSION | tr -d .)

OpenBSD herunterladen

Geladen wird das installXX.iso Image der gewünschent Architektur.²

set -u

mkdir -p $CDROM_PATH
wget -O $CDROM_PATH/openbsd-install${v}-${ARCH}.iso \
        https://cdn.openbsd.org/pub/OpenBSD/${VERSION}/${ARCH}/install${v}.iso

Virtuelle Maschine erstellen

Hier wird virt-install anstatt der grafischen Oberfläche virt-manager verwendet um die virtuelle Maschine mit nur einem Befehl zu erstellen.

set -u

virt-install --noautoconsole \
        --install no_install=yes \
        --metadata title="openbsd - Resflash-Buildumgebung [$ARCH]" \
        --name openbsd-$ARCH \
        --os-variant=openbsd7.0 \
        --ram=2048 --vcpus=4 \
        --graphics spice,listen=0.0.0.0 \
        --disk format=raw,path=/var/lib/libvirt/images/openbsd-$ARCH.raw,size=10 \
        --cdrom $CDROM_PATH/openbsd-install${v}-${ARCH}.iso \
        --network bridge=br0

OpenBSD in auf serielle Konsole umschalten

Um auf die Nutzung der grafischen libvirt-Verwaltungsoberfläche virt-manager auch für diesen Schritt zu verzichten, könnte eine eigene OpenBSD-ISO Datei mit bereits aktivierter serieller Konsole erstellt werden³.

Einfacher ist es allerdings, die Eingabe von set tty com0 direkt als Tastensequenz an die boot> Aufforderung der VM zu senden um so das System auf die serielle Konsole umzuschalten:

Maschine auf serielle Konsole umschalten

set -u

s='0x1f\n'
e='0x12\n'
t='0x14\n'
SPACE='0x39\n'
c='0x2e\n'
o='0x18\n'
m='0x32\n'
ZERO='0x0b\n'
y='0x15\n'

( virsh reset openbsd-$ARCH && sleep 3s
printf "%b" "$s$e$t${SPACE}$t$t$y${SPACE}$c$o$m$ZERO" | while read keysym ; do virsh send-key openbsd-$ARCH --codeset xt $keysym ; sleep .1 ; done
virsh send-key openbsd-$ARCH KEY_ENTER )

Verbindung zu serieller Konsole herstellen

Nun kann per Kommandozeile mittels virsh eine Verbindung hergestellt werden:

set -u
virsh console openbsd-$ARCH

In dieser Konsole erhöht man die Baudrate der Verbindung:

stty com0 115200

Verwendet man eine andere Architektur als i386 kann das Standard-System bereits mittels Befehl bsd.rd gestartet werden

[Nur i386] Problematische Kernel-Funktionen vorübergehend deaktivieren

Innerhalb der selben Konsole schaltet man nun die entsprechenden Funktionen für den aktuellen Bootvorgang ab:

boot -c
disable mpbios
disable acpimadt
quit

OpenBSD installieren

Direkt nachdem man an dieser Stelle die Installation von OpenBSD entsprechend der eigenen Anforderungen konfiguriert und installiert hat (Befehl (I)nstall), wechselt man zurück in die Kommandozeile (Befehl (S)hell) um anstelle eines direkten Neustarts mit den weiteren Schritten dieser Anleitung fortzufahren.

[Nur i386] Problematische Kernel-Funktionen dauerhaft deaktivieren

Nach wie vor innerhalb der OpenBSD Konsole schaltet man nun die entsprechenden Funktionen im Kernel dauerhaft ab:

echo 'disable mpbios\ndisable acpimadt' >> /mnt/etc/bsd.re-config
chroot /mnt sh -c 'cat /etc/bsd.re-config | config -e -o /bsd.new -c /dev/stdin /bsd'
mv /mnt/bsd /mnt/bsd.old && mv /mnt/bsd.new /mnt/bsd

Manpages: config, bsd.re-config

Virtuelle CD-ROM auswerfen und VM neu starten

Letztendlich wirft man über das Hostsystem die virtuelle CD-ROM aus und startet das neu installierte OpenBSD-System:

set -u
mediapath=$(virsh domblklist openbsd-$ARCH | grep -F "$CDROM_PATH" | awk '{ print $1 }')
virsh change-media openbsd-$ARCH $CDROM_PATH/openbsd-install${v}-${ARCH}.iso $mediapath --eject
virsh reboot openbsd-$ARCH

¹ https://misc.openbsd.narkive.com/lr1CB95G/very-slow-i-o-under-openbsd-i386-on-qemu-kvm-from-rhel7rc

² https://www.openbsd.org/faq/faq4.html#Download

³ http://www.weirdnet.nl/openbsd/serial/

Vorinstalliertes System durch Alpine Linux ersetzen

2023-03-21T00:00:00+01:00

Nur wenige Anbieter bieten virtuelle private Server (VPS) mit Alpine Linux an. Oft ist allerdings ein “Rettungsmodus” verfügbar, der grundlegende Änderungen am System ermöglicht.

Diese Anleitung beschreibt wie man diesen Rettungsmodus nutzt um ein vorinstalliertes Betriebssystem komplett durch ein “diskless” Alpine Linux zu ersetzen.

Obgleich sie auf die Änderungen in einem VPS optimiert ist, kann die gleiche Vorgehensweise bei Bedarf auch für lokale Installationen genutzt werden.

Rettungsmodus aktivieren

Der Rettungsmodus wird für gewöhnlich über die Web-Verwaltungsoberfläche des Hosting-Anbieters aktiviert.

Sobald sich das System in diesem Modus befindet, kann man mit folgenden Schritten fortfahren.

Im Rettungssystem: Alpine Linux herunterladen

Das ISO-Abbild dient als Vorlage für die bootbare Partition die eingerichtet werden soll.
Das minirootfs-Archiv stellt eine Alpine Linux chroot-Umgebung mit dem notwendigen Werkzeug `setup-bootable`¹ bereit.
Die headless.apkovl passt die Konfiguration so an, dass bereits beim ersten Start Fernzugriff per SSH möglich wird.

wget --no-check-certificate \
        https://dl-cdn.alpinelinux.org/alpine/v3.17/releases/x86_64/alpine-minirootfs-3.17.2-x86_64.tar.gz \
        https://dl-cdn.alpinelinux.org/alpine/v3.17/releases/x86_64/alpine-virt-3.17.2-x86_64.iso \
        https://github.com/macmpi/alpine-linux-headless-bootstrap/raw/main/headless.apkovl.tar.gz

Im Rettungssystem: Partitionen vorbereiten

Achtung: Ab hier werden die bisherigen Inhalte des angegebenen Geräts zerstört.

Es ist auch zu berücksichtigen, dass sich im Rettungssystem der Gerätename der Festplatte oft von dem im Normalbetrieb unterscheidet.

# Diese drei Konstanten anpassen
BLOCK_DEVICE=/dev/vdb
PARTITION1_MB=500
PARTITION2=${BLOCK_DEVICE}2

start=2048
sector_size=512
part1_sectors=$(($PARTITION1_MB *1024*1024/ $sector_size))

echo "label: dos
sector-size: $sector_size
start=$start, size=$part1_sectors, type=b, bootable
start=$(($start + $part1_sectors)), type=83
" | sfdisk $BLOCK_DEVICE

# Dateisystem der zweiten Partition initialisieren
mkfs.ext4 $PARTITION2

Im Rettungssystem: Temporäres Alpine Linux einrichten

# Diese Konstante anpassen
PARTITION1=${BLOCK_DEVICE}1

mkdir /alpine
tar xzvf alpine-minirootfs-3.17.2-x86_64.tar.gz -C /alpine

for d in dev sys proc tmp ; do mount --rbind /$d /alpine/$d ; done

cp /etc/resolv.conf /alpine/etc/resolv.conf 
cp /etc/network/interfaces /alpine/etc/network/interfaces
cp alpine-virt-3.17.2-x86_64.iso /alpine/root/

chroot /alpine mkfs.vfat -vn ALPINE $PARTITION1
chroot /alpine apk update
chroot /alpine apk add alpine-conf

Im Rettungssystem: Alpine Linux auf Zielgerät installieren

# Diese Konstante anpassen
BLOCK_DEVICE=/dev/vdb

chroot /alpine setup-bootable -v /root/alpine-virt-3.17.2-x86_64.iso $PARTITION1

mount $PARTITION1 /mnt
cp headless.apkovl.tar.gz /mnt/

poweroff

Rettungsmodus deaktivieren

An dieser Stelle schaltet man System wieder zurück in den Normalbetrieb und startet das neu installierte Alpine Linux.

Alpine Linux System konfigurieren

# Diese Konstante anpassen
PARTITION2=vda2

# System nach Wunsch konfigurieren
setup-alpine

# Zweite Partition beim Start einhängen
mkdir /media/${PARTITION2}
printf "\n/dev/${PARTITION2}\t/media/${PARTITION2}\text4\trw\t0 0\n" >> /etc/fstab

# Public Key SSH-Rootzugang vorbereiten
mkdir /root/.ssh && touch /root/.ssh/authorized_keys
chmod -R go-rwx /root/.ssh
lbu include /root/.ssh/authorized_keys

Änderungen dauerhaft übernehmen

lbu commit -d

lbu commit muss immer ausgeführt werden, wenn Änderungen dauerhaft übernommen werden sollen. Es schreibt Konfigurationsanpassungen in /media/$PARTITION1/$HOST.apkovl.tar.gz.

Von dieser Datei werden sie dann beim nächsten Systemstart wiederhergestellt. Das Grundsystem bleibt unverändert.

¹ https://wiki.alpinelinux.org/wiki/Alpine_setup_scripts#setup-bootable

Alpine Linux für Raspberry Pi aufsetzen

2023-03-10T00:00:00+01:00

Diese Anleitung basiert auf dem Artikel im offiziellen Alpine Linux Wiki¹. Sie beschreibt die Einrichtung eines “diskless” Setup und wurde mit einem Raspberry Pi 2 Model B Rev 1.1 getestet.

Alpine Linux für Raspberry Pi herunterladen

Auf einem bereits mit Linux laufenden Raspberry Pi kann man mittels grep -i model /proc/cpuinfo | uniq feststellen, welches Modell man besitzt.

Dementsprechend wählt man im Alpine Linux Downloadbereich das zur Architektur passende Archiv.

SD-Karte vorbereiten

Für den Betrieb ist lediglich eine bootbare VFAT Partition notwendig. In diesem Beispiel wird diese relativ klein gehalten um den restlichen Platz für eine weitere Partition vom Typ F2FS zu nutzen.

SD-Karte partitionieren

Achtung: Ab hier werden die bisherigen Inhalte des angegebenen Geräts zerstört.

# Diese beiden Konstanten anpassen
SD_CARD=/dev/mmcblk0
PARTITION1_MB=500

start=2048
sector_size=512
part1_sectors=$(($PARTITION1_MB *1024*1024/ $sector_size))

echo "label: dos
sector-size: $sector_size
start=$start, size=$part1_sectors, type=c, bootable
start=$(($start + $part1_sectors)), type=83
" | sfdisk $SD_CARD

Partitionen formatieren

# Diese Konstante anpassen
BLOCK_PREFIX=/dev/mmcblk0p

mkfs.vfat ${BLOCK_PREFIX}1
mkfs.f2fs ${BLOCK_PREFIX}2

Alpine Linux aufspielen

# Diese beiden Konstanten anpassen
BLOCK_PREFIX=/dev/mmcblk0p
ALPINE_ARCHIVE=alpine-rpi-3.17.2-armv7.tar.gz

MNT=$(mktemp --directory)

mount ${BLOCK_PREFIX}1 $MNT
tar xzvf $ALPINE_ARCHIVE -C $MNT

# Optional: Audio via Klinkenstecker aktivieren
#echo dtparam=audio=on >> $MNT/usercfg.txt 

# Optional: Overscan deaktivieren
#           siehe https://askubuntu.com/a/1229856
#echo disable_overscan=1 >> $MNT/usercfg.txt 


umount ${BLOCK_PREFIX}1 && rmdir $MNT

Alpine Linux System konfigurieren

Mit eingesetzter SD-Karte kann der Raspberry Pi nun gestartet werden.

Die Konfiguration des Systems erfolgt entsprechend den Anforderungen des Benutzers. Um eine reibungslose Grundeinrichtung zu gewährleisten, sollten allerdings folgende Antworten wie hier gezeigt übernommen werden:

setup-alpine

No disks available. Try boot media /media/mmcblk0p1? (y/n) => n
Enter where to store configs => mmcblk0p1
Enter apk cache directory => /media/mmcblk0p1/cache

Optimierungen ergänzen

# Ältere Paketversionen erhalten
sed -i 's|# BACKUP_LIMIT=3|BACKUP_LIMIT=3|g' /etc/lbu/lbu.conf

# Zusätzliche Paketquellen aktivieren
sed -i 's|#http://\(.*\)/community|http://\1/community|g' /etc/apk/repositories
#sed -i 's|#http://\(.*\)/testing|http://\1/testing|g' /etc/apk/repositories

# Zweite Partition bei Systemstart einhängen
PART2='mmcblk0p2'
mkdir /media/${PART2}
echo "/dev/${PART2} /media/${PART2} f2fs noatime,ro 0 0" >> /etc/fstab

# Public Key SSH-Rootzugang vorbereiten
mkdir /root/.ssh && touch /root/.ssh/authorized_keys && chmod -R go-rwx /root/.ssh
lbu include /root/.ssh/authorized_keys

Vorhandene Pakete aktualisieren und optional zusätzliche installieren

apk update && apk upgrade
#apk add rsync

Änderungen dauerhaft übernehmen

lbu commit -d

lbu commit muss immer ausgeführt werden, wenn Änderungen dauerhaft übernommen werden sollen. Es schreibt Konfigurationsanpassungen in /media/mmcblk0p1/$HOST.apkovl.tar.gz.

Von dieser Datei werden sie dann beim nächsten Systemstart wiederhergestellt. Das Grundsystem bleibt unverändert.

System neu starten

Abschließend sollte die Funktionstüchtigkeit des Systems nach einem Neustart verifiziert werden:

reboot

Hinweis: Headless-Installation

Sollte kein Bildschirm oder keine Tastatur verfügbar sein, kann – entsprechendes Verständins vorausgesetzt – eine passende Overlay-Datei genutzt werden um bereits beim ersten Start Zugang über das Netzwerk (SSH) zu ermöglichen.

¹ https://wiki.alpinelinux.org/wiki/Raspberry_Pi

Void-Linux als X2Go-ThinClient/-Server Lösung konfigurieren

2022-04-10T00:00:00+02:00

Die Anleitung(1) zur Konfiguration einer Thin-Client Umgebung mittels X2Go ist unnötig komplex und kann mit Hilfe der richtigen Werkzeuge drastisch vereinfacht werden.

Hier sind die notwendigen Schritte erläutert um Void-Linux als Server zu nutzen. Dieser stellt alles Notwendige bereit um Clients über das Netzwerk zu booten und ihn dann so zu nutzen, als wäre der Benutzer am Server lokal eingeloggt:

Ein DHCP-Dienst weist dem Client eine IP Adresse zu und teilt ihm mit wo die Inhalte für den weiteren Bootvorgang zu finden sind.
Ein TFTP-Dienst stellt dem Client einen Bootloader zur Verfügung, welcher im weiteren Schritt Kernel und Init-Umgebung laden kann.
Ein HTTP-Dienst stellt dem Client letztendlich Kernel, Init-Umgebung und ein vollständiges Betriebssystem-Abbild zur Verfügung.
Zu der am Server installierten grafischen Oberfläche XFCE verbindet sich der Client am Ende des Startvorgangs via X2Go-Client.

In diesem Beispiel wird in einer bereits vorbereiteten Void-Linux Installation(2) die Netzwerk-Schnittstelle eth1 als 192.168.0.3/24 konfiguriert.

Am Server sollten dafür mindestens 10 GB Festplattenkapazität zur Verfügung stehen und Clients sollten über mindestens 1 GB RAM verfügen.

Server für X2Go-Verbindungen vorbereiten

Pakete installieren und X2Go-Server vorbereiten

xbps-install -Suy dhcp syslinux tftpd-hpa darkhttpd xfce4 x2goserver curl dracut-network binutils squashfs-tools
ln -s /etc/sv/x2gocleansessions /var/service/
x2godbadmin --createdb

# X2Go-Verbindung zu Desktopumgebung von Void-Clients ermöglichen
sed -i 's#/etc/redhat-release ]#/etc/redhat-release ] || [ -d /usr/share/void-artwork ]#g' /etc/x2go/Xsession

XFCE ohne Compositor starten

Mit aktivem Compositor ist XFCE in X2Go quasi unbrauchbar(3). Er kann aber einfach deaktiviert werden:

cat >> /usr/local/bin/xfce << EOF
#!/bin/sh
/usr/bin/xfconf-query -c xfwm4 -p /general/use_compositing -s false
/usr/bin/xfce4-session
EOF

chmod +x /usr/local/bin/xfce

Netzwerk-Schnittstelle konfigurieren

cat >> /etc/rc.local << EOF
ip addr add 192.168.0.3/24 brd 192.168.0.255 dev eth1
ip link set eth1 up alias "'Network for Thin-Clients'"
EOF

/etc/rc.local

Dienste einrichten

Die Dienste stellen die eingangs genannten Boot-Schritte zur Verfügung: DHCP > TFTP > HTTP.

DHCP

cat >> /etc/dhcpd.conf << EOF
authoritative;
subnet 192.168.0.0 netmask 255.255.255.0 {
    range 192.168.0.20 192.168.0.250;
    option domain-name "local";
    option domain-name-servers 192.168.0.3;
    option broadcast-address 192.168.0.255;
    option routers 192.168.0.3;
    option subnet-mask 255.255.255.0;
    option root-path "/";
    filename "lpxelinux.0";
}
EOF

cp -a /etc/sv/dhcpd4 /etc/sv/dhcpd4-eth1
sed -i 's#dhcpd4.pid}$#dhcpd4.pid} eth1#g' /etc/sv/dhcpd4-eth1/run
ln -s /etc/sv/dhcpd4-eth1 /var/service/dhcpd4-eth1

TFTP

# PXE Netzwerk-Bootloader anbieten
cp -a /usr/lib/syslinux/ldlinux.c32 /usr/lib/syslinux/lpxelinux.0 /var/lib/tftp/

mkdir /var/lib/tftp/pxelinux.cfg
cat >> /var/lib/tftp/pxelinux.cfg/default << EOF
DEFAULT x2go-tce

LABEL x2go-tce
TIMEOUT 50
MENU LABEL X2Go-TCE
KERNEL http://192.168.0.3/vmlinuz
INITRD http://192.168.0.3/initrd.img
APPEND root=live:http://192.168.0.3/void.squashfs ro rd.live.image
EOF

ln -s /etc/sv/tftpd-hpa /var/service/

HTTP

# Netzwerk-Bootfähiges System bereit stellen
cp /boot/vmlinuz-`uname -r` /srv/www/darkhttpd/vmlinuz
dracut --omit "bash drm btrfs crypt dmraid lvm kernel-modules kernel-modules-extra mdraid nvdimm qemu cifs lunmask nfs resume terminfo usrmount virtfs" --add "livenet" /srv/www/darkhttpd/initrd.img
chmod +r /srv/www/darkhttpd/initrd.img

ln -s /etc/sv/darkhttpd /var/service/

An dieser Stelle sind alle Dienste des Servers vollständig konfiguriert. Es fehlt lediglich das Betriebssystem-Abbild welches der HTTP-Dienst dem Client bereit stellt.

Das Erstellen des Abbilds ist in folgendem Abschnitt erläutert.

Betriebssystem-Abbild für den Thin-Client vorkonfigurieren

Über https://voidlinux.org/download/ kann das tar-Archiv eines Void-Grundsystems gefunden werden.

Grundsystem installieren

URL=https://alpha.de.repo.voidlinux.org/live/current/void-x86_64-musl-ROOTFS-20210930.tar.xz
cd ~
curl -o rootfs.tar.xz "$URL"
mkdir ~/thin && tar xvf rootfs.tar.xz -C ~/thin

mount --rbind /sys  ~/thin/sys  && mount --make-rslave ~/thin/sys
mount --rbind /dev  ~/thin/dev  && mount --make-rslave ~/thin/dev
mount --rbind /proc ~/thin/proc && mount --make-rslave ~/thin/proc

cp /etc/resolv.conf ~/thin/etc/
echo "client" > ~/thin/etc/hostname

chroot ~/thin/ /bin/xbps-install -Suy xbps
chroot ~/thin/ /bin/xbps-install -uy
chroot ~/thin/ /bin/xbps-install -y base-system xorg-video-drivers xorg-fonts xorg-input-drivers xorg-minimal x2goclient
chroot ~/thin/ /bin/xbps-remove -y base-voidstrap
rm -Rf ~/thin/var/cache/xbps

chroot ~/thin/ /bin/passwd

X2Go-Verbindung definieren

chroot ~/thin/ /bin/mkdir /root/.x2goclient/

cat >> ~/thin/root/.x2goclient/sessions << EOF
[server]
clipboard=none
command=xfce
fullscreen=true
host=192.168.0.3
name=srv
icon=/usr/share/void-artwork/void-logo.svg
user=
EOF

Schritte des Systemstarts automatisieren

# root automatisch einloggen
sed -i 's#GETTY_ARGS=.*#GETTY_ARGS="--autologin root --noclear"#g' ~/thin/etc/sv/agetty-tty1/conf

# X auf tty0 automatisch starten
echo '[ `fgconsole` -eq 1 ] && startx' > ~/thin/root/.profile

# X2Go-Client automatisch starten
echo 'exec x2goclient --thinclient --session=srv --add-to-known-hosts --no-menu --no-session-edit --branding=/dev/null' > ~/thin/root/.xinitrc

# Herunterfahren per Ausschaltknopf ermöglichen
chroot ~/thin/ /bin/ln -s /etc/sv/acpid /etc/runit/runsvdir/default/acpid

Betriebssystem-Abbild als SquashFS verpacken

Spezielle Dateisysteme aus chroot aushängen

umount --recursive ~/thin/sys ~/thin/dev ~/thin/proc

Betriebsystem-Abbild generieren und in HTTP-Server erstellen

mksquashfs ~/thin /srv/www/darkhttpd/void.squashfs

An dieser Stelle sollte ein Client über das Netzwerk via PXE booten können.

Im letzten Abschnitt sei noch erläutert, wie man prüft ob jeder der Dienste die notwendigen Dateien korrekt ausliefert.

Konfiguration überprüfen

Antowort des DHCP-Dienstes prüfen

dhcpcd -T eth1

Verfügbarkeit der Dateien des TFTP-Dienstes prüfen

cd `mktemp -d`
tftp 192.168.0.3 -c get pxelinux.cfg/default
tftp 192.168.0.3 -c get vmlinuz 
tftp 192.168.0.3 -c get initrd.img
stat default vmlinuz initrd.img

Verfügbarkeit der Dateien des HTTP-Dienstes prüfen

curl http://192.168.0.3/void.squashfs -o /dev/null

¹ X2Go-ThinClientEditon-Live Installation Guide

² Void-Handbook: Installation

³ X2Go Desktop Environment Compatibility

⁴ Void-Handbook: Installation via the ROOTFS Method

LineageOS auf Samsung Galaxy Tab3 Tablet installieren

2022-04-03T00:00:00+02:00

Diese Anleitung erläutert das Ersetzen des Original-Betriebsystem eines Samsung Galaxy Tab3 Tablet durch das inoffizielle “LineageOS” (Android 7.1).

Das bisherige Betriebsystem wird dabei zerstört. Daten die nicht verloren gehen dürfen, müssen vorab gesichert werden.

Vorbereitung

Heimdall dient zum Aufspielen der notwendigen Daten auf das Tablet. Falls nicht in den Linux-Paketquellen verfügbar, kann es von der offiziellen Website geladen und installiert werden.

“Recovery”-System installieren (Tablet in “Downloadmodus”)

Team Win Recovery Project 3.x herunterladen
Tablet Ausschalten und USB-Kabel entfernen
Tablet in Downloadmodus starten: VolumeDown und zusätzlich Power drücken und beide Knöpfe gedrückt halten bis ein Warnsymbol erscheint. Nun mit VolumeUp bestätigen.
Tablet per USB mit dem Linux-PC verbinden
TWRP vom PC aus auf das Tablet laden:
heimdall flash --RECOVERY twrp-3.0.2-0-santos103g.img --no-reboot
Bei Erfolg (“RECOVERY upload successful”) das Tablet ausschalten(1)

LineageOS ROM installieren (Tablet in “Recoverymodus”)

LineageOS herunterladen und auf eine SD-Karte kopieren
Tablet Ausschalten und USB-Kabel entfernen
SD-Karte mit LineageOS ZIP-Datei in Tablet einsetzen(2)
Tablet in Recoverymodus starten: VolumeUp und zusätzlich Power drücken und beide Knöpfe gedrückt halten bis das Samsung-Logo erscheint.
Bisheriges System löschen (!): Wipe > Swipe to Factory Reset
Zurück zum Hauptmenü navigieren
Neues ROM installieren: Install > Select Storage > Micro SDCard > OK
lineage-14.1-20210426-UNOFFICIAL-santos103g.zip > Swipe to confirm Flash
Bei Erfolg Tablet neu starten

Der erste Start von LineageOS dauert auf diesem Gerät ungefähr 2-3 Minuten.

Weitere Informationen: [ROM][GT-P52XX][UNOFFICIAL][7.1.2] LineageOS 14.1

¹ Bei Problemen könnten diese Beiträge hilfreich sein: How to flash recovery using Linux and Heimdall?, Flashing with Heimdall

² Ist bekannt welche Komponenten wohin installiert werden müssen, kann Heimdall das ROM auch direkt installieren: Use Heimdall to Install Kernels, Recoveries, ROMs on your Samsung Android Device

S.M.A.R.T. Spickzettel: Gängige smartctl-Befehle

2021-10-05T00:00:00+02:00

Diese Liste sollte die häufigsten Befehle zur Verwaltung von Geräten mit S.M.A.R.T.-Unterstützung beinhalten.

Die notwendigen Werkzeuge können in den gängigen BSD-/sowie Linux-Distributionen über das Paket smartmontools installiert werden.

# Diese Konstante setzen
GERAET='sdb'

Sämtliche SMART-Informationen anzeigen

smartctl -a /dev/${GERAET}

Testlauf-Dauer vorab abschätzen (ungefähr)

smartctl -c /dev/${GERAET}

Schnellen SMART-Check ausführen

smartctl -t short /dev/${GERAET}

Detaillierten SMART-Check ausführen

smartctl -t long /dev/${GERAET}

Testergebnisse anzeigen

smartctl -l selftest /dev/${GERAET}

Aktiven Testlauf abbrechen

smartctl -X /dev/${GERAET}

Neue udev-Regeln nach allgemein gültigem Ansatz definieren

2018-10-16T00:00:00+02:00

Neue udev-Regeln nach allgemein gültigen Ansatz definieren

Der Ablauf ist weitgehend allgemein gültig. Die Beispielkommandos behandeln das Einsetzen einer SD-Karte.

Das gewünschte Gerät in /sys finden
- Beispiel find /sys -name 'mmcblk*' findet /sys/block/mmcblk0
Erkennunsmerkmale des Geräts auflisten
- udevadm info --attribute-walk /sys/block/mmcblk0
Passende Erkennunsmerkmale sammeln
- udevadm info --attribute-walk /sys/block/mmcblk0 |
  grep -wE 'KERNEL|SUBSYSTEM|size' > /etc/udev/rules.d/10-sdcard.rules
Erkennungsparameter in Editor aufbereiten
- ${EDITOR:-vi} /etc/udev/rules.d/10-sdcard.rules
- Die erste Zeile könnte dann beispielsweise so aussehen:
  ACTION=="add", KERNEL=="mmcblk0", SUBSYSTEM=="block", ATTR{size}=="15949824", \
Aktion zum Testen der Regel ergänzen
- Vorerest soll die zweite Zeile lediglich das Anlegen einer neuen Datei auslösen:
  RUN+="/usr/bin/touch /tmp/triggered-%k"
Regel ausführbar machen und Regel laden
- chmod +x /etc/udev/rules.d/10-sdcard.rules
- udevadm control --reload
Regel testen – Vorgang simulieren und prüfen ob Datei angelegt wurde
- udevadm trigger --sysname-match=mmcblk0 --action=add
- stat /tmp/triggered-* && rm /tmp/triggered-*
Regel testen – Gerät physisch einsetzen und prüfen ob Datei angelegt wurde
- stat /tmp/triggered-* && rm /tmp/triggered-*

An dieser Stelle ist sicher gestellt, dass die Regel erwartungsgemäß ausgeführt wird. Nun kann RUN auf das gewünschte Kommando geändert werden oder andere Aktionen, wie beispielweise SYMLINK, OWNER oder MODE definiert werden.

Die Möglichkeiten sind in udev(7) dokumentiert.

Tipp: Live-Überwachung

udev-Ereignisse können mittels udevadm monitor live überwacht werden. Für bessere Übersicht kann die Ausgabe nach Subsystem gefiltert werden. Beispiel:

udevadm monitor --subsystem-match=block

Internetverbindung des Sailfish X via WiFi freigeben (Workaround)

2018-01-02T00:00:00+01:00

In Sailfish 2.1.3.7 (Kymijoki) ist ein Workaround notwendig um das Gerät als WLAN Hotspot zu verwenden.

Der Workaround ist in einem Jolla Support-Artikel beschrieben. Allerdings ist die Reihenfolge der Schritte ungenau erläutert.

Aktivieren der Internetverbindungsfreigabe

Hier die exakten Schritte zum Aktivieren der Internetverbindungsfreigabe:

[GUI] Sowohl WLAN als auch die Internetverbindungsfreigabe ausschalten
[Terminal] Zu Superuser-Berechtigungsebene aufsteigen
- devel-su
[Terminal] Betriebsmodus umstellen:
- echo 2 > /sys/module/bcmdhd/parameters/op_mode
[GUI] Internetverbindungsfreigabe aktivieren
[Terminal] tether als master der WLAN Schnittstelle wlan0 setzen:
- ip link set dev wlan0 master tether

Deaktivieren der Internetverbindungsfreigabe

Zum Deaktivieren der Freigabe, den Betriebsmodus zurück setzen und WLAN wieder einschalten:

[GUI] Internetverbindungsfreigabe ausschalten
echo 1 > /sys/module/bcmdhd/parameters/op_mode
[GUI] WLAN einschalten und verbinden (“Internetverbindung herstellen”)

Maße und Gewicht beliebter Sailfish Handys: Nexus 5 und Xperia X

2017-10-28T00:00:00+02:00

	Google Nexus 5 (1)	Sony Xperia X (2)	Sony Xperia X Compact (3)	Sony Xperia 10
Höhe [mm]	138	143	129	156
Breite [mm]	69	69	65	68
Dick [mm]	9	8	10	8
Gewicht [g]	130	153	135	?

Anmerkung: Aus der Tabelle wird lediglich das Xperia X offiziell seitens Jolla unterstützt – siehe deren Blogbeitrag ‘Purchase, download and install your Sailfish X now’

¹ https://en.wikipedia.org/wiki/Nexus_5

² https://en.wikipedia.org/wiki/Sony_Xperia_X

³ https://en.wikipedia.org/wiki/Sony_Xperia_X_Compact

Zeitpunkt der Segwit2X Aktivierung berechnen (mit Ergebnis)

2017-10-15T00:00:00+02:00

Im Internet existiert kaum eine aktualisierte Angabe bezüglich Zeitpunkt der Segwit2X Aktivierung. Hier eine Anleitung zum selbst Berechnen:

Ausgangspunkt

Bitcoin ist so ausgelegt, dass im Durchschnitt alle 10 Minuten ein neuer Block gefunden (“gemined”) wird.
Segwit wurde zum Zeitpunkt 2017-08-24 01:57:37 UTC aktiviert(1) (Block 481824 auf Blockchain.info).
Zur Berechnung der Mining-Rate nehmen wir einen beliebigen Block als Referenzwert: Block 489992 . Dieser wurde zum Zeitpunkt 2017-10-15 17:02:45 UTC gefunden.
Segwit2X soll 144*90 Blöcke nach Segwit, also mit Block 494784, aktiviert werden.(2)

Kalkulation

Zwischen Segwit und dem Referenzblock liegen 8168 Blöcke und rund 1263 Stunden (8168 = 489992 - 481824; beziehungsweise 1263 = 2017-10-15 17:02:45 minus 2017-08-24 01:57:37).

Demnach wurden im Schnitt 6.47 Blöcke pro Stunde gefunden.

Vom gewählten Referenzblock ausgehend, fehlen noch 4792 Blöcke bis Segwit2X (4792 = 494784 - 489992).

Bleibt die Mining-Rate bei 6.47 Blöcken pro Stunde, dauert es ausgehend vom Referenzblock rund 741 Stunden bis zum Segwit2X Block (740.65 = 4792 / 6.47).

Das entspricht 30.86 Tagen (30.86 = 740.65 / 24), also ungefähr 30 Tagen und 21 Stunden.

Ergebnis

Ausgehend von den Annahmen und Angaben, ist der erste Segwit2X-Block am 2017-11-14 um zirka 21 Uhr UTC zu erwarten.

¹ https://bitsonline.com/segwit-bitcoin-activated/

² https://medium.com/@jimmysong/segwit2x-what-you-need-to-know-about-the-2mb-hard-fork-27749e1544ce

pfSense Boot-Slice über Kommandozeile duplizieren

2015-03-07T00:00:00+01:00

In einer typischen pfSense “embedded” Installation (NanoBSD) ist der Speicherplatz in zwei gleich große Slices (“Partitionen”) unterteilt.

Grundsätzlich beinhalten beide die selben Daten.

Bei einem Systemupdate wird auf das aktuell ungenutzte Slice geschrieben. Sollte das Update Fehler verursachen, kann im Rahmen des pfSense Bootvorgangs der bisherige Stand ausgewählt und somit der Betrieb wie gewohnt fortgesetzt werden.

Slice über Weboberfläche duplizieren

Nach einem erfolgreichen Update spiegelt man das nun aktualisierte Slice zurück und bereitet damit auf ein künftiges Systemupdate vor. In Diagnostics > NanoBSD der pfSense Weboberfläche kann dazu der Knopf Duplicate slice verwendet werden.

Je nach Datendurchsatz dauert der Vorgang eventuell länger als die Browserverbindung aufrecht erhalten werden kann.

In diesem Fall bleibt ungewiss, ob das Duplizieren erfolgreich war.

Slice über Kommandozeile duplizieren

Um das Problem zu umgehen, kann der entsprechende dd Befehl manuell via SSH ausgeführt werden. Auch über SSH ist die pfSense Developer Shell erreichbar.

Die pfSense Developer Shell ermöglicht den direkten Aufruf der PHP-Funktionen wie sie auch die pfSense Weboberfläche nutzt und erlaubt somit die Rekonstruktion eines möglichst identischen Ablaufs.

Auf Basis der Erkenntnisse aus dem pfSense Quellcode ergibt sich folgende PHP-Befehlsabfolge für die Developer Shell in pfSense 2.2.

Achtung: Die Befehlsfolge kann bei falscher Anwendung potentiell Schaden verursachen und darf lediglich als Leitfaden betrachtet werden.

nanobsd_detect_slice_info();
global $TOFLASH, $COMPLETE_PATH, $COMPLETE_BOOT_PATH;
echo "Will clone FROM $COMPLETE_BOOT_PATH TO $TOFLASH\n";
if(nanobsd_clone_slice($COMPLETE_PATH)) { echo "SUCCESS\n"; } else { echo "FAILURE\n"; }
nanobsd_detect_slice_info();
exec

Hinweis: Während im Rahmen der Funktion das nanobsd_clone_slice das dd-Kommando aktiv ist, kann der Fortschritt mittles STRG+T abgefragt werden.

Vergleiche dazu den Groovy-Skills Beitrag “Übertragenes Datenvolumen von dd ausgeben STATUS/SIGINFO/SIGUSR1”.

Installierte Ports nach einem bestimmtem Suchbegriff filtern

2014-10-20T00:00:00+02:00

Aus der Serie “Dumm kann man sein – zu helfen muss man sich wissen” wird hier ein Skript präsentiert, das die Portsammlung nutzt um herauszufinden, welche installierte Ports einen bestimmten Suchbegriff beinhalten.

# Suchbegriff hier setzen
SUCHBEGRIFF=

INSTALLED_PORTS=`mktemp`
PORTS_WITH_OPENSSL=`mktemp`

pkg info | sed 's#-[[:digit:]].*##g' > ${INSTALLED_PORTS}
cd /usr/ports && make quicksearch key=${SUCHBEGRIFF} | grep 'Port:' | sed 's#-[[:digit:]].*##g' | awk '{print $2}' > ${PORTS_WITH_OPENSSL}
grep ${INSTALLED_PORTS} -f ${PORTS_WITH_OPENSSL}

rm ${INSTALLED_PORTS} ${PORTS_WITH_OPENSSL}

pkg(8), sed(1), make(1), grep(1), awk(1)

Falls es hierfür auch einen direkten Schalter im pkg Kommando geben sollte, freue ich mich über einen entsprechenden Hinweis.

Entfernte Windows-Freigabe (CIFS) über rsync zu FreeNAS sichern

2014-09-12T00:00:00+02:00

Es bestehen diverse Möglichkeiten, auch einem Windows-Rechner rsync “beizubringen”. Die Nutzung entsprechender Software von Drittanbietern stellt jedoch stets eine potentielle zusätzliche Fehlerquelle dar. Ein Benutzer beschreibt seine Erfahrung mit Deltacopy, einer rsync-Lösung für Windows, im FreeNAS-Forum wie folgt:

It was easy to make work with FreeNAS, but its behavior was very odd and small things would cause it to fail(such as a non-english character in a filename) while doing rsync to rsync via 2 FreeNAS boxes was without any problems. Deltacopy was also very very slow, didn’t always behave according to what I expected for the settings, etc.

Aus solchen Gründen ist es ratsam, kritische Anforderungen auf Basis bewährter Funktionalitäten zu lösen.

Im Folgenden ist beschrieben, wie FreeNAS genutzt werden kann, um Inhalte einer entfernten Windows-Freigabe zum lokalen Speicher zu ziehen.

Windows-Freigabe am FreeNAS-System einhängen

# Verbindungsdaten festlegen (hier eigene Werte festlegen)
WINDOWS_IP=
WINDOWS_HOSTNAME=
WINDOWS_SHARE=
WINDOWS_USER=
WINDOWS_PASSWORD=

Funktionierende Verbindung sicherstellen

# Zugriff zur Freigabe prüfen
smbclient -U ${WINDOWS_USER} -L ${WINDOWS_IP}
smbclient \\\\${WINDOWS_IP}\\${WINDOWS_SHARE} -U ${WINDOWS_USER} ${PASSWORT}

# Freigabe testweise lokal einhängen
TEMP_MNT=`mktemp -d`
mount_smbfs -I ${WINDOWS_IP} //${WINDOWS_USER}@${WINDOWS_HOSTNAME}/${WINDOWS_SHARE} ${TEMP_MNT} &&
  ls ${TEMP_MNT}
umount ${TEMP_MNT}

Verbindung permanent einrichten

# Schreibzugriff zu Konfigurationdateien vorübergehend ermöglichen
mount -uo rw /

# Lokalen Mountpunkt erstellen
mkdir -p /network

# Mountoptionen in fstab festlegen
echo "//${WINDOWS_USER}@${WINDOWS_HOSTNAME}/${WINDOWS_SHARE} /network/${WINDOWS_SHARE} smbfs ro,-N,-I${WINDOWS_IP} 0 0" >> /conf/base/etc/fstab

# Zugangsdaten zur Windows-Freigabe in nsmb.conf hinterlegen
echo '' >> /conf/base/etc/nsmb.conf && echo "[${WINDOWS_HOSTNAME}:${WINDOWS_USER}]" >> /conf/base/etc/nsmb.conf && echo "password=${WINDOWS_PASSWORD}" >> /conf/base/etc/nsmb.conf

# Schreibzugriff zu Konfigurationdateien verbieten
mount -uo ro /

Einrichtung überprüfen

Die Änderungen werden erst nach einem Neustart aktiv. Um sie sofort zu testen, geht man wie folgt vor.

cp /conf/base/etc/nsmb.conf /etc/nsmb.conf &&
  mount -F /conf/base/etc/fstab /network/${WINDOWS_SHARE}

Rsync konfigurieren

Mit obiger Einrichtung wird die Windows-Freigabe quasi als lokale Ressource behandelt.

rsync kann auch zum Kopieren zwischen lokalen Pfaden eingesetzt werden. Über das Web-Interface von FreeNAS ist allerdings lediglich die Konfiguration der Nutzung eines entfernten Rechners möglich.

Um Benutzers des Web-Interface dennoch eine einfache Einrichtung von “Rsync Tasks” zu ermöglichen, wird FreeNAS selbst logisch als “entfernter” Rechner konfiguriert.

# Schreibzugriff zu Konfigurationdateien vorübergehend ermöglichen
mount -uo rw /

# SSH Public-Key für root generieren
ssh-keygen

# ECDSA Hostschlüssel importieren
ssh-keyscan localhost >> /root/.ssh/known_hosts

# Authentifizierung via Public Key von localhost erlauben
cat /root/.ssh/id_rsa.pub | sed 's/^/from="127.0.0.1",no-agent-forwarding,no-port-forwarding,no-user-rc,no-X11-forwarding /g' >> /root/.ssh/authorized_keys

# Schreibzugriff zu Konfigurationdateien verbieten
mount -uo ro /

Rsync-Task einrichten

An dieser Stelle ist alles Notwendige vorbereitet, um die Einrichtung eines Rsync-Task via FreeNAS-Web-Interface für das Kopieren der der Daten der Windows-Freigabe zum entsprechenden Ziel-Dataset zu ermöglichen (System > Rsync-Tasks > Add Rsync-Task).

Die Einrichtung an sich birgt noch ein relativ offensichtliches Risiko:
Schlägt das Einhängen der Windows-Freigabe fehl, werden, wenn die rsync-Option --delete verwendet wird, die Inhalte aus dem Zielverzeichnis gelöscht.

Sinnvollerweise wird dem entgegen gewirkt indem vor Ausführen von rsync die Verfügbarkeit der Quelle sichergestellt wird.

Rein über das Web-Interface ist dies allerdings unmöglich. Ist das Risiko für diesen Fall als relativ gering einzuschätzen, minimieren regelmäßige ZFS Snapshots die Auswirkungen des Problems (Storage > Periodic Snapshot Tasks > Add Periodic Snapshot).

Ansonsten muss mit einem entsprechenden Skript behandelt werden.

Von Sicherheitslücke betroffenen FreeBSD-Port installieren

2014-08-19T00:00:00+02:00

Ist die Version einer FreeBSD-Applikation aus der Portsammlung von einer Sicherheitslücke betroffen, kann dies zur wenig aussagekräftigen Fehlermeldung *** Error code 1 führen.

Versionsnummer prüfen

# grep 'PORTVERSION' /usr/ports/www/nginx/Makefile
PORTVERSION=    1.6.0

Versuch den Port zu bauen

# cd /usr/ports/www/nginx && make

*** Error code 1

Stop.
make[1]: stopped in /usr/ports/www/nginx
*** Error code 1

Stop.
make: stopped in /usr/ports/www/nginx

Details zur Sicherheitslücke ausgeben

# pkg audit
nginx-1.6.0,2 is vulnerable:
nginx -- inject commands into SSL session vulnerability
CVE: CVE-2014-3556
WWW: http://portaudit.FreeBSD.org/ad747a01-1fee-11e4-8ff1-f0def16c5c1b.html

1 problem(s) in the installed packages found.

Installation erzwingen

Auf eigene Verantwortung kann man mit folgendem Befehl auch das Bauen eines Port mit Sicherheitslücke erzwingen:

DISABLE_VULNERABILITIES=yes make

Folge mir auf Corilla

2014-08-18T00:00:00+02:00

Ich plane meine Woche und überlege, was ich unternehmen könnte.

Könnte ich in Corilla nur jene Aktivitäten auflisten, welche von Benutzern, denen ich folge, vorgemerkt sind? Das wäre praktisch.

So wäre meine persönliche “Doo-Liste” übersichtlich und ich könnte interessante Aktivitäten schneller ausfindig machen.

Genau das ist ab sofort möglich.

Corilla-Benutzern folgen

Klicke im Profil eines beliebigen Benutzers auf “Folgen”.

In Kürze werden damit seine vorgemerkten Doos auch für dich in deiner Profilseite sichtbar.

Probier’s aus: Folge unserem Maskottchen Cori jetzt auf Corilla!

Nach wenigen Augenblicken landet damit das aktuelle Doo “International Follow-Cori Week” auch in deiner Liste.

Automatische Doo-Liste

Mit dieser neuen Following-Funktionalität erhältst du automatisch Doos von Menschen mit für dich passenden Interessen.

Symbole lassen dich den Ursprung jeder Aktivität rasch erkennen:

Der Clou: Merkst du eine gewisse Aktivität vor, landet diese automatisch in den Doo-Listen jener Menschen, die wiederum dir folgen.

Ein interessantes Doo verbreitet sich somit auf einfache Art und Weise und erreicht rasch viele Menschen.

Über neue Follower wirst du übrigens automatisch per E-Mail informiert.
(Das ist in den Benutzereinstellungen änderbar.)

Eine eigene Aktivität verteilen

Möchtest du ein eigenes Doo an die Menschen “schicken”, die dir folgen?

Veröffentliche einfach ein neues Doo und merke es sofort selbst vor.

Probier’s aus: Veröffentliche jetzt ein eigenes Doo auf Corilla!

Hör auf, mich statisch zu nennen! Vorgenerierte Webseiten klagen

2014-07-28T00:00:00+02:00

“Statisch” hat in der Informationstechnologie viele Bedeutungen – zu viele. Auch nach einer kontextuellen Eingrenzung auf einen gewissen Teilbereich, kann dieses Wort zu ungünstigen Missverständnissen führen.

In einem kürzlichen Gespräch mit einer Führungskraft eines anderen Gebiets vermittelte das Wort “statisch” den Eindruck, es sei unmöglich, Animationen zu verwenden oder die Webseite nach Responsive-Prinzipien zu gestalten.

Tatsächlich ist das Gegenteil der Fall.

Designs können genau wie bei Verwendung anderer Methoden oder CMS frei gestaltet werden. Die wenigsten Funktionalitäten einer üblichen Unternehmenswebseite benötigen echte Dynamik im Sinne von “Seitengenerierung bei jeder Anfrage”.

Der Großteil einer Webpräsenz kann mittels Generatoren wie Jekyll oder Middleman kostengünstiger, performanter und stabiler umgesetzt werden.

Oft können bestimmte Berechnungen, die sonst blindlinks serverseitig erledigt werden, clientseitig in JavaScript oder CSS durchgeführt werden.

Das Entwickeln vorabgenerierter Webseiten fördert somit eine optimale Konzeptionierung und einen sauberen Programmierstil.

Verbleibende Anforderungen für dynamische Berechnungen wie zum Beispiel Kontaktformular oder Suchfunktion können über eigens dafür optimierte (!) Werkzeuge erfüllt oder einfach von Drittanbietern eingebunden und bezogen werden.

Ablöse für “statisch”

Um das Wort “statisch” und auch die Kombination “statisch generiert” künftig zu vermeiden, scheint die Verwendung von Begriffen wie die folgenden zweckdienlich und sinnvoll:

vorab generiert / vorgeneriert
vorberechnet
vorkompiliert

Im Beitrag ‘Perfekt einfach: Was ist Jekyll?’ werden Vorteile von vorab generierten Seiten beschrieben.

Wächst ein ZFS Snapshot bei Wiederanlage einer gelöschten Datei?

2014-07-12T00:00:00+02:00

Diese Frage ist kürzlich im Rahmen eines Sicherungsszenario aufgetreten und soll hier kurz in Form einiger Terminalabfragen und -ausgaben erläutert werden.

Ausgangssituation

ZFS Version 5
Deduplication deaktiviert

# zfs get dedup stash/install
NAME           PROPERTY  VALUE          SOURCE
stash/install  dedup     off            default

# zfs get version stash/install
NAME           PROPERTY  VALUE    SOURCE
stash/install  version   5        -

Test 1: Lokales Umbenennen einer Datei

Eine Datei wird lediglich lokal umbenannt.

# Snapshot erstellen
# zfs snap stash/install@before_rename

# Snapshot anzeigen
# zfs list -t snapshot | grep -E 'NAME|before_rename'
NAME                                                                        USED  AVAIL  REFER  MOUNTPOINT
stash/install@before_rename                                                    0      -  68.1G  -

# Datei verschieben (= umbenennen)
# ls -ahl archlinux-2013.04.01-dual.iso
-rw-rw-r--  1 g  g   506M Apr 23  2013 archlinux-2013.04.01-dual.iso
# mv archlinux-2013.04.01-dual.iso RENAMED_x-2013.04.01-dual.iso

# Snapshot erstellen
# zfs snap stash/install@after_rename
# zfs list -t snapshot | grep -E 'NAME|rename'
NAME                                                                        USED  AVAIL  REFER  MOUNTPOINT
stash/install@before_rename                                                    0      -  68.1G  -
stash/install@after_rename                                                     0      -  68.1G  -

Ergebnis: Snapshotgröße bleibt unberührt.

Test 2: Löschen und Wiedereinkopieren über Netzwerk

Eine Datei wird lokal gelöscht und über das Netzwerk (CIFS) wiedereinkopiert.

Dieser Anwendungsfall ist gängig, wenn ZFS als Ziel-Dateisystem für regelmäßige Sicherungen von anderen Netzwerkgeräten eingesetzt wird.

# rm RENAMED_archlinux-2013.04.01-dual.iso
# [an dieser Stelle wurde via Netzwerk einkopiert]
# ls -hal archlinux-2013.04.01-dual.iso 
-rw-------  1 g  g   506M Apr 23  2013 archlinux-2013.04.01-dual.iso

# Snapshot erstellen
# zfs snap stash/install@after_recreation_via_network
# zfs list -t snapshot | grep -E 'NAME|before|after'
NAME                                                                        USED  AVAIL  REFER  MOUNTPOINT
stash/install@before_rename                                                    0      -  68.1G  -
stash/install@after_rename                                                  163K      -  68.1G  -
stash/install@after_recreation_via_network                                     0      -  68.1G  -

Ergebnis: Snapshotgröße wächst mit 163K minimal an, anstatt den benötigten Speicherplatz der Datei erneut zu verbrauchen.

Alles Gute! Gratuliere Corilla und gewinne Metallica VIP-Karten

2014-07-04T00:00:00+02:00

Heute seit genau zwei Jahren beglückt Corilla das Internet mit seiner Präsenz.

Für die kommenden Monate sind spannende neue Funktionen geplant, denn die Registrierungszahlen steigen – und das motiviert! :)

Das, und der Geburtstag der Plattform sollen heute mit einer kleinen Aktion gefeiert werden.

Aber was soll ich denn schenken?

Möchtest du mitfeiern und VIP Karten für Metallica im Wert von rund 460 Euro gewinnen?

Dann schenke Corilla etwas ganz Besonderes: Neue Benutzer!

Um am Gewinnspiel teil zu nehmen, musst du zwei Anforderungen erfüllen:

Zwei Personen müssen sich über deinen Empfehlungslink zu Corilla registrieren.
Du musst Corilla über dein bevorzugtes soziales Netzwerk gratulieren.

Beides muss noch vor Montagnachmittag passieren. Im Folgenden sind die beiden Anforderungen genau erklärt.

1. Wie lade ich jemanden zu Corilla ein?

Logge dich auf Corilla mit deinem bestehenden Konto ein oder erstelle ein neues.
Klicke nach dem Anmelden rechts oben auf deinen Benutzernamen.
Kopiere deinen Empfehlungslink und lade zwei Freunde ein, sich darüber bei Corilla zu registrieren.

Sobald mindestens zwei Personen die Registrierung über deinen Link abgeschlossen haben, hast du diesen Teil der Anforderung bereits erfüllt!

2. Wie gratuliere ich Corilla standesgerecht zum Geburtstag?

Das ist einfach: Klicke einen der folgenden Links und veröffentliche dann den vorgefertigten Geburtstagsgruß.

Sobald dein Gruß auf mindestens einer dieser Plattformen veröffentlicht ist, hast du auch den zweiten und letzten Teil der Anforderung erfüllt und nimmst automatisch an der Verlosung teil.

Danke für dein Geschenk und viel Glück!

Corilla und das Team freuen sich bereits riesig, die neuen Benutzer begrüßen zu dürfen.

Wir wünschen dir viel Glück!

Vielleicht bist du nächste Woche bereits VIP-Gast bei Metallica.

Details und das Kleingedruckte … normal groß

Das Metallica-Konzert findet am 9. Juli 2014 in Wien statt. Alle Details findest du in diesem Corilla Doo.
Sämtliche Corilla-Nutzer, welche beide Anforderungen bis Montag Nachmittag (7. Juli 2014 um 16:00 MESZ) erfüllen, nehmen automatisch an der Verlosung teil.
- Für die Anzahl eingeladener Personen werden Benutzer-Einladungen ab dem 4. Juli 2014 gewertet.
Gewinner werden umgehend benachrichtigt. Die Eintrittskarten werden voraussichtlich per Eilsendung zugestellt.
Verlost wird per Zufallsgenerator. Der Rechtsweg ist ausgeschlossen.

Du willst noch mehr tun? Dann folge Corilla auf Twitter !

ZFS-Snapshots vergleichen und große Dateien ausfiltern

2014-04-03T00:00:00+02:00

Verbrauchen ZFS Snapshots unerwartet viel Speicherplatz, sind oft Änderungen an großen Dateien die Ursache.

E-Mail Clients wie Thunderbird welche sämtliche Nachrichten eines Mailordners in einer großen Datei speichern (mbox-Format) sind eine mögliche Ursache.

Veränderte Dateien identifizieren

Da scheinbar ein entsprechende Funktionalität in ZFS fehlt, wird hier ein kurzes Shell-Skript verwendet um veränderte Dateien zu finden.

# Zu vergleichende Snapshots (ohne Angabe von Dataset und Pfad) nennen
SNAPSHOT1=
SNAPSHOT2=

# In das Snapshot-Verzeichnis des betroffenen Dataset wechseln
DATASET_MOUNTPOINT=/mnt/stash/for/spark/home
cd ${DATASET_MOUNTPOINT}/.zfs/snapshot

# Unterschiede in eine Datei schreiben
LIST_OF_DIFFERING_FILES=`mktemp -t snapdiff`
diff -qr ${SNAPSHOT1} ${SNAPSHOT2} > ${LIST_OF_DIFFERING_FILES}

diff(1)

Große Dateien ausfiltern

Um festzustellen, welche der veränderten Dateien eine bestimmte Größe überschreiten, werden aus dem DIFF die Dateinamen ausgefiltert um dann via find eine Liste auszufiltern.

FIND_FILES_BIGGER_THAN='10M'
SANITIZED_DIFF=`mktemp -t sanitized_diff`

# Unerwünschte Zeilen aus DIFF entfernen
sed 's/^.* and //g' ${LIST_OF_DIFFERING_FILES} | sed 's/ differ$//g' | sed 's/^Only in .*$//g' | sed 's/^File .* is a socket//g' | grep -v '^$' > ${SANITIZED_DIFF}

# Jede Datei aus dem DIFF prüfen
while read line; do
  find $line -type f -size +${FIND_FILES_BIGGER_THAN} -exec ls -ahl {} \;
done < ${SANITIZED_DIFF} 2> /dev/null

sed(1), grep(1), find(1), ls(1)

Bei Überschreitung des festgelegten Schwellwerts laut ${FIND_FILES_BIGGER_THAN} wird die betreffende Datei mittles ls ausgegeben.

Rasche Einrichtung eines SFTP chroot-Zugangs in OpenSSH / FreeBSD

2014-04-03T00:00:00+02:00

Wichtig: In der Hierarchie bis zum freigegebenen Verzeichnis, muss root der Besitzer der übergeordneten Verzeichnisse sein.

SSHD Konfiguration eintragen

# Diese Variable nach Wunsch setzen
SFTP_USER=

# HOME-Zugriff für Mitglieder der Gruppe 'sftp' erlauben
echo 'Match Group sftp
        ChrootDirectory         %h
        ForceCommand            internal-sftp
        AllowTcpForwarding      no' >> /etc/ssh/sshd_config

# Benutzer als 'sftp'-Gruppenmitglied anlegen
pw groupadd sftp ${SFTP_USER}
pw useradd ${SFTP_USER} -m -c 'SFTP Dateiempfang' -g ${SFTP_USER} -G sftp
passwd ${SFTP_USER}

echo(1), pw(8), passwd(1)

Ein Neustart des OpenSSH-Diensts war im Test überflüssig.

SFTP-Zugang testen

SFTP_HOST=
echo 'pwd' | sftp ${SFTP_USER}@${SFTP_HOST}

sftp(1)

Mit obigen Kommando sollte die Verbindung aufgebaut und der Pfad des HOME-Verzeichnisses des Benutzer ausgegeben werden.

Quellen

pyLoad Download Manager in FreeBSD oder FreeBSD Jail installieren

2014-03-29T00:00:00+01:00

Der pyLoad FreeBSD Port von MrHanky ermöglicht eine rasche Installation des Download Managers in FreeBSD.

Abhängigkeiten und pyLoad installieren

pkg install devel/git databases/py-sqlite3 ftp/py-curl graphics/py-imaging lang/python security/py-pycrypto www/py-django security/py-openssl archivers/unrar archivers/unzip lang/spidermonkey17 graphics/gocr graphics/tesseract graphics/tesseract-data

cd ~
git clone https://github.com/mrhanky17/pyload-freebsd.git pyload
cd pyload/ && make install clean

pkg(8), git-clone(1)

Grundeinrichtung vornehmen

Die Konfiguration kann grundsätzlich laut der Anleitung für Linux in der offiziellen pyLoad Dokumentation vorgenommen werden.

Der Befehl pyload dient dabei als Abkürzung zu python pyLoadCore.py:

# Grundkonfiguration vornehmen (interaktiv)
pyload -s

# pyLoad dauerhaft aktivieren
echo 'pyload_enable="YES"' >> /etc/rc.conf

# pyLoad erstmalig starten
service pyload start

service(8)

An dieser Stelle sollte pyLoad bereits gestartet und verwendbar sein.

Zusätzliche oder bestehende Benutzerkonten können über pyload -u erstellt und verwaltet werden.

GitHub als CMS (2/2): Statische Webseiten mit Travis CI bauen

2014-03-20T00:00:00+01:00

Im ersten Teil dieser Artikelserie ist erläutert, wie man Web-Autoren das Editieren von Inhalten mittels GitHub erleichtern kann.

Dieser Artikel beschreibt das automatische Generieren und Veröffentlichen der Webseiten.

Grundkonzept

Grundsätzlich sind folgende Schritte erforderlich:

Quellcode beziehen
Statische Webseite bauen
Statische Webseite veröffentlichen

Im Rahmen dieses Artikels werden dafür folgende Dienste genutzt:

Der Quellcode wird auf GitHub verwaltet.
Die statische Webseite wird mittels Travis CI gebaut.
Die resultierende Statische Webseite wird auf GitHub Pages veröffentlicht.

Demnach gelten die jeweiligen Nutzungsrichtlinien von GitHub und Travis CI.

Außerdem ist wichtig, sich bewusst zu sein, dass in beide Dienste im Standardangebot sämtliche Inhalte als Open Source behandeln und somit für jedermann einsehbar sind.

Quellcode von GitHub beziehen

Sobald man sich mit dem entsprechenden GitHub-Konto bei Travis CI angemeldet hat, können einzelne Repositories zur Verarbeitung gewählt werden.

Der Leser sollte dies ohne Schwierigkeiten handhaben können. Details sind in der Travis CI Dokumentation erläutert.

Mittels Travis CI bauen und auf GitHub Pages veröffentlichen

Um von Travis CI in ein Git-Repository schreiben zu können, muss sichergestellt werden, dass sich die Applikation authentifizieren kann.

Anstatt umständlich mit SSH-Schlüsseln zu arbeiten, bietet es sich an, Benutzername und Passwort direkt in der Git-Remote URL fest zu halten.

Access Token generieren

Für diese HTTPS-Authentifizierung wird ein Zugriffskürzel benötigt, welches laut der Beschreibung auf GitHub generiert werden kann.

# Token zur weiteren Verarbeitung speichern
GITHUB_TOKEN=e2643f7d431b071c58729474daaa6d805b336596

Access Token verschlüsseln

Würde man das Token im Klartext in die Konfigurationsdatei schreiben, könnte dieses leicht kompromittiert werden.

Travis CI bietet daher eine einfache Möglichkeit, derartige Daten zu verschlüsseln und im Rahmen des Build-Prozesses wieder zur Verfügung zu stellen.

# Travis Gem installieren
gem install travis travis-lint

# Token verschlüsseln und in .travis.yml schreiben
travis encrypt GITHUB_TOKEN=${GITHUB_TOKEN} --add env.global

# Gültigkeit von .travis.yml sicherstellen
travis-lint

Damit werden Kommandos im späteren Travis CI Build-Prozess den ursprünglichen Wert von ${GITHUB_TOKEN} auslesen können.

Skript zur Veröffentlichung in .travis.yml hinterlegen

Dies ist ein vollständiges Beispiel für die Datei .travis.yml.

Nachdem die Abhängigkeiten installiert sind, wird die Seite gebaut (middleman build). Anschließend wird das Ergebnis als eigenes Git-Repository initialisiert, konfiguriert und in das Ziel-Repository veröffentlicht.

Man beachte den Zugriff auf ${GITHUB_TOKEN} im Rahmen des git remote Kommandos. Wichtig ist auch die Verwendung von --quiet um zu verhindern, dass das Token auf der Travis CI Website im Klartext aufscheint.

Achtung: In diesem Beispiel werden die Inhalte des Ziel-Repository gänzlich gelöscht und neu angelegt.

language: ruby
rvm: 2.0.0
env:
  global:
    secure: I3lfngRydxAJzdZQ7lVf2h8EqymIH8OyR71miD1NDN5ioOfXSaVPzB6+OX2KGI9x4TXs4QKZdBpu5zEJDfLqbLbbmn4X8AayGgzEmcEkubAOc8/epdELlYRxBL4x5v5R/wRDEl+0mr9G+cYZ+UKhvFnXnUX1V9JvsHS1P+xbfHk=
before_install:
- sudo apt-get update -qq
- sudo apt-get install -qq jpegoptim libjpeg-turbo-progs pngcrush optipng advancecomp
script: |
  bundle exec middleman build &&
  cd ./build && site_url=`cat CNAME` && [ ${site_url} != '' ] &&
  git init && git remote add origin https://BENUTZERNAME:${GITHUB_TOKEN}@github.com/BENUTZERNAME/${site_url}-build.git &&
  git config user.email \"`date '+%Y'`@example.org\" && git config user.name \"Travis\ CI `date '+%Y'`\" &&
  git add . && git status --porcelain | git commit --quiet --file=- &&
  git checkout -b gh-pages && git push --quiet --force --set-upstream origin gh-pages

Im gegebenen Anwendungsfall kann ein Build nur dann als erfolgreich betrachtet werden, wenn die Webseite auch korrekt veröffentlicht wurde. Demnach ist in diesem Beispiel die gesamte Logik Teil des Abschnitts script, während in anderen Beispielen entsprechende Hooks wie etwa after_success angebrachter sind.

GitHub als CMS (1/2): Statisch generierte Webseiten für Anfänger

2014-03-20T00:00:00+01:00

Statische Website Generatoren wie Jekyll oder Middleman bieten unzählige Vorteile im Vergleich zum Betrieb dynamischer, CMS-basierter Webseiten.

Technologie-versierte Nutzern mit Erfahrung in den jeweils zutreffenden Programmiersprachen können meist relativ rasch Websites mit Hilfe dieser Generatoren erzeugen.

Die Herausforderung liegt aktuell darin, diese Technologien auch Web-Autoren ohne Hintergrundkenntnisse zugänglich zu machen.

Hindernisse und Lösungen für Web-Autoren

Vor Allem folgende Punkte gestalten sich für Web-Autoren im Zusammenhang mit statischen Website-Generatoren schwierig:

die Handhabung von Inhalten
das Generieren der Webseite
das Veröffentlichen beim Hoster

Vereinfachte Handhabung von Inhalten

Es ist quasi undenkbar, vom Großteil der reinen Web-Autoren tief greifende Git-Kenntnisse zu fordern. Daher soll dieser Punkt abstrahiert und die Handhabung bekannter CMS weitgehend imitiert werden.

Online-Editoren von Drittanbietern

Online-Editoren wie Prose und TinyPress verbinden sich direkt mit GitHub und vereinfachen den Umgang mit den Inhalten. Mit diesen Benutzeroberflächen können kleinere Änderungen auf angenehme Weise durchgeführt werden.

Die Vorschauoptionen sind derzeit (03/2014) allerdings auf Texte im Markdown-Format beschränkt.

Direkt in GitHub bearbeiten

Die Tatsache scheint einigen Entwicklern unbekannt zu sein, doch können Dateien auch direkt auf GitHub editiert werden – “Zen-Modus” inklusive.

Um die entsprechende Vorschaufunktion mit weitreichender Unterstützung diverser Markup-Formate zu aktivieren muss eine neue Datei zumindest einmal mit entsprechender Endung gespeichert worden sein. Es empfiehlt sich daher, zuerst eine leere Datei zu erstellen.

Ein Autor muss nun lediglich darauf achten, die Dateien korrekt benannt im jeweils richtigen Verzeichnis abzulegen.

Vereinfachtes Generieren und Veröffentlichen

Sowohl das Generieren der Seiten als auch das Hochladen zum Hoster sollte dem Web-Autor gänzlich abgenommen werden.

Mit Jekyll und GitHub Pages ist bereits viel gewonnen. In dieser Kombination übernimmt GitHub selbst das Generieren – ein korrektes Repository-Setup vorausgesetzt.

Dafür muss Jekyll allerdings mit safe: true betrieben werden, wodurch komplexe Lösungen (Plugins) weitgehend unmöglich werden.

Erweiterte Möglichkeiten

Möchte man die oben genannte Einschränkung umgehen oder generell andere Generatoren, wie beispielsweise Middleman, nutzen, muss die Seite vorab generiert und erst dann zum entsprechenden Hoster geladen werden.

Beide Schritte können mit Travis CI elegant gelöst werden.

Die entsprechende Einrichtung ist in Teil 2 dieser Artikelserie erklärt.

Vorteile des Konzepts

Git bietet Vieles, was herkömmlichen CMS oft gesondert implementieren müssen, in ausgereifter Form:

Die Versionshistorie erlaubt das einfache Widerrufen bestimmter Änderungen.
Über die Gewährung des Collaborator Status in GitHub kann weiteren Benutzern Zugang zum Projekt gewährt werden.
Konzeptionell ist das Offline-Editieren eine Standardfunktion, welche vor allem in Zusammenhang mit Applikationen wie dem GitHub Mac Client zugänglich gemacht werden kann.

Git: Name und E-Mail Adresse zu Commits in Git-Historie ersetzen

2013-11-11T00:00:00+01:00

Achtung: git filter-branch ändert die Historie. Siehe dazu diesen Hinweis aus der git-filter-branch(1) Manpage:

WARNING! The rewritten history will have different object names for all the objects and will not converge with the original branch. You will not be able to easily push and distribute the rewritten branch on top of the original branch. Please do not use this command if you do not know the full implications, and avoid using it anyway, if a simple single commit would suffice to fix your problem.

Skript zum Ersetzen von Name und E-Mail Adresse

FROM_COMMITTER_NAME='BISHERIGER NAME'
TO_NAME='NEUER NAME'
TO_EMAIL='neue_email@example.com'
        
git filter-branch --commit-filter "
        if [ \"\$GIT_COMMITTER_NAME\" = '${FROM_COMMITTER_NAME}' ]; then
                GIT_COMMITTER_NAME='${TO_NAME}';
                GIT_AUTHOR_NAME='${TO_NAME}';
                GIT_COMMITTER_EMAIL='${TO_EMAIL}';
                GIT_AUTHOR_EMAIL='${TO_EMAIL}';
                git commit-tree \$@;
        else
                git commit-tree \$@;
        fi" HEAD

Perfekt einfach: Was ist Jekyll?

2013-10-26T00:00:00+02:00

Ausgehend von einer bestimmten Dateistruktur erzeugt Jekyll eine statische HTML Seite.

Beim Generieren werden sämtliche Inhalte der Seite bereits fertig berechnet und als Dateien abgelegt.

Üblicherweise ist das Resultat frei von dynamischen Inhalten. Der Webserver muss die Dateien lediglich so ausliefern, wie sie bereits vorliegen. Zu diesem Zeitpunkt entfällt der Rechenaufwand zum Zusammensetzen von Datenbankinhalten und dynamischem Code.

Webseiten auf Jekyll-Basis sind demnach designbedingt sicherer, schneller, wartungsfrei und langlebig.

Komplexität als Nachteil von Content Management Systemen

Dynamische CMS schaffen Probleme, die oft mit komplexen und fehleranfälligen Ansätzen behandelt werden müssen.

Ein Paradebeispiel für solche Ansätze sind Caching-Plugins wie sie für gängige CMS existieren. Solche Plugins müssen “entscheiden”, welche Inhalte wann und für wie lange statisch ausgeliefert werden können, bevor sie (erneut) aus den Ressourcen gebaut werden müssen.

Jekyll macht ein Caching in dieser Form überflüssig. Jene Inhalte, die dynamische Berechnungen erfordern, können über entsprechend spezialisierte Services oder auch über Drittanbieter gelöst werden.

Beispiel: Verwandlung von Jekyll “Quellcode” in HTML

Eine einfache Dateistruktur dient als Grundlage für Jekyll.

Mit dem entsprechenden Befehl weist man Jekyll an eine HTML-Seitenstruktur zu generieren welche am Webserver abgelegt werden kann.

Ausgangslage: Quell-Dateistruktur

Um rasch die notwendige Struktur zu erstellen, kann der Befehl jekyll new ${SEITENNAME} verwendet werden. In Jekyll 1.2.1 werden damit folgende Dateien und Verzeichnisse erstellt:

.
├── _config.yml
├── css
│   ├── main.css
│   └── syntax.css
├── index.html
├── _layouts
│   ├── default.html
│   └── post.html
└── _posts
    └── 2013-10-26-welcome-to-jekyll.markdown

3 directories, 7 files

Ergebnis: Generierte HTML-Dateistruktur

Mit jekyll build wird ein Unterverzeichnis _site mit folgendem Aufbau generiert:

_site
├── css
│   ├── main.css
│   └── syntax.css
├── index.html
└── jekyll
    └── update
        └── 2013
            └── 10
                └── 26
                    └── welcome-to-jekyll.html

6 directories, 4 files

Fazit

Die folgende Aufzählung zeigt einige der Probleme auf welche jeder Webentwickler früher oder später stößt.

Update einer Website, aufgrund von Sicherheitslücken im CMS
“Zusammenbruch” einer Website durch Inkompatibilät mit der Interpreterversion des Hosters (z.B. PHP)
Notwendigkeit zur Konfiguration eines Caching-Plugin auf CMS und Betriebssystemebene
Ineffizientes Arbeiten wegen umfangreicher Ladezeiten des Backends/Administrationbereich eines CMS

Wer einige dieser Erfahrungen gemacht hat, wird mit Jekyll seinen Horizont erweitert sehen.

Tipp: Wer Jekyll auch weniger versierten Nutzern schmackhaft machen möchte, findet mit Prose einen interessanten Ansatz um Inhalte direkt online editierbar zu machen.

Bye, Bye Spreadsheet. Hi, Jekyll Date Chart!

2013-10-10T00:00:00+02:00

Deckard	BTC	all but real
01.01.2013	=6000,00	a good start
16.01.2013	=+1500,00	they said we should use WordPress
03.03.2013	=-3000,00	asked my Dad for it; thank you Dad
04.04.2013	+1500,00	assume this is an addition
05.05.2013	+1500,00	sometimes Mum is more generous
06.06.2013	+1500,00	they said we should use WordPress

Quaid	BTC	all but real
01.01.2013	=4000,00	a good start
01.02.2013	-3000,00	they said we should use WordPress
01.03.2013	+1500,00	asked my Dad for it; thank you Dad
01.04.2013	-1500,00	assume this is an addition
01.05.2013	+1500,00	sometimes Mum is more generous
01.06.2013	+1500,00	they said we should use WordPress

Hauser	BTC	all but real
01.01.2013	=0,00	a good start
01.02.2013	+1500,00	they said we should use WordPress
01.03.2013	+2500,00	asked my Dad for it; thank you Dad
01.04.2013	+1500,00	assume this is an addition
01.05.2013	+2500,00	sometimes Mum is more generous
01.06.2013	+1500,00	they said we should use WordPress

Jekyll Date Chart (RubyGems, GitHub) erzeugt Liniendiagramme mit Datumsbezug aus Textile-ähnlichen Tabellen.

Im Folgenden werden einige Beispieldiagramme zum frisch gebackenen Jekyll Plugin aufgezeigt.

Nutzungsbeispiele mit allgemeinen Werten

Push-Ups	Repetitions	Push it to the limit, walk along the razors ed..
12.02.2013	=12	Hey, I’ve only just started out!
13.03.2013	=9	Hangover. Just don’t ask.
14.04.2013	=15	Look at that!
15.05.2013	=20	Superman is jealous.
16.06.2013	=30	Hulk is jealous.
17.07.2013	=50	Chuck Norris is jealous.

339	Repetitions	If you stick with us …
21.05.2013	=250	Checkin’ on the kids, eh Toni?
22.06.2013	=300	Hit my haaand, Jason!
24.07.2013	=339	Look, Audri, I did it! Oh, you’re still goin …
25.08.2013	=349	Might do a little bonus?? Hmpf
26.09.2013	=350	Adam, we’re done. Adam?!

Nutzungsbeispiele mit Finanzdaten

Zwei Tabellen – zwei Diagramme

Savings	USD	all but real
01.01.2013	=3.000,00	a good start
02.02.2013	=-2.920,30	they said we should use WordPress
03.03.2013	+2.500,00	asked my Dad for it; thank you Dad
04.04.2013	100,50	assume this is an addition
05.05.2013	+2.501,15	sometimes Mum is more generous
06.06.2013	+1,16	… and then Dad again

cash	EUR	vest, trousers, socks and the like
10.01.2013	=0,00	we all start out naked they say
02.02.2013	=-2.000,20	long night in Vegas; too long
30.03.2013	+2.200,00	mowed the lawn; big lawn
20.05.2013	-200,15	birthday party
30.07.2013	=+1.650,00	where did that come from?

Zwei Tabellen – ein Diagramm

Savings	EUR	all but real
01.01.2013	=3.000,00	a good start
02.02.2013	=-2.920,30	they said we should use WordPress
03.03.2013	+2.500,00	asked my dad for it; thank you dad

cash	EUR	vest, trousers, socks and the like
01.01.2013	=0,00	we all start out naked they say
02.02.2013	=-2.000,20	long night in Vegas; too long
03.03.2013	+2.200,00	mowed the lawn; big lawn

OpenVPN: Ohne manuelle Passworteingabe mit VPN-Anbieter verbinden

2013-09-26T00:00:00+02:00

Für wenige Bitcoin und ohne Angabe persönlicher Details ermöglichen Anbieter wie Private Internet Access (Empfehlungslink) ein entspannteres Nutzen des Internet mit den IP Adressen ihrer VPN-Server.

Um die Einwahl via OpenVPN beim Systemstart zu automatisieren und somit die Passwortabfrage zu vermeiden, können die entsprechenden Zugangsdaten in einer einfachen Textdatei abgelegt werden.

Ein Verweis aus der OpenVPN-Client Konfigurationsdatei reicht aus um die Textdatei zu nutzen.

OpenVPN Konfigurationsdateien von Private Internet Access laden

Nach der OpenVPN Installation (Ubuntu: sudo apt-get install openvpn) lädt man mit folgenden Befehlen das Konfigurationspaket herunter.

url='https://www.privateinternetaccess.com/openvpn/openvpn.zip'
tmpdir=`mktemp -d`
zip="${tmpdir}/openvpn.zip"

cd "${tmpdir}"
curl "${url}" > "${zip}"
unzip "${zip}" && rm "${zip}"

curl(1), unzip(1)

OpenVPN Konfigurationsdateien zur Nutzung der Credentials-Datei umschreiben

sed --in-place=_before_credentials_file \
's/auth-user-pass/auth-user-pass credentials.txt\nauth-nocache/g' *.ovpn

sed(1)

Credentials-Datei mit Benutzername und Kennwort erstellen

# Hier müssen die entsprechenden Daten eingetragen werden:
PIA_BENUTZERNAME=
PIA_PASSWORT=

# Daten in eine Datei schreiben
credentials_file=`mktemp`
echo "${PIA_BENUTZERNAME}\n${PIA_PASSWORT}" > ${credentials_file}
chmod go-rwx ${credentials_file}

sudo mv -i * /etc/openvpn/

echo(1), chmod(1), mv(1)

OpenVPN-Verbindung aktivieren

PIA_SERVER=Sweden

sudo ln -s /etc/openvpn/${SERVER}.ovpn /etc/openvpn/pia.conf
sudo service openvpn restart

ln(1), service(8)

An dieser Stelle sollte die Verbindung zum gewünschten Server des VPN-Anbieters hergestellt sein.

Tipps und Tricks

Gerätename für VPN-Tunnel festlegen

Standardmäßig wird beim Verbindungsaufbau ein neues tun-Gerät verwendet.

Dadurch könnte man theoretisch zu allen VPN-Servern gleichzeitig eine Verbindung aufbauen.

Möchte man sicherstellen, dass dies unterbunden ist, vergibt man in der Konfigurationsdatei explizit einen Namen:

sed --in-place=_before_dev_rename \
's/^dev tun$/dev tunPIA/g' *.ovpn

Nun wird das tun-Gerät stets als tunPIA benannt.

Das ist vor allem dann praktisch, wenn man den Schnittstellennamen in Skripten nutzen möchte.

Bestimmte IP Adressen von VPN-Tunnel ausnehmen

Bei manchen VPN-Anbietern muss man explizit ein Whitelisting von Mailservern beantragen, da sie ansonsten Verbindungen über die entsprechenden Ports blocken.

Möchte man den Aufwand vermeiden, oder vertraut man einer Verbindung zum Mailserver einfach mehr, kann man einzelne IP-Adressen via OpenVPN-Konfigurationsdatei am Tunnel vorbeileiten:

# IP hier angeben
AUSNAHME_IP=
echo "route ${AUSNAHME_IP} 255.255.255.255 net_gateway" | tee -a *.openvpn

tee(1)

Netzwerkschnittstellen elegant formatiert auflisten

# Aktive Schnittstellen auflisten
ip -family inet -oneline addr show scope global |
awk '{ printf "%s %s up\n", $2, $4 }'

# Inaktive Schnittstellen auflisten
ip -family inet -oneline link show scope global |
grep ' DOWN ' | sed 's/\://g' |
awk '{ printf "%s none down\n", $2}'

Fluxbox Toolbar: Mehrere Zeitzonen und dynamischen Text anzeigen

2013-09-22T00:00:00+02:00

Fluxbox bietet grundsätzlich nur wenige Möglichkeiten die Toolbar um eigene Inhalte zu erweitern.

Möchte man dennoch kurze Ausgaben von Kommandos und Skripts im Blickfeld behalten, so lassen sich dazu die Arbeitsflächennamen zweckentfremden.

In folgendem Beispiel wird die Arbeitsfläche so umbenannt, dass die Uhrzeiten unterschiedlicher Zeitzonen eingeblendet werden.

Kommandozeilenzugriff zu Fluxbox erlauben

Die Arbeitsflächennamen sind unter session.screen0.workspaceNames in der Datei ~/.fluxbox/init hinterlegt.

Ein direktes Bearbeiten der init-Datei kann allerdings elegant mit dem kaum bekannten Kommando fluxbox-remote vermieden werden.

fluxbox-remote ermöglicht es, die aus fluxbox-keys bekannten Kommandos auch direkt über die Shell auszuführen, fern manuell oder mit folgendem Befehl die entsprechende Erlaubnis erteilt wurde:

sed --in-place=_before_editing_allowRemoteActions \
's/\(session.screen[0-9]\+.allowRemoteActions\).*/\1:\ttrue/g' \
~/.fluxbox/init

sed(1)

Arbeitsflächenname mit dynamischem Text füllen

Die meisten von fluxbox -list-commands aufgelisteten Kommandos können nun direkt via fluxbox-remote ausgeführt werden.

Folgendes Skript macht sich dies zu Nutze um jede Sekunde die aktuelle Stunde von jeweils drei Zeitzonen in den Arbeitsflächennamen zu schreiben.

rename_fluxbox_workspace_with_tztimes.sh

#!/bin/sh
# See /usr/share/zoneinfo for supported time zones

while [ true ]; do
  utc=`export TZ && TZ=UTC && date +"%H"`
  cet=`export TZ && TZ=Europe/Vienna && date +"%H"`
  sgt=`export TZ && TZ=Asia/Singapore && date +"%H"`

  workspace_number=`xprop -root _NET_CURRENT_DESKTOP | awk '{print $3+1}'`
  workspace_name="|${utc}|${cet}|${sgt}|"

  fluxbox-remote "setworkspacename #${workspace_number}     ${workspace_name}     +"

  sleep 1
don

fluxbox-remote(1)

Wie im Skript erkennbar, kann man jederzeit per fluxbox-remote "setworkspacename $NAME" einen neuen Namen vergeben, was sonst nur in der graphischen Oberfläche von Fluxbox möglich wäre.

Node.js und Node Package Manager (NPM) in Ubuntu installieren

2013-09-15T00:00:00+02:00

Einige interessante Dienste wie beispielsweise Apache Cordova / PhoneGap sind mit Hilfe von Node.js als “serverseitiges JavaScript” implementiert.

Mit folgenden Befehlen kann Node.js und das dazugehörige Paketverwaltungswerkzeug npm rasch installiert werden.

Node.js installieren

sudo apt-get install g++ curl libssl-dev

cd `mktemp -d` &&
curl http://nodejs.org/dist/node-latest.tar.gz | tar xzv &&
cd node-v* && ./configure && make && sudo make install

Versionen überprüfen und NPM aktualisieren

node -v && npm -v

# Das "Node Packaged Module" 'npm' aktualisieren
sudo npm install -g npm

npm -v

node(1), npm(1)

ownCloud 5 in FreeNAS 9.1 Jail oder FreeBSD installieren

2013-09-03T00:00:00+02:00

Der FreeNAS Wiki-Artikel Adding Jails erläutert die Installation der Plugins-Jail.

Verbindet man sich danach via SSH zur FreeNAS-Box, kann man mittels Befehl “jexec 1 tcsh” in die entsprechende Jail wechseln und die notwendige Installation vornehmen.
Achtung: Die Ziffer variiert. Die korrekte kann man mit dem Befehl “jls” herausfinden.

Der anschließende Installationsverlauf funktioniert gleich wie außerhalb einer FreeBSD-Jail und ist im Folgenden erläutert. Die Anleitung ist mit FreeNAS 8.2 getestet.

Ports-Tree aktualisieren

portsnap fetch extract

portsnap(8)

ownCloud aus den Ports installieren

Beim Verfassen dieses Artikels ist 5.0.10 die aktuelle ownCloud-Version in den Ports.

Die Installation aus den Ports bringt zwei Vorteile: Einerseits werden dabei alle Paketabhängigkeiten konfiguriert und installiert. Zieht die Version aus den FreeBSD-Ports einst nach, erhält man zudem passende portaudit Berichte.

Beim Konfigurieren des PHP-Ports in folgendem Schritt muss Build FPM version ausgewählt sein. CLI und CGI können abgewählt werden.

cd /usr/ports/www/owncloud
make config-recursive
make install clean

PHP-FPM auf Socket umstellen und Transfer-Limits erhöhen

# PHP-FPM auf Socket umstellen
sed -i '' -e 's/^listen =.*/listen = \/var\/run\/php5-fpm.sock/g' /usr/local/etc/php-fpm.conf

cp /usr/local/etc/php.ini-production /usr/local/etc/php.ini

# Größere Uploads ermöglichen
sed -i '' -e 's/^post_max_size =.*/post_max_size = 300M/g' /usr/local/etc/php.ini
sed -i '' -e 's/^upload_max_filesize =.*/upload_max_filesize = 200M/g' /usr/local/etc/php.ini

sed(1)

nginx installieren

Beim Konfigurieren des nginx-Ports in folgendem Schritt muss HTTP_SSL Enable http_ssl module ausgewählt sein.

cd /usr/ports/www/nginx && make install clean

SSL Zertifikat für nginx erzeugen

Eine rasche Methode hierfür ist im Beitrag SSL Zertifikat erzeugen und direkt in die nginx.conf übernehmen erklärt.

nginx konfigurieren

Um sämtliche Funktionen von ownCloud nutzen zu können, müssen im server-Abschnitt (HTTPS) der /usr/local/etc/nginx/nginx.conf die kommentierten Bereiche freigestellt und folgende Einträge an Stelle der vorhandenen location-Direktiven eingefügt werden.

        root /usr/local/www/owncloud;
        client_max_body_size 200m; # set max upload size
        fastcgi_buffers 64 4K;

        rewrite ^/caldav(.*)$ /remote.php/caldav$1 redirect;
        rewrite ^/carddav(.*)$ /remote.php/carddav$1 redirect;
        rewrite ^/webdav(.*)$ /remote.php/webdav$1 redirect;

        index index.php;
        error_page 403 = /core/templates/403.php;
        error_page 404 = /core/templates/404.php;

        location = /robots.txt {
            allow all;
            log_not_found off;
            access_log off;
        }

        location ~ ^/(data|config|\.ht|db_structure\.xml|README) {
                deny all;
        }

        location / {
                # The following 2 rules are only needed with webfinger
                rewrite ^/.well-known/host-meta /public.php?service=host-meta last;
                rewrite ^/.well-known/host-meta.json /public.php?service=host-meta-json last;

                rewrite ^/.well-known/carddav /remote.php/carddav/ redirect;
                rewrite ^/.well-known/caldav /remote.php/caldav/ redirect;

                rewrite ^(/core/doc/[^\/]+/)$ $1/index.html;

                try_files $uri $uri/ index.php;
        }

        location ~ ^(.+?\.php)(/.*)?$ {
                try_files $1 = 404;

                include fastcgi_params;
                fastcgi_param SCRIPT_FILENAME $document_root$1;
                fastcgi_param PATH_INFO $2;
                fastcgi_param HTTPS on;
                fastcgi_pass unix:/var/run/php5-fpm.sock;
        }

        # Optional: set long EXPIRES header on static assets
        location ~* ^.+\.(jpg|jpeg|gif|bmp|ico|png|css|js|swf)$ {
                expires 30d;
                # Optional: Don't log access to assets
                access_log off;
        }

Quelle: ownCloud Administrators Manual

nginx und PHP-FPM dauerhaft aktivieren und starten

echo 'nginx_enable="YES"' >> /etc/rc.conf
echo 'php_fpm_enable="YES"' >> /etc/rc.conf

/usr/local/etc/rc.d/php-fpm start
/usr/local/etc/rc.d/nginx start

echo(1), rc.conf(5)

Zur ownCloud-Weboberfläche verbinden

Nun kann man sich via Browser zur ownCloud-Installation verbinden und die Software in vollem Umfang nutzen.

Die entsprechende IP-Adresse der Plugins-Jails kann man in der FreeNAS-Weboberfläche unter Services > Plugins > Management > Settings einsehen.

Tipp: Ein weiterer Artikel beschreibt, wie man die Dateien aus FreeNAS direkt in ownCloud verfügbar machen kann.

Passworteingaben und Makros in Fluxbox korrekt automatisieren

2013-08-13T00:00:00+02:00

In KDE funktioniert die Auto-Type Funktion aus KeePass zumindest, solange das Passwort frei von Sonderzeichen ist.

In Fluxbox sorgt das explizite Setzen des Tastaturlayouts via setxkbmap dafür, dass sämtliche Eingaben korrekt funktionieren.

Durch das Einfügen der folgenden Zeile in die Datei ~/.fluxbox/startup wird der notwendige Befehl bei jedem Start automatisch ausgeführt.

# Ensure correct pasting via xvkbd makros, keepassx autotype and the like.
setxkbmap -layout de -variant neo

-variant neo wählt das Neo-Tastaturlayout aus. Ist dies ungewünscht, kann der Schalter entfallen.

Auch Textmakros aus xvkbd (xvkbd -text ...) funktionieren danach korrekt.

Quelle: KeePassX Autotype in Dvorak

Speichermedium auf Fehler überprüfen und mit Zufallswerten füllen

2013-08-11T00:00:00+02:00

Achtung: Diese Befehle ZERSTÖREN absichtlich die Daten auf den betreffenden Geräten!

Um Speichermedien für die Verwendung als verschlüsselte Geräte vorzubereiten, ist es dringend empfohlen, diese auf Fehler zu überprüfen und mit Zufallswerten zu befüllen.

Zur Überprüfung wird hier badblocks verwendet. Die Zufallswerte werden aus /dev/urandom geholt.

Anmerkung zur Sicherheit der Überschreibungsvorgänge

Ein “sicher” vorbereitetes Medium zeichnet sich unter anderem durch den Schwierigkeit aus, Rückschlüsse auf Eigenschaften gespeicherter Daten zu ziehen.

Die hier beschriebenen Methoden dienen in erster Linie dazu, das Ausmaß verschlüsselter Datenbereiche zu verschleiern.

Zufallswerte in freien Speicherbereichen erschweren es, am verschlüsselten Medium entsprechende Muster zu erkennen. Je höher die Entropie generierter Werte, desto “zufälliger” sind sie.

badblocks – Integrität des Geräts überprüfen

Bei Verwendung des Schalters -w in Kombination mit -t random beschreibt badblocks das Medium während der Überprüfung mit Pseudo-Zufallswerten.

Je nach Risiko kann dies unzureichend und ein Beschreiben mit Zufallswerten aus /dev/urandom sinnvoll sein.

DISK=
sudo badblocks -c 10240 -s -w -t random -v ${DISK}

badblocks(8)

-c: Anzahl zeitgleich getesteter Blöcke
-w: Jeden Block mittels Schreibzugriff (!) testen
-t: Art des geschriebenen Testmusters festlegen
-v: Umfangreiche Ausgabe

Pro 100 GiB Speichervolumen dauerte dieser Vorgang bei den Festplatten aus dem Jahr 2010 rund eine Stunde.

urandom – Gerät mit Zufallswerten befüllen

Die Gerätedatei /dev/urandom arbeitet mit besonders hoher Entropie und ist somit eine der sichersten und langsamsten Methoden, Medien für eine Verschlüsselung vorzubereiten.

Wird /dev/random an Stelle von /dev/urandom genutzt, kann der Ablauf auf Kosten der Sicherheit beschleunigt werden.

DISK=
sudo dd if=/dev/urandom of=${DISK}

Manpages: dd(1), urandom(4)

Da dieser Vorgang bei großen Platten mehrere Tage dauert, sollte eine beständige Stromversorgung per Batterie (Laptop) oder USV sichergestellt sein.

Fortschritt überprüfen [optional]

Im Beitrag Übertragenes Datenvolumen von dd ausgeben ist erklärt, wie der Fortschritt von dd regelmäßig ausgegeben werden kann.

Jekyll Plugin als Ruby Gem vorbereiten und veröffentlichen

2013-08-10T00:00:00+02:00

Die hier beschriebenen Abläufe gelten großteils auch für Gems ohne Bezug zu Jekyll.

Korrekten Aufbau des Quellcodes vorbereiten

Vorab muss sichergestellt werden, dass die Dateistruktur der Quelldateien korrekt ist.

Der Name des Hauptskripts stellt sich aus dem späteren Gem-Namen mit der Dateiendung .rb zusammen und ist im Unterverzeichnis lib abgelegt.
Die Gem-Spezifikation liegt im Hauptverzeichnis und trägt den Gem-Namen mit der Dateiendung .gemspec. Sie wird am Einfachsten aus einer Vorlage erstellt.

Beispielstruktur

.
├── jekyll_image_encode.gemspec
├── lib
│   └── jekyll_image_encode.rb
└── README.textile

Das Anbieten der optionalen README-Datei wird dringend empfohlen.

Ruby Gem bauen und testen

# Diese Konstanten müssen den eigenen Gegebenheiten
# entsprechend initialisiert werden
GEM_NAME=jekyll_image_encode
GEM_VERSION=0.0.1
PATH_TO_JEKYLL_SITE=$HOME/jekyll/

# Gem bauen und lokal installieren
cd ${PATH_TO_JEKYLL_SITE}
gem build ${GEM_NAME}.gemspec
gem install ./${GEM_NAME}-${GEM_VERSION}.gem

# Gem in Jekyll Seite laden
echo "require 'jekyll_image_encode'" >> _plugins/ext.rb
jekyll serve

Nun kann man die Funktionalität des neuen Gem im Browser überprüfen.
Danach kann man den Gem mittels gem uninstall ${GEM_NAME} wieder entfernen.

Quellcode in GitHub veröffentlichen

Wichtig: Es wird davon ausgegangen, dass der Gem lokal bereits in ein Git Repository eingepflegt ist.

Zuerst wird ein neues Repository auf GitHub erstellt.
Danach wird das lokale Repository in das soeben auf GitHub erstellte hochladen:

# Diese Konstanten müssen den eigenen Gegebenheiten
# entsprechend initialisiert werden
GITHUB_USER=GSI
GEM_NAME=jekyll_image_encode
 
git remote add origin git@github.com:${GITHUB_USER}/${GEM_NAME}.git
git push -u origin master

Jekyll Gem auf RubyGems.org veröffentlichen

# Diese Konstanten müssen den eigenen Gegebenheiten
# entsprechend initialisiert werden
RUBYGEMS_USER=GSI
curl -u ${RUBYGEMS_USER} https://rubygems.org/api/v1/api_key.yaml > $HOME/.gem/credentials

gem push ${GEM_NAME}-${GEM_VERSION}.gem
gem list -r ${GEM_NAME}

Jeyll Gem in offizielle Jekyll-Dokumentation eintragen

Zum Zeitpunkt des Verfassens dieses Artikels unterhält das Jekyll Projekt eine Liste der verfügbaren Plugins, welche der Datei site/docs/plugins.md des auf GitHub veröffentlichten Quellcodes entspricht.

Mit Hilfe des üblichen GitHub Workflows, kann man die Listung des eigenen Jekyll Plugins beantragen:

Fork des jekyll Projekts erstellen
Datei site/docs/plugins.md entsprechend anpassen
Änderungen per Pull Request senden

VirtualBox: Windows 7 aus Linux auf physische Platte installieren

2013-04-07T00:00:00+02:00

Im Normalfall installiert man Windows via Installations-DVD.

Hat man jedoch ein ISO-Abbild der Installations-DVD zur Verfügung, kann man mit Hilfe von VirtualBox eine direkte Installation auf eine neue Festplatte vornehmen und somit das Brennen eines entsprechenden Mediums vermeiden.

Virtuelle Maschine erstellen

Zuerst legt man eine virtuelle Maschine an, welche die Anforderungen des Betriebssystems erfüllt.

Dieser Schritt kann bequem über die grafische Oberfläche von VirtualBox oder per Kommando VBoxManage(1) erledigt werden.

Auf eine detaillierte Erläuterung wird an dieser Stelle verzichtet, allerdings ist es wichtig, das ISO-Abbild als CD/DVD einzubinden.

Physische Festplatte verfügbar machen

Mit den folgenden Kommandos wird eine VMDK-Datei für die physische Festplatte angelegt und an die entsprechende virtuelle Maschine gebunden.

# Der VM_NAME kann über 'VBoxManage list vms' gefunden werden
VM_NAME='Windows 7 Home Premium (64 bit)'
VMDK=${HOME}/.VirtualBox/samsung_840_ssd.vmdk
# Die DISK_ID findet man beim Auflisten des Verzeichnisinhalts von /dev/disk/by-id/
DISK_ID=ata-Samsung_SSD_840_Series_S14GNEBCB66690P

# VMDK als Schnittstelle zu physischer Festplatte erstellen
VBoxManage internalcommands createrawvmdk -filename ${VMDK} -rawdisk /dev/disk/by-id/${DISK_ID}
# VMDK an virtuelle Maschine binden
# Name des Controllers kann mit folgendem Befehl eruiert werden: 'VBoxManage showvminfo --machinereadable "${VM_NAME}" | grep "storagecontrollername"'
VBoxManage storageattach "${VM_NAME}" --storagectl "SATA-Controller" --port 0 --device 0 --type hdd --nonrotational on --medium ${VMDK}

VBoxManage(1)

Installation durchführen und System starten

Dem jeweiligen Betriebssystem entsprechend kann nun die Installation durchgeführt werden.

Danach sollte sich das System auch außerhalb von VirtualBox direkt von der Festplatte starten lassen.

Blue-Screen beim Windows-Start?

Vor allem bei älteren Windows-Betriebssystemen schlägt der Start nach dem Tausch gewisser Hardware fehl.

Da man beim direkten Systemstart das virtualisierte Mainboard gegen das physische tauscht, kann das Problem im Rahmen dieser Einrichtung auftauchen.

Im Artikel “Windows XP nach Mainboard- oder Plattentausch lauffähig machen” ist beschrieben wie man das Problem mit Hilfe der Ultimate Boot CD for Windows (UBCD4Win) beheben kann.

Entfernen von Jekyll Bootstrap spart tausende Codezeilen ein

2013-03-29T00:00:00+01:00

Mit Jekyll Bootstrap gestaltet sich der Einstieg in Jekyll ein Wenig einfacher. Konfigurationsoptionen und Twitter Bootstrap ermöglichen das rasche Aufsetzen eines statischen Blogs.

Per _config.yml kann man die jeweiligen Webdienste für Diskussion, Besucherstatistik und der Gleichen auswählen. Auch die Idee, verschiedene Themes zu unterstützen, wirkt auf den ersten Blick interessant.

Bald merkt man jedoch, dass man sich immer weiter von der so attraktiven Jekyll-Grundidee entfernt: Vereinfachung

Nachteile von Jekyll-Bootstrap

Fehler und Inkompatibilitäten sind durch den größeren Umfang schwerer zu analysieren.

Nach längeren Pausen ist eine gewisse Wiedereinarbeitungszeit notwendig um Änderungen vorzunehmen zu können.

Themepfade und zusätzliche “includes” sind an mehreren Stellen hinterlegt und verkomplizieren diverse Anpassungen.

Reduktion auf das Notwendige

Im Falle der Seitenstruktur von groovy-skills.com waren einige Stunden notwendig um die Programmierung auf das Notwendige zu reduzieren. Dass sich die Investition lohnte, zeigen folgende Zahlen.

Exklusive Git, aber inklusive Binärdateien (Bilder) beinhaltete die Jekyll-Dateistruktur von groovy-skills.com 6.020 Zeilen.

Das Entfernen der unnötigen Daten von Twitter-Bootstrap reduzierte diese Zahl auf 5.141.

Nach der Reduzierung auf die tatsächlich benötigten Zeilen aus Jekyll-Bootstrap, war der Umfang letztendlich auf 3.526 Zeilen geschrumpft.

Von der Zahl ohne Twitter Bootstrap ausgehend, konnten demnach 1.615 Zeilen eingespart werden.

Das entspricht einer Reduktion von rund 31 %.

Zeilen aller Dateien eines Verzeichnisses zählen

Zum Bilden der Summe der Zeilen wurde das folgendes Skript verwendet.

sum=0
lines_counts=`find ./ -type f -exec wc -l {} \; | cut -d ' ' -f1`
for line_count in $lines_counts; do
  sum=`expr $sum + $line_count`
done
echo $sum

find(1), wc(1)

Alternativen zu Jekyll-Bootstrap

Aus genannten Gründen, raten wir zur Nutzung von Jekyll in seiner puren Form.

Wer dennoch einen einfacheren Einstieg in das Bloggen mit Jekyll sucht, kann auf Octopress zurück greifen.

Im Vergleich zu Jekyll-Bootstrap bietet es eine etwas einfachere Seitenstruktur. Viele nützliche Plugins werden bereits standardmäßig mitgeliefert.

Dateien aus FreeNAS in ownCloud Plugins Jail verfügbar machen

2012-11-05T00:00:00+01:00

Im Artikel eines anderen Blogs ergab sich die Frage, wie man innerhalb der ownCloud Plugins-Jail die Dateien aus dem FreeNAS-Hostsystem verfügbar machen könne.

Grundsätzlich bietet bereits das FreeNAS WebUI unter Services > Plugins > Management > Mount Points > Add Mount Point die Möglichkeit, Verzeichnisse aus dem Hostsystem in die Jail einzuhängen.

Über diesen Punkt hängt man den entsprechenden Pfad und in ein Unterverzeichnis von files ein. Beispiel:

Source: /mnt/pfad/im/hostsytem/dateien
Destination: /mnt/pfad/zu/jail/usr/local/www/owncloud-4.5/data/BENUTZERNAME/files/dateien

(Details sind im FreeNAS Wiki-Artikelabschnitt Mount Points erläutert.)

Berechtigungen setzen

Selten wird der Benutzer www auch Besitzer der eingehängten Dateien sein. Um ownCloud dennoch Zugriff zu gewähren, gibt es mehrere Ansätze.

Unter Berücksichtigung diverser Überlegungen, wird der Folgende in vielen Fällen geeignet sein.

www-Benutzer der Jail zu berechtigtem Gruppenmitglied machen

In der Plugins-Jail muss sichergestellt werden, dass die Gruppe zumindest Leserechte auf die betreffende Verzeichnisstruktur hat.

# Zur besseren Nachvollziehbarkeit sollte owning_group im
# Folgenden auf den Gruppennamen laut Hostsystem gesetzt werden:
set GROUPNAME_ACCORDING_TO_HOSTSYSTEM="users"
set OWNCLOUD_USERNAME='dice'
set DIR="/mnt/pfad/zu/jail/usr/local/www/owncloud-4.5/data/${OWNCLOUD_USERNAME}/files/dateien"
set owning_gid=`ls -dln ${DIR} | awk '{ print $4 }'`

# Der Gruppe Leserechte gewähren
chmod -R g+rX ${DIR}

# www-Benutzer in die Gruppe aufnehmen
pw groupadd ${GROUPNAME_ACCORDING_TO_HOSTSYSTEM} -g ${owning_gid} -M www

# Dienste neu starten
/usr/local/etc/rc.d/nginx restart
/usr/local/etc/rc.d/php-fpm restart

chmod(1), pw(8)

So kann man den Benutzer www in alle notwendigen Gruppen aufnehmen. Der Einfachheit halber ist es allerdings sinnvoll, deren Anzahl so gering wie möglich zu halten.

Dateien neu einlesen

Da dieser Vorgang die ownCloud Datenbank umgeht, sind auf diese Art und Weise verfügbar gemachte Dateien für ownCloud grundsätzlich unsichtbar,

ownCloud scanFiles-Bookmarklet

Um sie einzulesen, zieht man folgenden Link in die Browser-Lesezeichen, navigiert im ownCloud WebUI zum Menüpunkt Dateien und klickt dann auf das soeben erstellte Lesezeichen.

ownCloud Dateien neu einlesen;

ownCloud 4.5 in FreeNAS 8 Plugins-Jail oder FreeBSD installieren

2012-10-12T00:00:00+02:00

Es existiert eine vereinfachte und aktualisierte Version dieses Artikels: ownCloud 5 in FreeNAS 9.1 Jail oder FreeBSD installieren

Der FreeNAS Wiki-Artikelabschnitt Installing the Plugins Jail erläutert die Installation der Plugins-Jail.

Der anschließende Installationsverlauf funktioniert gleich wie außerhalb einer FreeBSD-Jail und ist im Folgenden erläutert. Die Anleitung ist mit FreeNAS 8.2 getestet.

Warnung vor möglichem Datenverlust

Ein späteres Update der Plugins-Jail führt zum Verlust der hier beschriebenen Einrichtung und der darin befindlichen persönlichen ownCloud-Daten.

Um das zu verhindern, könnte eine gesonderte Jail exklusiv für ownCloud eingerichtet werden.

Die bessere Integration in die FreeNAS-Weboberfläche spricht allerdings für die Nutzung der Plugins-Jail. Regelmäßige Datensicherungen in Kombination mit dieser Anleitung erleichtern das erneute Einrichten nach einem Update.

Diese Anmerkung bezieht sich ausschließlich auf Updates in der Plugins-Jail. Updates des FreeNAS-Hauptsystems können wie gewohnt durchgeführt werden, da diese die Jails grundsätzlich unberührt lassen.

Ports-Tree aktualisieren und Konflikt-Pakete entfernen

portsnap fetch extract
pkg_delete -f perl-5.12.4_3 pkg-config-0.25_1 pcre-8.21

portsnap(8), pkg_delete(1)

ownCloud aus den Ports installieren

Beim Verfassen dieses Artikels ist 4.0.7 die aktuelle ownCloud-Version in den Ports.

Obwohl letztendlich ownCloud 4.5.0 installiert werden soll, bringt die Installation aus den Ports zwei Vorteile: Einerseits werden dabei annähernd alle Paketabhängigkeiten konfiguriert und installiert. Zieht die Version aus den FreeBSD-Ports einst nach, erhält man zudem passende portaudit Berichte.

Beim Konfigurieren des PHP-Ports in folgendem Schritt muss Build FPM version ausgewählt sein. CLI und CGI können abgewählt werden.

cd /usr/ports/www/owncloud
make config-recursive
make install clean

Zusätzliche Abhängigkeiten installieren

Sowohl zlib als auch iconv werden von ownCloud benötigt.

cd /usr/ports/archivers/php5-zlib && make install clean
cd /usr/ports/converters/php5-iconv && make install clean

ownCloud 4.5.0 installieren

cd /usr/local/www/
fetch http://download.owncloud.org/releases/owncloud-4.5.0.tar.bz2
tar xjf owncloud-4.5.0.tar.bz2 -C /root/
mv /root/owncloud /usr/local/www/owncloud-4.5
chown -R www:www /usr/local/www/owncloud-4.5

fetch(1), tar(1)

PHP-FPM auf Socket umstellen und Transfer-Limits erhöhen

# PHP-FPM auf Socket umstellen
sed -i '' -e 's/^listen =.*/listen = \/var\/run\/php-fpm.sock/g' /usr/local/etc/php-fpm.conf

cp /usr/local/etc/php.ini-production /usr/local/etc/php.ini

# Größere Uploads ermöglichen
sed -i '' -e 's/^post_max_size =.*/post_max_size = 300M/g' /usr/local/etc/php.ini
sed -i '' -e 's/^upload_max_filesize =.*/upload_max_filesize = 200M/g' /usr/local/etc/php.ini

# Größere Downloads für Client-Apps ermöglichen (siehe untenstehende Anmerkung)
sed -i '' -e 's/^memory_limit =.*/memory_limit = 512M/g' /usr/local/etc/php.ini

sed(1)

Anmerkung zu memory_limit

Vor dem Herunterladen mittles ownCloud Client-App (beispielsweise auf Android), wird die betreffende Datei zuerst gänzlich in den Hauptspeicher geladen. Ist die Datei größer als das konfigurierte memory_limit, schlägt der Download mit folgender Meldung fehl:

PHP message: PHP Fatal error: Allowed memory size of ${memory_limit} bytes exhausted

An Stelle von ${memory_limit} wird dabei der enstprechend konfigurierte Wert ausgegeben.
Dieses Verhalten wurde zuletzt in ownCloud Version 4.5.1 verifiziert.

nginx installieren

Beim Konfigurieren des nginx-Ports in folgendem Schritt muss Enable http_ssl module ausgewählt sein.

cd /usr/ports/www/nginx && make install clean

SSL Zertifikat für nginx erzeugen

Eine rasche Methode hierfür ist im Beitrag SSL Zertifikat erzeugen und direkt in die nginx.conf übernehmen erklärt.

nginx konfigurieren

        root /usr/local/www/owncloud-4.5;
        client_max_body_size 200m;

        location / {
                index  index.html index.htm index.php;
                # http://forum.owncloud.org/viewtopic.php?f=3&t=2952&p=7158#p7157
                rewrite ^/.well-known/host-meta /public.php?service=host-meta last;
                rewrite ^/.well-known/carddav /remote.php/carddav/ redirect;
                rewrite ^/.well-known/caldav /remote.php/caldav/ redirect;
                rewrite ^/apps/calendar/caldav.php /remote.php/caldav/ last;
                rewrite ^/apps/contacts/carddav.php /remote.php/carddav/ last;
                rewrite ^/apps/([^/]*)/(.*\.(css|php))$ /index.php?app=$1&getfile=$2 last;
                rewrite ^/remote/(.*) /remote.php/$1 last;

                fastcgi_param   SCRIPT_FILENAME $document_root$fastcgi_script_name;
                fastcgi_param   SCRIPT_NAME     $fastcgi_script_name;
                fastcgi_param   PATH_INFO       $fastcgi_path_info;

                try_files $uri $uri/ @webdav;
        }

        location ~ \.php$ {
                # http://bugs.owncloud.org/thebuggenie/owncloud/issues/oc-902#comment_1_904_8388
                #fastcgi_split_path_info ^(.+\.php)(/.*)$;
                include         fastcgi_params;
                fastcgi_pass    unix:/var/run/php-fpm.sock;
                fastcgi_index   index.php;

                fastcgi_param   SCRIPT_FILENAME $document_root$fastcgi_script_name;
                fastcgi_param   SCRIPT_NAME     $fastcgi_script_name;
                fastcgi_param   PATH_INFO       $fastcgi_path_info;

                try_files $uri =404;
        }

        # owncloud WebDAV
        location @webdav {
                fastcgi_split_path_info ^(.+\.php)(/.*)$;
                fastcgi_pass    unix:/var/run/php-fpm.sock;

                fastcgi_param   SCRIPT_FILENAME $document_root$fastcgi_script_name;
                fastcgi_param   SCRIPT_NAME     $fastcgi_script_name;
                fastcgi_param   PATH_INFO       $fastcgi_path_info;

                fastcgi_param   HTTPS on;
                include         fastcgi_params;
        }

nginx und PHP-FPM dauerhaft aktivieren und starten

echo 'nginx_enable="YES"' >> /etc/rc.conf
echo 'php_fpm_enable="YES"' >> /etc/rc.conf

/usr/local/etc/rc.d/php-fpm start
/usr/local/etc/rc.d/nginx start

echo(1), rc.conf(5)

Zur ownCloud-Weboberfläche verbinden

Nun kann man sich via Browser zur ownCloud-Installation verbinden und die Software in vollem Umfang nutzen.

Die entsprechende IP-Adresse der Plugins-Jails kann man in der FreeNAS-Weboberfläche unter Services > Plugins > Management > Settings einsehen.

Tipp: Ein weiterer Artikel beschreibt, wie man die Dateien aus FreeNAS direkt in ownCloud verfügbar machen kann.

sudo: Bestimmte Kommandos ohne Passwortabfrage erlauben (sudoers)

2012-09-21T00:00:00+02:00

In /etc/sudoers wird festgelegt, welche Benutzer/Gruppe welche Kommandos via sudo ausführen dürfen.

Besonders interessant ist dabei die Möglichkeit, Kommandos zu nennen, welche ohne zusätzliche Passwortabfrage laufen dürfen.

/etc/sudoers via visudo editieren

sudo visudo

sudo(8), visudo(8)

Passwortloses sudo für bestimmte Gruppe erlauben

Durch Hinzufügen der folgenden Zeilen erlaubt man Mitgliedern der Gruppe adm die gelisteten Kommandos direkt auszuführen:

%adm ALL=(ALL:ALL) NOPASSWD:    /usr/bin/apt-get upgrade,       /usr/bin/apt-get dist-upgrade, \
                                /usr/bin/apt-get update,        /usr/bin/apt-get autoremove, \
                                /bin/netstat -tulpen,           /bin/netstat -lnp, \
                                /usr/sbin/openvpn,              /bin/kill -SIGHUP *, \
                                /sbin/modprobe pcspkr,          /usr/bin/vi /etc/bash.bashrc, \
                                /sbin/poweroff

Wie man sieht, kann auch vorgegeben werden, welche Schalter vorhanden sein müssen. Der Befehl sudo netstat -lnp würde demnach erfolgreich ausgeführt werden, während sudo netstat -l weiterhin die Authorisierung via Passwort erfordert.

Wichtige Anmerkungen

Einträge weiter unten in der Datei haben höhere Priorität als vorangestellte. Um Schwierigkeiten zu vermeiden, sollte der Ausschnitt aus dem obigem Beispiel am Ende der Datei eingefügt werden.
Da zuerst in die temporäre Datei /etc/sudoers.tmp geschrieben wird, treten die Einstellungen erst nach dem Schließen des Editors in Kraft.

Bestehende FreeNAS Plugins-Jail importieren (nach Factory Reset)

2012-09-16T00:00:00+02:00

In FreeNAS Version 8.2 scheint die Möglichkeit zum Import einer bestehenden Plugins-Jail zu fehlen. Mit wenig Aufwand kann man dennoch eine bestehende Jail wieder zum Einsatz bringen:

Sicherstellen, dass der Plugins-Dienst inaktiv ist (Services > Plugins > Management > Settings)

Bestehende Jail umbenennen

mv /mnt/volume1/jail/plugins-jail /mnt/volume1/jail/plugins-jail_backup

Eine neue Plugins-Jails via WebUI erstellen (Services > Plugins > Management > Settings)
- Speicherort: /mnt/volume1/jail/
- Name: plugins-jail

Die neu erzeugte Jail mit der der ursprünglichen vertauschen

mv /mnt/volume1/jail/plugins-jail /mnt/volume1/jail/plugins-jail_pristine
mv /mnt/volume1/jail/plugins-jail_backup /mnt/volume1/jail/plugins-jail

Den Plugins-Dienst via WebUI starten (Services > Control Services)

mv(1)

SSL Zertifikat erzeugen und direkt in die nginx.conf übernehmen

2012-09-15T00:00:00+02:00

Variablen deklarieren

Im Folgenden ist sowohl die csh-Syntax als auch die bash-/sh-Syntax gezeigt.

# Variablen initialisieren und in nginx-Verzeichnis wechseln
# CSH-Syntax (auch für tcsh und ähnliche)
set BASE_FILENAME=`hostname`
set key=${BASE_FILENAME}.key
set csr=${BASE_FILENAME}.csr
set crt=${BASE_FILENAME}.crt

# SH-Syntax (auch für bash und ähnliche)
BASE_FILENAME=`hostname`
key=${BASE_FILENAME}.key
csr=${BASE_FILENAME}.csr
crt=${BASE_FILENAME}.crt

SSL Schlüssel, CSR und Zertifikat erstellen

cd /usr/local/etc/nginx

# Schlüssel generieren
openssl genrsa -out ${key} 2048
# CSR erstellen (FQDN als Common Name eingeben!)
openssl req -new -key ${key} -out ${csr}
# Signiertes Zertifikat erstellen
openssl x509 -req -days 3650 -in ${csr} -signkey ${key} -out ${crt}

# Korrekte Dateinamen in nginx.conf referenzieren
# Achtung: Nutzt man in der nginx.conf mehrere unterschiedliche
# Zertifikate, ist das Ersetzen sämtlicher Vorkommnisse laut
# folgender Kommandos wahrscheinlich unerwünscht.
sed -i '' -e "s/^ *ssl_certificate_key .*/        ssl_certificate_key  ${key};/g" /usr/local/etc/nginx/nginx.conf
sed -i '' -e "s/^ *ssl_certificate .*/        ssl_certificate      ${crt};/g" /usr/local/etc/nginx/nginx.conf

openssl(1), sed(1)

KMail: Mails in Posteingang optimal zusammenstellen & gruppieren

2012-08-31T00:00:00+02:00

Schon seit einigen Versionen bietet KMail die Möglichkeit, E-Mails nach bestimmten Kriterien zusammen zu stellen.

Bedeutung der Begriffe “Zusammenstellung” und “Gruppierung”

Abhängig vom Inhalt des jeweiligen Ordners sind unterschiedliche Optionen interessant.

Zusammenstellung

Legt man in einem Ordner beispielsweise ausschließlich die Korrespondenz mit einer bestimmten Person ab, so bietet sich eine Zusammenstellung nach Datum an.

Die jeweiligen Tage werden damit auf- und zuklappbar und es ist möglich nur die gewünschten Zeiträume zu betrachten.

Gruppierung

Innerhalb der jeweiligen Zusammenstellung können einzelne Mails gruppiert werden. Das bedeutet, dass die Mails einer Korrespondenz (Mail, Antwort, weitere Antworten) hierarchisch aufgelistet werden. Es lässt sich auf den ersten Blick erkennen, welche Mail auf welche folgte.

Um dies optimal nutzen zu können, sollten sowohl empfangene als auch versendete Nachrichten im selben Ordner abgelegt werden.

Gruppierte Zusammenstellung nach Absender/Empfänger

Wenn man nun das Programm so konfiguriert, dass versendete Nachrichten im Posteingang (!) landen, kann es für diesen Ordner optimal sein, Zusammenstellungen auf Basis des jeweiligen “Gesprächspartners” zu erstellen.

Dies kann mit Ansicht > Nachrichtenliste > Zusammenstellung > Absender/Empfänger, flach erreicht werden.

Allerdings fehlt standardmäßig eine Option, die so erstellten Zusammenstellungen zusätzlich zu gruppieren. So erstellt man sie:

Klick auf Ansicht > Nachrichtenliste > Zusammenstellung > Einrichten …
Absender/Empfänger, flach wählen und Knopf Zusammenstellung kopieren drücken
Im Reiter Zusammenstellung und Gruppierung die Diskussionsfaden-Gruppierung auf Nur exakt (oder eine andere außer “Keine”) setzen
Im selben Reiter die Diskussionsfaden-Aufklapp-Richtlinie je nach Wunsch setzen
Im Reiter Allgemein den Namen beispielsweise auf Absender/Empfänger, gruppiert ändern
Mit OK bestätigen und die neue Zusammenstellung unter Ansicht > Nachrichtenliste > Zusammenstellung auswählen.

Sortierung

Um eine optimale Übersichtlichkeit zu erreichen, sollte zusätzlich die Sortierung gesetzt werden. Dazu wählt man unter Ansicht > Nachrichtenliste > Sortierung > Sortierkriterium für Gruppen die Option nach Datum/Zeit der neuesten Nachricht einer Gruppe aus.

Ab sofort erscheint die Zusammenstellung jenes Korrespondenzpartners, mit dem man zuletzt kommuniziert hat, in der Nachrichtenliste ganz oben.

Sinnvoll ist diese Konfiguration vor allem, wenn man sich angewöhnt hat im Posteingang lediglich unerledigte Nachrichten zu behalten und abgeschlossene zu löschen oder in einem anderen Ordner zu archivieren.

kmail(1)

Ultimativer Showdown: Grails vs Rails

2012-08-19T00:00:00+02:00

Vor rund zwei Jahren begannen wir die Entwicklung einer Web-Applikation. Aufgrund vorhandener Skills im Bereich Groovy & Java, wurde Grails als Framework gewählt.

Immer wieder schien das Framework, das sich mit dem Slogan “the search is over” brüstet, einer effizienten Entwicklung Steine in den Weg zu werfen.

Einfache Aufgaben erforderten komplexe Eigenprogrammierungen und kritische Fehler blieben unbehoben. Als der Veröffentlichungstermin der nun aktuellen Grails-Version 2 über das Jahr 2011 hinweg mehrmals verschoben wurde, kamen erste Zweifel auf.

Im Februar 2012 war unsere Applikation technisch bereit für den Go-Live. Die Fehleranfälligkeit und Komplexität von Grails veranlasste uns dennoch dazu, Alternativen zu suchen anstatt weitere Zeit mit diesem mangelhaften Werkzeug zu verschwenden.

Das Projekt wurde mit Rails neu gestartet und befindet sich seither in rascherer Entwicklung als zuvor.

Seit 4. Juli 2012 ist das Projekt Corilla im Grundumfang online und überschreitet in Bezug auf Stabilität und Geschwindigkeit sämtliche Erwartungen.

Vergleich

Im Folgenden sind die Vorteile von Rails gelistet welche innerhalb der ersten beiden Monate im Rails-Projekt sofort positiv aufgefallen sind.

Sie sind in der Reihenfolge gelistet in der sie bemerkt wurden. Somit ist die Reihenfolge ohne Bezug zur Relevanz des jeweiligen Punktes.

Verglichen wird die Rails Version 3.2 mit Grails 2.0.

SQLite vs. H2 als Datenbank in der Entwicklungsumgebung

Rails verwendet in der Development-Umgebung standardmäßig SQLite als Datenbank – Grails 2 setzt auf H2.

H2 ist eine in-memory Datenbank. Sämtliche Datensätze gehen beim Neustart der Applikation verloren. Testdatensätze muss man stets neu anlegen.
Die SQLite-Datenbanken werden im Projektverzeichnis gespeichert. Bei Bedarf können sie somit auch einfach in die Versionsverwaltung aufgenommen werden (obgleich das Format dafür eher ungeeignet ist).

Tatsächlich sollte man bei der Entwicklung jenes DBMS verwenden, welches auch in der Produktivumgebung zum Einsatz kommt. Dennoch ist für einen raschen Start der Rails-Ansatz klar vorzuziehen.

Design aus Scaffolding

In Rails ist das generierte Design aus dem Scaffolding Generator simpel gehalten. Damit ist es sinnvoll als Vorlage nutzbar.

In Grails ist der Aufwand, die ungewollten Teile zu löschen, oft größer als der Vorteil überhaupt erst ein Scaffolding für die Views zur Verfügung zu haben.

Rails Validations – Grails Constraints

Datenvalidierung passiert in Rails lediglich auf Applikationsebene.

Grails hinterlegt zusätzlich Datenbank-Constraints. Während letzteres definitiv als Best-Practice anzusehen ist, führt es wiederum zu Problemen welche die Vorteile nichtig machen.

Im Rahmen eines Grails Feature-Request wurde ein case-insensitive Constraint gefordert, der in quasi jeder Webapplikation zumindest für E-Mail Adressen notwendig ist. Die Idee wurde mit der widersprüchlichen Begründung abgelehnt, dass die Anforderung zu stark von der verwendeten Datenbank abhängen würde.

Während eine manuelle Implementierung in Grails via .withNewSession zu weiteren Verkomplizierungen bei Unit-Tests führt, bietet Rails standardmäßig die notwendige Flexibilität. Die folgende Definition erfüllt die Anforderung:

:uniqueness => { :case_sensitive => false }

Applikations-URL in Entwicklungsumgebung

In Rails kann die Applikation unter http://localhost:3000 abgerufen werden, während Grails zusätzlich den Applikationsnamen erfordert (http://localhost:8080/grailsapp).

Der kleine Vorteil der Rails Variante ist, dass nur ein Lesezeichen im Browser ausreicht um die jeweils in Entwicklung befindliche Applikation aufrufen zu können.

Grails hat den zusätzlichen Nachteil dass bei Falschschreibung des Applikationsnamens in der URL eine komplett leere Seite erscheint.

Als Konsequenz suchte ein Entwickler unnötig nach einem Fehler als der Applikationsname von Klein- auf Großschreibung geändert.
Das entsprechende Lesezeichen war ungültig geworden.

Scaffolding Formulare

In Rails wird für die generierte edit- und new-Action auf das gleiche Formular-Template (“partial”) zurückgegriffen, was im Großteil der Webapplikationen gewünscht ist und den Quellcode DRY hält.

Grails hingegen generiert für beide Actions jeweils eigene Formulare welche man erst mühevoll zusammenführen muss, um dem DRY-Prinzip folgen zu können.

Log Ausgaben

Das Logging in Rails beinhaltet die tatsächlichen Werte. Fehler in SQL Anweisungen können somit rasch gefunden werden.
(Besonders interessant in diesem Zusammenhang ist die Unterstützung für EXPLAIN.)

In Grails fehlen die Werte – stattdessen sind nur Fragezeichen sichtbar.

Festlegung von “variablen” Constraints

Constraints werden in Grails nur beim Start evaluiert.

Legt man beispielsweise fest, dass eine Datumsfeld nur ein Datum vom aktuellen Tag oder davor beinhalten darf, wird für die Auswertung der Tag des Starts der Webapplikation (!) genutzt. Ein entsprechender Bug-Report beschreibt das Problem.

In Rails kann die Aufgabenstellung mittels eines lambda gelöst werden.

Generell ist das Arbeiten mit Datumseinträgen in Grails schrecklich komplex – auch wenn man Joda Time zur Vereinfachung einsetzt.

Definition von Models

Die entsprechende Grails Syntax hierfür ist einfach gestaltet. Beispielsweise kann ein Datenbankfeld auf Basis einer selbst definierten Klasse definieren (MyClass fieldname). Grails kümmert sich dann intern um die entsprechende “Übersetzung” auf Datenbankebene.

Das in diesem Fall etwas irreführende Schlüsselwort “belongs_to”, welches bei Rails zum Einsatz kommt, ist oft schwieriger nachzuvollziehen aber letztendlich flexibler.

Methoden: Rückgabewert oder Veränderung des Objekts?

Dieser Punkt ist eher ein Vergleich “Ruby vs. Java” als “Rails vs. Grails”.

In Java ist kaum erkennbar, ob eine Methode das aufrufende Objekt ändert oder nur einen entsprechenden Rückgabewert liefert. Man bedient sich hoffnungsvoll der Logik oder muss in den Dokumentationen nachsehen.

Ein Rufzeichen am Ende eines Methodennamens deutet in Ruby-Konvention auf eine Änderung des aufrufenden Objekts hin – oder verlangt eine Exception im Fehlerfall.

Massen-Zuweisung von Werten

Mass-Assignment birgt das Risiko in sich, Benutzern versehentlich das beliebige Befüllen von Datenbankfeldern zu erlauben auf welche der Zugriff eigentlich verwehrt ist.

In Grails vermeidet man das Risiko grundsätzlich nur durch Verzicht auf die Funktionalität.

Rails bietet eine sichere Lösung:

config.active_record.whitelist_attributes = true

Constraints für E-Mail Adressen

Fern man auf ein entsprechendes Plugin verzichtet, muss man in Rails die Validierung von E-Mail Adressen selbst definieren. Je nachdem wie streng man RFC-Konformität anstrebt, kann sich das Unterfangen sehr komplex gestalten.

Grails bietet hingegen einen email-Constraint.

Stacktraces

In Rails sind die Stacktraces generell kürzer. Fehlermeldungen sind aus bisheriger Erfahrung stets deutlich und ermöglichen ein rasches Finden und Beheben von Fehlern.

Grails ist zum Großteil in Java geschrieben (!). Dadurch werden die Stacktraces weit länger und es ist oft unklar ob man mit einem Fehler in der Applikation oder im Framework selbst konfrontiert ist.

Weit schlimmer ist allerdings dass man für die Nutzung von Grails zwei Sprachen beherrschen muss: Groovy und Java.
Dabei ist sind die Anforderungen an Java-Fertigkeiten besonders hoch.

Rails ist ausschließlich in Ruby implementiert. Es ist unnötig C Quellcode zu lesen.
(Obgleich die Ruby-Standardimplementierung selbst in C geschrieben ist.)

Tests und Test-Driven Development

Tests laufen in Rails schneller als in Grails.

Besonders wichtig ist, dass man in Rails die Tests auch jederzeit starten kann während man den Webserver in der Entwicklungsumgebung (localhost:3000) betriebt.

In Grails scheitert dies. Entweder der Entwicklungsserver oder die Tests laufen.

Routing und erlaubte Requests

In Rails bestimmt das Routing, also die Rake Middleware, welche Request-Arten (GET, DELETE, POST, PUT) für welche Action erlaubt sind.

In Grails muss man dies explizit abfangen um die Applikation zusätzlich abzusichern oder eine unterschiedliche Handhabung zu erreichen.

Flexibilität des Datenbankmodells

Rails Migrations sind für uns der Vorteil von Rails. Sie ermöglichen eine flexible Entwicklung. Ruhigen Gewissens kann man eine Struktur nutzen und, sollte sich heraus stellen das ein Ansatz ungünstig war, rasch auf eine andere Modellierung wechseln.

Ein Grund warum unser Projekt auf Grails-Basis über den Entwicklungszeitraum hinweg offline blieb, war die Sorge das gröbere Änderungen am Datenmodell einen großen Mehraufwand beim manuellen Migrieren erfordern würden.

Mit den Migrations von Rails ist diese Sorge gänzlich beseitigt.

Arbeit mit Datum und Uhrzeit

Viele Date-Funktionen in Java (Grails) sind zu Gunsten des unnötig komplexen Calendar-Konzepts überholt (deprecated). Joda Time vereinfacht den Umgang ein wenig, führt aber andererseits auch zu Schwierigkeiten und notwendigen Konvertierungen vor dem Speichern in die Datenbank.

Die Einfachheit der Ruby/Rails Methoden spricht für sich selbst:

x = 5.hours.from_now
year = x.year
currently_open = Time.now.between? opens_at, closes_at

Auslesen der Instanzvariablen des Controllers

In Rails können mittels der assigns() Methode die im Controller gesetzten Instanzvariablen “von Außen” abgefragt werden. Das ermöglicht ausgesprochen einfache funktionale Tests. Folgendes Beispiel prüft ob die Anzahl der aufgelisteten Aktivitäten mit der Anzahl in der Datenbank überein stimmt.

activities_count = 3
# 3 Aktivitäten erstellen
activities_count.times do
  FactoryGirl.build(:activity)
end

# Anzahl der Aktivitäten aus index-action überprüfen
get :index
assert_equal activities_count, assigns(:activities).count

In Grails hingegen ist uns nur die komplizierte Möglichkeit über GUI-Selektoren bekannt. Der Aufwand für derartige Tests spricht aber selten dafür, sie auch tatsächlich einzusetzen (vgl. Beitrag zu Geb Functional Testing).

Hilfreiche Fehlermeldungen

Fehlermeldungen in Rails sind oft überraschend ausführlich. Folgendes Beispiel zeigt eine klare Formulierung. Sie beinhaltet sogar Vorschläge zur Korrektur (!) und eine passende Vermutung:

ActiveRecord::HasManyThroughSourceAssociationNotFoundError: Could not find the source association(s) :subscribed_activity or :subscribed_activities in model Subscription. Try ‘has_many :subscribed_activities, :through => :subscriptions, :source => ’. Is it one of :subscriber or :activity?

In Grails folgt man oft der falschen Fährte.

JavaScript standardmäßig unaufdringlich

In Rails wird JavaScript standardmäßig “unaufdringlich” (unobstrusive) gehalten.

Möchte man JavaScript in einer Grails Applikation unobstrusive halten, muss man auf die Unterstützung durch das Framework verzichten und die entsprechenden Funktionen selbst programmieren.

Vorkompilierte Klassen

Nur in seltenen Fällen ist in Rails während der Entwicklung ein Neustart der Applikation erforderlich – beispielsweise nach dem Hinzufügen neuer Plugins (Gems).

Ansonsten ist es allerdings sogar möglich den aktuellen Entwicklungsstand aus einem Repository zu ziehen (git pull) ohne Schwierigkeiten erwarten zu müssen.
Ein gesonderter Säuberungslauf ist unnötig.

In Grails kommt es regelmäßig vor, dass sonderbare Probleme wie aus dem Nichts auftauchen zu scheinen. Aus Erfahrung weiß man später, dass nur ein Säuberungslauf Abhilfe schaffen kann. Im Detail bedeutet das:

Applikation stoppen
Säubern (grails clean)
Applikation starten (grails run-app)

Der Ablauf kann je nach Umfang der Applikation mehrere kostbare Minuten beanspruchen.

Das Grails-Plugin N.A.D.D. Neutralizer unterstreicht die Ironie:

This plugin will use text to speech to tell you when key events in your build are complete. So say you are like me with a project that takes several minutes to start after grails run-app. You can, guilt-free, go browse your favorite sites without worrying about getting caught up in something. When your app is up and running, this plugin announces on your speakers, “Application is running!”

Alleine die Existenz eines solchen Plugins sollte skeptisch machen.

Plugin-Infrastruktur

Die Verwaltung von Gems in Rails ist dank Bundler sehr einfach.

Die Grails Plugin-Infrastruktur ist sehr streng und erlaubt den Entwicklern Kompatibilitätsanforderungen zu hinterlegen. Da diesen für gewöhnlich unbekannt ist, mit welchen Versionen ihr Plugin funktioniert, tragen sie oft sonderbare Grenzen ein. Umerziehungsmaßnahmen seitens der Grails Advokaten schlagen fehl und so passieren Dinge wie das folgende:

Quartz am 22.04.2012:

| Error Plugin quartz-1.0-RC1 requires version [1.2 > 1.3.7] of Grails which your current Grails installation does not meet. Please try install a different version of the plugin or Grails.

In diesem Beispiel stand keine andere Version des Plugin zur Verfügung. Allerdings ist davon auszugehen, dass die Versionsobergrenze (1.3.7) schlichtweg falsch gesetzt war und das Plugin durchaus auch mit der Grails Version 2 kompatibel wäre.

Speicherverbrauch

Für die Grails Entwicklung sollten mindestens 1,6 GB freier Hauptspeicher zur Verfügung stehen.

Rails ist mit einer Anforderung von rund 800 MB nur halb so gierig.

Im Folgenden ist die Aufteilung der Ressourcen beschrieben.

Frameworks

Der Rails Serverprozess (WEBrick) beansprucht 75 MB Hauptspeicher.

Die Grails Applikation mit ähnlichem Funktionsumfang benötigt mit 800 MB das Zehnfache (!)

Entwicklungsumgebungen

Sowohl RubyMine (für Ruby/Rails) als auch IntelliJ IDEA (für Java/Groovy/Grails) werden vom tschechischen Unternehmen JetBrains entwickelt. Es kann also davon ausgegangen werden, dass die Qualität der beiden Entwicklungsumgebungen auf ähnlichen Niveau befindet.

Der Speicherverbrauch von IntelliJ IDEA (Grails) mit gestarteter Applikation liegt laut eines kurzen Tests bei 780 MB.
RubyMine (Rails) verbraucht rund 600 MB.

Von einer Entwicklung mit SpringSource STS (Eclipse) oder NetBeans ist übrigens abzuraten. Beide bieten in Bezug auf die Grails Entwicklung kaum Vorteile. Ein guter Texteditor ist vorzuziehen.

HTML via content_for

Mit Methoden wie content_for(), bietet Rails elegante Möglichkeiten um HTML zu generieren. View Helper bleiben übersichtlich und sicher.

Vergleichbares könnte man in Grails theoretisch mittels der Builder erreichen, aber letztendlich ist dort das manuelle Zusammenstückeln der Elemente noch der sinnvollste Weg.

HTML Escaping

In Rails werden View Ausgaben (<%= ... %>) standardmäßig maskiert (escaped). Dadurch werden viele potentielle Angriffspunkte wie XSS geschlossen.
(Tipp: Benennt man einen Übersetzungsstring in einer i18n-Datei mit der Endung _html weiß Rails automatisch, dass für den hinterlegten Text das Escaping ausgesetzt werden soll)

Ein Grails-Projekt sollte man mit der entsprechenden Konfiguration absichern:

grails.views.default.codec = "html" // none, html, base64

Array Zugriff

In Groovy (Grails) wird eine Exception ausgelöst, wenn der abgefragte Bereich die größe des Arrays übersteigt. In einem Beispiel wie diesem muss man zuerst die Gesamtlänge abfragen, um dann entsprechend “korrekt” zugreifen zu können: "123"[0..10]

In Ruby (Rails) spart man sich die Abfrage. Im obigen Beispiel erhält man einfach “so viel wie möglich” – also das Array von 0-2.

Case insensitive scoped uniqueness

In diesem Grails Beispiel wird sichergestellt, dass ein Veröffentlicher ( scope ) keine Events mit gleichem Titel ( uniqueness ) veröffentlicht. Dabei soll Groß-/Kleinschreibung ignoriert werden ( case-insensitive ).

title (nullable: false, blank: false, unique: false, size: 5..30,
	validator:  { val, obj ->	(
			/* checks if the publisher has published an event with the exact same title (case-insensitive match) */
			!Event.withNewSession {	// if the get() returns an event, then this is an update - which is fine
				!Event.get(obj.id) &&  Event.findAllByTitleIlikeAndPublisher(val, obj.publisher)
			}
	)}
)

Das Gleiche in Rails:

validates :title, :length => { :in => 5..30 },
          :uniqueness => { :case_sensitive => false, :scope => :publisher_id }

Variablenübergabe an Views

Alle Instanzvariablen (@variblenname) aus der entsprechenden Action sind in Rails von der View aus verwendbar.

In Grails muss Alles in Form einer Map explizit aus dem Controller übergeben werden.

Counter-Cache

Um die Anzahl der zugehörigen Objekte zu finden stellt Rails die counter_cache Funktionalität bereit. Per Konvention wird bestimmt welches Feld benutzt werden soll.

Möchte man in Grails vermeiden bei jedem Aufruf ein SQL COUNT() abzusetzen, müsste eine ähnliche Funktionalität mittels diverser Interceptors manuell implementiert werden.

“Kleinigkeiten” wie diese zeigen vor allem auf, wie weit Rails bereits in den Details durchdacht ist, während Grails beständig “am Anfang” stehen zu scheint.

Fazit

Grails mag dank Groovy für Java-Veteranen (!) eine Erleichterung bieten. Als Framework ist es allerdings weit von den dem entfernt was die Eigenwerbung verspricht.

Für agile Web-Entwicklung und das schnelle Erreichen von Releases ist es schlicht ungeeignet.

Rails hingegen scheint sämtliche Best-Practices in der Web-Entwicklung zu vereinen und als Standard vorzulegen.

Der Arbeitsverlauf steckt voller positiver Überraschungen und das Endergebnis kann sich sehen lassen.

Shell-Kommando zum raschen Ändern der Jekyll-Post Front Matter

2012-08-16T00:00:00+02:00

In der Jekyll YAML Front-Matter werden Eckdaten wie der Titel des jeweiligen Artikels hinterlegt. Welche weiteren Informationen benötigt werden, hängt unter anderem von den verwendeten Jekyll-Plugins ab.

Batch-Ändern von Einträgen in der Jekyll-Post YAML Front Matter

Achtung: Im folgenden Beispiel wird die Originaldatei mit neuer Endung gesichert. Allerdings überschreibt ein erneutes Ausführen des Kommandos diese Sicherung wieder!

# Die Kategorie sämtlicher Jekyll-Posts im aktuellen Verzeichnis
# auf den Namen des aktuellen Verzeichnisses abändern:
sed --in-place=_with-previous-category "s/^category:.*$/category: \"${PWD##*/}\"/g" *.textile

# Schlagworte in der Jekyll-Post Front Matter abändern:
sed --in-place=_with-previous-tags "s/^tags:.*\]$/tags: \[${PWD##*/}\]/g" *.textile

sed(1)

Weitere Informationen zu ${PWD##*/} finden sich in dieser Stackoverflow-Antwort.

Meistgewünscht? Umgesetzt!

2012-08-16T00:00:00+02:00

Übersichtlichkeit verbessert

Aufteilung der Doos auf mehrere Seiten

Bisher wurden Doos einfach in einer Liste angezeigt, welche mit jedem Eintrag wuchs.
Nun sind sie in Seiten zu je 10 Aktivitäten unterteilt.

Aktuelle und künftige Doos bevorzugt

Sinnvollerweise wollten einige von euch lediglich aktuelle und künftige Doos in der Auflistung sehen. Erledigt.

Mit einem raschen Klick auf “Stöbern” findet man nun an erster Stelle das zeitlich näheste Doo.

Zwischen vergangenen und künftigen Aktivitäten wechselt man über den entsprechenden Filter.

Registrierungsablauf verständlich gestaltet

Die Registrierungsseite ist mit den drei Feldern Benutzername, E-Mail Adresse & Passwort tatsächlich etwas ungewöhnlich.

Das eine einmalige Angabe des Passworts ausreicht, sorgte für Verwirrung und verhinderte bei einigen das erfolgreiche Erstellen eines Corilla-Kontos.

Nun erscheint unter jedem Feld ein Hinweis der den jeweiligen Zweck verdeutlicht.

Sollte dich das gleiche Problem bisher von der Registrierung abgehalten haben, kannst du sie jetzt nachholen:

Klicke jetzt hier um dich bei Corilla zu registrieren!

Viel Spaß & Schöne Grüße!
<<>>

In KDE (Kubuntu) auf Dateien des Samsung Galaxy Note zugreifen

2012-08-14T00:00:00+02:00

(Der hier beschriebene Ablauf funktionert wahrscheinlich bei unterschiedlichen Android-Geräten)

Schließt man ein Samsung GT-N7000 (Note) per USB an den Kubuntu Rechner, wird standardmäßig das Media Transfer Protocol (MTP) für den Datenaustausch verwendet.

Zumindest in Ubuntu 11.04 & 12.04 führt dies scheinbar zu Problemen.
Man kann lediglich die Verzeichnisse sehen, während die Dateien selbst unsichtbar bleiben.
Auch im PTP-Modus ist die Nutzung unmöglich.

Die dritte Variante, das Gerät als USB-Massenspeicher einzubinden, war in früheren Android Versionen Standard und funktionierte mit Kubuntu einwandfrei.
In Android 4.0 (Ice Cream Sandwich) ist diese Möglichkeit nach wie vor vorhanden. Allerdings ist sie gut versteckt.

Galaxy Note als USB-Massenspeicher einbinden

Um das Galaxy Note als USB-Massenspeicher einzubinden, geht man wie folgt vor:

USB-Kabel vom Telefon abschließen
Unter Einstellungen > Mehr… > USB-Verbindung die Schaltfläche Speicher mit PC verbinden berühren
USB-Kabel anschließen
Schaltfläche Speicher mit PC verbinden berühren
Die folgende Warnung mit OK bestätigen

Nun kann man das Gerät wie gewoht in KDE einbinden und wie ein gewöhnliches Speichermedien nutzen.

Lokale PostgreSQL Datenbank für Rails Entwicklung einrichten

2012-07-26T00:00:00+02:00

# PostgreSQL Datenbankdienst und Header/Library installieren
sudo apt-get install postgresql libpq-dev
# Benutzer mit Berechtigung zum Anlegen neuer Datenbanken erstellen
sudo -u postgres createuser -U postgres -dRS `whoami`

-d entspricht --createdb
-R entspricht --no-superuser
-S entspricht --no-createrole

createuser(1)

Bei Bedarf kann man den erstellten Benutzer mit folgendem Befehl wieder entfernen:

sudo -u postgres dropuser `whoami`

dropuser(1)

Corilla sagt Hallo!

2012-07-04T00:00:00+02:00

Corilla erblickt das Licht der Welt. Und umgekehrt.

Seit wenigen Sekunden ist Corilla online.

Die Plattform startet heute in die Beta-Testphase.

Das bedeutet, dass ich trotz intensiver Bemühung keine gravierenden Fehler mehr auslösen konnte. Jetzt darfst du’s versuchen!

Wie?

Melde dich einfach bei Corilla an und verwende die Plattform frei nach Belieben. Über gröbere Fehler informiert mich Corilla automatisch. Kleinere Dinge, die dich ärgern, oder dir fehlen, kannst du per Kontaktformular mitteilen.

Ein Doo, viele Doos?

Bei Corilla heißt eine Aktivität kurz ‘Doo’.
Zum heutigen Stand ist der Funktionsumfang auf das Grundkonzept der Plattform begrenzt: Doos einstellen, Doos durchstöbern.

Die ersten Monate der Entwicklung wurden vor allem zur Schaffung eines starken Fundaments genutzt.

Corilla ist schnell, umfangreich getestet und für Suchmaschinen optimiert. Und, wie man so hört, ausgesprochen attraktiv.

Derzeit keine Unterstützung für Internet Explorer

Falls du Internet Explorer verwendest, wirst du von ‘attraktiv’ wenig mitbekommen, denn in diesem Browser ist das Design noch ganz zerschossen.
(Je älter deine Version, desto lustiger der Effekt.)
… aber wer verwendet schon noch Internet Explorer?

Reservierte Benutzernamen

Einige von euch haben sich schon vorab Benutzernamen reservieren lassen. Falls das auch bei dir der Fall sein sollte, melde dich bei Corilla zuerst mit einem anderen Namen an und gib mir dann Bescheid.
Ich ändere ihn dann auf deinen Wunschnamen.

Genug geredet

Klicke jetzt hier um Corilla zu besuchen!

Lass dir dabei ruhig Zeit – Ich folge derweil Corilla’s Leitspruch “Geh raus & fang an!” und gehe jetzt ein Bisschen verrückt feiern .

Viel Spaß & Schöne Grüße!
<<>>

Für die Neuankömmlinge – Hier der Link zum Nachlesen der ersten Nachricht:
Corilla Insider Infos Ausgabe #1: ‘Gerade noch rechtzeitig’

Gerade noch rechtzeitig

2012-07-02T00:00:00+02:00

… zumindest nach Winterzeit. In London.

Es hat ein bisschen länger gedauert, das versprochene Video zu erstellen. Somit kommt auch diese E-Mail verspätet an. Mittlerweile sind 28 Empfänger für die Corilla Insider Infos angemeldet – weit mehr als ich so kurzfristig erwartet hätte. Freut mich.

Worum geht’s?

Erstmals in der Schulzeit hatte ich die Idee eine Webplattform zu schaffen, welche die Menschen beim Koordinieren gemeinsamer Aktivitäten unterstützt. Vor zwei Jahren griff ich diese Idee wieder auf und nun, viele Stunden und Erfahrungen später, ist Corilla bereit für die Welt.

Das Konzept ist simpel:

Wer etwas Interessantes geplant hat und noch andere dabei haben möchte, kann die Informationen dazu auf Corilla veröffentlichen.
Wer für einen bestimmten Zeitraum noch etwas zu tun sucht, kann die veröffentlichten Infos anderer durchstöbern und sich anschließen.

Genau diese Grundanforderung erfüllt Corilla zum aktuellen Entwicklungsstand: Aktivitäten einstellen, Aktivitäten heraussuchen.

Hunderte weitere Ideen die ich selbst gerne in Corilla umgesetzt sehen möchte, sind bereits notiert. Und weil das Internet so schnelllebig ist, mache ich die Plattform bereits diese Woche – voraussichtlich in der Nacht von Mittwoch auf Donnerstag – für jeden zugänglich.

Das erlaubt mir, flexibel auf Wünsche zu reagieren und Corilla von Anfang an in eine Richtung zu entwickeln, die für die Nutzer den größten Wert bringt.

Mit deiner Anmeldung zu den Corilla Insider Infos bist du Teil des “eisernen Kerns der ersten Stunde” geworden.
Du wirst als Erster erfahren, wenn Corilla online ist und ich finde es richtig, dich generell ein Bisschen zu bevorzugen :)

Als erstes Goodie, gibt es hier ein Video, in dem ich mich im Zeitraffer durch die ersten fünf Monate der Corilla-Entstehung beame – untermalt mit genialer Mukke von K-OS. Es soll dir die Wartezeit bis zum Corilla-Start ein Bisschen versüßen.

Klicke hier um das Video ‘Corilla: Die ersten fünf Monate’ anzusehen
(Jede Kugel steht für eine Datei.)

Viel Spaß & Alles Gute!
<<>>

6 Vorteile von FreeBSD im Serverbetrieb

2012-05-30T00:00:00+02:00

Diese Vorteile fehlen zum Großteil in anderen Betriebssystemen und räumen somit FreeBSD als Betriebssystem im Serverbereich eine besonders interessante Position ein.

Jails !
- effiziente “Virtualisierung”
Zuverlässiger Update-Verlauf mit minimaler Downtime
- Sichere Aktualisierung von Konfigurationsdateien durch manuelles Zusammeführen
- lediglich zwei Reboots notwendig
Snapshots bei UFS / FFS und ZFS
- rasche Sicherungen vor dem Ausführen ungeübter Operationen
fsck im Betrieb
- konsistente Dateisystemzustände ohne Neustart
Das FreeBSD-Handbuch
- Schnelles Finden von Best-Practices
Z-Dateisystem (ZFS)
- ZFS Pool verhindert zu viel Platz auf der einen Partition zu haben der auf der anderen fehlt.
- ZFS Replikation ermöglicht einfaches Spiegeln und rasches Sichern

Die Liste ist nach unserer subjektiven Relevanz sortiert und mit einer Anmerkung versehen welche beschreibt warum eine Funktionalität für uns wertvoll ist.

Git Repositories zusammenführen (git pull)

2012-04-09T00:00:00+02:00

Mittels git pull kann man ein Git Repository in ein anderes ziehen und so beide zu einem zusammenführen. Die Historien beider Git-Repos bleiben dabei erhalten:

cd /pfad/zum/ersten_git_repo/
git pull /pfad/zum/zweiten_git_repo/

git-pull(1) führt dabei ein git fetch gefolgt von einem git merge aus.

In git log kann man nun die Historie beider Projekte sehen – und einen zusätzlichen commit der das soeben durchgeführte merge darstellt.

In ein Unterverzeichnis ziehen

Mit obigem Ansatz landen sämtliche Dateien des zweiten Git-Repositories im Hauptverzeichnis des ersten. Um das zu vermeiden, kann man zuerst im zweiten Repository die Dateien in ein Unterverzeichnis verschieben:

cd /pfad/zum/zweiten_git_repo/
mkdir verzeichnis_zweites_repo
# -k sorgt dafür, dass der Befehl trotz Warnung des mv-Kommandos durchgeführt wird:
git mv -k * verzeichnis_zweites_repo
git commit -m 'moved all files into subdirectory verzeichnis_zweites_repo'
# an dieser Stelle dieses Repository in das erste ziehen (siehe erstes Listing dieses Artikels)

Rückwirkend in ein Unterverzeichnis ziehen

In der aktuellen Revision liegen die Dateien dann zwar im korrekten Unterverzeichnis. In der Historie sind sie jedoch nach wie vor im Hauptverzeichnis zu finden.

Diesen Nachteil kann man vermeiden, indem man git filter-branch zum Verschieben in das Unterverzeichnis nutzt.

Achtung: git filter-branch ändert die Historie. Siehe dazu diesen Hinweis aus der git-filter-branch(1) Manpage:

WARNING! The rewritten history will have different object names for all the objects and will not converge with the original branch. You will not be able to easily push and distribute the rewritten branch on top of the original branch. Please do not use this command if you do not know the full implications, and avoid using it anyway, if a simple single commit would suffice to fix your problem.

cd /pfad/zum/zweiten_git_repo/
git filter-branch --tree-filter 'mkdir .temp; mv * .temp' HEAD
git filter-branch -f --tree-filter 'mv .temp verzeichnis_zweites_repo' HEAD
# an dieser Stelle dieses Repository in das erste ziehen (siehe erstes Listing dieses Artikels)

Unterverzeichnisse ohne Eingriff in das zweite Git-Repository?

Ich könnte mir vorstellen, dass etwas Ähnliches direkt mit git pull umsetzbar ist ohne das zweite Repository verändern zu müssen.

Solltest Du eine solche Möglichkeit kennen, freue ich mich über einen entsprechenden Hinweis in den Kommentaren.

Amarok 2 im Oldschool-Amarok 1 Stil gestalten

2012-02-15T00:00:00+01:00

In KDE3 gefiel mir ganz besonders die optische Gestaltung des Musikwiedergabeprogramms Amarok. Das Design ließ den Inhalten ausreichend Platz und das dunkle Funky Monkey Farbschema verlieh dem Player einen einzigartigen Charakter.

Amarok 2 in KDE4 ist lieblos und plump gestaltet. Die einzelnen Elemente des Wiedergabeprogramms verschwenden unnötig Platz und verdrängen das Wichtigste: Die Wiedergabeliste

KDE ist flexibel

Zurecht ist KDE seit jeher für seine Anpassbarkeit bekannt und so bieten sich bei Amarok 2 ausreichend Möglichkeiten um auch in der neuen Version den Stil von Amarok 1 weitgehend zu imitieren.

In Amarok 2.4.3 müssen drei Bereiche umgestaltet werden:

Aufbau und Inhalt der Wiedergabeliste
Anordnung der einzelnen Elemente
Hauptfenster schlank gestalten

Aufbau und Inhalt der Wiedergabeliste gestalten

Die Wiedergabeliste kann unter Wiedergabeliste > Ansichten > Ansichten einrichten … gestaltet werden. Meine fertige Zusammenstellung kann hier kopiert werden:

<!DOCTYPE layouts>
<playlist_layouts>
 <layout group_by="None" tooltips="true" name="Amarok 1.4.9">
  <single_track active_indicator_row="0" show_cover="false">
   <row>
    <element suffix="" prefix="" size="0" bold="false" alignment="center" value="Play count" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0.3" bold="false" alignment="left" value="Title" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0.15" bold="false" alignment="left" value="Artist" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0.15" bold="false" alignment="left" value="Album" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="right" value="Year" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="center" value="Track number" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="center" value="Bitrate" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0.25" bold="true" alignment="center" value="Moodbar" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="center" value="Rating" underline="false" italic="false"/>
   </row>
  </single_track>
  <group_head active_indicator_row="0" show_cover="false"/>
  <group_body active_indicator_row="0" show_cover="false">
   <row>
    <element suffix="" prefix="" size="0.5" bold="true" alignment="left" value="Title" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="left" value="Artist" underline="false" italic="true"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="right" value="Length" underline="false" italic="false"/>
   </row>
  </group_body>
  <group_variousArtistsBody active_indicator_row="0" show_cover="false">
   <row>
    <element suffix="" prefix="" size="0.5" bold="true" alignment="left" value="Title" underline="false" italic="false"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="left" value="Artist" underline="false" italic="true"/>
    <element suffix="" prefix="" size="0" bold="false" alignment="right" value="Length" underline="false" italic="false"/>
   </row>
  </group_variousArtistsBody>
 </layout>
</playlist_layouts>

Obige Definition in eine Textdatei namens Amarok 1.4.9.xml im Verzeichnis $HOME/.kde/share/apps/amarok/playlist_layouts/ kopieren
Amarok neustarten
- killall --wait amarok && amarok
Wiedergabeliste > Ansichten > Amarok 1.4.9 wählen

Anordnung der einzelnen Elemente optimieren

Ansicht > Ansicht sperren deaktivieren
Kontext auf Medienquellen positionieren
- Dies erstellt automatisch einen Reiter der das Umschalten zwischen den beiden Ansichten ermöglicht.
Wiedergabeliste rechts davon einordnen
Ansicht > Schmale Werzeugleiste aktivieren
Ansicht > Ansicht sperren aktivieren

Fenster schlanker machen

Dieser Schritt ist optional. Allerdings wäre es schade gerade auf eine der Hauptstärken des K Desktop Environment zu verzichten.

Fenster-Umrandung entfernen: Alt+F3 > Erweitert [W] > Keine Umrandung [K]
Fenster neu positionieren: Alt+F3 > Verschieben [V]
Fenstergröße anpassen: Alt+F3 > Größe ändern [G]

Unter folgendem Punkt können diese Einstellungen auch permanent festgelegt werden:
Alt+F3 > Erweitert [W] > Spezielle Einstellungen für dieses Fenster … [F]

Wo ist der Funky Monkey?

Amarok 2 übernimmt immer das aktuell eingestellte Farbschema der Desktopumgebung.

Es gibt Möglichkeiten ein eigenes Farbschema zu setzen, welches dann ausschließlich für das Wiedergabeprogramm verwendet wird. Diese Möglichkeiten bringen allerdings diverse Nachteile mit sich, weshalb ich davon abrate sie zu verfolgen und im Rahmen dieser Beschriebung vernachlässige.

Bei Bedarf veröffentliche ich das entsprechende Farbschema für KDE4 mit einigen Hinweisen zu den Umsetzungsvarianten.

WordPress Netzwerk-Seite in 9 Schritten zu neuem Server migrieren

2011-10-13T00:00:00+02:00

Anhand dieses Ablaufs kann eine WordPress Netzwerkinstallation ( Multisite ) von einem zum anderen Server migriert werden.

Am Zielsystem
1. Mapped-Domains definieren
2. WordPress Tables löschen
Am Quellsystem
1. Kommentare sperren
2. Verwaltungsmodus ( Maintenance Mode ) aktivieren
Am Zielsystem
1. Dateien von Quellsystem ziehen (via rsync; inkl. chown -R www:www ./)
2. Datenbank von Quellsystem ziehen (via mysqldump und mysql)
3. wp-config.php anpassen
Am Arbeitsplatzrechner
1. Zielsystem via /etc/hosts Eintrag testen
Bei Domainregistrar
1. DNS-Einträge (inkl. Mapped Domains) hinterlegen

Der Fokus dieser Vorgehensweise liegt darauf, sowohl Downtime und Aufwand gering zu halten.

Ist die Verfügbarkeit besonders kritisch, sollte auf eine Variante mit Datenbankreplikation zurückgegriffen werden.

WAVE-Audiodateien aus .bin/.cue extrahieren

2011-09-28T00:00:00+02:00

The Nameless Mod ist als eines der besten Mods für das Kultspiel Deus Ex bekannt.

Der Soundtrack zum Spiel steht auf der Projektseite kostenlos als Archiv zum Download bereit. Das Archiv enthält zwei CD’s als Speicherabbild/Cuesheet-Kombination (Dateiendungen .bin und .cue).

Einzelne Dateien als FLAC oder OGG fehlen, um die Fans zu animieren, die CD zu bestellen und mit dem Kauf die Entwickler zu unterstützen.

Audio-Dateien direkt auslesen anstatt auf CD brennen

Möchte man die Audiotracks dennoch lieber direkt speichern anstatt sie auf CD zu brennen, kann man mit dem Programm bchunk(1) die einzelnen Tracks direkt als WAV-Dateien (Waveform Audio File Format – Dateiendung .wav) auslesen.

# bchunk-Installation in Ubuntu:
sudo apt-get install bchunk
# Auslesen der WAVE-Dateien im Verzeichnis 'Friendly Disc':
bchunk -w TNMOST_Friendly.bin TNMOST_Friendly.cue TNMOST_Friendly
# Auslesen der WAVE-Dateien im Verzeichnis 'Hostile Disc':
bchunk -w TNMOST_Hostile.bin  TNMOST_Hostile.cue  TNMOST_Hostile

Als Resultat erhält man fortlaufend nummerierte WAV-Dateien, welche nun beispielsweise mit flac(1) komprimiert und mittels krename(1) sinnvoll benannt werden können.

Übertragenes Datenvolumen von dd ausgeben STATUS/SIGINFO/SIGUSR1

2011-09-08T00:00:00+02:00

Während der Befehl dd läuft, kann man in diversen UNIX-Systemen wie FreeBSD durch Drücken von STRG+T Details ausgeben lassen:

# Testkommando inkl. Ausgabe nach Drücken von STRG+T
dd if=/dev/random of=/dev/null
load: 0.63  cmd: dd 53428 [running] 1.78r 0.01u 1.76s 16% 868k
153125+0 records in
153125+0 records out
78400000 bytes transferred in 1.788752 secs (43829439 bytes/sec)

Auch per kill beziehungsweise pkill kann die entsprechende Ausgabe erzielt werden:

# kill
set prozessid=`pgrep dd`
kill -INFO ${prozessid}

# pkill
pkill -INFO dd

kill(1), pkill(1)

Details zum STATUS Zeichen sind in termios(4) vermerkt.
Das INFO-Signal ist auf Wikipedia erläutert.

Status von dd in Linux ausgeben

In Linux kann dd mit dem Signal USR1 zur Ausgabe des aktuellen Status aufgefordert werden:

# kill
prozessid=`pidof dd`
kill -USR1 ${prozessid}

# pkill
pkill -USR1 dd

pidof(8), kill(1), pkill(1)

Watch & Kill

Um eine Ausgabe in regelmäßigen Abständen zu erhalten, kann das pkill-Kommando mit watch kombiniert werden:

watch -n 10 pkill -USR1 dd

watch(1)

Nähere Informationen zum Kommando finden sich im Blog Linux Commando.

WordPress Wartung: Verwaltungsbereich sperren

2011-08-24T00:00:00+02:00

Für WordPress existieren einige “Maintenance Mode”-Plugins, welche die komplette Seite sperren.

Oft möchte man während einer Wartung allerdings nur Änderungen an der Datenbank verhindern während die Seite für Besucher weiterhin angezeigt werden soll.

Der Artikel WordPress Maintenance Mode Without a Plugin Part 3 beschreibt den umgekehrten Ansatz – das Backend bleibt aktiv während Frontend Zugriffe verboten werden.

Dieser Ansatz muss also nur noch entsprechend angepasst werden, sodass lediglich das Backend gesperrt wird, während Frontend-Zugriffe weiterhin funktionieren.

WordPress Login Sperre einrichten

Dazu erstellt man im WordPress Hauptverzeichnis die Datei .maintenance mit folgendem Inhalt:

<?php
if ( stristr($_SERVER['REQUEST_URI'], '/wp-admin') || stristr($_SERVER['REQUEST_URI'], '/wp-login.php') )
	$upgrading = time();
?>

Möchte man die Meldung noch aussagekräftiger gestalten, kann man die Datei wp-content/maintenance.php erstellen. Beispielinhalt:

<DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" lang="de-DE">

	<?php $heading = 'Wartungsarbeiten - Maintenance' ?>

	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
		<link rel='stylesheet' id='login-css'  href='/wp-admin/css/login.css' type='text/css' media='all' />
		<link rel='stylesheet' id='colors-fresh-css'  href='/wp-admin/css/colors-fresh.css' type='text/css' media='all' />
		<title><?php echo $heading; ?></title>
	</head>

	<body>
		<div style="margin:0px auto; max-width:960px;" >
			<h1><?php echo $heading; ?></h1>
			<br/>
			<h2><em>DEUTSCH:</em> Administrationsbereich tempor&auml;r gesperrt</h2>
			<p>Aufgrund von Wartungsarbeiten d&uuml;rfen derzeit keine &Auml;nderungen vorgenommen werden. Daher ist der Zugang zur WordPress Verwaltungsoberfl&auml;che gesperrt.</p>
			<br/>
			<h2><em>ENGLISH:</em> Admin-Interface temporarly locked</h2>
			<p>Due to scheduled maintenance changes are currently disallowed. Thus login to the WordPress backend is denied. </p>
		</div>
	</body>

</html>

Das Beispiel bindet die gleichen CSS Dateien ein, wie das WordPress Anmeldeformular und sorgt somit für die Verwendung der bekannten Schriftart.

Es kann natürlich beliebig optimiert werden. Einge Möglichkeit wäre die Sprache je nach Locale des Besuchers zu setzen.

WAR Dateien in Tomcat 7 entpacken - unpackWARs

2011-08-24T00:00:00+02:00

Bereits in Vorgängerversionen ist Tomcat standardmäßig so konfiguriert, dass WAR Dateien beim Deployment entpackt werden.

Das ermöglicht unter anderem, statische Inhalte (CSS, JS, Bilder, …) über einen anderen Webserver bereit zu stellen.

Allerdings kann es unter gewissen Umständen passieren, dass nach dem Update auf Tomcat 7 Applikationen verpackt bleiben – obwohl unpackWARs oder unpackWAR gesetzt ist.

Wann bleibt unpackWARs in Tomcat 7 effektlos?

Ein Vergleich der Tomcat-Dokumentationen zu unpackWAR im Context Container-Abschnitt ‘Standard Implementation’ zeigt warum:

Wichtiger Unterschied: “Note that WAR files located outside of a Host’s appBase are never unpacked.”

Hat man also beispielsweise in der context.xml (oder ROOT.xml) einen Pfad außerhalb des laut server.xml definierten Hosts angegeben, so ist unpackWARs effektlos.

Beispiel

Inhalt von /usr/local/apache-tomcat-7.0/conf/Catalina/localhost/ROOT.xml

<Context docBase="/home/someuser/some-grails-app.war" path="" reloadable="true"/>

Lösung: Symlink zur Applikation in webapps Verzeichnis

Damit WAR’s wieder entpackt werden, kann man entweder die appBase in der Host-Definition anpassen oder man entfernt die ROOT.xml und setzt stattdessen einen entsprechenden Symlink:

# Verschieben der original ROOT-Applikation:
mv /usr/local/apache-tomcat-7.0/webapps/ROOT /usr/local/apache-tomcat-7.0/webapps/ROOT_orig
# Verlinken der Grails-Beispielapplikation als ROOT.war:
ln -s /home/someuser/some-grails-app.war /usr/local/apache-tomcat-7.0/webapps/ROOT.war

Der hier gesetzte Link sorgt dafür, dass die Grails Applikation mit dem Namen “some-grails-app” als ROOT-Anwendung entpackt und gestartet wird.

Liste kürzlich installierter Ports ausgeben

2011-08-10T00:00:00+02:00

ls -lcrt /var/db/pkg/*/+DESC

Quelle: installdate of a port/package?

Geb Starthilfe - Grails Functional Testing

2011-07-25T00:00:00+02:00

Mittels Unit- und Integration-Tests kann die Qualität einer Grails Web-Applikation zum Großteil sichergestellt werden.

Um eine Funktionalität aus Nutzersicht zu überprüfen ist eine andere Herangehensweise erforderlich: Man startet die Applikation und überprüft per Browser ob die verschiedenen Anwendungsfälle wie gewünscht durchgeführt werden können.

Um langfristig zu gewährleisten, dass die Funktionalität erhalten bleibt, müsste man die Schritte nach jeder weiteren Code-Änderung wiederholen.

Dies ist umständlich bis unmöglich und kann in Grails mittels Geb automatisiert werden.

Anwendungsfälle von funktionalen Tests

Es gibt unendlich viele Möglichkeiten durch eine Web-Applikation zu navigieren. Dementsprechend sinnlos ist der Versuch “möglichst Alles” zu testen.

Folgende Szenarien sind aus meiner Sicht für “functional testing” interessant:

Sicherstellung von Kern-Funktionalität

Die Durchführbarkeit, zumindest jener Anwendungsfälle ohne welche die Web-Applikation nutzlos werden würde, kann gut über funktionale Tests sichergestellt werden.

Planung von Usability-Tests

Bei der Planung von Tests der Benutzerfreundlichkeit kann man den idealen Ablauf zur Lösung der Aufgabe definieren und damit sicherstellen, dass zumindest dieser Weg zum Zeitpunkt des Tests mit dem Teilnehmer funktionieren wird.

Regressionsvermeidung

Regressionen – für mich einer der Hauptgründe überhaupt Tests zu schreiben.

Für jeden gefundenen Programmfehler wird ein Test geschrieben, welcher diesen Fehler reproduziert. Dann implementiert man die Lösung so, dass der Test erfolgreich verläuft – natürlich ohne dabei den Test zu ändern.

Somit wird eine Applikation langfristig immer “besser”, da sich ein bereits gefundener Bug unmöglich erneut in das Programm einschleichen kann.

Starthilfe zur Geb-Entwicklung

Wie der Titel der offiziellen Dokumentation, “The Book of Geb”, vermuten lässt, ist Geb ist umfangreich dokumentiert.

Zumindest das Einführungskapitel solltest du an dieser Stelle gelesen haben.

Eine Sammlung weiterer wichtiger Ressourcen ist am Ende dieses Artikels zusammen gefasst.

Im Folgenden möchte ich auf einige Hürden und Tücken hinweisen um dir einen einfachen Einstieg in Geb zu ermöglichen.

Geb-Hürde 1: Abhängigkeitskonflikt verhindert sämtliche Grails Kommandos

Error executing script Clean: loader constraint violation: when resolving overridden method "org.apache.xerces.jaxp.SAXParserImpl.getParser()Lorg/xml/sax/Parser;" the class loader (instance of org/codehaus/groovy/grails/cli/support/GrailsRootLoader) of the current class, org/apache/xerces/jaxp/SAXParserImpl, and its superclass loader (instance of), have different Class objects for the type org/xml/sax/Parser used in the signature

Umgang mit der Hürde

Diesen Fehler konnte ich durch Ausschluss der Abhängigkeit zu xercesImpl bei selenium-htmlunit-driver beheben:

/** Ausschnitt aus der Datei BuildConfig.groovy **/
// ...
grails.project.dependency.resolution = {
// ...
  dependencies {
    test "org.codehaus.geb:geb-spock:0.6.0"

    def driverVersion = '2.1.0' // slow startup if set to 'latest.release'
    test("org.seleniumhq.selenium:selenium-htmlunit-driver:${driverVersion}") {
      exclude 'xml-apis'
      exclude 'xercesImpl' // IMPORTANT!
      //exclude 'xmlParserAPIs'
    }
    test "org.seleniumhq.selenium:selenium-firefox-driver:${driverVersion}"

    // other drivers ...
  }
}

Das Problem ist im Grail – user Forum erläutert.

Geb-Hürde 2: Abstraktionsebenen erschweren den Einstieg

Beim Einsatz von Geb in Grails müssen viele Ebenen zusammen arbeiten:

Grails Geb Plugin
Eigentliches Geb
Grails Testing Framework / Spock
Selenium WebDriver
Browser (HtmlUnit, Firefox, Chromium, IE)

Schwierigkeiten sind vor allem beim Grails Plugin (aufgrund der mangelhaften Dokumentation) und den Browsern oder “Browser-Drivers” wahrscheinlich.

Umgang mit der Hürde

Um das Grails Plugin möglichst schnell verstehen zu lernen ist Luke Daley’s Beispielprojekt auf GitHub hilfreich.

Übernimm am besten die Beispieldateien in dein Projekt und passe sie dann entsprechend an.

Geb-Hürde 2: Unzureichende Spezifizierung erschwert die Identifikation

Um innerhalb eines Tests überprüfen zu können, auf welcher Seite sich Geb gerade befindet, benötigt es gewisse Anhaltspunkte. Die Summe der Anhaltspunkte muss die jeweilige Seiten korrekt und vor allem eindeutig identifizieren.

Im oben genannten Beispielprojekt kannst du anhand der static at-Deklarationen erkennen, dass die einzelnen Pages hauptsächlich über ihren Titel identifiziert werden.

Oft reicht dies aus.

Spätestens bei einer mehrsprachigen Applikation schlägt es in dieser Form allerdings fehl.

Das entsprechende Stacktrace ist wenig hilfreich. Unter anderem fehlt ein Hinweis auf welcher Seite man sich denn – anstelle der erwarteten – befindet.

Condition not satisfied: at LoginPage | false

junit.framework.AssertionFailedError: Condition not satisfied:

at LoginPage
|
false

Versäumst du die eindeutige Definition, öffnet das also viele Fehlerquellen.

Umgang mit der Hürde

Es ist also sinnvoll, eine Seite über zusätzliche Elemente zu identifizieren.

static at = {
  // heading, ...
  title =~ /(?i)melde/
  $( "input.loginbtn", id:'loginbtn').value() =~ /(?i)anmelden/
}

Geb-Hürde 3: jQuery 1.6 wird in HtmlUnit fehlerhaft ausgeführt

Bei funktionialen Tests wird ein am System verfügbarer Browser gesteuert.

Man sieht also beispielsweise das Firefox-Fenster in welchem die definierten Anweisungen durchlaufen werden.

Andererseits fungiert auch HtmlUnit als Browser, bietet allerdings die Möglichkeit die Äblaufe im Hintergrund vorzunehmen.

Aufgrunddessen ist HtmlUnit für Build-Automation die erste Wahl.

Verwendet die zu testende Applikation jQuery, kommt es bei den aktuellen Versionen (1.6.x) zu einem Fehler:

The data necessary to complete this operation is not yet available.

In einem Blogbeitrag von Steve Liles ist die Ursache ausführlich beschrieben.

Umgang mit der Hürde

Um das Problem in unserem Fall zu umgehen muss die Deklaration von driver in der Datei GebConfig.groovy so geändert werden, dass ein anderer Browser verwendet wird. Zum Beispiel:

def driver = new HtmlUnitDriver(BrowserVersion.FIREFOX_3_6) // fails if BrowserVersion is left to the default value

Geb-Hürde 4: Fehler der Browser und Browser-Driver wirken sich im Test aus

Durch die Möglichkeit, verschiedene Browser automatisch steuern zu lassen, wirken sich die Eigenheiten und Bugs der jeweiligen Browser auf unsere Tests aus.

Zum Beispiel gibt es bei der Verwendung von Firefox scheinbar ein Problem beim Absenden von Formularen mittels ENTER 1, welches bei der Nutzung des FirefoxDriver auftritt.

Mit HtmlUnit hingegen funktioniert das Senden wie erwartet.

Umgang mit der Hürde

Im Zweifelsfall ist es daher sinnvoll, die Test’s mit unterschiedlichen Browsern laufen zu lassen. Die entsprechenden Befehle sind als Kommentare in der GebConfig.groovy Beispieldatei vermerkt.

Geb-Hürde 5: Mehrsprachigkeit erschwert das Finden von Elementen

Standardmäßig stellt Grails die Sprache einer Applikation entsprechend der Sprachkonfiguration im Browser des Besuchers ein.

Wenn also Firefox auf Deutsch und HtmlUnit auf Englisch eingestellt ist, fehlen möglicherweise Seiteninhalte, welche zur Identifikation oder Navigation einer Seite genutzt werden.

Die bereits früher im Artikel beschriebene Definition würde auf jene Seiten zutreffen, welche “melde” (in Groß-, Klein- oder gemischter Schreibweise) enthalten:

title =~ /(?i)melde/

Allerdings ist der Inhalt des Title-Elements auf Englisch wahrscheinlich anders.

Umgang mit der Hürde

Um auch die Zeichenkette “Login” gelten zu lassen, muss die Definition entsprechend angepasst werden:

title =~ /(?i)melde|(?i)login/

Alternativ könnte man dafür sorgen, dass alle Browser-Driver die selbe Sprache anfordern. Ich habe darauf verzichtet eine Lösung dafür zu suchen, wäre aber an einer interessiert.

Geb-Hürde 6: Die Verwendung von Variablen führt zu Fehlern

In einer Spezifikation hatte ich versucht die Werte über eine Variable zu setzen:

def subject = "Subject for testing the contact form via Geb"
// ... some logic
contactForm.subject = subject

Offensichtlich versucht Geb in diesem Fall ein Element namens subject auf der Website zu finden, anstatt die deklarierte Variable zu verwenden:

@No such property: subject for class: geb.navigator.EmptyNavigator

groovy.lang.MissingPropertyException: No such property: subject for class: geb.navigator.EmptyNavigator
at geb.navigator.EmptyNavigator.propertyMissing(EmptyNavigator.groovy:151)
at geb.navigator.Navigator.getProperty(Navigator.groovy)@

Umgang mit der Hürde

Ob und wie es möglich ist, Variablen zu nutzen ist mir derzeit unbekannt.

Wenn du auf Variablen verzichten kannst, weise einfach Strings zu.

Ressourcen

Folgende Ressourcen sind im Zusammenhang mit Geb hilfreich.

Dokumentation & Beispiele

Verwendete Technologien

Fehlerdetails

WordPress Anleitung: Einen Artikel als Ereignis markieren

2011-06-30T00:00:00+02:00

(WordPress Plugin Simple Upcoming Events)

Beim Erstellen eines Artikels in der Box “Benutzerdefinierte Felder” unter Name auf - Wähle - klicken
date auswählen
Rechts daneben unter Wert das Datum im Rückwärtsformat und durch Bindestriche getrennt eingeben (z.B 2011-06-30)
Auf den Knopf Benutzerdefiniertes Feld hinzufügen klicken

Anmerkung: Das Datum muss in der Zukunft liegen, damit das Ereignis im Menü aufscheint.

WordPress Anleitung: Einen Artikel verfassen

2011-06-13T00:00:00+02:00

Artikel ausklappen
Erstellen klicken
Überschrift & Text eingeben
Rechts das Veröffentlichungsdatum eingeben
Die Kategorie festlegen
Schlagwörter (= Themenbereiche) angeben, welche dieser Artikel betrifft

WordPress Anleitung: Eine Seite in ein Menü einfügen

2011-06-13T00:00:00+02:00

1. Zur Menüverwaltung wechseln

Klick auf Design > Menüs
Die Registerkarte für das gewünschte Menü anklicken

2. Die Seite ins Menü setzen

Die soeben erstellte Seite unter “Seiten” (mittig links in der Ansicht) auswählen und Knopf “Zum Menü hinzufügen” klicken.
Das kleine Pfeilsymbol anklicken um die Details des soeben eingefügten Elements auszuklappen
Unter “Angezeigter Name” das Gewünschte eintragen
Knopf “Menü speichern” klicken

3. Zur Kontrolle in das Frontend wechseln

Klick auf Titel der Seite ganz links oben

WordPress Anleitung: Ein Seite erstellen

2011-06-13T00:00:00+02:00

1. Zum Dashboard wechseln

Klick auf Meine Blogs > BLOGNAME

2. Seite erstellen

Klick auf Seiten > Erstellen
Unter Titel die gewünschte Überschrift für die Seite eintragen
Im großen Feld darunter, den frei formulierten Text eingeben

3. Text verlinken

Den Text der verlinkt werden soll, markieren
Auf das Kettenglied-Icon klicken

4. Seite veröffentlichen

Den blauen Knopf “Publizieren” (oder “Aktualisieren”) klicken

WordPress Anleitung: Ein Bild skalieren

2011-06-13T00:00:00+02:00

Mediathek > Medienübersicht
Bei Bild auf Bearbeiten klicken
Knopf “Bild Bearbeiten”
Rechts oben “Bild skalieren”
Maße des Bildes – dort wo aktuell die größere Zahl steht 800 eintragen
Klick auf “Skalierung”

DRY-Verwendung von Constraints in Grails-View

2011-05-09T00:00:00+02:00

Um dem Prinzip zur Redundanzvermeidung (DRY – Don’t repeat yourself) gerecht zu werden, kann man in Grails auf die Constraints einer Domainklasse in Grails auf einfache Art und Weise auch von anderen Stellen aus zugreifen – beispielsweise in der View oder im Controller.

Folgendes Beispiel zeigt die Verwendung des size Constraints um die maximale Länge (maxlength) eines INPUT zu beschränken:

Constraint aus dem Grails-Controller übergeben

z.B. in Action “create” von MyDomainController.groovy:

// Constraint in Controller abrufen und an die View übergeben
return [ titleMax:    MyDomain.constraints.title.size.max() ]

Constraint in der Grails-View verwenden

z.B. in mydomain/create.gsp

<!-- Constraint in der View nutzen -->
<g:textField name="title" maxlength="${titleMax}" />

Grails Framework Reference: constraints

Suchmaschinenoptimierung Ubuntu Style: Buchstaben im Title zählen

2011-03-10T00:00:00+01:00

Sucht man einen Begriff in einer Suchmaschine (z.B. ixquick, Google, Bing, Yahoo! …), wird in den Ergebnissen der Titel der gefundenen Seite verlinkt dargestellt.

Für diese Titel steht in der Regel begrenzter Platz zur Verfügung – normalerweise genau eine Zeile.

Die optimale Länge eines Seitentitels

Wie lang eine solche Zeile sein darf unterscheidet sich geringfügig von Suchmaschine zu Suchmaschine. Man kann die Längen durch Tests herausfinden. Im Blog von Powermapper sind die Ergebnisse solcher Tests aufgelistet.

Eine Länge von 65 Zeichen ist unter Berücksichtigung der gängigen Suchmaschinen optimal.

Die Anzahl der Zeichen im Titel zählen

Natürlich könnte man die Zeichen jeder Überschrift im Kopf zählen. Da sich das allerdings sehr aufwendig gestaltet, gibt es bei manchen Systemen einen entsprechenden Zähler.

Hat man einen Blog im Life Blogs Netzwerk, so ist dieser standardmäßig mit einem Zähler ausgestattet, welcher während der Eingabe die Anzahl der verwendeten Zeichen darstellt.

Benötigt man einen Zähler für andere Webseiten (z.B. Titel von YouTube Videos), so könnte man den Text dennoch im Blog eingeben und umkopieren, sobald die Länge korrekt ist.

Versierte Nutzer werden es allerdings oft praktikabler finden, die Titellänge mit schnell verfügbaren Kommandos zu testen und anzupassen.

Kommando in Ubuntu/Linux und FreeBSD

In Unix-orientierten Systemen gibt es für gewöhnlich die beiden Befehle echo(1) (eine Zeile Text anzeigen) sowie wc(1) (Bytes, Wörter und Zeilen von Dateien zählen).

Folgende Zeile schickt den Text an wc, welches wiederum die Anzahl der Zeichen ausgibt:

echo -n 'ZU PRÜFENDER SEITENTITEL' | wc -m

Wichtig: Der Text in diesem Beispiel muss frei von einfachen Hochkommata (') sein.

Nachdem man mit ENTER bestätigt, wird die Anzahl der Zeichen ausgegeben. Mit der Taste Pfeil nach oben holt man den Text wieder in die aktuelle Zeile, bearbeitet ihn erneut und bestätigt wieder mit ENTER. Das wiederholt man bis der Titel die gewünschte Länge erreicht hat.

Wo gibt man diese Kommandos ein?

In den aktuellen K/Ubuntu Versionen ist der sicherste Weg, den Schnellstarter (Alt+F2) aufzurufen und dort dann den Programmnamen einzugeben:

In Ubuntu/Gnome: gnome-terminal
In Kubuntu/KDE: konsole

Bei Unerreichbarkeit von Apache Tomcat automatisch eine selbst erstellte HTML-Seite darstellen

2011-01-29T00:00:00+01:00

Während eines “Redeploys” ist eine Applikation unerreichbar.

Hat man Apache HTTPD mit Tomcat verbunden, kann man diese Situationen und sogar den Ausfall des Apache Tomcat Dienstes elegant behandeln.

Die offizielle Dokumentation zu mod_jk definiert empfohlene Timeout-Werte. Bleibt eine Anfrage seitens Tomcat innerhalb der definierten Zeitfenster unbeantwortet, kann Apache HTTPD eine alternative Seite mit entsprechenden Hinweisen ausliefern.

Anstatt Besuchern kryptische und abschreckende Standard-Fehlermeldungen anzuzeigen, kann eine_ frei gestaltete Seite mit Hinweisen zum weiteren Vorgehen_ präsentiert werden. Dabei können alle Funktionalitäten der Apache HTTPD Installation (CSS, PHP, …) genutzt werden. Eine einfache (X)HTML Seite ist oft ausreichend.

Apache HTTPD: Die ErrorDocument Direktiven konfigurieren

Welche Seite in einem solchen Fehlerfall angezeigt wird, definiert man in der Apache HTTPD Konfigurationsdatei über die ErrorDocument-Direktive.

Im folgenden Beispiel wird in der Datei /etc/apache2/conf.d/localized-error-pages für einige der möglichen Statuscodes je eine HTML-Seite definiert.

# 404 - Not Found
ErrorDocument 404 /404.shtml
# 500 - Internal Server Error
ErrorDocument 500 /500.shtml
# 503 - Service Unavailable
ErrorDocument 503 /503.shtml

Damit diese Seiten auch für Tomcat angezeigt werden, muss die Konfiguration des entsprechenden Workers angepasst werden. Nach Befolgen der Anleitung zum Verbinden von Tomcat & HTTPD, müsste der worker als “ajp13_worker” benannt sein.

Apache Tomcat: Die worker.properties konfigurieren

Demnach sind folgende Werte in /etc/libapache2-mod-jk/workers.properties einzutragen:

worker.ajp13_worker.ping_mode=A
worker.ajp13_worker.ping_timeout=10000
worker.ajp13_worker.fail_on_status=500,503

Die ersten beiden Zeilen definieren die Timeouts. Die dritte Zeile definiert bei welchen Statuscodes der Worker als “versagt” (failed) betrachtet wird. In der offiziellen Dokumentation können Details zu fail_on_status nachgelesen werden.

Die Konfiguration testen

Hat man beispielsweise die Datei 503.shtml entsprechend erstellt und abgelegt, kann man testen, ob sie korrekt angezeigt wird.

Dazu liest man die Apache HTTPD Konfiguration neu ein, stoppt Tomcat und versucht die entsprechende Applikation per Browser zu erreichen.

sudo service apache2 reload
sudo service tomcat6 stop

Hinweis: Um Server Single Points of Failure zu vermeiden bietet mod_jk sehr interessante Möglichkeiten um im Fehlerfall oder auch bei unterschiedlichen Zugriffen auf andere Server umzuleiten. Neben einer Redundanz welche die Verfügbarkeit der Dienste absichert kann damit eine effiziente Lastverteilung erreicht werden.

Tiny Tiny RSS als Standard-Feedreader in Firefox einrichten

2011-01-19T00:00:00+01:00

Tiny Tiny RSS ist ein webbasierter open source Feed Aggregator. Sobald er auf einem Webserver installiert ist, kann man damit von überall aus Newsfeeds lesen und verwalten (Stichwort Content-Syndication").

Die folgenden Schritte erklären, wie man Tiny Tiny RSS als Standard-Newsreader für RSS/Atom Feeds einrichtet.

Website der Tiny Tiny RSS Installation aufrufen
Einloggen
Rechts oben auf Einstellungen klicken
Registerkarte Feeds wählen
Darunter Firefox Integration ausklappen
Knopf Diese Website als Feedreader registrieren. anklicken und bestätigen.
Firefox neu starten
Eine Website besuchen und den gewünschten Feed anklicken
Bei Diesen Feed abonnieren mit Tiny Tiny RSS auswählen
[OPTIONAL] Häkchen bei Feeds immer mit Tiny Tiny RSS abonnieren. setzen
Knopf Jetzt abonnieren klicken

Hat man eingestellt, die Feeds immer mit Tiny Tiny RSS zu abonnieren (optionaler Punkt 10.) kann man dies später wie folgt ändern.

Einstellung für Standard-Newsreader ändern

Im Firefox-Menü Bearbeiten > Einstellungen … klicken
Auf Anwendungen klicken
Im Suchfeld nach “Web-Feed” filtern
In der Spalte “Aktion” die gewünschte Auswahl treffen

Sämtliche symbolische Links zu einer bestimmten Datei finden

2010-12-31T00:00:00+01:00

Index-Node (Inode) Nummer der Datei feststellen
```
ls -di ${DATEI}
```

Die gefundene Inode Nummer mittels find suchen

sudo find -L / -inum ${INODE_NUMMER} 2>/dev/null

Einzeiler zum Finden sämtlicher Verweise auf die Datei

Gleiches wie oben als Einzeiler:

sudo find -L / -inum `ls -di ${DATEI} | awk '{ print $1 }'` 2>/dev/null

Durch den Schalter -d funktioniert der Befehl auch für Verzeichnisse.

ls(1), find(1), awk(1)

Quelle: http://ubuntuforums.org/showthread.php?t=90970

Anzeigen wohin ein symbolischer Link verweist

2010-12-31T00:00:00+01:00

DATEINAME_DES_SYMLINK=symbolischer.link
readlink ${DATEINAME_DES_SYMLINK}

Mittels Firefox Erweiterung Flagfox den Domainbesitzer bestimmen

2010-12-29T00:00:00+01:00

Immer wieder werde ich gebeten, herauszufinden, ob bestimmte Domains bereits vergeben sind oder wer aktuell Inhaber ist.

Folgender Linux-Befehl liefert für die gängigsten Top-Level-Domains rasch das Ergebnis:

whois GEWÜNSCHTEDOMAIN

Der Besuch von Whois-Websites wird dadurch meist überflüssig.

Wer diese Möglichkeit verzichten muss, kann sich im Firefox Web Browser eine andere Einrichtung konfigurieren.

Die "Firefox-Erweiterung “Flagfox”(Beschreibung zum Plugin "Flagfox" auf der offiziellen Website von Mozilla)":https://addons.mozilla.org/en-US/firefox/addon/5791/ fügt der Adresszeile eine kleine Flagge hinzu. Sie zeigt an, in welchem Land die gerade geöffnete Website gehostet wird.

Klickt man mit der rechten Maustaste auf diese Flagge, erscheint in einem Kontext der Menüpunkt “Whois”. Wählt man diesen, wird der Whois-Dienst der Website DomainTools.com geöffnet.

Für Kaufanfragen wendet man sich in der Regel an den administrativen Kontakt (ADMIN-C).

Manchmal sind die Informationen allerdings unvollständig. In diesem Fall findet sich oft ein Vermerk, welcher darauf hinweist, wo man den gesamten Whois-Eintrag abrufen kann ( “For complete domain details go to:” ).

Zusammenfassung der einzelnen Schritte

Einmalig

Flagfox-Erweiterung für Firefox installieren
Firefox neu starten

Für jede abzufragende Domain

Die gewünschte Website/Domain besuchen
Mit der_ rechten Maustaste_ auf die Flagfox-Flagge klicken
“Whois” anklicken
Überprüfen man den korrekten Whois-Datensatz gefunden hat (“Whois Record For GEWÜNSCHTEDOMAIN”); Falls nicht, gibt man die korrekte Domain nochmals im Feld “Search Whois Records” ein.
Die entsprechenden_ Kontaktdaten (z.B. ADMIN-C) ansehen_ oder den Verweis zu den “complete domain details” folgen und sie dort auslesen.

Verwendet man einen anderen Browser, oder möchte man auf Flagfox verzichten, kann man natürlich auch direkt whois.domaintools.com besuchen und die Domain direkt eingeben.

Apache HTTPD & Apache Tomcat 6 per AJP Connector verbinden (Ubuntu 10.04.1)

2010-09-21T00:00:00+02:00

In manchen Fällen ist sinnvoll, den Apache HTTP Server in Verbindung mit dem Apache Tomcat-Dienst einzusetzen. Die meisten Anwendungsgebiete finden sich, wenn die beiden Dienste auf unterschiedlichen physischen Servern betrieben werden sollen.

Sind beide Dienste am selben Server, so soll bevorzugt das AJP (Apache JServ Protocol) bzw. der AJP-Connector verwendet werden um die Kommunikation herzustellen.

When using a single server, the performance when using a native webserver in front of the Tomcat instance is most of the time significantly worse than a standalone Tomcat with its default HTTP connector, even if a large part of the web application is made of static files. If integration with the native webserver is needed for any reason, an AJP connector will provide faster performance than proxied HTTP. AJP clustering is the most efficient from the Tomcat perspective. It is otherwise functionally equivalent to HTTP clustering. [Von http://tomcat.apache.org/tomcat-6.0-doc/connectors.html]

Folgende Anleitung beschreibt die Einrichtung des Connectors auf einem Ubuntu 10.04.1 Server.

Voraussetzungen

Apache 2.2 (sudo apt-get install apache2.2-bin)
Apache Tomcat 6 (sudo apt-get install tomcat6)

Apache 2 Connector installieren

sudo apt-get install libapache2-mod-jk

Apache HTTP konfigurieren

In Datei /etc/apache2/sites-enabled/000-default innerhalb der entsprechenden _ Direktive _einen “Einhängepunkt” für die Tomcat-Applikation festlegen:

JkMount /NAME_DER_TOMCAT_APPLIKATION/* ajp13_worker

(Details hierzu unter Working with mod_jk)

Jk in der Datei /etc/apache2/mods-enabled/jk.load konfigurieren:

LoadModule jk_module /usr/lib/apache2/modules/mod_jk.so
JkWorkersFile   /etc/libapache2-mod-jk/workers.properties
JkLogFile       /var/log/apache2/mod_jk.log
JkLogLevel      error

(workers.properties enthält unter anderem die Konfiguration für den oben eingesetzten “ajp13_worker”. Die Datei wird automatisch bei der Installation des Pakets libapache2-mod-jk angelegt)

Apache Tomcat konfigurieren

In der Datei /etc/tomcat6/server.xml ist die nötige Zeile bereits – auskommentiert – vorhanden. Um den Zugriff von Apache HTTP zu ermöglichen, muss die folgende Zeile aktiviert werden, indem man die Kommentarzeichen entfernt:

 <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

[OPTIONAL] Direkten Zugriff zu Apache Tomcat deaktivieren

Möchte man ausschließlich Zugriffe via Apache HTTP erlauben, kann man den Connector-Block für das HTTP-Protokoll in Tomcat auskommentieren:

<!-- commented out to disable direct access to Tomcat
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
URIEncoding="UTF-8"
redirectPort="8443" />
-->

Apache HTTP und Apache Tomcat neu laden / starten

sudo service apache2 reload
sudo service tomcat6 restart

Siehe auch

Installing Tomcat6 on Ubuntu with Jk Connector

rdesktop Patch: Mittels Alt-Tab aus rdesktop-Session weg wechseln

2009-12-09T00:00:00+01:00

Folgendes Patch für rdesktop 1.6.0 verhindert, dass die Tastenkombination Alt-Tab innerhalb der Session gefangen wird.

Somit ist es möglich diese Kombination zu nutzen um zu anderen Anwendungen des Hauptsystems zu wechseln.

--- rdesktop-1.6.0/xkeymap.c	2007-10-08 14:34:05.000000000 +0200
+++ rdesktop-1.6.0vle/xkeymap.c	2009-12-09 16:25:32.000000000 +0100
@@ -597,6 +597,23 @@
 				ui_seamless_toggle();
 			break;

+		/* Added to allow ALT(left only)+TAB with local machines' windows
+		* note that no keyboard-shortcut relying on ALT_L will work within the RDP-session! */
+		case XK_Alt_L:
+			XUngrabKeyboard(g_display, CurrentTime);
+
+		/* alternatively switch Windows on Alt-Tab-Tab */
+/*		case XK_Tab:
+			if (get_key_state(state, XK_Alt_L))
+			{
+*/
+				/* Alt-Tab:
+				* Ungrab the keyboard so that user can use Windows manager's hot keys */
+/*
+				XUngrabKeyboard(g_display, CurrentTime);
+			}
+*/
+			break;
 	}
 	return False;
 }

rdesktop(1)

Für viele Anwendungsfälle ist SeamlessRDP eine sinnvolle Alternative zu diesem Patch.

Windows XP nach Mainboard- oder Plattentausch lauffähig machen

2009-09-02T00:00:00+02:00

Wechselt man bei einem Windows XP System grundlegende Hardware wie das Motherboard, kann dadurch der Betriebssystemstart versagen. Gleiches gilt natürlich, wenn man eine Festplatte mit Windows in einen anderen PC nutzen möchte.

Problembehebung nach dem Umbau

Wenn der Umbau bereits erfolgt ist, kann das Problem wie folgt behoben werden:

Ultimate Boot CD for Windows (UBCD4Win) herunterladen und installieren
UBCD4Win ausführen
Originale Windows XP CD einlegen und als Quellmedium angeben
Quellmedium durch Klick auf “Check” validieren
UBCD4Win brennen
Computer von der UBCD4Win CD starten
Im Boot-Menü Launch “The Ultimate Boot CD for Windows” laden
Zu Start > Programs > Registry Tools > Fix_hdc > Fix hard disk controller navigieren
Mit Taste M eine Aktualisierung der Massenspeicher-Treiber veranlassen
Computer ohne CD neu starten

Quellen und weiterführende Informationen:

Move Windows XP hard drive or change Motherboard without getting Blue Screen of Death – Raymond.cc
Changing a Motherboard or Moving a Hard Drive with XP Installed – MichaelStevensTech.com

Exif-Information über die Erstellungszeit eines Fotos korrigieren

2009-06-08T00:00:00+02:00

Im Exif (Exchangeable Image File Format) Header einer JPEG-Datei werden Metadaten zum jeweiligen Bild gespeichert. Mit dem Werkzeug jhead können diese Informationen per Kommandozeile geändert werden.

Hat man beispielsweise bei einer Reise in eine andere Zeitzone versäumt, die Zeit der Kamera auf die lokale Zeit umzustellen, kann man mit jhead nachträglich eine entsprechende Korrektur vornehmen.

Folgendes Beispiel setzt die Erstellungszeit des Bildes um 6 Stunden früher als in der Datei ursprünglich angegeben:

# jhead installieren
sudo apt-get install jhead
# "Time-adjust" um minus 6 Stunden
jhead -ta-6:00 ${JPEG_BILD}

jhead(1)

T Mobile web'n'walk Card compact III in Ubuntu 8.04 einrichten

2008-07-14T00:00:00+02:00

T Mobile web’n’walk Card compact III ist lediglich die Markenbezeichnung für eine Option GlobeTrotter Max.

HSO Treiber installieren

tar zxf hso-1.2.tar.gz
cd hso
make
sudo make install

Rezero installieren

tar xzvf rezero_hso-udev.tar.gz
cd rezero_hso-udev
# Direkt installieren, statt, wie in manchen Anleitungen beschrieben, neu kompilieren (make)
sudo make install

Treiber “option” in Blacklist aufnehmen

Da der option Treiber mit HSO in Konflikt steht, muss er per Blacklisting deaktiviert werden.

echo "blacklist option" >> /etc/modprobe.d/blacklist

HSOLink installieren

sudo dpkg -i --force-architecture hsolink_1.0.46-1_i386.deb

Der Benutzer muss Mitglied der Gruppe dialout sein:

usermod -a -G dialout ${BENUTZERNAME}

Quellen:

Audiodatei per Cuesheet aufteilen

2007-03-22T00:00:00+01:00

Falls die Datei in einem anderen Format vorliegt, muss sie zuerst in eine WAVE (Waveform Audio File Format) umgewandelt werden. Dazu kann mplayer verwendet werden. Beispiel:

# audiodump.wav erzeugen
mplayer audiodatei.flac -ao pcm

mplayer(1)

Anschließend wird die WAV-Datei mit Hilfe der Informationen aus dem Cuesheet und dem Programm bchunk aufgeteilt.

bchunk audiodump.wav cuesheet.cue -w ${BELIEBIGER_PRAEFIX}

bchunk(1)

Dateien in Verzeichnis zählen

2006-05-10T00:00:00+02:00

find ./ -type f | wc -l

find(1), wc(1)

KDE Version ausgeben

2005-11-17T00:00:00+01:00

# in KDE3
kde-config -v

# in KDE4
kde4-config -v

kde-config(1), kde4-config(1)

Webinhalte mittels wget leechen

2005-10-24T00:00:00+02:00

Beispiel: Sämtliche PNG-Dateien herunterladen

wget -e robots=off -r -l1 -A.png http://example.org

-e robots=off robots.txt ignorieren
-r rekursiv
-l Anzahl Levels bei Rekursion (ACHTUNG: -l0 bedeutet unendlich)
-A akzeptierte Dateiypen (kommagetrennt)

wget(1)

Quelle/weitere Infos: How to non-interactively retrieve files from the Web

Mittels awk Leerzeilen aus einer Textdatei entfernen

2005-10-24T00:00:00+02:00

cat ${INFILE} | awk '{ if ($0) print }' > ${OUTFILE}

Browser-Cache von Konqueror in KDE 3.5 auf RAM-Disk auslagern

2005-10-24T00:00:00+02:00

Die RAM-Disk selbst kann rasch erstellt werden, indem man die Gerätedatei /dev/ram0 ähnlich einer gewöhnlichen Festplatte behandelt.

GROESSE_IN_KB=200000
sudo mkdir /ramdisk
mke2fs /dev/ram0 ${GROESSE_IN_KB}
sudo mount /dev/ram0 /ramdisk

Dateien und Verzeichnisse in die RAM-Disk auslagern

Mit Hilfe symbolischer Verknüpfungen können diverse Verzeichnisse in die erzeugte RAM-Disk ausgelagert werden.

Folgende Beispiele beziehen sich auf den Browser-Cache und die Cookies in Konqueror von KDE 3.5.

# HTTP-Cache in die RAM-Disk verlegen
mv ${KDEHOME}/share/cache/http/* /ramdisk &&
rmdir ${KDEHOME}/share/cache/http &&
ln -s /ramdisk ${KDEHOME}/share/cache/http

# Cookies in die RAM-Disk verlegen
mv ${KDEHOME}/share/apps/kcookiejar/* /ramdisk &&
rmdir ${KDEHOME}/share/apps/kcookiejar &&
ln -s /ramdisk $KDEHOME/share/apps/kcookiejar

Weitere interessante Ansätze finden sich im Wiki von ubuntuusers.de.