Subversion Repositories Applications.framework

Rev

Rev 467 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 467 Rev 476
1 
<?php
 1 
<?php
2 
// declare(encoding='UTF-8');
 2 
// declare(encoding='UTF-8');
3 
/**
 3 
/**
4 
 * Classe de gestion des exceptions.
 4 
 * Classe de gestion des exceptions.
5 
 * C'est un Singleton.
 5 
 * C'est un Singleton.
6 
 *
 6 
 *
7 
 * @category	PHP 5.2
 7 
 * @category	PHP 5.2
8 
 * @package	Framework
 8 
 * @package		Framework
9 
 * @author		Aurélien PERONNET <aurelien@tela-botanica.org>
 9 
 * @author		Aurélien PERONNET <aurelien@tela-botanica.org>
10 
 * @author		Jean-Pascal MILCENT <jmp@tela-botanica.org>
 10 
 * @author		Jean-Pascal MILCENT <jmp@tela-botanica.org>
11 
 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
 11 
 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
12 
 * @license	http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 - 
 
13 
 * @license	http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 12 
 * @license		GNU-GPL-v3 <http://www.gnu.org/licenses/gpl.html>
14 
 * @version	$Id: GestionnaireException.php 342 2011-06-06 13:58:53Z jpm $$
 13 
 * @license		CECILL-v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt>
15 
 * @link		/doc/framework/
 - 
 
16 
 *
 - 
 
17 
 */
 14 
 */
18 
class GestionnaireException {
 15 
class GestionnaireException {
19
16 
 
20 
	const MODE_CLI = 'cli';
 17 
	const MODE_CLI = 'cli';
21
18 
 
22 
	/** Liste des exceptions enregistrées */
 19 
	/** Liste des exceptions enregistrées */
23 
	private static $exceptions = array();
 20 
	private static $exceptions = array();
24 
 
 21 
 
25 
	/** Détermine si l'on affiche ou non le contexte */
 22 
	/** Détermine si l'on affiche ou non le contexte */
26 
	private static $contexte = false;
 23 
	private static $contexte = false;
27 
 
 24 
 
28 
	 /** Détermine si l'on loggue ou non les erreurs */
 25 
	 /** Détermine si l'on loggue ou non les erreurs */
29 
	private static $logger = false;
 26 
	private static $logger = false;
30 
 
 27 
 
31 
	/** Détermine si l'affichage des erreurs est forcé (true) ou pas (false) à la destruction de la classe */
 28 
	/** Détermine si l'affichage des erreurs est forcé (true) ou pas (false) à la destruction de la classe */
32 
	private static $afficher = false;
 29 
	private static $afficher = false;
33 
 
 30 
 
34 
	/** Definit si php est lancé en ligne de commande ou en mode serveur */
 31 
	/** Definit si php est lancé en ligne de commande ou en mode serveur */
35 
	private static $mode = null ;
 32 
	private static $mode = null ;
36 
 
