Eight Phases of Drupal 7 Bootstrap

The moment a web browser requests a page, Drupal begins running a complex series of steps that result
in a fully rendered page being returned to the browser. With every page request, Drupal has to do those
same calculations,

The web server’s PHP interpreter parses index.php and executes the code. Drupal’s developers have
organized the process of creating a Drupal page into two sequences: bootstrap and execution of the page
callback associated with the current path. This division allows the use of a working Drupal environment
for applications other than generating web pages

All start with index.php file:

/**
 * @file
 * The PHP page that serves all page requests on a Drupal installation.
 *
 * The routines here dispatch control to the appropriate handler, which then
 * prints the appropriate page.
 *
 * All Drupal code is released under the GNU General Public License.
 * See COPYRIGHT.txt and LICENSE.txt.
 */
 
/**
 * Root directory of Drupal installation.
 */
define('DRUPAL_ROOT', getcwd());
 
require_once DRUPAL_ROOT . '/includes/bootstrap.inc';
drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
menu_execute_active_handler();

Now, let's take a look at the bootstrap.inc files,
The task of the bootstrap is to set the stage for business logic and theming to take place by including all
necessary libraries, preparing a database connection, and reading the configuration. It is accomplished
in separate phases, and each phase must be executed only once and in a particular order. This is
enforced by the drupal_bootstrap() function and by having a constant integer assigned to the phases
that represent their processing order , drupal_bootstrap() is called with the bootstrap
phase that should be reached as a parameter.

/**
 * First bootstrap phase: initialize configuration.
 */
define('DRUPAL_BOOTSTRAP_CONFIGURATION', 0);
 
/**
 * Second bootstrap phase: try to serve a cached page.
 */
define('DRUPAL_BOOTSTRAP_PAGE_CACHE', 1);
 
/**
 * Third bootstrap phase: initialize database layer.
 */
define('DRUPAL_BOOTSTRAP_DATABASE', 2);
 
/**
 * Fourth bootstrap phase: initialize the variable system.
 */
define('DRUPAL_BOOTSTRAP_VARIABLES', 3);
 
/**
 * Fifth bootstrap phase: initialize session handling.
 */
define('DRUPAL_BOOTSTRAP_SESSION', 4);
 
/**
 * Sixth bootstrap phase: set up the page header.
 */
define('DRUPAL_BOOTSTRAP_PAGE_HEADER', 5);
 
/**
 * Seventh bootstrap phase: find out language of the page.
 */
define('DRUPAL_BOOTSTRAP_LANGUAGE', 6);
 
/**
 * Final bootstrap phase: Drupal is fully loaded; validate and fix input data.
 */
define('DRUPAL_BOOTSTRAP_FULL', 7);
 
/**
 * Ensures Drupal is bootstrapped to the specified phase.
 *
 * In order to bootstrap Drupal from another PHP script, you can use this code:
 * @code
 *   define('DRUPAL_ROOT', '/path/to/drupal');
 *   require_once DRUPAL_ROOT . '/includes/bootstrap.inc';
 *   drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
 * @endcode
 *
 * @param int $phase
 *   A constant telling which phase to bootstrap to. When you bootstrap to a
 *   particular phase, all earlier phases are run automatically. Possible
 *   values:
 *   - DRUPAL_BOOTSTRAP_CONFIGURATION: Initializes configuration.
 *   - DRUPAL_BOOTSTRAP_PAGE_CACHE: Tries to serve a cached page.
 *   - DRUPAL_BOOTSTRAP_DATABASE: Initializes the database layer.
 *   - DRUPAL_BOOTSTRAP_VARIABLES: Initializes the variable system.
 *   - DRUPAL_BOOTSTRAP_SESSION: Initializes session handling.
 *   - DRUPAL_BOOTSTRAP_PAGE_HEADER: Sets up the page header.
 *   - DRUPAL_BOOTSTRAP_LANGUAGE: Finds out the language of the page.
 *   - DRUPAL_BOOTSTRAP_FULL: Fully loads Drupal. Validates and fixes input
 *     data.
 * @param boolean $new_phase
 *   A boolean, set to FALSE if calling drupal_bootstrap from inside a
 *   function called from drupal_bootstrap (recursion).
 *
 * @return int
 *   The most recently completed phase.
 */
