Roblet-Technik: Konzept der Anwenudngsentwicklung

(1) Roblet-Anwendung

Eine Roblet-Anwendung erstreckt sich mit Hilfe Ihrer Roblets (Schaubild 1) über beliebig viele Netzknoten. Ein Roblet kann als autonomes Programmteil verstanden werden, dass unter Kontrolle eines Roblet-Servers im Auftrag seiner Roblet-Anwendung Dienste verrichtet. Roblets können mit Ihrer Anwendung über ferne Instanzen kommunizieren oder nach Beendigung beliebige Werte an ihre Roblet-Anwendung zurück geben. Ein Roblet kann auch dann weiterlaufen, wenn die Verbindung zu seiner Roblet-Anwendung unterbrochen ist.

HelloWorld - Roblet#

01 class  HelloWorldRoblet
02     implements org.roblet.Roblet,
03                java.io.Serializable
04 {
05     // Wird vom Roblet-Server aufgerufen
06     public Object  execute (org.roblet.Robot robot)
07         throws Exception
08     {
09         // Wird auf dem entfernten Rechner
10         // ausgegeben
11         System.out.println("Hello World!");
12         
13         return null;
14     }
15 }
(2) - HelloWorldRoblet - Download(info)

Ein Roblet wird über seine Roblet-Klasse definiert. Schaubild (2) zeigt die denkbar einfachste Roblet-Klasse: Ein HelloWorld-Roblet:

  • Jede Roblet-Klasse muss das Interface org.roblet.Roblet implementieren (Zeile 2).
  • Jede Roblet-Klasse muss serialisierbar sein (Zeile 3).
  • org.roblet.Roblet schreibt die Implementierung der Methode org.roblet.Roblet.execute(Robot robot) vor (Zeile 06-13). Diese Methode wird vom Roblet-Server, in dem das Roblet laufen soll, aufgerufen. Genau genommen, spricht man erst dann von einem Roblet, wenn dessen execute-Methode aufgerufen wurde. Zeile 09-13 kommt also auf Server-Seite zur Ausführung. In diesem Beispiel wird die Ausgabe "Hello-World" erzeugt.

In prototypischen Systemen, in denen die Sicherheitsmechanismen auf Roblet-Server-Seite deaktiviert sind, kann beliebiger Programmcode von einem Roblet ausgeführt werden. So könnten zum Beispiel beliebige Prozesse auf dem Server-Netzknoten gestartet oder beendet werden. Auch der Aufruf eines System.exit(0); wäre möglich, was allerdings die JVM und damit auch den Roblet-Server auf entferntem Netzknoten beenden würde. Abgesehen davon, ist es nicht wünschenswert, dass ein Roblet unkontrolliert auf dem Roblet-Server agieren kann.

Einheiten#

Um Sicherheit und Kontrolle zu ermöglichen sollte ein Roblet in produktiven Systemen nur spezifizierte Methoden ausführen können. So kann sichergestellt werden, dass ein Roblet
  • nichts tut, was es nicht darf
  • die verwendeten Ressourcen in keinem unerwartetem Zustand hinterlässt
  • der Roblet-Server keinen Schaden trägt.

Um dies erreichen zu können, verwendet die Roblet-Technik unter anderem das Konzept der Einheiten. Eine Einheit ist eine Java-Klasse, welche Methoden implementiert, die von Roblets genutzt werden können. Ein Roblet nimmt die Dienste eines Roblet-Servers wahr, indem es sich Instanzen der Einheiten-Klassen vom Roblet-Server zurückgeben lässt, um dann die zur Verfügung stehenden Methoden der Instanz aufzurufen bzw. mit ihnen zu interagieren.

Einheiten-Definition#

