CakePHP exception logic - cakephp

Question

I have a controller where I throw a custom exception and I have a custom exception renderer class, which extends the basic exception renderer.
Now when I throw the exception, I'd like to do some cleanup with the stuff, that went wrong and after that render a custom error page.
class AppExceptionRenderer extends ExceptionRenderer {
public function invalidCall($error) {
$this->controller->render('/Errors/invalid_call');
$this->controller->response->send();
}
public function incompleteCall($error) {
$this->controller->render('/Errors/incomplete_call');
$this->controller->response->send();
}
}
The rendering works well so far. But where should I put the logic for the cleanup things?
In the exception itself? In the renderer? In the controller before throwing the exception?

Answer 1

Well, as so often there are many ways to skin a cat, but I'd say in order to stay DRY, for easy testing, and in order to stay in compliance with the recommended fat model concept, you should put the logic in the model.
And in order to decouple cleanup and exception handling, you could for example utilize the event system and let the models that may need to be cleaned attach themselfs as listeners (they should know best whether they may need to be cleaned up), and let a custom error handler dispatch an appropriate event, that way the exception handler doesn't need to know about the app internals.
Here's some very basic, untested example code that should illustrate the idea:
<?php
App::uses('CakeEventManager', 'Event');
class ExampleModel extends AppModel
{
public $name = 'Example';
public function __construct($id = false, $table = null, $ds = null)
{
CakeEventManager::instance()->attach(array($this, 'cleanup'), 'AppErrorHandler.beforeHandleException');
parent::__construct($id, $table, $ds);
}
public function cleanup()
{
// do some magic
}
}
?>
<?php
App::uses('CakeEvent', 'Event');
App::uses('CakeEventManager', 'Event');
class AppErrorHandler extends ErrorHandler
{
public static function handleException(Exception $exception)
{
CakeEventManager::instance()->dispatch(new CakeEvent('AppErrorHandler.beforeHandleException', get_called_class(), array($exception)));
parent::handleException($exception);
}
}
?>
Update
In order to be able to react to specific exceptions only, you could for example utilize the exception class name in the event name, so it would trigger events like ...beforeHandleFooBarException to wich you could explicitly subscribe:
<?php
class AppErrorHandler extends ErrorHandler
{
public static function handleException(Exception $exception)
{
CakeEventManager::instance()->dispatch(new CakeEvent('AppErrorHandler.beforeHandle' . get_class($exception), get_called_class(), array($exception)));
parent::handleException($exception);
}
}
?>
<?php
class ExampleModel extends AppModel
{
public $name = 'Example';
public function __construct($id = false, $table = null, $ds = null)
{
$eventManager = CakeEventManager::instance();
$callback = array($this, 'cleanup');
$eventManager->attach($callback, 'AppErrorHandler.beforeHandleInvalidCallException');
$eventManager->attach($callback, 'AppErrorHandler.beforeHandleIncompleteCallException');
parent::__construct($id, $table, $ds);
}
public function cleanup()
{
// do some magic
}
}
?>
If you would stick with the generic exception event, then another option would be to check the type of the exception in the models event listener callback:
public function __construct($id = false, $table = null, $ds = null)
{
CakeEventManager::instance()->attach(array($this, 'beforeHandleException'), 'AppErrorHandler.beforeHandleException', array('passParams' => true));
parent::__construct($id, $table, $ds);
}
public function beforeHandleException($exception)
{
if($exception instanceof InvalidCallException ||
$exception instanceof IncompleteCallException)
{
$this->cleanup();
}
}
public function cleanup()
{
// do some magic
}