install.core.inc 103 KB
Newer Older
1
2
<?php

3
use Drupal\Component\Utility\UserAgent;
4
5
use Drupal\Component\Utility\Crypt;

6
use Drupal\Component\Utility\Settings;
7
use Drupal\Core\Config\FileStorage;
katbailey's avatar
katbailey committed
8
use Drupal\Core\DrupalKernel;
9
use Drupal\Core\Database\Database;
10
use Drupal\Core\Database\DatabaseExceptionWrapper;
11
use Drupal\Core\Database\Install\TaskException;
12
13
14
use Drupal\Core\Installer\Exception\AlreadyInstalledException;
use Drupal\Core\Installer\Exception\InstallerException;
use Drupal\Core\Installer\Exception\NoProfilesException;
15
use Drupal\Core\Language\Language;
16
use Drupal\Core\Language\LanguageManager;
17
use Drupal\Core\StringTranslation\Translator\FileTranslation;
18
use Drupal\Core\Extension\ExtensionDiscovery;
19
use Drupal\Core\DependencyInjection\ContainerBuilder;
20
use Symfony\Component\DependencyInjection\Reference;
21
use Symfony\Component\HttpFoundation\Request;
22
use Symfony\Component\HttpFoundation\Response;
23

24
25
use Guzzle\Http\Exception\RequestException;

26
27
28
29
30
31
/**
 * @file
 * API functions for installing Drupal.
 */

/**
32
 * Do not run the task during the current installation request.
33
34
35
36
37
38
39
40
41
 *
 * This can be used to skip running an installation task when certain
 * conditions are met, even though the task may still show on the list of
 * installation tasks presented to the user. For example, the Drupal installer
 * uses this flag to skip over the database configuration form when valid
 * database connection information is already available from settings.php. It
 * also uses this flag to skip language import tasks when the installation is
 * being performed in English.
 */
42
const INSTALL_TASK_SKIP = 1;
43
44

/**
45
 * Run the task on each installation request that reaches it.
46
47
48
 *
 * This is primarily used by the Drupal installer for bootstrap-related tasks.
 */
49
const INSTALL_TASK_RUN_IF_REACHED = 2;
50
51

/**
52
 * Run the task on each installation request until the database is set up.
53
54
55
56
57
58
59
60
 *
 * This is the default method for running tasks and should be used for most
 * tasks that occur after the database is set up; these tasks will then run
 * once and be marked complete once they are successfully finished. For
 * example, the Drupal installer uses this flag for the batch installation of
 * modules on the new site, and also for the configuration form that collects
 * basic site information and sets up the site maintenance account.
 */
61
const INSTALL_TASK_RUN_IF_NOT_COMPLETED = 3;
62
63

/**
64
 * Installs Drupal either interactively or via an array of passed-in settings.
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 *
 * The Drupal installation happens in a series of steps, which may be spread
 * out over multiple page requests. Each request begins by trying to determine
 * the last completed installation step (also known as a "task"), if one is
 * available from a previous request. Control is then passed to the task
 * handler, which processes the remaining tasks that need to be run until (a)
 * an error is thrown, (b) a new page needs to be displayed, or (c) the
 * installation finishes (whichever happens first).
 *
 * @param $settings
 *   An optional array of installation settings. Leave this empty for a normal,
 *   interactive, browser-based installation intended to occur over multiple
 *   page requests. Alternatively, if an array of settings is passed in, the
 *   installer will attempt to use it to perform the installation in a single
 *   page request (optimized for the command line) and not send any output
 *   intended for the web browser. See install_state_defaults() for a list of
 *   elements that are allowed to appear in this array.
 *
 * @see install_state_defaults()
 */
function install_drupal($settings = array()) {
  global $install_state;
  // Initialize the installation state with the settings that were passed in,
  // as well as a boolean indicating whether or not this is an interactive
  // installation.
  $interactive = empty($settings);
  $install_state = $settings + array('interactive' => $interactive) + install_state_defaults();
92

93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
  try {
    // Begin the page request. This adds information about the current state of
    // the Drupal installation to the passed-in array.
    install_begin_request($install_state);
    // Based on the installation state, run the remaining tasks for this page
    // request, and collect any output.
    $output = install_run_tasks($install_state);
  }
  catch (InstallerException $e) {
    // In the non-interactive installer, exceptions are always thrown directly.
    if (!$install_state['interactive']) {
      throw $e;
    }
    $output = array(
      '#title' => $e->getTitle(),
      '#markup' => $e->getMessage(),
    );
  }
111

112
113
114
115
116
117
118
  // After execution, all tasks might be complete, in which case
  // $install_state['installation_finished'] is TRUE. In case the last task
  // has been processed, remove the global $install_state, so other code can
  // reliably check whether it is running during the installer.
  // @see drupal_installation_attempted()
  $state = $install_state;
  if (!empty($install_state['installation_finished'])) {
119
    unset($GLOBALS['install_state']);
120
121
  }

122
123
124
  // All available tasks for this page request are now complete. Interactive
  // installations can send output to the browser or redirect the user to the
  // next page.
125
126
  if ($state['interactive']) {
    if ($state['parameters_changed']) {
127
      // Redirect to the correct page if the URL parameters have changed.
128
      install_goto(install_redirect_url($state));
129
130
131
132
133
    }
    elseif (isset($output)) {
      // Display a page only if some output is available. Otherwise it is
      // possible that we are printing a JSON page and theme output should
      // not be shown.
134
      install_display_output($output, $state);
135
136
137
138
139
    }
  }
}

/**
140
 * Returns an array of default settings for the global installation state.
141
142
143
144
145
146
147
148
 *
 * The installation state is initialized with these settings at the beginning
 * of each page request. They may evolve during the page request, but they are
 * initialized again once the next request begins.
 *
 * Non-interactive Drupal installations can override some of these default
 * settings by passing in an array to the installation script, most notably
 * 'parameters' (which contains one-time parameters such as 'profile' and
149
 * 'langcode' that are normally passed in via the URL) and 'forms' (which can
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 * be used to programmatically submit forms during the installation; the keys
 * of each element indicate the name of the installation task that the form
 * submission is for, and the values are used as the $form_state['values']
 * array that is passed on to the form submission via drupal_form_submit()).
 *
 * @see drupal_form_submit()
 */
