Groovy Skills International

VirtualBox: Windows 7 aus Linux auf physische Platte installieren

2013-04-07T00:00:00-03: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.

<span class="nv">VM_NAME</span><span class="o">=</span><span class="s1">&#39;Windows 7 Home Premium (64 bit)&#39;</span>
<span class="nv">VMDK</span><span class="o">=</span><span class="k">${</span><span class="nv">HOME</span><span class="k">}</span>/.VirtualBox/samsung_840_ssd.vmdk
<span class="c"># Die DISK_ID findet man beim Auflisten des Verzeichnisinhalts von /dev/disk/by-id/</span>
<span class="nv">DISK_ID</span><span class="o">=</span>ata-Samsung_SSD_840_Series_S14GNEBCB66690P

<span class="c"># VMDK als Schnittstelle zu physischer Festplatte erstellen</span>
VBoxManage internalcommands createrawvmdk -filename <span class="k">${</span><span class="nv">VMDK</span><span class="k">}</span> -rawdisk /dev/disk/by-id/<span class="k">${</span><span class="nv">DISK_ID</span><span class="k">}</span>
<span class="c"># VMDK an virtuelle Maschine binden</span>
VBoxManage storageattach <span class="s2">&quot;${VM_NAME}&quot;</span> --storagectl <span class="s2">&quot;SATA-Controller&quot;</span> --port 0 --device 0 --type hdd --nonrotational on --medium <span class="k">${</span><span class="nv">VMDK</span><span class="k">}</span>

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-03: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.

<span class="nv">sum</span><span class="o">=</span>0
<span class="nv">lines_counts</span><span class="o">=</span><span class="sb">`</span>find ./ -type f -exec wc -l <span class="o">{}</span> <span class="se">\;</span> | cut -d <span class="s1">&#39; &#39;</span> -f1<span class="sb">`</span>
<span class="k">for </span>line_count in <span class="nv">$lines_counts</span>; <span class="k">do</span>
<span class="k">  </span><span class="nv">sum</span><span class="o">=</span><span class="sb">`</span>expr <span class="nv">$sum</span> + <span class="nv">$line_count</span><span class="sb">`</span>
<span class="k">done</span>
<span class="nb">echo</span> <span class="nv">$sum</span>

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-02: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

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

<span class="c"># Zur besseren Nachvollziehbarkeit sollte owning_group im</span>
<span class="c"># Folgenden auf den Gruppennamen laut Hostsystem gesetzt werden:</span>
<span class="nb">set </span><span class="nv">GROUPNAME_ACCORDING_TO_HOSTSYSTEM</span><span class="o">=</span><span class="s2">&quot;users&quot;</span>
<span class="nb">set </span><span class="nv">OWNCLOUD_USERNAME</span><span class="o">=</span><span class="s1">&#39;dice&#39;</span>
<span class="nb">set </span><span class="nv">DIR</span><span class="o">=</span><span class="s2">&quot;/mnt/pfad/zu/jail/usr/local/www/owncloud-4.5/data/${OWNCLOUD_USERNAME}/files/dateien&quot;</span>
<span class="nb">set </span><span class="nv">owning_gid</span><span class="o">=</span><span class="sb">`</span>ls -dln <span class="k">${</span><span class="nv">DIR</span><span class="k">}</span> | awk <span class="s1">&#39;{ print $4 }&#39;</span><span class="sb">`</span>

<span class="c"># Der Gruppe Leserechte gewähren</span>
chmod -R g+rX <span class="k">${</span><span class="nv">DIR</span><span class="k">}</span>

<span class="c"># www-Benutzer in die Gruppe aufnehmen</span>
pw groupadd <span class="k">${</span><span class="nv">GROUPNAME_ACCORDING_TO_HOSTSYSTEM</span><span class="k">}</span> -g <span class="k">${</span><span class="nv">owning_gid</span><span class="k">}</span> -M www

<span class="c"># Dienste neu starten</span>
/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 Plugins-Jail oder FreeBSD installieren

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

Der FreeNAS Wiki-Artikelabschnitt Installing the Plugins Jail 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.

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.

<span class="nb">cd</span> /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.

<span class="nb">cd</span> /usr/ports/archivers/php5-zlib &amp;&amp; make install clean
<span class="nb">cd</span> /usr/ports/converters/php5-iconv &amp;&amp; make install clean

ownCloud 4.5.0 installieren

<span class="nb">cd</span> /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

<span class="c"># PHP-FPM auf Socket umstellen</span>
sed -i <span class="s1">&#39;&#39;</span> -e <span class="s1">&#39;s/^listen =.*/listen = \/var\/run\/php-fpm.sock/g&#39;</span> /usr/local/etc/php-fpm.conf

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

<span class="c"># Größere Uploads ermöglichen</span>
sed -i <span class="s1">&#39;&#39;</span> -e <span class="s1">&#39;s/^post_max_size =.*/post_max_size = 300M/g&#39;</span> /usr/local/etc/php.ini
sed -i <span class="s1">&#39;&#39;</span> -e <span class="s1">&#39;s/^upload_max_filesize =.*/upload_max_filesize = 200M/g&#39;</span> /usr/local/etc/php.ini

<span class="c"># Größere Downloads für Client-Apps ermöglichen (siehe untenstehende Anmerkung)</span>
sed -i <span class="s1">&#39;&#39;</span> -e <span class="s1">&#39;s/^memory_limit =.*/memory_limit = 512M/g&#39;</span> /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.

