seeseekey.net - Invictus Deus Ex Machina

In den letz­ten Jah­ren sind sie aus dem Boden geschos­sen, soge­nannte „Read it later“-Dienste. Diese Dienste spei­chern dabei Arti­kel wel­che man erst spä­ter lesen möchte. Mög­lich wird dies durch Book­marklets, Add-Ons und Apps wel­che die jewei­li­gen Arti­kel zum ent­spre­chen­den „Read it later“-Dienst schie­ben. Mit der freien Soft­ware walla­bag, wel­che frü­her unter dem Namen poche bekannt war, kann man einen sol­chen Dienst sel­ber hosten.

Die Login-Seite von wallabag

walla­bag setzt auf PHP auf und ist unter der „DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE“ lizen­siert, und damit freie Soft­ware, wie man dem Lizenz­text ent­neh­men kann:

            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                    Version 2, December 2004

 Copyright (C) 2004 Sam Hocevar 

 Everyone is permitted to copy and distribute verbatim or modified
 copies of this license document, and changing it is allowed as long
 as the name is changed.

            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. You just DO WHAT THE FUCK YOU WANT TO.

Wich­tig ist nur das der Name der Appli­ka­tion geän­dert wird, wenn man diese for­ken möchte. walla­bag kann auf der offi­zi­el­len Seite des Pro­jek­tes unter www.wallabag.org bezo­gen werden.

Wenn man eine PHP-Applikation schreibt, wel­che in irgend­ei­ner Form mit Daten han­tiert, so feh­len einem bei der Ent­wick­lung meist plau­si­ble Test­da­ten. An die­ser Stelle springt die Biblio­thek Faker ein. Mit die­ser Biblio­thek ist es mög­lich die unter­schied­lichs­ten Daten zu erzeu­gen. Ein Mini­mal­b­ei­spiel würde dabei so aussehen:

require_once '/path/to/Faker/src/autoload.php';
$faker = Faker\Factory::create();
echo $faker->name; //Erzeugt einen Namen

Mög­lich wird dies durch die unter­schied­lichs­ten Pro­vi­der wel­che ange­fan­gen bei Lorem Ipsum über Mail­adres­sen bis Datums­an­ga­ben und Has­hes alles lie­fern was das Herz begehrt. Die Biblio­thek selbst steht unter der MIT-Lizenz und ist somit freie Soft­ware. Zu fin­den ist Faker in einem Git­Hub Repo­sitory.

Wer Entity-Relationship-Modelle bzw. die ent­spre­chen­den Dia­gramme (ERD) erstel­len möchte, der kann hier­für Soft­ware wie die freie MyS­QL­Work­bench nut­zen. Für das platt­form­über­grei­fende Erzeu­gen sol­cher Dia­gramme kann man aller­dings auch die freie Webap­pli­ka­tion wwws­ql­de­si­gner nutzen.

Der ERD-Designer in Aktion

Auf der Web­seite des Autors gibt es eine Demo zum Aus­pro­bie­ren. Die in PHP und Java­script geschrie­bene Soft­ware steht dabei unter einer BSD-Lizenz und ist somit freie Soft­ware. Bei der Instal­la­tion muss das ent­spre­chende Archiv nur auf dem Web­ser­ver ent­packt wer­den und kann sofort genutzt wer­den. Nur wer die Mög­lich­kei­ten der ser­ver­sei­ti­gen Spei­che­rung nut­zen möchte, muss einige Para­me­ter kon­fi­gu­rie­ren.

Wenn man auf sei­nem Ser­ver in den zu PHP gehö­ren­den Log­da­teien die Meldung:

