Das Script lädt die Datei mit cURL über die offzielle Website hoch. Nicht wirklich eine saubere Lösung, funktioniert aber perfekt. Naja, fast: Über die Website sind nur Uploads bis 150MB möglich, meine Backup-Zips sind aber inzwischen schon 188MB groß (ich blogge zu viel ). Daher habe ich mir ein kleines Script gebastelt, das die Dateien durchgeht, und alle die größer als 100MB sind, mit Hilfe von split in Teile á 100MB schneidet. Dabei wird dann einfach ein fortlaufender Buchstabe an den Dateinamen angehängt. Dazu habe ich das Upload Script noch so modifiziert, das es Dateien, die größer als 100MB sind, gar nicht erst hoch lädt (da sie eh nicht verarbeitet werden).

Als drittes im Bunde habe ich dann noch ein kleines Script das einen Dump der Datenbank erstellt, und zu guter Letzt noch ein Script, das alle die kleinen anderen Scripte der Reihe nach aufruft (und dabei noch ein VERBOSE Option zum testen durchreicht).

Mit diesem System habe ich jetzt meine Backups hoffentlich im Griff Bash-Scripting ist nicht wirklich mein Lieblingsthema… Aber ich hatte jetzt auch keine Lust das in C++ zu machen

Soviel zur Theorie, hier sind die ganzen Skripte:

Der Dump der Datenbank:

/usr/bin/mysqldump --all-databases --user=backup --password=verratichnicht > /var/backup/sqldump/backup_full_`date "+%y_%m_%d"`.sql

Das Zerteilen der Dateien in kleine Stücke:

#!/bin/bash

function split_dir
{
for i in *; do
if [ -f "$i" ]; then
FILESIZE=$(stat -c%s "$i")
if [ $FILESIZE -gt "104857600" ]; then
if [ $VERBOSE -eq 1 ]; then
echo "$1 is too big, splitting"
fi
split -a 1 -b 100M $i `basename $i`_
fi
fi

if [ -d "$i" ]; then
local OLD_PWD=$(pwd)
cd "$i"
split_dir "$1/$i"
cd "$OLD_PWD"
fi
done
}

cd $1
split_dir $1

Mein modifizierter Dropbox-Uploader: (Nur als Diff, sonst ist das ewig viel Text, das Original gibst hier)

26,27c26,27
< LOGIN_EMAIL="ich@ich.de"
< LOGIN_PASSWD="supergeheim"
---
> LOGIN_EMAIL=""
> LOGIN_PASSWD=""
90c90
<
---
>
101,107c101,102
<     FILESIZE=$(stat -c%s "$UPLOAD_FILE")
<
<     if [ $FILESIZE -gt 104857800 ]; then #file to big for upload (slighly more than 100M
<          print  "$UPLOAD_FILE is too big, ignoring."
<     else
<         curl $CURL_PARAMETERS -i -b $COOKIE_FILE -o $RESPONSE_FILE -F "plain=yes" -F "dest=$DEST_FOLDER" -F "t=$TOKEN" -F "file=@$UPLOAD_FILE"  "$UPLOAD_URL"
<         grep "HTTP/1.1 302 FOUND" "$RESPONSE_FILE" > /dev/null
---
>     curl $CURL_PARAMETERS -i -b $COOKIE_FILE -o $RESPONSE_FILE -F "plain=yes" -F "dest=$DEST_FOLDER" -F "t=$TOKEN" -F "file=@$UPLOAD_FILE"  "$UPLOAD_URL"
>     grep "HTTP/1.1 302 FOUND" "$RESPONSE_FILE" > /dev/null
109,116c104,108
<         if [ $? -ne 0 ]; then
<             print " Failed!\n"
<             if [ $END_ON_UPLOAD_ERROR -eq 1 ]; then
<                 remove_temp_files
<                 exit 1
<             fi
<         else
<             print " OK\n"
---
>     if [ $? -ne 0 ]; then
>         print " Failed!\n"
>         if [ $END_ON_UPLOAD_ERROR -eq 1 ]; then
>             remove_temp_files
>             exit 1
117a110,111
>     else
>         print " OK\n"

Und jetzt noch das eigentliche Skript, das alle aufruft, und dabei die -v Option durchreicht:

#!/bin/bash

#Helper scripts that calls all the backupscripts.
#-dumps all MySQL DBs
#-split big zip files in /backup
#-uploads all to dropbox

VERBOSE=0

#if the first argument is -v, the verbose mode for this scritp, and all scripts called is enable
if [ "$1" == "-v" ]; then
VERBOSE=1
fi

#create the MySQL dump
if [ $VERBOSE -eq 1 ]; then
echo "Doing DB Dump..."
fi
./backup_db.sh

#split big files
if [ $VERBOSE -eq 1 ]; then
echo "Splitting files..."
fi
env VERBOSE=$VERBOSE ./split_files.sh /var/backup

#upload all
if [ $VERBOSE -eq 1 ]; then
echo "Starting upload..."
./dropbox_uploader.sh -f /var/backup -d /ServerBackup -v
else
./dropbox_uploader.sh -f /var/backup -d /ServerBackup
fi

#done
if [ $VERBOSE -eq 1 ]; then
echo "Done!"
fi

Die Krönung wäre jetzt noch ein kleines Programm, das die Dateien auf meinem Rechner erkennt, wieder zusammensetzt, und in die Dropbox schiebt. Aber das kann ich immer noch machen, wenn ich das Backup mal brauche

Mal sehen, wie sich mein Sammelsurium von Skripten so macht!

Die Lösung, die auch schon in Piwiks Trac diskutiert wird, und auch in dem oben verlinkten Artikel vorgestellt wird, ist es, nach einer gewissen Frist einen “Pulsschlag” an Piwik zu senden, um anzuzeigen, das der Besucher noch auf der Seite ist. Die Lösung aus dem Artikel hat den Nachteil, das dadurch viele falsche Page-Impression erzeugt werden, weil Piwik (noch) kein API hat, um zu sagen “Besucher ist noch da”. Das einzige, was man machen kann, ist, den Klick auf einen Link vorzutäuschen. (Wenn man nicht im Core etwas ändern will).

