Zend FR

Salut,

as-tu regardé du coté de la classe ErrorException.

Théoriquement, le plugin ErrorHandler est censé être lancé à partir du moment ou une Exception est lancé durant la boucle de "dispatchage". Si tu arrives à capturer ton erreur fatal et à la traduire en Exception, ça devrait probablement fonctionner. Maintenant, j'imagine que ça va dépendre de l'endroit où l'erreur intervient et vraiment de sa gravité : si le système ne peut pas s'initialiser correctement, il ne pourra probablement pas rendre ton erreur comme tu le veux... Enfin, je crois.

Salut,

j'avoue que c'est une erreur que je ne connais pas ! Une petite recherche sur Google m'a amené sur une ce site.

Peut-être que ce que tu veux faire risque d'être un peu compliqué ;-)...

Dernière modification par NewSky (28-02-2010 20:04:54)

En fait le souci vient du fait que la fonction enregistrée à exécuter lors du shutdown qui s'effectue suite à une erreur fatale, s'execute en boucle si je lève la moindre exception, ce qui parait logique.

Je n'ai pas trouvé depuis hier soir comment bypasser ce souci, je tiens au courant de l'avancement.

PS : le "set_error_handler" me sert à rien ou c'est moi? Car j'ai fait des tests sans ce dernier et apparament, aucun impact...

Salut et merci du tuyau NewSky!

Tu es sûr que les erreurs de type fatal sont gérées dans le Zend_Config_Xml et le Zend_Config dont il hérite?

Il font en effet un set_error_handler d'une méthode héritée du Zend_Config dans le Zend_Config_Xml (_loadFileErrorHandler), puis un restore_error_handler qui doit (je présume) permettre d'enlever l'error handler pour permettre une levée d'exception normale par la suite, mais je ne suis pas sûr que les erreurs dont l'errno soit à 1 (typiquement, erreur fatale) soit récupérée.

J'ai fait 2 3 tests avec uniquement l'utilisation du "set_error_handler" mais les erreurs fatales passent encore une fois au travers

Merci de ta réponse sur Zend_Config NewSky, ils gerent en effet toutes les erreurs type 'fichier non existant' etc et font remonter les erreurs sous forme d'exception Zend.

Mais de mon coté, j'ai trouvé ma solution