<span class="nb">cd</span> /usr/ports/www/nginx &amp;&amp; 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 folgende Einträge gesetzt werden.

        <span class="k">root</span> <span class="s">/usr/local/www/owncloud-4.5</span><span class="p">;</span>
        <span class="k">client_max_body_size</span> <span class="mi">200m</span><span class="p">;</span>

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

                <span class="kn">fastcgi_param</span>   <span class="s">SCRIPT_FILENAME</span> <span class="nv">$document_root$fastcgi_script_name</span><span class="p">;</span>
                <span class="kn">fastcgi_param</span>   <span class="s">SCRIPT_NAME</span>     <span class="nv">$fastcgi_script_name</span><span class="p">;</span>
                <span class="kn">fastcgi_param</span>   <span class="s">PATH_INFO</span>       <span class="nv">$fastcgi_path_info</span><span class="p">;</span>

                <span class="kn">try_files</span> <span class="nv">$uri</span> <span class="nv">$uri/</span> <span class="s">@webdav</span><span class="p">;</span>
        <span class="p">}</span>

        <span class="k">location</span> <span class="p">~</span> <span class="sr">\.php$</span> <span class="p">{</span>
                <span class="c1"># http://bugs.owncloud.org/thebuggenie/owncloud/issues/oc-902#comment_1_904_8388</span>
                <span class="c1">#fastcgi_split_path_info ^(.+\.php)(/.*)$;</span>
                <span class="kn">include</span>         <span class="s">fastcgi_params</span><span class="p">;</span>
                <span class="kn">fastcgi_pass</span>    <span class="s">unix:/var/run/php-fpm.sock</span><span class="p">;</span>
                <span class="kn">fastcgi_index</span>   <span class="s">index.php</span><span class="p">;</span>

                <span class="kn">fastcgi_param</span>   <span class="s">SCRIPT_FILENAME</span> <span class="nv">$document_root$fastcgi_script_name</span><span class="p">;</span>
                <span class="kn">fastcgi_param</span>   <span class="s">SCRIPT_NAME</span>     <span class="nv">$fastcgi_script_name</span><span class="p">;</span>
                <span class="kn">fastcgi_param</span>   <span class="s">PATH_INFO</span>       <span class="nv">$fastcgi_path_info</span><span class="p">;</span>

                <span class="kn">try_files</span> <span class="nv">$uri</span> <span class="p">=</span><span class="mi">404</span><span class="p">;</span>
        <span class="p">}</span>

        <span class="c1"># owncloud WebDAV</span>
        <span class="k">location</span> <span class="s">@webdav</span> <span class="p">{</span>
                <span class="kn">fastcgi_split_path_info</span> <span class="s">^(.+\.php)(/.*)</span>$<span class="p">;</span>
                <span class="kn">fastcgi_pass</span>    <span class="s">unix:/var/run/php-fpm.sock</span><span class="p">;</span>

                <span class="kn">fastcgi_param</span>   <span class="s">SCRIPT_FILENAME</span> <span class="nv">$document_root$fastcgi_script_name</span><span class="p">;</span>
                <span class="kn">fastcgi_param</span>   <span class="s">SCRIPT_NAME</span>     <span class="nv">$fastcgi_script_name</span><span class="p">;</span>
                <span class="kn">fastcgi_param</span>   <span class="s">PATH_INFO</span>       <span class="nv">$fastcgi_path_info</span><span class="p">;</span>

                <span class="kn">fastcgi_param</span>   <span class="s">HTTPS</span> <span class="no">on</span><span class="p">;</span>
                <span class="kn">include</span>         <span class="s">fastcgi_params</span><span class="p">;</span>
        <span class="p">}</span>

nginx und PHP-FPM dauerhaft aktivieren und starten

<span class="nb">echo</span> <span class="s1">&#39;nginx_enable=&quot;YES&quot;&#39;</span> &gt;&gt; /etc/rc.conf
<span class="nb">echo</span> <span class="s1">&#39;php_fpm_enable=&quot;YES&quot;&#39;</span> &gt;&gt; /etc/rc.conf

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

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-03: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 update, /usr/bin/apt-get autoremove, \
                                /bin/netstat -tulpen,           /bin/netstat -lnp, \
                                /usr/sbin/openvpn, \
                                /usr/bin/vi /etc/bash.bashrc

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-03: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 bestehnede 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-03:00

Im Folgenden wird csh-Syntax verwendet. Für bash oder sh müssen die Variablendeklarationen entsprechend abgeändert werden.

<span class="c"># Variablen initialisieren und in nginx-Verzeichnis wechseln</span>
<span class="nb">set </span><span class="nv">BASE_FILENAME</span><span class="o">=</span><span class="sb">`</span>hostname<span class="sb">`</span>
<span class="nb">set </span><span class="nv">key</span><span class="o">=</span><span class="k">${</span><span class="nv">BASE_FILENAME</span><span class="k">}</span>.key
<span class="nb">set </span><span class="nv">csr</span><span class="o">=</span><span class="k">${</span><span class="nv">BASE_FILENAME</span><span class="k">}</span>.csr
<span class="nb">set </span><span class="nv">crt</span><span class="o">=</span><span class="k">${</span><span class="nv">BASE_FILENAME</span><span class="k">}</span>.crt
<span class="nb">cd</span> /usr/local/etc/nginx