Meine Idee (siehe auch die Kommentare) war es jetzt, darauf zu warten, das der Besucher die Seite verlässt, und erst dann einen “Klick” an Piwik zu senden. Damit würde jeder Besucher pro Seite nur zwei Aktionen auslösen, und die Besuchslänge sollte genau erfasst werden (im Gegensatz zum Pulsschlag alle x Sekunden).

Die meisten Browser (Ausnahme: Opera) bieten auch ein passendes Event für diesen Zweck an: onbeforeunload wird ausgelöst, kurz bevor der Browser die Seite verlässt. Darüber werden zum Beispiel Sicherheitsabfragen realisiert. Es gibt zwar auch onunload, aber das wird z.B. von Firefox nicht ausgelöst, wenn man den Browser schließt.

Ich habe jetzt also in meine Website ein kleines bisschen JavaScript eingefügt:

window.onbeforeunload = trackUnloadPage;
function trackUnloadPage()
{
    if(piwikTracker)
    {
        piwikTracker.trackPageView("unload event");
    }
}

Dieser Code signalisiert Piwik jetzt einen Besuch der Seite “unload event”, wenn der Browser geschlossen wird. Wie die Statistik zeigt, funktioniert meine Lösung recht gut.

Seltsamerweise gibt es immer noch (Nicht-Opera) Besucher, die nur eine Aktion auslösen. Evtl. löst ein anderer Browser das Event auch nicht immer aus, oder es kommt zu einer Race-Condition (Browser schon zu, bevor der Aufruf abgeschickt wurde).

Ich hoffe jetzt, das Piwik noch eine API für die “stillen Events” bietet, damit sie nicht die anderen Statistiken verfälschen… Vielleicht werde ich mir den Code auch selber mal ansehen

Dropbox hat einen gewissen Hang dazu ein bisschen viel Speicher zu verbrauchen (100% sind 20 GB).

Jetzt muss ich mir wohl was anderes überlegen, um meine Backups in die Dropbox zu schieben…

Was mich dieses Jahr begeistert hat, war die Großzügigkeit vieler Firmen in der Vorweihnachtszeit. Von Apple kennt man es ja schon, das es wieder nach Weihnachten 12 Tage Geschenke gibt, aber auch netcup hatte dieses Jahr einen Adventskalender mit viele wirklich guten Angeboten (aber leider nichts für mich). Die besten Angebote hat aber immer noch Steam: Da wird momentan richtig was rausgehauen (noch bis zum 1. Januar). Ich hab gestern Half-Life 1, HL1 Opposing Force, HL1 Blue Shift, Team Fortress Classic, Half Life 2 und HL2 Episode 1 für 7,72€ abgestaubt! Und jeden Tag gibt es auf andere Sachen 75% Rabatt. Das hat mich echt umgehauen!

Klar, das ist alles Marketing, aber es ist wirklich eine nette Geste. Also: Freut euch über Geschenke, aber denkt immer daran, was für ein großes Geschenk Gesundheit ist (das habe ich grade wieder am eigenen Leib erfahren). Genießt die Feiertage, kommt ein bisschen zur Ruhe.

Frohe Weihnachten 2011!

Die Aufgabe war es, zu untersuchen, ob das Integral der Funktion in Y₁ von 0 bis unendlich existiert (uneigentliches Integral). Und man könnte ja nun auf die Idee kommen, einfach die größtmögliche Zahl für unendlich einzusetzen: 10⁹⁹ mit mehr (oder weniger) kann der Rechner ja bekanntlich nicht umgehen.

Dummerweise gibt es wohl einen Bug in der Software, denn ab 10⁵ wird das Integral (das auch in Bild 3 zu sehen ist) leider null… Die richtige Lösung bekommt man mit der oberen Grenze von 100o: -70. Oder natürlich auch per Hand…

Besonders, wenn man grade diese Potenz des planckschen Wirkungsquantum braucht… Die Ursache ist einfach: h^3 ist weniger als 1E-99, und damit für den TI84+ leider gleich null…

Ich hab so ein ähnliches Spiel vor einiger Zeit mal lange auf meinem iPod gespielt, die Windows-Version wollte mich jetzt grade nicht so vom Hocker hauen. Relativ geringe Auflösung und alles in allem etwas billig gemacht. Typisches Casual-Game halt Aber die machen sicher ihr Geld mit diesen Spielen… Wo wir grad beim Thema sind: Plants vs. Zombies ist auch von PopCap und meiner Meinung nach um Längen besser. Bei Zuma wundert mich das verschenken nicht. Aber schaut es euch ruhig mal an. Gibt es auch für den Mac, BTW

[via]

Die Lösung: Einfach gleich die x86-Version benutzen, die funktioniert einwandfrei… Warum es zu so einem Fehler kommen kann, weiss ich aber auch nicht…

Jedes Jahr hat in jedem Monat einen Tag, der die gleiche Zahl wie der Monat trägt. Macht 12 von 365,2425 Tagen, macht 3,28% Anteil dieser Tage.

Davon kann man 10 mit nur einer Ziffer schreiben (1.1 – 9.9 + 11.11). Das macht 2,73%.

In jedem Jahrhundert gibt es 12 Tage, an denen die Zahlen von Tag, Monat und Jahr (mit zwei Ziffern) genau übereinstimmen. Das sind 12 von 3652,425 Tagen, also 0,32%. Einer dieser Tage ist bekanntlich heute

Davon kann man genau einen mit nur einer Ziffer schreiben, nämlich den 11.11.11. Das sind genau 0,00027%.

Weiter geht es in den Jahrtausenden: Dort kommt es wieder genau ein Mal vor, das man nur eine Ziffer benutzen muss, um auch ein Datum mit dreistelliger Jahreszahl zu schreiben: Am 11.11.111, der heute nicht ist… Das sind grade noch 0,000027%.

Jetzt wird es richtig groß: Pro “Jahrzehntausend” gibt es wieder zwölf Tage, an denen man den Tag bzw. Monat zwei Mal in der Jahreszahl finden, nämlich den 01.01.0101 usw. Das sind unglaubliche 0,00000032%.