Bon je préviens c'est un peu alambiqué, voir beaucoup. De plus c'est en cours de dev et ça va surement être grandement amélioré dans les jours qui viennent. De plus je commente tjs mon code en anglais (bon y'a pas bcp de commentaires dans ce que je poste), j'espère qu'il n'y a pas d'anglophobes.

Je précise que si je souhaite gérer les erreur de type fatal (E_ERROR) et dites "de compilation" (E_COMPILE_ERROR) c'est principalement dans un souci de lisibilité des erreurs, pour le dev car c'est un gros projet et que plusieurs personnes developpent en même temps.

Je travaille dans un controlleur de test nommé "testController", dans le répertoire "controllers" de mon application (pas eu trop le temps de m'interesser aux tests de zendframework, envisagé pour le futur), et utilise l'action "test" de ce controlleur (méthode public testAction()).

    public function testAction() {
        
        register_shutdown_function ( array ($this, 'myShutdownErrorHandler' ) );
        
        $this->view->title = "Test page ";
        
        $this->view->date = date ( 'd/m/Y' );
        $this->view->hour = date ( 'H:i:s' );
        $this->view->by = "Me";
        
        
        $bob = new BobMorane();

    }

évidemment, dans le code précédent, ma classe BobMorane n'existe pas. L'appel va donc générer une erreur de type E_ERROR.

C'est là que le register_shutdown_function entre en jeu. Comme on peut le voir dans le code précédent, il est enregistré en premier, et fait partie de l'objet TestController, c'est pourquoi on retrouve un array($this, 'myShutdownErrorHandler' ) lors de l'appel : pour lui spécifier qu'il faut utiliser la méthode myShutdownErrorHandler de l'objet courant. Son code :

    public function myShutdownErrorHandler() {
        
        $last_error = error_get_last ();
        
        if ($last_error ['type'] === E_ERROR || $last_error ['type'] === E_COMPILE_ERROR) {
            $this->errorProcessing ($last_error['message']);
        }
    
    }

On vérifie qu'une erreur n'a pas déja eu lieu grâce au error_get_last, et si c'est le cas, on va executer la méthode errorProcessing du controlleur de test. On remarque que l'on réalise cela dans le cas d'une erreur fatale (d'execution ou de compilation) comme expliqué précedemment, grâce au test de $last_error['type'].

La méthode errorProcessing quand à elle réalise le code suivant :

    public function errorProcessing($errMess) {
        
        $last_error = error_get_last ();
        
        $error = new Personnalized_Error_EngineErrors();
        
        //This type is used to tell the errorhandler the type of the error. Set to something different
        // from Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER 
        //Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION
        //Zend_Controller_Plugin_ErrorHandler::EXCEPTION_OTHER to be
        //used properly in the error controller and enter its switch-case default process.
        $error->type = "someerrortype"; 
        
        $error->exception = new ErrorException ( $errMess, 9999, 6666, $last_error ['file'], $last_error ['line'] );
        $error->request = new Zend_Controller_Request_Http();
        
        $error->request->setParams(array(
        'controller' => 'test',
        'action' => 'test',
        'module' => 'default'
        ));
        
        
        $this->getRequest ()->setParam ( 'error_handler', $error );
        
        $this->getRequest ()->setParam('controller','error');
        $this->getRequest ()->setParam ( 'action', 'error' );
        $this->getRequest ()->setControllerName ( 'error' );
        $this->getRequest ()->setActionName ( 'error' );
        
        //Tells the front controller the request hasn't been dispatched yet
        $this->getRequest()->setDispatched(false);
        
        Zend_Controller_Front::getInstance()->dispatch($this->getRequest(),$this->getResponse());
        
    }

On remarque que j'utilise un objet de type Personnalized_Error_EngineErrors qui ne me sert qu'a me faciliter le passage des erreurs au controlleur qui gère ces dernières.

Ce qu'il faut remarquer c'est qu'a un moment donné j'effectue un

        $this->getRequest ()->setParam ( 'error_handler', $error );

pour remplir le parametre "error_handler" de la requete avec mon objet Personnalized_Error_EngineErrors.

Derriere je relance le front controlleur.

J'ai un plugin qui me permet de gérer ce genre de cas particulier : il est enregistré dans mon bootstrap de la manière suivante :

    public function run() {
        
        $errorHandler = new Zend_Controller_Plugin_ErrorHandler();
        
        $front = Zend_Controller_Front::getInstance();
        $default = $front->getDefaultModule ();
        if (null === $front->getControllerDirectory ( $default )) {
            throw new Zend_Application_Bootstrap_Exception ( 'No default controller directory registered with front controller' );
        }
        
        //ADDED the presonalized plugin registration.
        $front->registerPlugin(new Personalized_Plugin_Plug());
        
        $front->setParam ( 'bootstrap', $this );
        $front->dispatch ();
    }

Et qui réalise seulement la manip suivante lors du routeShutdown :

    public function routeShutdown(Zend_Controller_Request_Abstract $request) {
        
        $errorHandler = $request->getParam ( 'error_handler' );
        
        if (! isset ( $errorHandler ) || is_string ( $errorHandler )) {
            //Some logic here that U don't need to see ;)
        } else {
            $request->setControllerName ( 'error' );
            $request->setActionName ( 'error' );
        }
    }

pour modifier la route et envoyer l'execution sur le controlleur d'erreurs.

Le controlleur d'erreurs qui est appelé est le suivant :

    public function errorAction() {
        
        $errors = $this->_getParam ( 'error_handler' );
        
        
        
        switch ($errors->type) {
            
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER :
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION :
                
                // 404 error -- controller or action not found
                $this->getResponse ()->setHttpResponseCode ( 404 );
                $this->view->message = 'Page not found';
                break;
            
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_OTHER :
                
                // 404 error -- controller or action not found
                $this->getResponse ()->setHttpResponseCode ( 404 );
                $this->view->message = 'Page not found';
                break;
            
            default :
                
                // application error 
                $this->getResponse ()->setHttpResponseCode ( 500 );
                $this->view->message = 'Application error';
                break;
        }
        
        $this->view->exception = $errors->exception;
        $this->view->request = $errors->request;
            
    }

il sera reconnu par ceux qui ont lu les différents tutos présents sur le net x). Il injecte directement dans la vue les variables "message","exception" et "request" utilisées par la vue pour afficher le contenu des erreurs.



