Subversion Repositories Applications.framework

Rev

Rev 216 | Rev 241 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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