Blog - Schlagwort Technik

Ich habe bei meinen aktuellen Java Web-Applikationen oft mit der Situation zu tun, dass verschiedene Handler der Applikation auf einen gemeinsamen Pool von Daten lesend (und manchmal auch schreibend) zugreifen müssen.

Das einfache Vorgehen, dass ich auch zu meinen PHP-Zeiten gewohnt war, ist es, eine Datenverbindung (soll heißen: eine offene MySQL-Verbindung) zu errichten oder aufrechtzuerhalten, und diese an alle Handler weiterzugeben, so dass diese die benötigten Daten unmittelbar aus der Datenbank lesen und Änderungen direkt in die Datenbank zurückschreiben können.

Allgemeine Überlegungen

Dieses “Read-On-Demand”-Verfahren hat aber ein paar häßliche Nachteile, weshalb ich es heute nicht mehr gerne einsetze:

• Die Daten aus der Datenbank müssen evtl. bei jedem Request neu eingelesen und verarbeitet werden. Das kann bei großen (oder komplizierten) Daten einiges an Verarbeitungszeit kosten
  (Beispielsweise dauert das Neueinlesen der Weblog-Daten aus diesem Blog schon ein paar Sekunden, da erst die enthaltenen Bilder nachgeprüft und verkleinert werden müssen, LaTeX-Formeln verarbeitet werden usw.)
• Bei einer Änderung der Datenschnittstelle (z.B: Änderung des Tabellenformats in der Datenbank) müssen alle Handler angepasst werden. Dabei kann man leicht eine Abfrage vergessen, die dann zu einem Bug führt.
• In jeden Handler muss das Lesen und Interpretieren der Daten (inklusive SQL-Abfragen) hineinprogrammiert werden, was den Aufwand zum Entwickeln eines Handlers stark erhöht. Oft ergibt sich dann doppelter Code, weil verschiedene Handler die selben Daten einlesen
• Bei mehreren gleichzeitigen Abfragen (wobei mindestens eine davon die Daten verändert) können Datenhazards auftreten, also eine Verfälschung der Daten durch eine falsche Verarbeitungsreihenfolge. Dadurch kann auch permanenter Datenverlust auftreten

Um diese Probleme zu umgehen bin ich seit kurzem auf Caches umgestiegen. Unter einem Cache verstehe ich eine gemeinsame Instanz, die den Zugriff auf eine bestimmte Datenmenge der Applikation zur Verfügung stellt:

Wenn man in Java mit komplexeren Strings arbeiten will, benötigt man oft Funktionen, um das Ergebnis aus einer Vorlage zu erzeugen, indem verschiedene Variablenwerte eingesetzt werden.
Vor allem, um Textdateien in einem bestimmten Format (z.B. CSV oder HTML) zu erzeugen, bei dem die Grundstruktur irgendwo entworfen und abgespeichert werden soll, macht ein Templatesystem für Strings Sinn.

Für die Web-Ausgabe gibt es JSP, um Inhalte in ein Template einzufügen und auszugeben.
Aber für lokale Anwendungen ist mir bisher kein solches System bekannt.
Einfache Sachen lassen sich ja in Java hartkodieren oder mit Suchen-und-Ersetzen-Methoden generieren, aber je komplizierter die Struktur wird, desto mehr Arbeit macht auch die Implementierung.

Um dieses Problem ein für alle Mal zu lösen, habe ich eine Template-Klasse geschrieben, die String-Templates mit folgenden Funktionen repräsentieren:

• Ersetzen von Variablen
• Auswählen von If-Then-Else-Verzweigungen
• Iterieren über Collections (mit Code-Duplikation)

Im Java-Umfeld hat sich die Datenspeicherung mit XML schon weitestgehend zum Standard durchgesetzt. Vor allem viele Konfigurationsdateien (z.B. fast alle Config-Dateien in der Java Servlet Engine „Apache Tomcat“ sind in XML gehalten) sind regelmäßig in XML notiert; aber auch viele andere Datendateien für Java-Programme werden in XML definiert, da sich für dieses Format die Validierung und das Parsing sehr einfach und generisch in Java (und anderen Tools) durchführen lässt.

Eine sehr gängige Methode für das Einlesen (und interne Verwalten) von XML-Daten liegt darin, das XML-Dokument in einen Baum zu transformieren.

