Max Wielsch und die Informatik

Android und Maven

2012-01-09T10:02:00.000-08:00

In einem aktuellen Projekt habe ich mit Webservices und Android zu tun. Wenn ich bisher mit Java EE zu tun hatte, habe ich Maven als Projektverwaltungstool benutzt. Nun möchte ich auch das Android-Projekt von Maven verwalten lassen. Im Netz habe ich unter folgendem Link einen extra Archetype für solche Maven-Projekte gefunden.
https://github.com/akquinet/android-archetypes/wiki/android-quickstart-archetype
Dort ist ein ganz einfaches Beispiel beschrieben, wie ein solches Maven-Projekt aufgesetzt wird. Dies sieht wie folgt aus:

 mvn archetype:generate
  -DarchetypeArtifactId=android-quickstart
  -DarchetypeGroupId=de.akquinet.android.archetypes
  -DarchetypeVersion=1.0.7
  -DgroupId=your.company
  -DartifactId=my-android-application

Dies funktionierte ohne Probleme. Danach kopierte ich die Dateien eines bestehenden Android-Projekts in das durch Maven generierte Projekt. Die danach aufgetretenen Fallstricke möchte ich in diesem Post kurz erklären.

Das ist zwar ein Standardfehler, bei meinen Android Projekten, aber er trat wieder auf. Wenn wieder mal Eclipse neu eingerichtet wird und dann das Android-Eclipse-Plugin für Android installiert wird, sollte man nicht vergessen den Installationspfad zum SDK zu setzen.
Ebenso ist der Pfad in der Maven-Konfiguration des Android-Build-Plugins zu setzen.
Das Build-Plugin fordert ebenso eine minimale Maven-Version, die ich ebenso nachinstallieren musste. Dies ist die Version 3.0.3.
Im Android-Manifest sollte man die benötigte Android-API-Version (android:minSdkVersion)noch prüfen.

Android: Der Vortrag in der Java User Group Görlitz

2011-10-26T20:00:00.000-07:00

Hallo an alle Android-Interessierten!

in diesem Post möchte ich die Folien und das Eclipse-Android-Projekt vom Java-User-Group-Vortrag zum Download zur Verfügung stellen. Bei dem Projekt handelt es sich um eine ganz primitive Memo-App. Wer noch Fragen hat, ist dazu angehalten diese zu stellen.

Hier die zwei Links:

Weiterhin gibt es noch die gratis Version des Buches "Android - Grundlagen und Programmierung" (Arno Becker und Marcus Pant) unter folgendem Link zum Download:

Android-Buch

Beim Durcharbeiten ist bitte zu beachten, dass an einigen Stellen Fehler enthalten sind, bzw. einige Erläuterungen fehlen. Dazu sind auf der Website zum Buch unter der Rubrik Errata Korrekturen und Anmerkungen zu lesen, die dann hilfreich sind, wenn irgendetwas im Buch nicht nachvollziehbar ist.

Viel Spaß

Ein paar Gedanken zum Testen von Regeln

2011-10-06T08:12:00.000-07:00

Da man mit Hilfe von Regeln fest einprogrammierte Logik aus einem System in diese stets veränderbaren Regeln hinauszieht, muss diese Logik natürlich auch getestet werden. Es steht also die Frage im Raum, wie ich Regeln Testen kann. Insbesondere die Frage nach der Testumgebung ist interessant.
Fest steht:

Die unmittelbare Ausführungsumgebung der Regeln ist die Rule-Engine (Regelmaschine).
Eigentlich ist bei Tests darauf zu achten, dass der Ausgangszustand immer derselbe ist. Für Regeln ist dies jedoch nicht sinnvoll. Denn gerade das Zusammenspiel von Regeln und das Wiedereinführen von Entscheidungen der Rule-Engine bilden das reele Verhalten von Rule-Engines und Regeln ab.
Entsprechende Fakten werden je nach Testfall in die Regelmaschine eingefügt. Je nachdem, welche Regel erwartungsgemäß aktiviert werden sollte, muss die Faktenbasis präpariert werden.

