1. sfException.class.php
  2. /**
 * sfException is the base class for all symfony related exceptions and
 * provides an additional method for printing up a detailed view of an
 * exception.
 *
 * @package    symfony
 * @subpackage exception
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfException.class.php 23901 2009-11-14 13:33:03Z bschussek $
 */
  3. class sfException extends Exception
  4. {
  5.   protected
  6.     $wrappedException = null;
  8.   static protected
  9.     $lastException = null;
  11.   /**
  12.    * Wraps an Exception.
  13.    *
  14.    * @param Exception $e An Exception instance
  15.    *
  16.    * @return sfException An sfException instance that wraps the given Exception object
  17.    */
  18.   static public function createFromException(Exception $e)
  19.   {
  20.     $exception = new sfException(sprintf('Wrapped %s: %s', get_class($e), $e->getMessage()));
  21.     $exception->setWrappedException($e);
  22.     self::$lastException = $e;
  24.     return $exception;
  25.   }
  27.   /**
  28.    * Sets the wrapped exception.
  29.    *
  30.    * @param Exception $e An Exception instance
  31.    */
  32.   public function setWrappedException(Exception $e)
  33.   {
  34.     $this->wrappedException = $e;
  36.     self::$lastException = $e;
  37.   }
  39.   /**
  40.    * Gets the last wrapped exception.
  41.    *
  42.    * @return Exception An Exception instance
  43.    */
  44.   static public function getLastException()
  45.   {
  46.     return self::$lastException;
  47.   }
  49.   /**
  50.    * Clears the $lastException property (added for #6342)
  51.    */
  52.   static public function clearLastException()
  53.   {
  54.   	self::$lastException = null;
  55.   }
  56.   
  57.   /**
  58.    * Prints the stack trace for this exception.
  59.    */
  60.   public function printStackTrace()
  61.   {
  62.     if (null === $this->wrappedException)
  63.     {
  64.       $this->setWrappedException($this);
  65.     }
  67.     $exception = $this->wrappedException;
  69.     if (!sfConfig::get('sf_test'))
  70.     {
  71.       // log all exceptions in php log
  72.       error_log($exception->getMessage());
  74.       // clean current output buffer
  75.       while (ob_get_level())
  76.       {
  77.         if (!ob_end_clean())
  78.         {
  79.           break;
  80.         }
  81.       }
  83.       ob_start(sfConfig::get('sf_compressed') ? 'ob_gzhandler' : '');
  85.       header('HTTP/1.0 500 Internal Server Error');
  86.     }
  88.     try
  89.     {
  90.       $this->outputStackTrace($exception);
  91.     }
  92.     catch (Exception $e)
  93.     {
  94.     }
  96.     if (!sfConfig::get('sf_test'))
  97.     {
  98.       exit(1);
  99.     }
  100.   }
  102.   /**
  103.    * Gets the stack trace for this exception.
  104.    */
  105.   static protected function outputStackTrace(Exception $exception)
  106.   {
  107.     $format = 'html';
  108.     $code   = '500';
  109.     $text   = 'Internal Server Error';
  111.     $response = null;
  112.     if (class_exists('sfContext', false) && sfContext::hasInstance() && is_object($request = sfContext::getInstance()->getRequest()) && is_object($response = sfContext::getInstance()->getResponse()))
  113.     {
  114.       $dispatcher = sfContext::getInstance()->getEventDispatcher();
  116.       if (sfConfig::get('sf_logging_enabled'))
  117.       {
  118.         $dispatcher->notify(new sfEvent($exception, 'application.log', array($exception->getMessage(), 'priority' => sfLogger::ERR)));
  119.       }
  121.       $event = $dispatcher->notifyUntil(new sfEvent($exception, 'application.throw_exception'));
  122.       if ($event->isProcessed())
  123.       {
  124.         return;
  125.       }
  127.       if ($response->getStatusCode() < 300)
  128.       {
  129.         // status code has already been sent, but is included here for the purpose of testing
  130.         $response->setStatusCode(500);
  131.       }
  133.       $response->setContentType('text/html');
  135.       if (!sfConfig::get('sf_test'))
  136.       {
  137.         foreach ($response->getHttpHeaders() as $name => $value)
  138.         {
  139.           header($name.': '.$value);
  140.         }
  141.       }
  143.       $code = $response->getStatusCode();
  144.       $text = $response->getStatusText();
  146.       $format = $request->getRequestFormat();
  147.       if (!$format)
  148.       {
  149.         $format = 'html';
  150.       }
  152.       if ($mimeType = $request->getMimeType($format))
  153.       {
  154.         $response->setContentType($mimeType);
  155.       }
  156.     }
  157.     else
  158.     {
  159.       // a backward compatible default
  160.       if (!sfConfig::get('sf_test'))
  161.       {
  162.         header('Content-Type: text/html; charset='.sfConfig::get('sf_charset', 'utf-8'));
  163.       }
  164.     }
  166.     // send an error 500 if not in debug mode
  167.     if (!sfConfig::get('sf_debug'))
  168.     {
  169.       if ($template = self::getTemplatePathForError($format, false))
  170.       {
  171.         include $template;
  172.         return;
  173.       }
  174.     }
  176.     // when using CLI, we force the format to be TXT
  177.     if (0 == strncasecmp(PHP_SAPI, 'cli', 3))
  178.     {
  179.       $format = 'txt';
  180.     }
  182.     $message = null === $exception->getMessage() ? 'n/a' : $exception->getMessage();
  183.     $name    = get_class($exception);
  184.     $traces  = self::getTraces($exception, $format);
  186.     // dump main objects values
  187.     $sf_settings = '';
  188.     $settingsTable = $requestTable = $responseTable = $globalsTable = $userTable = '';
  189.     if (class_exists('sfContext', false) && sfContext::hasInstance())
  190.     {
  191.       $context = sfContext::getInstance();
  192.       $settingsTable = self::formatArrayAsHtml(sfDebug::settingsAsArray());
  193.       $requestTable  = self::formatArrayAsHtml(sfDebug::requestAsArray($context->getRequest()));
  194.       $responseTable = self::formatArrayAsHtml(sfDebug::responseAsArray($context->getResponse()));
  195.       $userTable     = self::formatArrayAsHtml(sfDebug::userAsArray($context->getUser()));
  196.       $globalsTable  = self::formatArrayAsHtml(sfDebug::globalsAsArray());
  197.     }
  199.     if (isset($response) && $response)
  200.     {
  201.       $response->sendHttpHeaders();
  202.     }
  204.     if ($template = self::getTemplatePathForError($format, true))
  205.     {
  206.       if (isset($dispatcher))
  207.       {
  208.         ob_start();
  209.         include $template;
  210.         $content = ob_get_clean();
  212.         $event = $dispatcher->filter(new sfEvent($response, 'response.filter_content'), $content);
  214.         echo $event->getReturnValue();
  215.       }
  216.       else
  217.       {
  218.         include $template;
  219.       }
  221.       return;
  222.     }
  223.   }
  225.   /**
  226.    * Returns the path for the template error message.
  227.    *
  228.    * @param  string  $format The request format
  229.    * @param  Boolean $debug  Whether to return a template for the debug mode or not
  230.    *
  231.    * @return string|Boolean  false if the template cannot be found for the given format,
  232.    *                         the absolute path to the template otherwise
  233.    */
  234.   static public function getTemplatePathForError($format, $debug)
  235.   {
  236.     $templatePaths = array(
  237.       sfConfig::get('sf_app_config_dir').'/error',
  238.       sfConfig::get('sf_config_dir').'/error',
  239.       dirname(__FILE__).'/data',
  240.     );
  242.     $template = sprintf('%s.%s.php', $debug ? 'exception' : 'error', $format);
  243.     foreach ($templatePaths as $path)
  244.     {
  245.       if (null !== $path && is_readable($file = $path.'/'.$template))
  246.       {
  247.         return $file;
  248.       }
  249.     }
  251.     return false;
  252.   }
  254.   /**
  255.    * Returns an array of exception traces.
  256.    *
  257.    * @param Exception $exception  An Exception implementation instance
  258.    * @param string    $format     The trace format (txt or html)
  259.    *
  260.    * @return array An array of traces
  261.    */
  262.   static protected function getTraces($exception, $format = 'txt')
  263.   {
  264.     $traceData = $exception->getTrace();
  265.     array_unshift($traceData, array(
  266.       'function' => '',
  267.       'file'     => $exception->getFile() != null ? $exception->getFile() : null,
  268.       'line'     => $exception->getLine() != null ? $exception->getLine() : null,
  269.       'args'     => array(),
  270.     ));
  272.     $traces = array();
  273.     if ($format == 'html')
  274.     {
  275.       $lineFormat = 'at <strong>%s%s%s</strong>(%s)<br />in <em>%s</em> line %s <a href="#" onclick="toggle(\'%s\'); return false;">...</a><br /><ul class="code" id="%s" style="display: %s">%s</ul>';
  276.     }
  277.     else
  278.     {
  279.       $lineFormat = 'at %s%s%s(%s) in %s line %s';
  280.     }
  282.     for ($i = 0, $count = count($traceData); $i < $count; $i++)
  283.     {
  284.       $line = isset($traceData[$i]['line']) ? $traceData[$i]['line'] : null;
  285.       $file = isset($traceData[$i]['file']) ? $traceData[$i]['file'] : null;
  286.       $args = isset($traceData[$i]['args']) ? $traceData[$i]['args'] : array();
  287.       $traces[] = sprintf($lineFormat,
  288.         (isset($traceData[$i]['class']) ? $traceData[$i]['class'] : ''),
  289.         (isset($traceData[$i]['type']) ? $traceData[$i]['type'] : ''),
  290.         $traceData[$i]['function'],
  291.         self::formatArgs($args, false, $format),
  292.         self::formatFile($file, $line, $format, null === $file ? 'n/a' : sfDebug::shortenFilePath($file)),
  293.         null === $line ? 'n/a' : $line,
  294.         'trace_'.$i,
  295.         'trace_'.$i,
  296.         $i == 0 ? 'block' : 'none',
  297.         self::fileExcerpt($file, $line)
  298.       );
  299.     }
  301.     return $traces;
  302.   }
  304.   /**
  305.    * Returns an HTML version of an array as YAML.
  306.    *
  307.    * @param array $values The values array
  308.    *
  309.    * @return string An HTML string
  310.    */
  311.   static protected function formatArrayAsHtml($values)
  312.   {
  313.     return '<pre>'.self::escape(@sfYaml::dump($values)).'</pre>';
  314.   }
  316.   /**
  317.    * Returns an excerpt of a code file around the given line number.
  318.    *
  319.    * @param string $file  A file path
  320.    * @param int    $line  The selected line number
  321.    *
  322.    * @return string An HTML string
  323.    */
  324.   static protected function fileExcerpt($file, $line)
  325.   {
  326.     if (is_readable($file))
  327.     {
  328.       $content = preg_split('#<br />#', highlight_file($file, true));
  330.       $lines = array();
  331.       for ($i = max($line - 3, 1), $max = min($line + 3, count($content)); $i <= $max; $i++)
  332.       {
  333.         $lines[] = '<li'.($i == $line ? ' class="selected"' : '').'>'.$content[$i - 1].'</li>';
  334.       }
  336.       return '<ol start="'.max($line - 3, 1).'">'.implode("\n", $lines).'</ol>';
  337.     }
  338.   }
  340.   /**
  341.    * Formats an array as a string.
  342.    *
  343.    * @param array   $args     The argument array
  344.    * @param boolean $single
  345.    * @param string  $format   The format string (html or txt)
  346.    *
  347.    * @return string
  348.    */
  349.   static protected function formatArgs($args, $single = false, $format = 'html')
  350.   {
  351.     $result = array();
  353.     $single and $args = array($args);
  355.     foreach ($args as $key => $value)
  356.     {
  357.       if (is_object($value))
  358.       {
  359.         $formattedValue = ($format == 'html' ? '<em>object</em>' : 'object').sprintf("('%s')", get_class($value));
  360.       }
  361.       else if (is_array($value))
  362.       {
  363.         $formattedValue = ($format == 'html' ? '<em>array</em>' : 'array').sprintf("(%s)", self::formatArgs($value));
  364.       }
  365.       else if (is_string($value))
  366.       {
  367.         $formattedValue = ($format == 'html' ? sprintf("'%s'", self::escape($value)) : "'$value'");
  368.       }
  369.       else if (null === $value)
  370.       {
  371.         $formattedValue = ($format == 'html' ? '<em>null</em>' : 'null');
  372.       }
  373.       else
  374.       {
  375.         $formattedValue = $value;
  376.       }
  377.       
  378.       $result[] = is_int($key) ? $formattedValue : sprintf("'%s' => %s", self::escape($key), $formattedValue);
  379.     }
  381.     return implode(', ', $result);
  382.   }
  384.   /**
  385.    * Formats a file path.
  386.    * 
  387.    * @param  string  $file   An absolute file path
  388.    * @param  integer $line   The line number
  389.    * @param  string  $format The output format (txt or html)
  390.    * @param  string  $text   Use this text for the link rather than the file path
  391.    * 
  392.    * @return string
  393.    */
  394.   static protected function formatFile($file, $line, $format = 'html', $text = null)
  395.   {
  396.     if (null === $text)
  397.     {
  398.       $text = $file;
  399.     }
  401.     if ('html' == $format && $file && $line && $linkFormat = sfConfig::get('sf_file_link_format', ini_get('xdebug.file_link_format')))
  402.     {
  403.       $link = strtr($linkFormat, array('%f' => $file, '%l' => $line));
  404.       $text = sprintf('<a href="%s" title="Click to open this file" class="file_link">%s</a>', $link, $text);
  405.     }
  407.     return $text;
  408.   }
  410.   /**
  411.    * Escapes a string value with html entities
  412.    *
  413.    * @param  string  $value
  414.    *
  415.    * @return string
  416.    */
  417.   static protected function escape($value)
  418.   {
  419.     if (!is_string($value))
  420.     {
  421.       return $value;
  422.     }
  423.     
  424.     return htmlspecialchars($value, ENT_QUOTES, sfConfig::get('sf_charset', 'UTF-8'));
  425.   }
  426. }
Debug toolbar