function drupal_bootstrap($phase = NULL, $new_phase = TRUE) {
  // Not drupal_static(), because does not depend on any run-time information.
  static $phases = array(
    DRUPAL_BOOTSTRAP_CONFIGURATION,
    DRUPAL_BOOTSTRAP_PAGE_CACHE,
    DRUPAL_BOOTSTRAP_DATABASE,
    DRUPAL_BOOTSTRAP_VARIABLES,
    DRUPAL_BOOTSTRAP_SESSION,
    DRUPAL_BOOTSTRAP_PAGE_HEADER,
    DRUPAL_BOOTSTRAP_LANGUAGE,
    DRUPAL_BOOTSTRAP_FULL,
  );
  // Not drupal_static(), because the only legitimate API to control this is to
  // call drupal_bootstrap() with a new phase parameter.
  static $final_phase;
  // Not drupal_static(), because it's impossible to roll back to an earlier
  // bootstrap state.
  static $stored_phase = -1;
 
  if (isset($phase)) {
    // When not recursing, store the phase name so it's not forgotten while
    // recursing but take care of not going backwards.
    if ($new_phase && $phase >= $stored_phase) {
      $final_phase = $phase;
    }
 
    // Call a phase if it has not been called before and is below the requested
    // phase.
    while ($phases && $phase > $stored_phase && $final_phase > $stored_phase) {
      $current_phase = array_shift($phases);
 
      // This function is re-entrant. Only update the completed phase when the
      // current call actually resulted in a progress in the bootstrap process.
      if ($current_phase > $stored_phase) {
        $stored_phase = $current_phase;
      }
 
      switch ($current_phase) {
        case DRUPAL_BOOTSTRAP_CONFIGURATION:
          _drupal_bootstrap_configuration();
          break;
 
        case DRUPAL_BOOTSTRAP_PAGE_CACHE:
          _drupal_bootstrap_page_cache();
          break;
 
        case DRUPAL_BOOTSTRAP_DATABASE:
          _drupal_bootstrap_database();
          break;
 
        case DRUPAL_BOOTSTRAP_VARIABLES:
          _drupal_bootstrap_variables();
          break;
 
        case DRUPAL_BOOTSTRAP_SESSION:
          require_once DRUPAL_ROOT . '/' . variable_get('session_inc', 'includes/session.inc');
          drupal_session_initialize();
          break;
 
        case DRUPAL_BOOTSTRAP_PAGE_HEADER:
          _drupal_bootstrap_page_header();
          break;
 
        case DRUPAL_BOOTSTRAP_LANGUAGE:
          drupal_language_initialize();
          break;
 
        case DRUPAL_BOOTSTRAP_FULL:
          require_once DRUPAL_ROOT . '/includes/common.inc';
          _drupal_bootstrap_full();
          break;
      }
    }
  }
  return $stored_phase;
}

1. First Bootstrap Phase: Initialize Configuration
In phase one, settings.php is read from the sites/default folder and the most important global variables
are set, either directly from settings.php like $databases or by computing their value based on the server
environment. Here are three you will need in your daily site developer’s life:
$base_url: The base URL all your Drupal pages share. Each path is appended to it.
It must be a valid URL without a trailing slash. This only needs to be set if Drupal
does not determine it correctly.
$base_url = '<a href="http://www.example.com/drupal';">http://www.example.com/drupal';</a> // NO trailing slash!1
$base_path: The base URL’s path component (either ‘/’ or anything following the
domain part) with a trailing slash appended. It is derived from $base_url and can
be handy on its own.
$base_path = '/drupal/';
$base_root: Contains the protocol and domain parts of the URL. It is either the
base URL or derived from it by removing the base path if there is any.
$base_root = '<a href="http://www.example.com';">http://www.example.com';[/geshifilter-ruby]

2. Second Bootstrap Phase: Try to Serve a Cached Page
During the second bootstrap phase Drupal tries to deliver the whole page from its cache in case page
caching is enabled in the Performance section of the configuration interface and the visitor is not logged
in. If a cached version of the page can be found and is not expired, it is sent between invoking hook_boot() and hook_exit().
If the cache back end requires a database connection (determined by
$conf['page_cache_without_database'] in settings.php), the third and fourth bootstrap phases are
executed before fetching the cached page.
Debugging page caching is eased by an additional HTTP header the Drupal developers have
introduced for this purpose: if the page is actually served from cache, the X-Drupal-Cache HTTP header
is set to HIT; otherwise, its value is set to MISS