Und schlussendlich gibt es davon wieder genau einen Tag, an dem tatsächlich alle acht Ziffern des Datums die gleiche Zahl zeigen, den 11.11.1111, und das ist an 0,000000027% der Tage der Fall. Da gibst dann auch eine richtig große Party. Ach ne, das war ja schon, und bis zum nächsten Jahrzehntausend ist die Welt ja schon untergegangen. So ein Pech aber auch…

Das waren die 7 Fakten zum 11.11.11. Warum sieben? Weil Baum

Lösung: Einfach alle so verschieben, dass der Koordinatenursprung in der Instance da ist, wo man ihn haben will…

Kurz ein paar Worte zum Hintergrund: Mit .NET 4.0 wurde die sog. Dynamic Language Runtime (DLR) eingeführt. Die dient zum einen dazu, es Entwicklern einfacher zu machen, neue Sprache auf .NET Basis zu entwickeln (wie IronPython/IronRuby), hat aber auch ein paar tolle andere Features zu bieten. Eines davon ist das neue Schlüsselwort “dynamic”. Es funktioniert ähnlich wie “var” kann also jeden Typ annehmen. Wenn man darin aber ein Objekt speichert, das von System.Dynamic.DynamicObject abgeleitet ist, kann man bestimmen was passiert, wenn etwas “nicht erlaubtes” passiert, also wenn z.B. eine Methode aufgerufen wird, die es gar nicht gibt. Solche Aufrufe landen dann bei der Methode TryInvokeMember, und die kann dann entscheiden, was passieren soll.

Dieses Konzept habe ich jetzt genutzt, um einen Wrapper für das LuaInterface zu schreiben. Das Lua Interface ist eine Library für .NET, die es erlaubt, Lua in C# zu benutzen. Dabei kümmert sie sich auch darum, .NET Objekte in Lua abzubilden und vieles mehr. Diese Library ist wirklich unglaublich, man denkt wirklich, Lua hätte was mit Objekten am Hut.

Meine Idee war es jetzt, über das LuaInterface eine neue Hülle zu stecken, die es zusammen mit der DLR ermöglicht, Lua noch einfacher in C# (und anderen .NET Sprachen zu benutzen). Hier ein kleines Beispiel:

// Start a new Lua interpreter
dynamic lua = new DynamicLua.DynamicLua(); //Namespace and class name are the same!
// Run Lua chunks
lua("num = 2"); //no DoString()!
lua("str = ’a string’");
// Read global variables ’num’ and ’str’
double num = lua.num; //No explicit casting, no index operator!
string str = lua.str;
// Write to global variable ’str’
lua.str = "another string"; //No index operator
//Increase a global value
lua.num += 10; //A LOT cleaner

Wie man sehen kann wird eine neue Instanz des Interpreters erzeugt, wenn man ihn aufruft wie eine Funktion wird der Lua Code ausgeführt. Variablen aus Lua sind einfach als Eigenschaften des Objektes vorhanden. Es ist kein Problem, .NET Klasse an Lua zu schicken, eine einfache Zuweisung reicht. Noch ein paar der Features:

• Einfacher Zugriff auf Lua-Variablen
• Aufruf von Lua-Funktionen aus C#
• C#-Funktionen können in Lua Variablen gespeichert werden
• Lua-Table können in C# Variablen gespeichert werden
• Lua Metatables können in C# benutzt werden
• Open-Source (Apache Lizenz 2.0)
• Unit-Tests

Ich denke, mit DynamicLua ist es wirklich einfach Lua in C# einzubinden, weil vieles genau so funktioniert, wie man es erwarten würde. Das war zumindest mein Design-Ziel.

Genug der lobenden Worte, alles weitere ist auf der Codeplex-Seite zu finden: DynamicLua bei Codeplex. Momentan ist dort die Beta der Version 1.0 zu finden.

So, machen wir also weiter mit „Ich schreibe Sachen auf, die mir zu London einfallen”. So langsam haben wir die wichtigsten Sehenwürdigkeiten abgeklappert, auch wenn die Westminster Abbey leider geschlossen war (natürlich nur Freitags…). Davor hing noch ein Schild, das das zwar eine Kirche sei, aber es ja auch noch andere gibt, und man hier leider nicht umsonst beten kann. Naja, müssen wir wohl die £20 zahlen. Ja tatsächlich, das iPad hat auch eine Taste für das Pfundzeichen

Ganz wichtig war natürlich der Besuch der Apple Stores, auch wenn de gar nicht geplant war. Ist schon beeindruckend dar, ich hatte vorher noch keinen “richtigen” Apple Store gesehen. Neben jedem Mac liegt ein iPad 2, das nur dafür da ist, den Preis und ein paar Infos anzuzeigen… Die haben’s echt gut da. Ich würde gerne ein paar Fotos zeigen, aber leider hab ich kein Camera Connection Kit, und kann daher nur Fotos mit dem iPad machen. Und da bin ich nicht mal sicher, ob die überhaupt ohne Intenet gespeichert werden. Werden wir ja sehen.

So weiter im Text (bzw. im sinnlosen rumgeschreibe). Morgen wollen wir versuchen auf das London Eye zu kommen, das Riesenrad an der Themse. Dummerweise muss man die Karte eine ganze Zeit im Vorraus kaufen, weil der Andrang so groß ist. Das Risenrad braucht eine halbe Stunde für eine Umdrehung, aber es hat am Bode immer noch bestimmt einen Meter pro Sekinde drauf, so dass sie es für jede Kabiene anhalten müssen, wenn die 25 Insassen wechseln. Darus berechen wir: Es ist…groß. Dazu gibt es noch ein 4D Show (mit Zeitmaschiene???), wohingegen es im London Dungeon eine 5D Show geben soll, was mir doch etwas zu denken gibt…

Jetzt werde wir erst Mal, sehen, dass wir etwas zu Essen bekommen. Mal sehen, vielleicht gibt es ja noch einen dieser wahnsinnig spannenden Einträge, die die Besucherzahlen meines Blogs gleich in verdoppeln werden So wie es aussieht werden wir wohl nicht mehr nach Greewich kommen, auch wenn ich gerne einen Geocache auf dem Nullmeridian gehoben hätte. Wieso schlägt das iPad “Nullmeridian” vor, nachdem ich nur “Null” eingeben haben? Aber ich drifte ab, und ich glaube wir lassen das ganze jetzt mal.

