source: ether_core/trunk/kit/interactifKit/zipContent/src/Trace.java @ 6

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

ajout rep ether
  • Property svn:executable set to *
File size: 13.1 KB
Line 
1/**
2* Traces
3*
4* @version $Id: Trace.java,v 1.1 2001/01/15 15:38:48 pn Exp $
5* @author ppa
6*/
7package fr.alcatel.ether.tools;
8
9import java.text.SimpleDateFormat;
10import java.util.Date;
11import java.io.*;
12import java.util.*;
13
14// ------------------------------------------------------------------------------------------
15// CLASSES LOCALES
16// ------------------------------------------------------------------------------------------
17
18/**
19* Cette classe définit un fichier de log ou de trace
20*
21* @since JDK 1.1.x
22* @author Franck Allimant, Alcatel TITN Answare
23*/
24class Fichier
25{
26        /** Nom complet avec chemin du fichier */
27        String filePath;
28       
29        /** Descripteur associé au fichier */
30        File file;
31       
32        /** PrintWriter ou sortir le texte */
33        PrintWriter out;
34       
35        /** Taille maximale de ce fichier */
36        int tailleMax;
37       
38        /**
39        * Créer un nouveau fichier
40        *
41        * @param filePath le chemin complet
42        * @param tailleMax la taille maximale en octets
43        */
44        public Fichier(String filePath, int tailleMax)
45        {
46                this.filePath = filePath;
47               
48                createFile();
49               
50                this.tailleMax = tailleMax;
51               
52                reset();
53        }
54       
55        /**
56        * Créer un nouveau fichier de trace à partir d'un PrintStream
57        * existant (System.out, par exemple)
58        *
59        * Les notions de taille n'ont pas de sens dans ce cas.
60        */
61        public Fichier(PrintStream ps)
62        {
63                file = null;
64               
65                out = new PrintWriter(ps);
66               
67                this.tailleMax = tailleMax;
68               
69                filePath = "<sortie standard>";
70        }
71       
72        /**
73        * Récupérer le nom du fichier
74        */
75        public String getNom()
76        {
77                return filePath;
78        }
79
80        /**
81        * Déterminer si la taille du fichier dépasse la taille fixée (taille > tailleMax)
82        * Un Fichier crée à partir d'un PrintStream n'est jamais plein.
83        *
84        * @return true si le fichier est 'plein', false sinon
85        */
86        public boolean isPlein()
87        {
88                if (file == null)
89                        return false;
90                else
91                        return file.length() > tailleMax;
92        }
93       
94        /**
95        * Réinitialiser le fichier. La méthode détruit, puis recrée le fichier sur le disque
96        * Sans effet sur un Fichier crée à partir d'un PrintStream
97        */
98        public void reset()
99        {
100                if ( file != null )
101                {       
102                        out.close();   
103                        file.delete();
104                        createFile();
105                }
106        }
107       
108        /**
109        * Créer le fichier sur le disque
110        *
111        * Sans effet sur un Fichier crée à partir d'un PrintStream
112        */
113        private void createFile()
114        {
115                file = new File(filePath);
116               
117                try
118                {
119                        out = new PrintWriter(new FileWriter(filePath, true));
120                }
121                catch (Exception ex)
122                {
123                        System.out.println("Impossible d'ouvrir le fichier de Trace/Log " + filePath + "\n(Utilisation de stdout)");
124                       
125                        out = new PrintWriter(System.out);
126                }
127        }
128       
129        /**
130        * Cette méthode permet l'écriture dans le fichier
131        *
132        * @param msg le message à écrire
133        */
134        public synchronized void doPrint(String msg)
135        {
136                if ( isPlein() == true )
137                        reset();
138                       
139                out.print(msg);
140                out.flush();
141        }
142
143        /**
144        * Cette méthode permet l'écriture dans le fichier
145        *
146        * @param msg le message à écrire
147        */
148        public synchronized void doPrintln(String msg)
149        {
150                if ( isPlein() == true )
151                                reset();
152                               
153                out.println(msg);
154                out.flush();
155        }
156}
157
158/**
159* Classe permettant d'effectuer les logs necessaires au debugging en cours de developpent
160* ainsi qu'au logs relatifs aux problemes survenants a l'utilisation.
161*
162* @since JDK 1.1.x
163* @version Projet Notifier $Id: Trace.java,v 1.1 2001/01/15 15:38:48 pn Exp $
164* @author
165*/
166public class Trace
167{
168        /** Format des dates */
169        //private static SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM HH:mm:ss");
170        private static SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM HH:mm:ss.SSS");
171
172        /** Stdout */
173        private static PrintStream out = System.out;
174       
175        /** Stderr */
176        private static PrintStream err = System.err;
177       
178        /** Pas de debug */
179        public static final int OFF = 4;
180       
181        /** Niveau de trace debug */
182        public static final int DEBUG = 3;
183       
184        /** Niveau de trace erreur */
185        public static final int ERREUR = 2;
186       
187        /** Niveau de trace système*/
188        public static final int SYSTEME = 1;
189       
190        /** Niveau de trace perf */
191        public static final int PERF = 0;
192       
193        /** Libellé de la ressource 'chemin d'accès au fichier de conf' */
194        private static final String path_conf_trace     = "path_conf";
195       
196        /** Libellé de la ressource 'niveau' */
197        private static final String libelleNiveau               = "niveau";
198       
199        /** Libellé de la ressource 'nom du fichier debug' */
200        private static final String libelleDebugFile    = "nomFichierDebug";
201       
202        /** Libellé de la ressource 'nom du fichier log' */
203        private static final String libelleLogFile              = "nomFichierLog";
204       
205        /** Libellé de la ressource 'taille max des fichiers */
206        private static final String libelleTailleMax    = "tailleMax";
207       
208        /** Niveau de debug par défaut */
209        private static final String niveauDefaut = "0000";
210       
211        /** Fichier de debug par défaut */
212        private static final String debugFileDefaut = "./debug.txt";
213       
214        /** Fichier de log par défaut */
215        private static final String logFileDefaut = "./log.txt";
216       
217        /** Taille max par défaut */
218        private static final int                tailleMaxDefaut = 50000;
219               
220        /** Mémorise les niveaux de debug actifs */
221        private static BitSet debugLevel = new BitSet();
222
223        /** Fichier de log */
224        private static Fichier logFile;
225       
226        /** Fichier de debug */
227        private static Fichier debugFile;
228       
229        /** Flag indiquant si le singleton a été initialisé */
230        private static boolean initialised = false;
231       
232        /** Préfixe à insérer devant le nom des ressources, si nécessaire */
233        private static String prefixe = null;
234       
235        /**
236        * Ecrire un message dans le fichier de log
237        *
238        * @param s le message à logger
239        */
240        public static void log(String s)
241        {
242                log(null, s);
243        }
244
245        /**
246        * Ecrire un message dans le fichier de log
247        * avec signature de l'objet
248        *
249        * @param o objet appelant
250        * @param s le message à logger
251        */
252        public static void log(Object o, String s)
253        {
254                initTrace();
255                logFile.doPrintln( header(o) + " : " + s );
256        }
257
258        /**
259        * Logger une exception sur le fichier log
260        *
261        * @param t l'exception à logger
262        */
263        public static void log(Throwable t)
264        {
265                log(null, t);
266        }
267
268        /**
269        * Logger une exception sur le fichier log
270        *
271        * @param t l'exception à logger
272        * @param o objet appelant
273        */
274        public static void log(Object o, Throwable t)
275        {
276                initTrace();
277                logFile.doPrintln( header(o) + " : " + t.toString() );
278                t.printStackTrace( logFile.out );
279        }
280
281
282        /**
283        * Logger une exception sur le fichier log
284        * avec un message supplemantaire
285        *
286        * @param t l'exception à logger
287        * @param s le message à ajouter
288        * @param o objet appelant
289        */
290        public static void log(Object o, String s, Throwable t)
291        {
292                initTrace();
293                logFile.doPrintln( header(o) + " : " + s + "\r\n" + t);
294                t.printStackTrace(logFile.out);
295        }
296               
297        /**
298        * Imprime le message passe ainsi que le header de l'objet depuis lequel se fait la trace.
299        *
300        * @param obj, ou null si aucun
301        * @param mess
302        * @param t l'exception à logger, ou null si aucune
303        * @param level
304        */
305        public static void debug( int level, Object obj, String mess, Throwable t )
306        {
307                if ( !initialised ) initTrace();
308               
309                // Vérifier la valeur du paramètre level
310                if ( level < PERF || level > DEBUG ) level = DEBUG;
311
312                // Vérifier si ce niveau de debug est actif
313                if ( debugLevel.get( level ) == true )
314                {
315                        if (obj != null)
316                                mess = header(obj) + " : " + mess;
317
318                        if (t != null)
319                                mess = mess + "\r\n" + t;
320                               
321                        debugFile.doPrintln( mess );
322                       
323                        if (t != null)  t.printStackTrace(debugFile.out);
324                }       
325        }
326       
327
328        /**
329        * Ecrire un message de niveau DEBUG dans le fichier de trace, incluant
330        * la signature d'un objet, un message, et une exception.
331        *
332        * @param t l'exception à logger
333        * @param s le message à ajouter
334        * @param o objet appelant
335        */
336        public static void debug( Object o, String s, Throwable t )
337        {
338                debug( DEBUG, o, s, t );
339        }
340
341        /**
342        * Ecrire un message de niveau donné en incluant la signature d'un objet
343        *
344        * @param level  Le niveau du message
345        * @param obj            L'objet dont on veut inclure la signature
346        * @param mess           Le message à écrire
347        */
348        public static void debug( int level, Object obj, String mess )
349        {
350                debug(level, obj, mess, null );
351        }
352       
353        /**
354        * Ecrire un message de niveau Debug en incluant la signature d'un objet
355        *
356        * @param obj l'objet dont on veut inclure la signature
357        * @param mess   Le message à écrire
358        */
359        public static void debug( Object obj, String mess )
360        {
361                debug( DEBUG, obj, mess, null );
362        }
363               
364        /**
365        * Ecrire un message de niveau donné dans le fichier de debug
366        *
367        * @param niveau Le niveau du message (DEBUG, ERREUR, SYSTEME, PERF)
368        * @param mess           Le message à écrire
369        */
370        public static void debug(int niveau, String mess)
371        {
372                debug(niveau, null, mess, null );
373        }
374
375        /**
376        * Ecrire un message de niveau DEBUG
377        *
378        * @param mess Le message à écrire
379        */
380        public static void debug( String mess)
381        {
382                debug( DEBUG, null, mess, null );
383        }
384
385        /**
386        * Lit une property de type entier
387        *
388        * @param nom le nom de la porperty
389        * @param defaut une valeur poar défaut en cas de problème
390        */
391        private static  int readProperty(String nom, int defaut)
392        {
393                String value = System.getProperty(nom);
394               
395                if (value != null)
396                {       
397                        try
398                        {
399                                return Integer.parseInt(value);
400                        }
401                        catch (NumberFormatException nfe)
402                        {
403                                System.out.println("La ressource " + nom + " doit être numerique. Utilisation de la valeur par defaut (" + defaut + ")");
404                        }
405                }
406                else
407                {
408                        System.out.println( "Par défaut, " + nom + " = " + defaut );
409                }
410                                       
411                return defaut;
412               
413        }
414
415               
416// ------------------------------------------------------------------------------------------
417// METHODES SURCHARGEES ou IMPLEMENTEES
418// ------------------------------------------------------------------------------------------
419       
420// ------------------------------------------------------------------------------------------
421// METHODES PRIVEES
422// ------------------------------------------------------------------------------------------
423
424       
425       
426        /**
427        * Methode permettant a la classe de s'initialisaer, en particulier de
428        * charger le fuchier de conf
429        */
430        private static void initTrace()
431        {
432                Properties props;               // Les propriétés système
433                String nomFichierTrace; // Nom du fichier de debug
434                String nomFichierLog;           // Nom du fichier de log
435                String niveau;                          // Niveau de trace
436                int tailleMax;                          // Taille max des fichiers
437               
438                String resNiveau;                       // Libellé de la ressource 'Niveau de debug'
439                String resDebugFile;    // Libellé de la ressource 'Nom fichier debug'
440                String resLogFile;              // Libellé de la ressource 'Nom fichier log'
441                String resTailleMax;    // Libellé de la ressource 'Taille max'
442               
443                // Si la classe n'a pas déjà été initialisée   
444                if (! initialised)
445                {
446                        // Aucune trace par défaut
447                        debugLevel.clear( DEBUG );
448                        debugLevel.clear( ERREUR );
449                        debugLevel.clear( SYSTEME );
450                        debugLevel.clear( PERF );
451                       
452                        // Charger les propriétés:
453                        try
454                        {
455                                props = new Properties( System.getProperties() );                               
456                                props.load(new FileInputStream( System.getProperty( path_conf_trace ) ) );
457                                System.setProperties( props );
458                        }
459                        catch( Exception ex)
460                        {
461                                System.out.println( "Trace : impossible de charger le fichier de configuration.\n" + ex );                     
462                        }
463
464                        // Construire les libellés des ressources       
465                        if ( prefixe != null )
466                        {
467                                resNiveau = prefixe + "." + libelleNiveau;
468                                resDebugFile = prefixe + "." + libelleDebugFile;
469                                resLogFile = prefixe + "." + libelleLogFile;
470                                resTailleMax = prefixe + "." + libelleTailleMax;
471                        }
472                        else
473                        {
474                                resNiveau = libelleNiveau;
475                                resDebugFile = libelleDebugFile;
476                                resLogFile = libelleLogFile;
477                                resTailleMax = libelleTailleMax;
478                        }
479                       
480                        // Lire les valeurs correspondantes dans le fichier
481                        niveau                                  = readProperty( resNiveau                       , niveauDefaut );
482                        nomFichierTrace = readProperty( resDebugFile    , debugFileDefaut );
483                        nomFichierLog   = readProperty( resLogFile              , logFileDefaut ); 
484                        tailleMax                       = readProperty( resTailleMax  , tailleMaxDefaut );
485       
486                        // Lire les niveaux de trace demandés           
487                        char[] niv = niveau.toCharArray();
488       
489                        if ( niv.length >= 4 && niv[ DEBUG ] == '1' )
490                                        debugLevel.set( DEBUG );
491                        if ( niv.length >= 3 && niv[ ERREUR ] == '1' )
492                                        debugLevel.set( ERREUR );
493                        if ( niv.length >= 2 && niv[ SYSTEME ] == '1' )
494                                        debugLevel.set( SYSTEME );
495                        if ( niv.length >= 1 && niv[ PERF ] == '1' )
496                                        debugLevel.set( PERF );
497
498                        try
499                        {                                                                                               
500                                // Initialisation des fichiers:
501                                debugFile = new Fichier( nomFichierTrace, tailleMax );
502                                logFile = new Fichier( nomFichierLog, tailleMax );
503                        }
504                        catch(RuntimeException ex)
505                        {
506                                System.err.println("Erreur au cours de le création des fichiers de log/trace");
507                        }
508                                               
509                        initialised = true;
510                }
511        }
512
513
514        /**
515        * Methode qui imprime le header d'un objet:
516        * date et nom de classe
517        * @param Object
518        * @return String
519        */
520        static String header(Object o)
521        {
522                String objName;
523               
524                if (o != null)
525                {
526                        objName = o.getClass().getName();
527                       
528                        int p = objName.lastIndexOf('.');
529                       
530                        if (p != -1) objName = objName.substring(p + 1);
531                       
532                        objName = ", " + objName;
533                }
534                else
535                {
536                        objName = "";
537                }
538                       
539                return dateFormat.format(new Date()) + objName ;
540        }
541
542
543        /**
544        * Lit une property de type chaine
545        *
546        * @param nom le nom de la porperty
547        * @param defaut une valeur poar défaut en cas de problème
548        */
549        private static String readProperty(String nom, String defaut)
550        {
551                String value = System.getProperty(nom);
552               
553                if (value != null)
554                {       
555                        return value;
556                }
557                else
558                {
559                        System.out.println("Par défaut, " + nom + " = " + defaut );
560                }
561                                       
562                return defaut;
563        }
564
565        public static void getTrace( String pref )
566        {
567                if ( pref != null )
568                        prefixe = new String( pref );
569        }
570}
Note: See TracBrowser for help on using the repository browser.