function install_state_defaults() {
  $defaults = array(
    // The current task being processed.
    'active_task' => NULL,
    // The last task that was completed during the previous installation
    // request.
    'completed_task' => NULL,
164
    // TRUE when there are valid config directories.
165
    'config_verified' => FALSE,
166
    // TRUE when there is a valid database connection.
167
    'database_verified' => FALSE,
168
169
170
171
172
    // TRUE when a valid settings.php exists (containing both database
    // connection information and config directory names).
    'settings_verified' => FALSE,
    // TRUE when the base system has been installed and is ready to operate.
    'base_system_verified' => FALSE,
173
174
175
    // Whether a translation file for the selected language will be downloaded
    // from the translation server.
    'download_translation' => FALSE,
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
    // An array of forms to be programmatically submitted during the
    // installation. The keys of each element indicate the name of the
    // installation task that the form submission is for, and the values are
    // used as the $form_state['values'] array that is passed on to the form
    // submission via drupal_form_submit().
    'forms' => array(),
    // This becomes TRUE only at the end of the installation process, after
    // all available tasks have been completed and Drupal is fully installed.
    // It is used by the installer to store correct information in the database
    // about the completed installation, as well as to inform theme functions
    // that all tasks are finished (so that the task list can be displayed
    // correctly).
    'installation_finished' => FALSE,
    // Whether or not this installation is interactive. By default this will
    // be set to FALSE if settings are passed in to install_drupal().
    'interactive' => TRUE,
    // An array of parameters for the installation, pre-populated by the URL
    // or by the settings passed in to install_drupal(). This is primarily
    // used to store 'profile' (the name of the chosen installation profile)
195
    // and 'langcode' (the code of the chosen installation language), since
196
197
198
199
200
201
202
203
    // these settings need to persist from page request to page request before
    // the database is available for storage.
    'parameters' => array(),
    // Whether or not the parameters have changed during the current page
    // request. For interactive installations, this will trigger a page
    // redirect.
    'parameters_changed' => FALSE,
    // An array of information about the chosen installation profile. This will
204
    // be filled in based on the profile's .info.yml file.
205
206
207
    'profile_info' => array(),
    // An array of available installation profiles.
    'profiles' => array(),
208
209
    // The name of the theme to use during installation.
    'theme' => 'seven',
210
211
212
213
    // The server URL where the interface translation files can be downloaded.
    // Tokens in the pattern will be replaced by appropriate values for the
    // required translation file.
    'server_pattern' => 'http://ftp.drupal.org/files/translations/%core/%project/%project-%version.%language.po',
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
    // Installation tasks can set this to TRUE to force the page request to
    // end (even if there is no themable output), in the case of an interactive
    // installation. This is needed only rarely; for example, it would be used
    // by an installation task that prints JSON output rather than returning a
    // themed page. The most common example of this is during batch processing,
    // but the Drupal installer automatically takes care of setting this
    // parameter properly in that case, so that individual installation tasks
    // which implement the batch API do not need to set it themselves.
    'stop_page_request' => FALSE,
    // Installation tasks can set this to TRUE to indicate that the task should
    // be run again, even if it normally wouldn't be. This can be used, for
    // example, if a single task needs to be spread out over multiple page
    // requests, or if it needs to perform some validation before allowing
    // itself to be marked complete. The most common examples of this are batch
    // processing and form submissions, but the Drupal installer automatically
    // takes care of setting this parameter properly in those cases, so that
    // individual installation tasks which implement the batch API or form API
    // do not need to set it themselves.
    'task_not_complete' => FALSE,
    // A list of installation tasks which have already been performed during
    // the current page request.
    'tasks_performed' => array(),
236
237
238
    // An array of translation files URIs available for the installation. Keyed
    // by the translation language code.
    'translations' => array(),
239
240
241
242
243
  );
  return $defaults;
}

/**
244
 * Begins an installation request, modifying the installation state as needed.
245
246
247
248
249
250
251
252
253
 *
 * This function performs commands that must run at the beginning of every page
 * request. It throws an exception if the installation should not proceed.
 *
 * @param $install_state
 *   An array of information about the current installation state. This is
 *   modified with information gleaned from the beginning of the page request.
 */