Hinweis: Leider gibst hier im Hotel kein WLAN, daher werde ich die Artikel (wenn es mehr als dieser eine werden) wohl etwas zeitversetzt veröffentlichen. Außerdem schreibe ich auf dem iPad, ich habe also eine neue Ausrede für die vielen Tippfeheler

So, es sind also Herbstferien. Und damit dieser Blog hier nicht allzu sehr ins technische abrutscht, gibt es jetzt ein paar Zeilen aus meinem Urlaubsziel, London.

Momentan bin ich wirklich begeistert von London, eine tolle Stadt. Man merkt den Unterschied zu Deutschland. Die Leute sehen hier besser gekleidet aus, fast alle laufen hier mit modischem Schal rum, wenn nicht gleich mit Anzug. Mir sind bestimmt heute schon 5 kleine Jungen im Anzug entgegengekommen. Verrückt.

Was mich aber richtig begeistert hat, ist die U-Bahn, oder besser die Underground, alias “the Tube”. Stationen und Züge machen dem Namen alle Ehre, alles ist rund (und niedrig…). Die Züge selber sind alle etwas älter, und nicht besonders bequem (weil rund), aber an beiden Seiten mit extrem weichen und bequemen Sitzpolstern ausgestattet. Nicht wie bei uns in der U-Bahn mit diesen harten Plastiksitzen (die dafür wieder ziemlich bequem sind…). Auch ansonsten wirkt hier alles nicht so perfekt und optimiert wie in Deutschland/Hannover, aber viel herzlicher und gemütlicher. Ist wirklich schwer zu beschreiben, aber es ist toll.

Auf der anderen Seite ist hier aber auch alle extrem modern: Wo wir noch Papierkärtchen abstempeln, hat hier jeder eine “Oysterkard”, die vermutlich per RFID von der Zugangsschranke erkannt wird. Darauf kann man (wie wir) ein Wochenticket laden, oder ein bisschen Geld, mit dem automatisch bezahlt wird: Die Karte muss beim Betreten und Verlassen einer Station erkannt werden, daraus wird die Fahrstrecke berechnet und automatisch bezahlt. Genial das System. Man kann sogar bei McDonnald mit einem ähnlichen System bezahlen. Klar, man kann auch die Benutzer damit überwachen, aber kann ja auch noch normale Karten kaufen. Ich finde das System jedenfalls großartig.

Damit auch noch eine Schattenseite erwähnt wird: London ist teuer. Verdammt teuer. Das war’s dann aber auch schon. Ich bin jedenfalls wirklich begeistert von der Stadt.

Wenn ich mir das jetzt so durchlese ist das alles etwas wirr. Naja, ich bin auch schon etwas müde (um 3 aufgestanden…) Direktkopie meiner Gedanken sozusagen. Das war’s dann auch schon für heute, ich versuche jetzt noch ein tolles Foto meiner Oystercard anzuhängen (mit dem iPad gemacht!), und sollten wir sehen, wo wir zu Abend essen…

Ach ja: Wenn du bestanden hast, herzlichen Glückwunsch

• Windows hat zwar einen zentralen Zertifikatsspeicher, aber Firefox und Thunderbird benutzen (jeweils) einen eigenen. Das Zertifikat muss in allen installiert werden.
• Es gibt einen unterschied zwischen einer eigenen CA und selbst unterschriebenen Zertifikaten: Die selber abgesegneten Zertifikate muss man alle einzeln bestätigen, wobei hingegen es reicht das eigene Root-Zertifikat zu installieren, um automatisch allen davon unterzeichneten Zertifikaten zu vertauen. Viele Programme generieren bei der Installation selbst-unterschriebene Zertifikate, die man also immer einzeln akzeptieren muss.

Fangen wir also an! Die Anleitung basiert auf dieser Beschreibung. Wir legen uns erst Mal einen neuen Ordner an, und wechseln zu root (hatte ich erwähnt, das ich von Linux rede?). Die Zertifikate sollte nach Möglichkeit nur von root gelesen werden können, daher ist es sinnvoll diesen Benutzer auch zum erstellen zu benutzen.

openssl genrsa -des3 -out ca.key 4096
 openssl req -new -x509 -days 365 -key ca.key -out ca.crt

Diese beiden Zeilen generieren zunächst einen privaten Schlüssel in der Datei ca.key, der mit einem Passwort geschützt wird. Er sollte nicht aus der Hand gegeben werden! Er ist zwar passwortgeschützt, aber er beinhaltet eben den privaten Schlüssel, den wir zum signieren brauchen. Wem das jetzt allen nichts sagt, macht sich bei Wikipedia schlau: Asymmetrische Kryptosysteme. Kurzfassung: Mit dem privaten Schlüssel kann man nur verschlüsseln, mit dem öffentlichen nur entschlüsseln.

Die zweite Zeile erzeugt jetzt eben diesen öffentlichen Schlüssel, der zusammen mit ein paar Daten zum Aussteller in der Datei ca.crt landen. Alle Texte sind beliebig, wenn man nichts angeben will, reicht ein Punkt (.). Der Parameter hinter days gibt die Gültigkeitsdauer an, ein Jahr ist evtl. etwas kurz, 10 sollten reichen. Dieser Zertifikat wird nun automatisch selber unterschrieben, weil es ja niemanden gibt, der eine CA bestätigen kann.

Jetzt kommt das Erstellen eines neuen Zertifikates dran:

openssl genrsa -des3 -out server.key 4096
 openssl req -new -key server.key -out server.csr

Wir erstellen wieder einen Key, der auch mit einem Passwort geschützt wird. Danach erstellen wir statt einem Zertifikat wie oben, einen Certificate-Sign-Request (.csr). Es werden wieder ein paar Daten abgefragt, doch  hier ist es nicht ganz egal, was angegeben wird: Der CommonName (CN) sollte zum Server passen! Wenn das nicht der Fall ist, gibt es beim Starten des Servers eine Warnung, und die Client beschweren sich, das es einen Identitätsdiebstal gab, weil Domain und CN eben nicht passen. Für Webserver sollte man hier *.domain.tld angeben (mit den richtigen Werten natürlich), für Mail und FTP Server sollte genau der passende Name angegeben werden. Wenn man auch noch Email-Zertifikate haben will, muss die Email-Adresse hier angegeben werden.