Die Roblet-Technik erspart Ihnen an dieser Stelle die Auseinandersetzung mit einer weiteren Schnittstellen-Sprache (IDL, Interface Definition Language) und macht sich die Tatsache zu Nutze, dass Java von Haus aus schon die Interface-Klassen kennt. Das bedeutet, dass ein Roblet-Server die zur Verfügung stehenden Einheiten mit Hilfe üblicher Java-Interface-Klassen beschreibt. Eine einzelne solche Java-Interface-Klasse wird Einheiten-Definition genannt. In der Praxis werden diese Einheinten-Definitionen inkl. Dokumentation in Form von Paketen (jars) bereit gestellt, die dann von Roblet-Anwendungen auf Clienten-Seite in den Classpath eingebunden und verwendet werden können.

01 class  HelloUniversumRoblet
02     implements org.roblet.Roblet, 
03                java.io.Serializable
04 {
05   // Wird vom Roblet-Server aufgerufen
06   public Object  execute (org.roblet.Robot robot)
07       throws Exception
08   {
09       MailUnit msUnit;
10 
11       // Einholen der Einheit zum
12       // Versenden einer Email
13       msUnit = (MailUnit) robot.getUnit(MailUnit.class);
14 
15       // Aufruf einer Einheiten-Methode zum
16       // Versenden einer Email
17       msUnit.sendDummyMail();
18 
19       return null;
20     }
21 }
(3) - HelloUniversumRoblet - Download(info)

HelloUniversum - Roblet#

Quellcode (3) zeigt eine weitere Roblet-Klasse, diesmal unter Verwendung von Einheiten. Der Aufbau gleicht dem HelloWorldRoblet. Einziger Unterschied ist der execute-Methodenrumpf. Es wird nicht mehr nur eine blose Ausgabe erzeugt, sondern in Zeile 13 wird eine Einheiten-Instanz "MailUnit" zum Versenden von Emails über den Methodenaufruf: robot.getUnit(...) eingeholt. In Zeile 17 wird dann die Einheiten-Methode sendDummyMail() aufgerufen. Das Roblet kehrt anschließend zu seiner Anwendung zurück. org.roblet.robot dient als "Kontext" oder in anderen Worten als eine Zugangsinstanz zur Funktionalität des Roblet-Servers (Siehe Schaubild 5). Diese Instanz stellt die Methode Unit.getUnit(Class class) bereit. Über sie gibt der Roblet-Server eine beliebige Einheiten-Instanz - wie im Beispiel die MailUnit - an das Roblet zurück.

Roblets versenden#

Quellcode (4) zeigt eine Beispiel-Klasse zum Versenden eines Roblets. Die zentralen Klassen zur Kommunikation mit Robet-Servern sind in der Client-Bibliothek zusammengefasst.

In Zeile 06 wird eine Client-Instanz erzeugt. Über solche Client-Instanzen können beliebige Roblet-Server-Repräsentanten eingeholt werden, um mit Ihnen kommunizieren zu können. So wird in Zeile 09 ein Server-Repräsentant des roblet.org-Servers eingeholt (Dieser Server wird zu Testzwecken von roblet.org bereit gestellt).

Ein Roblet läuft nicht irgendwo in einem Roblet-Server sondern es läuft in einem vom Roblet-Server bereitgestelltem Slot. Um ein Roblet in einem Slot platzieren zu können, wird in Zeile 12 ein Slot-Repräsentant eingeholt. Über den Aufruf der Slot-Methode run(...) wird das Roblet auf dem Roblet-Server roblet.org:2001 zum Laufen gebracht.

01 class SendARoblet 
02     implements java.io.Serializable
03 {
04 
05     public static void  main (String[] args)
06         throws Exception
07     {
08        // Instanziieren eines Clients zur
09        // Kommunikation mit Roblet-Servern
10        Client client = new Client();
11 
12        // Einholen eines Roblet-Server
13        // Repräsentanten
14        Server server = 
15            client.getServer("roblet.org:2001");
16        
17        // Einholen eines Slot-Repräsentanten
18        Slot slot = server.getSlot();
19 
20        // Laufen lassen des Roblets im Slot im 
21        // entfernten Roblet-Server
22        slot.run( new HelloWorldRoblet());
23     }
24 }
(4) - Versenden eines Roblets - Download(info)

(5) Roblet-Server mit aktiven Roblets