 33 
 
37 
	/** Initialise le Gestionnaire d'exceptions et d'erreur sans tenir comptes des paramêtres de config. */
 34 
	/** Initialise le Gestionnaire d'exceptions et d'erreur sans tenir comptes des paramêtres de config. */
38 
	public static function initialiser() {
 35 
	public static function initialiser() {
39 
		self::$mode = php_sapi_name();
 36 
		self::$mode = php_sapi_name();
40 
		// Désactivation des balises HTML dans les messages d'erreur de PHP en mode ligne de commande
 37 
		// Désactivation des balises HTML dans les messages d'erreur de PHP en mode ligne de commande
41 
		if (self::$mode == self::MODE_CLI) {
 38 
		if (self::$mode == self::MODE_CLI) {
42 
			ini_set('html_errors', 0);
 39 
			ini_set('html_errors', 0);
43 
		}
40 
		}
44
41 
 
45 
		set_exception_handler(array(get_class(),'gererException'));
 42 
		set_exception_handler(array(get_class(),'gererException'));
46 
		set_error_handler(array(get_class(),'gererErreur'));
 43 
		set_error_handler(array(get_class(),'gererErreur'));
47 
	}
 44 
	}
48
45 
 
49 
	/** Configure le Gestionnaire d'exceptions et d'erreur à partir des paramêtres de config. */
 46 
	/** Configure le Gestionnaire d'exceptions et d'erreur à partir des paramêtres de config. */
50 
	public static function configurer() {
 47 
	public static function configurer() {
51 
		self::$contexte = Config::get('fw_debogage_contexte');
 48 
		self::$contexte = Config::get('fw_debogage_contexte');
52 
		self::$logger = Config::get('fw_log_debogage');
 49 
		self::$logger = Config::get('fw_log_debogage');
53 
		self::$afficher = Config::get('fw_debogage');
 50 
		self::$afficher = Config::get('fw_debogage');
54 
	}
 51 
	}
55
52 
 
56 
	/**
 - 
 
57 
	 * Renvoie le nombre d'exceptions et d'erreurs levées.
 - 
 
58 
	 * @see getExceptions() pour obtenir les exceptions formatées.
 - 
 
59 
	 * @since 0.3
- 
 
60 
	 * @return int le nombre d'exception actuellement levées
 - 
 
61 
	 */
 - 
 
62 
	public static function getExceptionsNbre() {
 - 
 
63 
		return count(self::$exceptions);
 - 
 
64 
	}
 - 
 
65
- 
 
66 
	/**
- 
 
67 
	 * Renvoie le booleen définissant si l'on affiche le contexte ou non
53 
	/** Renvoie le booleen définissant si l'on affiche le contexte ou non */
68 
	 * @return bool true si on affiche le contexte sinon false.
- 
 
69 
	 */
 - 
 
70 
	public static function getContexte() {
 54 
	public static function getContexte() {
71 
		return self::$contexte;
 55 
		return self::$contexte;
72 
	}
 56 
	}
73 
 
 57 
 
74 
	/**
 58 
	/**
75 
	 * Definit si l'on veut afficher le contexte ou non
 59 
	 * Definit si l'on veut afficher le contexte ou non
76 
	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
 60 
	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
77 
	 */
 61 
	 */
78 
	public static function setContexte($contexte) {
 62 
	public static function setContexte($contexte) {
79 
		self::$contexte = $contexte;
 63 
		self::$contexte = $contexte;
80 
	}
 64 
	}
81 
 
 65 
 
82 
	/**
 66 
	/**
83 
	 * Fonction de gestion des exceptions, remplace le handler par défaut.
 67 
	 * Fonction de gestion des exceptions, remplace le handler par défaut
84 
	 * Si une boucle génère de multiple exception (ou erreur) identique une seule sera stockée.
 - 
 
85 
	 * @param Exception $e l'exception à traiter
 68 
	 * @param Exception $e l'exception à traiter
86 
	 */
 69 
	 */
87 
	public static function gererException(Exception $e) {
 70 
	public static function gererException(Exception $e) {
88 
		$cle = hash('md5', $e->getMessage().'-'.$e->getFile().'-'.$e->getLine());
 71 
		// pour le moment on se contente de l'ajouter au tableau et de les afficher
89 
		if (!isset(self::$exceptions[$cle])) {
 72 
		self::$exceptions[] = $e;
90 
			self::$exceptions[$cle] = $e;
 73 
		// Log si nécéssaire
91 
			self::loggerException($e);
 74 
		self::loggerException($e);
92 
		}
 - 
 
93 
	}
 75 
	}
94 
 
 76 
 
95 
	/**
 77 
	/**
96 
	 * Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)
 78 
	 * Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)
97 
	 * @param int $niveau le niveau de l'erreur
 79 
	 * @param int $niveau le niveau de l'erreur
98 
	 * @param string $message le message associé à l'erreur
 80 
	 * @param string $message le message associé à l'erreur
99 
	 * @param string $fichier le nom du fichier où l'erreur s'est produite
 81 
	 * @param string $fichier le nom du fichier où l'erreur s'est produite
100 
	 * @param int $ligne la ligne où l'erreur s'est produite
 82 
	 * @param int $ligne la ligne où l'erreur s'est produite
101 
	 * @param string $contexte le contexte associé à l'erreur
 83 
	 * @param string $contexte le contexte associé à l'erreur
102 
	 */
 84 
	 */
103 
	public static function gererErreur($niveau,  $message,  $fichier,  $ligne,  $contexte){
 85 
	public static function gererErreur($niveau,  $message,  $fichier,  $ligne,  $contexte){
104 
		// Si un rapport d'erreur existe, création d'une exception
 86 
		// Si un rapport d'erreur existe, création d'une exception
105 
		if (error_reporting() != 0) {
 87 
		if (error_reporting() != 0) {
106 
			$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);
 88 
			$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);
- 
 
 89 
			// que l'on donne au tableau d'exceptions
- 
 
 90 
			self::$exceptions[] = $e;
- 
 
 91 
			// Log si nécéssaire
107 
			self::gererException($e);
 92 
			self::loggerException($e);
108 
		}
 93 
		}
109 
		return null;
 94 
		return null;
110 
	}
 95 
	}
