[Info]CORBA

Note : certaines choses que je vais écrire se rapprochent de RMI ou de COM/.NET, c'est normal : Sun et Microsoft font partie de l'OMG et leur technologies sont basées sur les mêmes principes que CORBA.

Tu as dans la doc du JDK une partie concernant CORBA initulée Java IDL. Tu as plusieurs implémentations de CORBA en Java (JacORB, ORbacus/JOB ...) mais en général celle de Sun fournie dans le JRE suffit largement pour faire ce dont on a envie. Du côté de ton serveur là il te faudra faire des recherches pour trouver un ORB suivant le language que tu utilises (j'imagine que tu n'utiliseras pas Java sur le super calculateur).

Il y a ACE/TAO en C++ qui est pas mal (quoique chiant à compiler et installer, mais une fois que c'est fait ca marche bien), gratuit et est compilable sur une floppée de systèmes. Il existe également des distros commerciales de TAO fournies avec des manuels, plus de doc et un support technique. D'après un copain qui y bosse c'est ce qui est utilisé dans certains labos/services de devel de chez Thales.

Toujours en C++, il y a aussi ORbacus/OB de IONA (ORbacus/JOB étant la version Java) qui est très bien et très accessible/facile à comprendre, avec une doc très bien faite... mais coute assez cher* (€2.500 par CPU). IOA a également un produit orienté entreprise ORBIX.

A la rigeur même si tu utilises TAO, essaie de récupérer le manuel d'ORBacus sur le site il te sera utile au début car le démarrage et l'explication des notions de base y est bien fait. Il faudra surtout bien s'attarder sur la gestion automatique de la mémoire (types Machin_var vs. Machin_ptr) et sur le besoin de dupliquer les structures et objets retournés (qui seront libérés par l'ORB lui-même).

Ensuite tu vas définir une interface écrite dans le language IDL* dans un fichier .idl.

*Le language IDL de l'OMG (l'organisme qui standardise CORBA), pas IDL le language de programmation scientifique.

Genre Hello.idl :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
module test {
  interface Hello {
    void sayHello();
    string tellHello();
  }
};

Ce fichier sera compilé avec le compilateur IDL -> language propre à chacun des 2 bouts. En général les fichiers générés forment un stub (côté client) et un skel (côté serveur).

Côté Java (le client), en restant avec l'ORB de Sun, tu vas compiler avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
idlj Hello.idl

Cela va te générer les fichiers du stub.
Pour également générer le skel il faut utiliser le flag -fall. En effet parfois la communication doit être bidirectionnelle, ou alors le client doit envoyer des objets distribués sur le serveur et donc il doit avoir des fonctionalités de type serveur même si dans l'usage ça reste un client.

Ensuite tu implémentes le code de ton client :
- tu crée un ORB avec la lib utilisée.
- tu récupères** une référence sur ton objet distribué.
- tu appèles les méthodes de cet objet via sa référence.
Voilà c'est pas plus compliqué. En plus côté Java la gestion mémoire est simplifiée grace au CG.

Coté serveur (dans l'exemple en C++, utilisant TAO), tu vas compiler avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
tao_idl Hello.idl

Cela va te générer les fichiers du stub et du skell.

Ensuite tu implémente ton code serveur :
- tu implémentes une classe qui étend le skel et fait concrètement les actions décrites dans le fichier IDL : le Servant.
Exemple très simple***:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
classe HelloImpl : public POA_test::Hello {
...}
 
void HelloImpl::sayHello() throw (CORBA::Exception) {
  std::cout << "Hello World!" << std::endl;
}
 
char* HelloImpl::tellHello() throw (CORBA::Exception) {
  return CORBA::String_dup("Hello World");
}

- tu crée un ORB avec la lib utilisée.
- tu récupères et actives le POA.
- tu crées une instance de ta classe HelloImpl implémentant le skel.
- tu enregistres cette instance sur le POA.
- tu fais en sorte qu'il soit possible de trouver une référence** sur cet objet.
- tu lances l'ORB (appel bloquant jusqu'à ce qu'on tue le programme ou fasse un shutdown de l'ORB).
Et voila, tu as un serveur qui marche et tu n'as pas à te préocuper de la couche réseau ou de la conversion de type C++ <=> Java.

** Pour que ton client trouve la référence/pointeur réseau de ton objet sur ton serveur , il y a 3 solutions possible (combinables) une fois que l'objet a été enregistré sur le POA :

- sauvegarder l'IOR (descriptif de référence) dans un fichier et la passer d'une manière ou d'un autre (simple copie, FTP, HTTP, ...) au client. Le client demande alors à son ORB de résoudre l'IOR ce qui retourne une référence sur l'objet en cas de succès. Attention comme le port du serveur n'est pas fixe, l'IOR change à chaque démarrage.

