1 \input texinfo @c -*-texinfo-*-
3 @setfilename Batch.info
4 @settitle Documentation de Batch
12 @dircategory Bibliotheque de classes Batch
14 * Batch: (Batch); Documentation de la bibliotheque de classes Batch.
23 @comment The title is printed in a large font.
24 @title Bibliotheque de classes Batch
25 @subtitle Documentation - version @value{VERSION}
26 @subtitle @value{UPDATED}
27 @author Ivan DUTKA-MALEN - EDF R&D
29 @c The following two commands start the copyright page.
31 @vskip 0pt plus 1filll
32 Copyright @copyright{} 2003-2004 EDF R&D sous licence GPL
38 @c ----------------------
39 @c ----------------------
40 @c ----------------------
42 @node Top, Description, Index , (dir)
43 @comment node-name, next, previous, up
45 Copyright @copyright{} 2003-2004 EDF R&D sous licence GPL
48 @unnumbered Introduction
50 Ceci est la documentation de la bibliotheque de classes Batch version
53 Ce manuel est normalement disponible sous la forme de fichiers
54 @file{.info}, PostScript @file{.ps}, PDF @file{.pdf} et HTML
55 @file{.html}. Merci a Texinfo.
59 * Description:: Le batch, c'est quoi ? Ca sert a quoi ?
60 * Classes:: Une description des classes internes.
61 * Utilisation:: Comment on s'en sert ? Quelques exemples.
62 * Installation de la bibliotheque:: Comment ca s'installe ?
63 * Divers:: D'autres petits details.
64 * Index:: Index generaux.
74 @c ----------------------
75 @c ----------------------
76 @c ----------------------
78 @node Description, Classes, Top, Top
79 @comment node-name, next, previous, up
80 @chapter Description Generale
83 Dans le domaine du batch, nombreux sont les gestionnaires qui sont
84 apparus et se sont popularises en fonction des plates-formes et des
85 constructeurs. On peut notamment citer NQS, le premier de tous, LSF,
86 LoadLeveler, PBS (et ses derives OpenPBS et PBS Pro), etc. qui se
87 prevalent tous d'une compatibilite avec NQS.
89 Si l'ensemble de ces produits offrent les fonctionnalites de base de
90 NQS, a savoir soumission, controle, destruction, modification, etc. de
91 travaux batch, ils se distinguent tous par leur incompatibilite mutuelle
92 et par les syntaxes de fichiers et les appels de fonction specifiques
93 qu'ils ont developpes.
95 Or il est interessant de pouvoir acceder d'une facon homogene et
96 generique aux fonctionnalites de ces gestionnaires quitte a se
97 restreindre a un sous-ensemble minimal mais essentiel de leurs
100 La bibliotheque de classes Batch fournit ce moyen de soumettre et
101 controler des travaux batch depuis une machine cliente sans s'occuper du
102 type de gestionnaire present sur le serveur sur lequel se deroule
103 l'execution du travail. Seul doit etre precise le nom du serveur sur
104 lequel sera soumis le travail batch et le type de gestionnaire qui s'y
105 trouve. Tout le reste est generique et ne depend plus de l'implementation.
113 @c ----------------------
114 @c ----------------------
115 @c ----------------------
117 @node Classes, Terminologie, Description, Top
118 @comment node-name, next, previous, up
119 @chapter Classes Internes
122 Les classes de la bibliotheque reposent sur des concepts issus du monde
123 de la gestion de batch, qui meritent d'etre reprecises pour ne pas
124 introduire d'ambiguite semantique dans le discours.
127 * Terminologie:: Description des termes employes.
128 * Classes generiques:: Les classes communes a tous les gestionnaires.
129 * Classes specifiques:: Les classes d'implementation.
135 @c ----------------------
136 @c ----------------------
137 @c ----------------------
139 @node Terminologie, Batch, Classes, Classes
140 @comment node-name, next, previous, up
141 @section Terminologie
144 Pour les non-inities aux mysteres de la gestion de batch, un petit
145 glossaire des termes employes dans cette documentation, assaisonne a la
146 sauce de la bibliotheque de classes Batch.
149 * Batch:: Gestion par lots, execution differee.
150 * BatchManager:: Gestionnaire de batch.
152 * Parametre:: Configuration de l'execution.
153 * Environnement:: Environnement d'execution.
154 * JobId:: Identifiant de travail.
155 * JobInfo:: Informations sur le travail.
159 @c ----------------------
160 @c ----------------------
161 @c ----------------------
163 @node Batch, BatchManager, Terminologie, Terminologie
164 @comment node-name, next, previous, up
168 Le traitement batch (batch processing en anglais), ou traitement par
169 lot, fait reference au mode de sequencage et d'utilisation des
170 ressources d'un calculateur tel qu'il a ete premierement employe dans
171 les debuts de l'ere informatique. Mais il faut preciser que cette
172 anteriorite ne condamne pas le traitement batch aux oubliettes au motif
173 d'une quelconque obsolescence. Si le traitement par lot a vu le jour et
174 existe encore aujourd'hui, c'est parce qu'il repond de maniere
175 satisfaisante a une certaine utilisation des ressources d'un
176 calculateur, et que cette utilisation est encore d'actualite. Present
177 depuis plus de quarante ans, le batch est encore largement utilise sur
178 les grands serveurs, et le sera vraisemblablement pour quelques annees
181 Le traitement par lot se distingue de l'execution interactive par le
182 fait que les travaux a effectuer sont places dans une file d'attente
183 avec une indication pour chaque lot des ressources dont il doit disposer
184 pour aboutir correctement. Une fois les travaux inscrits dans la file,
185 c'est au systeme de traitement batch (@xref{BatchManager}.) de veiller a
186 leur bonne execution en leur fournissant les ressources demandees. Tout
187 travail qui ne disposerait pas des ressources adequates ne peut pas etre
191 @c ----------------------
192 @c ----------------------
193 @c ----------------------
195 @node BatchManager, Job, Batch, Terminologie
196 @comment node-name, next, previous, up
197 @subsection Batch Manager
198 @cindex batch manager
201 Le role du gestionnaire de batch, ou batch manager en anglais, est
202 d'executer et eventuellement d'ordonner les travaux places en file
203 d'attente en leur allouant exclusivement les ressources necessaires a
204 leur execution. Son objectif est d'optimiser les ressources du systeme
205 dont il a la charge de maniere a ecouler le maximum de travaux en un
206 minimum de temps et un minimum de ressources materielles.
208 @c ----------------------
209 @c ----------------------
210 @c ----------------------
212 @node Job, Parametre, BatchManager, Terminologie
213 @comment node-name, next, previous, up
218 Le travail, ou job en anglais, est l'unite elementaire de traitement qui
219 peut etre soumis au gestionnaire de batch. Il peut s'agir d'une simple
220 commande systeme, comme d'une application ou bien meme de l'enchainement
221 complexe mais indivisible de plusieurs applications ou commandes.
223 Pour s'executer correctement, c'est-a-dire sans erreur, le job doit
224 disposer de certaines ressources --- de la memoire, du temps, de
225 l'espace disque @dots{} --- pendant toute la duree de son
226 execution. C'est au gestionnaire de batch (@xref{BatchManager}.) de
227 garantir au job la presence et la persistence de ces ressources pendant
230 Par contre c'est a l'utilisateur qui soumet le job d'informer le
231 gestionnaire de batch des ressources necessaires au job. Pour des
232 raisons evidentes de bonne gestion des ressources, le job ne peut
233 consommer plus de ressources que celles qu'il a demande et obtenu du
234 gestionnaire de batch sans etre arrete ou reclasse.
236 @c ----------------------
237 @c ----------------------
238 @c ----------------------
240 @node Parametre, Environnement, Job, Terminologie
241 @comment node-name, next, previous, up
242 @subsection Parametre
245 Le premier type de ressource necessaire a un job concerne les elements
246 materiels ou temporels, en un mot, physiques. Parmi ces ressources, on
247 trouve le temps de calcul, le temps de presence en machine, l'espace
248 disque, la quantite de memoire vive, l'architecture du calculateur, etc.
250 Dans la terminologie de la bibliotheque de classes Batch, tous ces
251 elements ont ete regroupes sous le terme de @emph{Parametre}.
253 @c ----------------------
254 @c ----------------------
255 @c ----------------------
257 @node Environnement, JobId, Parametre, Terminologie
258 @comment node-name, next, previous, up
259 @subsection Environnement
260 @cindex environnement
262 Le second type de ressource necessaire a un job concerne les elements
263 logiciels. Cela se traduit le plus souvent, et particulierement, dans
264 les systemes Unix par la notion de variable d'environnement. Lorsque le
265 job s'execute, il doit pouvoir trouver l'ensemble des commandes et des
266 applications auquel il souhaite faire appel. Les variables
267 d'environnement decrivent donc les localisations des ces
268 programmes. Elles peuvent egalement contenir des informations influant
269 sur le comportement des programmes.
271 Dans la terminologie de la bibliotheque de classes Batch, tous ces
272 elements on ete regroupes sous le terme de @emph{Environnement}.
274 @c ----------------------
275 @c ----------------------
276 @c ----------------------
278 @node JobId, JobInfo, Environnement, Terminologie
279 @comment node-name, next, previous, up
284 Si un job (@xref{Job}.) decrit les actions qui doivent etre effectues
285 par le systeme sous le controle du gestionnaire de batch, il est clair
286 qu'il est possible de soumettre plusieurs fois de suite le meme job, et
287 par la-meme d'executer plusieurs fois (et parfois simultanement) ces
288 memes actions. On a donc plusieurs instances du meme job qui sont
289 presentes en machine. Chaque instance peut etre distinguee des autres
290 par un identifiant unique qui lui est propre : c'est le @emph{jobId}.
292 Le JobId est determine par le gestionnaire de batch au moment de la
295 @c ----------------------
296 @c ----------------------
297 @c ----------------------
299 @node JobInfo, Classes generiques, JobId, Terminologie
300 @comment node-name, next, previous, up
305 Des qu'un job (@xref{Job}.) est soumis donc des qu'il dispose d'un
306 JobId (@xref{JobId}.), il est possible d'interroger le gestionnaire de
307 batch pour etre informe de son comportement, de son evolution au sein du
308 systeme pendant son execution.
310 On peut ainsi connaitre les parametres reellement consommes par rapport
311 aux parametres alloues, ainsi que l'environnement d'execution du job.
313 Le JobInfo est une structure qui collecte ses informations sur l'etat du
320 @c ----------------------
321 @c ----------------------
322 @c ----------------------
324 @node Classes generiques, Namespace, JobInfo, Classes
325 @comment node-name, next, previous, up
326 @section Classes generiques
327 @cindex classes generiques
329 Schematiquement, les classes composant la bibliotheque sont regroupees
330 en trois categories. Celles appartenant au groupe @emph{Types de base}
331 ne servent que de support au fonctionnement des classes de plus haut
332 niveau, egalement appellees @emph{Classes utilisateur}. Seules ces
333 dernieres sont vraiment interessantes pour l'utilisateur de la
334 bibliotheque. Les exceptions sont regroupees dans une categorie qui leur
338 * Namespace:: Espace de noms pour la bibliotheque.
339 * Types de base:: Les classes elementaires.
340 * Classes utilisateur:: Les classes de haut-niveau.
341 * Exceptions:: Les exceptions de la bibliotheque.
344 @c ----------------------
345 @c ----------------------
346 @c ----------------------
348 @node Namespace, Types de base, Classes generiques, Classes generiques
349 @comment node-name, next, previous, up
350 @subsection Namespace
353 Toutes les classes de la bibliotheque sont regroupees dans un unique
354 namespace nomme @emph{Batch} afin de ne pas introduire de conflit avec
355 d'autres classes de meme nom.
357 Ainsi lorsque par exemple on cite la classe @emph{BatchManager}, il
358 faudra declarer un objet @emph{Batch::BatchManager} ou bien faire appel
359 au namespace @emph{Batch} en C++. En Python, les objets sont regroupes
360 dans un module nomme @emph{libBatch_Swig}.
363 @c ----------------------
364 @c ----------------------
365 @c ----------------------
367 @node Types de base, Classe Couple, Namespace, Classes generiques
368 @comment node-name, next, previous, up
369 @subsection Types de base
370 @cindex types de base
372 Les classes decrites ici sont toutes utilisees ou utilisables par les
373 classes utilisateur de la bibliotheque, et en particulier par la classe
374 Versatile. @xref{Classe Versatile}.
376 Ces classes implementent sous forme d'objet les types de base du langage
377 C++. Ainsi la classe @emph{Booltype} implemente le type de base
378 @emph{bool}. Certains types de base n'existant pas dans le langage ont
379 ete crees et encapsules dans une classe : c'est le cas notamment du type
380 de base @emph{Date} et de la classe @emph{DateType}, et du type de base
381 @emph{Couple} et de la classe @emph{CoupleType}.
383 Tous les classes heritent de la classe generique @emph{GenericType}.
388 * Classe Couple:: Association de fichiers.
389 * Classe Date:: Type elementaire de date.
391 -- Classes d'implementation des types de base --
393 * Classe GenericType:: Classe-mere de tous les types.
394 * Classe BoolType:: Encapsulation du type bool.
395 * Classe CharType:: Encapsulation du type char.
396 * Classe CoupleType:: Encapsulation du type Couple.
397 * Classe DateType:: Encapsulation du type Date.
398 * Classe IntType:: Encapsulation du type int.
399 * Classe LongType:: Encapsulation du type long.
400 * Classe StringType:: Encapsulation du type string.
404 @c ----------------------
405 @c ----------------------
406 @c ----------------------
408 @node Classe Couple, Classe Date, Types de base, Types de base
409 @comment node-name, next, previous, up
411 @subsubsection Couple
414 La classe @emph{Couple} implemente le comportement d'un couple de deux
415 chaines de type @emph{string} qui sont respectivement nommees
416 @emph{local} et @emph{remote}.
418 Cette classe est utilisee essentiellement pour la designation des
419 fichiers a transferer lors des soumissions de travaux, d'ou les noms
423 Il faut toutefois faire attention a designer correctement ce qui est
424 local ou distant. Ainsi dans la bibliotheque de classes Batch, on a
425 adopte la convention qu'un fichier dit @emph{local} est celui present
426 sur la machine qui execute la bibliotheque de classes Batch, alors qu'un
427 fichier dit @emph{remote} (ou distant) est celui present sur le serveur
428 du gestionnaire de batch.
429 L'approche est donc clairement orientee utilisateur plutot que serveur.
439 // Constructeur standard
440 Couple(const string & local, const string & remote);
442 // Constructeur par recopie
443 Couple(const Couple & C);
445 // Operateur pour l'affichage sur un stream
446 friend ostream & operator << (ostream & os, const Couple & cp);
448 // Operateur d'affectation
449 virtual Couple & operator =(const Couple &);
451 // Conversion en chaine
452 virtual string str() const;
455 virtual string getLocal() const;
456 virtual string getRemote() const;
459 string _local; // chemin d'acces au fichier local
460 string _remote; // chemin d'acees au fichier distant
469 @c ----------------------
470 @c ----------------------
471 @c ----------------------
473 @node Classe Date, Classe GenericType, Classe Couple, Types de base
474 @comment node-name, next, previous, up
479 La classe @emph{Date} sert a stocker n'importe quelle information de
480 temps et peut la representer sous une forme plus lisible a l'utilisateur
481 que le traditionnel appel a la fonction @emph{ctime}. @xref{(*manpages*)ctime}.
490 // Constructeur standard (a partir d'une valeur epoch)
491 Date(const long l=0);
493 // Constructeur a partir d'une chaine hh:mm:ss
494 Date(const string s);
496 // Operateurs portant sur les Dates
497 virtual Date & operator =(long l);
498 virtual Date & operator +(long l);
499 virtual Date & operator -(long l);
500 virtual Date & operator +=(long l);
501 virtual Date & operator -=(long l);
502 virtual Date & operator =(const string & s);
504 // Conversions en types standards
505 virtual string str() const;
506 virtual long epoch() const;
509 int _day, _month, _year;
510 int _hour, _min, _sec;
520 @c ----------------------
521 @c ----------------------
522 @c ----------------------
524 @node Classe GenericType, Classe BoolType, Classe Date, Types de base
525 @comment node-name, next, previous, up
527 @subsubsection GenericType
530 La classe @emph{GenericType} est la classe-mere de toutes les classes
531 utilisees par la classe @emph{Versatile}. @xref{Classe Versatile}.
533 Elle definit une interface que @emph{Versatile} utilise pour controler
534 les objets : constructeur simple et destructeur, operateur sur
535 @emph{ostream}, conversion en chaine et surtout methode @emph{clone}.
537 La methode @emph{clone} permet de recuperer un nouvel objet identique au
538 premier qui sera automatiquement alloue sur le tas par un appel a
539 @emph{new}. Il est important de noter ici que le nouvel objet @strong{DEVRA}
540 etre desalloue par un appel a @emph{delete}. Cette desallocation est a
541 la charge de l'utilisateur de l'objet sans quoi une fuite memoire en
551 // Constructeur et destructeur
553 virtual ~GenericType();
555 // Operateur pour l'affichage sur un stream
556 friend ostream & operator << (ostream & os,
557 const GenericType & obj);
559 // Conversion en chaine
560 virtual string affiche() const;
562 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
563 // qu'il faudra detruire ensuite manuellement
564 virtual GenericType * clone() const;
566 // Retourne le nombre d'objets GenericType et al.
572 static int _nb; // nombre total d'objets GenericType et al.
579 @c ----------------------
580 @c ----------------------
581 @c ----------------------
583 @node Classe BoolType, Classe CharType, Classe GenericType, Types de base
584 @comment node-name, next, previous, up
586 @subsubsection BoolType
589 Cette classe encapsule le type C++ @emph{bool} dans un objet herite de
590 @emph{GenericType} de maniere a pouvoir le stocker aisement dans un
591 objet de classe @emph{Versatile}.
597 class BoolType : public GenericType
601 BoolType(const bool b=false);
603 // Conversion en chaine
604 virtual string affiche() const;
606 // Operateur d'affectation
607 virtual BoolType & operator =(bool);
609 // Conversion en bool
610 virtual operator bool() const;
612 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
613 // qu'il faudra detruire ensuite manuellement
614 virtual GenericType * clone() const;
626 @c ----------------------
627 @c ----------------------
628 @c ----------------------
630 @node Classe CharType, Classe CoupleType, Classe BoolType, Types de base
631 @comment node-name, next, previous, up
633 @subsubsection CharType
636 Cette classe encapsule le type C++ @emph{char} dans un objet herite de
637 @emph{GenericType} de maniere a pouvoir le stocker aisement dans un
638 objet de classe @emph{Versatile}.
645 class CharType : public GenericType
649 CharType(const char c=0);
651 // Conversion en chaine
652 virtual string affiche() const;
654 // Operateur d'affectation
655 virtual CharType & operator =(char);
657 // Conversion en char
658 virtual operator char() const;
660 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
661 // qu'il faudra detruire ensuite manuellement
662 virtual GenericType * clone() const;
674 @c ----------------------
675 @c ----------------------
676 @c ----------------------
678 @node Classe CoupleType, Classe DateType, Classe CharType, Types de base
679 @comment node-name, next, previous, up
681 @subsubsection CoupleType
684 Cette classe encapsule le type interne @emph{Couple} dans un objet herite de
685 @emph{GenericType} de maniere a pouvoir le stocker aisement dans un
686 objet de classe @emph{Versatile}.
693 class CoupleType : public GenericType
697 CoupleType(const Couple & C);
699 // Conversion en chaine
700 virtual string affiche() const;
701 virtual operator string() const;
703 // Operateur d'affectation
704 virtual CoupleType & operator =(const Couple & C);
706 // Conversion en char
707 virtual operator Couple() const;
709 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
710 // qu'il faudra detruire ensuite manuellement
711 virtual GenericType * clone() const;
723 @c ----------------------
724 @c ----------------------
725 @c ----------------------
727 @node Classe DateType, Classe IntType, Classe CoupleType, Types de base
728 @comment node-name, next, previous, up
730 @subsubsection DateType
733 Cette classe encapsule le type interne @emph{Date} dans un objet herite de
734 @emph{GenericType} de maniere a pouvoir le stocker aisement dans un
735 objet de classe @emph{Versatile}.
742 class DateType : public GenericType
746 DateType(const Date & d);
748 // Conversion en chaine
749 virtual string affiche() const;
751 // Operateur d'affectation
752 virtual DateType & operator =(const Date &);
754 // Conversion en Date
755 virtual operator Date() const;
757 // Conversion en long
758 virtual operator long() const;
760 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
761 // qu'il faudra detruire ensuite manuellement
762 virtual GenericType * clone() const;
773 @c ----------------------
774 @c ----------------------
775 @c ----------------------
777 @node Classe IntType, Classe LongType, Classe DateType, Types de base
778 @comment node-name, next, previous, up
780 @subsubsection IntType
783 Cette classe encapsule le type C++ @emph{int} dans un objet herite de
784 @emph{GenericType} de maniere a pouvoir le stocker aisement dans un
785 objet de classe @emph{Versatile}.
792 class IntType : public GenericType
796 IntType(const int i=0);
798 // Conversion en chaine
799 virtual string affiche() const;
801 // Operateur d'affectation
802 virtual IntType & operator =(int);
805 virtual operator int() const;
807 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
808 // qu'il faudra detruire ensuite manuellement
809 virtual GenericType * clone() const;
821 @c ----------------------
822 @c ----------------------
823 @c ----------------------
825 @node Classe LongType, Classe StringType, Classe IntType, Types de base
826 @comment node-name, next, previous, up
828 @subsubsection LongType
831 Cette classe encapsule le type C++ @emph{long} dans un objet herite de
832 @emph{GenericType} de maniere a pouvoir le stocker aisement dans un
833 objet de classe @emph{Versatile}.
839 class LongType : public GenericType
843 LongType(const long l=0L);
845 // Conversion en chaine
846 virtual string affiche() const;
848 // Operateur d'affectation
849 virtual LongType & operator =(long);
851 // Conversion en long
852 virtual operator long() const;
854 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
855 // qu'il faudra detruire ensuite manuellement
856 virtual GenericType * clone() const;
868 @c ----------------------
869 @c ----------------------
870 @c ----------------------
872 @node Classe StringType, Classes utilisateur, Classe LongType, Types de base
873 @comment node-name, next, previous, up
875 @subsubsection StringType
878 Cette classe encapsule le type C++ @emph{string} de la STL dans un objet
879 herite de @emph{GenericType} de maniere a pouvoir le stocker aisement
880 dans un objet de classe @emph{Versatile}.
886 class StringType : public GenericType
890 StringType(const string & s="");
892 // Conversion en chaine
893 virtual string affiche() const;
894 virtual operator string() const;
896 // Operateur d'affectation
897 virtual StringType & operator =(string);
899 // Clone duplique l'objet et en fabrique un nouveau a l'aide de new
900 // qu'il faudra detruire ensuite manuellement
901 virtual GenericType * clone() const;
915 @c ----------------------
916 @c ----------------------
917 @c ----------------------
919 @node Classes utilisateur, Exemple, Classe StringType, Classes generiques
920 @comment node-name, next, previous, up
922 @subsection Classes utilisateur
923 @cindex classes utilisateur
925 Les classes dites classes utilisateur sont en realite les classes de
926 plus haut niveau de la biliotheque de classes Batch. Ces classes
927 remplissent les unes avec les autres l'ensemble des fonctionnalites
928 proposees par la bibliotheque. L'utilisateur trouvera donc dans cette
929 section la description des possibilites de la bibliotheque et le moyen
930 de les mettre en oeuvre.
932 La premiere section montre un exemple complet de soumission et de
933 controle d'un job soumis a travers les classes de la biliotheque. Les
934 sections suivantes reprennent les elements de l'exemple pour le
935 detailler et le completer.
938 * Exemple:: Exemple simple mais complet d'utilisation.
939 * Classe BatchManagerCatalog:: Description de la classe BatchManagerCatalog.
940 * Classe FactBatchManager:: Description de la classe FactBatchManager.
941 * Classe BatchManager:: Description de la classe BatchManager.
942 * Classe Environnement:: Description de la classe Environnement.
943 * Classe Job:: Description de la classe Job.
944 * Classe JobId:: Description de la classe JobId.
945 * Classe JobInfo:: Description de la classe JobInfo.
946 * Classe Parametre:: Description de la classe Parametre.
947 * Classe Versatile:: Description de la classe Versatile.
951 @c ----------------------
952 @c ----------------------
953 @c ----------------------
955 @node Exemple, Classe BatchManagerCatalog, Classes utilisateur, Classes utilisateur
956 @comment node-name, next, previous, up
958 @subsubsection Exemple
961 Cet exemple decrit le processus type de creation et de soumission d'un
962 job a travers les classes de la bibliotheque.
964 Il faut toutefois penser que les appels aux methodes peuvent lever des
965 exceptions qu'il faudra intercepter et gerer. @xref{Exceptions}.
970 // On instancie le catalogue de gestionnaires de batch
971 Batch::BatchManagerCatalog cata;
973 // On cree un BatchManager qui se connecte au veritable gestionnaire
975 Batch::BatchManager & bm = (* cata("PBS"))("monserver.mondomaine.fr");
977 // Pour fabriquer un Job, on doit d'abord creer un objet Parametre et
978 // un objet Environnement qui contiennent respectivement la liste des
979 // parametres du job au sein du gestionnaire de batch et la liste des
980 // variables d'environnement necessaires au fonctionnement du job
981 Batch::Parametre param;
983 param[EXECUTABLE] = "/home/user/mon_application/executable";
984 param[NAME] = "MonJob";
985 param[ACCOUNT] = "MonProjet"; // code d'imputation/facturation
986 param[MAXCPUTIME] = 360L; // 6min
987 param[MAXWALLTIME] = 480L; // 8min
988 param[INFILE] = Batch::Couple("/tmp/infich1", rempath+"/infich1");
989 param[OUTFILE] = Batch::Couple("/tmp/outfich1", rempath+"/outfich1");
990 param[OUTFILE] += Batch::Couple("stderr", path + "/STDERR");
991 param[OUTFILE] += Batch::Couple("stdout", path + "/STDOUT");
992 param[MAIL] = "user@@domaine.fr";
993 param[USER] = "user";
995 Batch::Environnement env;
996 env["DEBUG"] = "3"; // un niveau de debug exige par l'application
997 env["MYAPP_FILE"] = "/home/user/mon_application/data/mydatafile";
1000 Batch::Job job(param, env);
1002 // On soumet le Job au BatchManager qui le relaie jusqu'au veritable
1003 // gestionnaire de batch sur le serveur. En retour on obtient un
1004 // identifiant unique de notre job (JobId).
1005 const Batch::JobId jobid = bm.submitJob(job);
1007 // On interroge le BatchManager pour connaitre l'etat du Job
1008 const Batch::JobInfo jinfo = jobid.queryJob();
1009 cout << jinfo << endl;
1011 // On detruit l'objet BatchManager
1018 @c ----------------------
1019 @c ----------------------
1020 @c ----------------------
1022 @node Classe BatchManagerCatalog, Classe FactBatchManager, Exemple, Classes utilisateur
1023 @comment node-name, next, previous, up
1025 @subsubsection BatchManagerCatalog
1026 @findex BatchManagerCatalog
1028 La classe @emph{BatchManagerCatalog} definit une interface d'acces au
1029 catalogue de fabriques de BatchManager. @xref{Classe FactBatchManager}.
1031 Pourquoi utiliser une fabrique et ne pas instancier directement un objet
1032 @emph{BatchManager} en fonction de sa classe ? C'est l'option qui avait ete
1033 choisie dans la premiere version de la bibliotheque de classes
1034 Batch. Cette facon de proceder est simple, aussi bien pour le
1035 developpeur de la classe que pour l'utilisateur, mais elle se revele a
1036 terme penalisante dans la souplesse d'utilisation des classes. Elle
1037 permet aussi moins facilement de mettre en place une strategie de
1038 singleton pour les objets @emph{BatchManager}, ce qui peut se reveler utile non
1039 pas en termes de performance mais plutot en termes de genericite et
1040 toujours de souplesse.
1042 En resume, l'utilisation de fabiques permet d'acceder a la genericite,
1043 qui rappelons-le est l'objet de cette biliotheque, a la souplesse et a
1044 la performance au prix d'une legere complication pour le developpeur
1045 mais pas pour l'utilisateur.
1047 Le catalogue de fabriques est une @emph{map}, ou tableau associatif,
1048 auquel on passe le nom d'une fabrique et qui retourne un pointeur sur
1049 une instance de cette fabrique.
1051 Le catalogue est renseigne statiquement par les fabriques declarees
1052 elles-memes statiquement dans la biliotheque. Il est donc precharge avec
1053 les fabriques correspondant a chacune des API disponibles. Comme le
1054 catalogue n'est pas declare constant, il est possible de rajouter ou de
1055 supprimer des fabriques dans le catalogue dynamiquement.
1061 class BatchManagerCatalog
1065 BatchManagerCatalog();
1067 virtual ~BatchManagerCatalog();
1070 static FactBatchManager * getFactBatchManager(const char * type);
1071 static void addFactBatchManager(const char * type,
1072 FactBatchManager * pFBM);
1073 virtual FactBatchManager * operator() (const char * type) const;
1076 virtual map<string, FactBatchManager *> * dict() const;
1077 virtual string __repr__() const;
1080 // Le catalogue est gere en singleton et en multi-thread
1081 static map<string, FactBatchManager *> * _p_catalog;
1082 static pthread_mutex_t _mutex;
1094 // On instancie le catalogue de gestionnaires de batch
1095 Batch::BatchManagerCatalog cata;
1103 @b{BatchManagerCatalog()}
1105 Le constructeur par defaut permet d'obtenir une instance de
1106 @emph{BatchManagerCatalog} qui permet de manipuler un objet statique
1107 interne. Cet objet interne est le veritable catalogue et se trouve etre
1112 @b{~BatchManagerCatalog()}
1114 Le destructeur n'a pas d'action particuliere.
1117 @b{static FactBatchManager * getFactBatchManager(const char * type)}
1119 Cet accesseur retourne un pointeur sur un objet de type
1120 @emph{FactBatchManager} en fonction du nom (le type) sous lequel il
1121 s'est enregistre dans le catalogue.
1123 Cette fonction est statique et peut donc etre utilisee pour interroger
1124 le catalogue depuis des objets statiques.
1127 @b{static void addFactBatchManager(const char * type, FactBatchManager * pFBM)}
1129 Cet accesseur enregistre dans le catalogue un pointeur sur un objet de type
1130 @emph{FactBatchManager} sous le nom (le type) passe en argument.
1132 Cette fonction est statique et peut donc etre utilisee pour enregistrer
1133 des objets statiques dans le catalogue.
1136 @b{FactBatchManager * operator() (const char * type) const}
1138 Cet accesseur retourne un pointeur sur un objet de type
1139 @emph{FactBatchManager} en fonction du nom (le type) sous lequel il
1140 s'est enregistre dans le catalogue.
1142 Cette fonction non statique est utilisable sur une instance de
1143 @emph{BatchManagerCatalog}.
1146 @b{map<string, FactBatchManager *> * dict() const}
1148 Cette methode utilisable depuis Python permet de recuperer un
1149 dictionnaire decrivant le contenu du catalogue.
1152 @b{string __repr__() const}
1154 Cette methode utilisable depuis Python retourne une description de
1155 l'objet @emph{BatchManagerCatalog}.
1163 @c ----------------------
1164 @c ----------------------
1165 @c ----------------------
1167 @node Classe FactBatchManager, Classe BatchManager, Classe BatchManagerCatalog, Classes utilisateur
1168 @comment node-name, next, previous, up
1170 @subsubsection FactBatchManager
1171 @findex FactBatchManager
1173 La classe @emph{FactBatchManager} est abstraite. Elle definit une interface
1174 qui doit etre implementee par des classes specialisees en fonction du
1175 gestionnaire de batch et de son API de communication. @xref{Classes specifiques}.
1177 Les objets repondant a l'interface de @emph{FactBatchManager} sont
1178 automatiquement inseres dans le catalogue des fabriques de
1179 @emph{BatchManager} a la construction de l'objet. Il est ainsi possible
1180 de definir statiquement des objets de ce type qui enrichiront le
1181 catalogue des la compilation. @xref{Classe
1182 BatchManagerCatalog}. @xref{Classe BatchManager}.
1184 Les objets de la classe @emph{FactBatchManager} ou de ses derivees sont
1185 des functors et renvoient au moment de l'appel un pointeur sur un objet
1186 gestionnaire de batch @emph{BatchManager} associe a un
1187 serveur. L'allocation de l'objet est faite sur le tas et celui-ci doit
1188 donc etre desalloue manuellement par l'utilisateur de la bibliotheque au
1195 class FactBatchManager
1199 FactBatchManager(const string & type);
1202 virtual ~FactBatchManager();
1205 virtual BatchManager * operator() (const char * hostname) const = 0;
1207 // Accesseur au type interne
1208 string getType() const;
1211 string __repr__() const;
1214 string type; // Le type interne
1226 // On instancie le catalogue de gestionnaires de batch
1227 Batch::BatchManagerCatalog cata;
1229 // On cree une fabrique de BatchManager de type PBS
1230 Batch::FactBatchManager & fbm = * cata("PBS");
1239 @b{FactBatchManager(const string & type)}
1241 Le constructeur de la classe prend un type qui doit identifer de maniere
1242 unique la fabrique au sein du catalogue de fabrique. Ce type sert de cle au
1243 catalogue. @xref{Classe BatchManagerCatalog}.
1246 @b{~FactBatchManager()}
1248 Le destructeur de la classe n'a pas d'action particuliere.
1251 @b{BatchManager * operator() (const char * hostname) const}
1253 Cette methode est virtuelle pure. Elle doit etre surchargee dans les
1254 classes derivees et doit retourner un pointeur sur un objet de type
1255 @emph{BatchManager} correpondant au type de la classe et oeuvrant sur la
1256 machine passee en argument. Le @emph{hostname} est soit alphabetique
1257 soit numerique et doit etre soit un nom de machine valide soit une
1258 adresse IP valide. Aucun controle n'est a priori realise et cet argument
1259 est passe tel quel a l'API du gestionnaire de batch.
1261 Cet objet agit comme @emph{parent} vis-a-vis de l'objet
1262 @emph{BatchManager} qu'il retourne.
1265 @b{string getType() const}
1267 Cette methode renvoie le type interne de l'objet, c'est-a-dire la cle
1268 sous lequel il est enregistre dans le catalogue.
1271 @b{string __repr__() const}
1273 Cette methode utilisable depuis Python retourne une description de
1274 l'objet @emph{FactBatchManager}.
1282 @c ----------------------
1283 @c ----------------------
1284 @c ----------------------
1286 @node Classe BatchManager, Classe Environnement, Classe FactBatchManager, Classes utilisateur
1287 @comment node-name, next, previous, up
1289 @subsubsection BatchManager
1290 @findex BatchManager
1292 La classe @emph{BatchManager} est abstraite. Elle definit une interface
1293 qui doit etre implementee par des classes specialisees en fonction du
1294 gestionnaire de batch et de son API de communication. @xref{Classes
1297 Toute action a destination du gestionnaire de batch doit etre precedee
1298 de l'instanciation d'un objet derivant de la classe @emph{BatchManager}
1299 puisque c'est a travers cet objet que l'on aura acces a l'interface du
1302 Cette instanciation est realisee par une fabrique de gestionnaire de
1303 batch, instance elle-meme derivee de la classe abstraite
1304 FactBatchManager. @xref{Classe FactBatchManager}.
1313 // Constructeur et destructeur
1314 BatchManager(const FactBatchManager * parent,
1315 const char * host="localhost")
1316 throw(InvalidArgumentException);
1317 virtual ~BatchManager();
1319 // Recupere l'identifiant d'un job deja soumis au BatchManager
1320 virtual const JobId getJobIdByReference(const string & ref);
1322 // Methodes pour le controle des jobs : virtuelles pures
1323 // soumet un job au gestionnaire
1324 virtual const JobId submitJob(const Job & job) = 0;
1326 // retire un job du gestionnaire
1327 virtual void deleteJob(const JobId & jobid) = 0;
1329 // suspend un job en file d'attente
1330 virtual void holdJob(const JobId & jobid) = 0;
1332 // relache un job suspendu
1333 virtual void releaseJob(const JobId & jobid) = 0;
1335 // modifie un job en file d'attente
1336 virtual void alterJob(const JobId & jobid,
1337 const Parametre & param,
1338 const Environnement & env) = 0;
1339 virtual void alterJob(const JobId & jobid,
1340 const Parametre & param) = 0;
1341 virtual void alterJob(const JobId & jobid,
1342 const Environnement & env) = 0;
1344 // renvoie l'etat du job
1345 virtual JobInfo queryJob(const JobId & jobid) = 0;
1348 virtual string __repr__() const;
1351 string _hostname; // serveur ou tourne le BatchManager
1352 const FactBatchManager * _parent; // fabrique qui a produit l'instance
1364 // On instancie le catalogue de gestionnaires de batch
1365 Batch::BatchManagerCatalog cata;
1367 // On cree un BatchManager qui se connecte au veritable gestionnaire
1369 Batch::BatchManager & bm = (* cata("PBS"))("monserver.mondomaine.fr");
1371 // Maintenant, on peut utiliser toutes les fonctionnalites du
1372 // gestionnaire de batch a travers le variable myBM
1374 // On detruit l'objet BatchManager
1383 @b{BatchManager(const FactBatchManager * parent,$*
1384 const char * host="localhost") throw(InvalidArgumentException)}
1386 Excepte un pointeur sur la fabrique qui a produit l'objet, @xref{Classe FactBatchManager},
1387 le constructeur accepte zero ou un argument de type
1388 @emph{string} decrivant soit le nom de domaine completement qualifie
1389 (FQDN, @i{fully qualified domain name}) du serveur de batch, soit son
1390 adresse IP dans un format decimal "aaa.bbb.ccc.ddd".
1392 Une resolution du nom ou de l'adresse peut etre realisee en fonction des
1393 capacites de la plate-forme pour s'assurer que le serveur est connu et
1394 joignable. En cas d'echec, une exception InvalidArgumentException est
1395 levee. @xref{Classe InvalidArgumentException}. A priori, aucune
1396 verification n'est faite par defaut.
1398 Ceci fait, une connexion est etablie avec le gestionnaire de batch qui
1399 est maintenue jusqu'a destruction de l'objet, si le gestionnaire le permet.
1404 Le destructeur supprime la connexion precedemment etablie par le
1405 constructeur lorsque celle-ci a reussi.
1408 @b{const JobId submitJob(const Job & job)}
1410 Cette methode soumet le job passe en argument au gestionnaire de
1411 batch. Etant donne que le job ne peut pas etre envoye tel quel puisqu'il
1412 a un format generique au sein de la bibliotheque de classes Batch, cette
1413 methode est chargee de le convertir dans un format adapte au
1414 gestionnaire de batch sous-jacent.
1416 Ce n'est que lorsque cette conversion est realisee que le job est soumis
1417 au gestionnaire a travers son API. L'identifiant propose par le
1418 gestionnaire est alors renvoye a l'appelant. Si la soumission echoue
1419 pour une raison ou une autre, une exception APIInternalFailureException est
1420 levee. @xref{Classe APIInternalFailureException}.
1423 @b{void deleteJob(const JobId & jobid)}
1425 Cette methode retire le job dont l'identifiant est passe en argument de
1426 la file d'attente du gestionnaire, ou bien l'arrete s'il est en cours
1427 d'execution. Cette methode est inoperante sur des travaux deja termines,
1428 auquel cas une exception APIInternalFailureException est
1429 levee. @xref{Classe APIInternalFailureException}.
1433 @b{void holdJob(const JobId & jobid)}
1435 Cette methode suspend le job dont l'identifiant est passe en argument au
1436 sein de la file d'attente du gestionnaire. Cette methode est inoperante
1437 sur des travaux en cours d'execution ou deja termines, ainsi que sur des
1438 travaux deja suspendus.
1439 En cas de probleme, une exception APIInternalFailureException est
1440 levee. @xref{Classe APIInternalFailureException}.
1443 @b{void releaseJob(const JobId & jobid)}
1445 Cette methode relache un job precedemment suspendu en file
1446 d'attente dont l'identifiant est passe en argument. Elle est inoperante
1447 sur des travaux deja relaches, en cours d'execution ou termines.
1448 En cas de probleme, une exception APIInternalFailureException est
1449 levee. @xref{Classe APIInternalFailureException}.
1453 @b{void alterJob(const JobId & jobid, const Parametre & param, const Environnement & env)@*
1454 void alterJob(const JobId & jobid, const Parametre & param)@*
1455 void alterJob(const JobId & jobid, const Environnement & env)}
1457 Ces methodes permettent de modifier les parametres d'execution et
1458 d'environnement d'un job dont l'identifiant est passe en
1459 argument. @xref{Classe Parametre}. @xref{Classe Environnement}. Il
1460 est important de noter que le job doit etre encore place en file
1461 d'attente sinon la methode est inoperante.
1462 En cas de probleme, une exception APIInternalFailureException est
1463 levee. @xref{Classe APIInternalFailureException}.
1466 @b{JobInfo queryJob(const JobId & jobid)}
1468 Cette methode permet de recuperer les informations concernant le job
1469 dont l'identifiant est passe en argument dans un objet de classe
1470 @emph{JobInfo}. @xref{Classe JobInfo}. On y retrouve les parametres
1471 d'execution et d'environnement du job tels qu'ils ont ete passes au
1472 gestionnaire au moment de la soumission, ainsi que des informations
1473 concernant l'execution du job comme par exemple la machine d'execution,
1474 le temps consomme, la memoire consommee, etc.
1476 Il n'est pas toujours possible d'interroger un job deja termine.
1477 En cas de probleme, une exception APIInternalFailureException est
1478 levee. @xref{Classe APIInternalFailureException}.
1482 @b{const JobId getJobIdByReference(const string & ref)}
1484 Cette methode permet de recuperer au sein de la classe un identifiant de
1485 job a partir d'une chaine de caracteres obtenue par un biais
1486 externe. Cet identifiant pourra etre utilise par la suite au sein de la
1487 biliotheque de classes pour controler le job comme s'il avait ete cree
1488 et soumis depuis la biliotheque-meme.
1496 @c ----------------------
1497 @c ----------------------
1498 @c ----------------------
1500 @node Classe Environnement, Classe Job, Classe BatchManager, Classes utilisateur
1501 @comment node-name, next, previous, up
1503 @subsubsection Environnement
1504 @findex Environnement
1506 La classe @emph{Environnement} permet de definir les variables
1507 d'environnement necessaires a l'execution d'un job. Ces variables seront
1508 creees automatiquement dans l'environnement du job lorsque celui-ci
1509 debutera son execution sur la machine.
1511 Une variable d'environnement est traditionnellement composee d'un nom et
1512 d'une valeur qui peut etre vide ou absente. L'ensemble des variables
1513 d'environnement peut ainsi etre represente sous la forme d'une table
1514 associative dans laquelle le nom de la variable correspond a la clef de la
1515 table, et la valeur de la variable correspond a la valeur de la table
1516 pour la clef donnee.
1518 Chaque objet de la classe @emph{Environnement} se comporte comme une
1519 table associative telle que decrite auparavant.
1525 typedef map < string, string > Environnement;
1534 env["MYAPP_ROOTDIR"] = "/home/user/myapplication";
1535 env["MYAPP_LICENSEFILE"] = env["MYAPP_ROOTDIR"] + "/license.dat";
1537 env["CXXFLAGS"] = "-g -O2";
1544 Compte tenu de la definition actuelle de la classe @emph{Environnement}
1545 en tant que map STL, elle beneficie de toutes les fonctionnalites
1546 classiques des maps STL.
1551 @c ----------------------
1552 @c ----------------------
1553 @c ----------------------
1555 @node Classe Job, Classe JobId, Classe Environnement, Classes utilisateur
1556 @comment node-name, next, previous, up
1561 La classe @emph{Job} represente la notion de travail, ou job, dans la
1562 bibliotheque de classes Batch. Elle se comporte essentiellement comme
1563 une collection de parametres et de variables necessaires a la
1564 description des actions qui doivent etre realisees dans des conditions
1567 Elle se repose sur deux autres classes qui distinguent la notion de
1568 parametre d'execution et celle de variable d'environnement : les classes
1569 @emph{Parametre} et @emph{Environnement}. @xref{Classe
1570 Parametre}. @xref{Classe Environnement}.
1572 Son role est de preparer la soumission qui aura lieu et qui concretisera
1573 l'incarnation du job dans le gestionnaire de batch. Tant que le job n'a
1574 pas ete soumis, on ne peut pas vraiment considerer son existence et de
1575 fait les interactions qu'on peut avoir avec l'objet sont tres limitees.
1584 // Constructeurs et destructeur
1586 Job(Parametre param);
1587 Job(Environnement env);
1588 Job(Parametre param, Environnement env);
1591 // Operateur pour l'affichage sur un stream
1592 friend ostream & operator <<(ostream & os, const Job & job);
1595 Parametre getParametre() const;
1596 void setParametre(const Parametre &);
1599 Environnement getEnvironnement() const;
1600 void setEnvironnement(const Environnement &);
1602 // Methodes pour l'interfacage avec Python (SWIG)
1603 string __repr__() const;
1606 Parametre _param; // table des parametres batch du job
1607 Environnement _env; // table des variables d'environnement
1619 @dots{} (ici on cree un BatchManager bm)
1623 @dots{} (ici on cree les parametres du job)
1625 Job job(param, env);
1626 JobId jobid = bm.sumbitJob(job);
1636 Job(Parametre param)$*
1637 Job(Environnement env)$*
1638 Job(Parametre param, Environnement env)}
1640 Le constructeur, en plus de creer l'objet, peut faire des verifications
1641 sur la coherence des objets passes en argument s'il y en a.
1646 Le destructeur libere simplement les espaces alloues.
1649 @b{ostream & operator <<(ostream & os, const Job & job)}
1651 Cette methode permet a l'utilisateur d'afficher sur un stream le contenu
1652 d'un objet de classe @emph{Job}.
1655 @b{Parametre getParametre() const}
1657 Un accesseur pour recuperer l'objet Parametre passe en argument du
1661 @b{void setParametre(const Parametre &)}
1663 Cette methode permet de positionner @i{a posteriori} l'objet
1664 @emph{Parametre}. Des tests complementaires peuvent etre faits pour
1665 verifier la coherence de l'objet.
1668 @b{Environnement getEnvironnement() const}
1670 Un accesseur pour recuperer l'objet Environnement passe en argument du constructeur.
1673 @b{void setEnvironnement(const Environnement &)}
1675 Cette methode permet de positionner @i{a posteriori} l'objet
1676 @emph{Environnement}. Des tests complementaires peuvent etre faits pour
1677 verifier la coherence de l'objet.
1680 @b{string __repr__() const}
1682 Cette methode sert dans l'interfacage Python de l'objet et permet d'en
1683 realiser l'affichage a travers l'interpreteur Python.
1688 @c ----------------------
1689 @c ----------------------
1690 @c ----------------------
1692 @node Classe JobId, Classe JobInfo, Classe Job, Classes utilisateur
1693 @comment node-name, next, previous, up
1695 @subsubsection JobId
1698 La classe @emph{JobId} represente l'incarnation d'un objet de classe
1699 @emph{Job} une fois soumis au travers du gestionnaire de batch. A chaque
1700 objet @emph{JobId} correspond une et une seule soumission d'un objet
1701 @emph{Job}. Ainsi un meme objet @emph{Job} peut etre soumis plusieurs
1702 fois de suite a un ou plusieurs gestionnaires de batch et produira
1703 autant d'objets @emph{JobId}.
1705 L'objet @emph{JobId} assure le controle et la gestion du job au travers
1706 du gestionnaire de batch. Chaque objet @emph{JobId} est associe a un
1707 gestionnaire particulier aupres duquel il relaie les actions qu'on lui
1717 friend class BatchManager;
1720 // Constructeur standard et destructeur
1724 // Constructeur avec le pointeur sur le BatchManager associe
1725 // et avec une reference
1726 JobId(BatchManager *, string ref);
1728 // Operateur d'affectation entre objets
1729 virtual JobId & operator =(const JobId &);
1731 // Constructeur par recopie
1732 JobId(const JobId &);
1734 // Accesseur pour la reference interne
1735 virtual string getReference() const;
1737 // Methodes pour le controle du job
1738 // retire un job du gestionnaire
1739 virtual void deleteJob() const;
1741 // suspend un job en file d'attente
1742 virtual void holdJob() const;
1744 // relache un job suspendu
1745 virtual void releaseJob() const;
1747 // modifie un job en file d'attente
1748 virtual void alterJob(const Parametre & param,
1749 const Environnement & env) const;
1750 virtual void alterJob(const Parametre & param) const;
1751 virtual void alterJob(const Environnement & env) const;
1753 // modifie un job en file d'attente
1754 virtual void setParametre(const Parametre & param);
1755 virtual void setEnvironnement(const Environnement & env);
1757 // renvoie l'etat du job
1758 virtual Batch::JobInfo queryJob() const;
1760 // Methodes pour l'interfacage avec Python (SWIG)
1761 string __str__() const; // SWIG : affichage en Python
1762 string __repr__() const; // SWIG : affichage en Python
1765 BatchManager * _p_batchmanager; // pointeur sur le BatchManager
1766 // qui controle le job
1767 string _reference; // reference du job au sein du BatchManager
1777 @dots{} (ici on cree un BatchManager bm et un Job job)
1779 // On soumet le job et on recupere un identifiant
1780 JobId jobid = bm.submitJob(job);
1782 // Ce qui permet d'interroger l'etat du job en cours
1783 JobInfo jinfo = jobid.queryJob();
1793 JobId(BatchManager *, string ref)}
1795 Le constructeur par defaut cree un @emph{JobId} qui devra etre complete
1796 par la suite. Ceci n'est pas directement realisable par l'utilisateur
1797 mais sert pour certaines classes amies de la classe @emph{JobId}.
1799 D'un point de vue utilisateur la construction d'un objet @emph{JobId}
1800 necessite un pointeur sur un gestionnaire de batch existant et une
1801 chaine de caractere representant une reference au sein de ce
1802 gestionnaire de batch.
1804 Ces parametres sont en general issus de la
1805 communication avec l'API du gestionnaire de batch et ne peuvent etre
1806 aisement deduits. C'est pourquoi il est recommande de passer par une
1807 classe d'implementation pour fabriquer un objet @emph{JobId}.
1813 Le destructeur libere l'espace occupe par l'objet.
1816 @b{JobId & operator =(const JobId &)}
1818 L'affectation d'un objet @emph{JobId} duplique les donnees internes de
1819 l'objet passe en argument. Les deux objets sont totalement independants
1820 a l'issue de l'affectation et designent chacun la meme instance du job
1821 dans le meme gestionnaire de batch. Le controle du job peut etre realise
1822 avec l'un ou l'autre des objets.
1825 @b{JobId(const JobId &)}
1827 De meme que l'affectation le constructeur par recopie produit un objet
1828 @emph{JobId} totalement independant de l'objet passe en argument et qui
1829 designe le meme job dans le meme gestionnaire de batch. Le controle du
1830 job peut etre realise avec l'un ou l'autre des objets.
1833 @b{string getReference() const}
1835 Cet accesseur retourne la reference du job pour le gestionnaire de batch
1836 qui a produit l'objet.
1839 @b{void deleteJob() const}
1841 Cette methode relaie aupres au gestionnaire de batch qui a produit
1842 l'objet la demande d'arret du job.
1845 @b{void holdJob() const}
1847 Cette methode relaie aupres au gestionnaire de batch qui a produit
1848 l'objet la demande de suspension du job.
1851 @b{void releaseJob() const}
1853 Cette methode relaie aupres au gestionnaire de batch qui a produit
1854 l'objet la demande de liberation du job.
1857 @b{void alterJob(const Parametre & param, const Environnement & env) const@*
1858 void alterJob(const Parametre & param) const@*
1859 void alterJob(const Environnement & env) const}
1861 Ces methodes relaient aupres du gestionnaire de batch qui a produit
1862 l'objet la demande de modification des parametres et/ou des variables
1863 d'environnement du job.
1866 @b{void setParametre(const Parametre & param)}
1868 Cette methode n'est utile que pour l'interfacage avec Python, car Python
1869 ne sait pas gerer la surcharge de methode, et de fait leve des
1870 exceptions lors d'appels a de telles methodes.
1872 Elle est equivalente a la methode @samp{void alterJob(const Parametre & param) const}.
1876 @b{void setEnvironnement(const Environnement & env)}
1878 Cette methode n'est utile que pour l'interfacage avec Python, car Python
1879 ne sait pas gerer la surcharge de methode, et de fait leve des
1880 exceptions lors d'appels a de telles methodes.
1882 Elle est equivalente a la methode @samp{void alterJob(const Environnement & env) const}.
1885 @b{Batch::JobInfo queryJob() const}
1887 Cette methode relaie aupres du gestionnaire de batch qui a produit
1888 l'objet la demande d'interrogation de l'etat du job.
1891 @b{string __str__() const}
1893 Cette methode n'est utile que pour l'interfacage avec Python. Elle
1894 permet d'afficher l'etat de l'objet @emph{JobId}.
1897 @b{string __repr__() const}
1899 Cette methode n'est utile que pour l'interfacage avec Python. Elle
1900 permet d'afficher l'etat de l'objet @emph{JobId}.
1905 @c ----------------------
1906 @c ----------------------
1907 @c ----------------------
1909 @node Classe JobInfo, Classe Parametre, Classe JobId, Classes utilisateur
1910 @comment node-name, next, previous, up
1912 @subsubsection JobInfo
1915 Un objet de classe @emph{JobInfo} represente l'ensemble des informations
1916 disponibles sur un travail actif, c'est-a-dire soumis au gestionnaire de
1917 batch, a un instant donne.
1919 Cet objet reprend des informations issues du job tel qu'il a ete soumis,
1920 @xref{Classe Job}, mais aussi des informations produites par le
1921 gestionnaire de batch a partir de la soumission et du transit du job en
1922 son sein : nom de la queue dans laquelle le job est inscrit, duree
1923 d'execution, date de soumission, etc.
1925 Ces informations sont disponibles aupres de l'utilisateur de la classe a
1926 travers les objets @emph{Parametre} et @emph{Environnement} que l'objet
1927 @emph{JobInfo} peut fournir.
1936 // Constructeur standard et destructeur
1940 // Constructeur par recopie
1941 JobInfo(const JobInfo & jinfo);
1943 // Operateur pour l'affichage sur un stream
1944 friend ostream & operator <<(ostream & os, const JobInfo & ji);
1947 virtual Parametre getParametre() const;
1948 virtual Environnement getEnvironnement() const;
1950 // Methodes pour l'interfacage avec Python (SWIG)
1951 string __str__() const; // SWIG : affichage en Python
1952 string __repr__() const; // SWIG : affichage en Python
1955 Parametre _param; // parametres du job
1956 Environnement _env; // variables d'environnement du job
1965 @dots{} (ici on cree un BatchManager bm et un Job job)
1967 // On soumet le job et on recupere un identifiant
1968 JobId jobid = bm.submitJob(job);
1970 // Ce qui permet d'interroger l'etat du job en cours
1971 JobInfo jinfo = jobid.queryJob();
1973 // On recupere l'objet Parametre interne modifie
1974 // par le gestionnaire de batch
1975 Parametre param = jinfo.getParametre();
1977 // On recupere l'objet Environnement interne modifie
1978 // par le gestionnaire de batch
1979 Environnement env = jinfo.getEnvironnement();
1989 Ce constructeur cree un objet @emph{JobInfo} vide.
1994 Le destructeur libere l'espace memoire alloue par l'objet.
1997 @b{JobInfo(const JobInfo & jinfo)}
1999 Le constructeur par recopie produit un objet identique a celui passe en
2000 argument. Les deux objets sont totalement independants l'un de l'autre.
2003 @b{ostream & operator <<(ostream & os, const JobInfo & ji)}
2005 Cet operateur permet de voir le contenu de l'objet sur un flot de sortie.
2008 @b{Parametre getParametre() const}
2010 Cet accesseur retourne l'objet interne @emph{Parametre} modifie par le
2011 gestionnaire de batch. En particulier on y retrouve toutes les clefs et
2012 les valeurs correspondant aux informations produites dynamiquement par
2013 le gestionnaire (duree d'execution, machine d'execution, etc.).
2014 Il n'est pas garanti que les valeurs passees au moment de la soumission
2015 soient inchangees car des modifications ont pu etre apportees a ces
2016 valeurs pendant le traitement du job par le gestionnaire.
2019 @b{Environnement getEnvironnement() const}
2021 Cet accesseur retourne l'objet interne @emph{Environnement} modifie par le
2022 gestionnaire de batch. En particulier on y retrouve toutes les clefs et
2023 les valeurs correspondant aux informations produites dynamiquement par
2024 le gestionnaire (chemin d'acces, variables d'environnement specifiques a
2025 la machine d'execution, etc.).
2026 Il n'est pas garanti que les valeurs passees au moment de la soumission
2027 soient inchangees car des modifications ont pu etre apportees a ces
2028 valeurs pendant le traitement du job par le gestionnaire.
2031 @b{string __str__() const}
2033 Cette methode n'est utile que pour l'interfacage avec Python. Elle
2034 permet d'afficher l'etat de l'objet @emph{JobInfo}.
2037 @b{string __repr__() const}
2039 Cette methode n'est utile que pour l'interfacage avec Python. Elle
2040 permet d'afficher l'etat de l'objet @emph{JobInfo}.
2046 @c ----------------------
2047 @c ----------------------
2048 @c ----------------------
2050 @node Classe Parametre, Classe Versatile, Classe JobInfo, Classes utilisateur
2051 @comment node-name, next, previous, up
2053 @subsubsection Parametre
2056 Les objets de la classe @emph{Parametre} se comportent comme des maps
2057 STL, dont ils ont les fonctionnalites, decrivant les parametres
2060 Contrairement aux variables d'environnement qui sont decrites par les
2061 objets de la classe @emph{Environnement}, les parametres d'execution
2062 servent a preciser les contraintes qui pesent sur le job, comme par
2063 exemple la duree maximale d'execution autorisee, la quantite maximale de
2064 memoire utilisable ou la queue de soumission, ou bien a renseigner le
2065 job avec des informations specifiques a l'utilisateur, comme son
2066 username, son adresse email, le code d'imputation du job, etc.
2068 En raison du caractere tres specifique et precis des informations qui
2069 doivent etre fournies au gestionnaire de batch, une nomenclature est
2070 proposee par la classe @emph{Parametre} qu'il est vivement conseille de
2071 suivre. De plus tout a ete fait pour rendre cette ecriture naturelle et
2072 facile, donc il ne devrait pas y avoir de probleme pour l'utiliser.
2074 Ainsi, a titre d'exemple, pour preciser le temps maximal autorise pour
2075 un job, il faut creer une clef de nom @var{maxcputime} dans un objet de
2076 classe @emph{Parametre} qui sera ensuite passe au job. Et pour preciser
2077 le code d'imputation du job, il faut creer une clef de nom @var{account}.
2079 Mais cet exemple simple montre que la valeur associee a la clef
2080 @var{maxcputime} est semantiquement une duree, et que la valeur associee a
2081 la clef @var{account} est semantiquement un nom. On a donc un probleme de
2082 type puisque dans la definition d'une map STL le type de la valeur doit
2083 etre le meme, et ce meme si les valeurs doivent par la suite avoir des
2084 types semantiques differents. C'est pourquoi on a definit une classe
2085 @emph{Versatile} qui encapsule des types differents. @xref{Classe
2088 Quoiqu'il en soit toute la mecanique est cachee et seul importe pour
2089 l'utilisateur de savoir que les valeurs associees aux clefs sont typees
2090 et que ces types sont definis dans l'enumeration @emph{DiscriminatorType}.
2091 @xref{Classe Versatile}.
2098 class Parametre : public map< string, Versatile >
2101 // Constructeur standard
2104 // Constructeur par recopie
2105 Parametre(const Parametre & PM);
2107 // Operateur de recherche dans la map
2108 Versatile & operator [] (const string &);
2109 const Versatile & operator [] (const string &) const;
2111 // Operateur d'affectation
2112 Parametre & operator =(const Parametre & PM);
2114 // Declarations statique des clefs de la map
2115 static const string ACCOUNT;
2116 static const string CHECKPOINT;
2117 static const string CKPTINTERVAL;
2118 static const string CREATIONTIME;
2119 static const string EGROUP;
2120 static const string ELIGIBLETIME;
2121 static const string EUSER;
2122 static const string EXECUTABLE;
2123 static const string EXECUTIONHOST;
2124 static const string HOLD;
2125 static const string ID;
2126 static const string INFILE;
2127 static const string MAIL;
2128 static const string MAXCPUTIME;
2129 static const string MAXDISKSIZE;
2130 static const string MAXRAMSIZE;
2131 static const string MAXWALLTIME;
2132 static const string MODIFICATIONTIME;
2133 static const string NAME;
2134 static const string OUTFILE;
2135 static const string PID;
2136 static const string QUEUE;
2137 static const string QUEUEDTIME;
2138 static const string SERVER;
2139 static const string STARTDATE;
2140 static const string STATE;
2141 static const string TEXT;
2142 static const string TMPDIR;
2143 static const string USEDCPUTIME;
2144 static const string USEDDISKSIZE;
2145 static const string USEDRAMSIZE;
2146 static const string USEDWALLTIME;
2147 static const string USER;
2150 // map interne servant a controler le type
2151 // de la valeur associee a chaque clef
2152 map< string, TypeParam > TypeMap;
2166 param[EXECUTABLE] = "/home/user/mon_application/executable";
2167 param[NAME] = "MonJob";
2168 param[ACCOUNT] = "MonProjet"; // code d'imputation/facturation
2169 param[MAXCPUTIME] = 360L; // 6min
2170 param[MAXWALLTIME] = 480L; // 8min
2171 param[INFILE] = Couple("/tmp/infich1", rempath + "/infich1");
2172 param[OUTFILE] = Couple("/tmp/outfich1", rempath + "/outfich1");
2173 param[OUTFILE] += Couple("stderr", path + "/STDERR");
2174 param[OUTFILE] += Couple("stdout", path + "/STDOUT");
2175 param[MAIL] = "user@@domaine.fr";
2176 param[USER] = "user";
2187 Le constructeur par defaut initialise l'objet @emph{Parametre} et cree
2188 la table des types internes. Par contre l'objet ne contient aucune valeur.
2191 @b{Parametre(const Parametre & PM)}
2193 Le constructeur par recopie cree un objet @emph{Parametre} a l'image de
2194 celui qui lui est passe en argument. La table des types internes est
2195 dupliquee ainsi que tous les objets correspondant a chacune des clefs.
2198 @b{Versatile & operator [] (const string &)}
2200 Cet operateur permet de recuperer la valeur designee par la clef passee
2201 en argument. Cette valeur est de classe @emph{Versatile} qui encapsule
2202 tous les types de base utilisables dans la bibliotheque en tant que
2203 parametre. @xref{Classe Versatile}.
2207 @b{const Versatile & operator [] (const string &) const}
2209 A l'image de l'operateur precedent, cet operateur permet de recuperer la
2210 valeur designee par la clef passee en argument mais uniquement pour des
2214 @b{Parametre & operator =(const Parametre & PM)}
2216 L'operateur d'affectation remplace l'ensemble du contenu de l'objet
2217 @emph{Parametre} par le contenu de l'objet passe en argument. Les
2218 valeurs sont dupliquees par rapport a l'objet @var{pm}.
2222 @item Description des clefs
2224 Selon les gestionnaires de batch utilises, certaines clefs sont actives
2225 ou inactives. Une definition superflue ne pose pas de probleme et se
2226 trouve ignoree au moment de la soumission. Par contre l'absence d'un
2227 clef peut empecher la soumission d'aboutir et lever une exception.
2230 @item ACCOUNT : type STRING
2232 Le code de facturation sur lequel le job doit s'imputer.
2234 @item CHECKPOINT : type LONG
2236 Une valeur non nulle indique au gestionnaire de batch que le job est
2237 @dfn{checkpointable}, c'est-a-dire interruptible pour une reprise
2240 @item CKPTINTERVAL : type LONG
2242 En liaison avec la clef @var{CHECKPOINT}, la clef @var{CKPTINTERVAL}
2243 indique l'intervalle en secondes entre deux interruptions du code
2246 @item CREATIONTIME : type LONG
2248 La date a laquelle le job a ete cree (soumis) dans le gestionnaire de batch.
2250 @item EGROUP : type STRING
2252 Le groupe effectif au sens Unix du terme dans lequel le job s'execute.
2254 @item ELIGIBLETIME : type LONG
2256 La date a laquelle le job a pu disposer des ressources necessaires a son
2259 @item EUSER : type STRING
2261 L'utilisateur effectif au sens Unix du terme pour lequel le job s'execute.
2263 @item EXECUTABLE : type STRING
2265 Le chemin d'acces absolu a l'executable sur la machine qui soumet le job.
2267 @item EXECUTIONHOST : type STRING
2269 Le nom de la machine qui execute le job.
2271 @item HOLD : type LONG
2273 Une valeur non nulle indique au gestionnaire de batch que le job doit
2274 etre place dans l'etat suspendu. Une valeur nulle libere le job.
2276 @item ID : type STRING
2278 L'identifiant unique du job pour le gestionnaire de batch.
2280 @item INFILE : type liste de COUPLE
2282 La clef @var{infile} liste les fichiers qui seront envoyes au job avant
2283 son execution. Chaque fichier peut avoir un nom different sur la machine
2284 cliente --- qui soumet le job --- et sur le serveur. C'est pourquoi
2285 chaque fichier a envoyer est represente par un couple dont le nom @var{local}
2286 est le chemin absolu du fichier sur la machine cliente et le nom
2287 @var{remote} est le chemin absolu du fichier sur le
2288 serveur. @xref{Classe Couple}.
2290 Si le nom @var{remote} vaut @samp{stdin}, alors le contenu du fichier
2291 designe par le nom @var{local} est envoye sur l'entree standard du job
2292 au moment de son execution.
2294 @item MAIL : type STRING
2296 L'adresse email de l'utilisateur ou lui seront envoyes les eventuels
2297 messages d'information et d'alerte du gestionnaire de batch.
2299 @item MAXCPUTIME : type LONG
2301 Le temps de calcul (@i{CPU time}) en secondes que ne devra pas depasser le job.
2303 @item MAXDISKSIZE : type LONG
2305 L'espace disque en octets que ne devra pas depasser le job.
2307 @item MAXRAMSIZE : type LONG
2309 La quantite de memoire vive en octets que ne devra pas depasser le job.
2311 @item MAXWALLTIME : type LONG
2313 Le temps reel (@i{elapsed time}) en secondes que ne devra pas depasser le job.
2315 @item MODIFICATIONTIME : type LONG
2317 La date a laquelle le job a ete modifie pour la derniere fois dans le
2318 gestionnaire de batch. Cette date correspond le plus souvent a la
2319 derniere operation realisee par le gestionnaire dans la gestion du job :
2320 routage au sein des files, suspension ou reprise, etc.
2322 @item NAME : type STRING
2324 Le nom du job tel qu'il apparait a l'utilisateur dans son dialogue avec
2325 le gestionnaire de batch. Ce nom n'a pas besoin d'etre unique et ne
2326 remplace pas l'identifiant (ID). Il n'est la que pour informer
2327 l'utilisateur de la nature de son job.
2329 @item OUTFILE : type liste de COUPLE
2331 La clef @var{outfile} liste les fichiers qui sont produits par le job et
2332 qui seront recuperes sur la machine locale de l'utilisateur apres
2333 son execution. Chaque fichier peut avoir un nom different sur la machine
2334 cliente --- qui soumet le job --- et sur le serveur. C'est pourquoi
2335 chaque fichier a recuperer est represente par un couple dont le nom @var{local}
2336 est le chemin absolu du fichier sur la machine cliente et le nom
2337 @var{remote} est le chemin absolu du fichier sur le
2338 serveur. @xref{Classe Couple}.
2340 Si le nom @var{local} vaut @samp{stdout}, alors le contenu du fichier
2341 designe par le nom @var{local} contient la sortie standard du job
2342 au moment de son execution.
2344 Si le nom @var{local} vaut @samp{stderr}, alors le contenu du fichier
2345 designe par le nom @var{local} contient la sortie d'erreur du job
2346 au moment de son execution.
2348 @item PID : type LONG
2350 La valeur du PID (@i{process identifier}) du job sur la machine sur
2351 lqsuelle il s'execute.
2353 @item QUEUE : type STRING
2355 Le nom de la queue, aussi appelee classe ou file suivant les
2356 terminologies, qui accueille le job.
2358 @item QUEUEDTIME : type LONG
2360 La date depuis laquelle le job a ete place en queue dans le gestionnaire
2363 @item SERVER : type STRING
2365 Le nom complet du serveur qui recoit les soumissions de job.
2367 @item STARTDATE : type LONG
2369 La date a partir de laquelle l'utilisateur desire que le job soit
2370 execute. L'execution ne demarrera qu'au dela de cette date et a
2371 condition que toutes les conditions de ressources soient remplies.
2373 @item STATE : type STRING
2375 L'etat actuel du job.
2377 ATTENTION : Ces valeurs ne sont pas encore normalisees.
2379 @item TEXT : type STRING
2381 Un texte d'information que le gestionnaire peut emettre a destination de
2382 l'utilisateur lorsque l'ensemble des parametres n'est pas suffisant pour
2383 traduire l'etat reel du job. Par exemple, ce message peut informer
2384 l'utilisateur de la raison qui maintient un job dans un etat suspendu ou
2385 qui l'empeche de s'executer.
2387 @item TMPDIR : type STRING
2389 Un chemin d'acces absolu a un repertoire qui sera cree au demarrage du
2390 job et qui isolera le job des autres travaux en cours d'execution sur la
2393 @item USEDCPUTIME : type LONG
2395 Le temps de calcul (@i{CPU time}) en secondes reellement consomme par le job.
2397 @item USEDDISKSIZE : type LONG
2399 L'espace disque en octets reellement consomme par le job.
2401 @item USEDRAMSIZE : type LONG
2403 L'espace disque en octets reellement consommee par le job.
2405 @item USEDWALLTIME : type LONG
2407 Le temps reel (@i{elapsed time}) en secondes reellement consomme par le job.
2409 @item USER : type STRING
2411 Le nom de l'utilisateur (@i{username}) sous lequel le job devra tourner
2412 sur la machine d'execution. Ce parametre est utile lorsque l'utilisateur
2413 possede des comptes differents sur les machines sur lequel il soumet et calcule.
2420 @c ----------------------
2421 @c ----------------------
2422 @c ----------------------
2424 @node Classe Versatile, Exceptions, Classe Parametre, Classes utilisateur
2425 @comment node-name, next, previous, up
2427 @subsubsection Versatile
2430 Cette classe est normalement invisible en tant que telle a l'utilsateur
2431 de la bibliotheque de classes Batch. Mais il est tout de meme utile de
2432 la presenter car son action est visible, notamment dans son interaction
2433 fine avec la classe @emph{Parametre}. @xref{Classe Parametre}.
2435 Comme il a ete precise dans la descrption de la classe @emph{Parametre},
2436 la classe @emph{Versatile} a ete concue pour encapsuler les valeurs de
2437 la map @emph{Parametre} qui peuvent etre de types effectifs differents.
2439 Ces types, decrits par l'enumeration @emph{DiscriminatorType}, sont
2440 actuellement au nombre de trois : @var{long}, @var{string} et
2441 @var{couple}. Ces types correpondent au types de base du langage C++ ou
2442 de la biliotheque de classes Batch. @xref{Types de base}.
2444 Le type special @var{undefined} ne sert que pour l'objet
2445 @emph{Versatile} juste cree mais non encore affecte d'une valeur et donc
2446 d'un type. La premiere affection d'une valeur a un objet
2447 @emph{Versatile} non encore affecte lui donne automatiquement le type de
2450 Les objets de classe @emph{Versatile} peuvent se comporter soit comme
2451 des variables scalaires, c'est-a-dire ne contenant qu'une valeur unique,
2452 soit comme des listes, auquel cas elles utilisent l'interface des
2453 @emph{list} de la STL. Toutefois afin de faciliter l'ecriture pour
2454 l'utilisateur basique de la classe @emph{Versatile} --- et de la classe
2455 @emph{Parametre} ---, des operateurs de concatenation @samp{+=} et
2456 @samp{,} ont ete ajoutes.
2463 // Les types autorises
2464 enum DiscriminatorType @{ UNDEFINED, LONG, STRING, COUPLE @};
2467 DiscriminatorType type; // le type de l'element interne
2468 int maxelem; // le nombre d'elements autorises
2471 class Versatile : public list< GenericType * >
2474 // Constructeur standard et destructeur
2476 virtual ~Versatile();
2478 // Constructeur par recopie
2479 Versatile(const Versatile & V);
2481 // Constructeur depuis le type de "base"
2483 Versatile(const string & s);
2484 Versatile(const Couple & c);
2486 // Operateur d'affectation et de concatenation
2487 // a partir d'un type de "base"
2488 Versatile & operator = (const long l)
2489 throw(TypeMismatchException);
2490 Versatile & operator = (const string & ch)
2491 throw(TypeMismatchException);
2492 Versatile & operator +=(const string & ch)
2493 throw(TypeMismatchException,ListIsFullException);
2494 Versatile & operator , (const string & ch)
2495 throw(TypeMismatchException,ListIsFullException);
2496 Versatile & operator = (const Couple & cp)
2497 throw(TypeMismatchException);
2498 Versatile & operator +=(const Couple & cp)
2499 throw(TypeMismatchException,ListIsFullException);
2500 Versatile & operator , (const Couple & cp)
2501 throw(TypeMismatchException,ListIsFullException);
2503 // Operateur d'affectation entre objets
2504 Versatile & operator = (const Versatile & V)
2505 throw(TypeMismatchException);
2507 // Conversion de type vers un type de "base"
2508 operator long() const throw(TypeMismatchException);
2509 operator string() const throw(TypeMismatchException);
2510 operator Couple() const throw(TypeMismatchException);
2511 string str() const throw(TypeMismatchException);
2513 // Operateur pour l'affichage sur un stream
2514 friend ostream & operator << (ostream & os, const Versatile & );
2516 // Positionnement et recuperation du type de l'element interne
2517 void setType(DiscriminatorType) throw(TypeMismatchException);
2518 DiscriminatorType getType() const;
2520 // Positionnement et recuperation du nombre d'elements internes
2521 void setMaxSize(int i);
2522 int getMaxSize() const;
2524 // Positionnement et recuperation du nom de l'objet
2525 string getName() const;
2526 void setName(const string & name);
2529 // Efface tous les elements internes de l'objet
2530 virtual void eraseAll();
2532 DiscriminatorType _discriminator; // type de l'element interne
2533 int _maxsize; // nombre max d'elements internes
2534 string _name; // nom de l'objet (sert pour les exceptions)
2546 // On cree un objet Versatile non encore affecte (scalaire)
2549 // L'affectation d'un long lui donne le type LONG
2550 Vlong = 1024L * 1024L * 1024L;
2551 cout << "Versatile long (must be 1073741824) : " << Vlong << endl;
2553 // On cree un objet Versatile non encore affecte (scalaire)
2556 // L'affectation d'une string (const char * promu en string)
2557 // lui donne le type STRING
2558 Vstring = "UneChaine";
2559 cout << "Versatile string (must be UneChaine) : " << Vstring << endl;
2563 // L'affectation d'un autre type leve une exception.
2564 // Il n'y a pas de retypage dynamique.
2566 cout << "ERR : No TypeMismatchException catched for Versatile long"
2569 catch (TypeMismatchException & ex)
2571 cout << "OK : TypeMismatchException catched for Versatile long"
2575 // Reaffectation avec le meme type
2576 Vlong = 1024L * 1024L;
2577 cout << "Versatile long (must be 1048576) : " << Vlong << endl;
2579 // On cree un objet Versatile non encore affecte (scalaire) ...
2582 // ... que l'on transforme en liste (non limitee)
2583 Vcat1.setMaxSize(0);
2585 // On affecte la premiere valeur ...
2588 // ... puis les suivantes par concatenation
2593 cout << "Versatile string concatenation (must be A B C D E) : "
2596 // Idem que pour Vcat1, mais avec une limite a 5 elements dans la liste
2598 Vcat2.setMaxSize(5);
2599 Vcat2 = "a", "b", "c", "d", "e";
2600 cout << "Versatile string concatenation (must be a b c d e) : "
2603 // On tronque les 2 derniers elements de la liste (il en reste 3)
2604 Vcat2.setMaxSize(3);
2605 cout << "Versatile string concatenation (must be a b c) : "
2609 Versatile Vcopy2(Vcat2);
2610 cout << "Versatile copy (must be a b c) : " << Vcopy2 << endl;
2614 cout << "Versatile affect (must be A B C D E) : " << Vaffect << endl;
2616 cout << "Versatile affect (must be a b c) : " << Vaffect << endl;
2620 // Retypage dynamique interdit
2622 cout << "ERR : No TypeMismatchException catched for Versatile"
2625 catch (TypeMismatchException & ex)
2627 cout << "OK : TypeMismatchException catched for Versatile string"
2633 // Concatenation au dela de la limite interdit
2635 cout << "ERR : No ListIsFullException catched for Versatile string"
2638 catch (ListIsFullException & ex)
2640 cout << "OK : ListIsFullException catched for Versatile string"
2644 // Les objets Versatile se comportent (presque) comme des objets
2645 // standards du langage
2647 cout << "Long value of Versatile long (must be 1048576) : "
2651 cout << "String value of Versatile (must be EncoreUneAutreChaine):"
2662 Le constructeur par defaut fabrique un objet scalaire de type
2663 @var{undefined} et de nom @samp{undefined}.
2668 Le destructeur efface tout le contenu de l'objet si celui-ci avait ete affecte.
2671 @b{Versatile(const Versatile & V)}
2673 Le constructeur par recopie duplique l'objet passe en argument ainsi que
2674 les valeurs qu'il contient. Le nouvel objet est totalement independant
2678 @b{Versatile(long l)@*
2679 Versatile(const string & s)@*
2680 Versatile(const Couple & c)}
2682 Ces constructeurs fabriquent des objets scalaires @emph{Versatile} a partir des
2683 types de base passes en argument. Chaque objet acquerera definitivement
2684 le type correspondant au type de base : @var{long} pour @samp{long},
2685 @var{string} pour @samp{string} et @var{couple} pour @samp{Couple}.
2688 @b{Versatile & operator = (const long l) throw(TypeMismatchException)@*
2689 Versatile & operator = (const string & ch) throw(TypeMismatchException)@*
2690 Versatile & operator = (const Couple & cp) throw(TypeMismatchException)}
2692 Ces operateurs affectent ou reaffectent la valeur passee en argument a
2693 l'objet. Le type de la valeur doit correspondre au type de l'objet si
2694 celui-ci a deja ete affecte, sinon une exception @emph{TypeMismatchException} est
2695 levee. @xref{Classe TypeMismatchException}.
2697 L'ancienne valeur de l'objet est perdue.
2700 @b{Versatile & operator += (const string & ch)
2701 throw(TypeMismatchException, ListIsFullException)@*
2702 Versatile & operator , (const string & ch)
2703 throw(TypeMismatchException, ListIsFullException)@*
2704 Versatile & operator += (const Couple & cp)
2705 throw(TypeMismatchException, ListIsFullException)@*
2706 Versatile & operator , (const Couple & cp)
2707 throw(TypeMismatchException, ListIsFullException)}
2709 Ces operateurs concatenent la valeur passee en argument a l'objet. Le
2710 type de la valeur doit correspondre au type interne de l'objet si
2711 celui-ci a deja ete affecte, sinon une exception @emph{TypeMismatchException} est
2712 levee. @xref{Classe TypeMismatchException}.
2714 Si la taille maximale de la liste est depasse, une exception @emph{ListIsFullException} est
2715 levee. @xref{Classe ListIsFullException}.
2718 @b{Versatile & operator = (const Versatile & V) throw(TypeMismatchException)}
2720 L'operateur d'affectation duplique l'objet passe en argument dans
2721 l'objet. Toutes les valeurs internes sont dupliquees de maniere a avoir
2722 une independance totale entre les deux objets a l'issue de
2725 Il est a noter qu'il est possible d'affecter a un objet un objet
2726 possedant un type different, auquel cas l'objet courant change de type
2727 pour acquerir celui de l'objet passe en argument. C'est le seul cas de
2728 changement de type autorise pour un objet.
2731 @b{operator long() const throw(TypeMismatchException)@*
2732 operator string() const throw(TypeMismatchException)@*
2733 operator Couple() const throw(TypeMismatchException)@*
2734 string str() const throw(TypeMismatchException)}
2736 Ces operateur de conversion dans les types de base permettent de
2737 recuperer la valeur interne de l'objet. Lorsque le type interne est
2738 incompatible avec la conversion une exception @emph{TypeMismatchException} est
2739 levee. @xref{Classe TypeMismatchException}.
2742 @b{ostream & operator << (ostream & os, const Versatile & )}
2744 Cet operateur permet de voir le contenu de l'objet sur un flot de sortie.
2747 @b{void setType(DiscriminatorType) throw(TypeMismatchException)}
2749 Cette methode change le type interne de l'objet en celui passe en
2750 argument. Ceci n'est possible que pour un objet non encore affecte. Si
2751 le nouveau type est different du type actuel une exception @emph{TypeMismatchException} est
2752 levee. @xref{Classe TypeMismatchException}.
2755 @b{DiscriminatorType getType() const}
2757 Cet accesseur renvoie le type interne de l'objet.
2760 @b{void setMaxSize(int i)}
2762 Cette methode permet de changer le nombre d'elements que l'objet est
2763 capable de stocker. Par defaut ce nombre est 1 a la construction de
2764 l'objet, signifiant qu'il ne peut contenir qu'une seule valeur a la fois
2767 Si ce nombre est superieur a 1 alors il represente une
2768 limite qui ne pourra etre depassee par l'objet sans lever d'exception
2769 @emph{ListIsFullException}. @xref{Classe ListIsFullException}.
2771 Si ce nombre vaut 0 (zero) alors il n'y a aucune limite superieure au
2772 nombre d'element dans l'objet.
2775 @b{int getMaxSize() const}
2777 Cet accesseur renvoie la taille maximale admise par l'objet.
2780 @b{void setName(const string & name)}
2782 Cette methode permet de positionner le nom de l'objet. Par defaut ce nom
2783 vaut @samp{undefined} a la construction de l'objet.
2785 Il est interessant de positionner le nom a une valeur significative
2786 comme par exemple le nom de la variable contenant l'objet car lorsqu'une
2787 exception est levee ce nom apparait en clair et aide au debugging.
2790 @b{string getName() const}
2792 Cet accesseur renvoie le nom interne de l'objet.
2800 @c ----------------------
2801 @c ----------------------
2802 @c ----------------------
2804 @node Exceptions, Classe APIInternalFailureException, Classe Versatile, Classes generiques
2805 @comment node-name, next, previous, up
2807 @subsection Exceptions
2810 La bibliotheque de classes Batch definit un certain nombre d'exceptions
2811 qui sont levees par les classes lors d'evenements qui traduisent un
2812 comportement anormal de la bibliotheque.
2815 * Classe APIInternalFailureException:: Erreur d'utilisation de l'API.
2816 * Classe ConnexionFailureException:: Probleme de connexion de l'API.
2817 * Classe GenericException:: Classe-mere de toutes les exceptions.
2818 * Classe InvalidArgumentException:: Parametre errone d'une methode.
2819 * Classe InvalidKeyException:: Clef erronee d'une map.
2820 * Classe ListIsFullException:: Debordement de taille d'une liste.
2821 * Classe NotYetImplementedException:: Methodes non encore implementee.
2822 * Classe RunTimeException:: Erreur d'execution imprevue.
2823 * Classe TypeMismatchException:: Probleme de conversion de type.
2827 @c ----------------------
2828 @c ----------------------
2829 @c ----------------------
2831 @node Classe APIInternalFailureException, Classe ConnexionFailureException, Exceptions, Exceptions
2832 @comment node-name, next, previous, up
2834 @subsubsection APIInternalFailureException
2835 @findex APIInternalFailureException
2837 Cette exception est levee par les classes d'implementation de la
2838 bibliotheque lorsqu'une erreur est detectee au moment de la
2839 communication avec l'API du gestionnaire de batch. En general l'erreur
2840 renvoyee par l'API est incluse dans le message de l'exception.
2842 Cette exception herite de la classe @emph{GenericException} qui definit
2843 uniquement un constructeur et deux membres publics constants : @emph{type} et
2844 @emph{message}. @xref{Classe GenericException}.
2850 class APIInternalFailureException : public GenericException
2854 APIInternalFailureException(string msg = "undefined");
2862 @b{APIInternalFailureException(string msg = "undefined")}
2864 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
2865 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
2866 membre public constant @emph{message}.
2868 Le membre public constant @emph{type} est initialise avec le nom de la
2869 classe, soit @emph{APIInternalFailureException}.
2876 @c ----------------------
2877 @c ----------------------
2878 @c ----------------------
2880 @node Classe ConnexionFailureException, Classe GenericException, Classe APIInternalFailureException, Exceptions
2881 @comment node-name, next, previous, up
2883 @subsubsection ConnexionFailureException
2884 @findex ConnexionFailureException
2886 Cette exception est levee par les classes d'implementation de la
2887 bibliotheque lorsqu'une erreur est detectee au moment de la
2888 connexion au gestionnaire de batch. En general l'erreur
2889 renvoyee par l'API de connexion est incluse dans le message de l'exception.
2891 Cette exception herite de la classe @emph{GenericException} qui definit
2892 uniquement un constructeur et deux membres publics constants : @emph{type} et
2893 @emph{message}. @xref{Classe GenericException}.
2899 class ConnexionFailureException : public GenericException
2903 ConnexionFailureException(string msg = "undefined");
2911 @b{ConnexionFailureException(string msg = "undefined")}
2913 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
2914 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
2915 membre public constant @emph{message}.
2917 Le membre public constant @emph{type} est initialise avec le nom de la
2918 classe, soit @emph{ConnexionFailureException}.
2924 @c ----------------------
2925 @c ----------------------
2926 @c ----------------------
2928 @node Classe GenericException, Classe InvalidArgumentException, Classe ConnexionFailureException, Exceptions
2929 @comment node-name, next, previous, up
2931 @subsubsection GenericException
2932 @findex GenericException
2934 Cette classe est generique comme son nom l'indique et definit une
2935 interface commune pour toutes les exceptions de la
2938 Cette exception definit uniquement un constructeur et deux membres
2939 publics constants : @emph{type} et @emph{message}. @xref{Classe
2947 class GenericException
2950 const string type; // la nature de l'exception
2951 const string message; // la raison de l'exception
2954 GenericException(const string tp = "GenericException",
2955 const string msg = "undefined");
2963 @b{GenericException(const string tp = "GenericException", const string msg = "undefined")}
2965 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
2966 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
2967 membre public constant @emph{message}.
2969 Le membre public constant @emph{type} est initialise avec le parametre
2970 @emph{tp} qui contient generalement le nom de la classe.
2977 @c ----------------------
2978 @c ----------------------
2979 @c ----------------------
2981 @node Classe InvalidArgumentException, Classe InvalidKeyException, Classe GenericException, Exceptions
2982 @comment node-name, next, previous, up
2984 @subsubsection InvalidArgumentException
2985 @findex InvalidArgumentException
2987 Cette exception est levee par les classes de la bibliotheque lorsqu'un
2988 parametre erronne est passe en argument a une methode. En general
2989 le nom de l'arguement erronne est inclus dans le message de
2992 Cette exception herite de la classe @emph{GenericException} qui definit
2993 uniquement un constructeur et deux membres publics constants : @emph{type} et
2994 @emph{message}. @xref{Classe GenericException}.
3000 class InvalidArgumentException : public GenericException
3004 InvalidArgumentException(string msg = "undefined");
3012 @b{InvalidArgumentException(string msg = "undefined")}
3014 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
3015 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
3016 membre public constant @emph{message}.
3018 Le membre public constant @emph{type} est initialise avec le nom de la
3019 classe, soit @emph{InvalidArgumentException}.
3026 @c ----------------------
3027 @c ----------------------
3028 @c ----------------------
3030 @node Classe InvalidKeyException, Classe ListIsFullException, Classe InvalidArgumentException, Exceptions
3031 @comment node-name, next, previous, up
3033 @subsubsection InvalidKeyException
3034 @findex InvalidKeyException
3037 Cette exception est levee par les methodes de la classe @emph{Parametre}
3038 lorsqu'une clef erronnee est utilisee. En general le nom de la clef
3039 erronnee est inclus dans le message de l'exception.
3041 Cette exception herite de la classe @emph{GenericException} qui definit
3042 uniquement un constructeur et deux membres publics constants : @emph{type} et
3043 @emph{message}. @xref{Classe GenericException}.
3049 class InvalidKeyException : public GenericException
3053 InvalidKeyException(string msg = "undefined");
3061 @b{InvalidKeyException(string msg = "undefined")}
3063 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
3064 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
3065 membre public constant @emph{message}.
3067 Le membre public constant @emph{type} est initialise avec le nom de la
3068 classe, soit @emph{InvalidKeyException}.
3075 @c ----------------------
3076 @c ----------------------
3077 @c ----------------------
3079 @node Classe ListIsFullException, Classe NotYetImplementedException, Classe InvalidKeyException, Exceptions
3080 @comment node-name, next, previous, up
3082 @subsubsection ListIsFullException
3083 @findex ListIsFullException
3085 Cette exception est levee par les methodes de la classe @emph{Versatile}
3086 lorsque la taille maximale de la liste interne est depasse. En general
3087 le nom de l'objet en erreur est inclus dans le message de l'exception.
3089 Cette exception herite de la classe @emph{GenericException} qui definit
3090 uniquement un constructeur et deux membres publics constants : @emph{type} et
3091 @emph{message}. @xref{Classe GenericException}.
3097 class ListIsFullException : public GenericException
3101 ListIsFullException(string msg = "undefined");
3109 @b{ListIsFullException(string msg = "undefined")}
3111 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
3112 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
3113 membre public constant @emph{message}.
3115 Le membre public constant @emph{type} est initialise avec le nom de la
3116 classe, soit @emph{ListIsFullException}.
3124 @c ----------------------
3125 @c ----------------------
3126 @c ----------------------
3128 @node Classe NotYetImplementedException, Classe RunTimeException, Classe ListIsFullException, Exceptions
3129 @comment node-name, next, previous, up
3131 @subsubsection NotYetImplementedException
3132 @findex NotYetImplementedException
3134 Cette exception est levee par les classes de la bibliotheque lorsqu'une
3135 methode declaree mais non encore implementee est utilisee. En general
3136 le nom de l'objet en erreur est inclus dans le message de l'exception.
3138 Cette exception herite de la classe @emph{GenericException} qui definit
3139 uniquement un constructeur et deux membres publics constants : @emph{type} et
3140 @emph{message}. @xref{Classe GenericException}.
3146 class NotYetImplementedException : public GenericException
3150 NotYetImplementedException(string msg = "undefined");
3158 @b{NotYetImplementedException(string msg = "undefined")}
3160 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
3161 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
3162 membre public constant @emph{message}.
3164 Le membre public constant @emph{type} est initialise avec le nom de la
3165 classe, soit @emph{NotYetImplementedException}.
3173 @c ----------------------
3174 @c ----------------------
3175 @c ----------------------
3177 @node Classe RunTimeException, Classe TypeMismatchException, Classe NotYetImplementedException, Exceptions
3178 @comment node-name, next, previous, up
3180 @subsubsection RunTimeException
3181 @findex RunTimeException
3183 Cette exception est levee par les classes de la bibliotheque lorsqu'une
3184 erreur inconnue et imprevue apparait. Cette exception est le
3185 comportement par defaut que doit gerer le gestionnaire d'exception en ce
3186 qui concerne les classes de la bibliotheque. En general le nom de
3187 l'objet en erreur est inclus dans le message de l'exception.
3189 Cette exception herite de la classe @emph{GenericException} qui definit
3190 uniquement un constructeur et deux membres publics constants : @emph{type} et
3191 @emph{message}. @xref{Classe GenericException}.
3197 class RunTimeException : public GenericException
3201 RunTimeException(string msg = "undefined");
3209 @b{RunTimeException(string msg = "undefined")}
3211 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
3212 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
3213 membre public constant @emph{message}.
3215 Le membre public constant @emph{type} est initialise avec le nom de la
3216 classe, soit @emph{RunTimeException}.
3224 @c ----------------------
3225 @c ----------------------
3226 @c ----------------------
3228 @node Classe TypeMismatchException, Classes specifiques, Classe RunTimeException, Exceptions
3229 @comment node-name, next, previous, up
3231 @subsubsection TypeMismatchException
3232 @findex TypeMismatchException
3234 Cette exception est levee par les methodes de la classe @emph{Versatile}
3235 lorsque qu'une erreur de type est rencontree dans un objet. Ce genre
3236 d'erreur survient lorsqu'on essaie d'affecter une valeur d'un type
3237 different du type interne de l'objet @emph{Versatile} a ce meme objet,
3238 ou bien lorsqu'on ajoute une valeur d'un type different a une liste. En
3239 general le nom de l'objet en erreur est inclus dans le message de
3242 Cette exception herite de la classe @emph{GenericException} qui definit
3243 uniquement un constructeur et deux membres publics constants : @emph{type} et
3244 @emph{message}. @xref{Classe GenericException}.
3250 class TypeMismatchException : public GenericException
3254 TypeMismatchException(string msg = "undefined");
3262 @b{TypeMismatchException(string msg = "undefined")}
3264 Ce contructeur prend la chaine @emph{msg} comme message d'erreur a
3265 renvoyer au gestionnaire d'exception. Cette valeur est stockee dans le
3266 membre public constant @emph{message}.
3268 Le membre public constant @emph{type} est initialise avec le nom de la
3269 classe, soit @emph{TypeMismatchException}.
3278 @c ----------------------
3279 @c ----------------------
3280 @c ----------------------
3282 @node Classes specifiques, Classes PBS, Classe TypeMismatchException, Classes
3283 @comment node-name, next, previous, up
3285 @section Classes specifiques
3286 @cindex classes specifiques
3288 Afin de pouvoir se connecter aux gestionnaires de batch reels a travers
3289 leurs API, les classes generiques ont ete derivees pour offrir une
3290 implementation correspondant a l'interface qu'elles definissent.
3292 Pour traduire a la fois le fait que les nouvelles classes derivent d'une
3293 classe generique et qu'elles sont une implementation d'une API
3294 particuliere, on adopte la convention de nom suivante : la classe se
3295 nomme comme sa classe generique mais est suffixee par le nom de l'API du
3296 gestionnaire de batch, les deux termes etant separes par un caractere
3299 Actuellement, seul le gestionnaire de batch OpenPBS, @xref{Prerequis}, est
3300 supporte. Mais ce catalogue devrait s'enrichir par la suite.
3302 Les classes de la bibliotheque sont egalement accessibles a travers un
3303 interpreteur Python, ce qui a necessite la creation de certaines classes
3304 d'interface avec l'interpreteur.
3307 * Classes PBS:: Classes d'implementation pour OpenPBS
3308 * Classes Python:: Classes d'interfacage avec Python.
3311 @c ----------------------
3312 @c ----------------------
3313 @c ----------------------
3315 @node Classes PBS, Classe FactBatchManager_PBS, Classes specifiques, Classes specifiques
3316 @comment node-name, next, previous, up
3318 @subsection Classes PBS
3321 Actuellement seules les classes @emph{BatchManager}, @emph{JobInfo} et
3322 @emph{Job} ont besoin d'etre derivees pour implementer la communication
3323 et l'interfacage avec l'API du gestionnaire de batch OpenPBS.
3327 * Classe FactBatchManager_PBS:: Description de la classe FactBatchManager_PBS.
3328 * Classe BatchManager_PBS:: Description de la classe BatchManager_PBS.
3329 * Classe JobInfo_PBS:: Description de la classe JobInfo_PBS.
3330 * Classe Job_PBS:: Description de la classe Job_PBS.
3334 @node Classe FactBatchManager_PBS, Classe BatchManager_PBS, Classes PBS, Classes PBS
3335 @comment node-name, next, previous, up
3336 @subsubsection FactBatchManager_PBS
3337 @cindex FactBatchManager_PBS
3339 Cette classe derive de la classe generique @emph{FactBatchManager},
3340 @xref{Classe FactBatchManager}.
3342 Les objets de la classe @emph{BatchManager_PBS} realisent l'interface de
3343 la bibliotheque avec l'API du gestionnaire de batch OpenPBS.
3349 class FactBatchManager_PBS : public FactBatchManager
3352 // Constructeur et destructeur
3353 FactBatchManager_PBS();
3354 virtual ~FactBatchManager_PBS();
3356 virtual BatchManager_PBS * operator() (const char * hostname) const;
3370 // On instancie le catalogue de gestionnaires de batch
3371 Batch::BatchManagerCatalog cata;
3373 // On cree une fabrique de BatchManager de type PBS
3374 Batch::FactBatchManager & fbm = * cata("PBS");
3382 @b{FactBatchManager_PBS()}
3384 Ce constructeur instancie un objet de la classe
3385 @emph{FactBatchManager_PBS} et l'enregistre automatiquement aupres du
3386 catalogue de fabrique. @xref{Classe BatchManagerCatalog}.
3388 Le type est positionne a la valeur PBS.
3391 @b{~FactBatchManager_PBS()}
3393 Le destructeur ne fait rien de particulier.
3396 @b{BatchManager_PBS * operator() (const char * hostname) const}
3398 Cet operateur renvoie un objet nouvellement cree de type
3399 @emph{BatchManager_PBS} derivant de @emph{BatchManager} et oeuvrant sur
3400 la machine @emph{hostname}. La destruction de l'objet est a la charge de
3407 @c ----------------------
3408 @c ----------------------
3409 @c ----------------------
3411 @node Classe BatchManager_PBS, Classe JobInfo_PBS, Classe FactBatchManager_PBS, Classes PBS
3412 @comment node-name, next, previous, up
3414 @subsubsection BatchManager_PBS
3415 @cindex BatchManager_PBS
3417 Cette classe derive de la classe generique @emph{BatchManager},
3418 @xref{Classe BatchManager}.
3420 Les objets de la classe @emph{BatchManager_PBS} realisent l'interface de
3421 la bibliotheque avec l'API du gestionnaire de batch OpenPBS.
3427 class BatchManager_PBS : public BatchManager
3430 // Constructeur et destructeur
3431 BatchManager_PBS(FactBatchManager * parent,
3432 const char * host) throw(InvalidArgumentException);
3433 virtual ~BatchManager_PBS();
3435 // Recupere le nom du serveur par defaut
3436 static string getDefaultServer();
3438 // Recupere le l'identifiant d'un job deja soumis au BatchManager
3439 virtual const JobId getJobIdByReference(const string & ref);
3441 // Methodes pour le controle des jobs : virtuelles pures
3442 // soumet un job au gestionnaire
3443 virtual const JobId submitJob(const Job & job);
3445 // retire un job du gestionnaire
3446 virtual void deleteJob(const JobId & jobid);
3448 // suspend un job en file d'attente
3449 virtual void holdJob(const JobId & jobid);
3451 // relache un job suspendu
3452 virtual void releaseJob(const JobId & jobid);
3454 // modifie un job en file d'attente
3455 virtual void alterJob(const JobId & jobid,
3456 const Parametre & param,
3457 const Environnement & env);
3458 virtual void alterJob(const JobId & jobid,
3459 const Parametre & param);
3460 virtual void alterJob(const JobId & jobid,
3461 const Environnement & env);
3463 // renvoie l'etat du job
3464 virtual JobInfo queryJob(const JobId & jobid);
3466 // modifie un job en file d'attente
3467 virtual void setParametre(const JobId & jobid,
3468 const Parametre & param);
3469 virtual void setEnvironnement(const JobId & jobid,
3470 const Environnement & env);
3473 string _hostname; // serveur ou tourne le BatchManager
3485 // On instancie le catalogue de gestionnaires de batch
3486 Batch::BatchManagerCatalog cata;
3488 // On cree une fabrique de BatchManager de type PBS
3489 Batch::BatchManager & myBM = (* cata("PBS"))("serveur.domaine.fr")
3491 // Maintenant, on peut utiliser toutes les fonctionnalites du
3492 // gestionnaire de batch a travers le variable myBM
3500 @b{BatchManager_PBS(FactBatchManager * parent,
3501 const char * host) throw(InvalidArgumentException)}
3503 Excepte un pointeur sur la fabrique qui a produit l'objet, le
3504 constructeur accepte zero ou un argument de type @emph{string} decrivant
3505 soit le nom de domaine completement qualifie (FQDN, @i{fully qualified
3506 domain name}) du serveur de batch, soit son adresse IP dans un format
3507 decimal "aaa.bbb.ccc.ddd".
3509 Si aucun parametre n'est passe au constructeur, celui-ci prend le
3510 serveur par defaut tel que renvoye par la methode @emph{getDefaultServer}.
3512 Une resolution du nom ou de l'adresse peut etre realisee en fonction des
3513 capacites de la plate-forme pour s'assurer que le serveur est connu et
3514 joignable. En cas d'echec, une exception InvalidArgumentException est
3515 levee. @xref{Classe InvalidArgumentException}.
3517 Ceci fait, une connexion est etablie avec le gestionnaire de batch qui
3518 est maintenue jusqu'a destruction de l'objet.
3523 Le destructeur supprime la connexion precedemment etablie par le
3524 constructeur lorsque celle-ci a reussi.
3527 @b{const JobId submitJob(const Job & job)}
3529 Cette methode soumet le job passe en argument au gestionnaire de
3530 batch. Etant donne que le job ne peut pas etre envoye tel quel puisqu'il
3531 a un format generique au sein de la bibliotheque de classes Batch, cette
3532 methode est chargee de le convertir dans un format adapte au
3533 gestionnaire de batch sous-jacent.
3535 La methode opere ici une conversion du job de la classe @emph{Job} en @emph{Job_PBS}.
3537 Ce n'est que lorsque cette conversion est realisee que le job est soumis
3538 au gestionnaire a travers son API. L'identifiant propose par le
3539 gestionnaire est alors renvoye a l'appelant. Si la soumission echoue
3540 pour une raison ou une autre, une exception APIInternalFailureException est
3541 levee. @xref{Classe APIInternalFailureException}.
3544 @b{void deleteJob(const JobId & jobid)}
3546 Cette methode retire le job dont l'identifiant est passe en argument de
3547 la file d'attente du gestionnaire, ou bien l'arrete en cours
3548 d'execution. Cette methode est inoperante sur des travaux deja termines,
3549 auquel cas une exception APIInternalFailureException est
3550 levee. @xref{Classe APIInternalFailureException}.
3554 @b{void holdJob(const JobId & jobid)}
3556 Cette methode suspend le job dont l'identifiant est passe en argument au
3557 sein de la file d'attente du gestionnaire. Cette methode est inoperante
3558 sur des travaux en cours d'execution ou deja termines, ainsi que sur des
3559 travaux deja suspendus.
3560 En cas de probleme, une exception APIInternalFailureException est
3561 levee. @xref{Classe APIInternalFailureException}.
3564 @b{void releaseJob(const JobId & jobid)}
3566 Cette methode relache un job precedemment suspendu en file
3567 d'attente dont l'identifiant est passe en argument. Elle est inoperante
3568 sur des travaux deja reclaches, en cours d'execution ou termines.
3569 En cas de probleme, une exception APIInternalFailureException est
3570 levee. @xref{Classe APIInternalFailureException}.
3574 @b{void alterJob(const JobId & jobid, const Parametre & param, const Environnement & env)@*
3575 void alterJob(const JobId & jobid, const Parametre & param)@*
3576 void alterJob(const JobId & jobid, const Environnement & env)}
3578 Ces methodes permettent de modifier les parametres d'execution et
3579 d'environnement d'un job dont l'identifiant est passe en
3580 argument. @xref{Classe Parametre}. @xref{Classe Environnement}. Il
3581 est important de noter que le job doit etre encore place en file
3582 d'attente sinon la methode est inoperante.
3583 En cas de probleme, une exception APIInternalFailureException est
3584 levee. @xref{Classe APIInternalFailureException}.
3587 @b{JobInfo queryJob(const JobId & jobid)}
3589 Cette methode permet de recuperer les informations concernant le job
3590 dont l'identifiant est passe en argument dans un objet de classe
3591 @emph{JobInfo}. @xref{Classe JobInfo}. On y retrouve les parametres
3592 d'execution et d'environnement du job tels qu'ils ont ete passes au
3593 gestionnaire au moment de la soumission, ainsi que des informations
3594 concernant l'execution du job comme par exemple la machine d'execution,
3595 le temps consomme, la memoire consommee, etc.
3597 Il n'est pas toujours possible d'interroger un job deja termine.
3598 En cas de probleme, une exception APIInternalFailureException est
3599 levee. @xref{Classe APIInternalFailureException}.
3603 @b{const JobId getJobIdByReference(const string & ref)}
3605 Cette methode permet de recuperer au sein de la classe un identifiant de
3606 job a partir d'une chaine de caracteres obtenue par un biais
3607 externe. Cet identifiant pourra etre utilise par la suite au sein de la
3608 biliotheque de classes pour controler le job comme s'il avait ete cree
3609 et soumis depuis la biliotheque-meme.
3612 @b{void setParametre(const JobId & jobid, const Parametre & param)}
3614 Cette methode n'est utile que pour l'interfacage avec Python, car Python
3615 ne sait pas gerer la surcharge de methode, et de fait leve des
3616 exceptions lors d'appels a de telles methodes.
3618 Elle est equivalente a la methode @samp{void alterJob(const JobId & jobid, const Parametre & param)}.
3621 @b{void setEnvironnement(const JobId & jobid, const Environnement & env)}
3623 Cette methode n'est utile que pour l'interfacage avec Python, car Python
3624 ne sait pas gerer la surcharge de methode, et de fait leve des
3625 exceptions lors d'appels a de telles methodes.
3627 Elle est equivalente a la methode @samp{void alterJob(const JobId & jobid, const Environnement & env)}.
3634 @c ----------------------
3635 @c ----------------------
3636 @c ----------------------
3639 @node Classe JobInfo_PBS, Classe Job_PBS, Classe BatchManager_PBS, Classes PBS
3640 @comment node-name, next, previous, up
3642 @subsubsection JobInfo_PBS
3645 Un objet de classe @emph{JobInfo} represente l'ensemble des informations
3646 disponibles sur un travail actif, c'est-a-dire soumis au gestionnaire de
3647 batch, a un instant donne.
3649 Cet objet reprend des informations issues du job tel qu'il a ete soumis,
3650 @xref{Classe Job}, mais aussi des informations produites par le
3651 gestionnaire de batch a partir de la soumission et du transit du job en
3652 son sein : nom de la queue dans laquelle le job est inscrit, duree
3653 d'execution, date de soumission, etc.
3655 Ces informations sont disponibles aupres de l'utilisateur de la classe a
3656 travers les objets @emph{Parametre} et @emph{Environnement} que l'objet
3657 @emph{JobInfo} peut fournir.
3663 class JobInfo_PBS : public JobInfo
3666 // Constructeur standard et destructeur
3668 JobInfo_PBS(struct batch_status * stat_list,
3669 bool tobedeleted = false);
3670 virtual ~JobInfo_PBS();
3672 // Constructeur par recopie
3673 JobInfo_PBS(const JobInfo_PBS & jinfo);
3675 // Methodes pour l'interfacage avec Python (SWIG)
3676 string __str__() const; // SWIG : affichage en Python
3677 string __repr__() const; // SWIG : affichage en Python
3680 Parametre _param; // parametres du job
3681 Environnement _env; // variables d'environnement du job
3690 @dots{} (ici on cree un BatchManager bm et un Job job)
3692 // On soumet le job et on recupere un identifiant
3693 JobId jobid = bm.submitJob(job);
3695 // Ce qui permet d'interroger l'etat du job en cours
3696 // Nota : l'objet retourne est un JobInfo_PBS
3697 JobInfo jinfo = jobid.queryJob();
3707 Ce constructeur cree un objet @emph{JobInfo_PBS} vide.
3712 Le destructeur libere l'espace memoire alloue pour l'objet si la
3713 desollacation n'a pas eu deja lieu dans le constructeur.
3716 @b{JobInfo_PBS(const JobInfo_PBS & jinfo)}
3718 Le constructeur par recopie produit un objet identique a celui passe en
3719 argument. Les deux objets sont totalement independants l'un de l'autre.
3722 @b{JobInfo_PBS(struct batch_status * stat_list, bool tobedeleted = false)}
3724 Ce constructeur recupere une liste chainee du type interne OpenPBS
3725 @emph{struct batch_status *}, la parcoure et l'analyse pour en extraire
3726 les informations utilisables par la bibliotheque de classes et les
3727 stocker dans deux objets internes @emph{Parametre} et
3728 @emph{Environnement}.
3730 Si le parametre @emph{tobedeleted} vaut @emph{true} alors la liste
3731 chainee @emph{stat_list} sera desallouee a la fin du constructeur. Sinon
3732 elle sera desalloue dans le destructeur au plus tard.
3735 @b{string __str__() const}
3737 Cette methode n'est utile que pour l'interfacage avec Python. Elle
3738 permet d'afficher l'etat de l'objet @emph{JobInfo}.
3741 @b{string __repr__() const}
3743 Cette methode n'est utile que pour l'interfacage avec Python. Elle
3744 permet d'afficher l'etat de l'objet @emph{JobInfo}.
3751 @c ----------------------
3752 @c ----------------------
3753 @c ----------------------
3756 @node Classe Job_PBS, Classes Python, Classe JobInfo_PBS, Classes PBS
3757 @comment node-name, next, previous, up
3759 @subsubsection Job_PBS
3762 Un objet de classe @emph{Job} possede une structure generique
3763 potentiellement utilisable par tout gestionnaire de batch mais pas en
3764 l'etat. Une conversion dans un format lisible par le gestionnaire doit
3767 Ceci se fait en produisant a partir des donnees generiques de la classe
3768 @emph{Job} des structures de donnees specifiques qui peuvent etre
3769 directement passees a l'API du gestionnaire.
3771 La classe @emph{Job_PBS} se distingue donc de la classe @emph{Job} par son
3772 constructeur et par des accesseurs specifiques qui produisent des
3773 donnees lisibles par OpenPBS.
3775 Etant donnee la specificite de cette classe, elle ne devrait concerner
3776 que les developpeurs de la bibliotheque de classes Batch.
3785 // Constructeurs et destructeur
3786 Job_PBS(const Job & job);
3790 struct attropl * getAttributesOP();
3791 struct attrl * getAttributes();
3793 char * getDestination();
3796 struct attropl * _p_attropl; // liste d'attributs + operateur
3797 struct attrl * _p_attrl; // liste d'attributs
3798 char * _script; // chemin d'acces au script du job
3799 char * _destination; // queue dans laquelle le job est soumis
3814 @dots{} (ici on cree les parametres du job)
3816 Job job(param, env);
3818 // On fabrique un job specifique a OpenPBS a partir du job generique
3819 // Ceci ne concerne en general pas l'utilisateur de la bibliotheque
3820 Job_PBS jobpbs(job);
3829 @b{Job_PBS(const Job & job)}
3831 Le constructeur convertit les objets internes @emph{Parametre} et
3832 @emph{Environnement} de l'objet passe en argument en un ensemble de
3833 quatre structures C @emph{AttributesOP}, @emph{Attributes},
3834 @emph{Script} et @emph{Destination} directement utilisable par l'API de
3840 Le destructeur libere simplement les espaces alloues pour les structures
3841 @emph{AttributesOP}, @emph{Attributes}, @emph{Script} et
3845 @b{struct attropl * getAttributesOP()}
3847 Cet accesseur retourne un pointeur sur la structure interne
3848 @emph{AttributesOP} de l'objet. Cette structure n'est pas protogee
3849 contre les modifications accidentelles de l'utilisateur. Par consequent
3850 il est recommande d'eviter d'y apporter toute alteration sous peine de
3853 Pour la definition de la structure @emph{AttributesOP}, voir la
3854 documentation OpenPBS.
3857 @b{struct attrl * getAttributes()}
3859 Cet accesseur retourne un pointeur sur la structure interne
3860 @emph{Attributes} de l'objet. Cette structure n'est pas protogee
3861 contre les modifications accidentelles de l'utilisateur. Par consequent
3862 il est recommande d'eviter d'y apporter toute alteration sous peine de
3865 Pour la definition de la structure @emph{Attributes}, voir la
3866 documentation OpenPBS.
3869 @b{char * getScript()}
3871 Cet accesseur retourne un parametre @emph{Script} qui est une chaine de
3872 caracteres C contenant le chemin absolu (sur la machine d'execution)
3873 du script a soumettre au gestionnaire de batch.
3875 Cette chaine n'est pas protegee contre les modifications accidentelles
3876 de l'utilisateur. Il est donc recommande de ne pas y apporter de modification.
3879 @b{char * getDestination()}
3881 Cet accesseur retourne un parametre @emph{Destination} qui est une chaine de
3882 caracteres C contenant le nom de la queue, ou classe ou file selon les terminologies,
3883 du gestionnaire de batch dans laquelle le job doit etre soumis.
3885 Cette chaine n'est pas protegee contre les modifications accidentelles
3886 de l'utilisateur. Il est donc recommande de ne pas y apporter de modification.
3893 @c ----------------------
3894 @c ----------------------
3895 @c ----------------------
3897 @node Classes Python, Classe PyVersatile, Classe Job_PBS, Classes specifiques
3898 @comment node-name, next, previous, up
3900 @subsection Classes Python
3901 @cindex classes Python
3903 L'integration de la bibliotheque de classes Batch dans l'interpreteur
3904 Python a beaucoup progresse depuis la precedente version et se trouve
3905 etre quasiment iso-fonctionelle avec le C++.
3907 Actuellement, l'interface avec Python s'appuie a la fois sur les
3908 fonctionnalites de l'utilitaire SWIG, et sur la definition d'une classe
3909 specifique qui permet de voir en Python la classe @emph{Versatile}.
3911 Certaines classes ont de plus des methodes specifiques pour le wrapping
3912 Python qui simplifient grandement le developpement des classes
3913 d'interface au detriment, il est vrai, d'une bonne independance entre
3914 les langages. Ce choix n'est pas definitif et pourra etre revu si
3915 l'occasion s'en presente.
3917 Quoi qu'il en soit toutes les classes de haut niveau sont interfacees en
3918 Python sous le meme nom et proposent les memes methodes (sauf celles
3919 surchargees en C++ qui sot parfois renommees pour lever
3920 l'ambiguite). Pour ne pas refaire un expose detaille et fastidieux des
3921 fonctionnalites Python de la bibliotheque de classes, il est propose de
3922 retrouver les noms et la syntaxe de ces classe dans la partie
3923 Utilisation de ce document. @xref{Utilisation}.
3926 * Classe PyVersatile:: Description de la classe PyVersatile.
3929 @c ----------------------
3930 @c ----------------------
3931 @c ----------------------
3934 @node Classe PyVersatile, Utilisation, Classes Python, Classes Python
3935 @comment node-name, next, previous, up
3937 @subsubsection PyVersatile
3941 La classe @emph{PyVersatile} derive de la classe @emph{Versatile} et
3942 offre la possibilite de convertir un tel objet en objet Python et
3950 class PyVersatile : public Versatile
3953 // Constructeur a partir d'un objet Versatile
3954 PyVersatile(const Versatile &);
3956 // Constructeur a partir d'un PyObject
3957 PyVersatile(const PyObject *) throw(TypeMismatchException,
3958 ListIsFullException,
3959 InvalidArgumentException);
3961 // Conversion de type vers un PyObject
3962 operator PyObject *() const;
3964 // Operateur d'affectation a partir d'un objet Versatile
3965 PyVersatile & operator =(const Versatile &);
3979 // On cree un objet Versatile contenant
3980 // une liste de chaine de caracteres
3984 // On convertit cet objet Versatile en PyVersatile
3987 // De la on produit un objet Python
3988 // qui est une liste de chaine de caracteres
3989 PyObject * PyO = PyV;
3998 @b{PyVersatile(const Versatile &)}
4000 Ce constructeur convertit un objet @emph{Versatile} en objet @emph{PyVersatile}.
4003 @b{PyVersatile(const PyObject *) throw(TypeMismatchException, ListIsFullException, InvalidArgumentException)}
4005 Ce constructeur convertit un objet Python passe en argument en un objet
4008 Seuls certains objets Python peuvent etre convertis : les @emph{string}
4009 et les @emph{long}, ainsi que les listes homogenes de ces types, ce qui
4010 est coherent avec la nature de l'objet @emph{Versatile}. Si tel n'est
4011 pas le cas, une exception Python est renvoyee a l'interpreteur.
4015 @b{operator PyObject *() const}
4017 Cet operateur convertit l'objet en objet Python. Selon le cas, l'objet
4018 retourne est soit un scalaire soit une liste. L'objet retourne est
4019 alloue dynamiquement et doit donc etre pris en charge par l'interpreteur.
4022 @b{PyVersatile & operator =(const Versatile &)}
4024 L'affectation d'un objet @emph{Versatile} passe en argument est
4025 similaire a l'affectation entre objets @emph{Versatile}. Les structures
4026 de donnees internes initiales de l'objet sont effacees et remplacees par
4027 une copie des donnees internes de l'objet passe en argument. Les deux
4028 objets restent independants l'un de l'autre a l'issue de l'affectation.
4036 @c ----------------------
4037 @c ----------------------
4038 @c ----------------------
4040 @node Utilisation, Connexion, Classe PyVersatile, Top
4041 @comment node-name, next, previous, up
4043 @chapter Utilisation
4046 Ce chapitre presente les differentes actions qu'il est possible de
4047 realiser avec les classes de la bilbiotheque.
4049 On presente un cas hypothetique ou un utilisateur voudrait soumettre et
4050 controler un job depuis un code C++. Les sections suivantes decrivent
4051 les operations a faire ainsi que leur action sur le travail soumis.
4054 * Connexion:: Creation d'un gestionnaire de batch.
4055 * Creation:: Declaration d'un job (travail).
4056 * Soumission:: Demande d'execution du job.
4057 * Interrogation:: Recuperation des informations sur le job.
4058 * Destruction:: Arret du job en cours.
4059 * Suspension:: Suspension du job en file d'attente.
4060 * Reprise:: Liberation du job en file d'attente.
4061 * Modification:: Modification d'un job en file d'attente.
4065 @c ----------------------
4066 @c ----------------------
4067 @c ----------------------
4069 @node Connexion, Creation, Utilisation, Utilisation
4070 @comment node-name, next, previous, up
4075 La premiere etape avant toute utilisation pratique des classes de la
4076 bibliotheque consiste a se connecter a un gestionnaire de batch.
4078 Ce concept de connexion est purement interne a la bibliotheque car il
4079 est tout a fait possible d'imaginer le controle de jobs a travers l'API
4080 d'un gestionnaire sans jamais etablir ni maintenir une quelconque
4081 connexion avec celui-ci. D'autres par contre reclament l'etablissement
4084 Quoiqu'il en soit ceci n'est pas genant et l'etablissement et le
4085 maintien de la connexion avec le gestionnaire de batch se fait par la
4086 creation d'un objet de classe @emph{BatchManager} ou d'une classe
4089 En pratique, la classe @emph{BatchManager} se comporte comme une
4090 interface et seules les classes d'implementation derivee doivent etre
4093 Si l'on prend le cas d'un serveur @samp{serveur.domaine.fr} supportant
4094 un gestionnaire de batch OpenPBS, on peut s'y connecter de la maniere
4101 BatchManagerCatalog cata;
4102 BatchManager_PBS & bm = * (* cata('PBS'))("serveur.domaine.fr");
4105 @item Exemple Python:
4108 cata = BatchManagerCatalog()
4109 bm = cata('PBS')('serveur.domaine.fr')
4114 Tant que l'objet @emph{bm} sera present --- tant que son destructeur
4115 n'aura pas ete appele --- la connexion sera maintenue. La deconnexion
4116 aura lieu a la destruction de l'objet.
4118 @xref{Classe BatchManager}.
4119 @xref{Classe BatchManager_PBS}.
4122 @c ----------------------
4123 @c ----------------------
4124 @c ----------------------
4126 @node Creation, Soumission, Connexion, Utilisation
4127 @comment node-name, next, previous, up
4131 La creation du job est l'etape qui precede toute soumission. Elle
4132 necessite de decrire d'un maniere ou d'un autre ce que l'on va demander
4133 a la machine d'executer.
4135 Pour cela on passe par deux objets intermediaires qui sont l'objet
4136 @emph{Parametre} et l'objet @emph{Environnement}.
4138 Le minimum a preciser est en general le chemin absolu d'acces a
4139 l'executable, quoique ceci depende fortement de la configuration du
4140 gestionnaire auquel on se connecte. Celui-ci peut reclamer des
4141 parametres supplementaires.
4143 Pour connaitre l'ensemble des parametres disponibles : @xref{Classe
4146 On supposera dans cet exemple que l'application en question sait
4147 reconnaitre une variable d'environnement @var{myapp_loglevel} qui prend
4148 une valeur numerique correspondant au niveau d'information affiche en
4151 Cette application imaginaire utilise egalement trois fichiers :
4155 un fichier d'entree nomme @file{Cas1.data} sur la machine locale qu'il
4156 faudra renommer @file{fort.9} pour que l'application puisse le lire
4157 (notre application imaginaire est ecrite en FORTRAN et attend un fichier
4158 d'entree sur son descripteur 9);
4161 un fichier de sortie standard que l'on voudra recuperer sous le nom
4165 un fichier d'erreur standard que l'on voudra recuperer sous le nom
4170 Le job est ensuite cree simplement a l'aide des deux objets precedents.
4177 param[EXECUTABLE] = "/home/user/my_app/bin/exec_app.sh";
4178 param[INFILE] = Couple("/home/user/my_app/data/Cas1.data","fort.9");
4179 param[OUTFILE] = Couple("/home/user/my_app/data/Cas1.out", "stdout"),
4180 Couple("/home/user/my_app/data/Cas1.err", "stderr");
4183 env["MYAPP_LOGLEVEL"] = "3";
4185 Job job(param, env);
4188 @item Exemple Python:
4192 param["EXECUTABLE"] = "/home/user/my_app/bin/exec_app.sh"
4193 param["INFILE"] = [ ("/home/user/my_app/data/Cas1.data","fort.9") ]
4194 param["OUTFILE"] = [ ("/home/user/my_app/data/Cas1.out", "stdout"),
4195 ("/home/user/my_app/data/Cas1.err", "stderr") ]
4198 env["MYAPP_LOGLEVEL"] = "3"
4201 job.setParametre(param)
4202 job.setEnvironnement(env)
4208 @xref{Classe Parametre}.
4209 @xref{Classe Environnement}.
4213 @c ----------------------
4214 @c ----------------------
4215 @c ----------------------
4217 @node Soumission, Interrogation, Creation, Utilisation
4218 @comment node-name, next, previous, up
4223 Une fois le job cree, il est alors tres simple de le soumettre au
4224 gestionnaire de batch en passant par l'intermediaire de l'objet
4225 @emph{BatchManager} cree precedemment.
4227 Cette soumission produira un objet @emph{JobId} qui servira a controler
4228 le job par la suite.
4230 Cependant des exceptions peuvent etre levees au moment de la soumission
4231 et il convient de fournir un gestionnaire d'exception pour gerer
4232 proprement ces incidents.
4239 const JobId jobid = bm.submitJob(job);
4241 @} catch (GenericException & ex) @{
4246 @item Exemple Python:
4250 jobid = bm.submitJob(job)
4259 @xref{Classe JobId}.
4263 @c ----------------------
4264 @c ----------------------
4265 @c ----------------------
4267 @node Interrogation, Destruction, Soumission, Utilisation
4268 @comment node-name, next, previous, up
4269 @section Interrogation
4270 @cindex interrogation
4273 La fourniture d'un objet @emph{JobId} permet d'avoir tout controle sur
4274 le job en cours. En particulier il est possible de l'interroger :
4275 ceci generera un objet @emph{JobInfo} qui donnera l'ensemble des
4276 informations disponibles sur l'etat du job aupres du gestionnaire de
4279 Ces informations sont disponibles a travers deux objets internes de
4280 classes @emph{Parametre} et @emph{Environnement}, les memes que pour la
4281 classe @emph{Job}, mais modifies et completes avec les donnees les plus
4282 a jour du gestionnaire de batch.
4289 const JobInfo jinfo = jobid.queryJob();
4291 Parametre newparam = jinfo.getParametre();
4292 Environnement newenv = jinfo.getEnvironnement();
4294 @} catch (GenericException & ex) @{
4299 @item Exemple Python:
4303 jobinfo = jobid.queryJob()
4305 newparam = jinfo.getParametre()
4306 newenv = jinfo.getEnvironnement()
4314 @xref{Classe JobId}.
4315 @xref{Classe JobInfo}.
4320 @c ----------------------
4321 @c ----------------------
4322 @c ----------------------
4324 @node Destruction, Suspension, Interrogation, Utilisation
4325 @comment node-name, next, previous, up
4326 @section Destruction
4332 Il est possible de detruire un job que celui-ci soit encore en file
4333 d'attente ou bien que son execution ait deja commence, auquel cas elle
4334 serait immediatement interrompue.
4344 @} catch (GenericException & ex) @{
4349 @item Exemple Python:
4362 @xref{Classe JobId}.
4367 @c ----------------------
4368 @c ----------------------
4369 @c ----------------------
4371 @node Suspension, Reprise, Destruction, Utilisation
4372 @comment node-name, next, previous, up
4377 La suspension consiste a figer en file d'attente un job qui n'aurait pas
4378 encore commence son execution. Il n'est pas possible de suspendre un job
4381 Il y a deux manieres de suspendre un job en file d'attente :
4383 @item en utilisant la methode @samp{holdJob};
4384 @item en modifiant les parametres du job a l'aide de la methode @samp{alterJob}.
4396 @} catch (GenericException & ex) @{
4401 @item Exemple Python:
4422 jobid.alterJob(altparam);
4424 @} catch (GenericException & ex) @{
4429 @item Exemple Python:
4432 // Compte tenu de la surcharge d'operateur, cet exemple peut ne pas
4433 // fonctionner encore
4436 altparam["HOLD"] = 1
4437 jobid.alterJob(altparam)
4447 @xref{Classe JobId}.
4451 @c ----------------------
4452 @c ----------------------
4453 @c ----------------------
4455 @node Reprise, Modification, Suspension, Utilisation
4456 @comment node-name, next, previous, up
4461 La reprise est l'operation inverse de la suspension en ceci qu'elle
4462 libere un job precedemment suspendu en file d'attente. Le job continuera
4463 alors son cheminement normal au sein du gestionnaire de batch.
4465 Il y a deux manieres de suspendre un job en file d'attente :
4467 @item en utilisant la methode @samp{releaseJob};
4468 @item en modifiant les parametres du job a l'aide de la methode @samp{alterJob}.
4480 @} catch (GenericException & ex) @{
4485 @item Exemple Python:
4506 jobid.alterJob(altparam);
4508 @} catch (GenericException & ex) @{
4513 @item Exemple Python:
4516 // Compte tenu de la surcharge d'operateur, cet exemple peut ne pas
4517 // fonctionner encore
4520 altparam["HOLD"] = 0
4521 jobid.alterJob(altparam)
4530 @xref{Classe JobId}.
4534 @c ----------------------
4535 @c ----------------------
4536 @c ----------------------
4538 @node Modification, Installation de la bibliotheque, Reprise, Utilisation
4539 @comment node-name, next, previous, up
4540 @section Modification
4541 @cindex modification
4544 Il est possible de modifier tout ou partie des parametres et des
4545 variables d'un job a condition que celui-ci soit encore en file
4546 d'attente. Un job dont l'execution a deja debute devient inalterable,
4547 sauf a l'arreter definitvement.
4549 La modification se fait en declarant un objet @emph{Parametre} et/ou un
4550 objet @emph{Environnement} contenant l'ensemble des alterations a
4551 apporter a la description du job. Ces alterations peuvent porter sur des
4552 parametres ou des variables deja definies ou non.
4554 En reprenant le cas du job imaginaire utilise jusqu'ici, on peut
4555 souhaiter changer le script qui tient lieu d'executable car le precedent
4556 etait incomplet, modifier le niveau d'affichage de la log et ajouter une
4557 variable nommee @var{myapp_debug} qui indique au code de passer en mode
4558 debug. Ceci pourrait se faire de la maniere suivante :
4566 altparam[EXECUTABLE] = "/home/user/my_app/bin/exec_app.sh";
4568 Environnement altenv;
4569 altenv["MYAPP_LOGLEVEL"] = "4";
4570 altenv["MYAPP_DEBUG"] = "1";
4571 jobid.alterJob(altparam, altenv);
4573 @} catch (GenericException & ex) @{
4578 @item Exemple Python:
4581 // Compte tenu de la surcharge d'operateur, cet exemple peut ne pas
4582 // fonctionner encore
4585 altparam["EXECUTABLE"] = "/home/user/my_app/bin/exec_app.sh"
4588 altenv["MYAPP_LOGLEVEL"] = "4";
4589 altenv["MYAPP_DEBUG"] = "1";
4591 jobid.alterJob(altparam, altenv)
4600 @xref{Classe JobId}.
4603 @c ----------------------
4604 @c ----------------------
4605 @c ----------------------
4607 @node Installation de la bibliotheque, Prerequis, Modification, Top
4608 @comment node-name, next, previous, up
4609 @chapter Installation
4610 @cindex installation
4612 Cette section montre comment installer l'ensemble de la bibliotheque de
4613 classes Batch sur une machine Unix.
4617 * Installation rapide::
4620 * Compilation de la documentation::
4627 @c ----------------------
4628 @c ----------------------
4629 @c ----------------------
4631 @node Prerequis, Installation rapide, Installation de la bibliotheque, Installation de la bibliotheque
4632 @comment node-name, next, previous, up
4636 @unnumberedsubsec GCC/G++
4638 A l'heure actuelle, la bibliotheque de classes Batch est developpee en
4639 C++ et necessite de fait un compilateur pour ce langage. GCC/G++
4640 version 2.95.3 (@inforef{Top, ,gcc} pour plus de detail) ou une version
4641 ulterieure est un choix judicieux.
4643 @unnumberedsubsec Gestionnaires de batch
4645 Comme la bibliotheque utilise les fonctionnalites de certains
4646 gestionnaires de batch, il est indispensable de pouvoir acceder aux
4647 bibliotheques et aux fichiers d'entete de ces produits, ou du moins des
4648 produits dont on se servira par la suite, ceci pour pouvoir communiquer
4649 a travers l'API qu'ils ont developpe.
4651 Le cas le plus simple est d'avoir le produit directement installe sur la
4652 machine sur laquelle sera compilee la bibliotheque de classes Batch.
4654 @unnumberedsubsubsec OpenPBS
4658 A ce jour, seul le gestionnaire de batch PBS (OpenPBS et PBS Pro) est
4659 supporte (voir le site officiel @uref{http://www.openpbs.org}). Il doit
4660 avoir une version au moins egale a 2.3.16.
4662 @unnumberedsubsubsec LSF
4665 Il est prevu d'avoir un support de LSF dans les mois qui viennent.
4667 @unnumberedsubsubsec LoadLeveler
4670 Il est prevu d'avoir un support de LoadLeveler mais dans un futur plus
4671 lointain en fonction de la disponibilite du produit mais surtout d'une
4672 machine sur lequel il serait installe.
4674 @unnumberedsubsubsec Sun Grid Engine
4676 Ce choix-la est beaucoup plus hypothetique, et risque bien de ne jamais
4679 @unnumberedsubsubsec Rsh/Ssh
4681 Il est prevu de simuler le fonctionnement d'un gestionnaire de batch a
4682 l'aide de commandes Unix Rsh et Ssh dans la mesure de leurs capacites
4683 lorsque qu'il n'est pas possible d'avoir un gestionnaire de batch sur
4684 certaines machines ou de s'y connecter (par exemple lorsqu'on traverse
4687 @unnumberedsubsec Python
4690 Les classes de haut-niveau de la bibliotheque de classes Batch disposent
4691 d'une interface en Python qui leur permet d'etre utilisables dans ce
4692 langage. L'usage de cette fonctionnalite necessite d'avoir a disposition
4693 une version de Python (voir le site officiel
4694 @uref{http://www.python.org}) au moins egale a 2.2.
4696 @unnumberedsubsec SWIG
4699 De plus l'interfacage avec Python est automatise a l'aide de
4700 l'utilitaire SWIG (voir le site officiel @uref{http://www.swig.org}) qui
4701 transcrit les definitions des classes C++ en classes Python. Il faut
4702 pour cela disposer de la version 1.3.17 ou ulterieure.
4707 @c ----------------------
4708 @c ----------------------
4709 @c ----------------------
4711 @node Installation rapide, Configuration, Prerequis, Installation de la bibliotheque
4712 @comment node-name, next, previous, up
4713 @section Installation rapide
4714 @cindex installation rapide
4716 Il faut commencer par decompresser le fichier @file{.tar.gz} ou
4717 @file{.tgz} et descendre dans le repertoire qu'il a cree :
4720 $ tar -xzvf Batch-@value{VERSION}.tar.gz
4721 $ cd Batch-@value{VERSION}
4724 Pour ceux qui sont vraiment presses, le minimum requis est :
4732 Pour ceux qui ont le temps de lire la suite, les sections suivantes
4733 decrivent plus en detail ces etapes et les differents tests que l'on
4736 @c ----------------------
4737 @c ----------------------
4738 @c ----------------------
4740 @node Configuration, Compilation, Installation rapide, Installation de la bibliotheque
4741 @comment node-name, next, previous, up
4742 @section Configuration
4743 @cindex configuration
4745 La phase de configuration, tres classique dans le domaine des logiciels
4746 libres, est basee sur les produits autoconf (voir @inforef{Top,
4747 ,autoconf}), automake (voir @inforef{Top, ,automake}) et libtool (voir
4748 @inforef{Top, ,libtool}).
4750 La configuration est faite a l'aide du programme @file{configure}
4751 present dans le repertoire racine de la bibliotheque de classes
4752 Batch. Ce programme analyse l'ensemble des elements du systeme sur
4753 lequel se deroulera la compilation pour determiner les parametres
4754 optimaux et la presence de tous les produits necessaires a la
4757 On n'oubliera pas de se referer a la documentation de @file{configure}
4758 notamment pour determiner l'emplacement definitif de l'installation :
4761 $ ./configure --help
4764 C'est aussi au cours de cette phase de configuration qu'il est
4765 indispensable de preciser avec quelles options la bibliotheque doit etre
4766 generee. En particulier il est necessaire d'indiquer avec quel(s)
4767 gestionnaire(s) de batch doit se faire la compilation de maniere a avoir
4770 Par exemple dans le cas de OpenPBS, il est necessaire de preciser :
4773 $ ./configure --with-openpbs=/path/to/PBS/root/dir
4776 Le chemin @file{/path/to/PBS/root/dir} est optionnel si la variable
4777 d'environnement @var{openpbs} est definie avec cette meme valeur.
4779 De meme pour Python que l'on indique de la maniere suivante :
4782 $ ./configure --with-python=/path/to/Python/root/dir
4785 ou bien a l'aide de la variable d'environnement @var{pythonhome}.
4787 @c ----------------------
4788 @c ----------------------
4789 @c ----------------------
4791 @node Compilation, Compilation de la documentation, Configuration, Installation de la bibliotheque
4792 @comment node-name, next, previous, up
4793 @section Compilation
4796 La compilation proprement dite n'appelle pas de remarque particuliere :
4802 On n'oubliera pas d'utiliser les focntionnalites de chaque @file{make},
4803 comme par exemple la compilation parallele pour reduire les temps de
4804 compilation (voir @inforef{Top, ,make}).
4806 @c ----------------------
4807 @c ----------------------
4808 @c ----------------------
4810 @node Compilation de la documentation, Tests, Compilation, Installation de la bibliotheque
4811 @comment node-name, next, previous, up
4812 @section Compilation de la documentation
4813 @cindex compilation de la documentation
4815 Normalement la documentation est automatiquement compilee lors de la
4816 compilation de la bibliotheque, mais uniquement sous la forme d'un
4817 fichier @file{.info}. Il est egalement possible d'obtenir un fichier
4818 @file{.dvi} qui permettra de generer d'autres formats comme le
4819 PostScript (fichier @file{.ps}) ou le PDF (fichier @file{.pdf}), ou bien
4820 une documentation sous forme HTML (fichier @file{.html}).
4822 Pour fabriquer le fichier @file{.dvi} il faut executer la commande
4829 Il est alors possible de produire une documentation sous forme
4834 $ dvips Batch.dvi -o Batch.ps
4841 $ dvipdf Batch.dvi Batch.pdf
4844 Pour la documentation HTML, on l'obtient a l'aide de le commande
4849 $ texi2html -split_node Batch.texi
4852 @c ----------------------
4853 @c ----------------------
4854 @c ----------------------
4856 @node Tests, Installation, Compilation de la documentation, Installation de la bibliotheque
4857 @comment node-name, next, previous, up
4861 @unnumberedsubsec Tests de pre-installation
4863 La bibliotheque de classes Batch dispose d'un ensemble de tests
4864 unitaires pour verifier le fonctionnement de chaque classe
4865 individuellement. Ces tests ne sont pas compiles lors de la compilation
4866 de la bibliotheque; ils ne le sont qu'au moment du test.
4868 Les tests sont executes de la maniere suivante :
4874 A la fin des tests, un compte rendu est fait qui avertit l'utilisateur
4875 des tests reussis et des echecs rencontres. Chaque test peut etre rejoue
4876 individuellement en se placant dans le repertoire @file{test} et en
4877 executant les tests manuellement comme par exemple :
4884 @unnumberedsubsec Tests de post-installation
4886 Certains tests ne sont pas executes lorsque la commande @file{make
4887 check} est lancee car ceux-ci necessitent l'installation prealable de
4888 certains fichiers qui ne l'ont pas encore ete, l'installation definitive
4889 n'ayant pas eu lieu encore. C'est pour cela que ces tests ne doivent et
4890 ne peuvent etre lances qu'une fois l'installation terminee. @xref{Installation}.
4892 Il faut pour cela executer :
4898 De la meme maniere que pour les tests de pre-installation, une compte
4899 rendu est fait et les tests defaillants peuvent etre rejoues
4900 manuellement pour determiner le probleme.
4902 @c ----------------------
4903 @c ----------------------
4904 @c ----------------------
4906 @node Installation, Divers, Tests, Installation de la bibliotheque
4907 @comment node-name, next, previous, up
4908 @section Installation
4909 @cindex installation
4911 L'installation est la mise a disposition definitive dans le systeme de
4912 la bibliotheque de classes Batch. C'est la derniere etape de la
4913 procedure apres la configuration et la compilation.
4915 On l'execute de la maniere suivante :
4921 Tous les fichiers compiles, la bibliotheque et les fichiers d'entete
4922 sont installes dans le repertoire definitif. Les fichiers de test de
4923 post-installation sont egalement copies (@xref{Tests}.) ainsi que la
4934 @c ----------------------
4935 @c ----------------------
4936 @c ----------------------
4938 @node Divers, Index, Installation, Top
4939 @comment node-name, next, previous, up
4947 @c ----------------------
4948 @c ----------------------
4949 @c ----------------------
4951 @node Index, Top , Divers, Top
4952 @comment node-name, next, previous, up
4955 @heading Index des concepts
4958 @heading Index des fonctions et des methodes