source: ether_core/trunk/kit/interactifKit/zipContent/src/Service.java @ 784

Last change on this file since 784 was 6, checked in by cbipsl, 18 years ago

ajout rep ether
  • Property svn:executable set to *
File size: 18.7 KB
Line 
1/**
2 *      <p>La classe Service décrit un serice exécutable dans le cadre du système Ether.</p>
3 * @since JDK 1.2
4 * @version $Id: Service.java,v 1.1 2001/01/15 15:38:47 pn Exp $
5 * @author Phillip Link
6 */
7package fr.alcatel.ether.app.service;
8
9// JDK - exceptions
10import java.io.IOException;
11import java.io.FileNotFoundException;
12import java.lang.SecurityException;
13import java.rmi.RemoteException;
14import java.rmi.NotBoundException;
15import java.net.MalformedURLException;
16// JDK - rmi
17import java.rmi.Naming;
18// JDK - io
19import java.io.File;
20import java.io.InputStream;
21import java.io.PrintWriter;
22import java.io.FileOutputStream;
23import java.io.Serializable;
24import java.util.*;
25import java.math.BigDecimal;
26// Ether application classes
27import fr.alcatel.ether.app.user.User;
28import fr.alcatel.ether.app.data.EtherFileName;
29//import fr.alcatel.ether.app.order.Orderable;
30//import fr.alcatel.ether.app.exception.InvalidServiceManager;
31//import fr.alcatel.ether.app.exception.QuotaReached;
32//import fr.alcatel.ether.app.exception.InsufficientRights;
33// Ether utilities
34import fr.alcatel.ether.app.common.Config;
35import fr.alcatel.ether.tools.Trace;
36//import fr.alcatel.ether.tools.HTable;
37//import fr.alcatel.ether.tools.PumperThread;
38// Ether persistency
39//import fr.alcatel.ether.persistency.Persistent;
40//import fr.alcatel.ether.persistency.DatabaseException;
41//import fr.alcatel.ether.persistency.DatabaseTools;
42//import fr.alcatel.ether.persistency.PersistentPeer;
43//import fr.alcatel.ether.persistency.ConnectionPool;
44
45public class Service implements Serializable {
46        /** Flag for debugging */
47        protected boolean DEBUG = true;
48       
49        /**
50         *      <p>Les services Ether définissent 3 types de codes retour</p>
51         *      <dl>
52         *      <dt>OK</dt><dd>Le service s'est exécuté correctement</dd>
53         *      <dt>WARNING</dt><dd>Le service s'est exécuté avec des warnings ou des erreurs, mais produit un résultat</dd>
54         *      <dt>FATAL</dt><dd>Le service n'a pas pu s'exécuter</dd>
55         *      </dl>
56         */
57         public static final int OK                             = 0;
58         public static final int WARNING        = 1;
59         public static final int FATAL          = 2;
60       
61        /** Identifiant du service */
62        private int id;
63       
64        /** Version du service */
65        private String version;
66       
67        /** Etat du service */
68        private String state;
69       
70        /** Format de codage su service */
71        private String coding ;
72       
73        /** Concepteur du service */
74        private String designer;
75       
76        /** Information sur le service */
77        private String information ;
78       
79        /** Machine hébergant le service */
80        private String host;
81       
82        /** Chemin d'accès aux fichiers sources */
83        private String pathSourceFiles;
84       
85        /** Chemin d'accès aux fichiers exécutables */
86        private String pathExecFiles;
87       
88        /** Nom du fichier exécutable */
89        private String execFileName;
90       
91        /** Chemin complet et nom du fichier paramètre */
92        private String paramFile;       
93       
94        /** Url d'activation */
95        private String activationUrl;
96       
97        /** Drapeau indiquant si le service produit des commandes */
98        private boolean orderOut;
99               
100        /** quota par défaut */
101        private int DEFAULT_QUOTA = 5;
102       
103        /** coefficient par défaut */
104        private double DEFAULT_COEFFICIENT = 1.0 ;
105       
106        /** Nom du service (nom fichier exécutable) */
107        private String name;
108       
109        /** Description du service (brève chaîne décrivant le service) */
110        private String description;
111
112        /** Paramètres à appliquer au service */
113        private String[] parameters;
114
115        /** Page de saisie des paramètres, ex : priv/param_selection.jsp */
116        private String parameterPage;
117               
118        /** Répertoire d'entrée du service */
119        private String inputPath;
120
121        /** Répertoire de sortie des résultats du service */
122        private String outputPath;
123
124        /** Répertoire de données des services CTSO */
125        private String dataPath;
126
127        /** Drapeau indiquant si le client du service veut garder les entrées */
128        private boolean keepOriginal = false;
129       
130        /** Drapeau indiquant si le service est interactif */
131//      private boolean interactif;
132       
133        /** Type du service, défini dans la classe ServiceType */
134        private String type ;
135       
136        /** Quota indiquant le nombre d'instances de ce service exécutant en simultané */
137        private int quota;
138       
139        /** Coefficient multiplicateur pour estimer la taille du résultat */
140        private double resultCoeff;
141       
142        /** Liste d'objets commandables (fichiers, ou jeux de données) */
143        private List files = Collections.synchronizedList( new ArrayList() );
144        /**
145        * Constructeur
146        *
147        */
148        public Service()
149        {
150                super();
151                Config.getConfig();
152                Trace.getTrace( "ether" );
153                String outPath = null;
154                init(outPath); 
155        }
156       
157        /**
158        * Constructeur
159        *
160        * @param id : l'identifiant du service
161        */
162        public Service(int id)
163        {
164                super();
165                Config.getConfig();
166                Trace.getTrace( "ether" );
167                String outPath = null;
168                init(outPath);
169                setId(id);
170        }
171       
172        /**
173        * Constructeur par copie
174        *
175        *
176        */
177        public Service( Service source )
178        {
179                super();
180                Config.getConfig();
181                Trace.getTrace( "ether" );
182                init( source );
183                setId( source.getId() );
184        }
185       
186        /**
187        * Constructeur
188        *
189        * @param id : l'identifiant du service
190        *       @param  outPath:        le répertoire de sortie des fichiers pour le service, peut être null
191        */
192        public Service(int id,String outPath)
193        {
194                super();
195                Config.getConfig();
196                Trace.getTrace( "ether" );
197                init(outPath);
198                setId(id);
199        }
200       
201       
202        /**
203         * <p>Initialisation du service (appelé par le constructeur)</p>
204         * <p>La variable outPath peut être null.</p>
205         *
206         *      @param  outPath:        le répertoire de sortie des fichiers pour le service, peut être null
207         */
208        protected void init(String outPath)
209        {
210                setActivationUrl(new String(""));
211                setCoding(new String(""));
212                setCoefficient(DEFAULT_COEFFICIENT);
213                setDescription(new String(""));
214                setDesigner(new String(""));
215                setExecFileName(new String(""));
216                setHost(new String(""));
217                setId(-1);
218                setInformation(new String(""));
219                // setInteractif(false);
220//              setType(ServiceType.BACKGROUND);
221                setKeepOriginal(false);
222                setName(new String(""));
223                setOrderOut(false);
224                if ( outPath != null )
225                {
226                        setOutputPath( outPath );
227                }
228                else
229                {
230                        setOutputPath(new String("")); 
231                }
232                setParameterPage("");
233                setParamFile(new String(""));
234                setPathExecFiles(new String(""));
235                setPathSourceFiles(new String(""));
236                setQuota(DEFAULT_QUOTA);
237                setState(new String(""));
238                setVersion(new String(""));
239                setParameters(null);
240        }
241       
242        /**
243        * Init à partir d'un autre service
244        *
245        */
246        protected void init(Service service)
247        {
248                setActivationUrl( service.getActivationUrl() );
249                setCoding( service.getCoding() );
250                setCoefficient( service.getCoefficient() );
251                setDescription( service.getDescription()  );
252                setDesigner( service.getDesigner() );
253                setExecFileName( service.getExecFileName() );
254                setHost( service.getHost() );
255                setId( service.getId() );
256                setInformation( service.getInformation() );
257//              setInteractif( service.getInteractif() );
258//              setType(service.getType());
259                setKeepOriginal( service.getKeepOriginal() );
260                setName( service.getName() );
261                setOrderOut( service.getOrderOut() );
262                if ( service.getOutputPath() != null )
263                {
264                        setOutputPath( new String( service.getOutputPath() ) );
265                }
266                else
267                {
268                        setOutputPath( "" );   
269                }
270                setParameterPage( service.getParameterPage() );
271                setParamFile( new String( service.getParamFile() ) );
272                setPathExecFiles( service.getPathExecFiles() );
273                setPathSourceFiles( service.getPathSourceFiles() );
274                setQuota( service.getQuota() );
275                setState( service.getState() );
276                setVersion( service.getVersion() );
277               
278                String[] srcParameters = service.getParameters();
279                String[] destParameters = null;
280                if ( srcParameters != null )
281                {
282                        destParameters = new String[ srcParameters.length ];
283                        for ( int i = 0; i < srcParameters.length; i++ )
284                        {
285                                destParameters[ i ] = new String( srcParameters[ i ] );
286                        }
287                }
288                setParameters( destParameters );
289        }
290       
291        /**
292         * Obtenir le nom du service.
293         *
294         *      @return le nom du service: l'exécutable à lancer
295         */
296        public String getName( ) {
297                return name;
298        }
299       
300       
301        /**
302         *      Mettre à jour le nom du service.
303         *
304         *      @param le nom du service
305         */
306        public void setName( String name ) {
307                this.name = name;
308        }
309       
310        /**
311         * Obtenir la chaîne de caractères décrivant brièvement ce service.
312         *
313         *      @return la description du service: chaîne de caractères imprimable
314         */
315        public String getDescription( ) {
316                return description;
317        }
318       
319       
320        /**
321         *      Mettre à jour la description du service.
322         *
323         *      @param la description du service
324         */
325        public void setDescription( String description ) {
326                this.description = description;
327        }
328
329        /**
330        *       Mettre à jour l'identifiant du service
331        *
332        * @param l'indentifiant
333        */
334        public void setId(int id)       {
335                this.id = id;
336        }
337       
338        /**
339        * Obtenir l'identifiant du service
340        *
341        * @return l'identifiant du service
342        */
343        public int getId(){
344                return id;
345        }
346
347        /**
348        * Mettre à jour la version du service
349        *
350        * @param la version du service
351        */
352        public void setVersion(String versionToSet){
353                this.version = versionToSet;
354        }
355       
356        /**
357        * Obtenir la version du service
358        *
359        * @return la version
360        */
361        public String getVersion(){
362                return version;
363        }
364               
365        /**
366        * Mettre à jour l'état du service
367        *
368        * @param l'état du service
369        */
370        public void setState(String stateToSet) {
371                this.state = stateToSet;
372        }
373       
374        /**
375        *       Obtenir l'état du service
376        *
377        * @return l'état du service
378        */
379        public String getState() {
380                return state;
381        }
382       
383        /**
384        *       Mettre à jour le codage du service
385        *
386        * @param le codage du service
387        */
388        public void setCoding(String codingToSet) {
389                coding = codingToSet;
390        }
391       
392        /**
393        * Obtenir le codage du service
394        *
395        * @return le codage du service
396        */
397        public String getCoding() {
398                return coding;
399        }
400               
401        /**
402        *       Mettre à jour le concepteur du service
403        *
404        * @param le concepteur du service
405        */
406        public void setDesigner(String designerToSet) {
407                designer = designerToSet;
408        }
409       
410        /**
411        * Obtenir le codage du service
412        *
413        * @return le codage du service
414        */
415        public String getDesigner()     {
416                return designer;
417        }
418
419        /**
420        *       Mettre à jour l'information du service
421        *
422        * @param l'information du service
423        */
424        public void setInformation(String infoToSet) {
425                information = infoToSet; 
426        }
427       
428        /**
429        *       Obtenir l'information du service
430        *
431        * @return l'information du service
432        */
433        public String getInformation() {
434                return information;
435        }
436
437        /**
438        * Mettre à jour la machine hébergant le service
439        *
440        * @param le nom de la machine hébergant le service
441        */
442        public void setHost(String hostToSet){
443                host = hostToSet;
444        }
445               
446        /*
447        * Obtenir le nom de la machine hébergant le service
448        *
449        * @return le nom de la machine
450        */
451        public String getHost() {
452                return host;
453        }
454       
455        /**
456        *       Mettre à jour le chemin d'accès aux fichiers sources du service
457        *
458        * @param le chemin d'accès
459        */
460        public void setPathSourceFiles(String pathSourceFilesToSet) {
461                pathSourceFiles = pathSourceFilesToSet;
462        }
463       
464        /*
465        * Obtenir le chemin d'accès aux fichiers sources du service
466        *
467        * @return le chemin d'accès
468        */
469        public String getPathSourceFiles() {
470                return pathSourceFiles;
471        }
472
473        /**
474        *       Mettre à jour le chemin d'accès aux fichiers exécutables du service
475        *
476        * @param le chemin d'accès
477        */
478        public void setPathExecFiles(String pathExecFilesToSet) {
479                pathExecFiles = pathExecFilesToSet;
480        }
481       
482        /*
483        * Obtenir le chemin d'accès aux fichiers exécutables du service
484        *
485        * @return le chemin d'accès
486        */
487        public String getPathExecFiles() {
488                return pathExecFiles;
489        }
490
491        /**
492        *       Mettre à jour le nom du fichier exécutable du service
493        *
494        * @param le nom du fichier exécutable
495        */
496        public void setExecFileName(String execFileNameToSet) {
497                execFileName = execFileNameToSet;
498        }
499       
500        /*
501        * Obtenir le nom du fichier exécutable du service
502        *
503        * @return le nom du fichier exécutable
504        */
505        public String getExecFileName() {
506                return execFileName;
507        }
508
509        /**
510        *       Mettre à jour le chemin d'accès aux fichiers exécutables du service
511        *
512        * @param le chemin d'accès
513        */
514        public void setParamFile(String paramFileToSet) {
515                paramFile = paramFileToSet;
516        }
517       
518        /*
519        * Obtenir le chemin d'accès aux fichiers exécutables du service
520        *
521        * @return le chemin d'accès
522        */
523        public String getParamFile() {
524                return paramFile;
525        }
526       
527        /**
528         * Obtenir les paramètres à utiliser lors de l'invocation du service.
529         *
530         *      @return liste des paramètres à fournir lors de l'exécution du service
531         *                                              (ou null s'il n'y a pas de paramètres).
532         */
533        public String[] getParameters( ) {
534                return parameters;
535        }
536       
537        /**
538        * Obtenir une liste de couples ( paramètre, valeur).
539        * Si le paramètre est de type "cle=valeur" alors il est inséré dans la table retourné.
540        * Sinon, il est bypassé.
541        *
542        * @return une hashMap contenant en clé : String paramètre
543        *                                                                                                                               en valeur : String valeur du paramètre
544        */
545        public HashMap getParametersTable() {
546                HashMap table = new HashMap();
547                String temp,first,second;
548                int index ;
549                if ( parameters != null )
550                {
551                        for ( int i = 0 ; i < parameters.length ; i++ )
552                        {
553                                temp = parameters[i];
554                                index = temp.indexOf('=');
555                               
556                                if ( index > 0)
557                                {
558                                        first = temp.substring(0,index);
559                                        if (index == (temp.length() - 1) )
560                                        {
561                                                // pas de valeur
562                                                second = new String("");
563                                        }
564                                        else
565                                        {
566                                                second = temp.substring(index + 1);
567                                        }
568                                        table.put(first,second);
569                                        if ( DEBUG ) Trace.debug(this,"INSERT INTO HASHMAP OF PARAMETER:"+ first + " WITH VALUE:" + second);
570                                }
571                        }
572                }
573               
574                return table;
575        }
576       
577       
578        /**
579        *       Mettre à jour les paramètres à utiliser lors de l'invocation du service.
580        *
581        * @param une hashMap contenant en clé : String paramètre
582        *                                                                                                                               en valeur : String valeur du paramètre
583        */
584        public void setParametersTable(HashMap table)
585        {
586                Set setTable = table.entrySet();
587                Iterator ite = setTable.iterator();
588                Map.Entry element;
589               
590                if ( setTable.size() == 0 )
591                {
592                        parameters = null ;
593                }
594                else
595                {
596                        parameters = new String[setTable.size()];
597                        int index = 0 ;
598                       
599                        while ( ite.hasNext() )
600                        {
601                                element = (Map.Entry) ite.next() ;
602                                parameters[index] = new String((String) element.getKey() + "=" + (String) element.getValue());
603                                if ( DEBUG ) Trace.debug(this,"ADDING INTO SERVICE , PARAMETER:" + parameters[index]); 
604                                index++;
605                        }
606                }
607        }
608       
609        /**
610         *      Mettre à jour les paramètres à utiliser lors de l'invocation du service.
611         *
612         *      @param liste des paramètres à fournir lors de l'exécution du service
613         */
614        public void setParameters( String[] parameters ) {
615                this.parameters = parameters;
616        }
617
618        /**
619         *      Obtenir l'url d'activation du service.
620         *
621         *      @return l'url d'activation de ce service
622         */
623        public String getActivationUrl( ) {
624                return activationUrl;
625        }
626       
627        /**
628         *      Mettre à jour l'url d'activation du service.
629         *
630         *      @param l'url d'activation
631         */
632        public void setActivationUrl( String url ) {
633                activationUrl = url;
634        }
635       
636        /**
637         *      <p>Obtenir le répertoire d'entrée du service.</p>
638         *      <p>Tous les fichiers nécessaires pour l'exécution de ce service
639         *      doivent être dans ce répertoire au début de l'exécution du service.</p>
640         *
641         *      @return le répertoire d'entrée du service
642         */
643        public String getInputPath( ) {
644                return inputPath;
645        }
646       
647       
648        /**
649         *      Mettre à jour le répertoire d'entrée du service.
650         *
651         *      @param le répertoire d'entrée du service
652         */
653        public void setInputPath( String inputPath ) {
654                this.inputPath = inputPath;
655        }
656
657        /**
658         *      <p>Obtenir le répertoire de sortie du service.</p>
659         *      <p>Tous les fichiers résultant de l'exécution de ce service
660         *      seront dans ce répertoire à la fin de l'exécution du service.</p>
661         *
662         *      @return le répertoire de sortie du service
663         */
664        public String getOutputPath( ) {
665                return outputPath;
666        }
667       
668       
669        /**
670         *      Mettre à jour le répertoire de sortie du service.
671         *
672         *      @param le répertoire de sortie du service
673         */
674        public void setOutputPath( String outputPath ) {
675                this.outputPath = outputPath;
676        }
677
678        /**
679         *      <p>Obtenir le répertoire de données pour les services CTSO.</p>
680         *
681         *      @return le répertoire de données pour les services CTSO
682         */
683        public String getDataPath( ) {
684                return dataPath;
685        }
686       
687       
688        /**
689         *      <p>Obtenir le répertoire de données pour les services CTSO.</p>
690         *
691         *      @param le répertoire de données pour les services CTSO
692         */
693        public void setDataPath( String dataPath ) {
694                this.dataPath = dataPath;
695        }
696
697        /**
698        * Indiquer si le service est intéractif
699        *
700        * @param interactif true si le service est intéractif,false sinon
701        */
702//      public void setInteractif(boolean interactifToSet) {
703//              interactif = interactifToSet;
704//      }
705               
706        /**
707        * Obtenir si le service est intéractif
708        *
709        * @return true si le service est intéractif,false sinon
710        */
711        public boolean getInteractif() {
712//              return ServiceType.isInteractif(getType());
713                return true;
714        }
715
716        /**
717        * Indiquer si le service produit des commandes
718        *
719        * @param orderOutToSet true si le service est produit des commandes,false sinon
720        */
721        public void setOrderOut(boolean orderOutToSet) {
722                orderOut = orderOutToSet;
723        }
724               
725        /**
726        * Savoir si le service est produit des commandes
727        *
728        * @return true si le service produit des commandes,false sinon
729        */
730        public boolean getOrderOut() {
731                return orderOut;
732        }
733       
734        /**
735         *      Vérifier si le client veut garder les fichiers d'origine.
736         *
737         *      @return drapeau indiquant si le client souhaite garder les fichiers d'origine
738         */
739        public boolean getKeepOriginal( ) {
740                return keepOriginal;
741        }
742       
743        /**
744         *      Vérifier si le client veut garder les fichiers d'origine.
745         *
746         *      @param keepOriginal     drapeau indiquant si le client souhaite garder les fichiers d'origine
747         */
748        public void setKeepOriginal( boolean keepOriginal ) {
749                this.keepOriginal = keepOriginal;
750        }
751       
752        /**
753        * Obtenir la page de sélection des paramètres si elle existe.
754        *
755        * @return la page jsp de sélection des paramètres (avec son chemin d'accés)
756        *                                                                                                       ex : priv/param_selection.jsp
757        */
758        public String getParameterPage() {
759                return parameterPage ;         
760        }
761               
762       
763        /**
764        * Mettre à jour la page de sélection des paramètres.
765        *
766        * @param la page jsp de sélection des paramètres (avec son chemin d'accés)
767        *                                                                                                       ex : priv/param_selection.jsp
768        */
769        public void setParameterPage(String page) {
770                this.parameterPage = page ;             
771        }
772       
773        /**
774        * Obtenir le type du service
775        *
776        */
777        public String getType()
778        {
779                return type;
780        }
781       
782        /**
783        * Mettre  à jour le type du service
784        *
785        */
786        public void setType(String type)
787        {
788                this.type = type;
789        }
790       
791       
792        /**
793         *      Obtenir le coefficient multiplicateur utilisé pour estimer la taille
794         *      d'un fichier de sortie après exécution du service.
795         *
796         *      @return drapeau indiquant si le client souhaite garder les fichiers d'origine
797         */
798        public double getCoefficient( ) {
799                return resultCoeff;
800        }
801       
802        /**
803         *      Mettre à jour le coefficient multiplicateur utilisé pour estimer la taille
804         *      des fichiers de sortie.
805         *
806         *      @param resultCoeff:     le coefficient multiplicateur.
807         */
808        public void setCoefficient( double resultCoeff ) {
809                this.resultCoeff = resultCoeff;
810        }
811       
812       
813        /**
814         *      Obtenir le quota (nombre d'instances autorisées à exécuter simultanément)..
815         *
816         *      @return drapeau indiquant si le client souhaite garder les fichiers d'origine
817         */
818        public int getQuota( ) {
819                return quota;
820        }
821       
822        /**
823         *      Mettre à jour le quota pour ce service.
824         *
825         *      @param le nombre d'instances du service autorisées à exécuter simultanément
826         */
827        public void setQuota( int quota ) {
828                this.quota = quota;
829        }
830       
831        /**
832         * Obtenir une représentation en chaîne de caractères de ce service.
833         *
834         *      @return la représentation chaîne de caractèrs du service
835         */
836        public String toString( ) {
837                return description + " (" + getName() + ")";
838        }
839
840       
841}
Note: See TracBrowser for help on using the repository browser.