February 6, 2015

Front Controller Pattern

Magento uses the Front Controller pattern for the following purposes:

Receiving and processing browser data, transferring it to other system elements;
Defining controller and proper action to perform using routes;
Displaying browser-requested data using blocks, templates and model data.

Front Controller main structure is stored in Core module:
Mage/Core/Controller/Varien/Front.

Let’s review the basic steps of Front Controller initialization.

The first call is performed in Mage_Core_Model_App constructor:

/**

* Run application. Run process responsible for request processing and sending response.

* List of supported parameters:

* scope_code – code of default scope (website/store_group/store code)

* scope_type – type of default scope (website/group/store)

* options – configuration options

* @param array $params application run parameters

* @return Mage_Core_Model_App

public function run($params)

{

$options = isset($params[‘options’]) ? $params[‘options’] : array();

$this->baseInit($options);

Mage::register(‘application_params’, $params);

if ($this->_cache->processRequest()) {

$this->getResponse()->sendResponse();

} else {

$this->_initModules();

$this->loadAreaPart(Mage_Core_Model_App_Area::AREA_GLOBAL, Mage_Core_Model_App_Area::PART_EVENTS);

if ($this->_config->isLocalConfigLoaded()) {

$scopeCode = isset($params[‘scope_code’]) ? $params[‘scope_code’] : ”;

$scopeType = isset($params[‘scope_type’]) ? $params[‘scope_type’] : ‘store’;

$this->_initCurrentStore($scopeCode, $scopeType);

$this->_initRequest();

Mage_Core_Model_Resource_Setup::applyAllDataUpdates();

}

$this->getFrontController()->dispatch();

}

return $this;

}

wherein getFrontController method is called. Before current request processing starts, Mage_Core_Controller_Varien_Front object is created and its initialization is called.

/**

* Initialize application front controller

* @return Mage_Core_Model_App

protected function _initFrontController()

{

$this->_frontController = new Mage_Core_Controller_Varien_Front();

Mage::register(‘controller’, $this->_frontController);

Varien_Profiler::start(‘mage::app::init_front_controller’);

$this->_frontController->init();

Varien_Profiler::stop(‘mage::app::init_front_controller’);

return $this;

}

Let’s take a closer look at the init method:

/**

* Init Front Controller

* @return Mage_Core_Controller_Varien_Front

public function init()

{

Mage::dispatchEvent(‘controller_front_init_before’, array(‘front’=>$this));

$routersInfo = Mage::app()->getStore()->getConfig(self::XML_STORE_ROUTERS_PATH);

Varien_Profiler::start(‘mage::app::init_front_controller::collect_routers’);

foreach ($routersInfo as $routerCode => $routerInfo) {

if (isset($routerInfo[‘disabled’]) && $routerInfo[‘disabled’]) {

continue;

}

if (isset($routerInfo[‘class’])) {

$router = new $routerInfo[‘class’];

if (isset($routerInfo[‘area’])) {

$router->collectRoutes($routerInfo[‘area’], $routerCode);

}

$this->addRouter($routerCode, $router);

}

Varien_Profiler::stop(‘mage::app::init_front_controller::collect_routers’);

Mage::dispatchEvent(‘controller_front_init_routers’, array(‘front’=>$this));

// Add default router at the last

$default = new Mage_Core_Controller_Varien_Router_Default();

$this->addRouter(‘default’, $default);

return $this;

}

Controller_front_init_before event is initially called:

1	Mage::dispatchEvent(‘controller_front_init_before’, array(‘front’=>$this));

It can be used to set the $routerInfo[‘disabled’] flag and to determine routes your way.

Next, routes, determined in config.xml in web/routes section (global configuration), are selected. At this application initialization stage, these are admin and standard sections, i.e. admin routing areas are determined:

(Mage_Core_Controller_Varien_Router_Admin) and standard (Mage_Core_Controller_Varien_Router_Standard):

1	$routersInfo = Mage::app()->getStore()->getConfig(self::XML_STORE_ROUTERS_PATH);

<web>

<!— ... —>

<admin>

<area>admin</area>

<class>Mage_Core_Controller_Varien_Router_Admin</class>

</admin>

<area>frontend</area>

<class>Mage_Core_Controller_Varien_Router_Standard</class>

</standard>

</routers>

<!— ... —>

</web>

Next, all active modules are processed and specified ones are added to their routes configurations:

foreach ($routersInfo as $routerCode => $routerInfo) {

if (isset($routerInfo[‘disabled’]) && $routerInfo[‘disabled’]) {

continue;

}

if (isset($routerInfo[‘class’])) {

$router = new $routerInfo[‘class’];

if (isset($routerInfo[‘area’])) {

$router->collectRoutes($routerInfo[‘area’], $routerCode);

}

$this->addRouter($routerCode, $router);

}

Next, controller_front_init_routers event is called:

1	Mage::dispatchEvent(‘controller_front_init_routers’, array(‘front’=>$this));

With the help of this event CMS module adds CMS routing area. We add our own routes as well.

Specified event:

<controller_front_init_routers>

<cms>

<class>Mage_Cms_Controller_Router</class>

<method>initControllerRouters</method>

</cms>

</observers>

</controller_front_init_routers>

</events>

</global>

method itself:

/**

* Initialize Controller Router

* @param Varien_Event_Observer $observer

public function initControllerRouters($observer)

{

/* @var $front Mage_Core_Controller_Varien_Front */

