OSGI Framework Knopflerfish

[Sindbad1983]

Hallo zusammen!

Nach erfolgreichem Abschluss der Programmier-LVA besuch ich jetzt schon den nächsten Kurs..
danke nochmal für eure tatkräftige Unterstützung!
Ohne java-forum.de hätt ich das wahrscheinlich nicht geschafft!

dieses Mal wartet echt eine sehr schwere Aufgabe auf mich!


Bin ich da richtig bei euch, wenn es ums Thema OSGI geht?
(Open Service Gateway Initiative)



Kennt sich damit jemand aus bzw. hat sich schon mal jemand damit beschäftigt?
Wir müssen alles in Java programmieren.

also OSGI ist ein Framework, das in Knopflerfish implementiert ist..

Tommy

 

[KISS]

was willst du den wissen?

 

[Sindbad1983]

naja...das lässt sich ehrlich gesagt ein bissl schwer erklären...



da gibt es ein Programm, welche Regeln erstellt:
man gibt als User Bedingungen an und das Programm führt dann Aktionen aus!

z.B.:

man kann beliebige Inputwerte festlegen:
length (int) >0
width (int) <10


und dann kann man sagen, was er berechnen soll(er soll eine Aktion ausführen)

area=length*width
also das ist die Aktion




und dann geht ein Fenster auf, in dem man das eben testen kann:


dann gibt man Werte für l und w ein, also

length=5
width=5

und er berechnet die Area mit 25


ist ganz simpel an und für sich...

soetwas ist 1 (!) Regelwerk, ok?

jetzt kann man in diesem Programm unbegrenzt viele verschiedene Regelwerke anlegen.

Dieses Programm, das letztes JAhr entwickelt wurde, wurde ein eigenes Compiler eingebaut, der aus dem Regelwerk ein JAVA-File generiert..also das steht in etwas drinnen, wie die Auswertung statt gefunden hat:

hier ein kleiner Einblick:

also dieses JAVA-File ist eigentlich der Ausgangspunkt für meine Aufgabenstellung:

import se.g2.blm.runtime.LOCK;
import se.g2.blm.runtime.JRuleSet;

 public class RWTest_RuleSetTest2 extends JRuleSet {

   /* Input values */
   public float length;
   public float width;

   /* Output values */
   public float area;

   /* Constructor */
   public RWTest_RuleSetTest2(float length, float width, boolean isInterpretative, boolean isMain) {
       this.length = length;
       this.width = width;
       this.isInterpretative = isInterpretative;
       this.isMain = isMain;
      }

   /* Starting point for processing rule set. */
   public JRuleSet execute() {
       if((length>0) && (width<10)) {
          rule_id = 0;
          action_1();
         }
       else  {
          rule_id = 1;
         }
       if(isMain) { 
          synchronized(LOCK.getLock()) { 
             try {
                LOCK.getLock().notifyAll();
               }
             catch(Exception exception) {
               }
             if(Thread.currentThread() instanceof se.g2.blm.runtime.RuleSetRuntime.JRuleSetExecutor) {
                ((se.g2.blm.runtime.RuleSetRuntime.JRuleSetExecutor)Thread.currentThread()).finished = true;
               }
             return this;
            }
         }
       return this;
      }

   public void action_1() {
       area=length*width;
      }

   public boolean processBreakPoint() { 
       synchronized(LOCK.getLock()) { 
          try {
             LOCK.getLock().notifyAll();
             LOCK.getLock().wait();
            }
          catch(Exception exception) {
            }
          return canContinue;
         }
      }

   public String toString() { 
       StringBuffer buffer = new StringBuffer();
       buffer.append("RULE: ").append(getRuleId() + 1).append("\n\n");
       buffer.append("INPUT:\n");
       buffer.append("length: ").append(length).append('\n');
       buffer.append("width: ").append(width).append('\n');
       buffer.append('\n');
       buffer.append("OUTPUT:\n");
       buffer.append("area: ").append(area).append('\n');
       return buffer.toString();
      }
  }

Die Klasse erbt von JRuleSet, das ist auch wichtig..die kann ich bei Bedarf noch reinstellen
JRuleSet ist ein abstrakte Klasse, von der eben alle erstellten Regelwerke erben...

Wichtig ist noch, dass eben verschiedene Regelwerke angelegt werden können...aber jedes Regelwerk für sich allein soll in ein Bundle kommen, ok?

UNSERE Aufgabe ist nun:

wir müssen jedes Regelwerk so erweitern, dass es in einem Bundle gespeichert wird und dann in Knopflerfish installiert werden kann!
Außerdem sollen über das Bundle verschiedene Informationen abgefragt werden könnnen, wie z.B.
wer hat es installiert, wie oft wurde es schon installiert, über welchen Zeitraum war es installiert etc.

Ich hoff, ich hab das jetzt nicht zu verwirrend erklärt...


Die Frage, die sich jetzt stellt ist, wie man das hinkriegt, dass man das JAVA-File, das vom jeweiligen Compiler kompiliert wird, so erweitert, dass daraus ein Bundle wird...


kann mir da jetzt jemand folgen?
soll ich noch detaillierte Informationen darüber geben?

Möchte mir jemand helfen?

Ich weiß, das klingt jetzt alles verwirrend, aber ich wär wie gesagt echt dankbar, wenn mir da jemand ein paar Tipps geben könnte..

 

[Gast]

Hi!

studierst du in der uni oder machst du grad eine Ausbildung wenn ich fragen darf??

Ich versteht deine Aufgaben auch nicht ganz richtig....