Jetzt spielen wir wieder CA: (Das ist das, wofür die so viel Geld haben wollen:)

openssl x509 -req -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt

Wir signieren den Request, den wir grade erstellt haben für 356 Tage (anpassen, 3560 ist besser), und benutzen dabei unser oben erstelltes CA-Zertifikat. Dabei wird auch nach dem Passwort des CA-Private-Keys gefragt, denn der ist zum signieren nötig. Die Seriennummer muss angepasst werden, wenn ein neues Zertifikat für den gleichen Domain ausgestellt wird (z.B. weil es abgelaufen ist): Client speichern das Zertifikat bei der ersten Verbindung und beschweren sich, wenn es sich geändert hat (könnte ja ein Hacker gewesen sein). Wenn die Seriennummer anders ist, gibt es kein Warnung.

Damit landet jetzt das unterschriebene Zertifikat in der Datei server.crt. Wenn man das Zertifikat jetzt in einem Server benutzen will, muss der den privaten Schlüssel beim Start laden, und braucht dazu das Passwort. Wem das zu blöd ist, kann das Passwort auch entfernen, muss dann aber mit geringerer Sicherheit leben. (Der private-key der CA sollte nie entschlüsselt werden!)

openssl rsa -in server.key -out server.key.insecure

So, damit ist unser Zertifikat fertig. Damit keine die private-keys klaut ist es keine schlecht Idee, diese nur für root lesbar zu machen. Die CSRs können gelöscht werden.

Nach diesem Muster kann man jetzt beliebig viele Zertifikate signieren. Allen wird vertraut, wenn denn das Root-Zertifikat installiert ist. Unter Firefox/Thunderbird geht das über Einstellungen/Erweitert/Zertifikate anzeigen/Zertifizierungstellen/Importieren (hier muss die öffentliche Datei importiert werden, also die .crt-Datei). Um das CA-Zertifikat Windows näher zu bringen öffnet man die Managment-Konsole per Win+R/mmc Dort wird ein SnapIn hinzugefügt: Strg+M/Zertifikate/Hinzufügen/Eigenes Benutzerkonto/Fertig stellen/OK. Das Zertifikat muss unter “Vertrauenswürdige Stammzertifizierungsstellen” (was für ein Wort) eingefügt werden, was unter Kontext-Menü/Alle Aufgaben/Importieren möglich ist.

Fehlen nur noch die Server. Natürlich hängt das jetzt stark von der Software ab, ich erkläre einfach mal das, was ich gemacht habe:

Apache: In den passenden vHost müssen diese Anweisungen:

SSLEngine On
 SSLCertificateFile /etc/apache2/ssl/server.crt
 SSLCertificateKeyFile /etc/apache2/ssl/server.key

Also private Schlüssel und öffentliches Zertifikat, das dem Client geschickt wird. Danach ist natürlich ein Neustart/Reload von Apache nötig. Was mir leider trotzt langem Ausprobieren nicht geglückt ist, ist es meine Website die unter ISPConfig laufen (wie dieser Blog) mit Zertifikaten zu versehen. ISPConfig hat da sein eigenes System, das nicht so richtig will wie ich… Dennoch sieht es wenigstes für die Admin-Oberfläche jetzt so aus wie auf dem Bild.

Weiter gehts mit Courier: Der IMAP Daemon ist ziemlich einfach mit Zertifikaten zu beglücken: Einfach .key und .crt Datei ein eine .pem Datei kopieren (einfach hintereinander), und die Datei nach /etc/courier/imapd.pem schieben. Danach ist natürlich auch ein Neustart fällig.

Wie es mit Postfix (SMTP Daemon) geht steht hier schon wunderbar.

Als letztes bliebt noch der FTP-Server Pure-FTPd: Der hat etwas seltsame Ansichten, weil er keine Konfigurationsdateien benutzt… Das Zertifikat muss wieder zusammen mit dem Key in die Datei /etc/ssl/private/pure-ftpd.pem (der Dateiname ist einkompiliert), danach muss noch die Datei /etc/pure-ftpd/conf/TLS mit dem Inhalt “1″ angelegt werden. Nach einem Neustart spricht dann auch der FTP-Server SSL.

Fazit: Wenn man den Dreh erst Mal raus hat, ist es ziemlich einfach, alles per SSL abzusichern. Langsam beginne ich auch den Sinn hinter Sachen wie S/MIME oder der ePost zu sehen. Mit günstigen Zertifikaten, die nur mit Ausweis ausgestellt werden, wäre das echt praktisch… (Nicht so wie es die Post macht, aber vom Prinzip her). Wie alles bei Unix/Linux (oder besser im Server Umfeld) funktioniert es echt gut, und ist super durchdacht, wenn man es erst Mal verstanden hat…

Also habe ich mich mal etwas im Netz umgesehen, und bin auf der Seite von Ulrich Müller gelandet, der sich die Mühe gemacht hat, allen möglichen Sprachen Bibliotheken zu schreiben. So gibt es auch ein in C#. Leider ist die Benutzung grade mit Windows 7 etwas kompliziert, daher will ich hier mal kurz erklären, wie es funktioniert. An dieser Stelle noch mal einen Dank an Ulrich Müller, der mit per Mail weiter geholfen hat.

Als erstes brauchen wir die USB-Treiber für das Interface, sonst ist gar keine Kommunikation möglich. Alternativ ist auch der Betrieb über COM möglich, aber so richtig ist das ja auch nichts… Die Treiber werden zusammen mit ROBO Pro installiert, wer die CD aber nicht findet, kann auch auf der Fischertechnik-Seite eine ZIP-Datei mit verschiedenen Hilfemitteln herunterladen, im Ordner /Driver sind dann die Treiber zu finden. Den Download gibt es hier: Fischertechnik Download-Seite (Treibersoftware KeLib).

Jetzt brauchen wir noch eine DLL, die die eigentliche Kommunikation übernimmt, und einen Wrapper in der passenden Sprache. Beides gibt auf der Seite von Ulrich Müller. Weil die Downloads etwas schwer zu finden sind, erlaube ich mir mal Deep-Links:

