WebSVN – Applications.framework – Diff – /trunk/framework/GestionnaireException.php


<?php
// declare(encoding='UTF-8');
/**
 * Classe de gestion des exceptions.
 * C'est un Singleton.
 *
 * PHP Version 5
 *
 * @category  Class
 * @package   Framework
 * @author	aurelien <aurelien@tela-botanica.org>
 * @copyright 2009 Tela-Botanica
 * @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 * @license   http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 * @version   SVN: $$Id: GestionnaireException.php 157 2010-03-04 14:24:54Z aurelien $$
 * @link	  /doc/framework/
 *
 */
class GestionnaireException {
 
	/**
	 * Liste des exceptions enregistrées
	 */
	private static $exceptions = array();
 
	/**
	 * Détermine si l'on affiche ou non le contexte
	 */
	private static $contexte = false;
 
	/**
	 * Détermine si l'on affiche ou non les erreur
	 */
	private static $afficher = false;
 
	 /**
	 * Détermine si l'on loggue ou non les erreurs
	 */
	private static $logger = false;
 
	/**
	 * Definit si php est lancé en ligne de commande ou en mode serveur
	 */
	private static $mode = php_sapi_name ;
 
	/**
	 * le gestionnaire d'exception est un singleton
	 * et possède donc un "pointeur statique sur lui-même"
	 */
	private static $gestionnaireException;
 
	/**
	 * Constructeur avec paramètres optionnel
	 * @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)
	 */
	public function __construct() {
		self::$exceptions = array();
		self::$contexte = Config::get('fw_debogage_contexte');
		self::$logger = Config::get('fw_log_debogage');
		self::$afficher = Config::get('fw_debogage');
		self::$mode = php_sapi_name();
 
		set_exception_handler(array(get_class($this),'gererException'));
		set_error_handler(array(get_class($this),'gererErreur'));
	}
 
	/**
	 * Renvoie le booleen définissant si l'on affiche le contexte ou non
	 */
	public static function getContexte() {
		return self::$contexte;
	}
 
	/**
	 * Definit si l'on veut afficher le contexte ou non
	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
	 */
	public function setContexte($contexte) {
		self::$contexte = $contexte;
	}
 
	 /** Fonction d'accès au singleton
	 * @return GestionnaireErreur le gestionnaire d'exceptions courant
	 */
	public static function getInstance() {
		if (self::$gestionnaireException instanceof GestionnaireException) {
			return self::$gestionnaireException;
		}
		self::$gestionnaireException = new GestionnaireException;
 
		return self::$gestionnaireException;
	}
 
	/**
	 * Fonction de gestion des exceptions, remplace le handler par défaut
	 * @param Exception $e l'exception à traiter
	 */
	public static function gererException(Exception $e) {
		// pour le moment on se contente de l'ajouter au tableau et de les afficher
		self::$exceptions[] = $e;
 
		// si on doit logger on envoie l'exception au loggeur
		if (self::$logger) {
			self::loggerException($e);
		}
	}
 
	/**
	 * Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)
	 * @param int $niveau le niveau de l'erreur
	 * @param string $message le message associé à l'erreur
	 * @param string $fichier le nom du fichier où l'erreur s'est produite
	 * @param int $ligne la ligne où l'erreur s'est produite
	 * @param string $contexte le contexte associé à l'erreur
	 */
	public static function gererErreur($niveau,  $message,  $fichier,  $ligne,  $contexte){
		// si aucun rapport d'erreur, on sort directement
		if (error_reporting() == 0) {
			return;
		}
 
		// sinon on crée une exception
		$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);
		// que l'on donne au tableau d'exceptions
		self::$exceptions[] = $e;
		// on la logge si nécéssaire
		if (self::$logger) {
			self::loggerException($e);
		}
		return;
	}
 
	/**
	 * Renvoie les exceptions au format (X)HTML
	 * ou bien au format texte suivant le mode d'utilisation de PHP
	 */
	public static function getExceptions() {
		$retour = '';
		foreach (self::$exceptions as $cle => $e) {
			switch (self::$mode) {
				case 'cli' :
					$retour .= $e->getMessage()."\n";
					$retour .= 'Fichier : '.$e->getFile()."\n";
					$retour .= 'Ligne : '.$e->getLine()."\n";
					if (self::getContexte()) {
						$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
					}
					break;
				default:
					$retour .= '<pre class="debogage">'."\n";
					$retour .= $e->getMessage()."\n";
					$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
					$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";
					$retour .= '</pre>'."\n";
 
					if (self::getContexte()) {
						$retour .= '<pre>'."\n";
						$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
						$retour .= '</pre>'."\n";
					}
			}
			// Nous vidons le tableau des exceptions au fur et à mesure
			unset(self::$exceptions[$cle]);
		}
		return $retour;
	}
 
	/**
	 * logge une exception donnée sous une forme lisible
	 * @param Exception	$e l'exception à logger
	 */
	private static function loggerException($e) {
		$erreur = '';
		$erreur .= $e->getMessage()."\n";
		$erreur .= 'Fichier : '.$e->getFile()."\n";
		$erreur .= 'Ligne : '.$e->getLine()."\n";
		if (self::getContexte()) {
			$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
		}
		$erreur .= "\n";
		Log::ajouterEntree('erreurs',$erreur);
	}
 
	public function __destruct() {
		// Si des erreurs n'ont pas été affichée nous forçons leur affichage
		if (self::$afficher && count(self::$exceptions) > 0) {
			echo self::getExceptions();
		}
	}
 
}
?>