Tests per JUnit ausführen zu lassen, wäre möglich. Es ist die Frage, ob dies sinnvoll ist, da nie klar ist, welche Regeln es geben wird, da diese nach Bedarf bzw. nach Anforderung erstellt wird. Sie werden also während der Laufzeit erstellt, erweitert bzw. modifiziert. Der Ausführungszeitpunkt von Unit-Tests ist hingegen vor der Inbetriebnahme des Systems. Daher sollte es eine Komponente geben, die eine Testumgebung bereitstellt, die man nach Bedarf konfigurieren kann. In dieser müsste man dann zur Betriebszeit die Regeln austesten können. Da bei Aktivierung von Regeln eine Konsequenz ausgeführt wird, die auf das Produktivsystem bzw. Umgebungssysteme Auswirkungen hat, müsste man an dieser Stelle eventuelle Modifikationen ermöglichen, die unerwünschte Auswirkungen für den Test zu unterdrücken.

Für den Test von Regeln interessiert hauptsächlich, ob eine bestimmte Regel aktiviert wird, weniger, ob eine Konsequenz ausgeführt wird. Wenn eine Regel also zur Aktivierung markiert ist (man sagt, sie ist auf der Agenda), dann ist die Ausführung der Konsequenz gewiss. Da die Logik der Konsequenz entkoppelt ist, kann man davon ausgehen, dass diese auch separat getestet worden ist.
Lediglich für den Fall, dass in einer Konsequenz Modifikationen an der Faktenbasis vorgenommen werden, sollte man diese Ausführung auch zulassen.
Heißt also, auch die Aktivierung der Regel muss für den Test konfiguriert werden können.

Ein Beispiel-Szenario für Drools-Regeln

2011-08-18T10:08:00.000-07:00

In dem Post "Drools für meine Rules" habe ich auf ein später folgendes Hello-World-Beispiel verwiesen. Nun ist es soweit.