• umFish.dll
• FischFace.dll

Die beiden oben angegebenen Dateien brauchen wir für die Kommunikation. Die Downloads enthalten noch etwas mehr, hauptsächlich Dokumentation. Davon ist auch auf der oben verlinkten Seite einiges zu finden.

Die umFish.dll ist die eigentliche Bibliothek zum steuern des Interfaces, die FishFace.dll nur der Wrapper für C#.

Wir fügen also beide Dateien einem neuen C# Projekt hinzu, und fügen einen Verweis auf die FishFace.dll hinzu. Mit folgendem Code stellen wir eine Verbindung zum Interface her:

using System;
using System.Collections.Generic;
using System.Text;
using FishFace40;

namespace ftTest
{
class Program
{
static void Main(string[] args)
{
FishFace ft = new FishFace();
ft.OpenInterface(IFTypen.ftROBO_first_USB, 0);
}
}
}

Mit den Parametern von OpenInterface() kann man die Schnittstelle auswählen, und über die Seriennummer auch mehr als ein Interface ansteuern. Am Ende des Programms sollte dann natürlich auch noch eine CloseInterface() stehen. Die restliche Steuerung ist ziemlich selbst erklärend, darum gehe ich da nicht weiter drauf ein.

Ich persönlich habe jetzt auch ein anderes Interface umgeschwenkt, dass ich von der Schule gestellt bekomme, weil ich die Verbindung zum Fischertechnik-Interface erst nicht hinbekommen habe (falsche Version der umFish.dll). Ist aber trotzdem praktisch, wenn man mal wieder was in der Richtung machen will…

Wenn ihr noch Fragen habt, einfach in die Kommentare damit.

Naja, etwas kleines neues gibt es doch: Ein Freund fragte mich, ob ich noch diese Website kenne, wo man beliebigen Text eingeben kann, und er dann zum Linux Quelltext würde. Scheinbar hat er das was verwechselt, ich kann mich jedenfalls nicht daran erinnern eine solche Seite gekannt zu haben

Jedenfalls hat er mich auf die Idee gebracht sowas mal zu programmieren, und das ist dabei herausgekommen:

Geht einfach auf diese Website, und zeigt allen, dass ihr den Linux Kernel aus dem Kopf schreiben könnt:

Update: Neue Version: Be a Pro Coder/Hacker

Be a Linux Coder/Hacker

Der Quelltext den ihr da schreibt stammt aus dem Linux Kernel, aus /kernel/irq/irqdesc.c. Ihr könnt die Seite gerne speichern und den Text ändern, aber er muss vorher für JavaScript escaped werden, und alle Zeilenumbrüche müssen natürlich durch ein <br> ersetzt werden.

Vorschläge für noch “schlimmere” Quelldateien im Kernel werden gerne angenommen, aber das Ding ist sauber geschrieben, ich musste schon richtig nach einer “komplizierten” Datei suchen. Ach: Der Kernel ist nicht auf kernel.org sondern auf GitHub zu finden!

UPDATE: Jetzt könnt ihr euch auch an dem FAT-Treiber aus GRUB oder der 99 Bottles of Beer Version in Brainfuck versuchen Und der Bug der in den Kommentaren angesprochen wurde, ist auch weg…

Also wollte ich die beiden zusammenführen. Bei mir ging das ziemlich einfach, darum gibt es jetzt hier eine kleine Anleitung: (Wie immer: Auf eigene Verantwortung, macht ein Backup)

Als erstes muss man sich überlegen, was man denn überhaupt alles zusammenfassen will. Folgendes kommt in Betracht:

• Wiki – Eine der leichteren Übungen, wenn es denn nicht zwei Seiten mit dem gleichen Namen in beiden trac’s gibt.
• Benutzer – Hier hängt das Vorgehen von der Autorisierungsmethode ab, das muss jeder selber wissen.
• Dateien (Anhänge) – Auch sehr leicht zu machen, wenn es nicht identische Dateinamen gibt
• Repositorys – sollte machbar sein. Trac kann mit mehr als einem Repository umgehen, oder man fasst die beiden einfach zu einem zusammen. Hier muss man sehen, was das VSC da her gibt.
• Changesets – unproblematisch
• Meilensteine, Versionen, etc. Machbar, erfordert aber etwas Handarbeit bzw. Suchen und Ersetzen
• Einstellungen/Plugins – Auch machbar, erfordert aber natürlich Handarbeit.
• Tickets – Das ist schwierig. Jede Installation fängt bei 1 an zu zählen, also kollidieren die Nummern. Entweder muss man die Nummern alle um einen Wert erhöhen (wodurch alle Links in Leere laufen), oder, wenn man nicht so viele hat, versuchen, die Tickets des einen möglichst auf die IDs des anderen zu legen, die schon erledigt sind. Damit sind die dann natürlich verloren. Erfordert in beiden Fällen etwas Handarbeit.

So nun gehts los. Wir arbeiten uns von einfach nach schwer durch. Als erstes sollte natürlich die Website offline gehen, das kann sonst zu Problemen führen.

Die einfachste Sache sind die Anhänge, denn die liegen einfach im Order /attachments der trac-Umgebung. Die werden einfach in die Ziel-Umgebung kopiert.

Die restlichen Daten legt trac in der Datenbank ab. Die meisten werden wohl eine lokale SQLite-Datenbank verwenden, für andere Typen sollte es analog funktionieren. Die wichtigsten Tabellen sind dabei wiki, attachment und ticket. Wir es hier vorgeschlagen wird, werden die Tabellen einfach exportiert, und in die Zieldatenbank wieder eingelesen.

Wer Debain oder ähnliches benutzt, kann dafür das Paket sqlite3 installieren, und diese Befehle benutzen. (Im Wurzelverzeichnis der Quellumgebung)

sqlite3 ./db/trac.db ".dump wiki" > wiki.sql

sqlite3 ./db/trac.db ".dump attachment" > attach.sql

sqlite3 ./db/trac.db ".dump ticket" > ticket.sql

cd ../zieltrac

sqlite ./db/trac.db ".read wiki.sql"

sqlite ./db/trac.db ".read attach.sql"

