Initial code using Drupal 6.38
This commit is contained in:
commit
4824608a33
467 changed files with 90887 additions and 0 deletions
31
modules/update/update-rtl.css
Normal file
31
modules/update/update-rtl.css
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
|
||||
.update .project {
|
||||
padding-right: .25em;
|
||||
}
|
||||
|
||||
.update .version-status {
|
||||
float: left;
|
||||
padding-left: 10px;
|
||||
}
|
||||
|
||||
.update .version-status .icon {
|
||||
padding-right: .5em;
|
||||
}
|
||||
|
||||
.update table.version .version-title {
|
||||
padding-left: 1em;
|
||||
}
|
||||
|
||||
.update table.version .version-details {
|
||||
padding-left: .5em;
|
||||
direction: ltr;
|
||||
}
|
||||
|
||||
.update table.version .version-links {
|
||||
text-align: left;
|
||||
padding-left: 1em;
|
||||
}
|
||||
|
||||
.update .check-manually {
|
||||
padding-right: 1em;
|
||||
}
|
||||
701
modules/update/update.compare.inc
Normal file
701
modules/update/update.compare.inc
Normal file
|
|
@ -0,0 +1,701 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Code required only when comparing available updates to existing data.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Fetch an array of installed and enabled projects.
|
||||
*
|
||||
* This is only responsible for generating an array of projects (taking into
|
||||
* account projects that include more than one module or theme). Other
|
||||
* information like the specific version and install type (official release,
|
||||
* dev snapshot, etc) is handled later in update_process_project_info() since
|
||||
* that logic is only required when preparing the status report, not for
|
||||
* fetching the available release data.
|
||||
*
|
||||
* This array is fairly expensive to construct, since it involves a lot of
|
||||
* disk I/O, so we cache the results into the {cache_update} table using the
|
||||
* 'update_project_projects' cache ID. However, since this is not the data
|
||||
* about available updates fetched from the network, it is ok to invalidate it
|
||||
* somewhat quickly. If we keep this data for very long, site administrators
|
||||
* are more likely to see incorrect results if they upgrade to a newer version
|
||||
* of a module or theme but do not visit certain pages that automatically
|
||||
* clear this cache.
|
||||
*
|
||||
* @see update_process_project_info()
|
||||
* @see update_calculate_project_data()
|
||||
* @see update_project_cache()
|
||||
*/
|
||||
function update_get_projects() {
|
||||
static $projects = array();
|
||||
if (empty($projects)) {
|
||||
// Retrieve the projects from cache, if present.
|
||||
$projects = update_project_cache('update_project_projects');
|
||||
if (empty($projects)) {
|
||||
// Still empty, so we have to rebuild the cache.
|
||||
_update_process_info_list($projects, module_rebuild_cache(), 'module');
|
||||
_update_process_info_list($projects, system_theme_data(), 'theme');
|
||||
// Allow other modules to alter projects before fetching and comparing.
|
||||
drupal_alter('update_projects', $projects);
|
||||
// Cache the site's project data for at most 1 hour.
|
||||
_update_cache_set('update_project_projects', $projects, time() + 3600);
|
||||
}
|
||||
}
|
||||
return $projects;
|
||||
}
|
||||
|
||||
/**
|
||||
* Populate an array of project data.
|
||||
*/
|
||||
function _update_process_info_list(&$projects, $list, $project_type) {
|
||||
foreach ($list as $file) {
|
||||
// A disabled base theme of an enabled sub-theme still has all of its code
|
||||
// run by the sub-theme, so we include it in our "enabled" projects list.
|
||||
if (!$file->status && !empty($file->sub_themes)) {
|
||||
foreach ($file->sub_themes as $key => $name) {
|
||||
// Build a list of enabled sub-themes.
|
||||
if ($list[$key]->status) {
|
||||
$file->enabled_sub_themes[$key] = $name;
|
||||
}
|
||||
}
|
||||
// If there are no enabled subthemes, we should ingore this theme and go
|
||||
// on to the next one.
|
||||
if (empty($file->enabled_sub_themes)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
elseif (empty($file->status)) {
|
||||
// Skip disabled modules or themes.
|
||||
continue;
|
||||
}
|
||||
|
||||
// Skip if the .info file is broken.
|
||||
if (empty($file->info)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// If the .info doesn't define the 'project', try to figure it out.
|
||||
if (!isset($file->info['project'])) {
|
||||
$file->info['project'] = update_get_project_name($file);
|
||||
}
|
||||
|
||||
// If we still don't know the 'project', give up.
|
||||
if (empty($file->info['project'])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// If we don't already know it, grab the change time on the .info file
|
||||
// itself. Note: we need to use the ctime, not the mtime (modification
|
||||
// time) since many (all?) tar implementations will go out of their way to
|
||||
// set the mtime on the files it creates to the timestamps recorded in the
|
||||
// tarball. We want to see the last time the file was changed on disk,
|
||||
// which is left alone by tar and correctly set to the time the .info file
|
||||
// was unpacked.
|
||||
if (!isset($file->info['_info_file_ctime'])) {
|
||||
$info_filename = dirname($file->filename) .'/'. $file->name .'.info';
|
||||
$file->info['_info_file_ctime'] = filectime($info_filename);
|
||||
}
|
||||
|
||||
if (!isset($file->info['datestamp'])) {
|
||||
$file->info['datestamp'] = 0;
|
||||
}
|
||||
|
||||
$project_name = $file->info['project'];
|
||||
|
||||
// Add a list of sub-themes that "depend on" the project and a list of base
|
||||
// themes that are "required by" the project.
|
||||
if ($project_name == 'drupal') {
|
||||
// Drupal core is always required, so this extra info would be noise.
|
||||
$sub_themes = array();
|
||||
$base_themes = array();
|
||||
}
|
||||
else {
|
||||
// Add list of enabled sub-themes.
|
||||
$sub_themes = !empty($file->enabled_sub_themes) ? $file->enabled_sub_themes : array();
|
||||
// Add list of base themes.
|
||||
$base_themes = !empty($file->base_themes) ? $file->base_themes : array();
|
||||
}
|
||||
|
||||
if (!isset($projects[$project_name])) {
|
||||
// Only process this if we haven't done this project, since a single
|
||||
// project can have multiple modules or themes.
|
||||
$projects[$project_name] = array(
|
||||
'name' => $project_name,
|
||||
// Only save attributes from the .info file we care about so we do not
|
||||
// bloat our RAM usage needlessly.
|
||||
'info' => update_filter_project_info($file->info),
|
||||
'datestamp' => $file->info['datestamp'],
|
||||
'includes' => array($file->name => $file->info['name']),
|
||||
'project_type' => $project_name == 'drupal' ? 'core' : $project_type,
|
||||
'sub_themes' => $sub_themes,
|
||||
'base_themes' => $base_themes,
|
||||
);
|
||||
}
|
||||
else {
|
||||
$projects[$project_name]['includes'][$file->name] = $file->info['name'];
|
||||
$projects[$project_name]['info']['_info_file_ctime'] = max($projects[$project_name]['info']['_info_file_ctime'], $file->info['_info_file_ctime']);
|
||||
$projects[$project_name]['datestamp'] = max($projects[$project_name]['datestamp'], $file->info['datestamp']);
|
||||
$projects[$project_name]['sub_themes'] = array_merge($projects[$project_name]['sub_themes'], $sub_themes);
|
||||
$projects[$project_name]['base_themes'] = array_merge($projects[$project_name]['base_themes'], $base_themes);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a $file object (as returned by system_get_files_database()), figure
|
||||
* out what project it belongs to.
|
||||
*
|
||||
* @see system_get_files_database()
|
||||
*/
|
||||
function update_get_project_name($file) {
|
||||
$project_name = '';
|
||||
if (isset($file->info['project'])) {
|
||||
$project_name = $file->info['project'];
|
||||
}
|
||||
elseif (isset($file->info['package']) && (strpos($file->info['package'], 'Core -') !== FALSE)) {
|
||||
$project_name = 'drupal';
|
||||
}
|
||||
elseif (in_array($file->name, array('bluemarine', 'chameleon', 'garland', 'marvin', 'minnelli', 'pushbutton'))) {
|
||||
// Unfortunately, there's no way to tell if a theme is part of core,
|
||||
// so we must hard-code a list here.
|
||||
$project_name = 'drupal';
|
||||
}
|
||||
return $project_name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process the list of projects on the system to figure out the currently
|
||||
* installed versions, and other information that is required before we can
|
||||
* compare against the available releases to produce the status report.
|
||||
*
|
||||
* @param $projects
|
||||
* Array of project information from update_get_projects().
|
||||
*/
|
||||
function update_process_project_info(&$projects) {
|
||||
foreach ($projects as $key => $project) {
|
||||
// Assume an official release until we see otherwise.
|
||||
$install_type = 'official';
|
||||
|
||||
$info = $project['info'];
|
||||
|
||||
if (isset($info['version'])) {
|
||||
// Check for development snapshots
|
||||
if (preg_match('@(dev|HEAD)@', $info['version'])) {
|
||||
$install_type = 'dev';
|
||||
}
|
||||
|
||||
// Figure out what the currently installed major version is. We need
|
||||
// to handle both contribution (e.g. "5.x-1.3", major = 1) and core
|
||||
// (e.g. "5.1", major = 5) version strings.
|
||||
$matches = array();
|
||||
if (preg_match('/^(\d+\.x-)?(\d+)\..*$/', $info['version'], $matches)) {
|
||||
$info['major'] = $matches[2];
|
||||
}
|
||||
elseif (!isset($info['major'])) {
|
||||
// This would only happen for version strings that don't follow the
|
||||
// drupal.org convention. We let contribs define "major" in their
|
||||
// .info in this case, and only if that's missing would we hit this.
|
||||
$info['major'] = -1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// No version info available at all.
|
||||
$install_type = 'unknown';
|
||||
$info['version'] = t('Unknown');
|
||||
$info['major'] = -1;
|
||||
}
|
||||
|
||||
// Finally, save the results we care about into the $projects array.
|
||||
$projects[$key]['existing_version'] = $info['version'];
|
||||
$projects[$key]['existing_major'] = $info['major'];
|
||||
$projects[$key]['install_type'] = $install_type;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Given the installed projects and the available release data retrieved from
|
||||
* remote servers, calculate the current status.
|
||||
*
|
||||
* This function is the heart of the update status feature. It iterates over
|
||||
* every currently installed project. For each one, it first checks if the
|
||||
* project has been flagged with a special status like "unsupported" or
|
||||
* "insecure", or if the project node itself has been unpublished. In any of
|
||||
* those cases, the project is marked with an error and the next project is
|
||||
* considered.
|
||||
*
|
||||
* If the project itself is valid, the function decides what major release
|
||||
* series to consider. The project defines what the currently supported major
|
||||
* versions are for each version of core, so the first step is to make sure
|
||||
* the current version is still supported. If so, that's the target version.
|
||||
* If the current version is unsupported, the project maintainer's recommended
|
||||
* major version is used. There's also a check to make sure that this function
|
||||
* never recommends an earlier release than the currently installed major
|
||||
* version.
|
||||
*
|
||||
* Given a target major version, it scans the available releases looking for
|
||||
* the specific release to recommend (avoiding beta releases and development
|
||||
* snapshots if possible). This is complicated to describe, but an example
|
||||
* will help clarify. For the target major version, find the highest patch
|
||||
* level. If there is a release at that patch level with no extra ("beta",
|
||||
* etc), then we recommend the release at that patch level with the most
|
||||
* recent release date. If every release at that patch level has extra (only
|
||||
* betas), then recommend the latest release from the previous patch
|
||||
* level. For example:
|
||||
*
|
||||
* 1.6-bugfix <-- recommended version because 1.6 already exists.
|
||||
* 1.6
|
||||
*
|
||||
* or
|
||||
*
|
||||
* 1.6-beta
|
||||
* 1.5 <-- recommended version because no 1.6 exists.
|
||||
* 1.4
|
||||
*
|
||||
* It also looks for the latest release from the same major version, even a
|
||||
* beta release, to display to the user as the "Latest version" option.
|
||||
* Additionally, it finds the latest official release from any higher major
|
||||
* versions that have been released to provide a set of "Also available"
|
||||
* options.
|
||||
*
|
||||
* Finally, and most importantly, it keeps scanning the release history until
|
||||
* it gets to the currently installed release, searching for anything marked
|
||||
* as a security update. If any security updates have been found between the
|
||||
* recommended release and the installed version, all of the releases that
|
||||
* included a security fix are recorded so that the site administrator can be
|
||||
* warned their site is insecure, and links pointing to the release notes for
|
||||
* each security update can be included (which, in turn, will link to the
|
||||
* official security announcements for each vulnerability).
|
||||
*
|
||||
* This function relies on the fact that the .xml release history data comes
|
||||
* sorted based on major version and patch level, then finally by release date
|
||||
* if there are multiple releases such as betas from the same major.patch
|
||||
* version (e.g. 5.x-1.5-beta1, 5.x-1.5-beta2, and 5.x-1.5). Development
|
||||
* snapshots for a given major version are always listed last.
|
||||
*
|
||||
* The results of this function are expensive to compute, especially on sites
|
||||
* with lots of modules or themes, since it involves a lot of comparisons and
|
||||
* other operations. Therefore, we cache the results into the {cache_update}
|
||||
* table using the 'update_project_data' cache ID. However, since this is not
|
||||
* the data about available updates fetched from the network, it is ok to
|
||||
* invalidate it somewhat quickly. If we keep this data for very long, site
|
||||
* administrators are more likely to see incorrect results if they upgrade to
|
||||
* a newer version of a module or theme but do not visit certain pages that
|
||||
* automatically clear this cache.
|
||||
*
|
||||
* @param $available
|
||||
* Array of data about available project releases.
|
||||
*
|
||||
* @see update_get_available()
|
||||
* @see update_get_projects()
|
||||
* @see update_process_project_info()
|
||||
* @see update_project_cache()
|
||||
*/
|
||||
function update_calculate_project_data($available) {
|
||||
// Retrieve the projects from cache, if present.
|
||||
$projects = update_project_cache('update_project_data');
|
||||
// If $projects is empty, then the cache must be rebuilt.
|
||||
// Otherwise, return the cached data and skip the rest of the function.
|
||||
if (!empty($projects)) {
|
||||
return $projects;
|
||||
}
|
||||
$projects = update_get_projects();
|
||||
update_process_project_info($projects);
|
||||
foreach ($projects as $project => $project_info) {
|
||||
if (isset($available[$project])) {
|
||||
|
||||
// If the project status is marked as something bad, there's nothing
|
||||
// else to consider.
|
||||
if (isset($available[$project]['project_status'])) {
|
||||
switch ($available[$project]['project_status']) {
|
||||
case 'insecure':
|
||||
$projects[$project]['status'] = UPDATE_NOT_SECURE;
|
||||
if (empty($projects[$project]['extra'])) {
|
||||
$projects[$project]['extra'] = array();
|
||||
}
|
||||
$projects[$project]['extra'][] = array(
|
||||
'class' => 'project-not-secure',
|
||||
'label' => t('Project not secure'),
|
||||
'data' => t('This project has been labeled insecure by the Drupal security team, and is no longer available for download. Immediately disabling everything included by this project is strongly recommended!'),
|
||||
);
|
||||
break;
|
||||
case 'unpublished':
|
||||
case 'revoked':
|
||||
$projects[$project]['status'] = UPDATE_REVOKED;
|
||||
if (empty($projects[$project]['extra'])) {
|
||||
$projects[$project]['extra'] = array();
|
||||
}
|
||||
$projects[$project]['extra'][] = array(
|
||||
'class' => 'project-revoked',
|
||||
'label' => t('Project revoked'),
|
||||
'data' => t('This project has been revoked, and is no longer available for download. Disabling everything included by this project is strongly recommended!'),
|
||||
);
|
||||
break;
|
||||
case 'unsupported':
|
||||
$projects[$project]['status'] = UPDATE_NOT_SUPPORTED;
|
||||
if (empty($projects[$project]['extra'])) {
|
||||
$projects[$project]['extra'] = array();
|
||||
}
|
||||
$projects[$project]['extra'][] = array(
|
||||
'class' => 'project-not-supported',
|
||||
'label' => t('Project not supported'),
|
||||
'data' => t('This project is no longer supported, and is no longer available for download. Disabling everything included by this project is strongly recommended!'),
|
||||
);
|
||||
break;
|
||||
case 'not-fetched':
|
||||
$projects[$project]['status'] = UPDATE_NOT_FETCHED;
|
||||
$projects[$project]['reason'] = t('Failed to fetch available update data');
|
||||
break;
|
||||
|
||||
default:
|
||||
// Assume anything else (e.g. 'published') is valid and we should
|
||||
// perform the rest of the logic in this function.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!empty($projects[$project]['status'])) {
|
||||
// We already know the status for this project, so there's nothing
|
||||
// else to compute. Just record everything else we fetched from the
|
||||
// XML file into our projects array and move to the next project.
|
||||
$projects[$project] += $available[$project];
|
||||
continue;
|
||||
}
|
||||
|
||||
// Figure out the target major version.
|
||||
$existing_major = $project_info['existing_major'];
|
||||
$supported_majors = array();
|
||||
if (isset($available[$project]['supported_majors'])) {
|
||||
$supported_majors = explode(',', $available[$project]['supported_majors']);
|
||||
}
|
||||
elseif (isset($available[$project]['default_major'])) {
|
||||
// Older release history XML file without supported or recommended.
|
||||
$supported_majors[] = $available[$project]['default_major'];
|
||||
}
|
||||
|
||||
if (in_array($existing_major, $supported_majors)) {
|
||||
// Still supported, stay at the current major version.
|
||||
$target_major = $existing_major;
|
||||
}
|
||||
elseif (isset($available[$project]['recommended_major'])) {
|
||||
// Since 'recommended_major' is defined, we know this is the new XML
|
||||
// format. Therefore, we know the current release is unsupported since
|
||||
// its major version was not in the 'supported_majors' list. We should
|
||||
// find the best release from the recommended major version.
|
||||
$target_major = $available[$project]['recommended_major'];
|
||||
$projects[$project]['status'] = UPDATE_NOT_SUPPORTED;
|
||||
}
|
||||
elseif (isset($available[$project]['default_major'])) {
|
||||
// Older release history XML file without recommended, so recommend
|
||||
// the currently defined "default_major" version.
|
||||
$target_major = $available[$project]['default_major'];
|
||||
}
|
||||
else {
|
||||
// Malformed XML file? Stick with the current version.
|
||||
$target_major = $existing_major;
|
||||
}
|
||||
|
||||
// Make sure we never tell the admin to downgrade. If we recommended an
|
||||
// earlier version than the one they're running, they'd face an
|
||||
// impossible data migration problem, since Drupal never supports a DB
|
||||
// downgrade path. In the unfortunate case that what they're running is
|
||||
// unsupported, and there's nothing newer for them to upgrade to, we
|
||||
// can't print out a "Recommended version", but just have to tell them
|
||||
// what they have is unsupported and let them figure it out.
|
||||
$target_major = max($existing_major, $target_major);
|
||||
|
||||
$version_patch_changed = '';
|
||||
$patch = '';
|
||||
|
||||
// Defend ourselves from XML history files that contain no releases.
|
||||
if (empty($available[$project]['releases'])) {
|
||||
$projects[$project]['status'] = UPDATE_UNKNOWN;
|
||||
$projects[$project]['reason'] = t('No available releases found');
|
||||
continue;
|
||||
}
|
||||
foreach ($available[$project]['releases'] as $version => $release) {
|
||||
// First, if this is the existing release, check a few conditions.
|
||||
if ($projects[$project]['existing_version'] === $version) {
|
||||
if (isset($release['terms']['Release type']) &&
|
||||
in_array('Insecure', $release['terms']['Release type'])) {
|
||||
$projects[$project]['status'] = UPDATE_NOT_SECURE;
|
||||
}
|
||||
elseif ($release['status'] == 'unpublished') {
|
||||
$projects[$project]['status'] = UPDATE_REVOKED;
|
||||
if (empty($projects[$project]['extra'])) {
|
||||
$projects[$project]['extra'] = array();
|
||||
}
|
||||
$projects[$project]['extra'][] = array(
|
||||
'class' => 'release-revoked',
|
||||
'label' => t('Release revoked'),
|
||||
'data' => t('Your currently installed release has been revoked, and is no longer available for download. Disabling everything included in this release or upgrading is strongly recommended!'),
|
||||
);
|
||||
}
|
||||
elseif (isset($release['terms']['Release type']) &&
|
||||
in_array('Unsupported', $release['terms']['Release type'])) {
|
||||
$projects[$project]['status'] = UPDATE_NOT_SUPPORTED;
|
||||
if (empty($projects[$project]['extra'])) {
|
||||
$projects[$project]['extra'] = array();
|
||||
}
|
||||
$projects[$project]['extra'][] = array(
|
||||
'class' => 'release-not-supported',
|
||||
'label' => t('Release not supported'),
|
||||
'data' => t('Your currently installed release is now unsupported, and is no longer available for download. Disabling everything included in this release or upgrading is strongly recommended!'),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Otherwise, ignore unpublished, insecure, or unsupported releases.
|
||||
if ($release['status'] == 'unpublished' ||
|
||||
(isset($release['terms']['Release type']) &&
|
||||
(in_array('Insecure', $release['terms']['Release type']) ||
|
||||
in_array('Unsupported', $release['terms']['Release type'])))) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// See if this is a higher major version than our target and yet still
|
||||
// supported. If so, record it as an "Also available" release.
|
||||
if ($release['version_major'] > $target_major) {
|
||||
if (in_array($release['version_major'], $supported_majors)) {
|
||||
if (!isset($available[$project]['also'])) {
|
||||
$available[$project]['also'] = array();
|
||||
}
|
||||
if (!isset($available[$project]['also'][$release['version_major']])) {
|
||||
$available[$project]['also'][$release['version_major']] = $version;
|
||||
}
|
||||
}
|
||||
// Otherwise, this release can't matter to us, since it's neither
|
||||
// from the release series we're currently using nor the recommended
|
||||
// release. We don't even care about security updates for this
|
||||
// branch, since if a project maintainer puts out a security release
|
||||
// at a higher major version and not at the lower major version,
|
||||
// they must remove the lower version from the supported major
|
||||
// versions at the same time, in which case we won't hit this code.
|
||||
continue;
|
||||
}
|
||||
|
||||
// Look for the 'latest version' if we haven't found it yet. Latest is
|
||||
// defined as the most recent version for the target major version.
|
||||
if (!isset($available[$project]['latest_version'])
|
||||
&& $release['version_major'] == $target_major) {
|
||||
$available[$project]['latest_version'] = $version;
|
||||
}
|
||||
|
||||
// Look for the development snapshot release for this branch.
|
||||
if (!isset($available[$project]['dev_version'])
|
||||
&& $release['version_major'] == $target_major
|
||||
&& isset($release['version_extra'])
|
||||
&& $release['version_extra'] == 'dev') {
|
||||
$available[$project]['dev_version'] = $version;
|
||||
}
|
||||
|
||||
// Look for the 'recommended' version if we haven't found it yet (see
|
||||
// phpdoc at the top of this function for the definition).
|
||||
if (!isset($available[$project]['recommended'])
|
||||
&& $release['version_major'] == $target_major
|
||||
&& isset($release['version_patch'])) {
|
||||
if ($patch != $release['version_patch']) {
|
||||
$patch = $release['version_patch'];
|
||||
$version_patch_changed = $release['version'];
|
||||
}
|
||||
if (empty($release['version_extra']) && $patch == $release['version_patch']) {
|
||||
$available[$project]['recommended'] = $version_patch_changed;
|
||||
}
|
||||
}
|
||||
|
||||
// Stop searching once we hit the currently installed version.
|
||||
if ($projects[$project]['existing_version'] === $version) {
|
||||
break;
|
||||
}
|
||||
|
||||
// If we're running a dev snapshot and have a timestamp, stop
|
||||
// searching for security updates once we hit an official release
|
||||
// older than what we've got. Allow 100 seconds of leeway to handle
|
||||
// differences between the datestamp in the .info file and the
|
||||
// timestamp of the tarball itself (which are usually off by 1 or 2
|
||||
// seconds) so that we don't flag that as a new release.
|
||||
if ($projects[$project]['install_type'] == 'dev') {
|
||||
if (empty($projects[$project]['datestamp'])) {
|
||||
// We don't have current timestamp info, so we can't know.
|
||||
continue;
|
||||
}
|
||||
elseif (isset($release['date']) && ($projects[$project]['datestamp'] + 100 > $release['date'])) {
|
||||
// We're newer than this, so we can skip it.
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// See if this release is a security update.
|
||||
if (isset($release['terms']['Release type'])
|
||||
&& in_array('Security update', $release['terms']['Release type'])) {
|
||||
$projects[$project]['security updates'][] = $release;
|
||||
}
|
||||
}
|
||||
|
||||
// If we were unable to find a recommended version, then make the latest
|
||||
// version the recommended version if possible.
|
||||
if (!isset($available[$project]['recommended']) && isset($available[$project]['latest_version'])) {
|
||||
$available[$project]['recommended'] = $available[$project]['latest_version'];
|
||||
}
|
||||
|
||||
// Stash the info about available releases into our $projects array.
|
||||
$projects[$project] += $available[$project];
|
||||
|
||||
//
|
||||
// Check to see if we need an update or not.
|
||||
//
|
||||
|
||||
if (!empty($projects[$project]['security updates'])) {
|
||||
// If we found security updates, that always trumps any other status.
|
||||
$projects[$project]['status'] = UPDATE_NOT_SECURE;
|
||||
}
|
||||
|
||||
if (isset($projects[$project]['status'])) {
|
||||
// If we already know the status, we're done.
|
||||
continue;
|
||||
}
|
||||
|
||||
// If we don't know what to recommend, there's nothing we can report.
|
||||
// Bail out early.
|
||||
if (!isset($projects[$project]['recommended'])) {
|
||||
$projects[$project]['status'] = UPDATE_UNKNOWN;
|
||||
$projects[$project]['reason'] = t('No available releases found');
|
||||
continue;
|
||||
}
|
||||
|
||||
// If we're running a dev snapshot, compare the date of the dev snapshot
|
||||
// with the latest official version, and record the absolute latest in
|
||||
// 'latest_dev' so we can correctly decide if there's a newer release
|
||||
// than our current snapshot.
|
||||
if ($projects[$project]['install_type'] == 'dev') {
|
||||
if (isset($available[$project]['dev_version']) && $available[$project]['releases'][$available[$project]['dev_version']]['date'] > $available[$project]['releases'][$available[$project]['latest_version']]['date']) {
|
||||
$projects[$project]['latest_dev'] = $available[$project]['dev_version'];
|
||||
}
|
||||
else {
|
||||
$projects[$project]['latest_dev'] = $available[$project]['latest_version'];
|
||||
}
|
||||
}
|
||||
|
||||
// Figure out the status, based on what we've seen and the install type.
|
||||
switch ($projects[$project]['install_type']) {
|
||||
case 'official':
|
||||
if ($projects[$project]['existing_version'] === $projects[$project]['recommended'] || $projects[$project]['existing_version'] === $projects[$project]['latest_version']) {
|
||||
$projects[$project]['status'] = UPDATE_CURRENT;
|
||||
}
|
||||
else {
|
||||
$projects[$project]['status'] = UPDATE_NOT_CURRENT;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'dev':
|
||||
$latest = $available[$project]['releases'][$projects[$project]['latest_dev']];
|
||||
if (empty($projects[$project]['datestamp'])) {
|
||||
$projects[$project]['status'] = UPDATE_NOT_CHECKED;
|
||||
$projects[$project]['reason'] = t('Unknown release date');
|
||||
}
|
||||
elseif (($projects[$project]['datestamp'] + 100 > $latest['date'])) {
|
||||
$projects[$project]['status'] = UPDATE_CURRENT;
|
||||
}
|
||||
else {
|
||||
$projects[$project]['status'] = UPDATE_NOT_CURRENT;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
$projects[$project]['status'] = UPDATE_UNKNOWN;
|
||||
$projects[$project]['reason'] = t('Invalid info');
|
||||
}
|
||||
}
|
||||
else {
|
||||
$projects[$project]['status'] = UPDATE_UNKNOWN;
|
||||
$projects[$project]['reason'] = t('No available releases found');
|
||||
}
|
||||
}
|
||||
// Give other modules a chance to alter the status (for example, to allow a
|
||||
// contrib module to provide fine-grained settings to ignore specific
|
||||
// projects or releases).
|
||||
drupal_alter('update_status', $projects);
|
||||
|
||||
// Cache the site's update status for at most 1 hour.
|
||||
_update_cache_set('update_project_data', $projects, time() + 3600);
|
||||
return $projects;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve data from {cache_update} or empty the cache when necessary.
|
||||
*
|
||||
* Two very expensive arrays computed by this module are the list of all
|
||||
* installed modules and themes (and .info data, project associations, etc),
|
||||
* and the current status of the site relative to the currently available
|
||||
* releases. These two arrays are cached in the {cache_update} table and used
|
||||
* whenever possible. The cache is cleared whenever the administrator visits
|
||||
* the status report, available updates report, or the module or theme
|
||||
* administration pages, since we should always recompute the most current
|
||||
* values on any of those pages.
|
||||
*
|
||||
* Note: while both of these arrays are expensive to compute (in terms of disk
|
||||
* I/O and some fairly heavy CPU processing), neither of these is the actual
|
||||
* data about available updates that we have to fetch over the network from
|
||||
* updates.drupal.org. That information is stored with the
|
||||
* 'update_available_releases' cache ID -- it needs to persist longer than 1
|
||||
* hour and never get invalidated just by visiting a page on the site.
|
||||
*
|
||||
* @param $cid
|
||||
* The cache id of data to return from the cache. Valid options are
|
||||
* 'update_project_data' and 'update_project_projects'.
|
||||
*
|
||||
* @return
|
||||
* The cached value of the $projects array generated by
|
||||
* update_calculate_project_data() or update_get_projects(), or an empty
|
||||
* array when the cache is cleared.
|
||||
*/
|
||||
function update_project_cache($cid) {
|
||||
$projects = array();
|
||||
|
||||
// On certain paths, we should clear the cache and recompute the projects or
|
||||
// update status of the site to avoid presenting stale information.
|
||||
$q = $_GET['q'];
|
||||
$paths = array('admin/build/modules', 'admin/build/themes', 'admin/reports', 'admin/reports/updates', 'admin/reports/status', 'admin/reports/updates/check');
|
||||
if (in_array($q, $paths)) {
|
||||
_update_cache_clear($cid);
|
||||
}
|
||||
else {
|
||||
$cache = _update_cache_get($cid);
|
||||
if (!empty($cache->data) && $cache->expire > time()) {
|
||||
$projects = $cache->data;
|
||||
}
|
||||
}
|
||||
return $projects;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filter the project .info data to only save attributes we need.
|
||||
*
|
||||
* @param array $info
|
||||
* Array of .info file data as returned by drupal_parse_info_file().
|
||||
*
|
||||
* @return
|
||||
* Array of .info file data we need for the Update manager.
|
||||
*
|
||||
* @see _update_process_info_list()
|
||||
*/
|
||||
function update_filter_project_info($info) {
|
||||
$whitelist = array(
|
||||
'_info_file_ctime',
|
||||
'datestamp',
|
||||
'major',
|
||||
'name',
|
||||
'package',
|
||||
'project',
|
||||
'project status url',
|
||||
'version',
|
||||
);
|
||||
$whitelist = array_flip($whitelist);
|
||||
foreach ($info as $key => $value) {
|
||||
if (!isset($whitelist[$key])) {
|
||||
unset($info[$key]);
|
||||
}
|
||||
}
|
||||
return $info;
|
||||
}
|
||||
109
modules/update/update.css
Normal file
109
modules/update/update.css
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
|
||||
.update .project {
|
||||
font-weight: bold;
|
||||
font-size: 110%;
|
||||
padding-left: .25em; /* LTR */
|
||||
height: 22px;
|
||||
}
|
||||
|
||||
.update .version-status {
|
||||
float: right; /* LTR */
|
||||
padding-right: 10px; /* LTR */
|
||||
font-size: 110%;
|
||||
height: 20px;
|
||||
}
|
||||
|
||||
.update .version-status .icon {
|
||||
padding-left: .5em; /* LTR */
|
||||
}
|
||||
|
||||
.update .version-date {
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.update .info {
|
||||
margin: 0;
|
||||
padding: 1em 1em .25em 1em;
|
||||
}
|
||||
|
||||
.update tr td {
|
||||
border-top: 1px solid #ccc;
|
||||
border-bottom: 1px solid #ccc;
|
||||
}
|
||||
|
||||
.update tr.error {
|
||||
background: #fcc;
|
||||
}
|
||||
|
||||
.update tr.error .version-recommended {
|
||||
background: #fdd;
|
||||
}
|
||||
|
||||
.update tr.ok {
|
||||
background: #dfd;
|
||||
}
|
||||
|
||||
.update tr.warning {
|
||||
background: #ffd;
|
||||
}
|
||||
|
||||
.update tr.warning .version-recommended {
|
||||
background: #ffe;
|
||||
}
|
||||
|
||||
.current-version, .new-version {
|
||||
direction: ltr; /* Note: version numbers should always be LTR. */
|
||||
}
|
||||
|
||||
.update tr.unknown {
|
||||
background: #ddd;
|
||||
}
|
||||
|
||||
table.update,
|
||||
.update table.version {
|
||||
width: 100%;
|
||||
margin-top: .5em;
|
||||
}
|
||||
|
||||
.update table.version tbody {
|
||||
border: none;
|
||||
}
|
||||
|
||||
.update table.version tr,
|
||||
.update table.version td {
|
||||
line-height: .9em;
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
border: none;
|
||||
}
|
||||
|
||||
.update table.version .version-title {
|
||||
padding-left: 1em; /* LTR */
|
||||
width: 14em;
|
||||
}
|
||||
|
||||
.update table.version .version-details {
|
||||
padding-right: .5em; /* LTR */
|
||||
}
|
||||
|
||||
.update table.version .version-links {
|
||||
text-align: right; /* LTR */
|
||||
padding-right: 1em; /* LTR */
|
||||
}
|
||||
|
||||
.update table.version-security .version-title {
|
||||
color: #970F00;
|
||||
}
|
||||
|
||||
.update table.version-recommended-strong .version-title {
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
.update .security-error {
|
||||
font-weight: bold;
|
||||
color: #970F00;
|
||||
}
|
||||
|
||||
.update .check-manually {
|
||||
padding-left: 1em; /* LTR */
|
||||
}
|
||||
284
modules/update/update.fetch.inc
Normal file
284
modules/update/update.fetch.inc
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Code required only when fetching information about available updates.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Callback to manually check the update status without cron.
|
||||
*/
|
||||
function update_manual_status() {
|
||||
if (_update_refresh()) {
|
||||
drupal_set_message(t('Attempted to fetch information about all available new releases and updates.'));
|
||||
}
|
||||
else {
|
||||
drupal_set_message(t('Unable to fetch any information about available new releases and updates.'), 'error');
|
||||
}
|
||||
drupal_goto('admin/reports/updates');
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch project info via XML from a central server.
|
||||
*/
|
||||
function _update_refresh() {
|
||||
static $fail = array();
|
||||
global $base_url;
|
||||
module_load_include('inc', 'update', 'update.compare');
|
||||
|
||||
// Since we're fetching new available update data, we want to clear
|
||||
// our cache of both the projects we care about, and the current update
|
||||
// status of the site. We do *not* want to clear the cache of available
|
||||
// releases just yet, since that data (even if it's stale) can be useful
|
||||
// during update_get_projects(); for example, to modules that implement
|
||||
// hook_system_info_alter() such as cvs_deploy.
|
||||
_update_cache_clear('update_project_projects');
|
||||
_update_cache_clear('update_project_data');
|
||||
|
||||
$available = array();
|
||||
$data = array();
|
||||
$site_key = md5($base_url . drupal_get_private_key());
|
||||
$projects = update_get_projects();
|
||||
|
||||
// Now that we have the list of projects, we should also clear our cache of
|
||||
// available release data, since even if we fail to fetch new data, we need
|
||||
// to clear out the stale data at this point.
|
||||
_update_cache_clear('update_available_releases');
|
||||
$max_fetch_attempts = variable_get('update_max_fetch_attempts', UPDATE_MAX_FETCH_ATTEMPTS);
|
||||
|
||||
foreach ($projects as $key => $project) {
|
||||
$url = _update_build_fetch_url($project, $site_key);
|
||||
$fetch_url_base = _update_get_fetch_url_base($project);
|
||||
if (empty($fail[$fetch_url_base]) || count($fail[$fetch_url_base]) < $max_fetch_attempts) {
|
||||
$xml = drupal_http_request($url);
|
||||
if (isset($xml->data)) {
|
||||
$data[] = $xml->data;
|
||||
}
|
||||
else {
|
||||
// Connection likely broken; prepare to give up.
|
||||
$fail[$fetch_url_base][$key] = 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// Didn't bother trying to fetch.
|
||||
$fail[$fetch_url_base][$key] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if ($data) {
|
||||
$parser = new update_xml_parser;
|
||||
$available = $parser->parse($data);
|
||||
}
|
||||
if (!empty($available) && is_array($available)) {
|
||||
// Record the projects where we failed to fetch data.
|
||||
foreach ($fail as $fetch_url_base => $failures) {
|
||||
foreach ($failures as $key => $value) {
|
||||
$available[$key]['project_status'] = 'not-fetched';
|
||||
}
|
||||
}
|
||||
$frequency = variable_get('update_check_frequency', 1);
|
||||
_update_cache_set('update_available_releases', $available, time() + (60 * 60 * 24 * $frequency));
|
||||
watchdog('update', 'Attempted to fetch information about all available new releases and updates.', array(), WATCHDOG_NOTICE, l(t('view'), 'admin/reports/updates'));
|
||||
}
|
||||
else {
|
||||
watchdog('update', 'Unable to fetch any information about available new releases and updates.', array(), WATCHDOG_ERROR, l(t('view'), 'admin/reports/updates'));
|
||||
}
|
||||
// Whether this worked or not, we did just (try to) check for updates.
|
||||
variable_set('update_last_check', time());
|
||||
return $available;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates the URL to fetch information about project updates.
|
||||
*
|
||||
* This figures out the right URL to use, based on the project's .info file
|
||||
* and the global defaults. Appends optional query arguments when the site is
|
||||
* configured to report usage stats.
|
||||
*
|
||||
* @param $project
|
||||
* The array of project information from update_get_projects().
|
||||
* @param $site_key
|
||||
* The anonymous site key hash (optional).
|
||||
*
|
||||
* @see update_refresh()
|
||||
* @see update_get_projects()
|
||||
*/
|
||||
function _update_build_fetch_url($project, $site_key = '') {
|
||||
$name = $project['name'];
|
||||
$url = _update_get_fetch_url_base($project);
|
||||
$url .= '/'. $name .'/'. DRUPAL_CORE_COMPATIBILITY;
|
||||
// Only append a site_key and the version information if we have a site_key
|
||||
// in the first place, and if this is not a disabled module or theme. We do
|
||||
// not want to record usage statistics for disabled code.
|
||||
if (!empty($site_key) && (strpos($project['project_type'], 'disabled') === FALSE)) {
|
||||
$url .= (strpos($url, '?') === TRUE) ? '&' : '?';
|
||||
$url .= 'site_key=';
|
||||
$url .= rawurlencode($site_key);
|
||||
if (!empty($project['info']['version'])) {
|
||||
$url .= '&version=';
|
||||
$url .= rawurlencode($project['info']['version']);
|
||||
}
|
||||
}
|
||||
return $url;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the base of the URL to fetch available update data for a project.
|
||||
*
|
||||
* @param $project
|
||||
* The array of project information from update_get_projects().
|
||||
* @return
|
||||
* The base of the URL used for fetching available update data. This does
|
||||
* not include the path elements to specify a particular project, version,
|
||||
* site_key, etc.
|
||||
*
|
||||
* @see _update_build_fetch_url()
|
||||
*/
|
||||
function _update_get_fetch_url_base($project) {
|
||||
return isset($project['info']['project status url']) ? $project['info']['project status url'] : variable_get('update_fetch_url', UPDATE_DEFAULT_URL);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform any notifications that should be done once cron fetches new data.
|
||||
*
|
||||
* This method checks the status of the site using the new data and depending
|
||||
* on the configuration of the site, notifies administrators via email if there
|
||||
* are new releases or missing security updates.
|
||||
*
|
||||
* @see update_requirements()
|
||||
*/
|
||||
function _update_cron_notify() {
|
||||
include_once './includes/install.inc';
|
||||
$status = update_requirements('runtime');
|
||||
$params = array();
|
||||
$notify_all = (variable_get('update_notification_threshold', 'all') == 'all');
|
||||
foreach (array('core', 'contrib') as $report_type) {
|
||||
$type = 'update_'. $report_type;
|
||||
if (isset($status[$type]['severity'])
|
||||
&& ($status[$type]['severity'] == REQUIREMENT_ERROR || ($notify_all && $status[$type]['reason'] == UPDATE_NOT_CURRENT))) {
|
||||
$params[$report_type] = $status[$type]['reason'];
|
||||
}
|
||||
}
|
||||
if (!empty($params)) {
|
||||
$notify_list = variable_get('update_notify_emails', '');
|
||||
if (!empty($notify_list)) {
|
||||
$default_language = language_default();
|
||||
foreach ($notify_list as $target) {
|
||||
if ($target_user = user_load(array('mail' => $target))) {
|
||||
$target_language = user_preferred_language($target_user);
|
||||
}
|
||||
else {
|
||||
$target_language = $default_language;
|
||||
}
|
||||
drupal_mail('update', 'status_notify', $target, $target_language, $params);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* XML Parser object to read Drupal's release history info files.
|
||||
* This uses PHP4's lame XML parsing, but it works.
|
||||
*/
|
||||
class update_xml_parser {
|
||||
var $projects = array();
|
||||
var $current_project;
|
||||
var $current_release;
|
||||
var $current_term;
|
||||
var $current_tag;
|
||||
var $current_object;
|
||||
|
||||
/**
|
||||
* Parse an array of XML data files.
|
||||
*/
|
||||
function parse($data) {
|
||||
foreach ($data as $datum) {
|
||||
$parser = xml_parser_create();
|
||||
xml_set_object($parser, $this);
|
||||
xml_set_element_handler($parser, 'start', 'end');
|
||||
xml_set_character_data_handler($parser, "data");
|
||||
xml_parse($parser, $datum);
|
||||
xml_parser_free($parser);
|
||||
}
|
||||
return $this->projects;
|
||||
}
|
||||
|
||||
function start($parser, $name, $attr) {
|
||||
$this->current_tag = $name;
|
||||
switch ($name) {
|
||||
case 'PROJECT':
|
||||
unset($this->current_object);
|
||||
$this->current_project = array();
|
||||
$this->current_object = &$this->current_project;
|
||||
break;
|
||||
case 'RELEASE':
|
||||
unset($this->current_object);
|
||||
$this->current_release = array();
|
||||
$this->current_object = &$this->current_release;
|
||||
break;
|
||||
case 'TERM':
|
||||
unset($this->current_object);
|
||||
$this->current_term = array();
|
||||
$this->current_object = &$this->current_term;
|
||||
break;
|
||||
case 'FILE':
|
||||
unset($this->current_object);
|
||||
$this->current_file = array();
|
||||
$this->current_object = &$this->current_file;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
function end($parser, $name) {
|
||||
switch ($name) {
|
||||
case 'PROJECT':
|
||||
unset($this->current_object);
|
||||
$this->projects[$this->current_project['short_name']] = $this->current_project;
|
||||
$this->current_project = array();
|
||||
break;
|
||||
case 'RELEASE':
|
||||
unset($this->current_object);
|
||||
$this->current_project['releases'][$this->current_release['version']] = $this->current_release;
|
||||
break;
|
||||
case 'RELEASES':
|
||||
$this->current_object = &$this->current_project;
|
||||
break;
|
||||
case 'TERM':
|
||||
unset($this->current_object);
|
||||
$term_name = $this->current_term['name'];
|
||||
if (!isset($this->current_release['terms'])) {
|
||||
$this->current_release['terms'] = array();
|
||||
}
|
||||
if (!isset($this->current_release['terms'][$term_name])) {
|
||||
$this->current_release['terms'][$term_name] = array();
|
||||
}
|
||||
$this->current_release['terms'][$term_name][] = $this->current_term['value'];
|
||||
break;
|
||||
case 'TERMS':
|
||||
$this->current_object = &$this->current_release;
|
||||
break;
|
||||
case 'FILE':
|
||||
unset($this->current_object);
|
||||
$this->current_release['files'][] = $this->current_file;
|
||||
break;
|
||||
case 'FILES':
|
||||
$this->current_object = &$this->current_release;
|
||||
break;
|
||||
default:
|
||||
$this->current_object[strtolower($this->current_tag)] = trim($this->current_object[strtolower($this->current_tag)]);
|
||||
$this->current_tag = '';
|
||||
}
|
||||
}
|
||||
|
||||
function data($parser, $data) {
|
||||
if ($this->current_tag && !in_array($this->current_tag, array('PROJECT', 'RELEASE', 'RELEASES', 'TERM', 'TERMS', 'FILE', 'FILES'))) {
|
||||
$tag = strtolower($this->current_tag);
|
||||
if (isset($this->current_object[$tag])) {
|
||||
$this->current_object[$tag] .= $data;
|
||||
}
|
||||
else {
|
||||
$this->current_object[$tag] = $data;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
11
modules/update/update.info
Normal file
11
modules/update/update.info
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
name = Update status
|
||||
description = Checks the status of available updates for Drupal and your installed modules and themes.
|
||||
version = VERSION
|
||||
package = Core - optional
|
||||
core = 6.x
|
||||
|
||||
; Information added by Drupal.org packaging script on 2016-02-24
|
||||
version = "6.38"
|
||||
project = "drupal"
|
||||
datestamp = "1456343372"
|
||||
|
||||
62
modules/update/update.install
Normal file
62
modules/update/update.install
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* Implementation of hook_install().
|
||||
*/
|
||||
function update_install() {
|
||||
// Create cache table.
|
||||
drupal_install_schema('update');
|
||||
// Remove stale variables from update_status 5.x contrib, if any.
|
||||
_update_remove_update_status_variables();
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_uninstall().
|
||||
*/
|
||||
function update_uninstall() {
|
||||
// Remove cache table.
|
||||
drupal_uninstall_schema('update');
|
||||
// Clear any variables that might be in use
|
||||
$variables = array(
|
||||
'update_check_frequency',
|
||||
'update_fetch_url',
|
||||
'update_last_check',
|
||||
'update_notification_threshold',
|
||||
'update_notify_emails',
|
||||
);
|
||||
foreach ($variables as $variable) {
|
||||
variable_del($variable);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_schema().
|
||||
*/
|
||||
function update_schema() {
|
||||
$schema['cache_update'] = drupal_get_schema_unprocessed('system', 'cache');
|
||||
$schema['cache_update']['description'] = 'Cache table for the Update module to store information about available releases, fetched from central server.';
|
||||
return $schema;
|
||||
}
|
||||
|
||||
/**
|
||||
* Private helper to clear out stale variables from update_status 5.x contrib.
|
||||
*
|
||||
* @see update_install()
|
||||
* @see update_update_6000()
|
||||
*/
|
||||
function _update_remove_update_status_variables() {
|
||||
variable_del('update_status_settings');
|
||||
variable_del('update_status_notify_emails');
|
||||
variable_del('update_status_check_frequency');
|
||||
variable_del('update_status_notification_threshold');
|
||||
variable_del('update_status_last');
|
||||
variable_del('update_status_fetch_url');
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear out stale variables from update_status.
|
||||
*/
|
||||
function update_update_6000() {
|
||||
_update_remove_update_status_variables();
|
||||
return array();
|
||||
}
|
||||
626
modules/update/update.module
Normal file
626
modules/update/update.module
Normal file
|
|
@ -0,0 +1,626 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* The "Update status" module checks for available updates of Drupal core and
|
||||
* any installed contributed modules and themes. It warns site administrators
|
||||
* if newer releases are available via the system status report
|
||||
* (admin/reports/status), the module and theme pages, and optionally via email.
|
||||
*/
|
||||
|
||||
/**
|
||||
* URL to check for updates, if a given project doesn't define its own.
|
||||
*/
|
||||
define('UPDATE_DEFAULT_URL', 'http://updates.drupal.org/release-history');
|
||||
|
||||
// These are internally used constants for this code, do not modify.
|
||||
|
||||
/**
|
||||
* Project is missing security update(s).
|
||||
*/
|
||||
define('UPDATE_NOT_SECURE', 1);
|
||||
|
||||
/**
|
||||
* Current release has been unpublished and is no longer available.
|
||||
*/
|
||||
define('UPDATE_REVOKED', 2);
|
||||
|
||||
/**
|
||||
* Current release is no longer supported by the project maintainer.
|
||||
*/
|
||||
define('UPDATE_NOT_SUPPORTED', 3);
|
||||
|
||||
/**
|
||||
* Project has a new release available, but it is not a security release.
|
||||
*/
|
||||
define('UPDATE_NOT_CURRENT', 4);
|
||||
|
||||
/**
|
||||
* Project is up to date.
|
||||
*/
|
||||
define('UPDATE_CURRENT', 5);
|
||||
|
||||
/**
|
||||
* Project's status cannot be checked.
|
||||
*/
|
||||
define('UPDATE_NOT_CHECKED', -1);
|
||||
|
||||
/**
|
||||
* No available update data was found for project.
|
||||
*/
|
||||
define('UPDATE_UNKNOWN', -2);
|
||||
|
||||
/**
|
||||
* There was a failure fetching available update data for this project.
|
||||
*/
|
||||
define('UPDATE_NOT_FETCHED', -3);
|
||||
|
||||
/**
|
||||
* Maximum number of attempts to fetch available update data from a given host.
|
||||
*/
|
||||
define('UPDATE_MAX_FETCH_ATTEMPTS', 2);
|
||||
|
||||
/**
|
||||
* Implementation of hook_help().
|
||||
*/
|
||||
function update_help($path, $arg) {
|
||||
switch ($path) {
|
||||
case 'admin/reports/updates':
|
||||
$output = '<p>'. t('Here you can find information about available updates for your installed modules and themes. Note that each module or theme is part of a "project", which may or may not have the same name, and might include multiple modules or themes within it.') .'</p>';
|
||||
$output .= '<p>'. t('To extend the functionality or to change the look of your site, a number of contributed <a href="@modules">modules</a> and <a href="@themes">themes</a> are available.', array('@modules' => 'http://drupal.org/project/modules', '@themes' => 'http://drupal.org/project/themes')) .'</p>';
|
||||
return $output;
|
||||
case 'admin/build/themes':
|
||||
case 'admin/build/modules':
|
||||
include_once './includes/install.inc';
|
||||
$status = update_requirements('runtime');
|
||||
foreach (array('core', 'contrib') as $report_type) {
|
||||
$type = 'update_'. $report_type;
|
||||
if (isset($status[$type]['severity'])) {
|
||||
if ($status[$type]['severity'] == REQUIREMENT_ERROR) {
|
||||
drupal_set_message($status[$type]['description'], 'error');
|
||||
}
|
||||
elseif ($status[$type]['severity'] == REQUIREMENT_WARNING) {
|
||||
drupal_set_message($status[$type]['description'], 'warning');
|
||||
}
|
||||
}
|
||||
}
|
||||
return '<p>'. t('See the <a href="@available_updates">available updates</a> page for information on installed modules and themes with new versions released.', array('@available_updates' => url('admin/reports/updates'))) .'</p>';
|
||||
|
||||
case 'admin/reports/updates/settings':
|
||||
case 'admin/reports/status':
|
||||
// These two pages don't need additional nagging.
|
||||
break;
|
||||
|
||||
case 'admin/help#update':
|
||||
$output = '<p>'. t("The Update status module periodically checks for new versions of your site's software (including contributed modules and themes), and alerts you to available updates.") .'</p>';
|
||||
$output .= '<p>'. t('The <a href="@update-report">report of available updates</a> will alert you when new releases are available for download. You may configure options for update checking frequency and notifications at the <a href="@update-settings">Update status module settings page</a>.', array('@update-report' => url('admin/reports/updates'), '@update-settings' => url('admin/reports/updates/settings'))) .'</p>';
|
||||
$output .= '<p>'. t('Please note that in order to provide this information, anonymous usage statistics are sent to drupal.org. If desired, you may disable the Update status module from the <a href="@modules">module administration page</a>.', array('@modules' => url('admin/build/modules'))) .'</p>';
|
||||
$output .= '<p>'. t('For more information, see the online handbook entry for <a href="@update">Update status module</a>.', array('@update' => 'http://drupal.org/handbook/modules/update')) .'</p>';
|
||||
return $output;
|
||||
|
||||
default:
|
||||
// Otherwise, if we're on *any* admin page and there's a security
|
||||
// update missing, print an error message about it.
|
||||
if (arg(0) == 'admin' && strpos($path, '#') === FALSE
|
||||
&& user_access('administer site configuration')) {
|
||||
include_once './includes/install.inc';
|
||||
$status = update_requirements('runtime');
|
||||
foreach (array('core', 'contrib') as $report_type) {
|
||||
$type = 'update_'. $report_type;
|
||||
if (isset($status[$type])
|
||||
&& isset($status[$type]['reason'])
|
||||
&& $status[$type]['reason'] === UPDATE_NOT_SECURE) {
|
||||
drupal_set_message($status[$type]['description'], 'error');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_menu().
|
||||
*/
|
||||
function update_menu() {
|
||||
$items = array();
|
||||
|
||||
$items['admin/reports/updates'] = array(
|
||||
'title' => 'Available updates',
|
||||
'description' => 'Get a status report about available updates for your installed modules and themes.',
|
||||
'page callback' => 'update_status',
|
||||
'access arguments' => array('administer site configuration'),
|
||||
'file' => 'update.report.inc',
|
||||
'weight' => 10,
|
||||
);
|
||||
$items['admin/reports/updates/list'] = array(
|
||||
'title' => 'List',
|
||||
'page callback' => 'update_status',
|
||||
'access arguments' => array('administer site configuration'),
|
||||
'file' => 'update.report.inc',
|
||||
'type' => MENU_DEFAULT_LOCAL_TASK,
|
||||
);
|
||||
$items['admin/reports/updates/settings'] = array(
|
||||
'title' => 'Settings',
|
||||
'page callback' => 'drupal_get_form',
|
||||
'page arguments' => array('update_settings'),
|
||||
'access arguments' => array('administer site configuration'),
|
||||
'file' => 'update.settings.inc',
|
||||
'type' => MENU_LOCAL_TASK,
|
||||
);
|
||||
$items['admin/reports/updates/check'] = array(
|
||||
'title' => 'Manual update check',
|
||||
'page callback' => 'update_manual_status',
|
||||
'access arguments' => array('administer site configuration'),
|
||||
'file' => 'update.fetch.inc',
|
||||
'type' => MENU_CALLBACK,
|
||||
);
|
||||
|
||||
return $items;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of the hook_theme() registry.
|
||||
*/
|
||||
function update_theme() {
|
||||
return array(
|
||||
'update_settings' => array(
|
||||
'arguments' => array('form' => NULL),
|
||||
),
|
||||
'update_report' => array(
|
||||
'arguments' => array('data' => NULL),
|
||||
),
|
||||
'update_version' => array(
|
||||
'arguments' => array('version' => NULL, 'tag' => NULL, 'class' => NULL),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_requirements().
|
||||
*
|
||||
* @return
|
||||
* An array describing the status of the site regarding available updates.
|
||||
* If there is no update data, only one record will be returned, indicating
|
||||
* that the status of core can't be determined. If data is available, there
|
||||
* will be two records: one for core, and another for all of contrib
|
||||
* (assuming there are any contributed modules or themes enabled on the
|
||||
* site). In addition to the fields expected by hook_requirements ('value',
|
||||
* 'severity', and optionally 'description'), this array will contain a
|
||||
* 'reason' attribute, which is an integer constant to indicate why the
|
||||
* given status is being returned (UPDATE_NOT_SECURE, UPDATE_NOT_CURRENT, or
|
||||
* UPDATE_UNKNOWN). This is used for generating the appropriate e-mail
|
||||
* notification messages during update_cron(), and might be useful for other
|
||||
* modules that invoke update_requirements() to find out if the site is up
|
||||
* to date or not.
|
||||
*
|
||||
* @see _update_message_text()
|
||||
* @see _update_cron_notify()
|
||||
*/
|
||||
function update_requirements($phase) {
|
||||
if ($phase == 'runtime') {
|
||||
if ($available = update_get_available(FALSE)) {
|
||||
module_load_include('inc', 'update', 'update.compare');
|
||||
$data = update_calculate_project_data($available);
|
||||
// First, populate the requirements for core:
|
||||
$requirements['update_core'] = _update_requirement_check($data['drupal'], 'core');
|
||||
// We don't want to check drupal a second time.
|
||||
unset($data['drupal']);
|
||||
if (!empty($data)) {
|
||||
// Now, sort our $data array based on each project's status. The
|
||||
// status constants are numbered in the right order of precedence, so
|
||||
// we just need to make sure the projects are sorted in ascending
|
||||
// order of status, and we can look at the first project we find.
|
||||
uasort($data, '_update_project_status_sort');
|
||||
$first_project = reset($data);
|
||||
$requirements['update_contrib'] = _update_requirement_check($first_project, 'contrib');
|
||||
}
|
||||
}
|
||||
else {
|
||||
$requirements['update_core']['title'] = t('Drupal core update status');
|
||||
$requirements['update_core']['value'] = t('No update data available');
|
||||
$requirements['update_core']['severity'] = REQUIREMENT_WARNING;
|
||||
$requirements['update_core']['reason'] = UPDATE_UNKNOWN;
|
||||
$requirements['update_core']['description'] = _update_no_data();
|
||||
}
|
||||
return $requirements;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Private helper method to fill in the requirements array.
|
||||
*
|
||||
* This is shared for both core and contrib to generate the right elements in
|
||||
* the array for hook_requirements().
|
||||
*
|
||||
* @param $project
|
||||
* Array of information about the project we're testing as returned by
|
||||
* update_calculate_project_data().
|
||||
* @param $type
|
||||
* What kind of project is this ('core' or 'contrib').
|
||||
*
|
||||
* @return
|
||||
* An array to be included in the nested $requirements array.
|
||||
*
|
||||
* @see hook_requirements()
|
||||
* @see update_requirements()
|
||||
* @see update_calculate_project_data()
|
||||
*/
|
||||
function _update_requirement_check($project, $type) {
|
||||
$requirement = array();
|
||||
if ($type == 'core') {
|
||||
$requirement['title'] = t('Drupal core update status');
|
||||
}
|
||||
else {
|
||||
$requirement['title'] = t('Module and theme update status');
|
||||
}
|
||||
$status = $project['status'];
|
||||
if ($status != UPDATE_CURRENT) {
|
||||
$requirement['reason'] = $status;
|
||||
$requirement['description'] = _update_message_text($type, $status, TRUE);
|
||||
$requirement['severity'] = REQUIREMENT_ERROR;
|
||||
}
|
||||
switch ($status) {
|
||||
case UPDATE_NOT_SECURE:
|
||||
$requirement_label = t('Not secure!');
|
||||
break;
|
||||
case UPDATE_REVOKED:
|
||||
$requirement_label = t('Revoked!');
|
||||
break;
|
||||
case UPDATE_NOT_SUPPORTED:
|
||||
$requirement_label = t('Unsupported release');
|
||||
break;
|
||||
case UPDATE_NOT_CURRENT:
|
||||
$requirement_label = t('Out of date');
|
||||
$requirement['severity'] = REQUIREMENT_WARNING;
|
||||
break;
|
||||
case UPDATE_UNKNOWN:
|
||||
case UPDATE_NOT_CHECKED:
|
||||
case UPDATE_NOT_FETCHED:
|
||||
$requirement_label = isset($project['reason']) ? $project['reason'] : t('Can not determine status');
|
||||
$requirement['severity'] = REQUIREMENT_WARNING;
|
||||
break;
|
||||
default:
|
||||
$requirement_label = t('Up to date');
|
||||
}
|
||||
if ($status != UPDATE_CURRENT && $type == 'core' && isset($project['recommended'])) {
|
||||
$requirement_label .= ' '. t('(version @version available)', array('@version' => $project['recommended']));
|
||||
}
|
||||
$requirement['value'] = l($requirement_label, 'admin/reports/updates');
|
||||
return $requirement;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_cron().
|
||||
*/
|
||||
function update_cron() {
|
||||
$frequency = variable_get('update_check_frequency', 1);
|
||||
$interval = 60 * 60 * 24 * $frequency;
|
||||
// Cron should check for updates if there is no update data cached or if the
|
||||
// configured update interval has elapsed.
|
||||
if (!_update_cache_get('update_available_releases') || ((time() - variable_get('update_last_check', 0)) > $interval)) {
|
||||
update_refresh();
|
||||
_update_cron_notify();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_form_alter().
|
||||
*
|
||||
* Adds a submit handler to the system modules and themes forms, so that if a
|
||||
* site admin saves either form, we invalidate the cache of available updates.
|
||||
*
|
||||
* @see update_invalidate_cache()
|
||||
*/
|
||||
function update_form_alter(&$form, $form_state, $form_id) {
|
||||
if ($form_id == 'system_modules' || $form_id == 'system_themes_form' ) {
|
||||
$form['#submit'][] = 'update_invalidate_cache';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prints a warning message when there is no data about available updates.
|
||||
*/
|
||||
function _update_no_data() {
|
||||
$destination = drupal_get_destination();
|
||||
return t('No information is available about potential new releases for currently installed modules and themes. To check for updates, you may need to <a href="@run_cron">run cron</a> or you can <a href="@check_manually">check manually</a>. Please note that checking for available updates can take a long time, so please be patient.', array(
|
||||
'@run_cron' => url('admin/reports/status/run-cron', array('query' => $destination)),
|
||||
'@check_manually' => url('admin/reports/updates/check', array('query' => $destination)),
|
||||
));
|
||||
}
|
||||
|
||||
/**
|
||||
* Internal helper to try to get the update information from the cache
|
||||
* if possible, and to refresh the cache when necessary.
|
||||
*
|
||||
* In addition to checking the cache lifetime, this function also ensures that
|
||||
* there are no .info files for enabled modules or themes that have a newer
|
||||
* modification timestamp than the last time we checked for available update
|
||||
* data. If any .info file was modified, it almost certainly means a new
|
||||
* version of something was installed. Without fresh available update data,
|
||||
* the logic in update_calculate_project_data() will be wrong and produce
|
||||
* confusing, bogus results.
|
||||
*
|
||||
* @param $refresh
|
||||
* Boolean to indicate if this method should refresh the cache automatically
|
||||
* if there's no data.
|
||||
*
|
||||
* @see update_refresh()
|
||||
* @see update_get_projects()
|
||||
*/
|
||||
function update_get_available($refresh = FALSE) {
|
||||
module_load_include('inc', 'update', 'update.compare');
|
||||
$available = array();
|
||||
|
||||
// First, make sure that none of the .info files have a change time
|
||||
// newer than the last time we checked for available updates.
|
||||
$needs_refresh = FALSE;
|
||||
$last_check = variable_get('update_last_check', 0);
|
||||
$projects = update_get_projects();
|
||||
foreach ($projects as $key => $project) {
|
||||
if ($project['info']['_info_file_ctime'] > $last_check) {
|
||||
$needs_refresh = TRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!$needs_refresh && ($cache = _update_cache_get('update_available_releases')) && $cache->expire > time()) {
|
||||
$available = $cache->data;
|
||||
}
|
||||
elseif ($needs_refresh || $refresh) {
|
||||
// If we need to refresh due to a newer .info file, ignore the argument
|
||||
// and force the refresh (e.g., even for update_requirements()) to prevent
|
||||
// bogus results.
|
||||
$available = update_refresh();
|
||||
}
|
||||
return $available;
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrapper to load the include file and then refresh the release data.
|
||||
*/
|
||||
function update_refresh() {
|
||||
module_load_include('inc', 'update', 'update.fetch');
|
||||
return _update_refresh();
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_mail().
|
||||
*
|
||||
* Constructs the email notification message when the site is out of date.
|
||||
*
|
||||
* @param $key
|
||||
* Unique key to indicate what message to build, always 'status_notify'.
|
||||
* @param $message
|
||||
* Reference to the message array being built.
|
||||
* @param $params
|
||||
* Array of parameters to indicate what kind of text to include in the
|
||||
* message body. This is a keyed array of message type ('core' or 'contrib')
|
||||
* as the keys, and the status reason constant (UPDATE_NOT_SECURE, etc) for
|
||||
* the values.
|
||||
*
|
||||
* @see drupal_mail()
|
||||
* @see _update_cron_notify()
|
||||
* @see _update_message_text()
|
||||
*/
|
||||
function update_mail($key, &$message, $params) {
|
||||
$language = $message['language'];
|
||||
$langcode = $language->language;
|
||||
$message['subject'] .= t('New release(s) available for !site_name', array('!site_name' => variable_get('site_name', 'Drupal')), $langcode);
|
||||
foreach ($params as $msg_type => $msg_reason) {
|
||||
$message['body'][] = _update_message_text($msg_type, $msg_reason, FALSE, $language);
|
||||
}
|
||||
$message['body'][] = t('See the available updates page for more information:', array(), $langcode) ."\n". url('admin/reports/updates', array('absolute' => TRUE, 'language' => $language));
|
||||
}
|
||||
|
||||
/**
|
||||
* Helper function to return the appropriate message text when the site is out
|
||||
* of date or missing a security update.
|
||||
*
|
||||
* These error messages are shared by both update_requirements() for the
|
||||
* site-wide status report at admin/reports/status and in the body of the
|
||||
* notification emails generated by update_cron().
|
||||
*
|
||||
* @param $msg_type
|
||||
* String to indicate what kind of message to generate. Can be either
|
||||
* 'core' or 'contrib'.
|
||||
* @param $msg_reason
|
||||
* Integer constant specifying why message is generated.
|
||||
* @param $report_link
|
||||
* Boolean that controls if a link to the updates report should be added.
|
||||
* @param $language
|
||||
* An optional language object to use.
|
||||
* @return
|
||||
* The properly translated error message for the given key.
|
||||
*/
|
||||
function _update_message_text($msg_type, $msg_reason, $report_link = FALSE, $language = NULL) {
|
||||
$langcode = isset($language) ? $language->language : NULL;
|
||||
$text = '';
|
||||
switch ($msg_reason) {
|
||||
case UPDATE_NOT_SECURE:
|
||||
if ($msg_type == 'core') {
|
||||
$text = t('There is a security update available for your version of Drupal. To ensure the security of your server, you should update immediately!', array(), $langcode);
|
||||
}
|
||||
else {
|
||||
$text = t('There are security updates available for one or more of your modules or themes. To ensure the security of your server, you should update immediately!', array(), $langcode);
|
||||
}
|
||||
break;
|
||||
|
||||
case UPDATE_REVOKED:
|
||||
if ($msg_type == 'core') {
|
||||
$text = t('Your version of Drupal has been revoked and is no longer available for download. Upgrading is strongly recommended!', array(), $langcode);
|
||||
}
|
||||
else {
|
||||
$text = t('The installed version of at least one of your modules or themes has been revoked and is no longer available for download. Upgrading or disabling is strongly recommended!', array(), $langcode);
|
||||
}
|
||||
break;
|
||||
|
||||
case UPDATE_NOT_SUPPORTED:
|
||||
if ($msg_type == 'core') {
|
||||
$text = t('Your version of Drupal is no longer supported. Upgrading is strongly recommended!', array(), $langcode);
|
||||
}
|
||||
else {
|
||||
$text = t('The installed version of at least one of your modules or themes is no longer supported. Upgrading or disabling is strongly recommended! Please see the project homepage for more details.', array(), $langcode);
|
||||
}
|
||||
break;
|
||||
|
||||
case UPDATE_NOT_CURRENT:
|
||||
if ($msg_type == 'core') {
|
||||
$text = t('There are updates available for your version of Drupal. To ensure the proper functioning of your site, you should update as soon as possible.', array(), $langcode);
|
||||
}
|
||||
else {
|
||||
$text = t('There are updates available for one or more of your modules or themes. To ensure the proper functioning of your site, you should update as soon as possible.', array(), $langcode);
|
||||
}
|
||||
break;
|
||||
|
||||
case UPDATE_UNKNOWN:
|
||||
case UPDATE_NOT_CHECKED:
|
||||
case UPDATE_NOT_FETCHED:
|
||||
if ($msg_type == 'core') {
|
||||
$text = t('There was a problem determining the status of available updates for your version of Drupal.', array(), $langcode);
|
||||
}
|
||||
else {
|
||||
$text = t('There was a problem determining the status of available updates for one or more of your modules or themes.', array(), $langcode);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if ($report_link) {
|
||||
$text .= ' '. t('See the <a href="@available_updates">available updates</a> page for more information.', array('@available_updates' => url('admin/reports/updates', array('language' => $language))), $langcode);
|
||||
}
|
||||
|
||||
return $text;
|
||||
}
|
||||
|
||||
/**
|
||||
* Private sort function to order projects based on their status.
|
||||
*
|
||||
* @see update_requirements()
|
||||
* @see uasort()
|
||||
*/
|
||||
function _update_project_status_sort($a, $b) {
|
||||
// The status constants are numerically in the right order, so we can
|
||||
// usually subtract the two to compare in the order we want. However,
|
||||
// negative status values should be treated as if they are huge, since we
|
||||
// always want them at the bottom of the list.
|
||||
$a_status = $a['status'] > 0 ? $a['status'] : (-10 * $a['status']);
|
||||
$b_status = $b['status'] > 0 ? $b['status'] : (-10 * $b['status']);
|
||||
return $a_status - $b_status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @defgroup update_status_cache Private update status cache system
|
||||
* @{
|
||||
*
|
||||
* We specifically do NOT use the core cache API for saving the fetched data
|
||||
* about available updates. It is vitally important that this cache is only
|
||||
* cleared when we're populating it after successfully fetching new available
|
||||
* update data. Usage of the core cache API results in all sorts of potential
|
||||
* problems that would result in attempting to fetch available update data all
|
||||
* the time, including if a site has a "minimum cache lifetime" (which is both
|
||||
* a minimum and a maximum) defined, or if a site uses memcache or another
|
||||
* plug-able cache system that assumes volatile caches.
|
||||
*
|
||||
* Update module still uses the {cache_update} table, but instead of using
|
||||
* cache_set(), cache_get(), and cache_clear_all(), there are private helper
|
||||
* functions that implement these same basic tasks but ensure that the cache
|
||||
* is not prematurely cleared, and that the data is always stored in the
|
||||
* database, even if memcache or another cache backend is in use.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Store data in the private update status cache table.
|
||||
*
|
||||
* Note: this function completely ignores the {cache_update}.headers field
|
||||
* since that is meaningless for the kinds of data we're caching.
|
||||
*
|
||||
* @param $cid
|
||||
* The cache ID to save the data with.
|
||||
* @param $data
|
||||
* The data to store.
|
||||
* @param $expire
|
||||
* One of the following values:
|
||||
* - CACHE_PERMANENT: Indicates that the item should never be removed except
|
||||
* by explicitly using _update_cache_clear() or update_invalidate_cache().
|
||||
* - A Unix timestamp: Indicates that the item should be kept at least until
|
||||
* the given time, after which it will be invalidated.
|
||||
*/
|
||||
function _update_cache_set($cid, $data, $expire) {
|
||||
$serialized = 0;
|
||||
if (is_object($data) || is_array($data)) {
|
||||
$data = serialize($data);
|
||||
$serialized = 1;
|
||||
}
|
||||
$created = time();
|
||||
db_query("UPDATE {cache_update} SET data = %b, created = %d, expire = %d, serialized = %d WHERE cid = '%s'", $data, $created, $expire, $serialized, $cid);
|
||||
if (!db_affected_rows()) {
|
||||
@db_query("INSERT INTO {cache_update} (cid, data, created, expire, serialized) VALUES ('%s', %b, %d, %d, %d)", $cid, $data, $created, $expire, $serialized);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve data from the private update status cache table.
|
||||
*
|
||||
* @param $cid
|
||||
* The cache ID to retrieve.
|
||||
* @return
|
||||
* The data for the given cache ID, or NULL if the ID was not found.
|
||||
*/
|
||||
function _update_cache_get($cid) {
|
||||
$cache = db_fetch_object(db_query("SELECT data, created, expire, serialized FROM {cache_update} WHERE cid = '%s'", $cid));
|
||||
if (isset($cache->data)) {
|
||||
$cache->data = db_decode_blob($cache->data);
|
||||
if ($cache->serialized) {
|
||||
$cache->data = unserialize($cache->data);
|
||||
}
|
||||
}
|
||||
return $cache;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invalidates specific cached data relating to update status.
|
||||
*
|
||||
* @param $cid
|
||||
* Optional cache ID of the record to clear from the private update module
|
||||
* cache. If empty, all records will be cleared from the table.
|
||||
*/
|
||||
function _update_cache_clear($cid = NULL) {
|
||||
if (empty($cid)) {
|
||||
db_query("TRUNCATE TABLE {cache_update}");
|
||||
}
|
||||
else {
|
||||
db_query("DELETE FROM {cache_update} WHERE cid = '%s'", $cid);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of hook_flush_caches().
|
||||
*
|
||||
* Called from update.php (among others) to flush the caches.
|
||||
* Since we're running update.php, we are likely to install a new version of
|
||||
* something, in which case, we want to check for available update data again.
|
||||
* However, because we have our own caching system, we need to directly clear
|
||||
* the database table ourselves at this point and return nothing, for example,
|
||||
* on sites that use memcache where cache_clear_all() won't know how to purge
|
||||
* this data.
|
||||
*
|
||||
* However, we only want to do this from update.php, since otherwise, we'd
|
||||
* lose all the available update data on every cron run. So, we specifically
|
||||
* check if the site is in MAINTENANCE_MODE == 'update' (which indicates
|
||||
* update.php is running, not update module... alas for overloaded names).
|
||||
*/
|
||||
function update_flush_caches() {
|
||||
if (defined('MAINTENANCE_MODE') && MAINTENANCE_MODE == 'update') {
|
||||
_update_cache_clear();
|
||||
}
|
||||
return array();
|
||||
}
|
||||
|
||||
/**
|
||||
* Invalidates all cached data relating to update status.
|
||||
*/
|
||||
function update_invalidate_cache() {
|
||||
_update_cache_clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* @} End of "defgroup update_status_cache".
|
||||
*/
|
||||
264
modules/update/update.report.inc
Normal file
264
modules/update/update.report.inc
Normal file
|
|
@ -0,0 +1,264 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Code required only when rendering the available updates report.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Menu callback. Generate a page about the update status of projects.
|
||||
*/
|
||||
function update_status() {
|
||||
if ($available = update_get_available(TRUE)) {
|
||||
module_load_include('inc', 'update', 'update.compare');
|
||||
$data = update_calculate_project_data($available);
|
||||
return theme('update_report', $data);
|
||||
}
|
||||
else {
|
||||
return theme('update_report', _update_no_data());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Theme project status report.
|
||||
*
|
||||
* @ingroup themeable
|
||||
*/
|
||||
function theme_update_report($data) {
|
||||
$last = variable_get('update_last_check', 0);
|
||||
$output = '<div class="update checked">'. ($last ? t('Last checked: @time ago', array('@time' => format_interval(time() - $last))) : t('Last checked: never'));
|
||||
$output .= ' <span class="check-manually">('. l(t('Check manually'), 'admin/reports/updates/check') .')</span>';
|
||||
$output .= "</div>\n";
|
||||
|
||||
if (!is_array($data)) {
|
||||
$output .= '<p>'. $data .'</p>';
|
||||
return $output;
|
||||
}
|
||||
|
||||
$header = array();
|
||||
$rows = array();
|
||||
|
||||
$notification_level = variable_get('update_notification_threshold', 'all');
|
||||
|
||||
foreach ($data as $project) {
|
||||
switch ($project['status']) {
|
||||
case UPDATE_CURRENT:
|
||||
$class = 'ok';
|
||||
$icon = theme('image', 'misc/watchdog-ok.png', t('ok'), t('ok'));
|
||||
break;
|
||||
case UPDATE_UNKNOWN:
|
||||
case UPDATE_NOT_FETCHED:
|
||||
$class = 'unknown';
|
||||
$icon = theme('image', 'misc/watchdog-warning.png', t('warning'), t('warning'));
|
||||
break;
|
||||
case UPDATE_NOT_SECURE:
|
||||
case UPDATE_REVOKED:
|
||||
case UPDATE_NOT_SUPPORTED:
|
||||
$class = 'error';
|
||||
$icon = theme('image', 'misc/watchdog-error.png', t('error'), t('error'));
|
||||
break;
|
||||
case UPDATE_NOT_CHECKED:
|
||||
case UPDATE_NOT_CURRENT:
|
||||
default:
|
||||
$class = 'warning';
|
||||
$icon = theme('image', 'misc/watchdog-warning.png', t('warning'), t('warning'));
|
||||
break;
|
||||
}
|
||||
|
||||
$row = '<div class="version-status">';
|
||||
switch ($project['status']) {
|
||||
case UPDATE_NOT_SECURE:
|
||||
$row .= '<span class="security-error">'. t('Security update required!') .'</span>';
|
||||
break;
|
||||
case UPDATE_REVOKED:
|
||||
$row .= '<span class="revoked">'. t('Revoked!') .'</span>';
|
||||
break;
|
||||
case UPDATE_NOT_SUPPORTED:
|
||||
$row .= '<span class="not-supported">'. t('Not supported!') .'</span>';
|
||||
break;
|
||||
case UPDATE_NOT_CURRENT:
|
||||
$row .= '<span class="not-current">'. t('Update available') .'</span>';
|
||||
break;
|
||||
case UPDATE_CURRENT:
|
||||
$row .= '<span class="current">'. t('Up to date') .'</span>';
|
||||
break;
|
||||
default:
|
||||
$row .= check_plain($project['reason']);
|
||||
break;
|
||||
}
|
||||
$row .= '<span class="icon">'. $icon .'</span>';
|
||||
$row .= "</div>\n";
|
||||
|
||||
$row .= '<div class="project">';
|
||||
if (isset($project['title'])) {
|
||||
if (isset($project['link'])) {
|
||||
$row .= l($project['title'], $project['link']);
|
||||
}
|
||||
else {
|
||||
$row .= check_plain($project['title']);
|
||||
}
|
||||
}
|
||||
else {
|
||||
$row .= check_plain($project['name']);
|
||||
}
|
||||
$row .= ' '. check_plain($project['existing_version']);
|
||||
if ($project['install_type'] == 'dev' && !empty($project['datestamp'])) {
|
||||
$row .= ' <span class="version-date">('. format_date($project['datestamp'], 'custom', 'Y-M-d') .')</span>';
|
||||
}
|
||||
$row .= "</div>\n";
|
||||
|
||||
$row .= "<div class=\"versions\">\n";
|
||||
|
||||
if (isset($project['recommended'])) {
|
||||
if ($project['status'] != UPDATE_CURRENT || $project['existing_version'] !== $project['recommended']) {
|
||||
|
||||
// First, figure out what to recommend.
|
||||
// If there's only 1 security update and it has the same version we're
|
||||
// recommending, give it the same CSS class as if it was recommended,
|
||||
// but don't print out a separate "Recommended" line for this project.
|
||||
if (!empty($project['security updates']) && count($project['security updates']) == 1 && $project['security updates'][0]['version'] === $project['recommended']) {
|
||||
$security_class = ' version-recommended version-recommended-strong';
|
||||
}
|
||||
else {
|
||||
$security_class = '';
|
||||
$version_class = 'version-recommended';
|
||||
// Apply an extra class if we're displaying both a recommended
|
||||
// version and anything else for an extra visual hint.
|
||||
if ($project['recommended'] !== $project['latest_version']
|
||||
|| !empty($project['also'])
|
||||
|| ($project['install_type'] == 'dev'
|
||||
&& isset($project['dev_version'])
|
||||
&& $project['latest_version'] !== $project['dev_version']
|
||||
&& $project['recommended'] !== $project['dev_version'])
|
||||
|| (isset($project['security updates'][0])
|
||||
&& $project['recommended'] !== $project['security updates'][0])
|
||||
) {
|
||||
$version_class .= ' version-recommended-strong';
|
||||
}
|
||||
$row .= theme('update_version', $project['releases'][$project['recommended']], t('Recommended version:'), $version_class);
|
||||
}
|
||||
|
||||
// Now, print any security updates.
|
||||
if (!empty($project['security updates'])) {
|
||||
foreach ($project['security updates'] as $security_update) {
|
||||
$row .= theme('update_version', $security_update, t('Security update:'), 'version-security'. $security_class);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ($project['recommended'] !== $project['latest_version']) {
|
||||
$row .= theme('update_version', $project['releases'][$project['latest_version']], t('Latest version:'), 'version-latest');
|
||||
}
|
||||
if ($project['install_type'] == 'dev'
|
||||
&& $project['status'] != UPDATE_CURRENT
|
||||
&& isset($project['dev_version'])
|
||||
&& $project['recommended'] !== $project['dev_version']) {
|
||||
$row .= theme('update_version', $project['releases'][$project['dev_version']], t('Development version:'), 'version-latest');
|
||||
}
|
||||
}
|
||||
|
||||
if (isset($project['also'])) {
|
||||
foreach ($project['also'] as $also) {
|
||||
$row .= theme('update_version', $project['releases'][$also], t('Also available:'), 'version-also-available');
|
||||
}
|
||||
}
|
||||
|
||||
$row .= "</div>\n"; // versions div.
|
||||
|
||||
$row .= "<div class=\"info\">\n";
|
||||
if (!empty($project['extra'])) {
|
||||
$row .= '<div class="extra">'."\n";
|
||||
foreach ($project['extra'] as $key => $value) {
|
||||
$row .= '<div class="'. $value['class'] .'">';
|
||||
$row .= check_plain($value['label']) .': ';
|
||||
$row .= theme('placeholder', $value['data']);
|
||||
$row .= "</div>\n";
|
||||
}
|
||||
$row .= "</div>\n"; // extra div.
|
||||
}
|
||||
|
||||
$row .= '<div class="includes">';
|
||||
sort($project['includes']);
|
||||
$row .= t('Includes: %includes', array('%includes' => implode(', ', $project['includes'])));
|
||||
$row .= "</div>\n";
|
||||
|
||||
if (!empty($project['base_themes'])) {
|
||||
$row .= '<div class="basethemes">';
|
||||
sort($project['base_themes']);
|
||||
// We use !dependencies and manually call theme('placeholder') here to
|
||||
// avoid breakding the D6 string freeze. This identical string is
|
||||
// already in modules/system/system.admin.inc.
|
||||
$row .= t('Depends on: !dependencies', array('!dependencies' => theme('placeholder', implode(', ', $project['base_themes']))));
|
||||
$row .= "</div>\n";
|
||||
}
|
||||
|
||||
if (!empty($project['sub_themes'])) {
|
||||
$row .= '<div class="subthemes">';
|
||||
sort($project['sub_themes']);
|
||||
// We use !required and manually call theme('placeholder') here to avoid
|
||||
// breakding the D6 string freeze. This identical string is already in
|
||||
// modules/system/system.admin.inc.
|
||||
$row .= t('Required by: !required', array('!required' => theme('placeholder', implode(', ', $project['sub_themes']))));
|
||||
$row .= "</div>\n";
|
||||
}
|
||||
|
||||
$row .= "</div>\n"; // info div.
|
||||
|
||||
if (!isset($rows[$project['project_type']])) {
|
||||
$rows[$project['project_type']] = array();
|
||||
}
|
||||
$row_key = isset($project['title']) ? drupal_strtolower($project['title']) : drupal_strtolower($project['name']);
|
||||
$rows[$project['project_type']][$row_key] = array(
|
||||
'class' => $class,
|
||||
'data' => array($row),
|
||||
);
|
||||
}
|
||||
|
||||
$project_types = array(
|
||||
'core' => t('Drupal core'),
|
||||
'module' => t('Modules'),
|
||||
'theme' => t('Themes'),
|
||||
'disabled-module' => t('Disabled modules'),
|
||||
'disabled-theme' => t('Disabled themes'),
|
||||
);
|
||||
foreach ($project_types as $type_name => $type_label) {
|
||||
if (!empty($rows[$type_name])) {
|
||||
ksort($rows[$type_name]);
|
||||
$output .= "\n<h3>". $type_label ."</h3>\n";
|
||||
$output .= theme('table', $header, $rows[$type_name], array('class' => 'update'));
|
||||
}
|
||||
}
|
||||
drupal_add_css(drupal_get_path('module', 'update') .'/update.css');
|
||||
return $output;
|
||||
}
|
||||
|
||||
/**
|
||||
* Theme the version display of a project.
|
||||
*
|
||||
* @ingroup themeable
|
||||
*/
|
||||
function theme_update_version($version, $tag, $class) {
|
||||
$output = '';
|
||||
$output .= '<table class="version '. $class .'">';
|
||||
$output .= '<tr>';
|
||||
$output .= '<td class="version-title">'. $tag ."</td>\n";
|
||||
$output .= '<td class="version-details">';
|
||||
$output .= l($version['version'], $version['release_link']);
|
||||
$output .= ' <span class="version-date">('. format_date($version['date'], 'custom', 'Y-M-d') .')</span>';
|
||||
$output .= "</td>\n";
|
||||
$output .= '<td class="version-links">';
|
||||
$links = array();
|
||||
$links['update-download'] = array(
|
||||
'title' => t('Download'),
|
||||
'href' => $version['download_link'],
|
||||
);
|
||||
$links['update-release-notes'] = array(
|
||||
'title' => t('Release notes'),
|
||||
'href' => $version['release_link'],
|
||||
);
|
||||
$output .= theme('links', $links);
|
||||
$output .= '</td>';
|
||||
$output .= '</tr>';
|
||||
$output .= "</table>\n";
|
||||
return $output;
|
||||
}
|
||||
107
modules/update/update.settings.inc
Normal file
107
modules/update/update.settings.inc
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Code required only for the update status settings form.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Form builder for the update settings tab.
|
||||
*/
|
||||
function update_settings() {
|
||||
$form = array();
|
||||
|
||||
$notify_emails = variable_get('update_notify_emails', array());
|
||||
$form['update_notify_emails'] = array(
|
||||
'#type' => 'textarea',
|
||||
'#title' => t('E-mail addresses to notify when updates are available'),
|
||||
'#rows' => 4,
|
||||
'#default_value' => implode("\n", $notify_emails),
|
||||
'#description' => t('Whenever your site checks for available updates and finds new releases, it can notify a list of users via e-mail. Put each address on a separate line. If blank, no e-mails will be sent.'),
|
||||
);
|
||||
|
||||
$form['update_check_frequency'] = array(
|
||||
'#type' => 'radios',
|
||||
'#title' => t('Check for updates'),
|
||||
'#default_value' => variable_get('update_check_frequency', 1),
|
||||
'#options' => array(
|
||||
'1' => t('Daily'),
|
||||
'7' => t('Weekly'),
|
||||
),
|
||||
'#description' => t('Select how frequently you want to automatically check for new releases of your currently installed modules and themes.'),
|
||||
);
|
||||
|
||||
$form['update_notification_threshold'] = array(
|
||||
'#type' => 'radios',
|
||||
'#title' => t('E-mail notification threshold'),
|
||||
'#default_value' => variable_get('update_notification_threshold', 'all'),
|
||||
'#options' => array(
|
||||
'all' => t('All newer versions'),
|
||||
'security' => t('Only security updates'),
|
||||
),
|
||||
'#description' => t('You can choose to send e-mail only if a security update is available, or to be notified about all newer versions. If there are updates available of Drupal core or any of your installed modules and themes, your site will always print a message on the <a href="@status_report">status report</a> page, and will also display an error message on administration pages if there is a security update.', array('@status_report' => url('admin/reports/status')))
|
||||
);
|
||||
|
||||
$form = system_settings_form($form);
|
||||
// Custom valiation callback for the email notification setting.
|
||||
$form['#validate'][] = 'update_settings_validate';
|
||||
// We need to call our own submit callback first, not the one from
|
||||
// system_settings_form(), so that we can process and save the emails.
|
||||
unset($form['#submit']);
|
||||
|
||||
return $form;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validation callback for the settings form.
|
||||
*
|
||||
* Validates the email addresses and ensures the field is formatted correctly.
|
||||
*/
|
||||
function update_settings_validate($form, &$form_state) {
|
||||
if (!empty($form_state['values']['update_notify_emails'])) {
|
||||
$valid = array();
|
||||
$invalid = array();
|
||||
foreach (explode("\n", trim($form_state['values']['update_notify_emails'])) as $email) {
|
||||
$email = trim($email);
|
||||
if (!empty($email)) {
|
||||
if (valid_email_address($email)) {
|
||||
$valid[] = $email;
|
||||
}
|
||||
else {
|
||||
$invalid[] = $email;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (empty($invalid)) {
|
||||
$form_state['notify_emails'] = $valid;
|
||||
}
|
||||
elseif (count($invalid) == 1) {
|
||||
form_set_error('update_notify_emails', t('%email is not a valid e-mail address.', array('%email' => reset($invalid))));
|
||||
}
|
||||
else {
|
||||
form_set_error('update_notify_emails', t('%emails are not valid e-mail addresses.', array('%emails' => implode(', ', $invalid))));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit handler for the settings tab.
|
||||
*/
|
||||
function update_settings_submit($form, $form_state) {
|
||||
$op = $form_state['values']['op'];
|
||||
|
||||
if ($op == t('Reset to defaults')) {
|
||||
unset($form_state['notify_emails']);
|
||||
}
|
||||
else {
|
||||
if (empty($form_state['notify_emails'])) {
|
||||
variable_del('update_notify_emails');
|
||||
}
|
||||
else {
|
||||
variable_set('update_notify_emails', $form_state['notify_emails']);
|
||||
}
|
||||
unset($form_state['notify_emails']);
|
||||
unset($form_state['values']['update_notify_emails']);
|
||||
}
|
||||
system_settings_form_submit($form, $form_state);
|
||||
}
|
||||
Reference in a new issue