111 
 
 96 
 
112 
	/**
 97 
	/**
113 
	 * Renvoie les exceptions au format (X)HTML ou bien au format texte suivant le mode d'utilisation de PHP.
 - 
 
114 
	 * @since 0.3
 - 
 
115 
	 * @deprecated
 - 
 
116 
	 * @see getExceptionsFormatees()
 98 
	 * Renvoie les exceptions au format (X)HTML
117 
	 * @return string les exceptions formatées en texte ou (X)HTML.
 99 
	 * ou bien au format texte suivant le mode d'utilisation de PHP
118 
	 */
 100 
	 */
119 
	public static function getExceptions() {
 101 
	public static function getExceptions() {
120 
		return self::getExceptionsFormatees();
 - 
 
121 
	}
 - 
 
122
- 
 
123 
	/**
 - 
 
124 
	 * Renvoie les exceptions au format (X)HTML ou bien au format texte suivant le mode d'utilisation de PHP.
 - 
 
125 
	 * @since 0.3
 - 
 
126 
	 * @return string les exceptions formatées en texte ou (X)HTML.
 - 
 
127 
	 */
 - 
 
128 
	public static function getExceptionsFormatees() {
 - 
 
129 
		$retour = '';
 102 
		$retour = '';
130 
		if (self::getExceptionsNbre() > 0) {
 - 
 
131 
			foreach (self::$exceptions as $cle => $e) {
 103 
		foreach (self::$exceptions as $cle => $e) {
132 
				switch (self::$mode) {
 104 
			switch (self::$mode) {
133 
					case self::MODE_CLI :
 105 
				case self::MODE_CLI :
134 
						$retour .= self::formaterExceptionTxt($e);
 106 
					$retour .= $e->getMessage()."\n";
135 
						break;
 - 
 
136 
					default:
 - 
 
137 
						$retour .= self::formaterExceptionXhtml($e);
 107 
					$retour .= 'Fichier : '.$e->getFile()."\n";
138 
				}
 - 
 
139 
				// Nous vidons le tableau des exceptions au fur et à mesure pour éviter le réaffichage avec le destructeur.
 108 
					$retour .= 'Ligne : '.$e->getLine()."\n";
140 
				unset(self::$exceptions[$cle]);
 109 
					if (self::getContexte()) {
- 
 
 110 
						$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
141 
			}
 111 
					}
142 
		}
 112 
					break;
143 
		return $retour;
 113 
				default:
144 
	}
 - 
 
145
- 
 
146 
	/**
 - 
 
147 
	 * Renvoie le tableau d'objets Exception générées par le script PHP triées du niveau de sévérité le plus élevé au moins élevé.
 114 
					$retour .= '<div class="debogage">'."\n";
148 
	 * Format du tableau :
 115 
					$retour .= $e->getMessage()."\n";
149 
	 * array{sévérité_1 = array{Exception1, Exception2, Exception3,...}, sévérité_1 =  array{Exception1, Exception2, ...}, ...};
 - 
 
150 
	 * ATTENTION : si vous utilisez cette méthode, c'est à vous de gérer l'affichage des Exceptions. Le gestionnaire d'exception
 116 
					$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
151 
	 * n'enverra plus rien au navigateur ou à la console.
 - 
 
152 
	 * @since 0.3
 - 
 
153 
	 * @return array le tableau trié d'objet Exception.
 117 
					$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";
154 
	 */
 - 
 
155 
	public static function getExceptionsTriees() {
 118 
					if (self::getContexte()) {
156 
		$retour = array();
 119 
						$retour .= '<pre>'."\n";
157 
		if (self::getExceptionsNbre() > 0) {
 - 
 
158 
			foreach (self::$exceptions as $cle => $e) {
 120 
						$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
159 
				$retour[$e->getSeverity()][] = $e;
 121 
						$retour .= '</pre>'."\n";
160 
				// Nous vidons le tableau des exceptions au fur et à mesure pour éviter le réaffichage avec le destructeur.
 - 
 
- 
 
 122 
					}
161 
				unset(self::$exceptions[$cle]);
 123 
					$retour .= '</div>'."\n";
162 
			}
 124 
			}
- 
 
 125 
			// Nous vidons le tableau des exceptions au fur et à mesure
163 
			ksort($retour);
 126 
			unset(self::$exceptions[$cle]);
164 
		}
 127 
		}
165 
		return $retour;
 128 
		return $retour;
166 
	}
 129 
	}