function install_begin_request(&$install_state) {
254
255
  $request = Request::createFromGlobals();

256
  // Add any installation parameters passed in via the URL.
257
  if ($install_state['interactive']) {
258
    $install_state['parameters'] += $request->query->all();
259
  }
260
261
262
263
264

  // Validate certain core settings that are used throughout the installation.
  if (!empty($install_state['parameters']['profile'])) {
    $install_state['parameters']['profile'] = preg_replace('/[^a-zA-Z_0-9]/', '', $install_state['parameters']['profile']);
  }
265
266
  if (!empty($install_state['parameters']['langcode'])) {
    $install_state['parameters']['langcode'] = preg_replace('/[^a-zA-Z_0-9\-]/', '', $install_state['parameters']['langcode']);
267
268
  }

269
  // Allow command line scripts to override server variables used by Drupal.
270
  require_once __DIR__ . '/bootstrap.inc';
271

272
273
274
275
276
277
  // Initialize conf_path().
  // This primes the site path to be used during installation. By not requiring
  // settings.php, a bare site folder can be prepared in the /sites directory,
  // which will be used for installing Drupal.
  conf_path(FALSE);

278
  // If the hash salt leaks, it becomes possible to forge a valid testing user
279
280
281
282
283
  // agent, install a new copy of Drupal, and take over the original site.
  // The user agent header is used to pass a database prefix in the request when
  // running tests. However, for security reasons, it is imperative that no
  // installation be permitted using such a prefix.
  if ($install_state['interactive'] && strpos($request->server->get('HTTP_USER_AGENT'), 'simpletest') !== FALSE && !drupal_valid_test_ua()) {
284
    header($request->server->get('SERVER_PROTOCOL') . ' 403 Forbidden');
285
286
287
    exit;
  }

288
289
  drupal_bootstrap(DRUPAL_BOOTSTRAP_CONFIGURATION);

290
291
  // Ensure that procedural dependencies are loaded as early as possible,
  // since the error/exception handlers depend on them.
292
293
294
295
296
  require_once __DIR__ . '/../modules/system/system.install';
  require_once __DIR__ . '/common.inc';
  require_once __DIR__ . '/file.inc';
  require_once __DIR__ . '/install.inc';
  require_once __DIR__ . '/schema.inc';
297
  require_once __DIR__ . '/../../' . Settings::get('path_inc', 'core/includes/path.inc');
298
299
300
301
  require_once __DIR__ . '/database.inc';
  require_once __DIR__ . '/form.inc';
  require_once __DIR__ . '/batch.inc';
  require_once __DIR__ . '/ajax.inc';
302
303

  // Load module basics (needed for hook invokes).
304
305
306
  include_once __DIR__ . '/module.inc';
  include_once __DIR__ . '/session.inc';
  require_once __DIR__ . '/entity.inc';
307

308
309
310
311
312
313
314
315
  // Create a minimal mocked container to support calls to t() in the pre-kernel
  // base system verification code paths below. The strings are not actually
  // used or output for these calls.
  // @todo Separate API level checks from UI-facing error messages.
  $container = new ContainerBuilder();
  $container->setParameter('language.default_values', Language::$defaultValues);
  $container
    ->register('language.default', 'Drupal\Core\Language\LanguageDefault')
316
    ->addArgument('%language.default_values%');
317
318
  $container
    ->register('language_manager', 'Drupal\Core\Language\LanguageManager')
319
    ->addArgument(new Reference('language.default'));
320
321
322
  $container
    ->register('string_translation', 'Drupal\Core\StringTranslation\TranslationManager')
    ->addArgument(new Reference('language_manager'));
323

324
  \Drupal::setContainer($container);
325

326
327
  // Determine whether base system services are ready to operate.
  $install_state['config_verified'] = install_verify_config_directory(CONFIG_ACTIVE_DIRECTORY) && install_verify_config_directory(CONFIG_STAGING_DIRECTORY);
328
329
  $install_state['database_verified'] = install_verify_database_settings();
  $install_state['settings_verified'] = $install_state['config_verified'] && $install_state['database_verified'];
330

331
  if ($install_state['settings_verified']) {
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
    try {
      $system_schema = system_schema();
      end($system_schema);
      $table = key($system_schema);
      $install_state['base_system_verified'] = Database::getConnection()->schema()->tableExists($table);
    }
    catch (DatabaseExceptionWrapper $e) {
      // The last defined table of the base system_schema() does not exist yet.
      // $install_state['base_system_verified'] defaults to FALSE, so the code
      // following below will use the minimal installer service container.
      // As soon as the base system is verified here, the installer operates in
      // a full and regular Drupal environment, without any kind of exceptions.
    }
  }

347
348
349
350
351
  // Replace services with in-memory and null implementations. This kernel is
  // replaced with a regular one in drupal_install_system().
  if (!$install_state['base_system_verified']) {
    $environment = 'install';
    $GLOBALS['conf']['container_service_providers']['InstallerServiceProvider'] = 'Drupal\Core\Installer\InstallerServiceProvider';
352
353
  }
  else {
354
355
    $environment = 'prod';
  }
356

357
358
  $kernel = new DrupalKernel($environment, drupal_classloader(), FALSE);
  $kernel->boot();
359

360
361
362
363
364
  // Enter the request scope and add the Request.
  // @todo Remove this after converting all installer screens into controllers.
  $container = $kernel->getContainer();
  $container->enterScope('request');
  $container->set('request', $request, 'request');
365

366
367
368
  // Register the file translation service.
  if (isset($GLOBALS['config']['locale.settings']['translation.path'])) {
    $directory = $GLOBALS['config']['locale.settings']['translation.path'];
369
  }
370
371
372
373
374
375
  else {
    $directory = conf_path() . '/files/translations';
  }
  $container->set('string_translator.file_translation', new FileTranslation($directory));
  $container->get('string_translation')
    ->addTranslator($container->get('string_translator.file_translation'));
376

377
378
  // Add in installation language if present.
  if (isset($install_state['parameters']['langcode'])) {
379
    \Drupal::translation()->setDefaultLangcode($install_state['parameters']['langcode']);
380
  }
381

382
383
384
385
386
387
388
  // Add list of all available profiles to the installation state.
  $listing = new ExtensionDiscovery();
  $listing->setProfileDirectories(array());
  $install_state['profiles'] += $listing->scan('profile');

  // Prime drupal_get_filename()'s static cache.
  foreach ($install_state['profiles'] as $name => $profile) {
389
    drupal_get_filename('profile', $name, $profile->getPathname());
390
  }
391

392
393
394
395
396
397
398
399
400
401
402
  if ($profile = _install_select_profile($install_state)) {
    $install_state['parameters']['profile'] = $profile;
    install_load_profile($install_state);
    if (isset($install_state['profile_info']['distribution']['install']['theme'])) {
      $install_state['theme'] = $install_state['profile_info']['distribution']['install']['theme'];
    }
  }

  // Override the module list with a minimal set of modules.
  $module_handler = \Drupal::moduleHandler();
  if (!$module_handler->moduleExists('system')) {
403
    $module_handler->addModule('system', 'core/modules/system');
404
405
  }
  if ($profile && !$module_handler->moduleExists($profile)) {
406
    $module_handler->addProfile($profile, $install_state['profiles'][$profile]->getPath());
407
408
409
410
411
412
413
  }
  // After setting up a custom and finite module list in a custom low-level
  // bootstrap like here, ensure to use ModuleHandler::loadAll() so that
  // ModuleHandler::isLoaded() returns TRUE, since that is a condition being
  // checked by other subsystems (e.g., the theme system).
  $module_handler->loadAll();

414
415
416
417
418
419
  // Prepare for themed output. We need to run this at the beginning of the
  // page request to avoid a different theme accidentally getting set. (We also
  // need to run it even in the case of command-line installations, to prevent
  // any code in the installer that happens to initialize the theme system from
  // accessing the database before it is set up yet.)
  drupal_maintenance_theme();
420

421
  if ($install_state['database_verified']) {
422
423
424
425
426
427
    // Verify the last completed task in the database, if there is one.
    $task = install_verify_completed_task();
  }
  else {
    $task = NULL;

428
    // Do not install over a configured settings.php.
429
    if (!empty($GLOBALS['databases'])) {
430
      throw new AlreadyInstalledException($container->get('string_translation'));
431
432
433
    }
  }

434
435
436
437
438
439
  // Ensure that the active configuration directory is empty before installation
  // starts.
  if ($install_state['config_verified'] && empty($task)) {
    $config = glob(config_get_config_directory(CONFIG_ACTIVE_DIRECTORY) . '/*.' . FileStorage::getFileExtension());
    if (!empty($config)) {
      $task = NULL;
440
      throw new AlreadyInstalledException($container->get('string_translation'));
441
442
443
    }
  }

444
445
446
447
448
  // Modify the installation state as appropriate.
  $install_state['completed_task'] = $task;
}

