522 lines
16 KiB
PHP
522 lines
16 KiB
PHP
<?php
|
|
|
|
/**
|
|
* Check if a given classname belongs to a subclass of AirtimeUpgrader
|
|
*
|
|
* @param $c string class name
|
|
*
|
|
* @return bool true if the $c is a subclass of AirtimeUpgrader
|
|
*/
|
|
function isUpgrade($c) {
|
|
return is_subclass_of($c, "AirtimeUpgrader");
|
|
}
|
|
|
|
/**
|
|
* Filter all declared classes to get all upgrade classes dynamically
|
|
*
|
|
* @return array all upgrade classes
|
|
*/
|
|
function getUpgrades() {
|
|
return array_filter(get_declared_classes(), "isUpgrade");
|
|
}
|
|
|
|
class UpgradeManager
|
|
{
|
|
|
|
/**
|
|
* Used to determine if the database schema needs an upgrade in order for this version of the Airtime codebase to work correctly.
|
|
* @return array A list of schema versions that this version of the codebase supports.
|
|
*/
|
|
public static function getSupportedSchemaVersions()
|
|
{
|
|
$config = Config::getConfig();
|
|
//What versions of the schema does the code support today:
|
|
return array($config['airtime_version']);
|
|
}
|
|
|
|
public static function checkIfUpgradeIsNeeded()
|
|
{
|
|
$schemaVersion = Application_Model_Preference::GetSchemaVersion();
|
|
$supportedSchemaVersions = self::getSupportedSchemaVersions();
|
|
return !in_array($schemaVersion, $supportedSchemaVersions);
|
|
}
|
|
|
|
/**
|
|
* Upgrade the Airtime schema version to match the highest supported version
|
|
*
|
|
* @return boolean whether or not an upgrade was performed
|
|
*/
|
|
public static function doUpgrade()
|
|
{
|
|
// Get all upgrades dynamically (in declaration order!) so we don't have to add them explicitly each time
|
|
// TODO: explicitly sort classnames by ascending version suffix for safety
|
|
$upgraders = getUpgrades();
|
|
$dir = (dirname(__DIR__) . "/controllers");
|
|
$upgradePerformed = false;
|
|
|
|
foreach ($upgraders as $upgrader) {
|
|
$upgradePerformed = self::_runUpgrade(new $upgrader($dir)) ? true : $upgradePerformed;
|
|
}
|
|
|
|
return $upgradePerformed;
|
|
}
|
|
|
|
/**
|
|
* Downgrade the Airtime schema version to match the given version
|
|
*
|
|
* @param string $toVersion the version we want to downgrade to
|
|
*
|
|
* @return boolean whether or not an upgrade was performed
|
|
*/
|
|
public static function doDowngrade($toVersion)
|
|
{
|
|
$downgraders = array_reverse(getUpgrades()); // Reverse the array because we're downgrading
|
|
$dir = (dirname(__DIR__) . "/controllers");
|
|
$downgradePerformed = false;
|
|
|
|
foreach ($downgraders as $downgrader) {
|
|
/** @var AirtimeUpgrader $downgrader */
|
|
$downgrader = new $downgrader($dir);
|
|
if ($downgrader->getNewVersion() == $toVersion) {
|
|
break; // We've reached the version we wanted to downgrade to, so break
|
|
}
|
|
$downgradePerformed = self::_runDowngrade($downgrader) ? true : $downgradePerformed;
|
|
}
|
|
|
|
return $downgradePerformed;
|
|
}
|
|
|
|
/**
|
|
* Run the given upgrade
|
|
*
|
|
* @param $upgrader AirtimeUpgrader the upgrader class to be executed
|
|
*
|
|
* @return bool true if the upgrade was successful, otherwise false
|
|
*/
|
|
private static function _runUpgrade(AirtimeUpgrader $upgrader) {
|
|
return $upgrader->checkIfUpgradeSupported() && $upgrader->upgrade();
|
|
}
|
|
|
|
/**
|
|
* Run the given downgrade
|
|
*
|
|
* @param $downgrader AirtimeUpgrader the upgrader class to be executed
|
|
* @param $supportedVersions array array of supported versions
|
|
*
|
|
* @return bool true if the downgrade was successful, otherwise false
|
|
*/
|
|
private static function _runDowngrade(AirtimeUpgrader $downgrader) {
|
|
return $downgrader->checkIfDowngradeSupported() && $downgrader->downgrade();
|
|
}
|
|
|
|
}
|
|
|
|
abstract class AirtimeUpgrader
|
|
{
|
|
protected $_dir;
|
|
|
|
protected $username, $password, $host, $database;
|
|
|
|
/**
|
|
* @param $dir string directory housing upgrade files
|
|
*/
|
|
public function __construct($dir) {
|
|
$this->_dir = $dir;
|
|
}
|
|
|
|
/** Schema versions that this upgrader class can upgrade from (an array of version strings). */
|
|
abstract protected function getSupportedSchemaVersions();
|
|
|
|
/** The schema version that this upgrader class will upgrade to. (returns a version string) */
|
|
abstract public function getNewVersion();
|
|
|
|
public static function getCurrentSchemaVersion()
|
|
{
|
|
return Application_Model_Preference::GetSchemaVersion();
|
|
}
|
|
|
|
/**
|
|
* This function checks to see if this class can perform an upgrade of your version of Airtime
|
|
* @return boolean True if we can upgrade your version of Airtime.
|
|
*/
|
|
public function checkIfUpgradeSupported()
|
|
{
|
|
return in_array(static::getCurrentSchemaVersion(), $this->getSupportedSchemaVersions());
|
|
}
|
|
|
|
/**
|
|
* This function checks to see if this class can perform a downgrade of your version of Airtime
|
|
*
|
|
* @return boolean True if we can downgrade your version of Airtime.
|
|
*/
|
|
public function checkIfDowngradeSupported()
|
|
{
|
|
return static::getCurrentSchemaVersion() == $this->getNewVersion();
|
|
}
|
|
|
|
protected function toggleMaintenanceScreen($toggle)
|
|
{
|
|
if ($toggle)
|
|
{
|
|
//Disable Airtime UI
|
|
//create a temporary maintenance notification file
|
|
//when this file is on the server, zend framework redirects all
|
|
//requests to the maintenance page and sets a 503 response code
|
|
/* DISABLED because this does not work correctly
|
|
$this->maintenanceFile = isset($_SERVER['AIRTIME_BASE']) ? $_SERVER['AIRTIME_BASE']."maintenance.txt" : "/tmp/maintenance.txt";
|
|
$file = fopen($this->maintenanceFile, 'w');
|
|
fclose($file);
|
|
*/
|
|
} else {
|
|
//delete maintenance.txt to give users access back to Airtime
|
|
/* DISABLED because this does not work correctly
|
|
if ($this->maintenanceFile) {
|
|
unlink($this->maintenanceFile);
|
|
}*/
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implement this for each new version of Airtime
|
|
* This function abstracts out the core upgrade functionality,
|
|
* allowing child classes to overwrite _runUpgrade to reduce duplication
|
|
*/
|
|
public function upgrade() {
|
|
try {
|
|
// $this->toggleMaintenanceScreen(true);
|
|
|
|
$this->_getDbValues();
|
|
$this->_runUpgrade();
|
|
|
|
Application_Model_Preference::SetSchemaVersion($this->getNewVersion());
|
|
|
|
// $this->toggleMaintenanceScreen(false);
|
|
} catch(Exception $e) {
|
|
// $this->toggleMaintenanceScreen(false);
|
|
Logging::error('Error in upgrade: '. $e->getMessage());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Implement this for each new version of Airtime
|
|
* This function abstracts out the core downgrade functionality,
|
|
* allowing child classes to overwrite _runDowngrade to reduce duplication
|
|
*/
|
|
public function downgrade() {
|
|
|
|
try {
|
|
$this->_getDbValues();
|
|
$this->_runDowngrade();
|
|
|
|
$highestSupportedVersion = null;
|
|
foreach ($this->getSupportedSchemaVersions() as $v) {
|
|
// version_compare returns 1 (true) if the second parameter is lower
|
|
if (!$highestSupportedVersion || version_compare($v, $highestSupportedVersion)) {
|
|
$highestSupportedVersion = $v;
|
|
}
|
|
}
|
|
|
|
// Set the schema version to the highest supported version so we don't skip versions when downgrading
|
|
Application_Model_Preference::SetSchemaVersion($highestSupportedVersion);
|
|
|
|
} catch(Exception $e) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
protected function _getDbValues() {
|
|
$config = Config::getConfig();
|
|
|
|
$this->username = $config['dsn']['username'];
|
|
$this->password = $config['dsn']['password'];
|
|
$this->host = $config['dsn']['hostspec'];
|
|
$this->database = $config['dsn']['database'];
|
|
}
|
|
|
|
protected function _runUpgrade() {
|
|
passthru("export PGPASSWORD=".$this->password." && psql -h ".$this->host." -U ".$this->username." -q -f ".$this->_dir."/upgrade_sql/airtime_"
|
|
.$this->getNewVersion()."/upgrade.sql ".$this->database." 2>&1 | grep -v -E \"will create implicit sequence|will create implicit index\"");
|
|
}
|
|
|
|
protected function _runDowngrade() {
|
|
passthru("export PGPASSWORD=".$this->password." && psql -h ".$this->host." -U ".$this->username." -q -f ".$this->_dir."/downgrade_sql/airtime_"
|
|
.$this->getNewVersion()."/downgrade.sql ".$this->database." 2>&1 | grep -v -E \"will create implicit sequence|will create implicit index\"");
|
|
}
|
|
|
|
}
|
|
|
|
class AirtimeUpgrader253 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions()
|
|
{
|
|
return array('2.5.1', '2.5.2');
|
|
|
|
}
|
|
public function getNewVersion()
|
|
{
|
|
return '2.5.3';
|
|
}
|
|
|
|
protected function _runUpgrade()
|
|
{
|
|
//Update disk_usage value in cc_pref
|
|
$storDir = isset($_SERVER['AIRTIME_BASE']) ? $_SERVER['AIRTIME_BASE']."srv/airtime/stor" : "/srv/airtime/stor";
|
|
$diskUsage = shell_exec("du -sb $storDir | awk '{print $1}'");
|
|
|
|
Application_Model_Preference::setDiskUsage($diskUsage);
|
|
|
|
parent::_runUpgrade();
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader254 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions()
|
|
{
|
|
return array('2.5.3');
|
|
}
|
|
public function getNewVersion()
|
|
{
|
|
return '2.5.4';
|
|
}
|
|
|
|
protected function _runUpgrade()
|
|
{
|
|
//First, ensure there are no superadmins already.
|
|
$numberOfSuperAdmins = CcSubjsQuery::create()
|
|
->filterByDbType(UTYPE_SUPERADMIN)
|
|
->filterByDbLogin("sourcefabric_admin", Criteria::NOT_EQUAL) //Ignore sourcefabric_admin users
|
|
->count();
|
|
|
|
//Only create a super admin if there isn't one already.
|
|
if ($numberOfSuperAdmins == 0)
|
|
{
|
|
//Find the "admin" user and promote them to superadmin.
|
|
$adminUser = CcSubjsQuery::create()
|
|
->filterByDbLogin('admin')
|
|
->findOne();
|
|
if (!$adminUser)
|
|
{
|
|
// Otherwise get the user with the lowest ID that is of type administrator:
|
|
$adminUser = CcSubjsQuery::create()
|
|
->filterByDbType(UTYPE_ADMIN)
|
|
->orderByDbId(Criteria::ASC)
|
|
->findOne();
|
|
|
|
if (!$adminUser) {
|
|
throw new Exception("Failed to find any users of type 'admin' ('A').");
|
|
}
|
|
}
|
|
|
|
$adminUser = new Application_Model_User($adminUser->getDbId());
|
|
$adminUser->setType(UTYPE_SUPERADMIN);
|
|
$adminUser->save();
|
|
Logging::info($_SERVER['HTTP_HOST'] . ': ' . $this->getNewVersion() . " Upgrade: Promoted user " . $adminUser->getLogin() . " to be a Super Admin.");
|
|
|
|
//Also try to promote the sourcefabric_admin user
|
|
$sofabAdminUser = CcSubjsQuery::create()
|
|
->filterByDbLogin('sourcefabric_admin')
|
|
->findOne();
|
|
if ($sofabAdminUser) {
|
|
$sofabAdminUser = new Application_Model_User($sofabAdminUser->getDbId());
|
|
$sofabAdminUser->setType(UTYPE_SUPERADMIN);
|
|
$sofabAdminUser->save();
|
|
Logging::info($_SERVER['HTTP_HOST'] . ': ' . $this->getNewVersion() . " Upgrade: Promoted user " . $sofabAdminUser->getLogin() . " to be a Super Admin.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader255 extends AirtimeUpgrader {
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.4'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.5';
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader259 extends AirtimeUpgrader {
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.5'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.9';
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader2510 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.9'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.10';
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader2511 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.10'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.11';
|
|
}
|
|
|
|
protected function _runUpgrade() {
|
|
$queryResult = CcFilesQuery::create()
|
|
->select(array('disk_usage'))
|
|
->withColumn('SUM(CcFiles.filesize)', 'disk_usage')
|
|
->find();
|
|
$disk_usage = $queryResult[0];
|
|
Application_Model_Preference::setDiskUsage($disk_usage);
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader2512 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.10',
|
|
'2.5.11'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.12';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class AirtimeUpgrader2513 - Celery and SoundCloud upgrade
|
|
*
|
|
* Adds third_party_track_references and celery_tasks tables for third party service
|
|
* authentication and task architecture.
|
|
*
|
|
* <br/><b>third_party_track_references</b> schema:
|
|
*
|
|
* id -> int PK
|
|
* service -> string internal service name
|
|
* foreign_id -> int external unique service id
|
|
* file_id -> int internal FK->cc_files track id
|
|
* upload_time -> timestamp internal upload timestamp
|
|
* status -> string external service status
|
|
*
|
|
* <br/><b>celery_tasks</b> schema:
|
|
*
|
|
* id -> int PK
|
|
* task_id -> string external unique amqp results identifier
|
|
* track_reference -> int internal FK->third_party_track_references id
|
|
* name -> string external Celery task name
|
|
* dispatch_time -> timestamp internal message dispatch time
|
|
* status -> string external Celery task status
|
|
*
|
|
*/
|
|
class AirtimeUpgrader2513 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.12'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.13';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class AirtimeUpgrader2514
|
|
*
|
|
* SAAS-923 - Add a partial constraint to cc_pref so that keystrings must be unique
|
|
*/
|
|
class AirtimeUpgrader2514 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.13'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.14';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Class AirtimeUpgrader2515
|
|
*
|
|
* SAAS-1071 - Remove not null constraint from file_id fk in third_party_track_references
|
|
* so that we can create track references for downloads (which won't have a file
|
|
* ID until the task is run and the file is POSTed back to Airtime)
|
|
*/
|
|
class AirtimeUpgrader2515 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array (
|
|
'2.5.14'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.15';
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader2516 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array(
|
|
'2.5.15'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '2.5.16';
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader300alpha extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array(
|
|
'2.5.16'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '3.0.0-alpha';
|
|
}
|
|
}
|
|
|
|
class AirtimeUpgrader300alpha1 extends AirtimeUpgrader
|
|
{
|
|
protected function getSupportedSchemaVersions() {
|
|
return array(
|
|
'3.0.0-alpha'
|
|
);
|
|
}
|
|
|
|
public function getNewVersion() {
|
|
return '3.0.0-alpha.1';
|
|
}
|
|
}
|