sqlite ./db/trac.db ".read ticket.sql"

Die Anhang-Tabelle sollte dabei fast keine Fehler produzieren, angesehen davon das sie schon existiert. Das Wiki wird ein paar Fehler werfen, weil in jedem trac eine Menge an Wiki-Seite von vornherein existieren, die dann zu Problemen führen. Am besten man schlägt die Zeilennummern in der Dump-Datei nach, um zu sehen, um welche Seite es sich handelt. Wenn doch eine Seite doppelt ist, kann man einfach in der SQL-Datei den Namen ändern (für alle Revisionen), und die Seite sollte dann unter dem Namen zu finden sein.

Was die Tickets betrifft muss sich jeder etwas überlegen, wie ich es oben schon angedeutet hatte. Am schmerzlosesten dürfte es noch sein, einfach alle Ticketnummern um eine gewisse Zahl zu erhöhen, bzw. einfach aus dem Dump zu löschen, dann müsste SQLite neue vergeben.

Wer auch die Änderungen an den Tickets mit Übernehmen will, muss sich dazu die Tabelle ticket_change ansehen, und sich etwas überlegen, um die Nummern passend zurechtzubiegen.

Der Rest ist fast komplett über die Weboberfläche machbar. Wenn es nicht zu viele Meilensteine, Versionen, etc. sind, kann man die einfach per Interface wieder anlegen, und dann per Hand oder Suchen und Ersetzen im Dump den Tickets zuweisen.

Die Repositorys kann man einfach hinzufügen, dann evtl. noch den post-commit Hook anpassen, und ein Resync durchführen. Damit sollten alle Changesets an der richtigen Stelle liegen. Als letztes muss man sich jetzt noch überlegen, ob man noch Plugins usw. übernehmen will, da muss dann halt einfach neu installiert werden.

Wer nicht mit der Konsole hantieren will, dem sei dieses Firefox-Plugin empfohlen: SQLite Manager. Damit kann man direkt in Firefox SQLite-Dateien editieren. Ich hab noch ein paar Bilder gemacht, die den Prozess erklären sollten:

Fazit: Es ist erstaunlich leicht, auch dank dem guten Datenbank-Design von trac. Und: Neustarten von trac nicht vergessen, sonst wird man die Änderungen nicht sehen.

Die Lösung war dann das Wikitionary: Das hat, wie jedes auf MediaWiki basierendes Wiki eine API. Dort kann man zwar auch eine zufällige Seite (=Wort) abrufen, aber eben nicht aus einer bestimmten Kategorie. Ich wollte nun aber nur deutsche Substantive. Durch etwas rumsurfen bin dann auch folgende Lösung gekommen:

private static string GetRandomNoun()
{
StringBuilder sb = new StringBuilder(3);
for (int i = 0; i < 3; i++)
{
sb.Append(alphabet[random.Next(26)]);
}

WebClient wc = new WebClient();
wc.Proxy = null;
wc.Headers.Add(HttpRequestHeader.UserAgent, "info@niklas-rother.de");
string response = wc.DownloadString(String.Format("http://de.wiktionary.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Substantiv_%28Deutsch%29&cmsort=sortkey&cmstartsortkey={0}&cmlimit=1&format=xml", sb.ToString()));

XmlDocument doc = new XmlDocument();
doc.LoadXml(response);

return doc["api"]["query"]["categorymembers"]["cm"].Attributes["title"].InnerText;
}

Das wichtigste ist dabei DownloadString(), hier wird eine Abfrage an die Wikitionary API gestellt. Dabei wird eine Liste der Kategoriemember abgefragt, doch mit einem kleinen Trick: cmstartsortkey wird auf ein zufälliges Buchstaben-Trippel gesetzt, und dadurch wird nur der Eintrag zurückgegeben, der diesen drei Buchstaben lexikographisch folgt. Man kann auch noch mehr Buchstaben benutzten, aber mit drei Buchstaben sollte man schon viele Wörter erwischen.

Kurze Rechnung: Die Kategorie Substantiv (Deutsch) hat 34.390 Seiten. Aus 3 mal 26 Buchstaben kann man 26³ = 17.576 Kombinationen machen. Das sind 51%. Man erwischt also theoretisch die Hälfte der Wörter, das sollte reichen. (Ja, ich mag Mathe )

Ein paar kleine Fallstricke gibt es noch: Die Wikitionary API will unbedingt einen UserAgent haben, also muss man einen setzen, wie oben gesehen. Dort sollte am besten eine Adresse für Beschwerden drin sein, falls sich ein Programm mal selbständig macht…

Und auch .NET hat noch eine kleine Eigenheit: Wenn man eine neue Instanz von WebClient das erste Mal benutzt, wird versucht einen Proxy zu finden. Das kann bis zu 30sec dauern. Will man nicht warten, setzt man die Eigenschaft Proxy einfach auf null, und verscherzt es sich mit Leuten, die einen Proxy nutzen…

Und zum Abschluss gibt es noch ein schönes Zufälliges Wort: Presslufthammer!

Anzahl der Posts über Zeit. So wie es aussieht produziere ich ziemlich regelmäßig, mein Ziel ist ja auch mindestens ein Post pro Woche. (Auch wenn es jetzt grade mehr sind )

Anzahl der Kommentare über Zeit. Über die Kommentare kann man das nicht sagen, besonders zu einem Zeitpunkt gab es sehr viele Kommentare. Was da los war zeigt das nächste Bild:

Kommentare pro Post. Besonders viele Kommentare gab es an Verbesserungsvorschlägen, und an verständnisvoll-wütenden Kommentaren zu meinem Serverumzug. Noch mal genau soviele wie für “Serverumzug abgeschlossen” entfallen auf einen anderen Beitrag zu dem Thema, den ich nicht zeigen darf. Da diese beiden Punkte beiden zeihtnah waren, gibt es da so viele Kommentare. Und wer schreibt die so?

Anzahl der Kommentare pro Person. Naja, ähm, ich schreibe die meisten… Gefolgt von Nico, und einem SimpleScreenshot Ideengeber.

So mehr sinnvolle Statistiken sind mir nicht mehr eingefallen… War aber auch mal interessant.