OSGi ist nicht schwer. Du hast bestimmt das Prinzip von OSGi verstanden.

So, Bundles kann man bequem über Eclipse erstellen. Du brauchst das Knopflerfish-Plugin.

Zu sind all deine Programm Bundles. Bundles sind jar Files die du über das Framework dynamisch laden kannst.

Dein Servicenutzer muss sich beim Serviceanbieter über einen "Tracker" ansprechen und die bereitgestellten Interfaces nutzen.

Dazu muss noch für je einen Bundle einen "Activator" schreiben...

 

[Sindbad1983]

...Uni

naja...es gibt nur um ein Java-File, das automatisch dann so erweitert werden muss, dass es zu einem Bundle wird...

 

[Gast]

Schreib mal das File hier hin dann zeigt dir dann wie man es erweitert und daraus ein bundle macht....

 

[Sindbad1983]

echt? boa, das wär ne Riesenhilfe...

ich such mal schnell...

 

[Sindbad1983]

ok...also nochmal ganz kurz zur Erklärung:


irgendein Programm (nicht wichtig für dich) erstellt verschiedene Regelwerke, d.h. man gibt Inputwerte rein und bekommt irgendwelche Outputwerte raus!
Der interne Compiler dieses Programms generiert dann folgenden Code:

diesen Code müssen wir hernehmen(also pro Regelwerk wird so ein Code generiert) und in ein Bundle verpacken!

Das heißt 1 Bundle enthält 1 Regelwerk

der vom internen Compiler generierte Code schaut folgendermaßen aus
hier beispielhaft für Regelwerk1 mit den Inputwerten length und width und den Outputwert area (es soll die Fläche berechnet werden):

public class Regelwerk1 extends JRuleSet {

   /* Input values */
   public float length;
   public float width;

   /* Output values */
   public float area;

   /* Constructor */
   public Regelwerk1(float length, float width, boolean isInterpretative, boolean isMain) {
       this.length = length;
       this.width = width;
       this.isInterpretative = isInterpretative;
       this.isMain = isMain;
      }

   /* Starting point for processing rule set. */
   public JRuleSet execute() {
       if((length>0) && (width<10)) {
          rule_id = 0;
          action_1();
         }
       else  {
          rule_id = 1;
         }
       if(isMain) { 
          synchronized(LOCK.getLock()) { 
             try {
                LOCK.getLock().notifyAll();
               }
             catch(Exception exception) {
               }
             
             return this;
            }
         }
       return this;
      }

   public void action_1() {
       area=length*width;
      }

   
    //Ausgabe
   public String toString() { 
       StringBuffer buffer = new StringBuffer();
       buffer.append("RULE: ").append(getRuleId() + 1).append("\n\n");
       buffer.append("INPUT:\n");
       buffer.append("length: ").append(length).append('\n');
       buffer.append("width: ").append(width).append('\n');
       buffer.append('\n');
       buffer.append("OUTPUT:\n");
       buffer.append("area: ").append(area).append('\n');
       return buffer.toString();
      }
  }

alle Regelwerke erben von der Klasse JRuleSet, die folgendermaßen aussieht(ist nur abstrakte Klasse)

public abstract class JRuleSet {
	   /* Instance variables */
	   protected boolean isInterpretative; // if true, don't skip the breakpoints
	   protected boolean canContinue = true; // if true, return after breakpoint
	   protected int rule_id; // holds the id of the rule,  which is beeing executed
	   protected boolean isMain = false; // this variable is false, if the RuleSet beeing executed is triggered from other RuleSet.
	   
	   
	   public abstract JRuleSet execute();   
	   
	  
	   public void setContinue(boolean canContinue) {
	      this.canContinue = canContinue;
	     }
	
	   public boolean isInterpretative() {
	      return isInterpretative;
	     }	 
		
	   public int getRuleId() {
	      return rule_id;
		 }
	
	   public boolean isMain() {
	      return isMain;
	     }	 
	  }

das heißt : jedes Bundle(das jeweils nur 1 Regelwerk enthält) wird wohl folgendes enthalten müssen:

1. java-File des jeweiligen Regelwerkes (hier Regelwerk1 )
2. java-File der Klasse JRuleSet
3. irgendeine Activator-Klasse mit start und stop, die das Regelwerk in der Registry registiert oder so...
4. Manifest-Datei

stimmt das?

weißt du ungefähr was ich meine?

am Schluss soll dann das ganze automatisch in eine jar-Datei umgewandelt werden, damit es im Knopflerfish lauffähig ist..

vielleicht kannst du mir ein paar Tipps bzw. Ansätze geben..
ich wär dir echt sehr sehr dankbar!


PS: Das ist nur ein sehr kleiner Teil unserer gesamten Aufgabe in diesem PRojekt... ist ne MEnge Arbeit!

 

[Gast]

hab grad über google eine gute seite gefunden. hier findest du praktische Beipsiel von OSGi:

http://roots.iai.uni-bonn.de/xp2005b/Wiki.jsp?page=OSGi

http://roots.iai.uni-bonn.de/xp2005b/Wiki.jsp?page=UebungOsgi

 

[Sindbad1983]

danke..schaut ganz interessant aus..
werd mir das mal anschaun!

 

[Gast]

Das brauchst du
http://www.knopflerfish.org/releases/1.3.3/knopflerfish_osgi_1.3.3.jar

Beispiele:
http://roots.iai.uni-bonn.de/xp2005b/attach?page=Doc/OSGiDemo.zip

 

[Gast]

ansonsten hier fragen...