PHP message: PHP Warning:  date(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected the timezone 'UTC' for now, but please set date.timezone to select your timezone.

fin­det, sollte man die Varia­ble „date.timezone“ in der „php.ini“ kon­fi­gu­rie­ren. Für Deutsch­land würde die Ein­stel­lung dabei wie folgt aussehen:

[Date]
; Defines the default timezone used by the date functions
; http://php.net/date.timezone
date.timezone = Europe/Berlin

Nach­dem der PHP-Service neu­ge­star­tet wurde, gehö­ren diese War­nun­gen der Ver­gan­gen­heit an.

Seit der neuen Ubuntu-Version Saucy Sala­man­der (13.10) befin­det sich die JSON Unter­stüt­zung für PHP nicht mehr im Standard-PHP-Paket. Aus die­sem Grunde muss das ganze mittels:

apt-get install php5-json

nach­in­stal­liert wer­den. Nach einem Neu­start des PHP-Service (in die­sem Fall der Fast­CGI Variante):

service php-fpm restart

kann die PHP JSON Unter­stüt­zung unter Ubuntu 13.10 genutzt werden.

Manch­mal möchte aus einer Desk­to­pan­wen­dung her­aus eine Mail ver­schi­cken. Das ist inso­fern pro­ble­ma­tisch, da man die Zugangs­da­ten für einen Mai­lac­count nicht in einer Anwen­dung hin­ter­le­gen sollte. Aus Web­an­wen­dun­gen her­aus ist das Sen­den von Mails dage­gen eine ein­fa­che Sache. Also was liegt näher als die­sen Vor­teil für das Sen­den von Mails aus Desk­to­pan­wen­dun­gen her­aus zu nutzen.

<?php
    $reciever=$_POST["reciever"];
    $allowedRecieverDomain="example.org";
    $subject=$_POST["subject"];
    $text=$_POST["message"];

    //Sender
    $senderName="Mailer";
    $sender="mailer@example.org";

    //Additional challenge
    $challenge="abc123";
    if($challenge!=$_POST["challenge"]) return;

    //Check reciever
    $atCount=substr_count($reciever, "@");
    if($atCount>1) return;

    if(!(strpos($reciever, "@" . $allowedRecieverDomain)===FALSE))
    {
        mail($reciever, $subject . " - (" . date("d.m.y - H:m:s") . ")", $text, "From: $senderName <$sender>");
    }
?>

Ein klei­nes PHP Skript mit dem Namen „mailer.php“ sorgt dafür das die Mail bzw. der Text der Mail in Emp­fang genom­men wird. Anschlie­ßend wird nach­ge­schaut ob die Mail an einen vali­den Sen­der adres­siert ist. In die­sem Bei­spiel wer­den nur Mails an @example.org wei­ter­ge­lei­tet. Schließ­lich möchte man keine Spamschleu­der betrei­ben. Nun müs­sen die Para­me­ter in der Anwen­dung noch per POST-Request über­ge­ben wer­den. Unter C# könnte das ganze so aussehen:

System.Net.ServicePointManager.Expect100Continue=false;

string url="http://example.org/mailer.php";

using(var wb=new WebClient())
{
    var data=new NameValueCollection();
    data["sendername"]="Mailer";
    data["sender"]="mailer@example.org";
    data["reciever"]="developer@example.org";
    data["subject"]="Mail from Application";
    data["message"]="Message";

    var response=wb.UploadValues(url, "POST", data);
}

Der Quell­code ist dabei auf Git­Hub zu fin­den und steht unter der AGPL.

Unter Umstän­den kann es vor­kom­men, das man sein Word­Press auf einem Ser­ver betreibt, wel­cher keine PHP „mail()“ Funk­tion unter­stützt. In die­sem Fall soll­ten die Mails per SMTP ver­sen­det wer­den. Mög­lich wird dies mit dem Plu­gin „Easy WP SMTP“. Damit wer­den die Mails nicht mehr über die PHP-Funktion, son­dern über einen SMTP Account versendet.

Die Ein­stel­lun­gen des Plugins Easy WP SMTP

Bei der Kon­fi­gu­ra­tion des Plugins wer­den SSL und TLS unter­stützt, so das hier die Zugangs­da­ten nicht im Klar­text durch das Netz gesen­det werden.

Stan­dard­mä­ßig liegt das Uploadli­mit für Dateien einer Nginx Instal­la­tion mit der ent­spre­chen­den PHP-Installation bei 2 MiB. Damit stößt man natür­lich bei vie­len Anwen­dun­gen sehr schnell an die Grenze, so z.B. beim Upload von grö­ße­ren Bil­dern. Möchte man dies ändern, müs­sen sowohl die Nginx-Konfiguration als auch die PHP-Konfiguration ange­passt wer­den. Im ers­ten Schritt wird die Nginx-Konfuration bearbeitet:

nano /etc/nginx/nginx.conf

Dort wird im „http“-Block die Zeile:

client_max_body_size 1024m;

hin­zu­ge­fügt. Unter Umstän­den muss hier auch die „client_body_timeout“-Option mit einem höhe­ren Time­out ver­se­hen wer­den. Dies sollte man aller­dings durch eigene Tests her­aus­fin­den. Nach­dem Nginx kon­fi­gu­riert ist, geht es an die „php.ini“-Datei:

nano /etc/php5/fpm/php.ini

Dort müs­sen fol­gende Para­me­ter gesetzt werden:

post_max_size = 1024M
upload_max_filesize = 1024M

Nach­dem das erle­digt ist, kön­nen Nginx und der PHP Ser­vice neu­ge­star­tet werden:

service nginx restart
service php5-fpm restart

Anschlie­ßend ver­fügt man in die­sem Fall über ein neues Upload Limit von 1024 MiB.

In einem mei­ner letz­ten Arti­kel gibt es darum, wie man Fire­fox Sync in Ver­bin­dung mit own­Cloud nutzt. Augen­schein­lich gibt es im Zusam­men­hang damit ein Pro­blem, das dass ganze nach dem Neu­start von Fire­fox nicht mehr rich­tig funk­tio­niert. Natür­lich kann man die ent­spre­chende App in own­Cloud deak­ti­vie­ren, aller­dings blei­ben dabei noch einige Ein­träge in der Daten­bank erhal­ten. Mit die­sem Skript kön­nen diese Ein­träge ent­fernt werden:

<?php
//Configuration
$dbServer = "localhost";
$dbDatabase = "owncloud";
$dbUsername = "user";
$dbPassword = "secret";

//Set up connection
$mySQLConnection = mysql_connect($dbServer, $dbUsername, $dbPassword) or die ("keine Verbindung möglich. Benutzername oder Passwort sind falsch!");
mysql_select_db($dbDatabase) or die ("Die Datenbank existiert nicht.");

//Cleanup ownCloud Tables
mysql_query("DELETE FROM `$dbDatabase`.`oc_appconfig` WHERE `oc_appconfig`.`appid` = 'core' AND `oc_appconfig`.`configkey` = 'remote_mozilla_sync' AND `oc_appconfig`.`configvalue` = 'mozilla_sync/appinfo/remote.php'");

mysql_query("DELETE FROM `$dbDatabase`.`oc_appconfig` WHERE `oc_appconfig`.`appid` = 'mozilla_sync' AND `oc_appconfig`.`configkey` = 'enabled' AND `oc_appconfig`.`configvalue` = 'no'");
mysql_query("DELETE FROM `$dbDatabase`.`oc_appconfig` WHERE `oc_appconfig`.`appid` = 'mozilla_sync' AND `oc_appconfig`.`configkey` = 'installed_version' AND `oc_appconfig`.`configvalue` = '1.0'");
mysql_query("DELETE FROM `$dbDatabase`.`oc_appconfig` WHERE `oc_appconfig`.`appid` = 'mozilla_sync' AND `oc_appconfig`.`configkey` = 'types' AND `oc_appconfig`.`configvalue` = ''");

//Drop tables
mysql_query("DROP TABLE `oc_mozilla_sync_collections`, `oc_mozilla_sync_users`, `oc_mozilla_sync_wbo`;");

//Close connection
mysql_close($mySQLConnection);
?>

Zu fin­den ist das Skript auf Git­Hub. Es ent­fernt dabei die Tabel­len „oc_mozilla_sync_collections“, „oc_mozilla_sync_users“ und „oc_mozilla_sync_wbo“. Dane­ben wird die Tabelle „oc_appconfig“ um die Ein­träge der App bereinigt.

Mit­tels Nginx ist ein Web­ser­ver mit PHP und MySQL in ein paar Minu­ten ein­ge­rich­tet. Dazu instal­liert man unter Ubuntu fol­gende Pakete:

sudo apt-get install mysql-server nginx php5-fpm php5-curl php5-gd php5-imap php5-mysql

Nach der Instal­la­tion der nöti­gen Pakete geht es an die grund­le­gende Kon­fi­gu­ra­tion des Webserver:

mkdir -p /var/www/example.org/root
mkdir -p /var/www/example.org/test
cd /var/www
chown -R www-data:www-data . 
usermod -a -G www-data nutzername

In die­sem Bei­spiel soll die Domain „example.org“ sowie die Sub­do­main „test.example.org“ ein­ge­rich­tet wer­den. Des­halb legen wir zwei Ord­ner an. Anschlie­ßend tei­len wir Nginx mit, wel­che Domains und Sub­do­mains der Web­ser­ver ver­wal­ten soll. Dazu legen wir die Datei „/etc/nginx/sites-available/example“ an und fül­len diese mit fol­gen­dem Inhalt:

server {
        listen   80;
        listen [::]:80;

        root /var/www/example.org/root;
        index index.php index.html index.htm;
 
        server_name .example.org;

        location ~ \.php$ {
                fastcgi_pass unix:/var/run/php5-fpm.sock;
                fastcgi_index index.php;
                include fastcgi_params;
        }
}

server {
        listen   80;
        listen [::]:80;

        root /var/www/example.org/test;
        index index.php index.html index.htm index.php; 

        server_name test.example.org;

        location / {
            auth_basic "Access denied";
            auth_basic_user_file /var/www/example.org/root/.htpasswd;

            autoindex on;
        }

        location ~ \.php$ {
                fastcgi_pass unix:/var/run/php5-fpm.sock;
                fastcgi_index index.php;
                include fastcgi_params;
        }
}

Im ers­ten Block wird die Domain „example.org“ defi­niert und kon­fi­gu­riert. Durch die Nota­tion „.example.org“ wird Nginx ange­wie­sen, jede Sub­do­main wel­che nicht defi­niert ist, auf die Haupt­seite umzu­lei­ten. Für die Domain „test.example.org“ wurde außer­dem ein Pass­wort­schutz ange­legt und die Ver­zeich­nis­an­sicht akti­viert. Damit die Kon­fi­gu­ra­tion auch aktiv wer­den kann, muss eine sym­bo­li­sche Ver­knüp­fung in das Ver­zeich­nis „/etc/nginx/sites-enabled“ ange­legt werden:

ln -s /etc/nginx/sites-available/example /etc/nginx/sites-enabled/example

Die beste­hende „default“-Datei im „sites-enabled“ Ord­ner ent­hält eine Bei­spiel­kon­fi­gu­ra­tion. Diese kann ent­wer­der ent­fernt wer­den oder kon­fi­gu­riert werden:

server {
        listen   80 default_server;
        listen [::]:80 default_server ipv6only=on;

        root /var/www/default/root;
        index index.php index.html index.htm;
 
        server_name _;
}

Mit die­ser Kon­fi­gu­ra­tion wird jede Seite auf Default umge­lei­tet, wel­che nicht in ande­ren Kon­fi­gu­ra­tio­nen auf­taucht. Nun muss nur noch der Web­ser­ver (und des PHPs Moduls) neu­ge­star­tet werden:

service nginx restart
service php5-fpm restart

Ist der Ser­ver bereits online, reicht es auch die Kon­fi­gu­ra­tion neuzuladen:

service nginx reload

Soll­ten wäh­rend der Kon­fi­gu­ra­tion Feh­ler auf­tre­ten, so hilft ein Blick in das ent­spre­chende Log:

cat /var/log/nginx/error.log

Benö­tigt man eine Daten­bank für die gewünschte Web­an­wen­dung, so muss diese in die SQL Daten­bank ein­ge­spielt wer­den. Ist alles rich­tig kon­fi­gu­riert wor­den, läuft der Web­ser­ver auf Port 80 und war­tet auf erste Anfragen.