Hierbei sind alle Knoten des Dokuments (Elemente, Attribute, Entitäten und CDATA) als Node-Objekt im Speicher repräsentiert, deren Eigenschaften als Membervariablen dieses Node-Objekts gelesen werden können (z.B. Tagname, Typ des Elements, Wert eines Attrubuts, …). Die einzelnen Node-Objekte sind über eine Vater-Söhne-Relation miteinander verbunden.

Das Einlesen eines XML-Dokuments in einen Baum kann mit vielen Java-Toolkits gemacht werden (z.B. mit DOM = Document Object Model)

Eine großer Nachteil bei dieser Methode ist es, dass man in seinem Java-Programm meist selbstständig den Baum durchlaufen und interpretieren muss.
Natürlich kann man mit Hilfsmitteln, wie XPath sehr gut und effektiv Anfragen auf den XML-Baum ausführen, aber den XML-Baum in seine Java-Datenstrukturen umwandeln muss man noch selbst.

Eine andere Möglichkeit, Java mit XML zu vereinen bringt JAXB (Java Architecture for XML Binding).

Bei meiner Arbeit auf Linux-Systemen kommt es ab und zu vor, dass ich einige Prozesse/Deamonen im Hintergrund laufen habe, die entweder defunktional oder von meiner Shell abgekoppelt sind.

Nun möchte man manchmal den Urzustand wieder herstelle und bräuchte so etwas wie “reset” für die ganze Session: also alles bis auf die aktive Shell beenden.

Dabei hat sich für mich mein Script shotgun bewährt: es werden alle laufenden Prozesse des aktuellen Users mit kill -9 abgeschossen (außer der Shell und den Programmen, die shotgun braucht, selbst).

Ist eigentlich ganz simpel, man spart sich dadurch aber manchmal, über htop oder ps aux alle Prozesse des Users von Hand aufzuspüren und zu beenden.

Das Script ist vor allem auch dann nützlich, wenn man die Session beendet hat, und noch irgendwelche Prozesse auf (ansonsten freien) Mounts oder SSH-Verbindungen sitzen, die man sonst nicht schließen kann.

Ich arbeite im Moment an dem interessanten Projekt, einen Traffic-Generator zu schreiben.

Dabei sollen die Zwischenankunftszeiten und Paketgrößen nach wählbaren Verteilungsfunktionen mit frei wählbaren Parametern verteilt sein.

Ich verwende die Java-Bibliothek JSimLib (eine Eigenentwicklung des Lehrstuhls), um Zufallszahlen nach bestimmten Verteilungen zu erhalten.

Da es einige Verteilungsklassen gibt (und diese möglicherweise noch ergänzt werden), und diese Verteilungsklassen unterschiedlich viele Parameter akzeptieren, wird ein Java-Machanismus benötigt, der ein Verteilungsobjekt mit der richtigen Verteilungklasse und den richtigen Parametern aus den Argumenten der Java-Kommandozeilenargumente erstellt.

Hierzu verwende ich die Reflections-Klassen von Java, die es ermöglichen, zur Laufzeit Klassen und Objekte zu untersuchen und zu erstellen.

Unter SSH (Secure Shell) versteht man ein Netzwerkprotokoll, über das man eine sichere Verbindung zu einem anderen Computer aufbauen kann.

Normalerweise benutzt man dieses Protokoll, um über eine sichere Leitung Kommandos auf dem entfernten Rechner auszuführen oder Dateien zu übertragen.

Aber die Vielseitigkeit dieses Protokolls erlaubt auch zahlreiche weitere Anwendungen, die einen Vorteil aus dieser sicheren Verbindung ziehen können.

Die wohl wichtigste Anwendung des Protokolls über seine Basisfunktionen hinaus sind die sogenannten SSH-Tunnel.

Wenn man Gentoo (oder ein anderes Paketbasiertes Basissystem) benutzt, kommt diese Situation schon des öfteren vor:

Man möchte ein Paket installieren, aber dieses Paket hat Abhängigkeiten zu irgendwelchen anderen Pakete, von denen man weiß, dass man auch ganz gut ohne sie auskommen kann (z.B. zusätzliche Themes), aber ohne die sich das Paket einfach nicht installieren lassen will.