<span class="c"># Schlüssel generieren</span>
openssl genrsa -out <span class="k">${</span><span class="nv">key</span><span class="k">}</span> 1024
<span class="c"># CSR erstellen (FQDN als Common Name eingeben!)</span>
openssl req -new -key <span class="k">${</span><span class="nv">key</span><span class="k">}</span> -out <span class="k">${</span><span class="nv">csr</span><span class="k">}</span>
<span class="c"># Signiertes Zertifikat erstellen</span>
openssl x509 -req -days 3650 -in <span class="k">${</span><span class="nv">csr</span><span class="k">}</span> -signkey <span class="k">${</span><span class="nv">key</span><span class="k">}</span> -out <span class="k">${</span><span class="nv">crt</span><span class="k">}</span>

<span class="c"># Korrekte Dateinamen in nginx.conf referenzieren</span>
<span class="c"># Achtung: Nutzt man in der nginx.conf mehrere unterschiedliche</span>
<span class="c"># Zertifikate, ist das Ersetzen sämtlicher Vorkommnisse laut</span>
<span class="c"># folgender Kommandos wahrscheinlich unerwünscht.</span>
sed -i <span class="s1">&#39;&#39;</span> -e <span class="s2">&quot;s/^ *ssl_certificate_key.*/        ssl_certificate_key  ${key}/g&quot;</span> /usr/local/etc/nginx/nginx.conf
sed -i <span class="s1">&#39;&#39;</span> -e <span class="s1">&#39;s/^ *ssl_certificate.*/        ssl_certificate      ${crt}/g&#39;</span> /usr/local/etc/nginx/nginx.conf

openssl(1), sed(1)

KMail: Mails in Posteingang optimal zusammenstellen & gruppieren

2012-08-31T00:00:00-03: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-03: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:

<span class="ss">:uniqueness</span> <span class="o">=&gt;</span> <span class="p">{</span> <span class="ss">:case_sensitive</span> <span class="o">=&gt;</span> <span class="kp">false</span> <span class="p">}</span>

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:

<span class="n">config</span><span class="o">.</span><span class="n">active_record</span><span class="o">.</span><span class="n">whitelist_attributes</span> <span class="o">=</span> <span class="kp">true</span>

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:

<span class="n">x</span> <span class="o">=</span> <span class="mi">5</span><span class="o">.</span><span class="n">hours</span><span class="o">.</span><span class="n">from_now</span>
<span class="n">year</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">year</span>
<span class="n">currently_open</span> <span class="o">=</span> <span class="no">Time</span><span class="o">.</span><span class="n">now</span><span class="o">.</span><span class="n">between?</span> <span class="n">opens_at</span><span class="p">,</span> <span class="n">closes_at</span>

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.

<span class="n">activities_count</span> <span class="o">=</span> <span class="mi">3</span>
<span class="c1"># 3 Aktivitäten erstellen</span>
<span class="n">activities_count</span><span class="o">.</span><span class="n">times</span> <span class="k">do</span>
  <span class="no">FactoryGirl</span><span class="o">.</span><span class="n">build</span><span class="p">(</span><span class="ss">:activity</span><span class="p">)</span>
<span class="k">end</span>

<span class="c1"># Anzahl der Aktivitäten aus index-action überprüfen</span>
<span class="n">get</span> <span class="ss">:index</span>
<span class="n">assert_equal</span> <span class="n">activities_count</span><span class="p">,</span> <span class="n">assigns</span><span class="p">(</span><span class="ss">:activities</span><span class="p">)</span><span class="o">.</span><span class="n">count</span>

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:

<span class="n">grails</span><span class="o">.</span><span class="na">views</span><span class="o">.</span><span class="na">default</span><span class="o">.</span><span class="na">codec</span> <span class="o">=</span> <span class="s">&quot;html&quot;</span> <span class="c1">// none, html, base64</span>

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 ).

<span class="n">title</span> <span class="o">(</span><span class="nl">nullable:</span> <span class="kc">false</span><span class="o">,</span> <span class="nl">blank:</span> <span class="kc">false</span><span class="o">,</span> <span class="nl">unique:</span> <span class="kc">false</span><span class="o">,</span> <span class="nl">size:</span> <span class="mi">5</span><span class="o">..</span><span class="mi">30</span><span class="o">,</span>
	<span class="nl">validator:</span>  <span class="o">{</span> <span class="n">val</span><span class="o">,</span> <span class="n">obj</span> <span class="o">-&gt;</span>	<span class="o">(</span>
			<span class="cm">/* checks if the publisher has published an event with the exact same title (case-insensitive match) */</span>
			<span class="o">!</span><span class="n">Event</span><span class="o">.</span><span class="na">withNewSession</span> <span class="o">{</span>	<span class="c1">// if the get() returns an event, then this is an update - which is fine</span>
				<span class="o">!</span><span class="n">Event</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">obj</span><span class="o">.</span><span class="na">id</span><span class="o">)</span> <span class="o">&amp;&amp;</span>  <span class="n">Event</span><span class="o">.</span><span class="na">findAllByTitleIlikeAndPublisher</span><span class="o">(</span><span class="n">val</span><span class="o">,</span> <span class="n">obj</span><span class="o">.</span><span class="na">publisher</span><span class="o">)</span>
			<span class="o">}</span>
	<span class="o">)}</span>
<span class="o">)</span>

Das Gleiche in Rails:

<span class="n">validates</span> <span class="ss">:title</span><span class="p">,</span> <span class="ss">:length</span> <span class="o">=&gt;</span> <span class="p">{</span> <span class="ss">:in</span> <span class="o">=&gt;</span> <span class="mi">5</span><span class="o">.</span><span class="n">.</span><span class="mi">30</span> <span class="p">},</span>
          <span class="ss">:uniqueness</span> <span class="o">=&gt;</span> <span class="p">{</span> <span class="ss">:case_sensitive</span> <span class="o">=&gt;</span> <span class="kp">false</span><span class="p">,</span> <span class="ss">:scope</span> <span class="o">=&gt;</span> <span class="ss">:publisher_id</span> <span class="p">}</span>

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-03: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!