/**
449
 * Runs all tasks for the current installation request.
450
451
452
453
454
455
456
457
458
 *
 * In the case of an interactive installation, all tasks will be attempted
 * until one is reached that has output which needs to be displayed to the
 * user, or until a page redirect is required. Otherwise, tasks will be
 * attempted until the installation is finished.
 *
 * @param $install_state
 *   An array of information about the current installation state. This is
 *   passed along to each task, so it can be modified if necessary.
459
 *
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
 * @return
 *   HTML output from the last completed task.
 */
function install_run_tasks(&$install_state) {
  do {
    // Obtain a list of tasks to perform. The list of tasks itself can be
    // dynamic (e.g., some might be defined by the installation profile,
    // which is not necessarily known until the earlier tasks have run),
    // so we regenerate the remaining tasks based on the installation state,
    // each time through the loop.
    $tasks_to_perform = install_tasks_to_perform($install_state);
    // Run the first task on the list.
    reset($tasks_to_perform);
    $task_name = key($tasks_to_perform);
    $task = array_shift($tasks_to_perform);
    $install_state['active_task'] = $task_name;
    $original_parameters = $install_state['parameters'];
    $output = install_run_task($task, $install_state);
    $install_state['parameters_changed'] = ($install_state['parameters'] != $original_parameters);
    // Store this task as having been performed during the current request,
    // and save it to the database as completed, if we need to and if the
    // database is in a state that allows us to do so. Also mark the
    // installation as 'done' when we have run out of tasks.
    if (!$install_state['task_not_complete']) {
      $install_state['tasks_performed'][] = $task_name;
      $install_state['installation_finished'] = empty($tasks_to_perform);
486
      if ($task['run'] == INSTALL_TASK_RUN_IF_NOT_COMPLETED || $install_state['installation_finished']) {
487
        \Drupal::state()->set('install_task', $install_state['installation_finished'] ? 'done' : $task_name);
488
489
490
491
492
493
494
495
496
497
498
499
      }
    }
    // Stop when there are no tasks left. In the case of an interactive
    // installation, also stop if we have some output to send to the browser,
    // the URL parameters have changed, or an end to the page request was
    // specifically called for.
    $finished = empty($tasks_to_perform) || ($install_state['interactive'] && (isset($output) || $install_state['parameters_changed'] || $install_state['stop_page_request']));
  } while (!$finished);
  return $output;
}

/**
500
 * Runs an individual installation task.
501
502
503
504
505
506
 *
 * @param $task
 *   An array of information about the task to be run.
 * @param $install_state
 *   An array of information about the current installation state. This is
 *   passed in by reference so that it can be modified by the task.
507
 *
508
509
510
511
512
513
514
 * @return
 *   The output of the task function, if there is any.
 */
function install_run_task($task, &$install_state) {
  $function = $task['function'];

  if ($task['type'] == 'form') {
515
    return install_get_form($function, $install_state);
516
517
518
519
  }
  elseif ($task['type'] == 'batch') {
    // Start a new batch based on the task function, if one is not running
    // already.
520
    $current_batch = \Drupal::state()->get('install_current_batch');
521
522
523
524
525
526
527
528
529
530
531
532
    if (!$install_state['interactive'] || !$current_batch) {
      $batch = $function($install_state);
      if (empty($batch)) {
        // If the task did some processing and decided no batch was necessary,
        // there is nothing more to do here.
        return;
      }
      batch_set($batch);
      // For interactive batches, we need to store the fact that this batch
      // task is currently running. Otherwise, we need to make sure the batch
      // will complete in one page request.
      if ($install_state['interactive']) {
533
        \Drupal::state()->set('install_current_batch', $function);
534
535
536
537
538
539
540
      }
      else {
        $batch =& batch_get();
        $batch['progressive'] = FALSE;
      }
      // Process the batch. For progressive batches, this will redirect.
      // Otherwise, the batch will complete.
541
542
543
544
545
546
547
548
      $response = batch_process(install_redirect_url($install_state), install_full_redirect_url($install_state));
      if ($response instanceof Response) {
        // Save $_SESSION data from batch.
        drupal_session_commit();
        // Send the response.
        $response->send();
        exit;
      }
549
550
551
552
    }
    // If we are in the middle of processing this batch, keep sending back
    // any output from the batch process, until the task is complete.
    elseif ($current_batch == $function) {
553
      $output = _batch_page(\Drupal::request());
554
      // Because Batch API now returns a JSON response for intermediary steps,
555
556
557
558
      // but the installer doesn't handle Response objects yet, just send the
      // output here and emulate the old model.
      // @todo Replace this when we refactor the installer to use a request-
      //   response workflow.
559
560
      if ($output instanceof Response) {
        $output->send();
561
        $output = NULL;
562
      }
563
564
565
      // The task is complete when we try to access the batch page and receive
      // FALSE in return, since this means we are at a URL where we are no
      // longer requesting a batch ID.
566
      if ($output === FALSE) {
567
        // Return nothing so the next task will run in the same request.
568
        \Drupal::state()->delete('install_current_batch');
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
        return;
      }
      else {
        // We need to force the page request to end if the task is not
        // complete, since the batch API sometimes prints JSON output
        // rather than returning a themed page.
        $install_state['task_not_complete'] = $install_state['stop_page_request'] = TRUE;
        return $output;
      }
    }
  }

  else {
    // For normal tasks, just return the function result, whatever it is.
    return $function($install_state);
  }
}