Damals war ich mir nicht so sicher, da das Programm doch sehr professionell ist, und es mir an Effekten fehlte. Doch jetzt habe ich mich mal rangewagt, und ich denke es war eine gute Entscheidung. Allerdings habe ich nicht alles in Lightworks gemacht, sondern mir noch ein paar Zusatzprogramme zu Hilfe genommen.

Los geht es mit dem Import. Den kann Lightworks zwar per FireWire direkt von der Kamera, aber ich wollte eigentlich nach Szenen getrennte Clips, und ich gehe davon aus, das Lightworks dann nur einen endlos langen Streifen produziert. Den Import hat also Windows direkt und ohne Probleme übernommen. Kamera anschließen, komplettes Band einlesen lassen, und eine Stunde später hat man 12,5 GB an Video in einer AVI Datei.

Praktischerweise speichert die Kamera die aktuelle Uhrzeit mit auf dem Band (obwohl ich gar nicht wusste, das sie eine Uhr hat…), und diese Daten landen auch in der AVI Datei. Das ist das Stichwort für Scenalyser. (Der Link für zur Freeware Version) Das kleine Programm schneidet die riesen Datei anhand der Uhrzeiten in einzelne Szenen. Hat bei mir perfekt funktioniert. Weitere 12,5 GB AVI Dateien…

Jetzt kommt schon Lightworks in Spiel. Hier werden die Datei erst mal importiert (weitere 12,5 GB…) und dann in Bins sortiert und dann geschnitten. Ein paar Tipps:

• Um Cue-Points auf dem Audio Kanal zu setzen, immer die rechte Maustaste benutzen!
• Vollbild Vorschau gibt’s mit F12.
• Wer Überblendeffekte will, muss die beiden Clips erst etwas kürzen (damit sie sich später überlagern können), das macht Lightworks nicht von selbst (wie viele andere Programme)
• Gelb ist keine gute Farbe für “Greenkeying”… Haut ist auch gelb…
• Im Kontextmenü eines Edits kann man “Audio Waveforms” aktivieren. Praktisch, wenn man den Ton nur bei Kommentaren haben will, und sonst Musik überblenden will.
• Wenn Lightworks abstürzt, kein Problem, es speichert nach jedem Klick.
• Wer die Videodateien auch auf die C: Platte packen will, muss das erst im Disk Manager erlauben!

Wenn man das erst mal drauf hat, geht es recht gut mit Lightworks. Teilweise konnte ich allerdings keine Keyframes setzen, das fand ich etwas blöd.

Der nächste Punkt waren Fotos. Ich habe rund 120 Fotos im Urlaub gemacht, und ein paar (~50) sollten auch in den Film. Zwar kann Lightworks theoretisch mit Fotos umgehen, in der Praxis ist das aber sehr umständlich. Daher habe ich mich nach einem Diashowprogramm umgesehen, aber wurde überrascht: Picasa hat das schon eingebaut! Zwar nicht ganz perfekt, aber ausreichend. Das Video wird leider als WMV gespeichert, die Lightworks nicht importieren kann.

Also dachte ich mir, wandle ich es mit FormatFactory eben in ein AVI um. Leider ist das Bild dann komplett grün und der Ton ist weg. Warum auch immer… Die Lösung war es dann das Video in MOV umzuwandeln. Das kann Lightworks zwar importieren, aber jedesmal wenn ich das Video abspielen will, stürzt es fast ab

Als letztes fehlten dann noch Titel, Abspann und ein paar Einblendungen im Film. Theoretisch kann Lightworks hier eine externe “CG Application” (Computer Graphics?) aufrufen, aber das klappt – auch mangels eines solchen Programmes – nicht. Doch man muss nur ein bisschen improvisieren: Benutzen wir doch einfach PowerPoint. Animationen sollten damit kein Problem sein, und es kann auch Videos exportieren. Auch dazu ein paar Tipps:

• Man kann den Folienhintergrund zwar transparent machen, aber dann ist er im Video weiß. Lieber das bekannte Magenta benutzen, das kann man in Lightworks dann per Colorkeying super entfernen.
• PowerPoint ist mächtig – aber es kennt keine Keyframes. Ich bin mit meinen einfachen Überblendungen schon an den Rand der Möglichkeiten gestoßen.
• PowerPoint kennt zwar Animationspfade, aber es kann keine Linie entlang eines Pfades zeichnen. Kann kann nur versuchen Linien in grade Stücke zu schneiden, und die dann per “Wischen” einzublenden
• Man kann beim Export angeben, wie lange jede Folie angezeigt werden soll. Die Zeit zählt nicht erst wenn die Animationen vorbei sind, sondern ab Anfang. Wer also den grade animiert eingeblendeten Titel noch stehen lassen will, sollte die Zeit nicht zu kurz wählen.

Ansonsten habe ich aber mit PowerPoint schöne Animationen hinbekommen, auch wenn ich wirklich  an die Grenzen des Programmes (oder meiner Kenntnisse) gestoßen bin.

So, Film fertig geschnitten, nun geht es an den Export. Sollte ja kein großes Problem sein… Ist es an sich auch nicht: Exportbutton anklicken, Format und Edit wählen, fertig. Doch was muss ich da sehen: In der von Lightworks exportierten Datei war das Bild zweimal übereinander drin! Und natürlich entsprechen gestaucht… Hieran bin ich beinahe verzweifelt, bis ich im Lightworksforum die Lösung gefunden habe: Man muss in den Projekteinstellungen, die “Display Optimisation” von “Fields” auf “Frames” stellen. Warum auch immer…

Naja, eine halbe Stunde später war die Datei dann fertig, und konnte mit dem DVD Maker von Windows auf eine DVD gebannt werden. Nur wie hat es Lightworks geschafft, aus 12,5 GB Ausgangsmaterial (62min) 40 GB Film zu machen (33min). Halbe Länge, viermal so viele Daten…WTF?!

Ich habe also etwas mehr Programme gebraucht, aber mit diesem Setup konnte ich eigentlich meine Vorstellungen gut umsetzen. Nur PowerPoint ist etwas problematisch – und das einzige Programm das nicht kostenlos ist. Leider kenne ich keine mächtigere Alternative, die auch gratis bzw. in meinem Besitz ist.