Das Beispiel-Szenario bezieht sich auf das Projekt des Human Task Service (http://www.humantaskservice.blogspot.com/). Eine Task-Instanz (TI) ist im Kontext dieses Systems das technische Äquivalent zu dem abstrakteren Begriff des Human Tasks. Die TI gehört also zum Domänen-Modell des Human Task Service (HTS). Für dieses Beipiel ist ein vereinfachtes Modell die Grundlage.

Jede TI wird zum Erzeugungszeitpunkt mit einem Zeitstempel versehen. Weiterhin ergibt sich aus der zugewiesenen Task-Beschreibung die maximale Dauer für die Bearbeitung einer Task-Instanz bzw. den Human Task. Diese muss für in jedem Fall zugesichert werden können, damit der HTS als wirtschaftliche Dienstleistung angeboten werden kann. Neben der Erfüllungsdauer gibt es noch weitere Gütemerkmale von Diensten. Diese werden in sog. Service Level Agreements definiert. Es muss für die Verwendung der Rule-Engine Drools also eine Regel formuliert werden, die den erklärten Sachverhalt erfüllt.

Hier kommt die Regel dazu:

<?xml version="1.0" encoding="UTF-8"?> 
<package 
    name="de.saxsys.hti.monitoring.controller" 
    xmlns="http://drools.org/drools-5.0" 
    xmlns:xs="http://www.w3.org/2001/XMLSchema-instance" 
    xs:schemaLocation="http://drools.org/drools-5.0 drools-4.0.xsd"> 
    <import name="de.saxsys.hti.monitoring.domain.*"/> 
    <import name="de.saxsys.hti.monitoring.util.mail.*"/> 
    <import name="de.saxsys.hti.monitoring.util.deadline.*"/> 
    <import name="de.saxsys.hti.monitoring.handler.*"/> 
    <import name="javax.xml.datatype.*"/> 
    <import name="java.math.BigDecimal"/> 
    <import name="java.util.*"/>
 
    <function 
        return-type="String" 
        name="prepareMessageText"> 
        <parameter 
            identifier="$ti" 
            type="TaskInstance"/> 
        <body>              
            StringBuffer sb = new StringBuffer(); 
            
            sb.append("An task instance with state '").append($ti.getState().value()); 
            sb.append("' has passed the half of the deadline!\n"); 
            sb.append("--------------------------------------------\n"); 
            sb.append("Detailed data:\n\n"); 
            sb.append("id: ").append($ti.getId()).append("\n");  
            sb.append("name: ").append($ti.getName()).append("\n"); 
            sb.append("creation: ").append($ti.getCreationTime()).append("\n"); 
            
            Date creationDate =    $ti.getCreationTime(); 
            String duration = $ti.getTaskDescription().getServiceLevelAgreement().getDeadline().getTimeSpan(); 
            sb.append("deadline: ").append(DeadlineChecker.getEndDate(creationDate, duration)); 
            
            return sb.toString(); 
        </body> 
    </function> 

    <rule name="deadline is half passed"> 
        <lhs> 
            <pattern object-type="TaskInstance" identifier="$ti"> 
                <and-constraint-connective> 
                    <field-constraint field-name="state"> 
                        <qualified-identifier-restriction evaluator="!=">State.COMPLETED</qualified-identifier-restriction> 
                    </field-constraint> 
                    <field-constraint field-name="state"> 
                        <qualified-identifier-restriction evaluator="!=">State.FAILED</qualified-identifier-restriction> 
                    </field-constraint> 
                </and-constraint-connective> 
            </pattern> 
            <eval> 
                DeadlineChecker.halfOfDeadlineHasPassed($ti.getCreationTime(), $ti.getTaskDescription().getServiceLevelAgreement().getDeadline().getTimeSpan()) 
            </eval> 
        </lhs> 
        <rhs> 
            $ti.setPriority(Prioritizer.increase($ti.getPriority())); 
            System.out.println("... increase priority to: " + $ti.getPriority().value()); 
            System.out.println("... inform responsible person of half passed deadline"); 
            String message = prepareMessageText($ti); 
            HTIReactionHandler htiRH = (HTIReactionHandler) ReactionHandlerFactory.getReactionHandler(ReactionHandlerType.HTI_HANDLER); 
            htiRH.sendMail("department_chief@anycompany.com", "Warning", message, $ti.getAttachment()); 
        </rhs> 
    </rule> 
</package>

Nun die Erläuterung des Dokuments:

Zuerst das Wurzelelement: <package></package> Mit dem Attribut name wird eine Bezeichnung angegeben, welche die in diesem Dokument enthaltenen Regeln im Speicher der Rule-Engine eindeutig von anderen Regeln unterscheidet.
In den Regeln kann Java-Codeenthalten sein. Die genutzten Klassen werden durch den import-Tag geladen.
Regeln werden durch das Element <rule/> ausgedrückt. Ein Regel besteht aus einem Bedingungsteil (left hand side) und dem Konsequenzteil (right hand side). Die Tags <lhs/> und <rhs/> besitzen diese Semantik und werden als Kindelemente des rule-Tags eingefügt.

Der Bedingungsteil:

Eine Bedingung wird in Drools durch sog. Patterns, also Muster, ausgedrückt. Man beschreibt mit Patterns wie entsprechende Datenobjekte ausehen sollen, welche die Bedingung erfüllen sollen. Mit dem Attribut object-type wird der Typ bzw. die Klasse des Objekts festgelegt. Über einen Bezeichner, der mit dem Attribut identifier angegeben wird, kann man in dem Dokument auf das aktuelle Objekt zugreifen.
Bisher würde die Bedingung lauten: "Objekte müssen vom Typ TaskInstance sein, damit der Konsequenzteil (rhs) aktiviert wird.". Darum werden mit Feld-Beschränkungen (Restriktionen) genauere Angaben zu dem Objekt gemacht. Mit dem field-constraint-Tag wird beschrieben, welche Felder das Objekt haben muss.
Als Kindelemente des field-constraint-Tags können zum Beispiel folgende Elemente verwendet werden, um die Werte der Felder zu beschränken:
- Um Enumerationen anzugeben, wird eine qualified-identifier-restriction verwendet.
- Für alle anderen (primitiven bzw. standard) Typen kann der folgende XML-Tag benutzt werden: <literal-restriction evaluator=">" value="0"/> Mit solchen Restriktionen können Felder mit Zahlen oder Zeichenketten ausgezeichnet werden. Mit dem evaluator-Attribut wird angegeben, wie der jeweilige Wert des Feldes auzuwerten oder zu interpretieren ist.
Um solche Feld-Restriktionen können nun noch logische Verknüpfungen (<and-constraint-connective/>, <or-restriction-connective/>) geschachtelt werden.
Um die Patterns können weiterhin Negationen (<not/>), der Existenz- (<exists/>) und der All-Quantor (<forall/>) geschachtelt werden.
Neben den Patterns zur Beschreibung der Beschaffenheit eines Objekts gibt es noch die Möglichkeit, diese durch eigenen Java-Code zu prüfen. Dafür wird der Tag <eval></eval> benutzt. In ihm kann beliebige Logik formuliert sein, die weitere Objektmerkmale prüfen kann. Die einzige Einschränkung ist, dass der Ausdruck zu einem Boolschen Wert evaluiert.

Der Konsequenzteil:

Im Konsequenzteil der Regel kann nun jedweder Java-Code stehen. Entsprechende Importe sind dafür nicht zu vergessen.
Um auf das aktuelle Objekt zuzugreifen und die Konsequenz für ein solches auszuführen, benötigt man eine Referenz darauf. Diese konnte durch die angabe eines Bezeichners (identifier) im Pattern angelegt werden. Damit haben wir nun Zugriff auf die Daten des Objekts. Für ein besseres Verständnis sorgt es, wenn in den Regelbedingungen angelegte Bezeichner mit beispielsweise dem Dollar-Zeichen den Unterschied zu im Java-Code definierten Bezeichnern singnalisieren.
Typisch für XML ist der Overhead, der durch die Dokumentstruktur entsteht. Aus diesem Grund, und für die Wiederverwendbarkeit ist es sinnvoll, Logik zu kapseln. Einfacherweise macht man dies in Java-Klassen, die nur eingebunden und aufgerufen werden brauchen. Eine zweite Möglichkeit ist, die Verwendung von Dokument-Internen Funktionen. Ein Exemplar davon ist genau unter den Import-Beschreibungen des Beispieldokuments zu finden. Weiterer Erklärung bedarf es nach all den Erläuterungen nicht. Wie zu sehen, kann im Funktionsrumpf wieder Java-Code stehen. Funktionen sind vor allem dafür geeignet, regelspezifische Logik im Regeldokument zu kapseln. Logik, die in unterschiedlichen Regeldokumenten gebraucht wird, sollte besser in Javaklassen verpackt werden.

Nachdem nun die Syntax des Regeldokuments recht ausgiebig erklärt wurde, folgt nun eine kurze Beschreibung der Semantik. Was soll die Regel tun?

Für jede Task-Instanz, die noch nicht im Zustand beendet (COMPLETED) oder fehlgeschlagen (FAILED) ist, und deren Bearbeitungsfrist bereits zur Hälfte überschritten wurde, soll eine Konsequenz ausgeführt werden.
Sinn der Regel ist das Scheitern des Human Tasks zu verhindern. Darum lautet die Konsequenzhandlung: Es muss eine zuständige Person, z.B. ein Abteilungsleiter, per E-Mail über den dringenden Zustand informiert werden.

Alle Sprachelemente und Funktionen konnten natürlich nicht gezeigt werden, jedoch wurde in diesem Post eine kleine Einführung in Drools-XML-Regeln gegeben.

Android: Eine kleine Radio-App

2011-07-24T06:13:00.000-07:00

Oft hat es mich bereits gefrustet, dass es vom MDR bereits für Jump eine Android-App gab, mit der man den Internetradio-Stream hören konnte, aber für mein geliebtes Figaro dagegen nicht. Einen Livestream haben Sie zwar schon, jedoch ist dieser nur über die Internetseite von MDR Figaro abspielbar.

Nun ja, das stimmt nicht ganz, man kann auch noch eine Wiedergabeliste dafür herunterladen. Ein beliebiger Player kann den Stream dann abspielen. Nachdem ich mir die Wiedergabeliste, eine pls-Datei, mal im Texteditor angeschaut hatte, war mir klar, dass ich auch selbst was damit anstellen könnte.

So schaut eine pls-Datei aus:

[playlist]
numberofentries=1
File1=http://c22033-l.i.core.cdn.streamfarm.net/22007mdrfigaro/live/3087mdr_figaro/live_de_128.mp3
Length1=-1

Gestern früh kam mir dann der Gedanke: Jetzt wo ich selbst ein Android-Telefon besitzte und ich auch noch Java kann, sollte ich mir doch mal eine eigene Figaro-App schreiben.

Den entsprechend geeigneten Player zu finden , der von Android für Internet-Audiostreams geboten wird, war nicht schwer. Der AsyncPlayer ist sehr einfach zu benutzen. Man übergibt einen URI und sagt ihm, dass er den Stream abspielen soll. Nach ein paar Sekunden beginnt er. Will man die Wiedergabe anhalten, ruft man die Stop-Methode auf. Mehr kann man mit diesem Player nicht anstellen. Folgender Code zeigt ein Beispiel:

android.media.AsyncPlayer player = new AsyncPlayer("StreamPlayer");

Uri uri = Uri.parse("http://c22033-l.i.core.cdn.streamfarm.net/22007mdrfigaro/live/3087mdr_figaro/live_de_128.mp3");

player.play(this, uri, true, AudioManager.STREAM_MUSIC); 

// Der Stream läuft

player.stop();

// Der stream ist gestoppt. Pause gibt es nicht.

Die App kommt aufgrund der Einfachheit mit einer Activity aus. Leider habe ich doch mehr als 5 Stunden daran gesessen. Grund dafür ist die bescheidene Android-Oberflächengestalltung. Das Layout macht nie das, was es soll :-) Die Beschreibung der View in XML ist eine saubere Sache, da Logik und Anzeige getrennt werden. Jedoch wäre es meines Erachtens nach gut gewesen, sich bei der Beschreibung der Oberfäche an XHTML und CSS zu orientieren. Lange Rede, kurzer Sinn: Die entworfene Oberfläche ist sehr einfach gehalten. Ein Play/Pause-Button und ein Stop-Button sowie ein Hintergrundbild habe ich für die View verwendet.