Subversion Repositories Applications.framework

(root)/trunk/framework/GestionnaireException.php – Rev 142 → 157

Rev 142		Rev 157
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	`* PHP Version 5`	7	`* PHP Version 5`
8	`*`	8	`*`
9	`* @category Class`	9	`* @category Class`
10	`* @package Framework`	10	`* @package Framework`
11	`* @author aurelien <aurelien@tela-botanica.org>`	11	`* @author aurelien <aurelien@tela-botanica.org>`
12	`* @copyright 2009 Tela-Botanica`	12	`* @copyright 2009 Tela-Botanica`
13	`* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL`	13	`* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL`
14	`* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL`	14	`* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL`
15	`* @version SVN: $$Id: GestionnaireException.php 142 2010-03-02 12:59:30Z jpm $$`	15	`* @version SVN: $$Id: GestionnaireException.php 157 2010-03-04 14:24:54Z aurelien $$`
16	`* @link /doc/framework/`	16	`* @link /doc/framework/`
17	`*`	17	`*`
18	`*/`	18	`*/`
19	`class GestionnaireException {`	19	`class GestionnaireException {`
20		20
21	`/**`	21	`/**`
22	`* Liste des exceptions enregistrées`	22	`* Liste des exceptions enregistrées`
23	`*/`	23	`*/`
24	`private static $exceptions = array();`	24	`private static $exceptions = array();`
25		25
26	`/**`	26	`/**`
27	`* Détermine si l'on affiche ou non le contexte`	27	`* Détermine si l'on affiche ou non le contexte`
28	`*/`	28	`*/`
29	`private static $contexte = false;`	29	`private static $contexte = false;`
-		30
-		31	`/**`
-		32	`* Détermine si l'on affiche ou non les erreur`
-		33	`*/`
-		34	`private static $afficher = false;`
30		35
31	`/**`	36	`/**`
32	`* Détermine si l'on loggue ou non les erreurs`	37	`* Détermine si l'on loggue ou non les erreurs`
33	`*/`	38	`*/`
34	`private static $logger = false;`	39	`private static $logger = false;`
35		40
36	`/**`	41	`/**`
37	`* Definit si php est lancé en ligne de commande ou en mode serveur`	42	`* Definit si php est lancé en ligne de commande ou en mode serveur`
38	`*/`	43	`*/`
39	`private static $mode = php_sapi_name ;`	44	`private static $mode = php_sapi_name ;`
40		45
41	`/**`	46	`/**`
42	`* le gestionnaire d'exception est un singleton`	47	`* le gestionnaire d'exception est un singleton`
43	`* et possède donc un "pointeur statique sur lui-même"`	48	`* et possède donc un "pointeur statique sur lui-même"`
44	`*/`	49	`*/`
45	`private static $gestionnaireException;`	50	`private static $gestionnaireException;`
46		51
47	`/**`	52	`/**`
48	`* Constructeur avec paramètres optionnel`	53	`* Constructeur avec paramètres optionnel`
49	`* @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)`	54	`* @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)`
50	`*/`	55	`*/`
51	`public function __construct() {`	56	`public function __construct() {`
52	`self::$exceptions = array();`	57	`self::$exceptions = array();`
53	`self::$contexte = Config::get('fw_debogage_contexte');`	58	`self::$contexte = Config::get('fw_debogage_contexte');`
54	`self::$logger = Config::get('fw_log_debogage');`	59	`self::$logger = Config::get('fw_log_debogage');`
-		60	`self::$afficher = Config::get('fw_debogage');`
55	`self::$mode = php_sapi_name();`	61	`self::$mode = php_sapi_name();`
56		62
57	`set_exception_handler(array(get_class($this),'gererException'));`	63	`set_exception_handler(array(get_class($this),'gererException'));`
58	`set_error_handler(array(get_class($this),'gererErreur'));`	64	`set_error_handler(array(get_class($this),'gererErreur'));`
59	`}`	65	`}`
60		66
61	`/**`	67	`/**`
62	`* Renvoie le booleen définissant si l'on affiche le contexte ou non`	68	`* Renvoie le booleen définissant si l'on affiche le contexte ou non`
63	`*/`	69	`*/`
64	`public static function getContexte() {`	70	`public static function getContexte() {`
65	`return self::$contexte;`	71	`return self::$contexte;`
66	`}`	72	`}`
67		73
68	`/**`	74	`/**`
69	`* Definit si l'on veut afficher le contexte ou non`	75	`* Definit si l'on veut afficher le contexte ou non`
70	`* @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false`	76	`* @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false`
71	`*/`	77	`*/`
72	`public function setContexte($contexte) {`	78	`public function setContexte($contexte) {`
73	`self::$contexte = $contexte;`	79	`self::$contexte = $contexte;`
74	`}`	80	`}`
75		81
76	`/** Fonction d'accès au singleton`	82	`/** Fonction d'accès au singleton`
77	`* @return GestionnaireErreur le gestionnaire d'exceptions courant`	83	`* @return GestionnaireErreur le gestionnaire d'exceptions courant`
78	`*/`	84	`*/`
79	`public static function getInstance() {`	85	`public static function getInstance() {`
80	`if (self::$gestionnaireException instanceof GestionnaireException) {`	86	`if (self::$gestionnaireException instanceof GestionnaireException) {`
81	`return self::$gestionnaireException;`	87	`return self::$gestionnaireException;`
82	`}`	88	`}`
83	`self::$gestionnaireException = new GestionnaireException;`	89	`self::$gestionnaireException = new GestionnaireException;`
84		90
85	`return self::$gestionnaireException;`	91	`return self::$gestionnaireException;`
86	`}`	92	`}`
87		93
88	`/**`	94	`/**`
89	`* Fonction de gestion des exceptions, remplace le handler par défaut`	95	`* Fonction de gestion des exceptions, remplace le handler par défaut`
90	`* @param Exception $e l'exception à traiter`	96	`* @param Exception $e l'exception à traiter`
91	`*/`	97	`*/`
92	`public static function gererException(Exception $e) {`	98	`public static function gererException(Exception $e) {`
93	`// pour le moment on se contente de l'ajouter au tableau et de les afficher`	99	`// pour le moment on se contente de l'ajouter au tableau et de les afficher`
94	`self::$exceptions[] = $e;`	100	`self::$exceptions[] = $e;`
95		101
96	`// si on doit logger on envoie l'exception au loggeur`	102	`// si on doit logger on envoie l'exception au loggeur`
97	`if (self::$logger) {`	103	`if (self::$logger) {`
98	`self::loggerException($e);`	104	`self::loggerException($e);`
99	`}`	105	`}`
100	`}`	106	`}`
101		107
102	`/**`	108	`/**`
103	`* Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)`	109	`* Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)`
104	`* @param int $niveau le niveau de l'erreur`	110	`* @param int $niveau le niveau de l'erreur`
105	`* @param string $message le message associé à l'erreur`	111	`* @param string $message le message associé à l'erreur`
106	`* @param string $fichier le nom du fichier où l'erreur s'est produite`	112	`* @param string $fichier le nom du fichier où l'erreur s'est produite`
107	`* @param int $ligne la ligne où l'erreur s'est produite`	113	`* @param int $ligne la ligne où l'erreur s'est produite`
108	`* @param string $contexte le contexte associé à l'erreur`	114	`* @param string $contexte le contexte associé à l'erreur`
109	`*/`	115	`*/`
110	`public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){`	116	`public static function gererErreur($niveau, $message, $fichier, $ligne, $contexte){`
111	`// si aucun rapport d'erreur, on sort directement`	117	`// si aucun rapport d'erreur, on sort directement`
112	`if (error_reporting() == 0) {`	118	`if (error_reporting() == 0) {`
113	`return;`	119	`return;`
114	`}`	120	`}`
115		121
116	`// sinon on crée une exception`	122	`// sinon on crée une exception`
117	`$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);`	123	`$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);`
118	`// que l'on donne au tableau d'exceptions`	124	`// que l'on donne au tableau d'exceptions`
119	`self::$exceptions[] = $e;`	125	`self::$exceptions[] = $e;`
120	`// on la logge si nécéssaire`	126	`// on la logge si nécéssaire`
121	`if (self::$logger) {`	127	`if (self::$logger) {`
122	`self::loggerException($e);`	128	`self::loggerException($e);`
123	`}`	129	`}`
124	`return;`	130	`return;`
125	`}`	131	`}`
126		132
127	`/**`	133	`/**`
128	`* Renvoie les exceptions au format (X)HTML`	134	`* Renvoie les exceptions au format (X)HTML`
129	`* ou bien au format texte suivant le mode d'utilisation de PHP`	135	`* ou bien au format texte suivant le mode d'utilisation de PHP`
130	`*/`	136	`*/`
131	`public static function getExceptions() {`	137	`public static function getExceptions() {`
132	`$retour = '';`	138	`$retour = '';`
133	`foreach (self::$exceptions as $cle => $e) {`	139	`foreach (self::$exceptions as $cle => $e) {`
134	`switch (self::$mode) {`	140	`switch (self::$mode) {`
135	`case 'cli' :`	141	`case 'cli' :`
136	`$retour .= $e->getMessage()."\n";`	142	`$retour .= $e->getMessage()."\n";`
137	`$retour .= 'Fichier : '.$e->getFile()."\n";`	143	`$retour .= 'Fichier : '.$e->getFile()."\n";`
138	`$retour .= 'Ligne : '.$e->getLine()."\n";`	144	`$retour .= 'Ligne : '.$e->getLine()."\n";`
139	`if (self::getContexte()) {`	145	`if (self::getContexte()) {`
140	`$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`	146	`$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`
141	`}`	147	`}`
142	`break;`	148	`break;`
143	`default:`	149	`default:`
144	`$retour .= '<pre class="debogage">'."\n";`	150	`$retour .= '<pre class="debogage">'."\n";`
145	`$retour .= $e->getMessage()."\n";`	151	`$retour .= $e->getMessage()."\n";`
146	`$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";`	152	`$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";`
147	`$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";`	153	`$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";`
148	`$retour .= '</pre>'."\n";`	154	`$retour .= '</pre>'."\n";`
149		155
150	`if (self::getContexte()) {`	156	`if (self::getContexte()) {`
151	`$retour .= '<pre>'."\n";`	157	`$retour .= '<pre>'."\n";`
152	`$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";`	158	`$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";`
153	`$retour .= '</pre>'."\n";`	159	`$retour .= '</pre>'."\n";`
154	`}`	160	`}`
155	`}`	161	`}`
156	`// Nous vidons le tableau des exceptions au fur et à mesure`	162	`// Nous vidons le tableau des exceptions au fur et à mesure`
157	`unset(self::$exceptions[$cle]);`	163	`unset(self::$exceptions[$cle]);`
158	`}`	164	`}`
159	`return $retour;`	165	`return $retour;`
160	`}`	166	`}`
161		167
162	`/**`	168	`/**`
163	`* logge une exception donnée sous une forme lisible`	169	`* logge une exception donnée sous une forme lisible`
164	`* @param Exception $e l'exception à logger`	170	`* @param Exception $e l'exception à logger`
165	`*/`	171	`*/`
166	`private static function loggerException($e) {`	172	`private static function loggerException($e) {`
167	`$erreur = '';`	173	`$erreur = '';`
168	`$erreur .= $e->getMessage()."\n";`	174	`$erreur .= $e->getMessage()."\n";`
169	`$erreur .= 'Fichier : '.$e->getFile()."\n";`	175	`$erreur .= 'Fichier : '.$e->getFile()."\n";`
170	`$erreur .= 'Ligne : '.$e->getLine()."\n";`	176	`$erreur .= 'Ligne : '.$e->getLine()."\n";`
171	`if (self::getContexte()) {`	177	`if (self::getContexte()) {`
172	`$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`	178	`$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";`
173	`}`	179	`}`
174	`$erreur .= "\n";`	180	`$erreur .= "\n";`
175	`Log::ajouterEntree('erreurs',$erreur);`	181	`Log::ajouterEntree('erreurs',$erreur);`
176	`}`	182	`}`
177		183
178	`public function __destruct() {`	184	`public function __destruct() {`
179	`// Si des erreurs n'ont pas été affichée nous forçons leur affichage`	185	`// Si des erreurs n'ont pas été affichée nous forçons leur affichage`
180	`if (count(self::$exceptions) > 0) {`	186	`if (self::$afficher && count(self::$exceptions) > 0) {`
181	`echo self::getExceptions();`	187	`echo self::getExceptions();`
182	`}`	188	`}`
183	`}`	189	`}`
184		190
185	`}`	191	`}`
186	`?>`	192	`?>`