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

katbailey's avatar
katbailey committed
3
use Drupal\Core\DrupalKernel;
4
5
use Drupal\Core\Database\Database;
use Drupal\Core\Database\Install\TaskException;
6
use Drupal\Core\Language\Language;
7

8
9
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
10
use Symfony\Component\HttpFoundation\Request;
11
use Symfony\Component\HttpFoundation\Response;
12

13
14
15
16
17
18
/**
 * @file
 * API functions for installing Drupal.
 */

/**
19
 * Do not run the task during the current installation request.
20
21
22
23
24
25
26
27
28
 *
 * 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.
 */
29
const INSTALL_TASK_SKIP = 1;
30
31

/**
32
 * Run the task on each installation request that reaches it.
33
34
35
 *
 * This is primarily used by the Drupal installer for bootstrap-related tasks.
 */
36
const INSTALL_TASK_RUN_IF_REACHED = 2;
37
38

/**
39
 * Run the task on each installation request until the database is set up.
40
41
42
43
44
45
46
47
 *
 * 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.
 */
48
const INSTALL_TASK_RUN_IF_NOT_COMPLETED = 3;
49
50

/**
51
 * Installs Drupal either interactively or via an array of passed-in settings.
52
53
54
55
56
57
58
59
60
61
62
63
64
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
92
93
94
95
96
 *
 * 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();
  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 (Exception $e) {
    // When an installation error occurs, either send the error to the web
    // browser or pass on the exception so the calling script can use it.
    if ($install_state['interactive']) {
      install_display_output($e->getMessage(), $install_state);
    }
    else {
      throw $e;
    }
  }
97
98
99
100
101
102
103
  // 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'])) {
104
    unset($GLOBALS['install_state']);
105
106
  }

107
108
109
  // 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.
110
111
  if ($state['interactive']) {
    if ($state['parameters_changed']) {
112
      // Redirect to the correct page if the URL parameters have changed.
113
      install_goto(install_redirect_url($state));
114
115
116
117
118
    }
    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.
119
      install_display_output($output, $state);
120
121
122
123
124
    }
  }
}

/**
125
 * Returns an array of default settings for the global installation state.
126
127
128
129
130
131
132
133
 *
 * 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
134
 * 'langcode' that are normally passed in via the URL) and 'forms' (which can
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 * 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,
149
150
151
    // This becomes TRUE only when a valid config directory is created or
    // detected.
    'config_verified' => FALSE,
152
153
    // This becomes TRUE only when Drupal's system module is installed.
    'database_tables_exist' => FALSE,
154
155
156
    // This becomes TRUE only when a valid database connection can be
    // established.
    'database_verified' => FALSE,
157
158
159
    // Whether a translation file for the selected language will be downloaded
    // from the translation server.
    'download_translation' => FALSE,
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
    // 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)
179
    // and 'langcode' (the code of the chosen installation language), since
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
    // 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
    // be filled in based on the profile's .info file.
    'profile_info' => array(),
    // An array of available installation profiles.
    'profiles' => array(),
    // An array of server variables that will be substituted into the global
    // $_SERVER array via drupal_override_server_variables(). Used by
    // non-interactive installations only.
    'server' => array(),
196
197
198
199
    // 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',
200
201
202
    // This becomes TRUE only when a valid settings.php file is written
    // (containing both valid database connection information and a valid
    // config directory).
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
    'settings_verified' => FALSE,
    // 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(),
226
227
228
    // An array of translation files URIs available for the installation. Keyed
    // by the translation language code.
    'translations' => array(),
229
230
231
232
233
  );
  return $defaults;
}

/**
234
 * Begins an installation request, modifying the installation state as needed.
235
236
237
238
239
240
241
242
243
 *
 * 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) {
244
  // Add any installation parameters passed in via the URL.
245
246
247
  if ($install_state['interactive']) {
    $install_state['parameters'] += $_GET;
  }
248
249
250
251
252

  // 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']);
  }
253
254
  if (!empty($install_state['parameters']['langcode'])) {
    $install_state['parameters']['langcode'] = preg_replace('/[^a-zA-Z_0-9\-]/', '', $install_state['parameters']['langcode']);
255
256
  }

257
  // Allow command line scripts to override server variables used by Drupal.
258
  require_once DRUPAL_ROOT . '/core/includes/bootstrap.inc';
259

260
261
262
263
264
265
  if (!$install_state['interactive']) {
    drupal_override_server_variables($install_state['server']);
  }
  // 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.
266
  elseif (isset($_SERVER['HTTP_USER_AGENT']) && strpos($_SERVER['HTTP_USER_AGENT'], "simpletest") !== FALSE) {
267
268
269
270
    header($_SERVER['SERVER_PROTOCOL'] . ' 403 Forbidden');
    exit;
  }

271
272
273
274
275
276
  // 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);

277
278
  drupal_bootstrap(DRUPAL_BOOTSTRAP_CONFIGURATION);

279
280
281
  // A request object from the HTTPFoundation to tell us about the request.
  $request = Request::createFromGlobals();

282
283
284
  // This must go after drupal_bootstrap(), which unsets globals!
  global $conf;

285
286
287
288
  require_once DRUPAL_ROOT . '/core/modules/system/system.install';
  require_once DRUPAL_ROOT . '/core/includes/common.inc';
  require_once DRUPAL_ROOT . '/core/includes/file.inc';
  require_once DRUPAL_ROOT . '/core/includes/install.inc';
289
  require_once DRUPAL_ROOT . '/core/includes/schema.inc';
290
  require_once DRUPAL_ROOT . '/' . settings()->get('path_inc', 'core/includes/path.inc');
291
292

  // Load module basics (needed for hook invokes).
293
294
  include_once DRUPAL_ROOT . '/core/includes/module.inc';
  include_once DRUPAL_ROOT . '/core/includes/session.inc';
295
  require_once DRUPAL_ROOT . '/core/includes/entity.inc';
296

297
298
  // Determine whether the configuration system is ready to operate.
  $install_state['config_verified'] = install_verify_config_directory(CONFIG_ACTIVE_DIRECTORY) && install_verify_config_directory(CONFIG_STAGING_DIRECTORY);
299
300
301
  // Check existing settings.php.
  $install_state['database_verified'] = install_verify_database_settings();
  $install_state['settings_verified'] = $install_state['config_verified'] && $install_state['database_verified'];
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322

  // If it is not, replace the configuration storage with the InstallStorage
  // implementation, for the following reasons:
  // - The first call into drupal_container() will try to set up the regular
  //   runtime configuration storage, using the CachedStorage by default. It
  //   calls config_get_config_directory() to retrieve the config directory to
  //   use, but that throws an exception, since $config_directories is not
  //   defined since there is no settings.php yet. If there is a prepared
  //   settings.php already, then the returned directory still cannot be used,
  //   because it does not necessarily exist. The installer ensures that it
  //   exists and is writeable in a later step.
  // - The installer outputs maintenance theme pages and performs many other
  //   operations, which try to load configuration. Since there is no active
  //   configuration yet, and because the configuration system does not have a
  //   notion of default values at runtime, data is missing in many places. The
  //   lack of data does not trigger errors, but results in a broken user
  //   interface (e.g., missing page title, etc).
  // - The actual configuration data to read during installation is essentially
  //   the default configuration provided by the installation profile and
  //   modules (most notably System module). The InstallStorage therefore reads
  //   from the default configuration directories of extensions.
323
324
  // This override is reverted as soon as the config directory and the
  // database has been set up successfully.
325
  // @see drupal_install_config_directories()
326
327
328
329
330
331
  // @see install_settings_form_submit()
  if ($install_state['settings_verified']) {
    $kernel = new DrupalKernel('install', FALSE, drupal_classloader(), FALSE);
    $kernel->boot();
  }
  else {
332
333
334
    // @todo Move into a proper Drupal\Core\DependencyInjection\InstallContainerBuilder.
    $container = new ContainerBuilder();

335
    $container->register('event_dispatcher', 'Symfony\Component\EventDispatcher\EventDispatcher');
336
337
338
339

    $container->register('config.storage', 'Drupal\Core\Config\InstallStorage');
    $container->register('config.factory', 'Drupal\Core\Config\ConfigFactory')
      ->addArgument(new Reference('config.storage'))
340
      ->addArgument(new Reference('event_dispatcher'));
341

342
343
344
345
346
347
348
349
    // The install process cannot use the database lock backend since the database
    // is not fully up, so we use a null backend implementation during the
    // installation process. This will also speed up the installation process.
    // The site being installed will use the real lock backend when doing AJAX
    // requests but, except for a WSOD, there is no chance for a a lock to stall
    // (as opposed to the cache backend) so we can afford having a null
    // implementation here.
    $container->register('lock', 'Drupal\Core\Lock\NullLockBackend');
350
351
352
353

    // Register a module handler for managing enabled modules.
    $container
      ->register('module_handler', 'Drupal\Core\Extension\ModuleHandler');
354
355
356
    drupal_container($container);
  }

357
  // Set up $language, so t() caller functions will still work.
katbailey's avatar
katbailey committed
358
  drupal_language_initialize();
359

360
  require_once DRUPAL_ROOT . '/core/includes/ajax.inc';
361
362
363
364
365
366
367

  $module_handler = drupal_container()->get('module_handler');
  if (!$module_handler->moduleExists('system')) {
    // Override the module list with a minimal set of modules.
    $module_handler->setModuleList(array('system' => 'core/modules/system/system.module'));
  }
  $module_handler->load('system');
368

369
  require_once DRUPAL_ROOT . '/core/includes/cache.inc';
370
  $conf['cache_classes'] = array('cache' => 'Drupal\Core\Cache\MemoryBackend');
371

372
373
374
375
376
377
  // 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();
378

379
  if ($install_state['database_verified']) {
380
381
    // Initialize the database system. Note that the connection
    // won't be initialized until it is actually requested.
382
    require_once DRUPAL_ROOT . '/core/includes/database.inc';
383
384
385
386
387
388
389

    // Verify the last completed task in the database, if there is one.
    $task = install_verify_completed_task();
  }
  else {
    $task = NULL;

390
391
392
393
394
    // Do not install over a configured settings.php. Check the 'db_url'
    // variable in addition to 'databases', since previous versions of Drupal
    // used that (and we do not want to allow installations on an existing site
    // whose settings file has not yet been updated).
    if (!empty($GLOBALS['databases']) || !empty($GLOBALS['db_url'])) {
395
396
397
398
399
400
401
      throw new Exception(install_already_done_error());
    }
  }

  // Modify the installation state as appropriate.
  $install_state['completed_task'] = $task;
  $install_state['database_tables_exist'] = !empty($task);
402
403

  // Add the list of available profiles to the installation state.
404
  $install_state['profiles'] += drupal_system_listing('/^' . DRUPAL_PHP_FUNCTION_PATTERN . '\.profile$/', 'profiles');
405
406
407
}

/**
408
 * Runs all tasks for the current installation request.
409
410
411
412
413
414
415
416
417
 *
 * 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.
418
 *
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
 * @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);
      if ($install_state['database_tables_exist'] && ($task['run'] == INSTALL_TASK_RUN_IF_NOT_COMPLETED || $install_state['installation_finished'])) {
446
        variable_set('install_task', $install_state['installation_finished'] ? 'done' : $task_name);
447
448
449
450
451
452
453
454
455
456
457
458
      }
    }
    // 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;
}

/**
459
 * Runs an individual installation task.
460
461
462
463
464
465
 *
 * @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.
466
 *
467
468
469
470
471
472
473
 * @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') {
474
    require_once DRUPAL_ROOT . '/core/includes/form.inc';
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
    if ($install_state['interactive']) {
      // For interactive forms, build the form and ensure that it will not
      // redirect, since the installer handles its own redirection only after
      // marking the form submission task complete.
      $form_state = array(
        // We need to pass $install_state by reference in order for forms to
        // modify it, since the form API will use it in call_user_func_array(),
        // which requires that referenced variables be passed explicitly.
        'build_info' => array('args' => array(&$install_state)),
        'no_redirect' => TRUE,
      );
      $form = drupal_build_form($function, $form_state);
      // If a successful form submission did not occur, 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 drupal_render($form);
      }
      // Otherwise, return nothing so the next task will run in the same
      // request.
      return;
    }
    else {
      // For non-interactive forms, submit the form programmatically with the
      // values taken from the installation state. Throw an exception if any
      // errors were encountered.
501
502
503
504
505
506
507
508
      $form_state = array(
        'values' => !empty($install_state['forms'][$function]) ? $install_state['forms'][$function] : array(),
        // We need to pass $install_state by reference in order for forms to
        // modify it, since the form API will use it in call_user_func_array(),
        // which requires that referenced variables be passed explicitly.
        'build_info' => array('args' => array(&$install_state)),
      );
      drupal_form_submit($function, $form_state);
509
510
511
512
513
514
515
516
517
518
      $errors = form_get_errors();
      if (!empty($errors)) {
        throw new Exception(implode("\n", $errors));
      }
    }
  }

  elseif ($task['type'] == 'batch') {
    // Start a new batch based on the task function, if one is not running
    // already.
519
    $current_batch = variable_get('install_current_batch');
520
521
522
523
524
525
526
527
528
529
530
531
    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']) {
532
        variable_set('install_current_batch', $function);
533
534
535
536
537
538
539
540
541
542
543
544
      }
      else {
        $batch =& batch_get();
        $batch['progressive'] = FALSE;
      }
      // Process the batch. For progressive batches, this will redirect.
      // Otherwise, the batch will complete.
      batch_process(install_redirect_url($install_state), install_full_redirect_url($install_state));
    }
    // 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) {
545
      include_once DRUPAL_ROOT . '/core/includes/batch.inc';
546
      $output = _batch_page();
547
      // Because Batch API now returns a JSON response for intermediary steps,
548
549
550
551
      // 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.
552
553
      if ($output instanceof Response) {
        $output->send();
554
        $output = NULL;
555
      }
556
557
558
      // 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.
559
      if ($output === FALSE) {
560
        // Return nothing so the next task will run in the same request.
561
        variable_del('install_current_batch');
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
        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);
  }
}

/**
581
 * Returns a list of tasks to perform during the current installation request.
582
583
584
585
586
587
588
 *
 * 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.
589
 *
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
 * @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;
}

/**
612
 * Returns a list of all tasks the installer currently knows about.
613
614
615
616
617
618
619
620
621
 *
 * 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.
622
 *
623
624
625
626
 * @return
 *   A list of tasks, with associated metadata.
 */