$front = $observer->getEvent()->getFront();

$front->addRouter(‘cms’, $this);

}

Default route is added after all (Mage_Core_Controller_Varien_Router_Default):

1 2	$default = new Mage_Core_Controller_Varien_Router_Default(); $this->addRouter(‘default’, $default);<span style=“font-family: Georgia, ‘Times New Roman’, ‘Bitstream Charter’, Times, serif; font-size: 13px; line-height: 19px;”> </span>

At the end we have routs processing order:

admin

standard

cms

default

Module route is determined in its config.xml

For a frontend:

<use>standard</use>

<args>

<module>My_Module</module>

<frontName>mymodule</frontName>

</args>

</mymodule>

</routers>

</frontend>

Frontend and Admin routs should differ.

After routes are formed, current browser request processing route is being determined (dispatch).

public function dispatch()

{

$request = $this->getRequest();

// If pre-configured, check equality of base URL and requested URL

$this->_checkBaseUrl($request);

$request->setPathInfo()->setDispatched(false);

if (!$request->isStraight()) {

Varien_Profiler::start(‘mage::dispatch::db_url_rewrite’);

Mage::getModel(‘core/url_rewrite’)->rewrite();

Varien_Profiler::stop(‘mage::dispatch::db_url_rewrite’);

}

Varien_Profiler::start(‘mage::dispatch::config_url_rewrite’);

$this->rewrite();

Varien_Profiler::stop(‘mage::dispatch::config_url_rewrite’);

Varien_Profiler::start(‘mage::dispatch::routers_match’);

$i = 0;

while (!$request->isDispatched() && $i++<100) {

foreach ($this->_routers as $router) {

if ($router->match($this->getRequest())) {

break;

}

Varien_Profiler::stop(‘mage::dispatch::routers_match’);

if ($i>100) {

Mage::throwException(‘Front controller reached 100 router match iterations’);

}

// This event gives possibility to launch something before sending output (allow cookie setting)

Mage::dispatchEvent(‘controller_front_send_response_before’, array(‘front’=>$this));

Varien_Profiler::start(‘mage::app::dispatch::send_response’);

$this->getResponse()->sendResponse();

Varien_Profiler::stop(‘mage::app::dispatch::send_response’);

Mage::dispatchEvent(‘controller_front_send_response_after’, array(‘front’=>$this));

return $this;

}

Main application address is checked:

1	$this->_checkBaseUrl($request);

Basic variables are prepared and flag of route correspondence in false is set. It determines if search should be continued or finished.

1	$request->setPathInfo()->setDispatched(false);

Rewrite is chosen from the database for the current request:

if (!$request->isStraight()) {

Varien_Profiler::start(‘mage::dispatch::db_url_rewrite’);

Mage::getModel(‘core/url_rewrite’)->rewrite();

Varien_Profiler::stop(‘mage::dispatch::db_url_rewrite’);

}

If there is a match, the address, corresponding to this rewrite, is followed. This is the custom url mechanism.

We also loop through rewrite, determined in global/routes configuration section:

Varien_Profiler::start(‘mage::dispatch::config_url_rewrite’);

$this->rewrite();

Varien_Profiler::stop(‘mage::dispatch::config_url_rewrite’);

Rewrite controllers are determined here:

<!— This is a class name for your controller —>

<mynamespace_mymodule_checkout_cart>

<!—Original controller route to be replaced —>

<!—Our controller route —>

<to>/mymodule/checkout_cart/</to>

</mynamespace_mymodule_checkout_cart>

</rewrite>

</global>

Next, corresponding controller is determined and required action is performed:

Varien_Profiler::start(‘mage::dispatch::routers_match’);

$i = 0;

while (!$request->isDispatched() && $i++<100) {

foreach ($this->_routers as $router) {

if ($router->match($this->getRequest())) {

break;

}

Varien_Profiler::stop(‘mage::dispatch::routers_match’);

if ($i>100) {

Mage::throwException(‘Front controller reached 100 router match iterations’);

}

Match search among all the known routes $this->_routers is performed.

1	$router->match($this->getRequest())

As soon as controller match is found, it is initialized and specified action or default action is performed (unless the action is determined directly in the request). Our later articles will explain routes as well as routes processing in greater detail.

As may be seen from the source code, the maximum number of attempts may not exceed 100.

Next, current request contents, including events before and after displaying setting, are prepared to be sent to the browser. Displaying can be prepared and changed in them correspondingly:

Mage::dispatchEvent(‘controller_front_send_response_before’, array(‘front’=>$this));

Varien_Profiler::start(‘mage::app::dispatch::send_response’);

$this->getResponse()->sendResponse();

Varien_Profiler::stop(‘mage::app::dispatch::send_response’);

Mage::dispatchEvent(‘controller_front_send_response_after’, array(‘front’=>$this));

February 6, 2015

Application Initialization (Magento Certified Developer Exam)

Magento initialization process starts in index.php (with the exception of Magento integrated with some other sites or CMS).

Let’s take a look at the code of this file. Magento developers made their comments using multi line comment and PHPDoc style comments, so for my own comments I’ll use one line style (so called c++ style) comments.

index.php

// Magento checks whether your PHP version is older than 5.2.0

// if not, error message is being displayed; you are suggested to install it once again and exit.

if (version_compare(phpversion(), ‘5.2.0’, ‘<‘)===true) {

echo ‘<div style=”font:12px/1.35em arial, helvetica, sans-serif;”>

Whoops, it looks like you have an invalid PHP version.</h3></div><p>Magento supports PHP 5.2.0 or newer.

<a href=”http://www.magentocommerce.com/install” target=””>Find out</a> how to install</a>

Magento using PHP-CGI as a work-around.</p></div>’;

exit;

}

/**

* Error reporting

error_reporting(E_ALL | E_STRICT);

/**

* Compilation includes configuration file

define(‘MAGENTO_ROOT’, getcwd());

// Include of compiler configuration

// If compiler is enabled in System -> Tools -> Compilation

// this will change loading pathes

// Magento classes will be put in one ‘src’ folder

$compilerConfig = MAGENTO_ROOT . ‘/includes/config.php’;

if (file_exists($compilerConfig)) {

include $compilerConfig;

}

// Include (require_once) of Mage.php file

// If file doesn’t exist redirect to downoader

// If it also doesn’t exist show error message

$mageFilename = MAGENTO_ROOT . ‘/app/Mage.php’;

$maintenanceFile = ‘maintenance.flag’;

if (!file_exists($mageFilename)) {

if (is_dir(‘downloader’)) {

header(“Location: downloader”);

} else {

echo $mageFilename.” was not found”;

}

exit;

}

if (file_exists($maintenanceFile)) {

include_once dirname(__FILE__) . ‘/errors/503.php’;

exit;

}

require_once $mageFilename;

//Enable Varien profiler by uncommenting this line

#Varien_Profiler::enable();

// Set Magento in developer Mode

// More info in Alan Storm’s article http://alanstorm.com/magento_exception_handling_developer_mode

if (isset($_SERVER[‘MAGE_IS_DEVELOPER_MODE’])) {

Mage::setIsDeveloperMode(true);

}

#ini_set(‘display_errors’, 1);

umask(0);

/* Store or website code */

// Magento accepts store code

// If you don’t specify anything it will use ‘default’

$mageRunCode = isset($_SERVER[‘MAGE_RUN_CODE’]) ? $_SERVER[‘MAGE_RUN_CODE’] : ”;

/* Run store or run website */

$mageRunType = isset($_SERVER[‘MAGE_RUN_TYPE’]) ? $_SERVER[‘MAGE_RUN_TYPE’] : ‘store’;

// app/Mage.php run() method

// Main application entry point

Mage::run($mageRunCode, $mageRunType);

Now we should dig into app/Mage.php. It contains about 1000 lines (to be precise, it’s 989), so we will explore the most important things only. However, I think it’s a good idea for you to open it and analyze the whole file.

At the beginning of the file Magento checks if Compilation mode was enabled. If compiler is not enabled, Magento will include default paths, load code pools, load app/code/core/Mage/functions.php (if it’s not overwritten in local or community pool), load lib/Varien/Autoload.php and finally call Varien_Autoload::register() method.

app/Mage.php

define(‘DS’, DIRECTORY_SEPARATOR);

define(‘PS’, PATH_SEPARATOR);

define(‘BP’, dirname(dirname(__FILE__)));

Mage::register(‘original_include_path’, get_include_path());

if (defined(‘COMPILER_INCLUDE_PATH’)) {

$appPath = COMPILER_INCLUDE_PATH;

set_include_path($appPath . PS . Mage::registry(‘original_include_path’));

include_once COMPILER_INCLUDE_PATH . DS . “Mage_Core_functions.php”;

include_once COMPILER_INCLUDE_PATH . DS . “Varien_Autoload.php”;

} else {

/**

* Set include path

$paths[] = BP . DS . ‘app’ . DS . ‘code’ . DS . ‘local’;

$paths[] = BP . DS . ‘app’ . DS . ‘code’ . DS . ‘community’;

$paths[] = BP . DS . ‘app’ . DS . ‘code’ . DS . ‘core’;

$paths[] = BP . DS . ‘lib’;

$appPath = implode(PS, $paths);

set_include_path($appPath . PS . Mage::registry(‘original_include_path’));

include_once “Mage/Core/functions.php”;

include_once “Varien/Autoload.php”;

}

Varien_Autoload::register();

In register() method from lib/Varien/autoload.php system registers auotload using PHPspl_autoload_register which “registers a function with the spl provided __autoload stack. If the stack is not yet activated, it will be.”

/**

* Register SPL autoload function

static public function register()

{

spl_autoload_register(array(self::instance(), ‘autoload’));

}

Finally, Magento executes autoload method, which loads all class source codes (and again: depending on whether Compilation mode enabled or not it could go different ways).

/**

* Load class source code

* @param string $class

public function autoload($class)

{

if ($this->_collectClasses) {

$this->_arrLoadedClasses[self::$_scope][] = $class;

}

if ($this->_isIncludePathDefined) {

$classFile = COMPILER_INCLUDE_PATH . DIRECTORY_SEPARATOR . $class;

} else {

$classFile = str_replace(‘ ‘, DIRECTORY_SEPARATOR, ucwords(str_replace(‘_’, ‘ ‘, $class)));

}

$classFile.= ‘.php’;

//echo $classFile;die();

return include $classFile;

}

So now we know that when Mage.php is included in index.php file, the include path set up and the auto loader is registered. After that, we can instantiate Models, Helpers and Blocks using static factory methods on the global Mage class (like Mage::getModel(‘catalog/product’))

As you remember, on the last line of index.php there was a call to Mage.php run() method (below I only put ‘try’ piece of this method without catch part). This is an entry point of front end rendering: request and response setters, initialization of global observers collection, etc.

/**

* Front end main entry point

* @param string $code

* @param string $type

* @param string|array $options

public static function run($code = ”, $type = ‘store’, $options = array())

{

try {

Varien_Profiler::start(‘mage’);

self::setRoot();

if (isset($options[‘edition’])) {

self::$_currentEdition = $options[‘edition’];

}

self::$_app = new Mage_Core_Model_App();

if (isset($options[‘request’])) {

self::$_app->setRequest($options[‘request’]);

}

if (isset($options[‘response’])) {

self::$_app->setResponse($options[‘response’]);

}

self::$_events = new Varien_Event_Collection();

self::_setIsInstalled($options);

self::_setConfigModel($options);

self::$_app->run(array(

‘scope_code’ => $code,

‘scope_type’ => $type,

‘options’ => $options,

));

Varien_Profiler::stop(‘mage’);

}

Next, have a look at Mage_Core_Model_App::run() where most of app initialization work is done, i.e. config loading, request and routing initialization – so this method can be called the heart of application initialization process!

app/code/core/Mage/Core/Model/App.php

/**

* Run application. Run process responsible for request processing and sending response.

* List of supported parameters:

* scope_code – code of default scope (website/store_group/store code)

* scope_type – type of default scope (website/group/store)

* options – configuration options

* @param array $params application run parameters

* @return Mage_Core_Model_App

public function run($params)

{

$options = isset($params[‘options’]) ? $params[‘options’] : array();

$this->baseInit($options);

Mage::register(‘application_params’, $params);

if ($this->_cache->processRequest()) {

$this->getResponse()->sendResponse();

} else {

$this->_initModules();

$this->loadAreaPart(Mage_Core_Model_App_Area::AREA_GLOBAL, Mage_Core_Model_App_Area::PART_EVENTS);

if ($this->_config->isLocalConfigLoaded()) {

$scopeCode = isset($params[‘scope_code’]) ? $params[‘scope_code’] : ”;

$scopeType = isset($params[‘scope_type’]) ? $params[‘scope_type’] : ‘store’;

$this->_initCurrentStore($scopeCode, $scopeType);

$this->_initRequest();

Mage_Core_Model_Resource_Setup::applyAllDataUpdates();

}

$this->getFrontController()->dispatch();

}

return $this;

}

In this method, Magento calls $this->baseInit($options), which in turn loads Mage::getConfig and _init that initializes base system configuration (local.xml and config.xml files) (base configuration provides ability to initialize DB connection and cache backend) by calling loadBase in app/code/core/Mage/Core/Model/Config.php.

/**

* Load base system configuration (config.xml and local.xml files)

* @return Mage_Core_Model_Config

public function loadBase()

{

$etcDir = $this->getOptions()->getEtcDir();

$files = glob($etcDir.DS.‘*.xml’);

$this->loadFile(current($files));

while ($file = next($files)) {

$merge = clone $this->_prototype;

$merge->loadFile($file);

$this->extend($merge);

}

if (in_array($etcDir.DS.‘local.xml’, $files)) {

$this->_isLocalConfigLoaded = true;

}

return $this;

}

After we loaded local.xml and config.xml files, Magento runs _initModules() of the same class. It, by-turn, initializes active modules configuration and data via Mage_Core_Model_Config::loadModules(). In this loadModules method, Magento loads all active modules from “etc” folders and combines data from the specified xml file names to one object with the help of loadModulesConfiguration().

Then system executes setup scripts via Mage_Core_Model_Resource_Setup::applyAllUpdates() and loads config data from DB via Mage_Core_Model_App::loadDb()

After that, request/store initialization happens

if ($this->_config->isLocalConfigLoaded()) {

$scopeCode = isset($params[‘scope_code’]) ? $params[‘scope_code’] : ”;

$scopeType = isset($params[‘scope_type’]) ? $params[‘scope_type’] : ‘store’;

//Init store, group and website collections

$this->_initCurrentStore($scopeCode, $scopeType);

//Init request object

$this->_initRequest();

//Apply database data updates whenever needed

Mage_Core_Model_Resource_Setup::applyAllDataUpdates();

}

And finally we have $this->getFrontController()->dispatch() So routing here is the domain of front controller. We already have the article on front controller pattern by Aleksander Tretjak describing its work in details.

I think that it’s always better to have a look into the source code to understand how things work, but in this case it’d be very helpful to see this request flow on the image. Here is a Magento request flow made by Pavel Novitsky.

M	T	W	T	F	S	S
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28

PHP T!PS & Tricks

Better sound through T!PS & Tricks

Day: February 6, 2015

Front Controller Pattern

Application Initialization (Magento Certified Developer Exam)