<span class="c"># Die Kategorie sämtlicher Jekyll-Posts im aktuellen Verzeichnis</span>
<span class="c"># auf den Namen des aktuellen Verzeichnisses abändern:</span>
sed --in-place<span class="o">=</span>_with-previous-category <span class="s2">&quot;s/^category:.*$/category: \&quot;${PWD##*/}\&quot;/g&quot;</span> *.textile

<span class="c"># Schlagworte in der Jekyll-Post Front Matter abändern:</span>
sed --in-place<span class="o">=</span>_with-previous-tags <span class="s2">&quot;s/^tags:.*\]$/tags: \[${PWD##*/}\]/g&quot;</span> *.textile

sed(1)

Weitere Informationen zu ${PWD##*/} finden sich in dieser Stackoverflow-Antwort.

Meistgewünscht? Umgesetzt!

2012-08-16T00:00:00-03: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-03: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-03:00

<span class="c"># PostgreSQL Datenbankdienst und Header/Library installieren</span>
sudo apt-get install postgresql libpq-dev
<span class="c"># Benutzer mit Berechtigung zum Anlegen neuer Datenbanken erstellen</span>
sudo -u postgres createuser -U postgres -dRS <span class="sb">`</span>whoami<span class="sb">`</span>

-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 <span class="sb">`</span>whoami<span class="sb">`</span>

dropuser(1)

Corilla sagt Hallo!

2012-07-04T00:00:00-03: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-03: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-03: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-03: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:

<span class="nb">cd</span> /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:

<span class="nb">cd</span> /pfad/zum/zweiten_git_repo/
mkdir verzeichnis_zweites_repo
<span class="c"># -k sorgt dafür, dass der Befehl trotz Warnung des mv-Kommandos durchgeführt wird:</span>
git mv -k * verzeichnis_zweites_repo
git commit -m <span class="s1">&#39;moved all files into subdirectory verzeichnis_zweites_repo&#39;</span>
<span class="c"># an dieser Stelle dieses Repository in das erste ziehen (siehe erstes Listing dieses Artikels)</span>

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.

<span class="nb">cd</span> /pfad/zum/zweiten_git_repo/
git filter-branch --tree-filter <span class="s1">&#39;mkdir .temp; mv * .temp&#39;</span> HEAD
git filter-branch -f --tree-filter <span class="s1">&#39;mv .temp verzeichnis_zweites_repo&#39;</span> HEAD
<span class="c"># an dieser Stelle dieses Repository in das erste ziehen (siehe erstes Listing dieses Artikels)</span>

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-02: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:

<span class="cp">&lt;!DOCTYPE layouts&gt;</span>
<span class="nt">&lt;playlist_layouts&gt;</span>
 <span class="nt">&lt;layout</span> <span class="na">group_by=</span><span class="s">&quot;None&quot;</span> <span class="na">tooltips=</span><span class="s">&quot;true&quot;</span> <span class="na">name=</span><span class="s">&quot;Amarok 1.4.9&quot;</span><span class="nt">&gt;</span>
  <span class="nt">&lt;single_track</span> <span class="na">active_indicator_row=</span><span class="s">&quot;0&quot;</span> <span class="na">show_cover=</span><span class="s">&quot;false&quot;</span><span class="nt">&gt;</span>
   <span class="nt">&lt;row&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;center&quot;</span> <span class="na">value=</span><span class="s">&quot;Play count&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0.3&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;left&quot;</span> <span class="na">value=</span><span class="s">&quot;Title&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0.15&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;left&quot;</span> <span class="na">value=</span><span class="s">&quot;Artist&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0.15&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;left&quot;</span> <span class="na">value=</span><span class="s">&quot;Album&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;right&quot;</span> <span class="na">value=</span><span class="s">&quot;Year&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;center&quot;</span> <span class="na">value=</span><span class="s">&quot;Track number&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;center&quot;</span> <span class="na">value=</span><span class="s">&quot;Bitrate&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0.25&quot;</span> <span class="na">bold=</span><span class="s">&quot;true&quot;</span> <span class="na">alignment=</span><span class="s">&quot;center&quot;</span> <span class="na">value=</span><span class="s">&quot;Moodbar&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;center&quot;</span> <span class="na">value=</span><span class="s">&quot;Rating&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
   <span class="nt">&lt;/row&gt;</span>
  <span class="nt">&lt;/single_track&gt;</span>
  <span class="nt">&lt;group_head</span> <span class="na">active_indicator_row=</span><span class="s">&quot;0&quot;</span> <span class="na">show_cover=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
  <span class="nt">&lt;group_body</span> <span class="na">active_indicator_row=</span><span class="s">&quot;0&quot;</span> <span class="na">show_cover=</span><span class="s">&quot;false&quot;</span><span class="nt">&gt;</span>
   <span class="nt">&lt;row&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0.5&quot;</span> <span class="na">bold=</span><span class="s">&quot;true&quot;</span> <span class="na">alignment=</span><span class="s">&quot;left&quot;</span> <span class="na">value=</span><span class="s">&quot;Title&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;left&quot;</span> <span class="na">value=</span><span class="s">&quot;Artist&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;true&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;right&quot;</span> <span class="na">value=</span><span class="s">&quot;Length&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
   <span class="nt">&lt;/row&gt;</span>
  <span class="nt">&lt;/group_body&gt;</span>
  <span class="nt">&lt;group_variousArtistsBody</span> <span class="na">active_indicator_row=</span><span class="s">&quot;0&quot;</span> <span class="na">show_cover=</span><span class="s">&quot;false&quot;</span><span class="nt">&gt;</span>
   <span class="nt">&lt;row&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0.5&quot;</span> <span class="na">bold=</span><span class="s">&quot;true&quot;</span> <span class="na">alignment=</span><span class="s">&quot;left&quot;</span> <span class="na">value=</span><span class="s">&quot;Title&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;left&quot;</span> <span class="na">value=</span><span class="s">&quot;Artist&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;true&quot;</span><span class="nt">/&gt;</span>
    <span class="nt">&lt;element</span> <span class="na">suffix=</span><span class="s">&quot;&quot;</span> <span class="na">prefix=</span><span class="s">&quot;&quot;</span> <span class="na">size=</span><span class="s">&quot;0&quot;</span> <span class="na">bold=</span><span class="s">&quot;false&quot;</span> <span class="na">alignment=</span><span class="s">&quot;right&quot;</span> <span class="na">value=</span><span class="s">&quot;Length&quot;</span> <span class="na">underline=</span><span class="s">&quot;false&quot;</span> <span class="na">italic=</span><span class="s">&quot;false&quot;</span><span class="nt">/&gt;</span>
   <span class="nt">&lt;/row&gt;</span>
  <span class="nt">&lt;/group_variousArtistsBody&gt;</span>
 <span class="nt">&lt;/layout&gt;</span>
<span class="nt">&lt;/playlist_layouts&gt;</span>

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-03: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.

<span class="c"># bchunk-Installation in Ubuntu:</span>
sudo apt-get install bchunk
<span class="c"># Auslesen der WAVE-Dateien im Verzeichnis &#39;Friendly Disc&#39;:</span>
bchunk -w TNMOST_Friendly.bin TNMOST_Friendly.cue TNMOST_Friendly
<span class="c"># Auslesen der WAVE-Dateien im Verzeichnis &#39;Hostile Disc&#39;:</span>
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 des dd Befehls ausgeben STATUS/SIGINFO

2011-09-08T00:00:00-03:00

Während der Befehl dd läuft, kann man in diversen UNIX-Systemen durch Drücken von STRG+T Details ausgeben lassen:

<span class="c"># Testkommando inkl. Ausgabe nach Drücken von STRG+T</span>
dd <span class="k">if</span><span class="o">=</span>/dev/random <span class="nv">of</span><span class="o">=</span>/dev/null
load: 0.63  cmd: dd 53428 <span class="o">[</span>running<span class="o">]</span> 1.78r 0.01u 1.76s 16% 868k
153125+0 records in
153125+0 records out
78400000 bytes transferred in 1.788752 secs <span class="o">(</span>43829439 bytes/sec<span class="o">)</span>

Detail zum STATUS Zeichen sind in termios(4) vermerkt.
Das SIGINFO-Signal ist auf Wikipedia erläutert.

WordPress Wartung: Verwaltungsbereich sperren

2011-08-24T00:00:00-03: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.

WordPress Login Sperre einrichten

Dazu erstellt man im WordPress Hauptverzeichnis die Datei .maintenance mit folgendem Inhalt:

<span class="cp">&lt;?php</span>
<span class="k">if</span> <span class="p">(</span> <span class="nb">stristr</span><span class="p">(</span><span class="nv">$_SERVER</span><span class="p">[</span><span class="s1">&#39;REQUEST_URI&#39;</span><span class="p">],</span> <span class="s1">&#39;/wp-admin&#39;</span><span class="p">)</span> <span class="o">||</span> <span class="nb">stristr</span><span class="p">(</span><span class="nv">$_SERVER</span><span class="p">[</span><span class="s1">&#39;REQUEST_URI&#39;</span><span class="p">],</span> <span class="s1">&#39;/wp-login.php&#39;</span><span class="p">)</span> <span class="p">)</span>
	<span class="nv">$upgrading</span> <span class="o">=</span> <span class="nb">time</span><span class="p">();</span>
<span class="cp">?&gt;</span><span class="x"></span>

Möchte man die Meldung noch aussagekräftiger gestalten, kann man die Datei wp-content/maintenance.php erstellen. Beispielinhalt:

<span class="nt">&lt;DOCTYPE</span> <span class="na">html</span> <span class="na">PUBLIC</span> <span class="err">&quot;</span><span class="na">-</span><span class="err">//</span><span class="na">W3C</span><span class="err">//</span><span class="na">DTD</span> <span class="na">XHTML</span> <span class="na">1</span><span class="err">.</span><span class="na">0</span> <span class="na">Strict</span><span class="err">//</span><span class="na">EN</span><span class="err">&quot;</span> <span class="err">&quot;</span><span class="na">http:</span><span class="err">//</span><span class="na">www</span><span class="err">.</span><span class="na">w3</span><span class="err">.</span><span class="na">org</span><span class="err">/</span><span class="na">TR</span><span class="err">/</span><span class="na">xhtml1</span><span class="err">/</span><span class="na">DTD</span><span class="err">/</span><span class="na">xhtml1-strict</span><span class="err">.</span><span class="na">dtd</span><span class="err">&quot;</span><span class="nt">&gt;</span>
<span class="nt">&lt;html</span> <span class="na">xmlns=</span><span class="s">&quot;http://www.w3.org/1999/xhtml&quot;</span> <span class="na">dir=</span><span class="s">&quot;ltr&quot;</span> <span class="na">lang=</span><span class="s">&quot;de-DE&quot;</span><span class="nt">&gt;</span>

	<span class="cp">&lt;?php $heading = &#39;Wartungsarbeiten - Maintenance&#39; ?&gt;</span>

	<span class="nt">&lt;head&gt;</span>
		<span class="nt">&lt;meta</span> <span class="na">http-equiv=</span><span class="s">&quot;Content-Type&quot;</span> <span class="na">content=</span><span class="s">&quot;text/html; charset=utf-8&quot;</span> <span class="nt">/&gt;</span>
		<span class="nt">&lt;link</span> <span class="na">rel=</span><span class="s">&#39;stylesheet&#39;</span> <span class="na">id=</span><span class="s">&#39;login-css&#39;</span>  <span class="na">href=</span><span class="s">&#39;/wp-admin/css/login.css&#39;</span> <span class="na">type=</span><span class="s">&#39;text/css&#39;</span> <span class="na">media=</span><span class="s">&#39;all&#39;</span> <span class="nt">/&gt;</span>
		<span class="nt">&lt;link</span> <span class="na">rel=</span><span class="s">&#39;stylesheet&#39;</span> <span class="na">id=</span><span class="s">&#39;colors-fresh-css&#39;</span>  <span class="na">href=</span><span class="s">&#39;/wp-admin/css/colors-fresh.css&#39;</span> <span class="na">type=</span><span class="s">&#39;text/css&#39;</span> <span class="na">media=</span><span class="s">&#39;all&#39;</span> <span class="nt">/&gt;</span>
		<span class="nt">&lt;title&gt;</span><span class="cp">&lt;?php echo $heading; ?&gt;</span><span class="nt">&lt;/title&gt;</span>
	<span class="nt">&lt;/head&gt;</span>

	<span class="nt">&lt;body&gt;</span>
		<span class="nt">&lt;div</span> <span class="na">style=</span><span class="s">&quot;margin:0px auto; max-width:960px;&quot;</span> <span class="nt">&gt;</span>
			<span class="nt">&lt;h1&gt;</span><span class="cp">&lt;?php echo $heading; ?&gt;</span><span class="nt">&lt;/h1&gt;</span>
			<span class="nt">&lt;br/&gt;</span>
			<span class="nt">&lt;h2&gt;&lt;em&gt;</span>DEUTSCH:<span class="nt">&lt;/em&gt;</span> Administrationsbereich tempor<span class="ni">&amp;auml;</span>r gesperrt<span class="nt">&lt;/h2&gt;</span>
			<span class="nt">&lt;p&gt;</span>Aufgrund von Wartungsarbeiten d<span class="ni">&amp;uuml;</span>rfen derzeit keine <span class="ni">&amp;Auml;</span>nderungen vorgenommen werden. Daher ist der Zugang zur WordPress Verwaltungsoberfl<span class="ni">&amp;auml;</span>che gesperrt.<span class="nt">&lt;/p&gt;</span>
			<span class="nt">&lt;br/&gt;</span>
			<span class="nt">&lt;h2&gt;&lt;em&gt;</span>ENGLISH:<span class="nt">&lt;/em&gt;</span> Admin-Interface temporarly locked<span class="nt">&lt;/h2&gt;</span>
			<span class="nt">&lt;p&gt;</span>Due to scheduled maintenance changes are currently disallowed. Thus login to the WordPress backend is denied. <span class="nt">&lt;/p&gt;</span>
		<span class="nt">&lt;/div&gt;</span>
	<span class="nt">&lt;/body&gt;</span>

<span class="nt">&lt;/html&gt;</span>

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-03: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

<span class="nt">&lt;Context</span> <span class="na">docBase=</span><span class="s">&quot;/home/someuser/some-grails-app.war&quot;</span> <span class="na">path=</span><span class="s">&quot;&quot;</span> <span class="na">reloadable=</span><span class="s">&quot;true&quot;</span><span class="nt">/&gt;</span>

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:

<span class="c"># Verschieben der original ROOT-Applikation:</span>
mv /usr/local/apache-tomcat-7.0/webapps/ROOT /usr/local/apache-tomcat-7.0/webapps/ROOT_orig
<span class="c"># Verlinken der Grails-Beispielapplikation als ROOT.war:</span>
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-03:00

ls -lcrt /var/db/pkg/*/+DESC

Quelle: installdate of a port/package?

Geb Starthilfe - Grails Functional Testing

2011-07-25T00:00:00-03: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:

<span class="cm">/** Ausschnitt aus der Datei BuildConfig.groovy **/</span>
<span class="c1">// ...</span>
<span class="n">grails</span><span class="o">.</span><span class="na">project</span><span class="o">.</span><span class="na">dependency</span><span class="o">.</span><span class="na">resolution</span> <span class="o">=</span> <span class="o">{</span>
<span class="c1">// ...</span>
  <span class="n">dependencies</span> <span class="o">{</span>
    <span class="n">test</span> <span class="s">&quot;org.codehaus.geb:geb-spock:0.6.0&quot;</span>

    <span class="n">def</span> <span class="n">driverVersion</span> <span class="o">=</span> <span class="err">&#39;</span><span class="mf">2.1</span><span class="o">.</span><span class="mi">0</span><span class="err">&#39;</span> <span class="c1">// slow startup if set to &#39;latest.release&#39;</span>
    <span class="n">test</span><span class="o">(</span><span class="s">&quot;org.seleniumhq.selenium:selenium-htmlunit-driver:${driverVersion}&quot;</span><span class="o">)</span> <span class="o">{</span>
      <span class="n">exclude</span> <span class="err">&#39;</span><span class="n">xml</span><span class="o">-</span><span class="n">apis</span><span class="err">&#39;</span>
      <span class="n">exclude</span> <span class="err">&#39;</span><span class="n">xercesImpl</span><span class="err">&#39;</span> <span class="c1">// IMPORTANT!</span>
      <span class="c1">//exclude &#39;xmlParserAPIs&#39;</span>
    <span class="o">}</span>
    <span class="n">test</span> <span class="s">&quot;org.seleniumhq.selenium:selenium-firefox-driver:${driverVersion}&quot;</span>

    <span class="c1">// other drivers ...</span>
  <span class="o">}</span>
<span class="o">}</span>

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</code>

<code>junit.framework.AssertionFailedError: Condition not satisfied:</code>

<code>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.

<span class="kd">static</span> <span class="n">at</span> <span class="o">=</span> <span class="o">{</span>
  <span class="c1">// heading, ...</span>
  <span class="n">title</span> <span class="o">=~</span> <span class="o">/(?</span><span class="n">i</span><span class="o">)</span><span class="n">melde</span><span class="o">/</span>
  <span class="n">$</span><span class="o">(</span> <span class="s">&quot;input.loginbtn&quot;</span><span class="o">,</span> <span class="nl">id:</span><span class="err">&#39;</span><span class="n">loginbtn</span><span class="err">&#39;</span><span class="o">).</span><span class="na">value</span><span class="o">()</span> <span class="o">=~</span> <span class="o">/(?</span><span class="n">i</span><span class="o">)</span><span class="n">anmelden</span><span class="o">/</span>
<span class="o">}</span>

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:

<span class="n">def</span> <span class="n">driver</span> <span class="o">=</span> <span class="k">new</span> <span class="n">HtmlUnitDriver</span><span class="o">(</span><span class="n">BrowserVersion</span><span class="o">.</span><span class="na">FIREFOX_3_6</span><span class="o">)</span> <span class="c1">// fails if BrowserVersion is left to the default value</span>

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:

<span class="n">title</span> <span class="o">=~</span> <span class="o">/(?</span><span class="n">i</span><span class="o">)</span><span class="n">melde</span><span class="o">/</span>

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:

<span class="n">title</span> <span class="o">=~</span> <span class="o">/(?</span><span class="n">i</span><span class="o">)</span><span class="n">melde</span><span class="o">|(?</span><span class="n">i</span><span class="o">)</span><span class="n">login</span><span class="o">/</span>

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:

<span class="n">def</span> <span class="n">subject</span> <span class="o">=</span> <span class="s">&quot;Subject for testing the contact form via Geb&quot;</span>
<span class="c1">// ... some logic</span>
<span class="n">contactForm</span><span class="o">.</span><span class="na">subject</span> <span class="o">=</span> <span class="n">subject</span>

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

DRY-Verwendung von Constraints in Grails-View

2011-05-09T00:00:00-03: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:

<span class="c1">// Constraint in Controller abrufen und an die View übergeben</span>
<span class="k">return</span> <span class="o">[</span> <span class="nl">titleMax:</span>    <span class="n">MyDomain</span><span class="o">.</span><span class="na">constraints</span><span class="o">.</span><span class="na">title</span><span class="o">.</span><span class="na">size</span><span class="o">.</span><span class="na">max</span><span class="o">()</span> <span class="o">]</span>

Constraint in der Grails-View verwenden

z.B. in mydomain/create.gsp

<span class="c">&lt;!-- Constraint in der View nutzen --&gt;</span>
<span class="nt">&lt;g:textField</span> <span class="na">name=</span><span class="s">&quot;title&quot;</span> <span class="na">maxlength=</span><span class="s">&quot;${titleMax}&quot;</span> <span class="nt">/&gt;</span>

Grails Framework Reference: constraints

Suchmaschinenoptimierung Ubuntu Style: Buchstaben im Title zählen

2011-03-10T00:00:00-02: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:

<span class="nb">echo</span> <span class="s1">&#39;ZU PRÜFENDER SEITENTITEL&#39;</span> | 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-02: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.

<span class="c"># 404 - Not Found</span>
<span class="nb">ErrorDocument</span> <span class="m">404</span> <span class="sx">/404.shtml</span>
<span class="c"># 500 - Internal Server Error</span>
<span class="nb">ErrorDocument</span> <span class="m">500</span> <span class="sx">/500.shtml</span>
<span class="c"># 503 - Service Unavailable</span>
<span class="nb">ErrorDocument</span> <span class="m">503</span> <span class="sx">/503.shtml</span>

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:

<span class="err">worker</span>.<span class="err">ajp13_worker</span>.<span class="err">ping_mode=</span><span class="nb">A</span>
worker.ajp13_worker.ping_timeout=10000
<span class="err">worker</span>.<span class="err">ajp13_worker</span>.<span class="err">fail_on_status=500,503</span>

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-02: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”).

Vielleicht schreibe ich demnächst mehr über die Software und ihre breiten Einsatzmöglichkeiten.

Vorerst möchte ich hier 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-02:00

Index-Node (Inode) Nummer der Datei feststellen

ls -di <span class="k">${</span><span class="nv">DATEI</span><span class="k">}</span>

Die gefundene Inode Nummer mittels find suchen

sudo find -L / -inum <span class="k">${</span><span class="nv">INODE_NUMMER</span><span class="k">}</span> 2&gt;/dev/null

Einzeiler zum Finden sämtlicher Verweise auf die Datei

Gleiches wie oben als Einzeiler:

sudo find -L / -inum <span class="sb">`</span>ls -di <span class="k">${</span><span class="nv">DATEI</span><span class="k">}</span> | awk <span class="s1">&#39;{ print $1 }&#39;</span><span class="sb">`</span> 2&gt;/dev/null

Durch den Schalter -d funktioniert der Befehl auch für Verzeichnisse.

ls(1), find(3), awk(1)

Quelle: http://ubuntuforums.org/showthread.php?t=90970

Anzeigen wohin ein symbolischer Link verweist

2010-12-31T00:00:00-02:00

readlink DATEINAME_DES_SYMLINK

Mittels Firefox Erweiterung Flagfox den Domainbesitzer bestimmen

2010-12-29T00:00:00-02: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-03: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:

<span class="nb">JkMount</span> <span class="sx">/NAME_DER_TOMCAT_APPLIKATION/</span>* ajp13_worker

(Details hierzu unter Working with mod_jk)

Jk in der Datei /etc/apache2/mods-enabled/jk.load konfigurieren:

<span class="nb">LoadModule</span> jk_module <span class="sx">/usr/lib/apache2/modules/mod_jk.so</span>
<span class="nb">JkWorkersFile</span>   <span class="sx">/etc/libapache2-mod-jk/workers.properties</span>
<span class="nb">JkLogFile</span>       <span class="sx">/var/log/apache2/mod_jk.log</span>
<span class="nb">JkLogLevel</span>      <span class="k">error</span>

(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:

 <span class="nt">&lt;Connector</span> <span class="na">port=</span><span class="s">&quot;8009&quot;</span> <span class="na">protocol=</span><span class="s">&quot;AJP/1.3&quot;</span> <span class="na">redirectPort=</span><span class="s">&quot;8443&quot;</span> <span class="nt">/&gt;</span>

[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:

<span class="c">&lt;!-- commented out to disable direct access to Tomcat</span>
<span class="c">&lt;Connector port=&quot;8080&quot; protocol=&quot;HTTP/1.1&quot;</span>
<span class="c">connectionTimeout=&quot;20000&quot;</span>
<span class="c">URIEncoding=&quot;UTF-8&quot;</span>
<span class="c">redirectPort=&quot;8443&quot; /&gt;</span>
<span class="c">--&gt;</span>

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-02: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.

<span class="gd">--- rdesktop-1.6.0/xkeymap.c	2007-10-08 14:34:05.000000000 +0200</span>
<span class="gi">+++ rdesktop-1.6.0vle/xkeymap.c	2009-12-09 16:25:32.000000000 +0100</span>
<span class="gu">@@ -597,6 +597,23 @@</span>
 				ui_seamless_toggle();
 			break;

<span class="gi">+		/* Added to allow ALT(left only)+TAB with local machines&#39; windows</span>
<span class="gi">+		* note that no keyboard-shortcut relying on ALT_L will work within the RDP-session! */</span>
<span class="gi">+		case XK_Alt_L:</span>
<span class="gi">+			XUngrabKeyboard(g_display, CurrentTime);</span>
<span class="gi">+</span>
<span class="gi">+		/* alternatively switch Windows on Alt-Tab-Tab */</span>
<span class="gi">+/*		case XK_Tab:</span>
<span class="gi">+			if (get_key_state(state, XK_Alt_L))</span>
<span class="gi">+			{</span>
<span class="gi">+*/</span>
<span class="gi">+				/* Alt-Tab:</span>
<span class="gi">+				* Ungrab the keyboard so that user can use Windows manager&#39;s hot keys */</span>
<span class="gi">+/*</span>
<span class="gi">+				XUngrabKeyboard(g_display, CurrentTime);</span>
<span class="gi">+			}</span>
<span class="gi">+*/</span>
<span class="gi">+			break;</span>
 	}
 	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-03: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-03: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:

<span class="c"># jhead installieren</span>
sudo apt-get install jhead
<span class="c"># &quot;Time-adjust&quot; um minus 6 Stunden</span>
jhead -ta-6:00 <span class="k">${</span><span class="nv">JPEG_BILD</span><span class="k">}</span>

jhead(1)

T Mobile web'n'walk Card compact III in Ubuntu 8.04 einrichten

2008-07-14T00:00:00-03: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
<span class="nb">cd </span>hso
make
sudo make install

Rezero installieren

tar xzvf rezero_hso-udev.tar.gz
<span class="nb">cd </span>rezero_hso-udev
<span class="c"># Direkt installieren, statt, wie in manchen Anleitungen beschrieben, neu kompilieren (make)</span>
sudo make install

Treiber “option” in Blacklist aufnehmen

Da der option Treiber mit HSO in Konflikt steht, muss er per Blacklisting deaktiviert werden.

<span class="nb">echo</span> <span class="s2">&quot;blacklist option&quot;</span> &gt;&gt; /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-03: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:

<span class="c"># audiodump.wav erzeugen</span>
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 <span class="k">${</span><span class="nv">BELIEBIGER_PRAEFIX</span><span class="k">}</span>

bchunk(1)

Dateien in Verzeichnis zählen

2006-05-10T00:00:00-03:00

find ./ -type f | wc -l

find(3), wc(1)

KDE Version ausgeben

2005-11-17T00:00:00-02:00

<span class="c"># in KDE3</span>
kde-config -v

<span class="c"># in KDE4</span>
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 <span class="nv">robots</span><span class="o">=</span>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 <span class="s1">&#39;{ if ($0) print }&#39;</span> &gt; outfile