3.Third Bootstrap Phase: Initialize the Database Layer
The database abstraction layer is set up in this phase. Because there’s no need to open a connection yet,
only the base classes and utility functions (db_query, et al) are included. In addition, callbacks for
autoloading classes and interfaces are registered with the Standard PHP Library (SPL) autoload stack3.
The files containing classes and interfaces are declared by modules’ .info files or live in the main include
folder, and Drupal maintains a registry to track them. The first time a class or interface is needed during
execution, the callbacks use this registry to include the necessary file.

4. Fourth Bootstrap Phase: Initialize the Variable System
In the fourth bootstrap phase, Drupal fetches all values from the variable database table (which includes
both configuration settings and persistent variables) and merges them with those defined in
settings.php in the global variable $conf. Values set in the file via $conf['variable_name'] take
precedence over those stored in the database; in other words, you can prevent variables from being
overridden through the UI by defining them in the settings.php file.

The $conf variable takes the form of a giant associative array. Its values can be obtained by calling
variable_get('key_name', 'a default value'). Variables can be persisted by calling
variable_set('key_name', 'value') in your code

In addition to the variables, all modules required during bootstrap are loaded, implementing hooks
called during bootstrap, hook_boot(), hook_exit(), hook_language_init(), and hook_watchdog().

5.Fifth Bootstrap Phase: Initialize Session Handling
Things covered so far: database, settings, variables, some common Drupal functions and constants,
global variables, and bootstrap modules.
In this phase, Drupal registers its session handler and a session is associated for already
authenticated users. Usually, anonymous users won’t get a session at all unless something needs to be
stored in $_SESSION; for this case, a session ID is pregenerated. This allows HTTP proxy caching for
anonymous visitors. If Drupal can’t detect a logged in user, a dummy user object is created during this
phase that represents the anonymous visitor with a user ID 0 in Drupal’s database.
If you need fancier session handling than Drupal’s own database solution, you can include an
alternative by pointing $['conf']['session_inc'] in settings.php to a file containing the functions that
need to be implemented. Sites with many authenticated visitors can benefit from a more efficient
session storage.

6.Sixth Bootstrap Phase: Set up the Page Header
After all that nice setup, the first output is generated to be sent to the site’s visitor: the HTTP headers.
The default headers Drupal sends to the client only affect caching. To be precise: No byte is sent on its
way to the visitor because Drupal operates in output buffering mode. In other words, nothing leaves the
server until the buffer is flushed, which happens at the final stage of the cycle. Wait! Something happens
before: hook_boot() is invoked, giving modules a first opportunity to intervene in the page creation cycle.
Note that this hook must be disabled to support external caching mechanisms

7. Seventh Bootstrap Phase: Find out the Language of the Page
The next-to-last step in the bootstrap process deals with language selection for the current visitor if the
site is multilingual. Once the language is determined, implementations of hook_language_init() can
react, for instance by setting language dependent variables.

Language Negotiation Algorithms
Negotiation algorithms that determine which language to use can be provided by
hook_language_negotiation_info() and existing ones can be modified by
hook_language_negotiation_info_alter(). The providers will have a chance to determine a language in
the order they are set by the site admin at the language configuration page
(admin/config/regional/language/configure). Each defined negotiation algorithm must provide a
callback to determine the language. Language selection stops as soon as a provider returns a valid
language.
Here is an example of a language provider:

$providers[LOCALE_LANGUAGE_NEGOTIATION_URL] = array(
'types' => array(LANGUAGE_TYPE_CONTENT, LANGUAGE_TYPE_INTERFACE, LANGUAGE_TYPE_URL),
'callbacks' => array(
'language' => 'locale_language_from_url',
'switcher' => 'locale_language_switcher_url',
'url_rewrite' => 'locale_language_url_rewrite_url',
),
'file' => $file,
'weight' => -8,
'name' => t('URL'),
'description' => t('Determine the language from the URL (Path prefix or domain).'),
'config' => 'admin/config/regional/language/configure/url',
);

8. Final Bootstrap Phase: Load Modules and Initialize Theme
Finally drupal_bootstrap_full() is executed. All files containing the Drupal utility functions are
included. Enabled modules are loaded (in other words, the .module files are included). Modules get a
chance to register stream wrappers4 by means of hook_stream_wrappers() and modify existing ones with
hook_stream_wrapper_alter().The path in $_GET['q'] is normalized and the theme is initialized

Note: You can replace all or some of the original functions of Drupal’s menu system and path handling functions
by providing an alternative menu.inc or path.inc in settings.php. You might want to do this to improve the
performance of your Drupal site.