Nochmal das Observer Problem nur konkreter

[zander180_0]

Hallo Leute,
es sieht bei mir im Moment wie folgt aus.
Vergesst die letzte Frage.
Also ich habe ja eine Client-Server Anwenndung geschrieben. Der Client bin ich und der Server eine Hardware. Das ganze läuft über Corba d.h. ich arbeite mit idl-Datein. Der Server ist in C++ realisiert und ich möchte nun die Client Seite in Python schreiben. Wi schon gesagt die Verbindung steht. Nun möchte ich einen Befehl senden und eine Antwort vom server zurück bekommen. Um das zu beobachten möchte ich das Observer-Pattern nutzen. Die Observer.idl habe ich und sieht wie folgt aus:

Code: Alles auswählen

module Observer{


	/*
	* Daten die an den Monitor zurückgegeben werden 
	*/
	struct InfoData{
		string bez;					// name des Wertes		
		long type;					// rückgabetype
		any value;					// Wert
	};
									

	// InfoData zum beobachter zu senden
	interface DataObserver{
		
		void notify(in InfoData data);
    };
};

Als erstes muß ich den DataObserver implemenmtieren aber ich weiß nicht wie. Danach soll die notify-Methode die Parameter zurück geben, die sich geändert haben.

Da ich ja mit Corba das ganze umsetze, habe ich mir auch das dementsprechende Python-File generiert.

Demnach muß ich mir doch eine Klasse beuen, die vom generierten Observer Python-File erbt.
Ich habe das bereits probiert aber ohne erfolg

[BlackJack]

@zander180_0: Ich habe immer noch nicht verstanden was Du eigentlich willst. Bist Du sicher dass *Du* weisst was Du willst und was das Observer-Entwurfsmuster ist!?

Wo ist diese `notify()`-Funktion? Wer soll die aufrufen? Und was meinst Du damit, dass die etwas *zurückgeben* soll? Die gibt nichts zurück, weder in der Signatur die man in der IDL dort sieht (``void``), noch im Entwurfsmuster.

[zander180_0]

Ich probiere es nochmal.
Ich habe ja auf der Client Seite das Programm, was die Hardware ansteuert, Auf der Server Seite habe ich die Hardware. Das Programm und die Hardware sind mittels eines Busses verbunden. Wenn ich jetzt eine Botschaft sende, möchte ich ja von der Hardware die erhalten. Bevor ich die Botschaft abschicke, möchte ich den Observer registrieren. Danach die Botschaft definieren und dann los schicken. Das Plugin, was die Hardware an Plateau und Corba anbindet schickt mir dann mittels der notify-Methode die Parameter zurück und ich kann dann über das struct auf die Parameter zugreifen.
die notify-Funktion ist im Interface DataObserver der Observer.dl

Oder könnt ihr mir eine triviale Observer implementierung zeigen?

[BlackJack]

@zander180_0: Das beantwortet immer noch nicht die Frage was wo läuft. Was läuft auf welchem Rechner, in welcher Sprache implementiert? Der Observer in Python? Das Observable in C++? Oder umgekehrt? Was davon hast Du implementiert beziehungsweise was kannst Du ändern oder beeinflussen? Wie sieht das IDL des Obvervable aus? Da brauchst Du ja die Möglichkeit Observer zu registrieren.

Was genau machst Du um den Observer in Python zu implementieren? Welche CORBA-Implementierung verwendest Du? Was geht nicht?

[zander180_0]

Hallo,
der Server bzw. das Plugin ist in C++ implementiert und ist somit unveränderbar.
Der Client ist Python realisiert. Den Client habe ich selbst implemenetiert, den Server (Plugin) habe ich komplett erhalten und es kann nicht geändert werden. Die Observer.idl ist ebenfalls fest. Das Observable ist somit in C++ realisiert und der Observer soll in Python realisiert werden. Die Observer.idl wurde bereits für eine andere Hardware genutzt dedoch nicht in Python sondern ebenfalls in C++.

Ich weiß halt nicht, wie ich den Observer implementieren soll. Es gibt zwar beispiele im www aber damit kann ich nix so recht anfangen.

[BlackJack]

@zander180_0: Welche CORBA-Implementierung verwendest Du denn in Python? Und wie sieht die Schnittstelle zum Registrieren des `DataObserver`\s aus?

[zander180_0]

Was meinst du mit welche Corba Implementierung ich nutze?
Was meinst du, wie die Schnittstelle zum Registrieren des Observers aussieht?

Kannst du das für mich bitte etwas einfacher erklären was du meinst?

[BlackJack]

@zander180_0: CORBA ist ein Protokoll. Es gibt verschiedene Bibliotheken und Python-Anbindungen dafür. Zum Beispiel fnorb, omniORB, oder orbit2. Welche davon verwendest Du?

Der C++-Code soll ja das `notify()` in Deinem Python-Code aufrufen. Dazu muss er irgendwoher wissen, dass es da eine Implementierung gibt und die finden. Also musst Du das Objekt irgendwie bekannt machen. Die Frage ist nun wie!? Als Objekt mit Namen bei einem Nameserver registrieren? Oder musst Du Dir ein "Observable"-Objekt holen und Deine `DataObserver`-Implementierung dort registrieren?

Prinzipiell sieht das Entwurfsmuster ja so aus:

Code: Alles auswählen

class Observable(object):
    def __init__(self):
        self.observers = set()
    
    def register(self, observer):
        self.observers.add(observer)
    
    def fire_notify(self, data):
        for observer in self.observers:
            observer.notify(data)


class Observer(object):
    def notify(self, data):
        print data


def main():
    observable = Observable()
    observer = Observer()
    observable.register(observer)

Du willst den `Observer` in Python implementieren, aber das `Observable` existiert irgendwo als C++-Objekt und Du musst die beiden ja irgendwie zusammenbringen, damit das `Observable` weiss wo es die `notify()`-Methode aufrufen muss.

[zander180_0]

Erst einmal vielen Dank, für deine Mühe mit mir.

Ich nutze OmniOrb für die Python Anbindung.
Zu deiner zweiten Frage, ich muß mir das Observable holen und dort die DataObserver Implementierung registrieren.
Muß ich nicht die Klasse Observer vom generierten python-File der Observer.idl erben lassen?
Da ja das ganze über Corba geht muß ich doch die Observer.idl nutzen oder seh ich das falsch.

[BlackJack]

Die `Observer.idl` musst Du benutzen, aber die `Observable.idl` *auch* denn Dein Python-Programm muss sich ja ein Proxy-Objekt dafür von der CORBA-Implementierung geben lassen.

Und dann musst Du wohl eher von `Observer__POA` erben, denn Du stellst ja eine Implementierung, also den Servant bereit.