Wer Interesse an der App hat, kann Sie sich unter folgendem Link herunterladen.

http://dl.dropbox.com/u/3538883/Downloads_Max_Blog/MDRFigaroWebRadio.apk

Drools für meine Rules :-)

2011-07-10T06:03:00.000-07:00

Schon seit ein paar Tagen habe ich mich mit Drools beschäftigt. Jetzt endlich kann ich sagen welche Rule Engine die jenige ist, die ich fürs Monitoring benutzen kann. Was habe ich also die letzten Tage gemacht?

Zuerst einmal findet man im Netz relativ viel Material zu Drools. Die Beispiele für Regeldefinitionen haben mich natürlich am meisten interessiert. Schnell hatte ich einige gefunden, die ganz gut aussahen. Daher begann ich mich näher mit Drools zu beschäftigen um ein kleines Hello-World-Projekt aufzusetzen. Damit fingen die Probleme an.

Nachdem ich alle Ressourcen heruntergeladen und eingebunden hatte, habe ich ein Rule-File nach den Beispielen im Netz geschrieben. Leider lief nichts. Bei der Fehlersuche verwirrte mich Anfangs, dass es noch so viele andere Sprachen für Drools gab. Das genau ist der Punkt!

Drools hat erstens sein eigenes Regelformat namens "drl" (kein XML) und zweitens unterstützt es außerdem noch Regeldefinition via XML. Das Tückische daran ist, dass Drools, aktuell in der Version 5.2.0 vorliegend, eine sehr starke Entwicklung durchlaufen hat. So gibt es einige verschiedene XML-Formate, die alle nicht mehr aktuell sind. Die Materialien, die man im Netz dazu findet, sind oft für die alten Formate gewesen. Wenn man das weiß, stellt es kein Problem dar :-)