167 
 
 130 
 
168 
	/**
 131 
	/**
169 
	 * Logue une exception donnée sous une forme lisible si self::logger vaut true.
 132 
	 * Logue une exception donnée sous une forme lisible si self::logger vaut true.
170 
	 * @param Exception	$e l'exception à logger
 133 
	 * @param Exception	$e l'exception à logger
171 
	 */
 134 
	 */
172 
	private static function loggerException(Exception $e) {
 135 
	private static function loggerException($e) {
173 
		if (self::$logger) {
 136 
		if (self::$logger) {
174 
			$message = self::formaterExceptionTxt($e);
 - 
 
175 
			Log::ajouterEntree('erreurs', $message);
 - 
 
176 
		}
 - 
 
177 
	}
 - 
 
178
- 
 
179 
	/**
 - 
 
180 
	 * Formate en texte une exception passée en paramètre.
 - 
 
181 
	 * @since 0.3
 - 
 
182 
	 * @param Exception l'exception à formater.
 - 
 
183 
	 */
 - 
 
184 
	public static function formaterExceptionTxt(Exception $e) {
 - 
 
185 
		$message = '';
 137 
			$erreur = '';
186 
		$message .= $e->getMessage()."\n";
 138 
			$erreur .= $e->getMessage()."\n";
187 
		$message .= 'Fichier : '.$e->getFile()."\n";
 139 
			$erreur .= 'Fichier : '.$e->getFile()."\n";
188 
		$message .= 'Ligne : '.$e->getLine()."\n";
 140 
			$erreur .= 'Ligne : '.$e->getLine()."\n";
189 
		if (self::getContexte()) {
 141 
			if (self::getContexte()) {
190 
			$message .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
 142 
				$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
191 
		}
 143 
			}
192 
		$message .= "\n";
 144 
			$erreur .= "\n";
193 
		return $message;
 - 
 
194 
	}
 - 
 
195
- 
 
196 
	/**
 - 
 
197 
	 * Formate en (X)HTML une exception passée en paramètre.
 - 
 
198 
	 * @since 0.3
 - 
 
199 
	 * @param Exception l'exception à formater.
 - 
 
200 
	 */
 - 
 
201 
	public static function formaterExceptionXhtml(Exception $e) {
 - 
 
202 
		$message = '';
 - 
 
203 
		$message .= '<div class="debogage">'."\n";
 - 
 
204 
		$message .= $e->getMessage()."\n";
 145 
			Log::ajouterEntree('erreurs', $erreur);
205 
		$message .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
 - 
 
206 
		$message .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";
 - 
 
207 
		if (self::getContexte()) {
 - 
 
208 
			$message .= '<pre>'."\n";
 - 
 
209 
			$message .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
 - 
 
210 
			$message .= '</pre>'."\n";
 - 
 
211 
		}
 146 
		}
212 
		$message .= '</div>'."\n";
 - 
 
213 
		return $message;
 - 
 
214 
	}
 147 
	}
215
148 
 
216 
	/**
 - 
 
217 
	 * Lors de la destruction de la classe si des exceptions n'ont pas été affichées, et si le débogage est à true, elles sont
 - 
 
218 
	 * affichées.
- 
 
219 
	 */
 - 
 
220 
	public function __destruct() {
 149 
	public function __destruct() {
221 
		// Si des erreurs n'ont pas été affichée nous forçons leur affichage
 150 
		// Si des erreurs n'ont pas été affichée nous forçons leur affichage
222 
		if (self::$afficher && self::getExceptionsNbre() > 0) {
 151 
		if (self::$afficher && count(self::$exceptions) > 0) {
223 
			echo self::getExceptionsFormatees();
 152 
			echo self::getExceptions();
224 
		}
 153 
		}
225 
	}
 154 
	}
226 
 
 155 
 
227 
}
 156 
}
228 
?>
 157 
?>