function install_tasks($install_state) {
627
628
629
  // Determine whether a translation file must be imported during the
  // 'install_import_translations' task. Import when a non-English language is
  // available and selected.
630
  $needs_translations = count($install_state['translations']) > 1 && !empty($install_state['parameters']['langcode']) && $install_state['parameters']['langcode'] != 'en';
631
632
633
634
  // 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';
635

636
  // Start with the core installation tasks that run before handing control
637
  // to the installation profile.
638
  $tasks = array(
639
640
641
642
    'install_select_language' => array(
      'display_name' => st('Choose language'),
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
643
644
645
    'install_download_translation' => array(
      'run' => $needs_download ? INSTALL_TASK_RUN_IF_REACHED : INSTALL_TASK_SKIP,
    ),
646
647
648
649
650
651
652
653
654
655
656
657
658
659
    'install_select_profile' => array(
      'display_name' => st('Choose profile'),
      'display' => count($install_state['profiles']) != 1,
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
    'install_load_profile' => array(
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
    'install_verify_requirements' => array(
      'display_name' => st('Verify requirements'),
    ),
    'install_settings_form' => array(
      'display_name' => st('Set up database'),
      'type' => 'form',
660
661
662
      // 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.
663
664
      'run' => $install_state['settings_verified'] ? INSTALL_TASK_SKIP : INSTALL_TASK_RUN_IF_NOT_COMPLETED,
    ),
665
    'install_base_system' => array(
666
667
668
669
670
    ),
    'install_bootstrap_full' => array(
      'run' => INSTALL_TASK_RUN_IF_REACHED,
    ),
    'install_profile_modules' => array(
671
      'display_name' => count($install_state['profiles']) == 1 ? st('Install site') : st('Installation profile'),
672
673
      'type' => 'batch',
    ),
674
    'install_import_translations' => array(
675
676
677
678
679
680
681
682
683
684
685
686
687
      'display_name' => st('Set up translations'),
      'display' => $needs_translations,
      'type' => 'batch',
      'run' => $needs_translations ? INSTALL_TASK_RUN_IF_NOT_COMPLETED : INSTALL_TASK_SKIP,
    ),
    'install_configure_form' => array(
      'display_name' => st('Configure site'),
      'type' => 'form',
    ),
  );

  // Now add any tasks defined by the installation profile.
  if (!empty($install_state['parameters']['profile'])) {
688
689
    // Load the profile install file, because it is not always loaded when
    // hook_install_tasks() is invoked (e.g. batch processing).
690
691
    $profile = $install_state['parameters']['profile'];
    $profile_install_file = dirname($install_state['profiles'][$profile]->uri) . '/' . $profile . '.install';
692
693
694
    if (file_exists($profile_install_file)) {
      include_once $profile_install_file;
    }
695
696
697
698
699
700
701
702
703
704
705
    $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(
706
    'install_import_translations_remaining' => array(
707
708
709
710
711
712
713
714
715
716
717
718
      'display_name' => st('Finish translations'),
      'display' => $needs_translations,
      'type' => 'batch',
      'run' => $needs_translations ? INSTALL_TASK_RUN_IF_NOT_COMPLETED : INSTALL_TASK_SKIP,
    ),
    'install_finished' => array(
      'display_name' => st('Finished'),
    ),
  );

  // Allow the installation profile to modify the full list of tasks.
  if (!empty($install_state['parameters']['profile'])) {
719
720
    $profile = $install_state['parameters']['profile'];
    $profile_file = $install_state['profiles'][$profile]->uri;
721
    if (file_exists($profile_file)) {
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
      include_once $profile_file;
      $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;
}

/**
744
 * Returns a list of tasks that should be displayed to the end user.
745
746
747
748
749
750
 *
 * 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.
751
 *
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
 * @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;
}

/**
769
 * Returns the URL that should be redirected to during an installation request.
770
771
772
773
774
 *
 * The output of this function is suitable for sending to install_goto().
 *
 * @param $install_state
 *   An array of information about the current installation state.
775
 *
776
777
778
779
780
781
 * @return
 *   The URL to redirect to.
 *
 * @see install_full_redirect_url()
 */
function install_redirect_url($install_state) {
782
  return 'core/install.php?' . drupal_http_build_query($install_state['parameters']);
783
784
785
}

/**
786
 * Returns the complete URL redirected to during an installation request.
787
788
789
 *
 * @param $install_state
 *   An array of information about the current installation state.
790
 *
791
792
793
794
795
796
797
798
799
800
801
 * @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);
}

/**
802
 * Displays themed installer output and ends the page request.
803
804
805
806
807
808
809
810
811
812
813
814
 *
 * Installation tasks should use drupal_set_title() to set the desired page
 * 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) {
  drupal_page_header();
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829

  // 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');

830
831
832
833
834
835
836
837
838
  // 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'];
    drupal_add_region_content('sidebar_first', theme('task_list', array('items' => install_tasks_to_display($install_state), 'active' => $active_task)));
  }
839
  print theme('install_page', array('content' => $output));
840
841
842
843
  exit;
}

/**
844
 * Verifies the requirements for installing Drupal.
845
846
847
 *
 * @param $install_state
 *   An array of information about the current installation state.
848
 *
849
850
851
852
853
854
855
856
857
858
 * @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);

859
  return install_display_requirements($install_state, $requirements);
860
861
862
}

/**
863
 * Installation task; install the base functionality Drupal needs to bootstrap.
864
865
866
867
 *
 * @param $install_state
 *   An array of information about the current installation state.
 */
868
function install_base_system(&$install_state) {
869
870
  // Install system.module.
  drupal_install_system();
871

872
873
874
875
876
877
878
879
880
  // 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();

881
882
883
884
  // Enable the user module so that sessions can be recorded during the
  // upcoming bootstrap step.
  module_enable(array('user'), FALSE);

885
  // Save the list of other modules to install for the upcoming tasks.
886
  // variable_set() can be used now that system.module is installed.
887
888
  $modules = $install_state['profile_info']['dependencies'];

889
  // The installation profile is also a module, which needs to be installed
890
891
892
  // after all the dependencies have been installed.
  $modules[] = drupal_get_profile();

893
  state()->set('install_profile_modules', array_diff($modules, array('system')));
894
895
896
897
  $install_state['database_tables_exist'] = TRUE;
}

/**
898
 * Verifies and returns the last installation task that was completed.
899
900
901
902
903
904
 *
 * @return
 *   The last completed task, if there is one. An exception is thrown if Drupal
 *   is already installed.
 */
function install_verify_completed_task() {
905
906
907
908
909
910
911
912
913
914
  try {
    if ($result = db_query("SELECT value FROM {variable} WHERE name = :name", array('name' => 'install_task'))) {
      $task = unserialize($result->fetchField());
    }
  }
  // Do not trigger an error if the database query fails, since the database
  // might not be set up yet.
  catch (Exception $e) {
  }
  if (isset($task)) {
915
916
917
918
919
920
921
922
    if ($task == 'done') {
      throw new Exception(install_already_done_error());
    }
    return $task;
  }
}

/**
923
 * Verifies that settings.php specifies a valid database connection.
924
 */
925
function install_verify_database_settings() {
926
  global $databases;
927
  if (!empty($databases)) {
928
929
930
931
932
933
934
935
936
937
938
939
    $database = $databases['default']['default'];
    drupal_static_reset('conf_path');
    $settings_file = './' . conf_path(FALSE) . '/settings.php';
    $errors = install_database_errors($database, $settings_file);
    if (empty($errors)) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
940
 * Form constructor for a form to configure and rewrite settings.php.
941
942
943
 *
 * @param $install_state
 *   An array of information about the current installation state.
944
 *
945
946
 * @see install_settings_form_validate()
 * @see install_settings_form_submit()
947
 * @ingroup forms
948
949
 */
function install_settings_form($form, &$form_state, &$install_state) {
950
  global $databases;
951
952
953
954
955
956
957
958
959
  $profile = $install_state['parameters']['profile'];

  drupal_static_reset('conf_path');
  $conf_path = './' . conf_path(FALSE);
  $settings_file = $conf_path . '/settings.php';
  $database = isset($databases['default']['default']) ? $databases['default']['default'] : array();

  drupal_set_title(st('Database configuration'));

960
  $drivers = drupal_get_database_types();
961
  $drivers_keys = array_keys($drivers);
962

963
964
965
966
  $form['driver'] = array(
    '#type' => 'radios',
    '#title' => st('Database type'),
    '#required' => TRUE,
967
    '#default_value' => !empty($database['driver']) ? $database['driver'] : current($drivers_keys),
968
969
970
971
    '#description' => st('The type of database your @drupal data will be stored in.', array('@drupal' => drupal_install_profile_distribution_name())),
  );
  if (count($drivers) == 1) {
    $form['driver']['#disabled'] = TRUE;
972
    $form['driver']['#description'] .= ' ' . st('Your PHP configuration only supports a single database type, so it has been automatically selected.');
973
974
  }

975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
  // Add driver specific configuration options.
  foreach ($drivers as $key => $driver) {
    $form['driver']['#options'][$key] = $driver->name();

    $form['settings'][$key] = $driver->getFormOptions($database);
    $form['settings'][$key]['#prefix'] = '<h2 class="js-hide">' . st('@driver_name settings', array('@driver_name' => $driver->name())) . '</h2>';
    $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),
      )
    );
  }
990

991
  $form['actions'] = array('#type' => 'actions');
992
993
994
  $form['actions']['save'] = array(
    '#type' => 'submit',
    '#value' => st('Save and continue'),
995
996
997
998
999
    '#limit_validation_errors' => array(
      array('driver'),
      array(isset($form_state['input']['driver']) ? $form_state['input']['driver'] : current($drivers_keys)),
    ),
    '#submit' => array('install_settings_form_submit'),
1000
1001
1002
1003
  );

  $form['errors'] = array();
  $form['settings_file'] = array('#type' => 'value', '#value' => $settings_file);
1004
1005
1006
1007
1008

  return $form;
}

/**
1009
1010
1011
 * Form validation handler for install_settings_form().
 *
 * @see install_settings_form_submit()
1012
1013
 */
function install_settings_form_validate($form, &$form_state) {
1014
1015
1016
1017
  $driver = $form_state['values']['driver'];
  $database = $form_state['values'][$driver];
  $database['driver'] = $driver;

1018
1019
  // TODO: remove when PIFR will be updated to use 'db_prefix' instead of
  // 'prefix' in the database settings form.
1020
1021
  $database['prefix'] = $database['db_prefix'];
  unset($database['db_prefix']);
1022

1023
1024
  $form_state['storage']['database'] = $database;
  $errors = install_database_errors($database, $form_state['values']['settings_file']);
1025
1026
1027
1028
1029
1030
  foreach ($errors as $name => $message) {
    form_set_error($name, $message);
  }
}

/**
1031
 * Checks a database connection and returns any errors.
1032
1033
1034
1035
1036
 */
function install_database_errors($database, $settings_file) {
  global $databases;
  $errors = array();

1037
  // Check database type.
1038
  $database_types = drupal_get_database_types();
1039
1040
  $driver = $database['driver'];
  if (!isset($database_types[$driver])) {
1041
    $errors['driver'] = st("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));
1042
1043
  }
  else {
1044
1045
1046
    // Run driver specific validation
    $errors += $database_types[$driver]->validateDatabaseSettings($database);

1047
    // Run tasks associated with the database type. Any errors are caught in the
1048
    // calling function.
1049
1050
    $databases['default']['default'] = $database;
    // Just changing the global doesn't get the new information processed.
1051
1052
1053
1054
1055
    // We need to close any active connections and tell the Database class to
    // re-parse $databases.
    if (Database::isActiveConnection()) {
      Database::closeConnection();
    }
1056
1057
1058
    Database::parseConnectionInfo();

    try {
1059
      db_run_tasks($driver);
1060
    }
1061
    catch (TaskException $e) {
1062
1063
1064
      // 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.
1065
      $errors[$driver . '][0'] = $e->getMessage();
1066
1067
1068
1069
1070
1071
    }
  }
  return $errors;
}

/**
1072
1073
1074
 * Form submission handler for install_settings_form().
 *
 * @see install_settings_form_validate()
1075
1076
 */
function install_settings_form_submit($form, &$form_state) {
1077
  global $install_state;
1078

1079
  // Update global settings array and save.
1080
  $settings['databases'] = array(
1081
    'value'    => array('default' => array('default' => $form_state['storage']['database'])),
1082
1083
1084
    'required' => TRUE,
  );
  $settings['drupal_hash_salt'] = array(
1085
    'value'    => drupal_hash_base64(drupal_random_bytes(55)),
1086
1087
    'required' => TRUE,
  );
1088

1089
  drupal_rewrite_settings($settings);
gdd's avatar
gdd committed
1090

1091
1092
  // Add the config directories to settings.php.
  drupal_install_config_directories();
gdd's avatar
gdd committed
1093

1094
1095
1096
1097
1098
  // 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;
1099
1100
  $install_state['config_verified'] = TRUE;
  $install_state['database_verified'] = TRUE;
1101
1102
1103
1104
  $install_state['completed_task'] = install_verify_completed_task();
}

/**
1105
 * Selects which profile to install.
1106
1107
1108
1109
1110
 *
 * @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.
1111
 *
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
 * @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'])) {
    // Try to find a profile.
    $profile = _install_select_profile($install_state['profiles']);
    if (empty($profile)) {
      // We still don't have a profile, so display a form for selecting one.
      // Only do this in the case of interactive installations, since this is
      // not a real form with submit handlers (the database isn't even set up
      // yet), rather just a convenience method for setting parameters in the
      // URL.
      if ($install_state['interactive']) {
1128
        include_once DRUPAL_ROOT . '/core/includes/form.inc';
1129
        drupal_set_title(st('Select an installation profile'));
1130
        $form = drupal_get_form('install_select_profile_form', $install_state);
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
        return drupal_render($form);
      }
      else {
        throw new Exception(install_no_profile_error());
      }
    }
    else {
      $install_state['parameters']['profile'] = $profile;
    }
  }
}

/**
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
 * Selects an installation profile.
 *
 * A profile will be selected if:
 * - Only one profile is available,
 * - A profile was submitted through $_POST,
 * - Exactly one of the profiles is marked as "exclusive".
 * If multiple profiles are marked as "exclusive" then no profile will be
 * selected.
 *
 * @param array $profiles
 *   An associative array of profiles with the machine-readable names as keys.
 *
 * @return
 *   The machine-readable name of the selected profile or NULL if no profile was
 *   selected.
1159
1160
1161
 */
function _install_select_profile($profiles) {
  // Don't need to choose profile if only one available.
1162
  if (count($profiles) == 1) {
1163
1164
1165
    $profile = array_pop($profiles);
    return $profile->name;
  }
1166
1167
  elseif (!empty($_POST['profile']) && isset($profiles[$_POST['profile']])) {
    return $profiles[$_POST['profile']]->name;
1168
  }
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
  // Check for a profile marked as "exclusive" and ensure that only one
  // profile is marked as such.
  $exclusive_profile = NULL;
  foreach ($profiles as $profile) {
    $profile_info = install_profile_info($profile->name);
    if (!empty($profile_info['exclusive'])) {
      if (empty($exclusive_profile)) {
        $exclusive_profile = $profile->name;
      }
      else {
        // We found a second "exclusive" profile. There's no way to choose
        // between them, so we ignore the property.
        return;
      }
    }
  }
  return $exclusive_profile;
1186
1187
1188
}

/**
1189
 * Form constructor for the profile selection form.
1190
 *
1191
1192
 * @param array $install_state
 *   An array of information about the current installation state.
1193
1194
 *
 * @ingroup forms
1195
 */
1196
function install_select_profile_form($form, &$form_state, $install_state) {
1197
1198
1199
  $profiles = array();
  $names = array();

1200
  foreach ($install_state['profiles'] as $profile) {
1201
    $details = install_profile_info($profile->name);
1202
1203
1204
1205
1206
    // Don't show hidden profiles. This is used by to hide the testing profile,
    // which only exists to speed up test runs.
    if ($details['hidden'] === TRUE) {
      continue;
    }
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
    $profiles[$profile->name] = $details;

    // Determine the name of the profile; default to file name if defined name
    // is unspecified.
    $name = isset($details['name']) ? $details['name'] : $profile->name;
    $names[$profile->name] = $name;
  }

  // Display radio buttons alphabetically by human-readable name, but always
  // put the core profiles first (if they are present in the filesystem).
  natcasesort($names);
  if (isset($names['minimal'])) {
    // If the expert ("Minimal") core profile is present, put it in front of
    // any non-core profiles rather than including it with them alphabetically,
    // since the other profiles might be intended to group together in a
    // particular way.
    $names = array('minimal' => $names['minimal']) + $names;
  }
  if (isset($names['standard'])) {
    // If the default ("Standard") core profile is present, put it at the very
    // top of the list. This profile will have its radio button pre-selected,
    // so we want it to always appear at the top.
    $names = array('standard' => $names['standard']) + $names;
  }

  foreach ($names as $profile => $name) {
1233
1234
1235
    // The profile name and description are extracted for translation from the
    // .info file, so we can use st() on them even though they are dynamic data
    // at this point.
1236
1237
1238
1239
    $form['profile'][$name] = array(
      '#type' => 'radio',
      '#value' => 'standard',
      '#return_value' => $profile,
1240
1241
      '#title' => st($name),
      '#description' => isset($profiles[$profile]['description']) ? st($profiles[$profile]['description']) : '',
1242
1243
1244
      '#parents' => array('profile'),
    );
  }
1245
  $form['actions'] = array('#type' => 'actions');
1246
1247
1248
1249
1250
1251
1252
1253
  $form['actions']['submit'] =  array(
    '#type' => 'submit',
    '#value' => st('Save and continue'),
  );
  return $form;
}

/**
1254
 * Finds all .po files that are useful to the installer.
1255
1256
 *
 * @return
1257
1258
 *   An associative array of file URIs keyed by language code. URIs as
 *   returned by file_scan_directory().
1259
1260
 *
 * @see file_scan_directory()
1261
 */
1262
function install_find_translations() {
1263
  $translations = array();
1264
  $files = install_find_translation_files();
1265
1266
  // English does not need a translation file.
  array_unshift($files, (object) array('name' => 'en'));
1267
  foreach ($files as $uri => $file) {
1268
    // Strip off the file name component before the language code.
1269
    $langcode = preg_replace('!^(.+\.)?([^\.]+)$!', '\2', $file->name);
1270
    // Language codes cannot exceed 12 characters to fit into the {language}
1271
    // table.
1272
1273
    if (strlen($langcode) <= 12) {
      $translations[$langcode] = $uri;
1274
    }
1275
  }
1276
  return $translations;
1277
1278
1279
}

/**
1280
 * Finds installer translations either for a specific langcode or all languages.
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
 *
 * @param $langcode
 *   (optional) The language code corresponding to the language for which we
 *   want to find translation files. If omitted, information on all available
 *   files will be returned.
 *
 * @return
 *   An associative array of file information objects keyed by file URIs as
 *   returned by file_scan_directory().
 *
 * @see file_scan_directory()
1292
 */
1293
function install_find_translation_files($langcode = NULL) {
1294
  $directory = variable_get('locale_translate_file_directory', conf_path() . '/files/translations');
1295
  $files = file_scan_directory($directory, '!drupal-\d+\.\d+\.' . (!empty($langcode) ? preg_quote($langcode, '!') : '[^\.]+') . '\.po$!', array('recurse' => FALSE));
1296
  return $files;
1297
1298
1299
}

/**
1300
 * Selects which language to use during installation.
1301
1302
1303
 *
 * @param $install_state
 *   An array of information about the current installation state. The chosen
1304
1305
 *   langcode will be added here, if it was not already selected previously, as
 *   will a list of all available languages.
1306
 *
1307
1308
 * @return
 *   For interactive installations, a form or other page output allowing the
1309
1310
1311
 *   language to be selected or providing information about language selection,
 *   if a language has not been chosen. Otherwise, an exception is thrown if a
 *   language cannot be chosen automatically.
1312
 */
1313
function install_select_language(&$install_state) {
1314
1315
1316
  include_once DRUPAL_ROOT . '/core/includes/standard.inc';

  // Find all available translation files.
1317
1318
1319
  $files = install_find_translations();
  $install_state['translations'] += $files;

1320
1321
1322
1323
1324