/**
588
 * Returns a list of tasks to perform during the current installation request.
589
590
591
592
593
594
595
 *
 * Note that the list of tasks can change based on the installation state as
 * the page request evolves (for example, if an installation profile hasn't
 * been selected yet, we don't yet know which profile tasks need to be run).
 *
 * @param $install_state
 *   An array of information about the current installation state.
596
 *
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
 * @return
 *   A list of tasks to be performed, with associated metadata.
 */
function install_tasks_to_perform($install_state) {
  // Start with a list of all currently available tasks.
  $tasks = install_tasks($install_state);
  foreach ($tasks as $name => $task) {
    // Remove any tasks that were already performed or that never should run.
    // Also, if we started this page request with an indication of the last
    // task that was completed, skip that task and all those that come before
    // it, unless they are marked as always needing to run.
    if ($task['run'] == INSTALL_TASK_SKIP || in_array($name, $install_state['tasks_performed']) || (!empty($install_state['completed_task']) && empty($completed_task_found) && $task['run'] != INSTALL_TASK_RUN_IF_REACHED)) {
      unset($tasks[$name]);
    }
    if (!empty($install_state['completed_task']) && $name == $install_state['completed_task']) {
      $completed_task_found = TRUE;
    }
  }
  return $tasks;
}

/**
619
 * Returns a list of all tasks the installer currently knows about.
620
621
622
623
624
625
626
627
628
 *
 * This function will return tasks regardless of whether or not they are
 * intended to run on the current page request. However, the list can change
 * based on the installation state (for example, if an installation profile
 * hasn't been selected yet, we don't yet know which profile tasks will be
 * available).
 *
 * @param $install_state
 *   An array of information about the current installation state.
629
 *
630
631
632
633
 * @return
 *   A list of tasks, with associated metadata.
 */