Mein Hello-World-Beispiel habe ich zum laufen bekommen. Es ist das Ergebnis dieses Wochenendes. Eine komische Fehlermeldung wird jedoch nach wie vor angezeigt. Trage ich die Schemaversionen analog zum Versionsstand (5) von Drools ein, findet er das Schema nicht. Trage ich die Version 4 ein, wie es in der aktuellen Dokumentation von der Drools-Seite zu lesen ist, bekomme ich die Meldung, dass ich doch bitte mal Version 5 eintragen soll. Seltsam!

Mein Hello-World-Beispiel kommt später.

Auswahl einer Rule-Engine

2011-07-09T08:04:00.000-07:00

Wie im vorigen Post beschrieben kann man Rule-Engines nutzen, um Business-Logik in Regeln zu kapseln. Vorteile sind:

Der Code ist leichter verständlicher. Die Regeln sind in einem extra Dokument, von wo aus man zentral alle Regeln bearbeiten/betrachten kann.
Auch bei großen Datenmengen können die Business-Rules noch schnell ausgeführt bzw. die Daten noch schnell ausgewertet werden.
Die Regeln können an aktuelle Anforderungen angepasst werden, ohne das System bis ins Detail kennen zu müssen ... und (!) man kann die Regeln von Außen zur Laufzeit gut manipulieren.

