PHP Profile::start方法代码示例

 /**
  * Gets a service.
  *
  * @param  string $id The service identifier
  *
  * @return object The associated service
  *
  * @throw InvalidArgumentException if the service is not defined
  * @throw LogicException if the service has a circular reference to itself
  */
 public function getService($id)
 {
     Profile::start('SymfonyContainer', 'Getting service');
     try {
         $return = parent::getService($id);
     } catch (InvalidArgumentException $e) {
         if (isset($this->loading[$id])) {
             Profile::stop();
             throw new LogicException(sprintf('The service "%s" has a circular reference to itself.', $id));
         }
         if (!$this->hasServiceDefinition($id) && isset($this->aliases[$id])) {
             $return = $this->getService($this->aliases[$id]);
         } else {
             $definition = $this->getServiceDefinition($id);
             $this->loading[$id] = true;
             if ($definition->isShared()) {
                 $service = $this->services[$id] = $this->createService($definition);
             } else {
                 $service = $this->createService($definition);
             }
             unset($this->loading[$id]);
             $return = $service;
         }
     }
     Profile::stop();
     return $return;
 }

 /**
  * {@inheritdoc}
  */
 public function render($viewName, Model $model, NotificationCenter $notificationCenter, $output = true)
 {
     Profile::start('Renderer', 'Generate HTML');
     $templateName = $viewName . '.' . static::$templateFileExtension;
     $dwoo = new Dwoo($this->compiledPath, $this->cachePath);
     $dwoo->getLoader()->addDirectory($this->functionsPath);
     Profile::start('Renderer', 'Create template file.');
     $template = new Dwoo_Template_File($templateName);
     $template->setIncludePath($this->getTemplatesPath());
     Profile::stop();
     Profile::start('Renderer', 'Render');
     $dwooData = new Dwoo_Data();
     $dwooData->setData($model->getData());
     $dwooData->assign('errorMessages', $notificationCenter->getErrors());
     $dwooData->assign('successMessages', $notificationCenter->getSuccesses());
     $this->setHeader('Content-type: text/html', $output);
     // I do never output directly from dwoo to have the possibility to show an error page if there was a render error.
     $result = $rendered = $dwoo->get($template, $dwooData, null, false);
     if ($output) {
         echo $result;
     }
     Profile::stop();
     Profile::stop();
     return $output ? null : $rendered;
 }

 public function testProfile()
 {
     $p = new Profile();
     $p->start('foo');
     $p->start('bar');
     $p->start('foo');
     $p->stop();
     // stop foo 2
     $p->stop();
     // stop bar
     $p->start('che');
     $p->stop();
     // stop che 1
     $p->stop();
     // stop foo 1
     $map = $p->get();
     $this->assertTrue(isset($map['foo']['children']['bar']['children']['foo']));
     $this->assertTrue(isset($map['foo']['children']['che']));
 }

 /**
  * {@inheritdoc}
  */
 public function render($viewName, Model $model, NotificationCenter $notificationCenter, $output = true)
 {
     Profile::start('Renderer', 'Generate HTML');
     $filename = $this->templatesPath . $viewName . '.' . static::$templateFileExtension;
     if ($output) {
         $html = null;
         readfile($filename);
     } else {
         $html = file_get_contents($filename);
     }
     Profile::stop();
     return $html;
 }

 /**
  * Loads and caches the config files
  */
 public function load()
 {
     if ($this->config) {
         return;
     }
     Profile::start('IniFileConfig', 'Load');
     if ($this->defaultConfigFileUri) {
         $this->config = $this->mergeConfigArrays(parse_ini_file($this->defaultConfigFileUri, $this->useSections), parse_ini_file($this->configFileUri, $this->useSections));
     } else {
         $this->config = parse_ini_file($this->configFileUri, $this->useSections);
     }
     Profile::stop();
 }

 public function next()
 {
     Profile::start(__METHOD__);
     parent::next();
     $this->_stepInOut = 0;
     $this->_stepFirst = false;
     while (count($this->_stack) > 0 && $this->_stack[0] < $this->_current_model->rside) {
         array_shift($this->_stack);
         $this->_stepInOut--;
     }
     if ($this->_stack[0] != $this->_current_model->rside) {
         array_splice($this->_path, count($this->_path) + $this->_stepInOut++, count($this->_path), (string) $this->_current_model);
         array_unshift($this->_stack, $this->_current_model->rside);
     }
     Profile::stop(__METHOD__);
 }

 /**
  * run downloader
  */
 public function process()
 {
     try {
         Writer::send('Start ' . date('d-m-Y H:i'), 'success');
         Profile::start();
         $this->setOptions()->prepareDirs();
         Writer::send('Retrieving list');
         $this->getFs()->saveList($this->getApi()->getList());
         Writer::send('Processing list');
         $this->processList();
         Writer::send('End ' . date('d-m-Y H:i'), 'success');
         $profiler = Profile::getResult();
         foreach ($profiler as $k => $v) {
             Writer::send(ucfirst($k) . ' used: ' . $v);
         }
     } catch (\Exception $e) {
         Writer::send($e->getMessage(), 'failure');
     }
 }

 /**
  * {@inheritdoc}
  */
 public function render($viewName, Model $model, NotificationCenter $notificationCenter, $output = true)
 {
     Profile::start('Renderer', 'Rendering HTML');
     $templateName = $viewName . '.' . static::$templateFileExtension;
     $loader = new Twig_Loader_Filesystem($this->templatesPath);
     $twig = new Twig_Environment($loader, array('cache' => $this->cachePath));
     foreach ($this->extensions as $extension) {
         $twig->addExtension($extension);
     }
     foreach ($this->globals as $name => $global) {
         $twig->addGlobal($name, $global);
     }
     $twig->addGlobal('notifications', $notificationCenter);
     //    $twig->addGlobal('controller', $);
     $this->setHeader('Content-type: text/html', $output);
     $result = $twig->render($templateName, $model->getData());
     if ($output) {
         echo $result;
     }
     Profile::stop();
     return $output ? null : $rendered;
 }

 /**
  * {@inheritdoc}
  */
 public function render($viewName, Model $model, NotificationCenter $notificationCenter, $output = true)
 {
     Profile::start('Renderer', 'Generate JSON');
     if (strpos($viewName, 'errors/') === 0) {
         $data = array('error' => substr($viewName, strlen('errors/')));
     } else {
         $c = $model->getData(Model::PUBLISHABLE);
         $data = array('content' => count($c) === 0 ? null : $c);
     }
     if (count($notificationCenter->getErrors())) {
         $data['errorMessages'] = $notificationCenter->getErrors();
     }
     if (count($notificationCenter->getSuccesses())) {
         $data['successMessages'] = $notificationCenter->getSuccesses();
     }
     $json = json_encode($data);
     $this->setHeader('Content-type: application/json', $output);
     if ($output) {
         echo $json;
     }
     Profile::stop();
     return $output ? null : $json;
 }

 /**
  * @covers Profile::start
  */
 public function testStartWithoutSection()
 {
     $this->profiler->expects($this->once())->method('start')->with('context_x', null);
     Profile::start('context_x');
 }

 /**
  * Parses the url, and dispatches to the appropriate controller.
  * @param bool $skipControllerInitialization
  */
 public function dispatch($skipControllerInitialization = false)
 {
     Profile::start('Dispatcher', 'Dispatching');
     $contentTypes = array();
     try {
         $controllerName = isset($_GET['controller']) ? trim($_GET['controller']) : $this->defaultControllerName;
         $controllerName = $this->controllerFromUrlSanitizer->sanitize($controllerName);
         $invalidControllerName = false;
         try {
             $controller = $this->controllerFactory->get($controllerName);
         } catch (ControllerFactoryException $e) {
             // Not failing just yet, so the model gets initialized.
             $invalidControllerName = true;
             $controller = $this->controllerFactory->get($this->defaultControllerName);
         }
         $model = new Model();
         $controller->setModel($model);
         $controller->initModel();
         $contentTypes = $this->getAcceptContentTypes($_SERVER['HTTP_ACCEPT']);
         try {
             if ($invalidControllerName) {
                 ErrorCode::notFound();
             }
             try {
                 $errorDuringRender = null;
                 $errorCode = null;
                 // Try to dispatch to the actual action.
                 $actionParameters = explode('/', isset($_GET['action']) ? $_GET['action'] : 'index');
                 $action = $actionParameters[0];
                 array_shift($actionParameters);
                 if ($action[0] === '_') {
                     throw new ErrorCode(ErrorCode::NOT_FOUND, 'Tried to access action with underscore.');
                 }
                 $action = $this->actionFromUrlSanitizer->sanitize($action);
                 try {
                     // Check if the action is valid
                     $reflectionClass = new ReflectionClass($controller);
                     $actionMethod = $reflectionClass->getMethod($action);
                     if ($action !== 'index' && (method_exists('Controller', $action) || !$actionMethod->isPublic() || $actionMethod->class !== get_class($controller))) {
                         throw new DispatcherException();
                     }
                 } catch (Exception $e) {
                     throw new ErrorCode(ErrorCode::NOT_FOUND, 'Tried to access invalid action.');
                 }
                 $controller->setAction($action);
                 $parameters = array();
                 $stringParameters = array();
                 $i = 0;
                 foreach ($actionMethod->getParameters() as $parameter) {
                     $actionParameter = isset($actionParameters[$i]) ? $actionParameters[$i] : null;
                     if ($actionParameter === null) {
                         if (!$parameter->isDefaultValueAvailable()) {
                             throw new ErrorCode(ErrorCode::BAD_REQUEST, 'Not all parameters supplied.');
                         }
                         // Well: there is no more additional query, and apparently the rest of the parameters are optional, so continue.
                         continue;
                     }
                     if (($parameterTypeClass = $parameter->getClass()) != false) {
                         if (!$parameterTypeClass->isSubclassOf('RW_Type')) {
                             throw new ErrorCode(ErrorCode::BAD_REQUEST, 'Invalid parameter type.');
                         }
                         $parameterTypeClassName = $parameterTypeClass->getName();
                         $parameters[] = new $parameterTypeClassName($actionParameter);
                     } else {
                         $parameters[] = $actionParameter;
                     }
                     $stringParameters[] = $actionParameter;
                     $i++;
                 }
                 $controller->setActionParameters($stringParameters);
                 if (!$skipControllerInitialization) {
                     $controller->initialize();
                 }
                 // This actually calls the apropriate action.
                 call_user_func_array(array($controller, $action), $parameters);
                 $controller->extendModel();
                 try {
                     $this->renderers->render($controller->getViewName(), $model, $this->notificationCenter, $this->theme->getTemplatesPath(), $contentTypes, $controller);
                 } catch (Exception $e) {
                     throw new ErrorCode(ErrorCode::INTERNAL_SERVER_ERROR, 'Error during render: ' . $e->getMessage());
                 }
             } catch (ErrorMessageException $e) {
                 $errorDuringRender = true;
                 $this->notificationCenter->addError($e->getMessage());
             } catch (ErrorCode $e) {
                 throw $e;
             } catch (Exception $e) {
                 $additionalInfo = array();
                 $additionalInfo['controllerName'] = $controllerName;
                 if (isset($action)) {
                     $additionalInfo['action'] = $action;
                 }
                 $additionalInfo['exceptionThrown'] = get_class($e);
                 $additionalInfo['error'] = $e->getMessage();
                 Log::warning($e->getMessage(), 'Dispatcher', $additionalInfo);
                 throw new ErrorCode(ErrorCode::INTERNAL_SERVER_ERROR);
//.........这里部分代码省略.........