function install_tasks($install_state) {
634
635
636
  // Determine whether a translation file must be imported during the
  // 'install_import_translations' task. Import when a non-English language is
  // available and selected.
637
  $needs_translations = count($install_state['translations']) > 1 && !empty($install_state['parameters']['langcode']) && $install_state['parameters']['langcode'] != 'en';
638
639
640
641
  // Determine whether a translation file must be downloaded during the
  // 'install_download_translation' task. Download when a non-English language
  // is selected, but no translation is yet in the translations directory.
  $needs_download = isset($install_state['parameters']['langcode']) && !isset($install_state['translations'][$install_state['parameters']['langcode']]) && $install_state['parameters']['langcode'] != 'en';
642

643
  // Start with the core installation tasks that run before handing control
644
  // to the installation profile.
645
  $tasks = array(
646
    'install_select_language' => array(
647
      'display_name' => t('Choose language'),
648
649
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
650
651
652
    'install_download_translation' => array(
      'run' => $needs_download ? INSTALL_TASK_RUN_IF_REACHED : INSTALL_TASK_SKIP,
    ),
653
    'install_select_profile' => array(
654
      'display_name' => t('Choose profile'),
655
      'display' => empty($install_state['profile_info']['distribution']['name']) && count($install_state['profiles']) != 1,
656
657
658
659
660
661
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
    'install_load_profile' => array(
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
    'install_verify_requirements' => array(
662
      'display_name' => t('Verify requirements'),
663
664
    ),
    'install_settings_form' => array(
665
      'display_name' => t('Set up database'),
666
      'type' => 'form',
667
668
669
      // Even though the form only allows the user to enter database settings,
      // we still need to display it if settings.php is invalid in any way,
      // since the form submit handler is where settings.php is rewritten.
670
671
      'run' => $install_state['settings_verified'] ? INSTALL_TASK_SKIP : INSTALL_TASK_RUN_IF_NOT_COMPLETED,
    ),
672
    'install_base_system' => array(
673
      'run' => $install_state['base_system_verified'] ? INSTALL_TASK_SKIP : INSTALL_TASK_RUN_IF_NOT_COMPLETED,
674
    ),
675
    // All tasks below are executed in a regular, full Drupal environment.
676
677
678
679
    'install_bootstrap_full' => array(
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
    'install_profile_modules' => array(
680
      'display_name' => t('Install site'),
681
682
      'type' => 'batch',
    ),
683
    'install_import_translations' => array(
684
      'display_name' => t('Set up translations'),
685
686
687
688
689
      'display' => $needs_translations,
      'type' => 'batch',
      'run' => $needs_translations ? INSTALL_TASK_RUN_IF_NOT_COMPLETED : INSTALL_TASK_SKIP,
    ),
    'install_configure_form' => array(
690
      'display_name' => t('Configure site'),
691
692
693
694
695
696
      'type' => 'form',
    ),
  );

  // Now add any tasks defined by the installation profile.
  if (!empty($install_state['parameters']['profile'])) {
697
698
    // Load the profile install file, because it is not always loaded when
    // hook_install_tasks() is invoked (e.g. batch processing).
699
    $profile = $install_state['parameters']['profile'];
700
    $profile_install_file = $install_state['profiles'][$profile]->getPath() . '/' . $profile . '.install';
701
    if (file_exists($profile_install_file)) {
702
      include_once DRUPAL_ROOT . '/' . $profile_install_file;
703
    }
704
705
706
707
708
709
710
711
712
713
714
    $function = $install_state['parameters']['profile'] . '_install_tasks';
    if (function_exists($function)) {
      $result = $function($install_state);
      if (is_array($result)) {
        $tasks += $result;
      }
    }
  }

  // Finish by adding the remaining core tasks.
  $tasks += array(
715
    'install_import_translations_remaining' => array(
716
      'display_name' => t('Finish translations'),
717
718
719
720
      'display' => $needs_translations,
      'type' => 'batch',
      'run' => $needs_translations ? INSTALL_TASK_RUN_IF_NOT_COMPLETED : INSTALL_TASK_SKIP,
    ),
721
    'install_update_configuration_translations' => array(
722
      'display_name' => t('Translate configuration'),
723
724
725
726
      'display' => $needs_translations,
      'type' => 'batch',
      'run' => $needs_translations ? INSTALL_TASK_RUN_IF_NOT_COMPLETED : INSTALL_TASK_SKIP,
    ),
727
    'install_finished' => array(
728
      'display_name' => t('Finished'),
729
730
731
732
733
    ),
  );

  // Allow the installation profile to modify the full list of tasks.
  if (!empty($install_state['parameters']['profile'])) {
734
    $profile = $install_state['parameters']['profile'];
735
    if ($install_state['profiles'][$profile]->load()) {
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
      $function = $install_state['parameters']['profile'] . '_install_tasks_alter';
      if (function_exists($function)) {
        $function($tasks, $install_state);
      }
    }
  }

  // Fill in default parameters for each task before returning the list.
  foreach ($tasks as $task_name => &$task) {
    $task += array(
      'display_name' => NULL,
      'display' => !empty($task['display_name']),
      'type' => 'normal',
      'run' => INSTALL_TASK_RUN_IF_NOT_COMPLETED,
      'function' => $task_name,
    );
  }
  return $tasks;
}

/**
757
 * Returns a list of tasks that should be displayed to the end user.
758
759
760
761
762
763
 *
 * The output of this function is a list suitable for sending to
 * theme_task_list().
 *
 * @param $install_state
 *   An array of information about the current installation state.
764
 *
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
 * @return
 *   A list of tasks, with keys equal to the machine-readable task name and
 *   values equal to the name that should be displayed.
 *
 * @see theme_task_list()
 */
function install_tasks_to_display($install_state) {
  $displayed_tasks = array();
  foreach (install_tasks($install_state) as $name => $task) {
    if ($task['display']) {
      $displayed_tasks[$name] = $task['display_name'];
    }
  }
  return $displayed_tasks;
}

781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
/**
 * Builds and processes a form for the installer environment.
 *
 * Ensures that FormBuilder does not redirect after submitting a form, since the
 * installer uses a custom step/flow logic via install_run_tasks().
 *
 * @param string|array $form_id
 *   The form ID to build and process.
 * @param array $install_state
 *   The current state of the installation.
 *
 * @return array|null
 *   A render array containing the form to render, or NULL in case the form was
 *   successfully submitted.
 *
 * @throws \Drupal\Core\Installer\Exception\InstallerException
 */
function install_get_form($form_id, array &$install_state) {
  // Ensure the form will not redirect, since install_run_tasks() uses a custom
  // redirection logic.
  $form_state = array(
    'build_info' => array(
      'args' => array(&$install_state),
    ),
    'no_redirect' => TRUE,
  );
  if ($install_state['interactive']) {
    $form = drupal_build_form($form_id, $form_state);
    // If the form submission was not successful, the form needs to be rendered,
    // which means the task is not complete yet.
    if (empty($form_state['executed'])) {
      $install_state['task_not_complete'] = TRUE;
      return $form;
    }
  }
  else {
    // For non-interactive installs, submit the form programmatically with the
    // values taken from the installation state.
    $form_state['values'] = array();
    if (!empty($install_state['forms'][$form_id])) {
      $form_state['values'] = $install_state['forms'][$form_id];
    }
    drupal_form_submit($form_id, $form_state);

    // Throw an exception in case of any form validation error.
    if ($errors = form_get_errors($form_state)) {
      throw new InstallerException(implode("\n", $errors));
    }
  }
}

832
/**
833
 * Returns the URL that should be redirected to during an installation request.
834
835
836
837
838
 *
 * The output of this function is suitable for sending to install_goto().
 *
 * @param $install_state
 *   An array of information about the current installation state.
839
 *
840
841
842
843
844
845
 * @return
 *   The URL to redirect to.
 *
 * @see install_full_redirect_url()
 */
function install_redirect_url($install_state) {
846
  return 'core/install.php?' . drupal_http_build_query($install_state['parameters']);
847
848
849
}

/**
850
 * Returns the complete URL redirected to during an installation request.
851
852
853
 *
 * @param $install_state
 *   An array of information about the current installation state.
854
 *
855
856
857
858
859
860
861
862
863
864
865
 * @return
 *   The complete URL to redirect to.
 *
 * @see install_redirect_url()
 */
function install_full_redirect_url($install_state) {
  global $base_url;
  return $base_url . '/' . install_redirect_url($install_state);
}

/**
866
 * Displays themed installer output and ends the page request.
867
 *
868
 * Installation tasks should use #title to set the desired page
869
870
871
872
873
874
875
876
877
 * title, but otherwise this function takes care of theming the overall page
 * output during every step of the installation.
 *
 * @param $output
 *   The content to display on the main part of the page.
 * @param $install_state
 *   An array of information about the current installation state.
 */
function install_display_output($output, $install_state) {
878
879
880
881
882
  // Ensure the maintenance theme is initialized.
  // The regular initialization call in install_begin_request() may not be
  // reached in case of an early installer error.
  drupal_maintenance_theme();

883
  drupal_page_header();
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898

  // Prevent install.php from being indexed when installed in a sub folder.
  // robots.txt rules are not read if the site is within domain.com/subfolder
  // resulting in /subfolder/install.php being found through search engines.
  // When settings.php is writeable this can be used via an external database
  // leading a malicious user to gain php access to the server.
  $noindex_meta_tag = array(
    '#tag' => 'meta',
    '#attributes' => array(
      'name' => 'robots',
      'content' => 'noindex, nofollow',
    ),
  );
  drupal_add_html_head($noindex_meta_tag, 'install_meta_robots');

899
900
901
902
903
904
905
  // Only show the task list if there is an active task; otherwise, the page
  // request has ended before tasks have even been started, so there is nothing
  // meaningful to show.
  if (isset($install_state['active_task'])) {
    // Let the theming function know when every step of the installation has
    // been completed.
    $active_task = $install_state['installation_finished'] ? NULL : $install_state['active_task'];
906
907
908
909
910
911
912
    $task_list = array(
      '#theme' => 'task_list',
      '#items' => install_tasks_to_display($install_state),
      '#active' => $active_task,
      '#variant' => 'install',
    );
    drupal_add_region_content('sidebar_first', drupal_render($task_list));
913
  }
914
915
916
917
918
919
920
921
922
923
924
  $install_page = array(
    '#theme' => 'install_page',
    // $output has to be rendered here, because the install page template is not
    // wrapped into the html template, which means that any #attached libraries
    // in $output will not be loaded, because the wrapping HTML has been printed
    // already.
    '#content' => drupal_render($output),
  );
  if (isset($output['#title'])) {
    $install_page['#page']['#title'] = $output['#title'];
  }
925
  print drupal_render($install_page);
926
927
928
929
  exit;
}

/**
930
 * Verifies the requirements for installing Drupal.
931
932
933
 *
 * @param $install_state
 *   An array of information about the current installation state.
934
 *
935
936
937
938
939
940
941
942
943
944
 * @return
 *   A themed status report, or an exception if there are requirement errors.
 */
function install_verify_requirements(&$install_state) {
  // Check the installation requirements for Drupal and this profile.
  $requirements = install_check_requirements($install_state);

  // Verify existence of all required modules.
  $requirements += drupal_verify_profile($install_state);

945
  return install_display_requirements($install_state, $requirements);
946
947
948
}

/**
949
 * Installation task; install the base functionality Drupal needs to bootstrap.
950
951
952
953
 *
 * @param $install_state
 *   An array of information about the current installation state.
 */
954
function install_base_system(&$install_state) {
955
  // Install system.module.
956
  drupal_install_system($install_state);
957

958
959
960
961
962
963
964
965
966
  // Call file_ensure_htaccess() to ensure that all of Drupal's standard
  // directories (e.g., the public files directory and config directory) have
  // appropriate .htaccess files. These directories will have already been
  // created by this point in the installer, since Drupal creates them during
  // the install_verify_requirements() task. Note that we cannot call
  // file_ensure_access() any earlier than this, since it relies on
  // system.module in order to work.
  file_ensure_htaccess();

967
968
  // Enable the user module so that sessions can be recorded during the
  // upcoming bootstrap step.
969
  \Drupal::moduleHandler()->install(array('user'), FALSE);
970

971
  // Save the list of other modules to install for the upcoming tasks.
972
  // State can be set to the database now that system.module is installed.
973
974
  $modules = $install_state['profile_info']['dependencies'];

975
  // The installation profile is also a module, which needs to be installed
976
977
978
  // after all the dependencies have been installed.
  $modules[] = drupal_get_profile();

979
  \Drupal::state()->set('install_profile_modules', array_diff($modules, array('system')));
980
  $install_state['base_system_verified'] = TRUE;
981
982
983
}

/**
984
 * Verifies and returns the last installation task that was completed.
985
986
987
988
989
990
 *
 * @return
 *   The last completed task, if there is one. An exception is thrown if Drupal
 *   is already installed.
 */
function install_verify_completed_task() {
991
  try {
992
    $task = \Drupal::state()->get('install_task');
993
994
995
  }
  // Do not trigger an error if the database query fails, since the database
  // might not be set up yet.
996
  catch (\Exception $e) {
997
998
  }
  if (isset($task)) {
999
    if ($task == 'done') {
1000
      throw new AlreadyInstalledException(\Drupal::service('string_translation'));
1001
1002
1003
1004
1005
1006
    }
    return $task;
  }
}

/**
1007
 * Verifies that settings.php specifies a valid database connection.
1008
 */
1009
function install_verify_database_settings() {
1010
1011
1012
  global $databases;
  if (!empty($databases)) {
    $database = $databases['default']['default'];
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
    $settings_file = './' . conf_path(FALSE) . '/settings.php';
    $errors = install_database_errors($database, $settings_file);
    if (empty($errors)) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
1023
 * Form constructor for a form to configure and rewrite settings.php.
1024
1025
1026
 *
 * @param $install_state
 *   An array of information about the current installation state.
1027
 *
1028
1029
 * @see install_settings_form_validate()
 * @see install_settings_form_submit()
1030
 * @ingroup forms
1031
1032
 */
function install_settings_form($form, &$form_state, &$install_state) {
1033
1034
  global $databases;

1035
1036
1037
  $conf_path = './' . conf_path(FALSE);
  $settings_file = $conf_path . '/settings.php';

1038
  $form['#title'] = t('Database configuration');
1039

1040
  $drivers = drupal_get_database_types();
1041
  $drivers_keys = array_keys($drivers);
1042

1043
1044
  // If database connection settings have been prepared in settings.php already,
  // then the existing values need to be taken over.
1045
1046
1047
  // Note: The installer even executes this form if there is a valid database
  // connection already, since the submit handler of this form is responsible
  // for writing all $settings to settings.php (not limited to $databases).
1048
1049
1050
  if (isset($databases['default']['default'])) {
    $default_driver = $databases['default']['default']['driver'];
    $default_options = $databases['default']['default'];
1051
  }
1052
1053
1054
1055
  // Otherwise, use the database connection settings from the form input.
  // For a non-interactive installation, this is derived from the original
  // $settings array passed into install_drupal().
  elseif (isset($form_state['input']['driver'])) {
1056
1057
1058
    $default_driver = $form_state['input']['driver'];
    $default_options = $form_state['input'][$default_driver];
  }
1059
1060
1061
  // If there is no database information at all yet, just suggest the first
  // available driver as default value, so that its settings form is made
  // visible via #states when JavaScript is enabled (see below).
1062
1063
1064
1065
1066
  else {
    $default_driver = current($drivers_keys);
    $default_options = array();
  }

1067
1068
  $form['driver'] = array(
    '#type' => 'radios',
1069
    '#title' => t('Database type'),
1070
    '#required' => TRUE,
1071
    '#default_value' => $default_driver,
1072
1073
1074
  );
  if (count($drivers) == 1) {
    $form['driver']['#disabled'] = TRUE;
1075
1076
  }

1077
1078
1079
1080
  // Add driver specific configuration options.
  foreach ($drivers as $key => $driver) {
    $form['driver']['#options'][$key] = $driver->name();

1081
    $form['settings'][$key] = $driver->getFormOptions($default_options);
1082
    $form['settings'][$key]['#prefix'] = '<h2 class="js-hide">' . t('@driver_name settings', array('@driver_name' => $driver->name())) . '</h2>';
1083
1084
1085
1086
1087
1088
1089
1090
1091
    $form['settings'][$key]['#type'] = 'container';
    $form['settings'][$key]['#tree'] = TRUE;
    $form['settings'][$key]['advanced_options']['#parents'] = array($key);
    $form['settings'][$key]['#states'] = array(
      'visible' => array(
        ':input[name=driver]' => array('value' => $key),
      )
    );
  }
1092

1093
  $form['actions'] = array('#type' => 'actions');
1094
1095
  $form['actions']['save'] = array(
    '#type' => 'submit',
1096
    '#value' => t('Save and continue'),
1097
    '#button_type' => 'primary',
1098
1099
    '#limit_validation_errors' => array(
      array('driver'),
1100
      array($default_driver),
1101
1102
    ),
    '#submit' => array('install_settings_form_submit'),
1103
1104
1105
1106
  );

  $form['errors'] = array();
  $form['settings_file'] = array('#type' => 'value', '#value' => $settings_file);
1107
1108
1109
1110
1111

  return $form;
}

/**
1112
1113
1114
 * Form validation handler for install_settings_form().
 *
 * @see install_settings_form_submit()
1115
1116
 */
function install_settings_form_validate($form, &$form_state) {
1117
1118
  $driver = $form_state['values']['driver'];
  $database = $form_state['values'][$driver];
1119
1120
1121
1122
1123
  $drivers = drupal_get_database_types();
  $reflection = new \ReflectionClass($drivers[$driver]);
  $install_namespace = $reflection->getNamespaceName();
  // Cut the trailing \Install from namespace.
  $database['namespace'] = substr($install_namespace, 0, strrpos($install_namespace, '\\'));
1124
1125
1126
1127
  $database['driver'] = $driver;

  $form_state['storage']['database'] = $database;
  $errors = install_database_errors($database, $form_state['values']['settings_file']);
1128
  foreach ($errors as $name => $message) {
1129
    form_set_error($name, $form_state, $message);
1130
1131
1132
1133
  }
}

/**
1134
 * Checks a database connection and returns any errors.
1135
1136
 */
function install_database_errors($database, $settings_file) {
1137
  global $databases;
1138
1139
  $errors = array();

1140
  // Check database type.
1141
  $database_types = drupal_get_database_types();
1142
1143
  $driver = $database['driver'];
  if (!isset($database_types[$driver])) {
1144
    $errors['driver'] = t("In your %settings_file file you have configured @drupal to use a %driver server, however your PHP installation currently does not support this database type.", array('%settings_file' => $settings_file, '@drupal' => drupal_install_profile_distribution_name(), '%driver' => $driver));
1145
1146
  }
  else {
1147
1148
    // Run driver specific validation
    $errors += $database_types[$driver]->validateDatabaseSettings($database);
1149

1150
    // Run tasks associated with the database type. Any errors are caught in the
1151
    // calling function.
1152
1153
1154
1155
1156
1157
1158
1159
1160
    $databases['default']['default'] = $database;
    // Just changing the global doesn't get the new information processed.
    // We need to close any active connections and tell the Database class to
    // re-parse $databases.
    if (Database::isActiveConnection()) {
      Database::closeConnection();
    }
    Database::parseConnectionInfo();

1161
    try {
1162
      db_run_tasks($driver);
1163
    }
1164
    catch (TaskException $e) {
1165
1166
1167
      // These are generic errors, so we do not have any specific key of the
      // database connection array to attach them to; therefore, we just put
      // them in the error array with standard numeric keys.
1168
      $errors[$driver . '][0'] = $e->getMessage();
1169
1170
1171
1172
1173
1174
    }
  }
  return $errors;
}

/**
1175
1176
1177
 * Form submission handler for install_settings_form().
 *
 * @see install_settings_form_validate()
1178
1179
 */
function install_settings_form_submit($form, &$form_state) {
1180
  global $install_state;
1181

1182
  // Update global settings array and save.
1183
1184
  $settings = array();
  $database = $form_state['storage']['database'];
1185
1186
1187
1188
  $settings['databases']['default']['default'] = (object) array(
    'value'    => $database,
    'required' => TRUE,
  );
1189
  $settings['settings']['hash_salt'] = (object) array(
1190
    'value'    => Crypt::randomBytesBase64(55),
1191
1192
    'required' => TRUE,
  );
1193
  // Remember the profile which was used.
1194
1195
1196
  $settings['settings']['install_profile'] = (object) array(
    'value' => $install_state['parameters']['profile'],
    'required' => TRUE,
1197
1198
  );

1199
  drupal_rewrite_settings($settings);
gdd's avatar
gdd committed
1200

1201
  // Add the config directories to settings.php.
1202
  drupal_install_config_directories();
gdd's avatar
gdd committed
1203

1204
1205
1206
1207
1208
  // Indicate that the settings file has been verified, and check the database
  // for the last completed task, now that we have a valid connection. This
  // last step is important since we want to trigger an error if the new
  // database already has Drupal installed.
  $install_state['settings_verified'] = TRUE;
1209
1210
  $install_state['config_verified'] = TRUE;
  $install_state['database_verified'] = TRUE;
1211
1212
1213
1214
  $install_state['completed_task'] = install_verify_completed_task();
}

/**
1215
 * Selects which profile to install.
1216
1217
1218
1219
1220
 *
 * @param $install_state
 *   An array of information about the current installation state. The chosen
 *   profile will be added here, if it was not already selected previously, as
 *   will a list of all available profiles.
1221
 *
1222
1223
1224
1225
1226
1227
1228
 * @return
 *   For interactive installations, a form allowing the profile to be selected,
 *   if the user has a choice that needs to be made. Otherwise, an exception is
 *   thrown if a profile cannot be chosen automatically.
 */
function install_select_profile(&$install_state) {
  if (empty($install_state['parameters']['profile'])) {
1229
1230
1231
    // If there are no profiles at all, installation cannot proceed.
    if (empty($install_state['profiles'])) {
      throw new NoProfilesException(\Drupal::service('string_translation'));
1232
    }
1233
    // Try to automatically select a profile.