Wie funktionieren Rule-Engines nun?

Prozesse oder Daten müssen auf bestimmte Eigenschaften ausgewertet werden. Wird eine bestimmte Bedingung erfüllt, muss eine dafür geplante Aktion ausgeführt werden.

Diese Sachverhalte kann man in Regeln formulieren. Unsere Regeln bestehen also aus:

einer Bedingung, auf die ein Eingabedatum geprüft werden muss
und ein Folgeaktion, die nur dann ausgeführt wird, wenn die Bedingung erfüllt worden ist.

Regeln werden auf eine Menge von Fakten angewandt. Fakten sind unsere Geschäfts- oder Prozessdaten. Das Anwenden bzw. Ausführen der Regeln übernimmt die Rule-Engine.

Implementierung von Rule-Engines für Java gibt es einige (Vgl. http://java-source.net/open-source/rule-engines). Das Problem bei der Auswahl ist die Sprache, mit der die Regeln verwendet werden. Aktuell gibt es noch nicht wirklich einen Standard für solche Sprachen. Es gibt Sprachen, mit XML-Syntax, mit Lisp-ähnlicher Syntax, und diverse andere DSLs (Mehr Interessantes zu DSLs auf: http://raik-bieniek.blogspot.com/).

Bei der Suche nach einer geeigneten Rule-Engine für das Monitoring ist also die Regel-Sprache wichtig. als Regelsprache werde ich eine XML-Sprache verwenden. Die Manipulation von XML ist sehr einfach, da es für XML genügend Werkzeuge dafür gibt. In wie weit es genügend gute Werkzeuge für proprietäre Sprachen gibt, ist mir nicht bekannt. Das Suchen danach liegt momentan nicht in meinem Fokus. Daher soll es XML sein.
Weiterhin ist es von Vorteil, wenn die Rule-Engine für OSGi geeignet ist, sprich es sollte eine OSGi-Version davon geben. Dies ist jedoch kein "Muss", mehr ein "Nice-To-Have".

Über mich

2011-07-09T07:29:00.000-07:00

Als erstes möchte ich für den frischen Blog ein paar Worte zu mir sagen.

Ich studiere seit 2008 Informatik und schreibe bereits meine Bachelorarbeit. Das Thema der Bachelorarbeit ist die "Entwicklung einer Monitoring-Komponente für den HTS" (http://www.humantaskservice.blogspot.com/). Um nur mal ein paar Buzzwords für die (Java-) Technologien zu nennen, mit denen ich mich gerade beschäftige, sei folgendes genannt:

OSGi: Der HTS besteht aus den Teilen HTP, TPC und der Human Task Infrastructure (HTI). Diese wurde basierend auf dem OSGi-Standard entwickelt. Kurz gesagt bietet dieses Framework die folgenden Vorteile, die Grund für den Einsatz dessen waren: Modularisierung, Erweiterbarkeit, austauschbarkeit, Hot-Deployment
Drools (Rule-Engine): Mit Hilfe von Rule-Engines kann man Business-Code einer Anwendung der aus etlichen If-Then-Else-Statements besteht in Form von Regeln implementieren. Diese Regeln, oft in einem extra Dokument formuliert, können dann von einer sog. Rule-Engine auf einen Satz von Daten ausgeführt werden. Damit errreicht man selbst bei einer riesigen Datenmenge eine immernoch performante Abarbeitung. Ein weiterer Grund Business-Logik in solchen Regeln zu formulieren ist, dass die einzelnen Regeln (je nach verwendeter Regel-Sprache) einfacher lesbar, damit schneller verständlich und besser wartbar sind. Gerade in der heutigen Welt ändern sich die Anforderungen an ein Software-System sehr schnell.
JMX: Die Java Management Extension erlaubt es Java-Anwendungen zu monitoren. Mehr dazu auf http://de.wikipedia.org/wiki/Java_Management_Extensions
JAX-WS: Da die Dienste des HT-Service über das Netz angeboten werden, liegt es nahe Java-Webservices zu nutzen.

Dies sind die wichtigsten Technologien, mit denen die Monitoring-Komponente umgesetzt wird.