Comme je l'ai dit au tout premier post, je débute sous Zend donc je suis bien conscient que j'ai surement fait des erreurs dans ma façon d'appréhender le shmilblik, donc si tu remarques que j'ai fait une erreur énormissime quelque part NewSky je t'en prie ou qui que ce soit d'autre d'ailleurs.

Et comme je l'ai dit dans ce post, ça va évoluer dans les jours qui viennent et sûrement pas qu'un peu, surtout si j'ai fait des erreurs grosses comme moi x).

J'espère que je suis clair dans l'explication que je fournis ici, si je dois modifier des choses je posterai derrière que ça puisse servir à d'autres personnes.


EDIT : modification dans la méthode errorProcessing : j'avais recopié la mauvaise fin de la méthode qui fonctionnait aussi mais qui relançait tout le front controller, hors là on lui indique juste que la requete n'a pas encore été dispatchée et on relance le dispatching avec une requete modifiée juste auparavant.

Dernière modification par Gorgoth (02-03-2010 18:18:04)

pour la réexecution du dispatch qui réécrit le controlleur et l'action, j'ai compris pourquoi : lorsque je fais appel au dispatch du frontController, ce dernier réalise tout le routage (routeStartup des plugins, route du routeur et routeShutdown des plugins) avant de réaliser le dispatchLoopStartup des plugins, puis le predispatch des plugins pour apres lancer un dispatch mais du dispatcheur cette fois ci.

j'ai donc tenté de remplacer le

        Zend_Controller_Front::getInstance()->dispatch($this->getRequest(),$this->getResponse());

par

        Zend_Controller_Front::getInstance()->getDispatcher()->dispatch($this->getRequest(),$this->getResponse());

mais là, il ne se passe plus rien..... je sèche donc (comme un slip au soleil, ou comme les élèves quand il fait beau temps)

Merci Gorboth ! Je suis en train de chercher à réaliser un peu le même effet que toi mais pour enregistrer les erreurs dans une base de donnés lorsque le site est en production.

J'ai une question à propos de ton code: D'où est-ce que tu prends ceci : Engine_Error_EngineErrors() ?
Tu as créé une autre classe ?

Resalut Gorgoth !

Je suis confronté à un problème que tu as surement vu. Lorsque j'ai une erreur et que j'essaie de renvoyé à mon controller d'erreur...il rentre en boucle infinis puisqu'en entrant dans le controller d'erreur...il détecte toujours le warning.

Dans ce cas, ce système fonctionne seulement lorsque les erreurs sont dans des controlleurs et des actions spécifique et non dans un code qui sera appeler à chaque requête par exemple...le layout, utilisé pour le controlleur d'erreur.

Est-ce que tu as réussis à contourner ce genre de problème ? Merci

bonjour à tous,

j'utilise le zend framework pour me connecter à google apps!
c à dire j'utilise un compte que j'ai chez google pour m'identifier.
cependant qand je rentre un faux mot de passe (par exp) le zend me génere  Fatal error: Uncaught exception 'Zend_Gdata_App_AuthException'
je veux eviter cette erreur pour afficher une autre page en disant que le mot de passe est erroné!
est ce que vs avez une idée comment dois je faire??

un tres grand merci

C'est justement une fatal error parce que tu ne l'as pas attrapé :

try {
    // l'auth avec le mauvais mot de passe
} catch (Zend_Gdata_App_AuthException $e) {
    // Ce que tu veux
}

comment capturer mon erreur fatal et la traduire en exception??
merci d'avance