Normalerweise sind dafür USE-Flags vorhanden, aber manchmal werden diese auch nicht so vollständig implementiert, wie man das gerne hätte.

Ich möchte die Situation einmal an einem ganz konkreten Beispiel verdeutlichen:

Ich möchte eine neuere Version von Gnome (welche eigentlich noch über Keywords maskiert ist) installieren. Diese neue Version verlangt allerdings eine Aktualisierung des Pakets gnome-themes, wobei in der neueren Version mein lieblings-Theme des Window-Decorators in meinen Augen “verunstaltet” ist. Sprich: ich will die alte Version behalten.

Dumm nur, dass sich gnome-2.20.0 nur installieren lässt, wenn ich gnome-themes-2.20.0 oder höher unmaske und damit zum installieren oder updaten freigebe.

Die Lösung für das Problem ist eigentlich ganz simpel: ich verändere das Gnome-Paket.

Wie man unschwer erkennt, habe ich mich auf die Suche nach (relativ) sicheren, praktikablen und kompatiblen Verschlüsselungen gemacht. Der Hintergrund: einerseits interessiere ich mich sehr fü die Kryptographie, andererseits finde ich, dass die heutigen Computersysteme geradezu nachlässig sind bezüglich unserer Geheimnisse und persönlichen Daten.

Und wer jetzt das Killerargument „wer nichts verbotetes tut, muss nichts geheimhalten, ergo Datenschützer = Terroristen“ im Hinterkopf hat, dem sei gesagt, dass dieses Argument aus logischer Sicht sehr bedenklich ist:

• Im Allgemeinen muss man paranoid sein und davon ausgehen, dass andere (unpersönlich) dich (wirtschaftlich) ausnutzen wollen. Wenn der Viagrahersteller XY deine E-Mail Adresse rausbekommt, kriegst du nunmal zehn Spammail mehr am Tag. Oder wenn ein Gauner an deine zwischengespeicherte Kredikartennummer im Browsercache kommt, ist halt nunmal dein Geld weg. Gelegenheiten gibt es viele - und die sollte man vermeiden …
• Der Datenschutz ist (beispielsweise im Postgeheimnis) in den Grundrechten verankert. Und ein Grundrecht sollte man nicht leichtsinnig aufgeben.
• Es geht einfach NIEMANDEN was an, mit wem ich E-Mails schreibe, welche Webseiten ich besuche und welches Textverarbeitungsprogramm ich benutze. Ebenso haben meinen Chef meine privaten Urlaubsfotos nicht zu interessieren und meine Notizen zu Thema XY haben auch keinen zu interessieren, wenn ich das nicht möchte.

Wie auch immer, ich machte mich jedenfalls (unter Linux) auf die Suche nach anwendbare Verschlüsselungstechniken.

Jetzt habe ich mich intensiver mit direkter Hardwarenaher Verschlüsselung mittels eines Device Mappers beschäftigt.

Wer schon einmal einen Rootserver administriert hat, kennt sicher das leidige Problem der Datenübertragung.

Folgende Situation: Man hat auf der einen Seite den eigenen Arbeitsrechner, auf der anderen Seite den Server. Wenn man nun Dateien auf den Server aufspielen möchte, ist der einfachste Weg über FTP:

• FTP Serverprogramm installieren
• FTP Benutzer einstellen (evtl. Systembenutzer?)
• Verbinden und übertragen.

Nun ist diese Vorgehensweise recht trivial und bietet doch gewisse Nachteile:

1. FTP ist unsicher. Das wird sich auch nicht so schnell ändern. Das Benutzerpasswort wird unverschlüsselt übertragen und die Verbindung ist nicht über TLS/SSL oder sonstiges gesichert. Jeder kann den Traffic abhören.
2. Wenn man über FTP Daten überträgt, nehmen diese Daten den Owner und die Gruppe des FTP-Benutzers an.
3. Man kann FTP-Benutzer (mit den üblichen FTP-Servern) nur schwer auf ein Verzeichnis beschränken. Entweder der ganze Verzeichnisbaum oder nur das Home-Verzeichnis des FTP Benutzers

Man sieht also, FTP ist ganz OK für schnelle und einfache Dateiübertragung, bietet aber auch entscheidende Nachteile.

Ein anderer Weg führt über SSH (Secure Shell).