FR 2876852 A1 20060421 FR 0410952 A 20041015 PROCEDE DE FIABILISATION DE LA MULTI-DIFFUSION D'OBJETS DISTRIBUES La présente invention se rapporte à un procédé de fiabilisation de la mufti- diffusion d'objets distribués. Actuellement, le standard CORBA, qui est un des moyens utilisés pour assurer la transmission d'objets distribués, par exemple pour les transmissions entre calculateurs d'un même réseau, ne supporte que la multi-diffusion ( multicast en anglais) non fiabilisée des requêtes CORBA avec le protocole MIOP (cf. le document, OMG ptc/03-01-11 en date d'octobre 2001). Ce protocole MIOP ( Multicast Inter-ORB Protocol ) est mis en oeuvre pour envoyer des requêtes CORBA vers une couche de protocole multi-diffusion UDP, mais il ne garantit pas la fiabilité de la réception des requêtes et le respect de l'ordre de réception (appelé aussi ordonnancement ou ordering en anglais) de ces requêtes. Il est donc alors possible que des requêtes arrivent dans le désordre à leur destinataire, ou même qu'elles se perdent dans le réseau sans pouvoir être récupérées à la réception. Un nouveau protocole de multi-diffusion, le ROMIOP ( Reliable Ordered Multicast Inter-ORB Protocol en anglais, c'est-à-dire le protocole MIOP fiabilisé et ordonnancé), est en cours d'élaboration (la dernière version révisée connue date d' Octobre 2003), mais jusqu'à présent aucune réalisation concrète n'a été proposée au niveau industriel. En outre, ce protocole ROMIOP ne s'appuie pas sur les caractéristiques du protocole MIOP actuel, mais définira un nouveau protocole de communication. Il en résulte que si on l'utilisait tel qu'il est défini actuellement dans un environnement dans lequel les différents calculateurs ont des implémentations de CORBA différentes, mais inter-opérables, cela obligerait à conférer à tous les ORBs (les bus logiciels des objets répartis assurant le transport des requêtes entre les objets distribués) des implémentations compatibles entre elles du protocole ROMIOP. Enfin, ce protocole ROMIOP ne permet pas le choix, à l'émission et/ou à la réception de requêtes de multi-diffusion, d'une stratégie assurant un niveau de fiabilisation et/ou d'ordonnancement désiré, et limite le nombre de stratégies possibles au niveau des ORBs. La présente invention a pour objet un procédé de fiabilisation de la multidiffusion d'objets distribués, en particulier mais non exclusivement avec le langage CORBA, ce procédé permettant de fixer à tout moment et de manière dynamique une qualité de service souhaitée durant la durée d'utilisation du système de mise en oeuvre de la multi-diffusion, et assurant le bon ordonnancement et la réception des requêtes émises en multi-diffusion, et ce, sans modifier, du point de vue de l'utilisateur de l'application de ce système, les objets distribués; la mise en oeuvre de ce procédé pouvant être faite à l'aide de composants logiciels du commerce (composants dits COTS ) et de langages standard. La présente invention a également pour objet une librairie structurante ( Framework en anglais) pouvant être facilement intégrée à un système existant, sans modifier les couches ORB. Le procédé conforme à l'invention est un procédé de fiabilisation de la multidiffusion d'objets distribués, et il est caractérisé en ce que l'on établit un fichier décrivant l'interface entre les applications distribuées et indépendant du langage utilisé pour la gestion des objets, que l'on établit un fichier décrivant les qualités de service attendues, que l'on génère une liste de méta-modèles indépendants du langage de l'application, que l'on établit une bibliothèque d'algorithmes de fiabilisation, que l'on réalise un réceptacle dans lequel l'utilisateur décrit le comportement de l'application, que l'on établit un fichier de paramétrage du service côté client, et un fichier de paramétrage du service côté serveur et que l'on réalise par compilation un programme exécutable pour gérer les clients et les serveurs. La présente invention sera mieux comprise à la lecture de la description détaillée d'un mode de réalisation, pris à titre d'exemple non limitatif et illustré par le dessin annexé, sur lequel: - la figure 1 est un bloc-diagramme servant à expliquer la mise en oeuvre du procédé de l'invention, - la figure 2 est un bloc-diagramme d'un système simplifié mettant en oeuvre l'invention, et la figure 3 est un diagramme simplifié des différentes couches logiques du système de la figure 2 (les ORBs représentés sur la figure sont donnés à titre d'exemples et de manière non restrictive). La présente invention est décrite ci-dessous en référence à la multidiffusion de messages utilisant le langage CORBA, mais il est bien entendu qu'elle n'est pas limitée à cette seule application, et qu'elle peut être mise en oeuvre avec d'autres langages utilisant des vecteurs de transport de requêtes pour la distribution d'objets, comme par exemple le langage EJB ou le langage DOT.NET. Selon le diagramme de la figure 1 du dessin, on a représenté les différentes étapes menant à la réalisation de programmes exécutables destinés à créer, du côté des calculateurs clients et des calculateurs serveurs, des couches intermédiaires entre les applications et le middleware (couche intermédiaire) CORBA. A la fin de la présente description, on a fourni un exemple simplifié de différents fichiers (annexes 1 à 9). Cet exemple a été illustré à l'aide d'une requête quelconque, dont le nom générique est Foo , et qui est, pour le cas représenté sur les figures 2 et 3, la requête Hello . En premier lieu, on établit un fichier 1 (voir annexe 1), en format IDL, décrivant l'application considérée, les services et l'interface entre les applications distribuées, puis un fichier 2 (voir annexe 2), en format XML, décrivant les différentes qualités de service susceptibles d'être utilisées. A l'aide d'un générateur 3 de code multi-diffusion, par exemple un COTS (logiciel du commerce) en format XSLT, on génère un proxy (image locale d'un objet distant) côté client 4 incluant la définition des différentes qualités de service (telles que définies dans le fichier 2) et un squelette 5 côté serveur, incluant également la définition des différentes qualités de service (telles que définies dans le fichier 2). Par ailleurs, on dispose d'une bibliothèque 6 de services de multidiffusion, c'est-à-dire une bibliothèque d'algorithmes d'élaboration des différentes qualités de service, telles que définies dans le fichier 2. On dispose également d'un fichier 7 de code applicatif (voir annexe 4) utilisant les services de l'application, côté client (récepteur), et d'un fichier 8 (voir annexe 3) en langage IDL, généré grâce au générateur 3 à partir du fichier 1 que l'utilisateur doit implémenter et décrivant le comportement des services de l'application. L'utilisateur compile (9) les éléments 4 à 8 pour obtenir les exécutables client (10) (voir annexe 8) et serveur (11) (voir annexe 9). L'exécutable client comporte une bibliothèque 12 de noyau multi-diffusion, un proxy client 13 et un code de l'application 14. L'exécutable serveur comporte une bibliothèque 15 de noyau multi-diffusion, un squelette serveur 16 et la description 17 du comportement des services. Dans l'annexe 5, on a fourni un exemple de code d'implémentation utilisé lors de la transmission à nouveau d'une requête perdue, à l'initiative du client. L'annexe 6 est un exemple d'outil serveur permettant de créer des objets ORB sécurisés selon l'une parmi plusieurs qualités de service disponibles, tandis que l'annexe 7 est un exemple d'outil similaire pour le client associé à la même qualité de service. On a représenté en figure 2, de façon très simplifiée, un système comportant deux calculateurs 18, 19 reliés à un réseau de transmission commun 20, qui est une couche de middleware CORBA. Le calculateur client 18 est associé à une application quelconque 21 qui est encapsulée dans un réceptacle 22. Ce réceptacle 22 est une interface mettant en oeuvre l'exécutable 10 décrit ci-dessus, et en particulier la bibliothèque 12. Le calculateur serveur 19 est associé à une application quelconque 23, qui peut être différente de l'application 21. L'application 23 est encapsulée dans un réceptacle 24, qui est une interface mettant en oeuvre l'exécutable 11, et en particulier la bibliothèque 15. La couche CORBA 20 mémorise la liste ordonnée à numérotation régulière et continue 25 des requêtes envoyées par le client, et une liste ordonnée à numérotation régulière et continue 26 des requêtes reçues par le serveur. Le présent exemple se rapporte à une qualité de service absence d'un accusé de réception par le serveur ("negative acknowledgement" en anglais), mais il est bien entendu que d'autres types de qualité de service peuvent aussi bien être mis en oeuvre. L'application 21 émet une première requête, qui est, dans le cas présent, et 30 comme précisé ci-dessus, Hello . Cette requête est d'abord traitée par le service de multi-diffusion 12, puis transmise (27) via la couche CORBA 20 vers le service de multi-diffusion 15, homologue du service 12 avec ajout du numéro d'ordre de requête associé pour ce type de qualité de service particulière. Le service 15 devrait normalement transmettre cette requête à l'application 23. Si cette requête était perdue dans le réseau (comme illustré par une croix 28 coupant le trajet 27) , le service 15 enverrait une requête 29 de transmission à nouveau de la première requête étant entendu que cette dernière ne peut être effectuée que lors de la réception d'une autre requête de type 27 afin de déterminer un trou dans la séquence des numéros d'ordres des requêtes reçues 26 pour ce type de qualité de service. Le service 12 répète alors (30) la première requête. On a détaillé en figure 3 les différentes couches logiques de la librairie structurante de l'invention. L'application cliente (21) comporte une couche de composants logiciels 31 de communication CORBA. Ces composants sont, par exemple, en langage C++, et renferment un code applicatif 32 utilisant le service applicatif client. de l'application 21. De façon similaire, l'application serveur (23) comporte une couche de composants logiciels 33 de communication CORBA. Ces composants sont, par exemple, en langage Java, et renferment un code serveur 34 fourni par l'utilisateur de l'application 23, ce code correspondant au comportement du service applicatif serveur. Le service 32 envoie ses requêtes au proxy client 13, qui est contenu dans le réceptacle 22. Ce proxy 13 contient la définition courante de la qualité de service demandée pour les requêtes client. Le proxy 13, d'une part, communique avec la bibliothèque 12, et d'autre part envoie les requêtes 27 et 30 au squelette serveur 16 via la couche CORBA 20. Cette couche 20 comporte par exemple, du côté client, une implémentation d'un ORB TAO 35 TAO est un COTS et un exemple d'ORB supportant la projection ( mapping en anglais) CORBA IDL / C++ - , et du côté serveur, une implémentation d'un ORB du type JacORB (JacORB est un COTS et un exemple d'ORB supportant le mapping CORBA IDL / Java) contenues dans 20.La communication entre client et serveur est réalisée selon le protocole multidiffusion UDP/IP 37. Du côté serveur, le squelette 16 reçoit les requêtes client 27 et 30, et communique avec la bibliothèque 15, qui est chargée d'émettre la requête d'émission à nouveau 29. Le squelette 16 transmet les informations reçues au code 34. Ainsi, la librairie structurante ( Framework en anglais) de l'invention permet de placer les solutions de fiabilité non pas sous forme ROMIOP (au niveau des objets ORB donc de manière intrusive pour l'implémentation des ORBs), mais au-dessus de la couche ORB, sans modifier les objets des ORBs. Le problème d'inter-opérabilité est alors résolu en utilisant le service de multi-diffusion standard actuel (le protocole MIOP). Il en résulte que les moyens assurant la fiabilité et l'ordonnancement peuvent être facilement intégrés à un système existant en tant qu'élément enfichable ( plug-in en anglais), et ce, sans modifier la couche ORB. La présente invention permet de prévoir dans un système à la fois différentes qualités de service et différents types d'ordonnancement, et de choisir l'un d'entre eux, et même d'en changer dynamiquement. Parmi les différentes qualités de service possibles, on peut citer: - service non fiabilisé (équivalent au MIOP), service fiabilisé par émission multiple, service fiabilisé avec détection d'erreurs par le serveur, - service fiabilisé avec détection d'erreurs par le client, - service avec présence d'un accusé de reception par le client ou en l'absence d'un accusé de réception par le serveur (respectivement "acknowledgement", ou "negative acknowledgement" en anglais). Bien entendu, compte tenu de l'aspect modulaire du service, il est facilement possible d'ajouter ultérieurement d'autres qualités de service. Parmi les différents types d'ordonnancement (analogues aux types d'ordonnancement de files d'attente de messages CORBA) , on peut citer: l'ordonnancement temporel, - l'ordonnancement à priorités de message, l'ordonnancement avec respect des temps maximaux alloués à la 30 réception des requêtes. Grâce à l'invention, on minimise l'impact sur l'utilisation de l'architecture CORBA (au niveau des API), ce qui permettra l'éventuelle utilisation du service de multi-diffusion fiable du futur standard ROMIOP en plus du service de l'invention. L'invention offre en outre une architecture ouverte, c'est-à-dire donnant le moyen aux utilisateurs d'ajouter facilement d'autres types de qualité de service et d'ordonnancement des requêtes CORBA. L'utilisation du langage CORBA standard assure une meilleure interopérabilité entre applications différentes et l'utilisation de méta-modèles ( templates XSLT) au niveau du générateur de code garantit l'évolutivité du service par le support de différents langages de programmation pour manipuler les objets distribués (C++, Java, Ada...). ANNEXES ANNEXE 1 #ifndef _BasicFooManager_idl_ #define _BasicFooManager_idl_ #include "ValuetypeBlock.idl" module Test { interface FooManager { oneway void set_Foo_name(in string name); // create source Foo oneway void create_source_Foo (in Block::SourceBlock theSourceBlock, in Block::IdentityBlock theldentityBlock, in Block::KinematicBlock theKinematicBlock); // update source Foo kinematic block oneway void update_source_Foo_kinematic (in B1ock::SourceBlock theSourceBlock, in Block::KinematicBlock theKinematicBlock); 2876852 8 // update a Foo // the Foo is identified by the source block embedded in the sequence of blocks // the other blocks contains the updated data oneway void update_Foo (in Block::Blocks theBlocks); // drop source Foo oneway void drop_source_Foo (in B1ock::SourceBlock theSourceBlock); // drop a list of source Foos oneway void drop_source_Foos (in B1ock::SourceBlocks theSourceBlocks); #endif ANNEXE 2 Test ../idl/BasicFooManager.idl ---------------- ANNEXE 3 /* = FooManagerBehavior.idl = This file has been generated by COBRA (COrba Based Real-time Architecture) Code Generator 1.0 = for the fault tolerance and multicast service(s) = on Fri May 07 16:37:01 CEST 2004 = DO NOT EDIT! ! ! =*/ #ifndef _FooManagerBehavior_idl_ 10 #define _FooManagerBehavior_idl_ #include "BasicFooManager.idl" local interface FooManagerBehavior: Test::FooManager {}; #endif //FooManagerBehavior idl_ ----------------ANNEXE 4 = FooManager_ROTemporalMulticast.idl = This file has been generated by COBRA (COrba Based Real-time Architecture) Code Generator 1.0 = for the fault tolerance and multicast service(s) = on Fri May 07 16:37:01 CEST 2004 = DO NOT EDIT! ! ! = ===---=*/ #ifndef _FooManager_ROTemporalMulticast_idl_ #define _FooManager_ROTemporalMulticast _idl_ // To add multicast types #include #include "BasicFooManager.idl" interface FooManager_ROTemporalMulticast { // Operations like: // oneway void op(QoS, args); oneway void set_Foo_name( in Multicast::Senderldentifier sender, in Multicast::QueueOrder order, 45 in string name); oneway void create_source_Foo( in Multicast::Senderldentifier sender, in Multicast::QueueOrder order, in B1ock::SourceBlock theSourceBlock, in B1ock::IdentityBlock theldentityBlock, in B1ock::KinematicBlock theKinematicBlock); oneway void update_source_Foo_kinematic( in Multicast::Senderldentifier sender, in Multicast::QueueOrder order, in B1ock::SourceBlock theSourceBlock, in B1ock::KinematicBlock theKinematicBlock); oneway void update_Foo( in Multicast::Senderldentifier sender, in Multicast::QueueOrder order, in Block::Blocks theBlocks); oneway void drop_source_Foo( in Multicast::Senderldentifier sender, in Multicast::QueueOrder order, in B1ock::SourceBlock theSourceBlock); oneway void drop_source_Foos( in Multicast::Senderldentifier sender, in Multicast::QueueOrder order, in B1ock::SourceBlocks theSourceBlocks); // Attributes like: // oneway void set_attr(QoS, value); // No attribute accessor here #endif //_FooManager ROTemporalMulticast_idl_ 35 ----------------Annexe 5 / * = FooManager_ROTemporalMulticast impl.cpp = This file has been generated by COBRA (COrba Based Real-time Architecture) Code Generator 1.0 = for the fault tolerance and multicast service(s) = on Fri May 07 16:37:01 CEST 2004 10 15 20 25 = DO NOT EDIT! ! ! #include "FooManager_ROTemporalMulticast_impl.hpp" FooManager_ROTemporalMulticast impl::FooManager_ROTemporalMulticast_im p10: m_strategy(0) FooManager_ROTemporalMulticast_impl::- FooManager ROTemporalMulticast_i mpl() { if (m_strategy) { delete m strategy; m_strategy = 0; }; void FooManager_ROTemporalMulticast_impl::init(FooManagerBehavior_ptr 20 local ref, const Multicast::Reliability& reliability, const Multicast::Ordering& ordering, const Multicast::QueueSize& queue_size, const Multicast::Timeout& timeout, const Multicast::Retries& retries, const Multicast::FaultReportFile& file, const Multicast::NumberOfSenders& const Multicast: : Retransmission& const Multicast::RetransmissionMode& const Multicast::InetAddress& const Multicast::FirstRequestMode& const Multicast::InetAddress& inet_address, CORBA::ORB_ptr orb) m_local_ref = FooManagerBehavior::_duplicate(local_ref); m_reliability = reliability; m_ordering = ordering; m_number of senders = number_of_senders; m_timeout = timeout; mretnes = retries; _ m file = file; number of senders, retransmission, retransmission mode, retransmission_inetaddress, first request mode, m_retransmission = retransmission; m_retransmission_mode = retransmission_mode; m_ retransmission_inetaddress = retransmission_inetaddress; m_first_request_mode = first_request_mode; minet address = inet_address; m_orb = CORBA: : ORB: :_duplicate(orb); m_strategy = new Multicast::StrategyManager; m_strategy->init(reliability, ordering, queue_size, timeout, retries, retransmission, retransmission_mode, retransmission_inetaddress, first_request_mode, inet_address, 10 file, orb); for(int i=O;i add_strategy(new Multicast::OrderTemporalReceiverStrategy()); } #ifdef MSDEBUG1 std::cout m_strategy->print() std::endl; #endif // Operations like // virtual void FooManager_ROTemporal::op(args) throw (CORBA::SystemException) { ... }; // // FooManager ROTemporalMulticast_impl::set_Foo_name() // ---=--== = ---void FooManager_ROTemporalMulticast_impl::set_Foo_name( const char* sender, Multicast::QueueOrder order, const char* name) throw (CORBA::SystemException) #ifdef MSDEBUG2 std::cout "execute set Foo narre " std::endl; #endif Multicast::OrderTemporalReceiverStrategy* strategy = (Multicast::OrderTemporalReceiverStrategy*) m_strategy-> get_strategy(sender); if (strategy!= (Multicast:: OrderTemporalReceiverStrategy*) NULL) { 35 Multicast::OrderedQueue* queue = strategy->getQueue(); Multicast::MutexType& mutex = queue->getMutex(); bool try_execute = false; bool out of range = false; CDMW MUTEX GUARD(mutex); Multicast::QueueOrderElementHeader* elementHeader = queue-> try_append(order); if (((elementHeader!_ (Multicast::QueueOrderElementHeader*) NULL) && (elementHeader!_ (Multicast::QueueOrderElementHeader*) 0))) { Multicast::QueueOrderElement* element = new FooManager_set_Foo_name_ROTemporalMulticastArgs( m_local_ref.in(), narre); element->element_id = "Test: :FooManager: : set_Foo_name"; element-> sender = CORBA::string_dup(sender); element->order = order; elementHeader- >element = element; queue->appended(elementHeader); try_execute = true; else if (elementHeader = (Multicast::QueueOrderElementHeader*) 0) out_of_range = true; if (try_execute) strategy->try_execute(order); else if (out_of_range) strategy->out_of range(); 45} // _= // FooManager ROTemporalMulticast impl::create_source_Foo() //---= =----=--====----== = = void FooManager_ROTemporalMulticast_impl::create_source_Foo( const char* sender, Multicast::QueueOrder order, B1ock::SourceBlock* theSourceBlock, B1ock::IdentityBlock* theldentityBlock, Block::KinematicBlock* theKinematicBlock) throw (CORBA: :SystemException) #ifdef MSDEBUG2 std::cout "execute create_source_Foo " std::endl; #endif Multicast:: OrderTemporalReceiverStrategy* strategy = (Multicast::OrderTemporalReceiverStrategy*) m_strategy-> get_strategy(sender); if (strategy!_ (Multicast::OrderTemporalReceiverStrategy*) NULL) { Multicast::OrderedQueue* queue = strategy->getQueue(); Multicast::MutexType& mutex = queue->getMutex(); bool try_execute = false; 30 bool out_of range = false; CDMW MUTEX GUARD(mutex); Multicast::QueueOrderElementHeader* elementHeader = queue-> try_append(order); if (((elementHeader!_ (Multicast:: QueueOrderElementHeader*) NULL) && 40 (elementHeader!= (Multicast::QueueOrderElementHeader*) 0))) Multicast::QueueOrderElement* element = new FooManager_create_source_Foo_ROTemporalMulticastArgs( m_local_ref.in(), theSourceBlock, theldentityBlock, 45 theKinematicBlock); element->element_id = "Test: :FooManager: :create_source_Foo"; element-> sender = CORBA::string_dup(sender); element->order = order; elementHeader>element = element; queue->appended(elementHeader); try_execute = truc; else if (elementHeader = (Multicast::QueueOrderElementHeader*) 0) { out of range = truc; if (try_execute) strategy->try_execute(order); else if (out_of_range) strategy->out_of range(); } 25} // _ _ =--==--==--===== = _ _ // FooManager_ROTemporalMulticast impl::update_source_Foo_kinematic() --=- void FooManager ROTemporalMulticast_impl::update_source_Foo_kinematic( const char* sender, Multicast::QueueOrder order, Block: : SourceBlock* theSourceBlock, Block: :KinematicBlock* theKinematicBlock) 35 throw (CORBA::SystemException) #ifdef MSDEBUG2 std::cout "execute update_source_Foo_kinematic " std::endl; #endif Multicast::OrderTemporalReceiverStrategy* strategy = (Multicast:: OrderTemporalReceiverStrategy*) m_strategy-> get_strategy(sender); if (strategy!_ (Multicast:: OrderTemporalReceiverStrategy*) NULL) Multicast::OrderedQueue* queue = strategy->getQueue(); Multicast::MutexType& mutex = queue->getMutexO; bool try_execute = false; bool out of range = false; { CDMW MUTEX GUARD(mutex); Multicast::QueueOrderElementHeader* elementHeader = queue>try_append(order); if (((elementHeader!_ (Multicast::QueueOrderElementHeader*) NULL) && (elementHeader!_ (Multicast:: QueueOrderElementHeader*) 0))) Multicast::QueueOrderElement* element = new FooManager update_source_Foo_kinematic_ROTemporalMulticastArgs( m local_ref.in(), theSourceBlock, theKinematicBlock); element->element_id = "Test::FooManager::update_source_Foo_kinematic"; element->sender = CORBA::string_dup(sender); element->order = order; elementHeader->element = element; queue->appended(elementHeader); try_execute = true; 35} else if (elementHeader (Multicast::QueueOrderElementHeader*) 0) { out_of range = true; if (try_execute) strategy->try_execute(order); 45 else if (out_of_range) strategy->out_of rangeQ; // // FooManager_ROTemporalMulticast impl::update_Foo() // == void FooManager ROTemporalMulticast_impl::update_Foo( const char* sender, Multicast::QueueOrder order, const Block::Blocks& theBlocks) throw (CORBA::SystemException) #ifdef MSDEBUG2 std::cout "execute update_Foo " std::endl; #endif Multicast::OrderTemporalReceiverStrategy* strategy = (Multicast:: OrderTemporalReceiverStrategy*) m_strategy-> get_strategy(sender); if (strategy!= (Multicast:: OrderTemporalReceiverStrategy*) NULL) { Multicast::OrderedQueue* queue = strategy->getQueue0; Multicast::MutexType& mutex = queue->getMutexQ; bool try_execute = false; bool out of range = false; CDMW MUTEX GUARD(mutex); Multicast::QueueOrderElementHeader* elementHeader = queue-> try_append(order); if (((elementHeader!= (Multicast::QueueOrderElementHeader*) NULL) && (elementHeader!= (Multicast::QueueOrderElementHeader*) 0))) Multicast::QueueOrderElement* element = new FooManager_update_Foo_ROTemporalMulticastArgs( m_local_ref. inQ, theBlocks); element->element_id = "Test::FooManager::update_Foo"; element->sender = CORBA::string_dup(sender); element->order = order; elementHeader->element = element; queue->appended(elementHeader); try_execute = true; else if (elementHeader = (Multicast::QueueOrderElementHeader*) 0) { out_of range = truc; if (try_execute) strategy->try_execute(order); else if (out_of_range) strategy->out_of range(); } } //--= =-fi FooManager_ROTemporalMulticast impl::drop_source_Foo() //--_ - -- void FooManager_ROTemporalMulticast_impl::drop_source_Foo( const char* sender, Multicast: : QueueOrder order, B1ock::SourceBlock* theSourceBlock) throw (CORBA: : SystemException) #ifdef MSDEBUG2 std::cout "execute drop_source_Foo " std::endl; #endif Multicast::OrderTemporalReceiverStrategy* strategy = (Multicast::OrderTemporalReceiverStrategy*) m_strategy-> get_strategy(sender); if (strategy!_ (Multicast:: OrderTemporalReceiverStrategy*) NULL) Multicast::OrderedQueue* queue = strategy->getQueue(); Multicast::MutexType& mutex = queue->getMutexO; bool try_execute = false; bool out of range = false; CDMW MUTEX GUARD(mutex); Multicast::QueueOrderElementHeader* elementHeader = queue-> try_append(order); if (((elementHeader!= (Multicast::QueueOrderElementHeader*) NULL) && (elementHeader!= (Multicast:: QueueOrderElementHeader*) 0))) Multicast::QueueOrderElement* element = new FooManager_drop_source_Foo_ROTemporalMulticastArgs( m_local_ref.inQ, theSourceBlock); element->element_id = "Test: :FooManager::drop_source_Foo"; element->sender = CORBA::string_dup(sender) ; 25 element->order = order; elementHeader->element = element; queue-> appended(elementHeader); try_execute = true; else if (elementHeader = (Multicast:: QueueOrderElementHeader*) 0) { out_of range = true; } if (try_execute) strategy->try_execute(order); else if (out_of_range) strategy->out_of range(); 15 } // // FooManager_ROTemporalMulticast impl::drop_source_Foos() // void FooManager_ROTemporalMulticast_impl::drop_source_Foos( const char* sender, Multicast::QueueOrder order, const Block::SourceBlocks& theSourceBlocks) throw (CORBA::SystemException) #ifdef MSDEBUG2 std::cout "execute drop_source_Foos " std::endl; #endif Multicast::OrderTemporalReceiverStrategy* strategy = (Multicast::OrderTemporalReceiverStrategy*) m_strategy-> get_strategy(sender); if (strategy!_ (Multicast::OrderTemporalReceiverStrategy*) NULL) { Multicast::OrderedQueue* queue = strategy->getQueue();Multicast::MutexType& mutex = queue->getMutex(); bool try_execute = false; bool out of range = false; CDMW MUTEX GUARD(mutex); Multicast::QueueOrderElementHeader* elementHeader = queue-> try_append(order); if (((elementHeader!_ (Multicast: : QueueOrderElementHeader*) NULL) && (elementHeader!_ (Multicast::QueueOrderElementHeader*) 0))) Multicast::QueueOrderElement* element = new FooManager_drop_source_Foos_ROTemporalMulticastArgs( m_local_ref.in(), theSourceBlocks); element->element_id = "Test::FooManager::drop_source_Foos"; element->sender = CORBA::string_dup(sender); element->order = order; elementHeader->element = element; queue->appended(elementHeader); try_execute = true; else if (elementHeader (Multicast::QueueOrderElementHeader*) 0) out_of range = true; 15} if (try_execute) strategy->try_execute(order); else if (out_of_range) strategy->out_of range(); // Attributes like: // virtual void set_attr(value) throw (CORBA::SystemException); // No attribute accessor here ---------------- ANNEXE 6 /* --= FooManager_ROTemporalMulticastServerFactory.hpp = This file has been generated by COBRA (COrba Based Real-time Architecture) Code Generator 1.0 = for the fault tolerance and multicast service(s) = on Fri May 07 16:37:01 CEST 2004 = DO NOT EDIT! ! ! #ifndef _FooManager ROTemporalMulticastServerFactory_hpp_ #define _FooManager_ROTemporalMulticastServerFactory_hpp_ #include #include "FooManager_ROTemporalMulticast_impl.hpp" clans FooManager_ROTemporalMulticastServerFactory { public: FooManager_ROTemporalMulticastServerFactory(); FooManager_ROTemporalMulticastServerFactoryO; inline void initServerSide(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, FooManagerBehavior_ptr user_impl_object) { m_orb = CORBA: : ORB: :_duplicate(orb); if (!CORBA::is_nil(poa)) m_poa = PortableServer: :POA: :_duplicate(poa); muser impl_object = FooManagerBehavior::_duplicate(user impl_object); } ; inline void setInetAddress(const Multicast::InetAddress& inetAddress) { m_inetAddress = inetAddress; }; inline void setTTL(const Multicast::TTL& ttl) { m_ttl = ttl; }; inline void setQueueSize(const Multicast::QueueSize& queue_size) { 30 m_queue_size = queue_size; } ; inline void setNumberOfSenders(const Multicast::NumberOfSenders& number_ofsenders) { m_numberof senders = number_of senders; }; inline void setReliability(const Multicast::Reliability& reliability) { m_reliability = reliability; }; inline void setOrdering(const Multicast::Ordering& ordering) { m_ordering = ordering; }; inline void setRetransmission(const Multicast::Retransmission& retransmission) { m_retransmission = retransmission; }; inline void setRetransmissionMode(const Multicast::RetransmissionMode& retransmission_mode) { m_retransmission_mode = retransmission_mode; }; inline void setRetransmissionInetAddress(const Multicast::InetAddress& retransmission_inetaddress) { m_ retransmission_inetAddress = retransmission_inetaddress; }; inline void setFirstRequestMode(const Multicast::FirstRequestMode& 45 first_request_mode) { m_first_request_mode = first_request_mode; } ; inline void setRetries(const Multicast::Retries& retries) { m_retries = retries; }; 2876852 23 inline void setTimeout(const Multicast::Timeout& timeout) { m_timeout = timeout; }; inline void setFaultReportFile(const Multicast::FaultReportFile& file) { m_file = file; }; inline void setThreadPoolSize(int thread_pool_size) { m_thread_pool_size = thread_pool_size; } ; inline void setCorbaloc(const Multicast::Corbaloc& corbaloc) { m_corbaloc = corbaloc; }; inline Multicast::InetAddress getInetAddressQ { return m_inetAddress; }; inline Multicast::TTL getTTLQ { return m_ttl; }; inline Multicast::QueueSize getQueueSize() { return m_queue_size; }; inline Multicast::NumberOfSenders getNumberOfSenders() { return m_number_ofsenders; }; inline Multicast::Reliability getReliability() { return m_reliability; }; inline Multicast::Ordering getOrdering() { return m_ordering; }; inline Multicast::Retransmission getRetransmission() { return m_retransmission; }; inline Multicast::RetransmissionMode getRetransmissionMode() { return m_retransmissionmode; }; inline Multicast::InetAddress getRetransmissionlnetAddress() { return mretransmissioninetAddress; }; inline Multicast::FirstRequestMode getFirstRequestMode() { return m_first_request_mode; 1; inline Multicast::Retries getRetries() { return m_retries; }; inline Multicast::Timeout getTimeout() { return m_timeout; } ; inline Multicast::FaultReportFile getFaultReportFile() { return m_file; }; inline Multicast::ThreadPoolSize getThreadPoolSize() { return m_thread_pool_size; } ; inline Multicast::Corbaloc getCorbaloc() { return m_corbaloc; }; 30 inline Multicast::TTL getDefaultTTL() { return DEFAULT_TTL; }; inline Multicast::QueueSize getDefaultQueueSize() { return DEFAULT_QUEUE_SIZE; }; inline Multicast::NumberOfsenders getDefaultNumberOfSenders() { return 35 DEFAULT_NUMBER_OF_SENDERS; }; inline Multicast::Reliability getDefaultReliability() { return DEFAULT_RELIABILITY; }; inline Multicast::Ordering getDefaultOrdering() { return DEFAULT_ORDERING; }; inline Multicast::Retransmission getDefaultRetransmission() { return DEFAULT_RETRANSMISSION; }; inline Multicast::RetransmissionMode getDefaultRetransmissionMode() { return DEFAULT_RETRANSMISSION_MODE; }; inline Multicast::InetAddress getDefaultRetransmissionInetAddress() { return 45 ((getRetransmission() == Multicast: : MULTICAS T_RETRANSMIS SION) ? DEFAULT_MIOP_RELIABLE_INETADDRESS: DEFAULT_IIOP_RELIABLE_INETADDRESS); }; inline Multicast::FirstRequestMode getDefaultFirstRequestModeO { return DEFAULT_FIRST_REQUEST_MODE; }; inline Multicast::Retries getDefaultRetries() { return DEFAULT_LIMITED_RETRIES; }; inline Multicast::Timeout getDefaultTimeoutO { return DEFAULT_RELATIVE_REQUEST_TIMEOUT; }; inline Multicast::FaultReportFile getDefaultFaultReportFile() { Multicast::FaultReportFile default_file; default_file.init(DEFAULT FAULT_REPORT_FILE("FooManager_ROTemporalS erver")); return default_file; }; inline Multicast::ThreadPoolSize getDefaultThreadPoolSize() { return DEFAULT_THREAD_POOL_SIZE; }; Test::FooManager_ptr create_objectO; inline PortableServer::ServantBase* getServant() { return m_remote_impl; }; void activate_object_with_id(PortableServer::ServantBase* servant); void deactivate_object(PortableServer::ServantBase* servant); bool is_activated(PortableServer::ServantBase* servant); Multicast:: Reliability Multicast::Ordering Multicast: :Retransmission Multicast::RetransmissionMode m_retransmission_mode; Multicast::InetAddress mretransmission_inetAddress; Multicast:: FirstRequestMode m_first_request_mode; Multicast::Retries mretries; Multicast::Timeout m_timeout; Multicast::FaultReportFile m_file; Multicast::ThreadPoolSize m_thread_pool_size; Multicast::Corbaloc m_corbaloc; CORBA::ORB var m_orb; PortableServer::POA_var m_poa; PortableServer::POA_var m_rt_poa; PortableServer::ObjectId_var m_oid; CORBA::Object_var m_object_group; FooManagerBehavior_var m_user impl_object; FooManager_ROTemporalMulticast impl* m_remote_impl; 30 private: Multicast::InetAddress m_inetAddress; Multicast::TTL m_ttl; Multicast::QueueSize m_queue_size; Multicast::NumberOfSenders mnumberofsenders; _ _ m_reliability; m_ordering; m _retransmission; std::string m_corbalocAddress; std::list m_oid_list; typedef std::list ::iterator oid LI; }; #endif // FooManager ROTemporalMulticastServerFactory_hpp_ ----------------ANNEXE 7 ----------------- /* ==--=--==----=.= -------- _ _--_ = FooManager_ROTemporalMulticastClientFactory.hpp = This file has been generated by COBRA (COrba Based Real-time Architecture) Code Generator 1.0 = for the fault tolerance and multicast service(s) = on Fri May 07 16:37:01 CEST 2004 = DO NOT EDIT! ! ! _*/ #ifndef _FooManager_ROTemporalMulticastClientFactory_hpp_ 25 #define _FooManager_ROTemporalMulticastClientFactory_hpp_ #include #include "FooManager_ROTemporalMulticast proxy_impl.hpp" class FooManager_ROTemporalMulticastClientFactory { public: FooManager_ROTemporalMulticastClientFactory(); FooManager_ROTemporalMulticastClientFactory(); inline void initClientSide(CORBA::ORB ptr orb) {m_orb = CORBA::ORB::_duplicate(orb); } ; inline void setInetAddress(const Multicast::InetAddress& inetAddress) { m_inetAddress = inetAddress; }; inline void setTTL(const Multicast::TTL& ttl) { m_ttl = ttl; }; inline void setQueueSize(const Multicast::QueueSize& queue_size) { 45 m_queue_size = queue_size; } ; inline void setReliability(const Multicast::Reliability& reliability) { m_reliability = reliability; }; inline void setOrdering(const Multicast::Ordering& ordering) { m_ordering = ordering; } ; inline void setRetransmission(const Multicast::Retransmission& retransmission) { m_retransmission = retransmission; }; inline void setRetransmissionInetAddress(const Multicast::InetAddress& retransmission_inetaddress) { m_retransmission_inetAddress = retransmission_inetaddress; }; inline void setRetries(const Multicast::Retries& retries) { m_retries = retries; }; inline void setTimeout(const Multicast::Timeout& timeout) { m_timeout = timeout; }; inline void setRepetitionNumber(const Multicast::RepetitionNumber& repetition_number) { m_repetition_number = repetition_number; }; inline void setRepetitionDelay(const Multicast::RepetitionDelay& repetition_delay) { m_repetition_delay = repetition_delay; }; inline void setFaultReportFile(const Multicast::FaultReportFile& file) { m_file = file; }; inline void setSenderldentifier(const Multicast::Senderldentifier& sender) { 20 m_sender = CORBA::string_dup(sender); }; inline void setCorbaloc(const Multicast::Corbaloc& corbaloc) { m_corbaloc = corbaloc; }; inline Multicast::InetAddress getlnetAddress() { return m_inetAddress; }; inline Multicast::TTL getTTL() { return m_ttl; }; inline Multicast::QueueSize getQueueSize() { return m_queue_size; }; inline Multicast::Reliability getReliability() { return m_reliability; }; inline Multicast::Ordering getOrdering() { return m_ordering; }; inline Multicast::Retransmission getRetransmissionO { return m_retransmission; }; inline Multicast::InetAddress getRetransmissionInetAddress() { return m_retransmission_inetAddress; }; inline Multicast::Retries getRetries() { return m_retries; }; inline Multicast::Timeout getTimeoutO { return m_timeout; }; inline Multicast::RepetitionNumber getRepetitionNumber() { return m_repetition_number; }; inline Multicast::RepetitionDelay getRepetitionDelayO { return m_repetition_delay; }; inline Multicast::FaultReportFile getFaultReportFile() { return m_fle; }; inline Multicast::Senderldentifier getSenderldentifier() { return m_sender; }; inline Multicast::Corbaloc getCorbaloc() { return m_corbaloc; }; inline Multicast::TTL getDefaultTTL() { return DEFAULT_TTL; }; inline Multicast::QueueSize getDefaultQueueSize() { return DEFAULT_QUEUE_SIZE; }; inline Multicast::Reliability getDefaultReliability() { return DEFAULT_RELIABILITY; }; inline Multicast::Ordering getDefaultOrdering() { return DEFAULT_ORDERING; }; inline Multicast::Retransmission getDefaultRetransmission() { return DEFAULT_ RETRANSMISSION; }; inline Multicast::InetAddress getDefaultRetransmissionlnetAddress() { return ((getRetransmission() == Multicast::MULTICAST_RETRANSMISSION) ? DEFAULT MIOP RELIABLE INETADDRESS: DEFAULT_IIOP_RELIABLE_INETADDRESS); }; inline Multicast::Retries getDefaultRetries() { return DEFAULT LIMITEDRETRIES; }; inline Multicast::Timeout getDefaultTimeout() { return DEFAULT RELATIVE REQUESTTIMEOUT; }; inline Multicast::RepetitionNumber getDefaultRepetitionNumber() { return DEFAULT_REPETITION_NUMBER; }; inline Multicast::RepetitionDelay getDefaultRepetitionDelay() { return DEFAULT REPETITIONDELAY; }; inline Multicast::FaultReportFile getDefaultFaultReportFile() Multicast::FaultReportFile default_file; default_file. init(DEFAULT_FAULT_REPORT_F ILE("FooManager_ROTemporalC lient")); return default_file; }; inline Multicast:: Senderldentifier getDefaultSenderldentifier() INIT SENDER IDENTIFIER; return DEFAULT SENDER IDENTIFIER(m_inetAddress,"Test::FooManager","FooMan ager_ROTemporal"); } ; Test::FooManager_ptr create_objectO; private: Multicast::InetAddress Multicast::TTL Multicast:: Queue S ize Multicast:: Rel iability Multicast::Ordering Multicast: :Retransmission Multicast::InetAddress Multicast::Retries Multicast::Timeout Multicast:: RepetitionNumber Multicast:: RepetitionDelay Multicast::FaultReportFile Multicast:: Senderldentifier_var Multicast::Corbaloc CORBA::ORB_var}; m_inetAddress; m ttl; m_queue_size; m_reliability; m_ordering; m retransmission; _ m_retransmission_inetAddress; mretries; mtimeout; _ m_repetition_number; m_repetition_delay; m_file; m_sender; m corbaloc; m orb; #endif // FooManager_ROTemporalMulticastClientFactory_hpp_ --------------- -ANNEXE 8 // // File: Client.cpp // #include "FooManager_ROTemporalMulticastClientFactoryHelper.hpp" // Stimulator include #include #include 15 #include #include // Implementation of all Actions #include "InstAction.hpp" #include "MulticastEventListener.hpp" // perco includes #include #include #include #include #include 30 #include using namespace std; static bool M_stopped = false; void usage(string exeName) { cout "Usage: " exeName " [Properties file] [Server endpoint]" endl; cout " endl; } Option: [QueueSize] [Timeout] [Retries] [TTL]" void instance_stimulator(string parseFile, Test:: FooManager var FooManagerV, 45 CORBA::ORBvar orb) Stimulator* stimu = new Stimulator(); // Parse file "Stimulator.properties" Parser* parse = new Parser(); // conf. the stimu members and all actions members parse-> parseFileln(parseFile); // instance of de Default call back cycle DefaultEndCycleCallback *decc = new DefaultEndCycleCallbackO; // instance of actions CreateSourceFooAction *cal; UpdateSourceFooKinematicAction *ca2; 15 UpdateFooAction *ca4; Drop SourceFooAction *ca3; Drop SourceFoosAction *ca5; SetFooNameAction *ca6; // instance of ResultWriter ResultWriter* resultWriter = new ResultWriterO; // add endcyclecallbacks in the Stimulator stimu-> setEndCycleCallback(decc); // set stimulator properties stimu->m_cyclePeriod = parse->getStimulatorPropertiesO.m_cyclePeriod; stimu->m_statisticsType = parse->getStimulatorProperties(). m_statisticsType; stimu->m _nbDummyCycles = parse>getStimulatorPropertiesO.m_nbDummyCycles; stimu->m nbCycles = parse-> getStimulatorProperties().m_nbCycles; // add actions in the stimulator and transfert properties for(int i=0; i getNumberOfActionsO; i++) { switch(parse->getActionProperties(i). m_ActionType) case 1: cal = new CreateSourceFooAction(FooManagerV); ça 1->m_info = parse->getActionProperties(i).m_info; 40 cal -> m_startupDelay = parse>getActionProperties(i).m_startupDelay; cal ->m_nbExecutionsPerCycle = parse->getActionProperties(i).m_nbExecutionsPerCycle; cal->m_executionGroupSize = parse>getActionProperties(i).m_executionGroupSize; cal ->m_betweenGroups Delay = parse->getActionPropertie s(i). m_betweenGroup sDelay; cal -> m_ActionType = parse->getActionProperties(i).m_ActionType; stimu-> addAction(ca 1); break; case 3: ca2 = new UpdateSourceFooKinematicAction(FooManagerV); ca2->m_info = parse-> getActionProperties(i).m_info; ca2->m_startupDelay = parse-> getActionProperties(i).m_startupDelay; ca2->m_nbExecutionsPerCycle = parse->getActionProperties(i).m_nbExecutionsPerCycle; ca2-> m_executionGroupSize = parse->getActionProperties(i).m_executionGroupSize; ca2->m_betweenGroupsDelay = parse->getActionProperties(i). m_betweenGroupsDelay; ca2->m_ActionType = parse>getActionProperties(i).m_ActionType; stimu->addAction(ca2); break; case 2: ca3 = new Drop SourceFooAction(FooManagerV); ca3->m_info = parse-> getActionProperties(i).m_info; ca3->m_startupDelay = parse>getActionProperties(i).m_startupDelay; ca3->m_nbExecutionsPerCycle = parse->getActionProperties(i).m_nbExecutionsPerCycle; ca3-> m_executionGroupSize = parse->getActionProperties(i).m_executionGroupSize; ca3->m_betweenGroupsDelay = parse->getActionProperties(i). m_betweenGroupsDelay; ca3->m_ActionType = parse>getActionProperties(i).m_ActionType; stimu->addAction(ca3); break; case 4: ca4 = new UpdateFooAction(FooManagerV); ca4->m_info = parse-> getActionProperties(i).m_info; ca4->m_startupDelay = parse>getActionProperties(i).m_startupDelay; ca4->m_nbExecutionsPerCycle = parse->getActionProperties(i).m_nbExecutionsPerCycle; ca4-> m_executionGroupSize = parse->getActionProperties(i). m_executionGroup S ize; 45 ca4->m_betweenGroupsDelay = parse->getActionProperties(i). m_betweenGroupsDelay; ca4->m_ActionType = parse- >getActionPropertie s(i). m_ActionType; stimu->addAction(ca4); break; case 5: ca5 = new DropSourceFoosAction(FooManagerV); ca5->m_info = parse-> getActionProperties(i).m_info; ca5->m_startupDelay = parse>getActionProperties(i).m_startupDelay; ca5->m_nbExecutionsPerCycle = parse->getActionProperties(i).m_nbExecutionsPerCycle; ca5->m_executionGroupSize = parse>getActionProperties(i).m_executionGroupSize; ca5->m_betweenGroupsDelay = parse- >getActionPropertie s(i). m_betweenGroup sDelay; ca5->m_ActionType = parse- >getActionProperties(i).m_ActionType; stimu->addAction(ca5); break; case 6: ca6 = new SetFooNameAction(FooManagerV); ca6->m_info = parse-> getActionProperties(i).m_info; ca6->m_startupDelay = parse-. >getActionPropertie s(i). m_startupDelay; ca6->m_nbExecutionsPerCycle = parse->getActionProperties(i).m_nbExecutionsPerCycle; ca6->m_executionGroupSize = parse>getActionProperties(i).m_executionGroupSize; ca6->m_betweenGroupsDelay = parse->getActionProperties(i).m_betweenGroupsDelay; ca6->m_ActionType = parse- >getActionProperties(i).m_ActionType; stimu->addAction(ca6); break; default: cout "Error in Type of actions!! !" endl; exit(0); break; // start the stimulator stimu->start(); // get out a result file if(parse->getResultOutputFile() !_ "") resultWriter->writeFileOut(parse->getResultOutputFileQ, stimu); delete stimu; delete resultWriter; delete parse; orb->shutdown(false); } // Stimulator thread class StimulatorThread: Cdmw::OsSupport::Thread public: StimulatorThread(string parseFile, Test::FooManager ptr FooManagerV, CORBA::ORB ptr orb) m_parseFile(parseFile), m_FooManagerV(Test::FooManager::_duplicate(FooManagerV)), m_orb(CORBA::ORB::_duplicate(orb)) { start(); }; StimulatorThread() throw() { }; inline void run() throw() { instance_stimulator(m_parseFile, m_FooManagerV, morb); }; inline void wait() { join(); }; private: string m _parseFile; Test::FooManager_var m_FooManagerV; CORBA::ORB_var m_orb; 30}; void network_interruptor() { string interruptor_filename = ".interruptor"; const int MAX = 100; char buf[MAX]; char interrupted[ 1]; cout "Interruptor initialized." endl; while (!M_stopped) { // open file and read Line ifstream ifileln(interrupto _filename.c_st()); if (!ifileln.goodQ) { cout "Exception \"FileError\" :" interruptor_filename.c_str() " not open..." endl; exit(0); } ifileln.getline(buf, MAX); if(ifileln. eofO) break; if(ifileln. fai1Q) { cout "Exception \"ReadError\" :" " cant read file " interruptor_filename.c_str() " endl; exit(0); } int rc = sscanf(buf, "%s", interrupted); if (rc > 0) { if (strcmp(interrupted," 1 ") = 0) Multicast::M_debug_failure percentage = 100; cout " > Interruptor off now!" endl; else Multicast::M_debug_failure_percentage = 0; } 35} ifileln.closeQ; // Wait int timescale = Comw::TestUtils::Testable::get_timescale(); Comw::OsSupport::OS:: sleep(timescale* 100); 15 45} // Interruptor thread to change the state of network class InterruptorThread: Comw::OsSupport::Thread { public: InterruptorThread() { start(); }; InterruptorThread() throw() { }; inline void run() throw() { network_interruptor(); } ; inline void wait() { joinO; }; private: int main(int argc, char* argv[], char* envp[]) { bool interruptor_mode = false; // Usage Method call. if(argc // filter to catch all multicast events Multicast::M_print_events = true; Multicast::M_print_no_fault_events = true; // create a multicast event listener MulticastEventListener* multicast_event_listener = new MulticastEventListener(); multicast eventlistener->init file(argv[3]); factory.initClientSide(orb.in()); factory. setlnetAddress(argv[2]); factory. setQueueSize((Multicast:: QueueSize)atoi(argv[4] )); factory.setTimeout((Multicast::Timeout) atoi(argv[5])); factory. setRetries((Multi cast:: Retries)atoi(argv [6] )) ; factory.setTTL((Multicast::TTL)atoi(argv[7])); // override the default report file on the multicast event listener factory. setFaultReportFile(*multicast event_listener); // current failure percentage to simulate the lost of requests // fix failure percentage to simulate the lost of requests if (! interruptor_mode) Multicast::M_debug_failure_percentage = (unsigned int) atoi(argv[8]); 20} else { Multicast::M_debug_failure_percentage = 0; cout "Interruptor mode activated." endl; cout "The current theorical failure percentage is " Multicast::M_debug_failure_percentage endl; FooManagerV = factory.create_object(); // instance_stimulator() Method set all derived Actions precised in properties file in the stimulator, // in our test case, we choose as if ACTION_TYPE Tag in propertie file equal to: // 1 we set a create With 3 Blocks in parameter, // 2 we set a drop With 1 Block in parameter, // 3 we set an update With 2 Blocks in parameter, // 4 we set an update With a sequence of MultiBlocks in parameter, // 5 we set an drop With a sequence of SourceBlocks in parameter. // Stimulator thread StimulatorThread* stimulator_thread = new StimulatorThread(string(argv[1]), FooManagerV.in(), orb.in()); InterruptorThread* interruptor_thread = NULL; if (interruptor_mode) 40 36 interruptor_thread = new InterruptorThreadQ; } 5 orb->runO; stimulator thread->wait(); 10 delete stimulator_thread; if (interruptor_mode) { M_stopped = true; interruptor_thread->wait(); delete interruptor_thread; } catch(CORBA::Exception &e) { cerr "Client Detection: Caught CORBA Exception " e endl; return 1; cout endl; cout "--- Successfully Bound to FooManager Server" endl; cout endl; return 0; } // End main ---------------- ANNEXE 9 // // File: server.cpp // #include "ValuetypeBlock_impl.hpp" #include "FooManager_ROTemporalMulticastServerFactoryHelper.hpp" #include "FooManagerBehavior_impl.hpp" #include "MulticastEventListener.hpp" #include #include 25 #include using namespace std; void usage(string exeName) cout "Usage: " exeName " [-trace] 1 [-notrace] [display frequency] [InetAdress] [id]" endl; cout " Option: [QueueSize] [ThreadPool] [Timeout] [QueueSizeList] [Retries] [TTL]" endl; int main(int argc, char* argv[], char* envp[]) cout endl; cout " starting Foo Manager server " endl; cout endl; Test::FooManager_var FooManagerV; FooManager_ROTemporalMulticastServerFactory factory; try{ // Initialize ORB CORBA::ORB var orb = CORBA::ORB imt(argc, argv); // Register all factories SourceBlockFactory* srcBlockFactory = new SourceBlockFactory(); orb->regi ster_value_factory("IDL: B lock/SourceB lock:1.0", 30 srcBlockFactory); IdentityCharactFactory* identCharactFactory = new IdentityCharactFactoryQ; orb-> register_value_factory("IDL: Block/IdentityCharact:1.0", 35 identCharactFactory); IdentityBlockFactory* identBlockFactory = new IdentityBlockFactory(); orb ->regi ster_value_factory(" ID L: Block/IdentityBlock:1.0", identBlockFactory); NonPonctualKinematicBlockFactory* npkinBlockFactory = new NonPonctualKinematicBlockFactory(); orb->register value_factory("IDL:Block/NonPonctualKinematicBlock:1.0", npkinBlockFactory); PonctualKinematicBlockFactory* pkinBlockFactory = new PonctualKinematicBlockFactory(); orb->register value_factory("IDL:Block/PonctualKinematicBlock:1.0", pkinBlockFactory); // Get reference to Root POA CORBA::Object_var obj = orb-> resolve_initial_references("RootPOA"); PortableServer::POAvar poa = PortableServer::POA::_narrow(obj.in()); // Test if to output trace or no if (! ((strcmp(argv[ 1], "-trace")==0 && argc≥4) Il (strcmp(argv[ 1], "-notrace")=0 && argc≥3))) { usage(argv[0]) ; orb->shutdown(true); return 1; // filter to catch all multicast events Multicast::M_print_events = true; Multicast::M_print_no_fault_events = true; // create a multicast event listener MulticastEventListener* multicast_event_listener = new MulticastEventListenerO; string file; // Create a servant FooManagerBehavior_impl* FooManager imp1= new 30 FooManagerBehavior impl(argc, argv); factory.initServerSide(orb.in(), poa. inO, FooManager_impl); if ((strcmp(argv[ 1], "-trace")==0 && argc ≥ 4)) { factory. setInetAddress(argv[3 D; file = argv[4]; // argv[2] is display frequency factory. setThreadPool Size((Multicast: :ThreadPoolSize)atoi(argv[5] ; factory. setNumberOfSenders((Multicast: :NumberOfSenders)atoi(argv [6] ; factory. setQueueSize((Multicast:: QueueSize)atoi(argv[7] )); factory.setTimeout((Multicast: :Timeout) atoi(argv[8])); factory. setRetries((Multicast:: Retries)atoi(argv [ 9] ; factory. setTTL((Multicast:: TTL)atoi (argv [ 10] ; } else { factory. s etInetAddress(argv [2] ); file = argv[3]; factory. setThreadPoolSize((Multicast::ThreadPoolSize)atoi(argv[4])); factory. setNumberOf Senders((Multicast::NumberOfSenders)atoi(argv[5] ; factory. setQueueSize((Multicast:: QueueSize)atoi(argv[6] )); factory. setTimeout((Multicast:: Timeout)atoi(argv[7])); factory. setRetries((Multicast:: Retries)atoi(argv[8])); factory. setTTL((Multicast::TTL)atoi(argv[9])); multicast_event_listener-> init_file(file. c_strO); // override the default report file on the multicast event listener factory.setFaultReportFile(*multicast_event listener); FooManagerV = factory.create_objectO; // Activate PAO manager PortableServer::POAManager_var poa_mgr = poa -> the_POAManagerO; poa_mgr -> activateO; // Accept requests orb->run(); catch (CORBA::Exception &e) { cerr "Server Detection: Caught CORBA Exception " e endl; return 1; cout endl; cout " server is terminating " endl; cout endl; return 0; ---------------- REVENDICATIONS 1. Procédé de fiabilisation de la multi-diffusion d'objets distribués, caractérisé en ce que l'on établit un fichier (1) décrivant l'interface entre les applications distribuées et indépendant du langage utilisé pour la gestion des objets, que l'on établit un fichier (2) décrivant les qualités de service attendues, que l'on génère une liste de méta-modèles (4,5) indépendants du langage de l'application, que l'on établit une bibliothèque d'algorithmes de fiabilisation (6), que l'on réalise un réceptacle dans lequel l'utilisateur décrit le comportement de l'application (8) , que l'on établit un fichier de paramétrage du service côté client (7) et un fichier de paramétrage du service côté serveur (8) et que l'on réalise par compilation (9) un programme exécutable pour gérer les clients et les serveurs (10, 11). 2. Procédé selon la revendication 1, caractérisé en ce que le langage utilisant la multi-diffusion d'objets est le langage CORBA. 3. Procédé selon la revendication 1, caractérisé en ce que le langage utilisant la multi-diffusion d'objets est le langage EJB. 4. Procédé selon la revendication 1, caractérisé en ce que le langage utilisant la multi-diffusion d'objets est le langage DOT.NET. 5. Librairie structurante permettant la fiabilisation de la multidiffusion d'objets distribués selon le procédé de l'une des revendications précédentes, associée à des applications distribuées (21, 23) communiquant entre elles par des vecteurs de transport de requêtes pour la distribution d'objets (20), caractérisé en ce qu'elle comporte, pour chaque application cliente, au sein de la couche de composants de communication (31), un code applicatif (32) utilisant le service applicatif client, un proxy client (13) et une bibliothèque de noyau multi-diffusion (12) contenus dans un réceptacle (22) distinct de l'application, et comportant pour chaque application serveur (23), un code serveur (34) fourni par l'utilisateur de l'application et correspondant au comportement du service applicatif serveur, ainsi qu'un squelette serveur (16) et une bibliothèque de noyau multidiffusion (15) contenus dans un réceptacle (24) distinct de l'application. 6. Librairie selon la revendication 5, caractérisée en ce que le proxy et le squelette contiennent la définition courante de la qualité de service demandée. 7. Librairie selon la revendication 5 ou 6, caractérisée en ce que le code serveur (34) correspond au comportement du service applicatif serveur.