496 lines
17 KiB
PHP
496 lines
17 KiB
PHP
<?php
|
|
// ***** BEGIN LICENSE BLOCK *****
|
|
//
|
|
// Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
//
|
|
// The contents of this file are subject to the Mozilla Public License Version
|
|
// 1.1 (the "License"); you may not use this file except in compliance with
|
|
// the License. You may obtain a copy of the License at
|
|
// http://www.mozilla.org/MPL/
|
|
//
|
|
// Software distributed under the License is distributed on an "AS IS" basis,
|
|
// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
// for the specific language governing rights and limitations under the
|
|
// License.
|
|
//
|
|
// The Original Code is AUS.
|
|
//
|
|
// The Initial Developer of the Original Code is Mike Morgan.
|
|
//
|
|
// Portions created by the Initial Developer are Copyright (C) 2006
|
|
// the Initial Developer. All Rights Reserved.
|
|
//
|
|
// Contributor(s):
|
|
// Mike Morgan <morgamic@mozilla.com>
|
|
//
|
|
// Alternatively, the contents of this file may be used under the terms of
|
|
// either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
// in which case the provisions of the GPL or the LGPL are applicable instead
|
|
// of those above. If you wish to allow use of your version of this file only
|
|
// under the terms of either the GPL or the LGPL, and not to allow others to
|
|
// use your version of this file under the terms of the MPL, indicate your
|
|
// decision by deleting the provisions above and replace them with the notice
|
|
// and other provisions required by the GPL or the LGPL. If you do not delete
|
|
// the provisions above, a recipient may use your version of this file under
|
|
// the terms of any one of the MPL, the GPL or the LGPL.
|
|
//
|
|
// ***** END LICENSE BLOCK *****
|
|
|
|
define('DEFAULT_SNIPPET_SCHEMA_VER', 0);
|
|
define('CURRENT_SNIPPET_SCHEMA_VER', 1);
|
|
|
|
/**
|
|
* AUS Patch class.
|
|
* @package aus
|
|
* @subpackage inc
|
|
* @author Mike Morgan
|
|
*
|
|
* This class is for handling patch objects.
|
|
* These carry relevant information about partial or complete patches.
|
|
*/
|
|
class Patch extends AUS_Object {
|
|
|
|
// Patch metadata.
|
|
var $type;
|
|
var $url;
|
|
var $hashFunction;
|
|
var $hashValue;
|
|
var $size;
|
|
var $build;
|
|
|
|
// Array that maps versions onto their respective branches.
|
|
var $productBranchVersions;
|
|
|
|
// Array the defines which channels are flagged as 'nightly' channels.
|
|
var $nightlyChannels;
|
|
|
|
// Valid patch flag.
|
|
var $isPatch;
|
|
|
|
// Is this patch a complete or partial patch?
|
|
var $patchType;
|
|
|
|
// Update metadata, read from patch file.
|
|
var $updateType;
|
|
var $updateVersion;
|
|
var $updateExtensionVersion;
|
|
var $licenseUrl;
|
|
|
|
// Do we have Update metadata information?
|
|
var $hasUpdateInfo;
|
|
var $hasDetailsUrl;
|
|
|
|
/**
|
|
* Constructor.
|
|
*/
|
|
function Patch($productBranchVersions=array(),$nightlyChannels,$type='complete') {
|
|
$this->setProductBranchVersions($productBranchVersions);
|
|
$this->setNightlyChannels($nightlyChannels);
|
|
$this->setVar('isPatch',false);
|
|
$this->setVar('patchType',$type);
|
|
$this->setVar('updateType','minor');
|
|
$this->setVar('hasUpdateInfo',false);
|
|
$this->setVar('hasDetailsUrl',false);
|
|
}
|
|
|
|
/**
|
|
* Set the filepath for the snippet based on product/platform/locale and
|
|
* SOURCE_DIR, which is set in config.
|
|
*
|
|
* @param string $product
|
|
* @param string $platform
|
|
* @param string $locale
|
|
* @param string $version
|
|
* @param string $build
|
|
* @param string $buildSource
|
|
* @param string $channel
|
|
*
|
|
* @return boolean
|
|
*/
|
|
function setPath ($product,$platform,$locale,$version=null,$build,$buildSource,$channel) {
|
|
switch($buildSource) {
|
|
case 3:
|
|
return $this->setVar('path',OVERRIDE_DIR.'/'.$product.'/'.$version.'/'.$platform.'/'.$build.'/'.$locale.'/'.$channel.'/'.$this->patchType.'.txt',true);
|
|
break;
|
|
case 2:
|
|
return $this->setVar('path',SOURCE_DIR.'/'.$buildSource.'/'.$product.'/'.$version.'/'.$platform.'/'.$build.'/'.$locale.'/'.$this->patchType.'.txt',true);
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Read the given file and store its contents in our Patch object.
|
|
*
|
|
* @param string $path
|
|
*
|
|
* @return boolean
|
|
*/
|
|
function setSnippet ($path) {
|
|
|
|
// Default to the old Schema type
|
|
$snippetSchemaVersion = DEFAULT_SNIPPET_SCHEMA_VER;
|
|
|
|
// Attempt to read the file. Return false on failure, since there's nothing left to do.
|
|
if (!($file = explode("\n",file_get_contents($path,true)))) {
|
|
return false;
|
|
}
|
|
|
|
if (preg_match('/^version=(\d+)$/', $file[0], $matches)) {
|
|
$snippetSchemaVersion = $matches[1];
|
|
}
|
|
|
|
/**
|
|
* This is the "legacy" way of reading snippet files. This will be phased out.
|
|
*/
|
|
if (DEFAULT_SNIPPET_SCHEMA_VER == $snippetSchemaVersion) {
|
|
|
|
$this->setVar('version', DEFAULT_SNIPPET_SCHEMA_VER);
|
|
$this->setVar('type',$file[0]);
|
|
$this->setVar('url',$file[1]);
|
|
$this->setVar('hashFunction',$file[2]);
|
|
$this->setVar('hashValue',$file[3]);
|
|
$this->setVar('size',$file[4]);
|
|
$this->setVar('build',$file[5]);
|
|
|
|
// Attempt to read update information.
|
|
if ($this->isComplete() && isset($file[6]) && isset($file[7])) {
|
|
$this->setVar('updateVersion',$file[6],true);
|
|
$this->setVar('updateExtensionVersion',$file[7],true);
|
|
$this->setVar('hasUpdateInfo',true,true);
|
|
}
|
|
|
|
// Pull update metadata if it exists, and the patch is a complete patch.
|
|
if ($this->isComplete() && isset($file[8])) {
|
|
$this->setVar('detailsUrl',$file[8],true);
|
|
$this->setVar('hasDetailsUrl',true,true);
|
|
}
|
|
|
|
$this->setVar('isPatch',true,true);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This is an attribute-driven build snippet schema. Data will be in the form:
|
|
* key=value
|
|
* foo=bar
|
|
* bar=foo
|
|
*/
|
|
elseif (CURRENT_SNIPPET_SCHEMA_VER == $snippetSchemaVersion) {
|
|
|
|
// For each line in the file, read the key=value pairing.
|
|
//
|
|
// If the pairing is matches our expected schema format, set them appropriately.
|
|
foreach ($file as $row) {
|
|
if (preg_match('/^(\w+)=(.+)$/', $row, $matches)) {
|
|
$snippetKey = $matches[1];
|
|
$snippetValue = $matches[2];
|
|
$this->setVar($snippetKey, $snippetValue, true);
|
|
}
|
|
}
|
|
|
|
// Store information found only in complete snippets.
|
|
// This information is tied to the <update> element.
|
|
if ($this->isComplete()) {
|
|
if (isset($this->appv) && isset($this->extv)) {
|
|
$this->setVar('updateVersion', $this->appv, true);
|
|
$this->setVar('updateExtensionVersion', $this->extv, true);
|
|
$this->setVar('hasUpdateInfo', true, true);
|
|
}
|
|
|
|
if (isset($this->detailsUrl)) {
|
|
$this->setVar('hasDetailsUrl', true, true);
|
|
}
|
|
}
|
|
|
|
$this->setVar('isPatch',true,true);
|
|
return true;
|
|
} else {
|
|
error_log("Unknown snippet schema version: $snippetSchemaVersion");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempt to read and parse the designated source file.
|
|
* How and where the file is read depends on the client version.
|
|
*
|
|
* For more information on why this is a little complicated, see:
|
|
* https://intranet.mozilla.org/AUS:Version2:Roadmap:Multibranch
|
|
*
|
|
* @param string $product
|
|
* @param string $platform
|
|
* @param string $locale
|
|
* @param string $version
|
|
* @param string $build
|
|
* @param string $channel
|
|
*
|
|
* @return boolean
|
|
*/
|
|
function findPatch($product,$platform,$locale,$version,$build,$channel=null) {
|
|
|
|
// If a specific update exists for the specified channel, it takes priority over the branch update.
|
|
if (!empty($channel) && $this->setPath($product,$platform,$locale,$version,$build,3,$channel) && file_exists($this->path) && filesize($this->path) > 0) {
|
|
return $this->setSnippet($this->path);
|
|
}
|
|
|
|
// If our channel matches our regexp for fallback channels, let's try to fallback.
|
|
//
|
|
// In our condition below, we check to see that the normal update path doesn't have a file that exists.
|
|
//
|
|
// If the file does exist, we don't ever fall back, which is the hacky way to stop the fallback behavior,
|
|
// but the only way we have so far.
|
|
if (!empty($channel) && $this->setPath($product,$platform,$locale,$version,$build,3,$channel) && !file_exists($this->path) && preg_match('/^[\w\-]+\-cck\-.[\w\-]+$/',$channel)) {
|
|
|
|
// Partner fallback channel to be used if the partner-specific update doesn't exist or work.
|
|
$buf = array();
|
|
$buf = split('-cck-',$channel);
|
|
$fallbackChannel = $buf[0];
|
|
|
|
// Do a check for the fallback update. If we find a valid fallback update, we can offer it.
|
|
if (!empty($fallbackChannel) && $this->setPath($product,$platform,$locale,$version,$build,3,$fallbackChannel) && file_exists($this->path) && filesize($this->path) > 0) {
|
|
return $this->setSnippet($this->path);
|
|
}
|
|
}
|
|
|
|
// Determine the branch of the client's version.
|
|
$branchVersion = $this->getBranch($product,$version);
|
|
|
|
// Otherwise, if it is a complete patch and a nightly channel, force the complete update to take the user to the latest build.
|
|
if ($this->isComplete() && $this->isNightlyChannel($channel)) {
|
|
|
|
// Get the latest build that has an update for this branch.
|
|
$latestCompleteBuild = $this->getLatestCompleteBuild($product,$branchVersion,$platform);
|
|
|
|
// If we have the latest complete build, the path is valid, the file exists, and the filesize is greater than zero, we have a valid complete patch.
|
|
if ($latestCompleteBuild && $this->setPath($product,$platform,$locale,$branchVersion,$latestCompleteBuild,2,$channel) && file_exists($this->path) && filesize($this->path) > 0) {
|
|
$this->setSnippet($this->path);
|
|
return $this->isNewerBuild($build);
|
|
}
|
|
}
|
|
|
|
// Otherwise, check for the partial snippet info. If an update exists, pass it along.
|
|
if ($this->isPartial() && $this->isNightlyChannel($channel) && $this->setPath($product,$platform,$locale,$branchVersion,$build,2,$channel) && file_exists($this->path) && filesize($this->path) > 0) {
|
|
$this->setSnippet($this->path);
|
|
return $this->isNewerBuild($build);
|
|
}
|
|
|
|
// Note: Other data sets were made obsolete in 0.6. May incoming/0,1 rest in peace.
|
|
|
|
// If we get here, we know for sure that no updates exist for the current request..
|
|
// Return false by default, which prompts the "no updates" XML output.
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Compare passed build to build in snippet.
|
|
* Returns true if the snippet build is newer than the client build.
|
|
*
|
|
* @param string $build
|
|
* @return boolean
|
|
*/
|
|
function isNewerBuild($build) {
|
|
return ($this->build>$build);
|
|
}
|
|
|
|
/**
|
|
* Set the product & branch versions array.
|
|
*
|
|
* @param array $productBranchVersions
|
|
* @return boolean
|
|
*/
|
|
function setProductBranchVersions($productBranchVersions) {
|
|
return $this->setVar('productBranchVersions',$productBranchVersions);
|
|
}
|
|
|
|
/**
|
|
* Set the nightly channels array.
|
|
*
|
|
* @param array $branchVersions
|
|
* @return boolean
|
|
*/
|
|
function setNightlyChannels($nightlyChannels) {
|
|
return $this->setVar('nightlyChannels',$nightlyChannels);
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not the given channel is flagged as nightly.
|
|
*
|
|
* @param string $channel
|
|
*
|
|
* @return bool
|
|
*/
|
|
function isNightlyChannel($channel) {
|
|
return in_array($channel,$this->nightlyChannels);
|
|
}
|
|
|
|
|
|
/**
|
|
* Determine whether or not the incoming version is a product BRANCH.
|
|
*
|
|
* @param string $product
|
|
* @param string $version
|
|
* @return string|false
|
|
*/
|
|
function getBranch($product,$version) {
|
|
if (!isset ($this->productBranchVersions[$product])) {
|
|
return false;
|
|
}
|
|
foreach ($this->productBranchVersions[$product] as $versionPattern => $branch) {
|
|
// No need to create a regular expression if there's no wildcard
|
|
if (strpos ($versionPattern, '*') === false) {
|
|
if ($versionPattern == $version) {
|
|
return $branch;
|
|
}
|
|
} elseif (preg_match('/^'. str_replace('\\*', '.*', preg_quote($versionPattern, '/')) .'$/', $version)) {
|
|
return $branch;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not something is Trunk.
|
|
*
|
|
* @param string $version
|
|
* @return boolean
|
|
*/
|
|
function isTrunk($version) {
|
|
return ($version == 'trunk') ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Does this object contain a valid patch file?
|
|
* @return boolean
|
|
*/
|
|
function isPatch() {
|
|
return $this->isPatch;
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not this patch is a complete patch.
|
|
*/
|
|
function isComplete() {
|
|
return $this->patchType === 'complete';
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not this patch is a partial patch.
|
|
*/
|
|
function isPartial() {
|
|
return $this->patchType === 'partial';
|
|
}
|
|
|
|
|
|
/**
|
|
* Determine whether or not this patch has a details URL.
|
|
* @TODO Make this a bit more graceful, possibly join it with hasUpdateInfo, or find a better way.
|
|
*/
|
|
function hasDetailsUrl() {
|
|
return $this->hasDetailsUrl;
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not this patch has update information.
|
|
* @TODO Make this a bit more graceful.
|
|
*/
|
|
function hasUpdateInfo() {
|
|
return $this->hasUpdateInfo;
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not this patch has update type information.
|
|
*/
|
|
function hasUpdateType() {
|
|
return isset($this->updateType);
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not we have a license URL and our patch is a major update.
|
|
*/
|
|
function hasLicenseUrl() {
|
|
return (isset($this->licenseUrl) && $this->isComplete());
|
|
}
|
|
|
|
/**
|
|
* Determine whether or not the to_build matches the latest build (taken from the complete build) for a partial patch.
|
|
* @param string $completeBuild
|
|
*
|
|
* @return bool
|
|
*/
|
|
function isOneStepFromLatest($completeBuild) {
|
|
return ($this->build == $completeBuild) ? true : false;
|
|
}
|
|
|
|
/**
|
|
* Get the latest build with and update for this branch. The purpose of this function is to find the last build that contains an update.
|
|
* @param string $product
|
|
* @param string $branchVersion
|
|
* @param string $platform
|
|
* @param return string|false false if there is no matching build
|
|
*/
|
|
function getLatestCompleteBuild($product,$branchVersion,$platform) {
|
|
$files = array();
|
|
|
|
$dir = SOURCE_DIR.'/2/'.$product.'/'.$branchVersion.'/'.$platform;
|
|
|
|
// Find the build ids for the given product/branchVersion/platform. The last complete update
|
|
// is found in the second-to-last build directory.
|
|
//
|
|
// To get this build id, we sort the directory listing by number and retrieve $files[1].
|
|
if (is_dir($dir)) {
|
|
$fp = opendir($dir);
|
|
while (false !== ($filename = readdir($fp))) {
|
|
if ($filename!='.' && $filename!='..') {
|
|
$files[] = $filename;
|
|
}
|
|
}
|
|
closedir($fp);
|
|
|
|
rsort($files,SORT_NUMERIC);
|
|
|
|
// Only return the build id if it is not empty and not numeric.
|
|
if (!empty($files[1]) && is_numeric($files[1])) {
|
|
return $files[1];
|
|
}
|
|
}
|
|
|
|
// By default we return false, meaning that there is no latest complete update.
|
|
// Doing so means no updates for the nightly channel.
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Determine if the current update should be blocked because of its
|
|
* OS_VERSION.
|
|
*
|
|
* @param string updateType type of update (major|minor)
|
|
* @param string product name of the product
|
|
* @param string version product version
|
|
* @param string os OS_VERSION
|
|
* @param array unsupportedPlatforms - array of unsupported platforms
|
|
* @return boolean
|
|
*/
|
|
function isSupported($updateType, $product, $version, $os, $unsupportedPlatforms) {
|
|
|
|
// If it's not a major update, we're not blocking platforms.
|
|
if ($updateType == 'minor' || empty($unsupportedPlatforms[$product])) {
|
|
return true;
|
|
}
|
|
|
|
foreach ($unsupportedPlatforms[$product] as $versionPattern => $badPlatforms) {
|
|
if ($version == $versionPattern || preg_match('/^'. str_replace('\\*', '.*', preg_quote($versionPattern, '/')) .'$/', $version)) {
|
|
foreach ($badPlatforms as $badPlatform) {
|
|
if (strpos($os, $badPlatform) !== false) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
?>
|