* @link http://www.pradosoft.com/
* @copyright Copyright © 2005-2014 PradoSoft
* @license http://www.pradosoft.com/license/
* @package Prado
*/
namespace Prado;
use Prado\Exceptions\TErrorHandler;
use Prado\Exceptions\THttpException;
use Prado\Exceptions\TConfigurationException;
use Prado\Security\TSecurityManager;
use Prado\Web\TAssetManager;
use Prado\Web\THttpRequest;
use Prado\Web\THttpResponse;
use Prado\Web\THttpSession;
use Prado\Util\TLogger;
/**
* TApplication class.
*
* TApplication coordinates modules and services, and serves as a configuration
* context for all Prado components.
*
* TApplication uses a configuration file to specify the settings of
* the application, the modules, the services, the parameters, and so on.
*
* TApplication adopts a modular structure. A TApplication instance is a composition
* of multiple modules. A module is an instance of class implementing
* {@link IModule} interface. Each module accomplishes certain functionalities
* that are shared by all Prado components in an application.
* There are default modules and user-defined modules. The latter offers extreme
* flexibility of extending TApplication in a plug-and-play fashion.
* Modules cooperate with each other to serve a user request by following
* a sequence of lifecycles predefined in TApplication.
*
* TApplication has four modes that can be changed by setting {@link setMode Mode}
* property (in the application configuration file).
* - Off mode will prevent the application from serving user requests.
* - Debug mode is mainly used during application development. It ensures
* the cache is always up-to-date if caching is enabled. It also allows
* exceptions are displayed with rich context information if they occur.
* - Normal mode is mainly used during production stage. Exception information
* will only be recorded in system error logs. The cache is ensured to be
* up-to-date if it is enabled.
* - Performance mode is similar to Normal mode except that it
* does not ensure the cache is up-to-date.
*
* TApplication dispatches each user request to a particular service which
* finishes the actual work for the request with the aid from the application
* modules.
*
* TApplication maintains a lifecycle with the following stages:
* - [construct] : construction of the application instance
* - [initApplication] : load application configuration and instantiate modules and the requested service
* - onBeginRequest : this event happens right after application initialization
* - onAuthentication : this event happens when authentication is needed for the current request
* - onAuthenticationComplete : this event happens right after the authentication is done for the current request
* - onAuthorization : this event happens when authorization is needed for the current request
* - onAuthorizationComplete : this event happens right after the authorization is done for the current request
* - onLoadState : this event happens when application state needs to be loaded
* - onLoadStateComplete : this event happens right after the application state is loaded
* - onPreRunService : this event happens right before the requested service is to run
* - runService : the requested service runs
* - onSaveState : this event happens when application needs to save its state
* - onSaveStateComplete : this event happens right after the application saves its state
* - onPreFlushOutput : this event happens right before the application flushes output to client side.
* - flushOutput : the application flushes output to client side.
* - onEndRequest : this is the last stage a request is being completed
* - [destruct] : destruction of the application instance
* Modules and services can attach their methods to one or several of the above
* events and do appropriate processing when the events are raised. By this way,
* the application is able to coordinate the activities of modules and services
* in the above order. To terminate an application before the whole lifecycle
* completes, call {@link completeRequest}.
*
* Examples:
* - Create and run a Prado application:
*
* $application=new TApplication($configFile);
* $application->run();
*
*
* @author Qiang Xue
* @package Prado
* @since 3.0
*/
class TApplication extends \Prado\TComponent
{
/**
* possible application mode.
* @deprecated deprecated since version 3.0.4 (use TApplicationMode constants instead)
*/
const STATE_OFF='Off';
const STATE_DEBUG='Debug';
const STATE_NORMAL='Normal';
const STATE_PERFORMANCE='Performance';
/**
* Page service ID
*/
const PAGE_SERVICE_ID='page';
/**
* Application configuration file name
*/
const CONFIG_FILE_XML='application.xml';
/**
* File extension for external config files
*/
const CONFIG_FILE_EXT_XML='.xml';
/**
* Configuration file type, application.xml and config.xml
*/
const CONFIG_TYPE_XML = 'xml';
/**
* Application configuration file name
*/
const CONFIG_FILE_PHP='application.php';
/**
* File extension for external config files
*/
const CONFIG_FILE_EXT_PHP='.php';
/**
* Configuration file type, application.php and config.php
*/
const CONFIG_TYPE_PHP = 'php';
/**
* Runtime directory name
*/
const RUNTIME_PATH='runtime';
/**
* Config cache file
*/
const CONFIGCACHE_FILE='config.cache';
/**
* Global data file
*/
const GLOBAL_FILE='global.cache';
/**
* @var array list of events that define application lifecycles
*/
private static $_steps=array(
'onBeginRequest',
'onLoadState',
'onLoadStateComplete',
'onAuthentication',
'onAuthenticationComplete',
'onAuthorization',
'onAuthorizationComplete',
'onPreRunService',
'runService',
'onSaveState',
'onSaveStateComplete',
'onPreFlushOutput',
'flushOutput'
);
/**
* @var string application ID
*/
private $_id;
/**
* @var string unique application ID
*/
private $_uniqueID;
/**
* @var boolean whether the request is completed
*/
private $_requestCompleted=false;
/**
* @var integer application state
*/
private $_step;
/**
* @var array available services and their configurations indexed by service IDs
*/
private $_services;
/**
* @var IService current service instance
*/
private $_service;
/**
* @var array list of loaded application modules
*/
private $_modules=array();
/**
* @var array list of application modules yet to be loaded
*/
private $_lazyModules=array();
/**
* @var \Prado\Collections\TMap list of application parameters
*/
private $_parameters;
/**
* @var string configuration file
*/
private $_configFile;
/**
* @var string configuration file extension
*/
private $_configFileExt;
/**
* @var string configuration type
*/
private $_configType;
/**
* @var string application base path
*/
private $_basePath;
/**
* @var string directory storing application state
*/
private $_runtimePath;
/**
* @var boolean if any global state is changed during the current request
*/
private $_stateChanged=false;
/**
* @var array global variables (persistent across sessions, requests)
*/
private $_globals=array();
/**
* @var string cache file
*/
private $_cacheFile;
/**
* @var TErrorHandler error handler module
*/
private $_errorHandler;
/**
* @var THttpRequest request module
*/
private $_request;
/**
* @var THttpResponse response module
*/
private $_response;
/**
* @var THttpSession session module, could be null
*/
private $_session;
/**
* @var ICache cache module, could be null
*/
private $_cache;
/**
* @var IStatePersister application state persister
*/
private $_statePersister;
/**
* @var IUser user instance, could be null
*/
private $_user;
/**
* @var TGlobalization module, could be null
*/
private $_globalization;
/**
* @var TSecurityManager security manager module
*/
private $_security;
/**
* @var TAssetManager asset manager module
*/
private $_assetManager;
/**
* @var TAuthorizationRuleCollection collection of authorization rules
*/
private $_authRules;
/**
* @var TApplicationMode application mode
*/
private $_mode=TApplicationMode::Debug;
/**
* @var string Customizable page service ID
*/
private $_pageServiceID = self::PAGE_SERVICE_ID;
/**
* Constructor.
* Sets application base path and initializes the application singleton.
* Application base path refers to the root directory storing application
* data and code not directly accessible by Web users.
* By default, the base path is assumed to be the protected
* directory under the directory containing the current running script.
* @param string application base path or configuration file path.
* If the parameter is a file, it is assumed to be the application
* configuration file, and the directory containing the file is treated
* as the application base path.
* If it is a directory, it is assumed to be the application base path,
* and within that directory, a file named application.xml
* will be looked for. If found, the file is considered as the application
* configuration file.
* @param boolean whether to cache application configuration. Defaults to true.
* @throws TConfigurationException if configuration file cannot be read or the runtime path is invalid.
*/
public function __construct($basePath='protected',$cacheConfig=true, $configType=self::CONFIG_TYPE_XML)
{
// register application as a singleton
Prado::setApplication($this);
$this->setConfigurationType($configType);
$this->resolvePaths($basePath);
if($cacheConfig)
$this->_cacheFile=$this->_runtimePath.DIRECTORY_SEPARATOR.self::CONFIGCACHE_FILE;
// generates unique ID by hashing the runtime path
$this->_uniqueID=md5($this->_runtimePath);
$this->_parameters=new \Prado\Collections\TMap;
$this->_services=array($this->getPageServiceID()=>array('TPageService',array(),null));
Prado::setPathOfAlias('Application',$this->_basePath);
}
/**
* Resolves application-relevant paths.
* This method is invoked by the application constructor
* to determine the application configuration file,
* application root path and the runtime path.
* @param string the application root path or the application configuration file
* @see setBasePath
* @see setRuntimePath
* @see setConfigurationFile
*/
protected function resolvePaths($basePath)
{
// determine configuration path and file
if(empty($basePath) || ($basePath=realpath($basePath))===false)
throw new TConfigurationException('application_basepath_invalid',$basePath);
if(is_dir($basePath) && is_file($basePath.DIRECTORY_SEPARATOR.$this->getConfigurationFileName()))
$configFile=$basePath.DIRECTORY_SEPARATOR.$this->getConfigurationFileName();
else if(is_file($basePath))
{
$configFile=$basePath;
$basePath=dirname($configFile);
}
else
$configFile=null;
// determine runtime path
$runtimePath=$basePath.DIRECTORY_SEPARATOR.self::RUNTIME_PATH;
if(is_writable($runtimePath))
{
if($configFile!==null)
{
$runtimePath.=DIRECTORY_SEPARATOR.basename($configFile).'-'.Prado::getVersion();
if(!is_dir($runtimePath))
{
if(@mkdir($runtimePath)===false)
throw new TConfigurationException('application_runtimepath_failed',$runtimePath);
@chmod($runtimePath, PRADO_CHMOD); //make it deletable
}
$this->setConfigurationFile($configFile);
}
$this->setBasePath($basePath);
$this->setRuntimePath($runtimePath);
}
else
throw new TConfigurationException('application_runtimepath_invalid',$runtimePath);
}
/**
* Executes the lifecycles of the application.
* This is the main entry function that leads to the running of the whole
* Prado application.
*/
public function run()
{
try
{
$this->initApplication();
$n=count(self::$_steps);
$this->_step=0;
$this->_requestCompleted=false;
while($this->_step<$n)
{
if($this->_mode===self::STATE_OFF)
throw new THttpException(503,'application_unavailable');
if($this->_requestCompleted)
break;
$method=self::$_steps[$this->_step];
Prado::trace("Executing $method()",'Prado\TApplication');
$this->$method();
$this->_step++;
}
}
catch(\Exception $e)
{
$this->onError($e);
}
$this->onEndRequest();
}
/**
* Completes current request processing.
* This method can be used to exit the application lifecycles after finishing
* the current cycle.
*/
public function completeRequest()
{
$this->_requestCompleted=true;
}
/**
* @return boolean whether the current request is processed.
*/
public function getRequestCompleted()
{
return $this->_requestCompleted;
}
/**
* Returns a global value.
*
* A global value is one that is persistent across users sessions and requests.
* @param string the name of the value to be returned
* @param mixed the default value. If $key is not found, $defaultValue will be returned
* @return mixed the global value corresponding to $key
*/
public function getGlobalState($key,$defaultValue=null)
{
return isset($this->_globals[$key])?$this->_globals[$key]:$defaultValue;
}
/**
* Sets a global value.
*
* A global value is one that is persistent across users sessions and requests.
* Make sure that the value is serializable and unserializable.
* @param string the name of the value to be set
* @param mixed the global value to be set
* @param mixed the default value. If $key is not found, $defaultValue will be returned
* @param boolean wheter to force an immediate GlobalState save. defaults to false
*/
public function setGlobalState($key,$value,$defaultValue=null,$forceSave=false)
{
$this->_stateChanged=true;
if($value===$defaultValue)
unset($this->_globals[$key]);
else
$this->_globals[$key]=$value;
if($forceSave)
$this->saveGlobals();
}
/**
* Clears a global value.
*
* The value cleared will no longer be available in this request and the following requests.
* @param string the name of the value to be cleared
*/
public function clearGlobalState($key)
{
$this->_stateChanged=true;
unset($this->_globals[$key]);
}
/**
* Loads global values from persistent storage.
* This method is invoked when {@link onLoadState OnLoadState} event is raised.
* After this method, values that are stored in previous requests become
* available to the current request via {@link getGlobalState}.
*/
protected function loadGlobals()
{
$this->_globals=$this->getApplicationStatePersister()->load();
}
/**
* Saves global values into persistent storage.
* This method is invoked when {@link onSaveState OnSaveState} event is raised.
*/
protected function saveGlobals()
{
if($this->_stateChanged)
{
$this->_stateChanged=false;
$this->getApplicationStatePersister()->save($this->_globals);
}
}
/**
* @return string application ID
*/
public function getID()
{
return $this->_id;
}
/**
* @param string application ID
*/
public function setID($value)
{
$this->_id=$value;
}
/**
* @return string page service ID
*/
public function getPageServiceID()
{
return $this->_pageServiceID;
}
/**
* @param string page service ID
*/
public function setPageServiceID($value)
{
$this->_pageServiceID=$value;
}
/**
* @return string an ID that uniquely identifies this Prado application from the others
*/
public function getUniqueID()
{
return $this->_uniqueID;
}
/**
* @return TApplicationMode application mode. Defaults to TApplicationMode::Debug.
*/
public function getMode()
{
return $this->_mode;
}
/**
* @param TApplicationMode application mode
*/
public function setMode($value)
{
$this->_mode=TPropertyValue::ensureEnum($value,'\Prado\TApplicationMode');
}
/**
* @return string the directory containing the application configuration file (absolute path)
*/
public function getBasePath()
{
return $this->_basePath;
}
/**
* @param string the directory containing the application configuration file
*/
public function setBasePath($value)
{
$this->_basePath=$value;
}
/**
* @return string the application configuration file (absolute path)
*/
public function getConfigurationFile()
{
return $this->_configFile;
}
/**
* @param string the application configuration file (absolute path)
*/
public function setConfigurationFile($value)
{
$this->_configFile=$value;
}
/**
* @return string the application configuration file (absolute path)
*/
public function getConfigurationType()
{
return $this->_configType;
}
/**
* @param string the application configuration type. 'xml' and 'php' are valid values
*/
public function setConfigurationType($value)
{
$this->_configType = $value;
}
/**
* @return string the application configuration type. default is 'xml'
*/
public function getConfigurationFileExt()
{
if($this->_configFileExt===null)
{
switch($this->_configType)
{
case TApplication::CONFIG_TYPE_PHP:
$this->_configFileExt = TApplication::CONFIG_FILE_EXT_PHP;
break;
default:
$this->_configFileExt = TApplication::CONFIG_FILE_EXT_XML;
}
}
return $this->_configFileExt;
}
/**
* @return string the default configuration file name
*/
public function getConfigurationFileName()
{
static $fileName;
if($fileName == null)
{
switch($this->_configType)
{
case TApplication::CONFIG_TYPE_PHP:
$fileName = TApplication::CONFIG_FILE_PHP;
break;
default:
$fileName = TApplication::CONFIG_FILE_XML;
}
}
return $fileName;
}
/**
* @return string the directory storing cache data and application-level persistent data. (absolute path)
*/
public function getRuntimePath()
{
return $this->_runtimePath;
}
/**
* @param string the directory storing cache data and application-level persistent data. (absolute path)
*/
public function setRuntimePath($value)
{
$this->_runtimePath=$value;
if($this->_cacheFile)
$this->_cacheFile=$this->_runtimePath.DIRECTORY_SEPARATOR.self::CONFIGCACHE_FILE;
// generates unique ID by hashing the runtime path
$this->_uniqueID=md5($this->_runtimePath);
}
/**
* @return IService the currently requested service
*/
public function getService()
{
return $this->_service;
}
/**
* @param IService the currently requested service
*/
public function setService($value)
{
$this->_service=$value;
}
/**
* Adds a module to application.
* Note, this method does not do module initialization.
* @param string ID of the module
* @param IModule module object or null if the module has not been loaded yet
*/
public function setModule($id, IModule $module=null)
{
if(isset($this->_modules[$id]))
throw new TConfigurationException('application_moduleid_duplicated',$id);
else
$this->_modules[$id]=$module;
}
/**
* @return IModule the module with the specified ID, null if not found
*/
public function getModule($id)
{
if(!array_key_exists($id, $this->_modules))
return null;
// force loading of a lazy module
if($this->_modules[$id]===null)
{
$module = $this->internalLoadModule($id, true);
$module[0]->init($module[1]);
}
return $this->_modules[$id];
}
/**
* Returns a list of application modules indexed by module IDs.
* Modules that have not been loaded yet are returned as null objects.
* @return array list of loaded application modules, indexed by module IDs
*/
public function getModules()
{
return $this->_modules;
}
/**
* Returns the list of application parameters.
* Since the parameters are returned as a {@link \Prado\Collections\TMap} object, you may use
* the returned result to access, add or remove individual parameters.
* @return \Prado\Collections\TMap the list of application parameters
*/
public function getParameters()
{
return $this->_parameters;
}
/**
* @return THttpRequest the request module
*/
public function getRequest()
{
if(!$this->_request)
{
$this->_request=new \Prado\Web\THttpRequest;
$this->_request->init(null);
}
return $this->_request;
}
/**
* @param THttpRequest the request module
*/
public function setRequest(THttpRequest $request)
{
$this->_request=$request;
}
/**
* @return THttpResponse the response module
*/
public function getResponse()
{
if(!$this->_response)
{
$this->_response=new THttpResponse;
$this->_response->init(null);
}
return $this->_response;
}
/**
* @param THttpRequest the request module
*/
public function setResponse(THttpResponse $response)
{
$this->_response=$response;
}
/**
* @return THttpSession the session module, null if session module is not installed
*/
public function getSession()
{
if(!$this->_session)
{
$this->_session=new THttpSession;
$this->_session->init(null);
}
return $this->_session;
}
/**
* @param THttpSession the session module
*/
public function setSession(THttpSession $session)
{
$this->_session=$session;
}
/**
* @return TErrorHandler the error handler module
*/
public function getErrorHandler()
{
if(!$this->_errorHandler)
{
$this->_errorHandler=new TErrorHandler;
$this->_errorHandler->init(null);
}
return $this->_errorHandler;
}
/**
* @param TErrorHandler the error handler module
*/
public function setErrorHandler(TErrorHandler $handler)
{
$this->_errorHandler=$handler;
}
/**
* @return TSecurityManager the security manager module
*/
public function getSecurityManager()
{
if(!$this->_security)
{
$this->_security=new TSecurityManager;
$this->_security->init(null);
}
return $this->_security;
}
/**
* @param TSecurityManager the security manager module
*/
public function setSecurityManager(TSecurityManager $sm)
{
$this->_security=$sm;
}
/**
* @return TAssetManager asset manager
*/
public function getAssetManager()
{
if(!$this->_assetManager)
{
$this->_assetManager=new TAssetManager;
$this->_assetManager->init(null);
}
return $this->_assetManager;
}
/**
* @param TAssetManager asset manager
*/
public function setAssetManager(TAssetManager $value)
{
$this->_assetManager=$value;
}
/**
* @return IStatePersister application state persister
*/
public function getApplicationStatePersister()
{
if(!$this->_statePersister)
{
$this->_statePersister=new TApplicationStatePersister;
$this->_statePersister->init(null);
}
return $this->_statePersister;
}
/**
* @param IStatePersister application state persister
*/
public function setApplicationStatePersister(IStatePersister $persister)
{
$this->_statePersister=$persister;
}
/**
* @return ICache the cache module, null if cache module is not installed
*/
public function getCache()
{
return $this->_cache;
}
/**
* @param ICache the cache module
*/
public function setCache(\Prado\Caching\ICache $cache)
{
$this->_cache=$cache;
}
/**
* @return IUser the application user
*/
public function getUser()
{
return $this->_user;
}
/**
* @param IUser the application user
*/
public function setUser(\Prado\Security\IUser $user)
{
$this->_user=$user;
}
/**
* @param boolean whether to create globalization if it does not exist
* @return TGlobalization globalization module
*/
public function getGlobalization($createIfNotExists=true)
{
if($this->_globalization===null && $createIfNotExists)
{
$this->_globalization=new TGlobalization;
$this->_globalization->init(null);
}
return $this->_globalization;
}
/**
* @param TGlobalization globalization module
*/
public function setGlobalization(\Prado\I18N\TGlobalization $glob)
{
$this->_globalization=$glob;
}
/**
* @return TAuthorizationRuleCollection list of authorization rules for the current request
*/
public function getAuthorizationRules()
{
if($this->_authRules===null)
$this->_authRules=new \Prado\Security\TAuthorizationRuleCollection;
return $this->_authRules;
}
protected function getApplicationConfigurationClass()
{
return '\Prado\TApplicationConfiguration';
}
protected function internalLoadModule($id, $force=false)
{
list($moduleClass, $initProperties, $configElement)=$this->_lazyModules[$id];
if(isset($initProperties['lazy']) && $initProperties['lazy'] && !$force)
{
Prado::trace("Postponed loading of lazy module $id ({$moduleClass})",'\Prado\TApplication');
$this->setModule($id, null);
return null;
}
Prado::trace("Loading module $id ({$moduleClass})",'\Prado\TApplication');
$module=Prado::createComponent($moduleClass);
foreach($initProperties as $name=>$value)
{
if($name==='lazy') continue;
$module->setSubProperty($name,$value);
}
$this->setModule($id,$module);
// keep the key to avoid reuse of the old module id
$this->_lazyModules[$id]=null;
return array($module,$configElement);
}
/**
* Applies an application configuration.
* @param TApplicationConfiguration the configuration
* @param boolean whether the configuration is specified within a service.
*/
public function applyConfiguration($config,$withinService=false)
{
if($config->getIsEmpty())
return;
// set path aliases and using namespaces
foreach($config->getAliases() as $alias=>$path)
Prado::setPathOfAlias($alias,$path);
foreach($config->getUsings() as $using)
Prado::using($using);
// set application properties
if(!$withinService)
{
foreach($config->getProperties() as $name=>$value)
$this->setSubProperty($name,$value);
}
if(empty($this->_services))
$this->_services=array($this->getPageServiceID()=>array('TPageService',array(),null));
// load parameters
foreach($config->getParameters() as $id=>$parameter)
{
if(is_array($parameter))
{
$component=Prado::createComponent($parameter[0]);
foreach($parameter[1] as $name=>$value)
$component->setSubProperty($name,$value);
$this->_parameters->add($id,$component);
}
else
$this->_parameters->add($id,$parameter);
}
// load and init modules specified in app config
$modules=array();
foreach($config->getModules() as $id=>$moduleConfig)
{
if(!is_string($id))
$id='_module'.count($this->_lazyModules);
$this->_lazyModules[$id]=$moduleConfig;
if($module = $this->internalLoadModule($id))
$modules[]=$module;
}
foreach($modules as $module)
$module[0]->init($module[1]);
// load service
foreach($config->getServices() as $serviceID=>$serviceConfig)
$this->_services[$serviceID]=$serviceConfig;
// external configurations
foreach($config->getExternalConfigurations() as $filePath=>$condition)
{
if($condition!==true)
$condition=$this->evaluateExpression($condition);
if($condition)
{
if(($path=Prado::getPathOfNamespace($filePath,$this->getConfigurationFileExt()))===null || !is_file($path))
throw new TConfigurationException('application_includefile_invalid',$filePath);
$cn=$this->getApplicationConfigurationClass();
$c=new $cn;
$c->loadFromFile($path);
$this->applyConfiguration($c,$withinService);
}
}
}
/**
* Loads configuration and initializes application.
* Configuration file will be read and parsed (if a valid cached version exists,
* it will be used instead). Then, modules are created and initialized;
* Afterwards, the requested service is created and initialized.
* @param string configuration file path (absolute or relative to current executing script)
* @param string cache file path, empty if no present or needed
* @throws TConfigurationException if module is redefined of invalid type, or service not defined or of invalid type
*/
protected function initApplication()
{
Prado::trace('Initializing application','Prado\TApplication');
if($this->_configFile!==null)
{
if($this->_cacheFile===null || @filemtime($this->_cacheFile)_configFile))
{
$config=new TApplicationConfiguration;
$config->loadFromFile($this->_configFile);
if($this->_cacheFile!==null)
file_put_contents($this->_cacheFile,serialize($config),LOCK_EX);
}
else
$config=unserialize(file_get_contents($this->_cacheFile));
$this->applyConfiguration($config,false);
}
if(($serviceID=$this->getRequest()->resolveRequest(array_keys($this->_services)))===null)
$serviceID=$this->getPageServiceID();
$this->startService($serviceID);
}
/**
* Starts the specified service.
* The service instance will be created. Its properties will be initialized
* and the configurations will be applied, if any.
* @param string service ID
*/
public function startService($serviceID)
{
if(isset($this->_services[$serviceID]))
{
list($serviceClass,$initProperties,$configElement)=$this->_services[$serviceID];
$service=Prado::createComponent($serviceClass);
if(!($service instanceof IService))
throw new THttpException(500,'application_service_invalid',$serviceClass);
if(!$service->getEnabled())
throw new THttpException(500,'application_service_unavailable',$serviceClass);
$service->setID($serviceID);
$this->setService($service);
foreach($initProperties as $name=>$value)
$service->setSubProperty($name,$value);
if($configElement!==null)
{
$config=new TApplicationConfiguration;
if($this->getConfigurationType()==self::CONFIG_TYPE_PHP)
$config->loadFromPhp($configElement,$this->getBasePath());
else
$config->loadFromXml($configElement,$this->getBasePath());
$this->applyConfiguration($config,true);
}
$service->init($configElement);
}
else
throw new THttpException(500,'application_service_unknown',$serviceID);
}
/**
* Raises OnError event.
* This method is invoked when an exception is raised during the lifecycles
* of the application.
* @param mixed event parameter
*/
public function onError($param)
{
Prado::log($param->getMessage(),TLogger::ERROR,'Prado\TApplication');
$this->raiseEvent('OnError',$this,$param);
$this->getErrorHandler()->handleError($this,$param);
}
/**
* Raises OnBeginRequest event.
* At the time when this method is invoked, application modules are loaded
* and initialized, user request is resolved and the corresponding service
* is loaded and initialized. The application is about to start processing
* the user request.
*/
public function onBeginRequest()
{
$this->raiseEvent('OnBeginRequest',$this,null);
}
/**
* Raises OnAuthentication event.
* This method is invoked when the user request needs to be authenticated.
*/
public function onAuthentication()
{
$this->raiseEvent('OnAuthentication',$this,null);
}
/**
* Raises OnAuthenticationComplete event.
* This method is invoked right after the user request is authenticated.
*/
public function onAuthenticationComplete()
{
$this->raiseEvent('OnAuthenticationComplete',$this,null);
}
/**
* Raises OnAuthorization event.
* This method is invoked when the user request needs to be authorized.
*/
public function onAuthorization()
{
$this->raiseEvent('OnAuthorization',$this,null);
}
/**
* Raises OnAuthorizationComplete event.
* This method is invoked right after the user request is authorized.
*/
public function onAuthorizationComplete()
{
$this->raiseEvent('OnAuthorizationComplete',$this,null);
}
/**
* Raises OnLoadState event.
* This method is invoked when the application needs to load state (probably stored in session).
*/
public function onLoadState()
{
$this->loadGlobals();
$this->raiseEvent('OnLoadState',$this,null);
}
/**
* Raises OnLoadStateComplete event.
* This method is invoked right after the application state has been loaded.
*/
public function onLoadStateComplete()
{
$this->raiseEvent('OnLoadStateComplete',$this,null);
}
/**
* Raises OnPreRunService event.
* This method is invoked right before the service is to be run.
*/
public function onPreRunService()
{
$this->raiseEvent('OnPreRunService',$this,null);
}
/**
* Runs the requested service.
*/
public function runService()
{
if($this->_service)
$this->_service->run();
}
/**
* Raises OnSaveState event.
* This method is invoked when the application needs to save state (probably stored in session).
*/
public function onSaveState()
{
$this->raiseEvent('OnSaveState',$this,null);
$this->saveGlobals();
}
/**
* Raises OnSaveStateComplete event.
* This method is invoked right after the application state has been saved.
*/
public function onSaveStateComplete()
{
$this->raiseEvent('OnSaveStateComplete',$this,null);
}
/**
* Raises OnPreFlushOutput event.
* This method is invoked right before the application flushes output to client.
*/
public function onPreFlushOutput()
{
$this->raiseEvent('OnPreFlushOutput',$this,null);
}
/**
* Flushes output to client side.
* @param boolean whether to continue buffering after flush if buffering was active
*/
public function flushOutput($continueBuffering = true)
{
$this->getResponse()->flush($continueBuffering);
}
/**
* Raises OnEndRequest event.
* This method is invoked when the application completes the processing of the request.
*/
public function onEndRequest()
{
$this->flushOutput(false); // flush all remaining content in the buffer
$this->saveGlobals(); // save global state
$this->raiseEvent('OnEndRequest',$this,null);
}
}