- utiliser un service/daemon CORBA appelé le Service de Nommage (fournis en général avec ton ORB) que tu auras préalablement lancé sur une machine fixe (le super-calculateur, une autre machine, ...) et un port fixe. Cette solution est pas mal utile en grande entreprise.
Le serveur enregistrera l'objet avec un Nom et une Variante sur le Service de Nommage. Le client se connectera au service de Nommage et grace au Nom et à la Variante récupèrera la référence.

- Lancer le serveur sur un port fixe (voir les opions de l'ORB que tu utilises). Alors enregistrer l'objet avec un Nom sur un autre service CORBA propre a ton implémentation (IORTable dans TAO, BootManager dans ORBacus) que tu peux initialiser directement depuis ton code. Dans ce cas il n'y a donc rien besoin de lancer manuellement sur une autre machine.
Le client peut alors trouver une référence sur l'objet faisant une requête sur l'ORB ave l'URL corbaloc:iiop:<NomDuServer>:<PortDuServeur>/<NomDeLObjet>
A mon boulot je prefère cette solution qui est simple (côté client) et pas prise de tête.

*** Dans un vrai projet on aura tendance à séparer la partie CORBA et non CORBA. Cela permet entre autre de develloper facilement, tester séparément et réutiliser ailleurs (si besoin) les parties non-CORBA. Ainsi un servant sera plutot dans le genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
classe HelloImpl : public POA_test::Hello {
private :
  HelloNonCORBA* m_delegated;
 
...}
 
HelloImpl::HelloImpl(HelloNonCORBA* delegated) {
  m_delegated = delegated;
}
 
void HelloImpl::sayHello() throw (CORBA::Exception) {
  m_delegated->sayHello();
}
 
char* HelloImpl::tellHello() throw (CORBA::Exception) {
  const char* result = m_delegated->tellHello();
  return CORBA::String_dup(result);
}

Avec les options de bases de idlj tu ne peux obtenir que les fichiers de support du client. Je te conseilles toutefois de regarder la section Java IDL de la documentation Java tu y trouveras un didacticiel.

Tu peux cependant créer un client assez simple en utilisant un code similaire à celui-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
import test.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
 
...
 
try {
  ORB orb = ORB.init( (String[])null, null);
  String ior = ...
  /////////////////////////////////////////////////////////////////////////
  // Récupérer ici l'IOR de l'objet suivant l'un des 3 méthodes.  //
  // précédement décrites                                                      //
  // Voir didacticiel.                                                               //
  /////////////////////////////////////////////////////////////////////////
  org.omg.CORBA.Object objref = orb.string_to_object(ior);
  Hello hello = HelloHelper.narrow(objref);
  hello.sayHello(); // Affiche "Hello world" sur le serveur.
  System.out.println(hello.tellHello()); //Affiche "Hello world" sur le client.
}
catch (Throwable t) {
  t.printStackTrace();
}

Tu peux facilement reconnaitre les 3 étapes précédement décrites dans mon précédent courrier.

Pour le serveur ca va être un peu plus compliqué. Il faut d'abord que tu choisisses le language et la lib CORBA. Bien sur tu peux te créer un serveur de test en Java. Lis la doc, fais les tests de base décrits et on en reparleras alors.

Dans un domaine plus générique CORBA il existe "Advanced CORBA Programming with C++ de Michi Henning et Steve Vinoski chez Addison-Wesley ISBN 0-201-37927-9" mais j'ignore s'il existe en francais. Ce bouquin peut être très utile même si tu n'utilises pas C++. Par contre ce n'est en aucun cas un livre d'initiation (comme son titre le laisse penser) il faut connaitre un minimum de CORBA.

NON l'IOR ne te permet que de récupérer la référence sur l'objet distribué. => Ton serveur doit déjà tourner sur ton serveur de calcul.

Typiquement ton serveur sera un service/daemon (celon l'OS de ton supercalculateur) qui tournera en permanence sur le supercalculateur. Ton client se connectera sur ce service et lui demandera de lancer/arrêter des calculs. Il peut aussi lui demander d'acceder à un objet permettant de vérifier l'état dd'un calcul ou d'une simul donnée.

Simplement par l'une des 3 méthodes précédement décrites.

- enregistrer l'IOR dans un fichier
=> transmettre ce fichier au client (copie, FTP, HTTP, ...), lire ce fichier et se connecter au serveur.

- enregister l'objet sur le Service de Nommage.
=> contacter le service de Nommage pour obtenir l'IOR et se connecter au serveur.

- démarrer sur un port fixe et enregistrer l'objet sur un service CORBA propre à ton implémentation.
=> se connecter directement au serveur en utilisant une url corbaloc.