YAWK\update Class Reference

The update class - handles yawk's system update functions. More...

Public Member Functions
	__construct ()
	update constructor. Check if allow_url_fopen is enabled More...
	fetchFiles (object $db, string $currentVersion, string $updateVersion, array $lang)
	read system/update/updateFiles.ini and fetch files from remote (GitHub) server More...
	generateLocalFilebase (object $db, array $lang)
	Read all files of current YaWK installation and write each file with path + MD5 hash to ini file to compare it later with the possible update files. This is used to verify the integrity of the files. More...
	getUpdateSettings ()
	get update settings from local update folder (system/update/update.ini) and return array|false More...
	isServerReachable (string $url)
	check if update server is reachable More...
	readUpdateFilebaseFromServer ()
	read filebase.ini from update server (https://update.yawk.io/filebase.ini) and return array|false More...
	readUpdateIniFromServer ()
	read update.ini from update server (https://update.yawk.io/update.ini) and return array|false More...
	recordMigration ($db, $successfulMigrations)
	record migration in database More...
	runMigrations (object $db, array $lang)
	Run the migration SQL files. More...

Public Attributes
string	$base_dir = ''
string	$currentVersion = ''
string	$githubServer = 'https://raw.githubusercontent.com/YaWK/yawk.io/master/'
string	$localUpdateSystemPath = 'system/update/'
bool	$migrationSuccessful = false
string	$updateFile = 'update.ini'
string	$updateFilebase = 'filebase.ini'
array	$updateFiles = array()
string	$updateFilesFile = 'updateFiles.ini'
string	$updateServer = 'https://update.yawk.io/'
array	$updateSettings = array()
string	$updateVersion = ''

Detailed Description

The update class - handles yawk's system update functions.

YaWK System Updater Class

The YaWK System Updater Class provides methods to facilitate the updating process of the system. It includes features such as checking for new versions, verifying and comparing files to ensure a stable and reliable update. This class aims to simplify the update process and minimize the risk of any errors or issues during the update.

Author

Daniel Retzl danie.nosp@m.lret.nosp@m.zl@gm.nosp@m.ail..nosp@m.com

Copyright

2009-2023 Daniel Retzl @license https://opensource.org/licenses/MIT

Version

1.0.0

Definition at line 20 of file update.php.

Constructor & Destructor Documentation

__construct()

YAWK\update::__construct

(

)

update constructor. Check if allow_url_fopen is enabled

will be called by xhr request from admin/js/update-generateLocalFilebase.php

Definition at line 78 of file update.php.

        {
            // Get the value of the allow_url_fopen setting
            $allowUrlFopen = ini_get('allow_url_fopen');
            // Check if allow_url_fopen is enabled
            if (!$allowUrlFopen)
            {   // allow_url_fopen is disabled, exit with error
                // todo: syslog entry
                echo "allow_url_fopen is disabled, but required to use the update methods. Please enable allow_url_fopen in your php.ini file or ask your admin / hoster for assistance.";
            }
 
            // check if update server is reachable
            if ($this->isServerReachable($this->updateServer.$this->updateFile) === false)
            {   // todo: syslog entry
                echo "Update server $this->updateServer not reachable. Update not possible at the moment - please try again later.<br>";
            }
 

References YAWK\update\isServerReachable().

Member Function Documentation

fetchFiles()

bool $migrationSuccessful true false indicates if migration was successful call YAWK\update::fetchFiles	(	object	$db,
		string	$currentVersion,
		string	$updateVersion,
		array	$lang
	)

read system/update/updateFiles.ini and fetch files from remote (GitHub) server

will be called by xhr request from admin/js/update-fetchFiles.php

Parameters

$db	object database connection
$updateVersion	string update version
$lang	array language array

Definition at line 365 of file update.php.

                                                                                                          : void
        {
            // init updateSucceed flag, will be set to true if update was successful
            $updateSucceed = false;
 
            // set update version
            $this->currentVersion = $currentVersion;
            $this->updateVersion = $updateVersion;
 
            // override $this->updateServer with GitHub url
            $this->updateServer = $this->githubServer;
 
            // file fetched successfully
            $basedir = __DIR__;
            // remove last 15 chars from $basedir (system/update/)
            $basedir = substr($basedir, 0, -14);
            // $basedir = substr($basedir, 0, -8);
 
            $response = ''; // init output string, result of the update process, will be returned to the frontend
            // check if updateFiles.ini exists
            if (file_exists($basedir.$this->localUpdateSystemPath . $this->updateFilesFile))
            {
                // updateFiles.ini exists
                // parse updateFiles.ini into array
                $this->updateFiles = parse_ini_file($basedir.$this->localUpdateSystemPath . $this->updateFilesFile);
                if (count($this->updateFiles) < 1)
                {   // unable to read updateFiles.ini from local update folder
                    $response .= "<span class=\"text-warning\"><p><i class=\"fa fa-exclamation-triangle text-warning\"></i>".$lang['UPDATE_FAST_FORWARD_INFO']."
                    <a href=\"#fastForwardUpdate\" id=\"fastForwardUpdateBtn\" class=\"btn btn-warning\">".$lang['UPDATE_FAST_FORWARD_BTN']." &nbsp;<i class=\"fa fa-fast-forward\"></i></a></span><br>";
                }
                else
                {   // count elements of updateFiles array
                    $totalUpdateFiles = count($this->updateFiles);
                    $failedFiles = 0;
                    $successFiles = 0;
                    $fetchFailed = 0;
                    $fetchSucceed = 0;
                    $processedFiles = 0;
 
                    // updateFiles.ini read successfully
                    // fetch files from remote server
                    foreach ($this->updateFiles as $key => $value)
                    {
                        $processedFiles++;
                        // debug line can be removed $response .= "VALUE: $value <br>";
 
                        // build file url
                        $fileUrl = $this->updateServer . $value;
                        // fetch next file to update
                        $file = file_get_contents($fileUrl);
                        if ($file === false)
                        {
                            // unable to fetch file
                            $response .= $lang['UPDATE_FETCH_FILE_FAILED'].$fileUrl."<br>";
                            $fetchFailed++;
                        }
                        else
                        {   // count successful fetches
                            $fetchSucceed++;
 
                            // Write file to local system
                            if (!file_put_contents($basedir.$value, $file))
                            {   // unable to write file to local system
                                $failedFiles++; // count failed files
                                $response .= "<b> class=\"text-danger\">".$lang['UPDATE_UNABLE_TO_WRITE_FILE']."</b> " .$basedir.$value . "<br>";
                            }
                            else
                            {   // file written successfully
                                $successFiles++; // count successful written files
                                $response .= "<b class=\"text-success animated fadeIn slow\">".$lang['UPDATE_FILE_WRITTEN']."</b> " . $basedir.$value . "<br>";
                            }
                        }
                    }
                    // check if all files were fetched successfully
                    if ($fetchFailed > 0)
                    {   // at least one file could not be fetched
                        $response .= "<b class=\"text-danger\">".$lang['UNABLE_TO_FETCH_FILES_FROM_REMOTE_SERVER']." $fetchFailed</b><br>";
                    }
                    else if ($fetchSucceed === $totalUpdateFiles)
                    {   // all files fetched successfully
                        $response .= "<b class=\"text-success\">$fetchSucceed ".$lang['UPDATE_SUCCESSFULLY_FETCHED']."</b><br>";
                    }
                    // check if all files were written successfully
                    if ($failedFiles > 0)
                    {   // at least one file could not be written
                        $response .= "<b class=\"text-danger\">$failedFiles ".$lang['UPDATE_FAILED_FILES']."</b><br>";
                    }
                    else if ($successFiles === $totalUpdateFiles)
                    {   // all files written successfully
                        $response .= "<b class=\"text-success\">".$lang['ALL']." ".$successFiles." ".$lang['UPDATE_ALL_FILES_SUCCESS']."</b><br>";
                    }
                    // check if all files were processed
                    if ($processedFiles === $totalUpdateFiles)
                    {   // all files processed
                        $response .= "<b class=\"text-success\">".$lang['ALL']." ".$processedFiles." ".$lang['UPDATE_FILES_PROCESSED']."</b><br>";
                    }
                    else
                    {   // not all files processed
                        $response .= "<b class=\"text-danger\">".$lang['UPDATE_NOT_ALL_FILES_PROCESSED']." ".$processedFiles." ".$lang['OF']." ".$totalUpdateFiles." ".$lang['UPDATE_FILES_PROCESSED'].".</b><br>";
                    }
                    // check if update was successful
                    if ($successFiles === $totalUpdateFiles)
                    {   // update was successful
                        $updateSucceed = true;
                    }
                    else
                    {   // update failed
                        $response .= "<h3 class=\"text-danger\">".$lang['UPDATE_FAILED']."</h3>";
                    }
                }
            }
            else
            {   // updateFiles.ini does not exist
                $response .= "<span class=\"text-danger\"><b>".$lang['ERROR'].":</b> ".$lang['UPDATE_FILES_INI_MISSING']." " .$basedir.$this->localUpdateSystemPath . $this->updateFilesFile . "</span>";
            }
 
            // check if update was successful
            if ($updateSucceed === true)
            {   // set new version in database
                settings::setSetting($db, "yawkversion", $updateVersion, $lang);
 
                // get version from database to check if it was updated correctly
                $version = settings::getSetting($db, "yawkversion");
                if ($version == $updateVersion && $updateSucceed === true)
                {   // system version was updated successfully
                    $response .= "<h3 class=\"text-success\">".$lang['UPDATE_TO']." $updateVersion ".$lang['COMPLETED_SUCCESSFULLY']."</b><h3>";
                    sys::setSyslog($db, 54, 0, "<b>UPDATE COMPLETE</b> Migration and Files updated to $updateVersion.", 0, 0, 0, 0);
                }
                else
                {   // failed to update version in database
                    $response .= "<h3 class=\"text-danger\">".$lang['UPDATE_FAILED_TO_WRITE_VERSION_NUMBER']." ($updateVersion)</h3>";
                }
            }
            else
            {   // update failed
                $response .= "<h3 class=\"text-danger\">".$lang['UPDATE_FAILED_FROM']." $this->currentVersion ".$lang['TO']." $updateVersion.</h3>";
            }
            // return xhr response
            echo $response;
 
            // close database connection
            $db->close();

References YAWK\update\$currentVersion, $db, YAWK\update\$githubServer, $lang, $response, YAWK\update\$updateVersion, $value, YAWK\settings\getSetting(), and YAWK\settings\setSetting().

generateLocalFilebase()

YAWK\update::generateLocalFilebase	(	object	$db,
		array	$lang
	)

Read all files of current YaWK installation and write each file with path + MD5 hash to ini file to compare it later with the possible update files. This is used to verify the integrity of the files.

Parameters

$db	object global db object
$lang	array global language array

Returns

void

Definition at line 546 of file update.php.

                                                                      : void
        {
            $this->base_dir = dirname(__FILE__);
            $this->base_dir = substr($this->base_dir, 0, -15); // remove last 15 chars
            // echo "<p>Base directory: $this->base_dir</p>";
 
            // set path and filename of the ini file
            $updatePath = '/system/update/';
            $updateFolder = $this->base_dir.$updatePath;
 
            if (!is_dir($updateFolder)){
                if (!mkdir($updateFolder, 0777, true) && !is_dir($updateFolder)) {
                    throw new \RuntimeException(sprintf('Unable to create "%s" - please check folder permissions or create folder by hand', $updateFolder));
                }
            }
            $iniFileName = 'filebase.current.ini';
            $input_folder = $this->base_dir;
            $output_file = $updateFolder.$iniFileName;
            $writeIniFile = true;
 
            // delete old file if exists
            if (is_file($output_file)){
                unlink($output_file);
            }
 
            // Open the output file for writing
            $output_handle = fopen($output_file, 'w');
            if (!$output_handle) {
                // handle the error (e.g. show an error message or log the error)
                die("Failed to open file for writing: $output_file");
            }
 
            // Get the full path of the input folder
            $input_folder = realpath($input_folder);
 
            // Loop through all files in the input folder and its subfolders
            echo "<p>".$lang['UPDATE_BUILDING_LOCAL_FILEBASE']." <i><small>$input_folder</small></i></p>";
            $root_files = array();
            $subfolder_files = array();
            foreach(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($input_folder)) as $file_path)
            {
                // Skip some excluded directories and hidden files
                if ($file_path->isDir()
                    || $file_path->getFilename()[0] == '.'
                    || strpos($file_path, '/.git/') !== false
                    || strpos($file_path, '/.github/') !== false
                    || strpos($file_path, '/.idea/') !== false
                    || strpos($file_path, '/content/') !== false
                    || strpos($file_path, '/media/') !== false)
                {   // skip this file/folder
                    continue;
                }
 
                // Calculate the MD5 hash of the file
                $md5_hash = md5_file($file_path);
 
                // Get the full path of the file
                $full_path = realpath($file_path);
 
                // Remove the input folder path from the full path to get the relative path
                $relative_path = substr($full_path, strlen($input_folder) + 1);
 
                // Split the relative path into an array of path components
                $path_components = explode('/', $relative_path);
 
                // Check if the path has only one component (i.e. it's a file in the root folder)
                if (count($path_components) == 1) {
                    $root_files[$relative_path] = $md5_hash;
                } else {
                    $subfolder_files[$relative_path] = $md5_hash;
                }
            }
 
            // Sort the arrays alphabetically by key (the relative path)
            ksort($root_files);
            ksort($subfolder_files);
 
            // Merge the two arrays so that the root files are listed first
            $hashes = array_merge($root_files, $subfolder_files);
 
            // init counters
            $totalFiles = count($hashes);   // count total files
            $totalFilesVerified = 0;        // number of verified files
            $totalFilesFailed = 0;          // number of failed files
 
            // Write the sorted array to the output file in the .ini format
            foreach ($hashes as $relative_path => $md5_hash)
            {   // write each file with its md5 hash to ini file
                // echo "Writing $relative_path=$md5_hash to $output_file\n";
                // Write the relative path and MD5 hash to the output file
                if (file_put_contents($output_file, "$relative_path=$md5_hash\n", FILE_APPEND))
                {   // line written successfully
                    // echo '<p class="text-success">Verified '.$relative_path.' <small>'.$md5_hash.'</small></p>';
                    $totalFilesVerified++;
                }
                else
                {   // line failed
                    // echo '<p class="text-danger">Failed '.$relative_path.' <small>'.$md5_hash.'</small></p>';
                    $totalFilesFailed++;
                }
            }
 
            // Close the output file
            echo '<p class="animated fadeIn slow delay-1s">'.$lang['UPDATE_INDEXING'].' <b>'.$totalFiles.'</b> '.$lang['FILES'].'. '.$lang['VERIFIED'].' <b>'.$totalFilesVerified.'</b> '.$lang['FILES'].'. '.$lang['FAILED'].' <b>'.$totalFilesFailed.'</b> '.$lang['FILES'].'.</p>';
 
            if (!is_file($output_file))
            {   // unable to write ini file
                $iniFileWritten = "<h4 class=\"text-danger\">".$iniFileName." ".$lang['COULD_NOT_BE_WRITTEN']."</h4>";
            }
            else
            {   // ini file written successfully
                $iniFileWritten = "<p class=\"animated fadeIn slow delay-5s\">".$lang['UPDATE_HASH_VALUES_WRITTEN_TO']." <b><a href=\"$updatePath$iniFileName\" target=\"_blank\">$updatePath$iniFileName</a></b></p>";
            }
 
            // check if all files were verified
            if ($totalFiles == $totalFilesVerified)
            {   // set success icon, message and colors
                $icon = '<i class="fa fa-check-circle-o fa-2x text-success"></i>';
                $done = "<h4 class=\"text-success animated fadeIn slow delay-4s\">".$totalFiles."&nbsp;".$lang['UPDATE_VERIFICATION_SUCCESS']."</h4>";
                $iconFalse = '';
                $successColor = ' text-success';
                $failedColor = '';
            }
            else
            {   // set failure icon, message and colors
                $iconFalse = '<i class="fa fa-exclamation-triangle fa-2x text-danger"></i>';
                $done = "<h4 class=\"text-danger\"><b>".$totalFilesFailed." ".$lang['UPDATE_VERIFICATION_FAILED']."</b></h4>";
                $failedColor = ' text-danger';
                $successColor = '';
            }
 
            echo "
            <p class=\"animated fadeIn slow delay-2s$successColor\">$icon &nbsp;".$lang['UPDATE_GENERATED_HASH_VALUES']." <b>$totalFilesVerified / $totalFiles</b></p>";
            echo"<h4 class=\"animated fadeIn slow delay-4s\">$done</h4>
            $iniFileWritten";
 
            // check if any files failed
            if ($totalFilesFailed > 0)
            {   // show amount of failed files
                echo"<p class=\"animated fadeIn slow delay-3s$failedColor\">$iconFalse &nbsp;".$lang['UPDATE_FAILED_TO_VERIFY']." <b>$totalFilesFailed</b></p>";
            }
 
            // Close the output file
            if (!fclose($output_handle))
            {   // unable to close ini file
                echo '<p class="animated fadeIn slow delay-5s">failed to close: '.$updateFolder.$iniFileName.'</p>';
            }

References YAWK\update\$base_dir, $lang, and die.

getUpdateSettings()

YAWK\update::getUpdateSettings

(

)

get update settings from local update folder (system/update/update.ini) and return array|false

will be called by xhr request from admin/js/update-generateLocalFilebase.php

Returns

array|false

Definition at line 131 of file update.php.

                                           : array|false
        {
            // read update.ini from local update folder
            $this->updateSettings = parse_ini_file($this->localUpdateSystemPath.$this->updateFile);
            if (count($this->updateSettings) < 1)
            {   // unable to read update.ini from local update folder
                echo "Error: Unable to read update.ini from local update folder. Check if this file exists: ".$this->localUpdateSystemPath.$this->updateFile;
            }
            else {
                // update.ini read successfully
                // set update version
                $this->updateVersion = $this->updateSettings['version'];
 
                // return update settings array
                return $this->updateSettings;
            }
            // return false if something went wrong
            return false;

References YAWK\update\$updateSettings.

isServerReachable()

YAWK\update::isServerReachable

(

string

$url

)

check if update server is reachable

returns true if server is reachable, false if not

Parameters

$url	string url to check

Returns

bool true|false

Definition at line 103 of file update.php.

                                                      : bool
        {
            $ch = curl_init($url);
            curl_setopt($ch, CURLOPT_NOBODY, true);
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30);
            curl_setopt($ch, CURLOPT_TIMEOUT, 30);
            curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
            curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);
            curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (compatible; UpdateClient/1.0)');
 
            $response = curl_exec($ch);
            $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 
            curl_close($ch);
 
            if ($httpCode >= 200 && $httpCode < 300) {
                return true;
            } else {
                return false;
            }

References $response, and $url.

Referenced by YAWK\update\__construct().

readUpdateFilebaseFromServer()

YAWK\update::readUpdateFilebaseFromServer

(

)

read filebase.ini from update server (https://update.yawk.io/filebase.ini) and return array|false

will be called by xhr request from admin/js/update-readUpdateFilebase.php The filebase.ini contains a list of all files with their md5 hash. This function returns the filebase as array. (to compare it later with the local filebase)

Returns

array|false

Definition at line 702 of file update.php.

                                                      : array|false
        {
            // URL of the remote INI file
            $url = $this->updateServer.'filebase.ini';
 
            // Get the content of the remote INI file
            $iniContent = file_get_contents($url);
 
            // Check if the content was retrieved successfully
            if ($iniContent !== false)
            {   // Parse the INI content into an associative array
                $filebase = parse_ini_string($iniContent);
 
                // Print the contents of the array
                foreach ($filebase as $key => $value)
                {   // set update array
                    $updateFilebase[$key] = $value;
                }
            }
            else
            {   // unable to read filebase from remote server
                echo "Error: Unable to read filebase from remote server. Check if this file exists: $url";
            }
            // return array or false
            return $updateFilebase ?? false;

References YAWK\update\$updateFilebase, $url, and $value.

readUpdateIniFromServer()

YAWK\update::readUpdateIniFromServer

(

)

read update.ini from update server (https://update.yawk.io/update.ini) and return array|false

Returns

false|array

Definition at line 513 of file update.php.

                                                 : false|array
        {
            // URL of the remote INI file
            $url = $this->updateServer.$this->updateFile;
 
            // Get the content of the remote INI file
            $iniContent = file_get_contents($url);
 
            // Check if the content was retrieved successfully
            if ($iniContent !== false)
            {   // Parse the INI content into an associative array
                $config = parse_ini_string($iniContent);
 
                // Print the contents of the array
                foreach ($config as $key => $value)
                {   // set update array
                    $updateConfig['UPDATE'][$key] = $value;
                }
            }
            else
            {   // unable to read update.ini from remote server
                echo "Error: Unable to read the remote INI file.";
            }
            return $updateConfig ?? false;

References $url, and $value.

recordMigration()

YAWK\update::recordMigration	(		$db,
			$successfulMigrations
	)

record migration in database

will be called from runMigrations() if migration was successful

Parameters

$db
$successfulMigrations

Returns

void

Definition at line 159 of file update.php.

                                                                   : void
        {
            $output = '';
            // check if migrations array is set and got at least 1 entry
            if (is_array($successfulMigrations) && (count($successfulMigrations) > 0))
            {   // loop through all migrations
                foreach ($successfulMigrations as $migrationVersion) {
                    // record migration
                    if (!$db->query("INSERT INTO {migrations} (`version`, `executed_at`) VALUES ('$migrationVersion', NOW())"))
                    {   // error recording migration
                        sys::setSyslog($db, 53, 0, "Error recording migration for version $migrationVersion: " . $db->error . " ", 0, 0, 0, 0);
                        $output .= "Error recording migration for version $migrationVersion: " . $db->error . "<br>";
                    }
                    else
                    {   // migration recorded successfully
                        sys::setSyslog($db, 53, 0, "Migration record for version $migrationVersion successful.", 0, 0, 0, 0);
                        $output .= "Migration for version $migrationVersion executed successfully.<br>";
                    }
                }
            }
            else
            {   // no migrations to record
                sys::setSyslog($db, 54, 0, "No Migrations to record. Is there a logical error?", 0, 0, 0, 0);
                $output .= "No migrations to record.<br>";
            }
            echo $output;

References $db.

Referenced by YAWK\update\runMigrations().

runMigrations()

YAWK\update::runMigrations	(	object	$db,
		array	$lang
	)

Run the migration SQL files.

If update.ini contains migration files between the current version and the update version, this function will be called

Parameters

$db	object the database object
$lang	array the language array

Returns

void true|false if migrations were successful or not

Parameters

$db

db

Definition at line 194 of file update.php.

                                                       : void
        {
            require_once 'sys.php';
            /** @param $db db */
            ini_set('display_errors', 1);
            error_reporting(E_ALL);
 
            // init variables
            $output = '';
            $totalMigration = 0;
            $successfulMigrations = 0;
            $failedMigrations = 0;
            $successfulMigrationVersions = array();
 
            // log start of migration
            sys::setSyslog($db, 56, 0, "runMigrations initialized. Updating from $this->currentVersion to $this->updateVersion", 0, 0, 0, 0);
 
            // run migrations
            try
            {   // Start transaction, so we can roll back if something goes wrong
                $db->beginTransaction();
 
                // Determine which migrations need to be executed
                $migrationUrlBase = $this->updateServer . 'migration-';
                $currentVersionParts = explode('.', $this->currentVersion);
                $updateVersionParts = explode('.', $this->updateVersion);
                // Start at the next minor version after the current version
                $startIndex = (int)$currentVersionParts[2] + 1;
                // End at the minor version of the update version
                $endIndex = (int)$updateVersionParts[2];
                $output .= '<br><br><div class="panel-group animated fadeIn slow delay-2s" id="accordion" role="tablist" aria-multiselectable="true">
  <div class="panel panel-default">
    <div class="panel-heading" role="tab" id="headingMigration">
      <h4 class="panel-title">
        <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseMigration" aria-expanded="true" aria-controls="collapseMigration">
          '.$lang['UPDATE_MIGRATIONS'].'<br>
          <small>(database updates)</small>
        </a>
      </h4>
    </div>
    <div id="collapseMigration" class="panel-collapse collapse" role="tabpanel" aria-labelledby="headingMigration">
      <div class="panel-body">';
 
                // Loop through the migration files
                for ($i = $startIndex; $i <= $endIndex; $i++)
                {
                    $totalMigration++;
                    // build migration version
                    $migrationVersion = $currentVersionParts[0] . '.' . $currentVersionParts[1] . '.' . $i;
                    // build migration filename
                    $migrationUrl = $migrationUrlBase . $migrationVersion . '.sql';
 
                    // check if migration was already executed
                    $migrationRecord = $db->query("SELECT version FROM {migrations} WHERE version = '$migrationVersion'")->fetch_assoc();
 
                    // check if migration was already executed
                    if ($migrationRecord !== null)
                    {   // migration was already executed
                        $output .= "$migrationVersion : ".$lang['UPDATE_MIGRATION_ALREADY_EXEC']."<br>";
                        sys::setSyslog($db, 53, 1, "Migration for build $migrationVersion was already executed.", 0, 0, 0, 0);
                        $failedMigrations++;
                        continue;
                    }
                    else {
                        // migration was not executed yet
                        // $output .= "Migration for build $migrationVersion was not executed yet.<br>";
                        // Fetch the migration file
                        $migrationSql = @file_get_contents($migrationUrl);
                    }
 
                    // Check if the migration file was fetched successfully
                    if ($migrationSql === false)
                    {   // Unable to fetch migration file
                        $output .= $lang["UPDATE_NO_MIGRATION_REQUIRED_FOR_BUILD"]." ".$migrationVersion."<br>";
                        sys::setSyslog($db, 53, 0, "No migration required for build $migrationVersion", 0, 0, 0, 0);
                        $failedMigrations++;
                        continue;
                    }
                    else
                    {   // Fetched migration file successfully
                        $output .= "<span style=\"text-success\"><b>".$lang['UPDATE_FETCHED_MIGRATION_FILE_FROM']."</b>".$migrationUrl."</span><br>";
                        sys::setSyslog($db, 54, 0, "<b>Fetched migration file</b> from $migrationUrl", 0, 0, 0, 0);
                        $successfulMigrations++;
                        $successfulMigrationVersions[] = $migrationVersion;
                    }
 
                    $output .= "Multi-query SQL: " . $migrationSql . "<br>";
 
                    // explode the migration file into individual queries (array)
                    $sqlStatements = explode(';', $migrationSql);
                    // to keep track of the statement number
                    $statementCounter = 0;
                    // loop through all sql queries of current migration file
                    foreach ($sqlStatements as $sqlStatement)
                    {   // increment statement counter
                        $statementCounter++;
                        // trim the sql statement
                        $sqlStatement = trim($sqlStatement);
                        // check if sql statement is not empty
                        if (!empty($sqlStatement))
                        {   // execute the sql statement
                            if (!$db->query($sqlStatement))
                            {   // migration failed
                                $output .= $migrationVersion." ".$lang['UPDATE_ERROR_EXEC_FAILED']." ".$statementCounter . $db->error . "<br>";
                                sys::setSyslog($db, 56, 2, "Error executing migration statement #$statementCounter for version (query failed) $migrationVersion: " . $db->error . " ", 0, 0, 0, 0);
                                $db->rollback(); // Rollback the transaction
                                return;
                            }
                            else
                            {   // migration successful
                                $output .= "<span style=\"text-success\">$migrationVersion ".$lang['UPDATE_ERROR_EXEC_SUCCESS']." $statementCounter</span><br>";
                                sys::setSyslog($db, 53, 0, "executed migration statement #$statementCounter : $migrationUrlBase$migrationVersion.sql ", 0, 0, 0, 0);
                            }
                        }
                    }
                } // end loop through migration files
 
                // Commit the transaction if all migrations executed successfully
                $db->commit();
 
                // if there was at least one successful migration
                if ($successfulMigrations > 0)
                {   // store migration version in database
                    $this->recordMigration($db, $successfulMigrationVersions);
                    foreach ($successfulMigrationVersions as $successfulMigrationVersion)
                    {   // output successful migration version
                        $output .= "<span style=\"text-success\">$successfulMigrationVersion ".$lang['UPDATE_MIGRATION_RECORDED']."</span><br>";
                    }
                    // log successful migration
                    sys::setSyslog($db, 54, 0, "<b>Migration complete</b>Migrations executed successfully.", 0, 0, 0, 0);
                    $this->migrationSuccessful = true;
                }
                // END migrations executed successfully
            }
            // TRANSACTION FAILED - ROLLBACK
            catch (\Exception $e)
            {   // An exception was thrown, rollback the transaction
                if ($db->rollback() === true)
                {   // rollback successful
                    sys::setSyslog($db, 56, 2, "<b>Rolled back transaction</b> because there was an error executing migrations: " . $e->getMessage() ." ", 0, 0, 0, 0);
                    $output .= $lang['UPDATE_MIGRATION_ROLLED_BACK'] . $e->getMessage() . "\n";
                }
                else
                {   // rollback failed
                    sys::setSyslog($db, 56, 2, "<b>Rollback FAILED!</b>, additionally there was an error during migrations: " . $e->getMessage() ." ", 0, 0, 0, 0);
                    $output .= $lang['UPDATE_MIGRATION_ROLLBACK_FAILED']  . $e->getMessage() . "\n";
                }
                $this->migrationSuccessful = false;
            }
            // close migration panel body+panel
            $output .= "</div></div></div>";
 
            // output ajax response
            if (!empty($output))
            {   // will be returned to ajax request
                echo $output;
            }
            else
            {   // no output was generated - this should not happen
                sys::setSyslog($db, 56, 2, "No migrations were executed. Output is empty. output was not filled with any value during runMigrations(). (this is not possible?!)", 0, 0, 0, 0);
                echo $lang['UPDATE_NO_MIGRATION_EXECUTED'];
            }

References $db, $i, $lang, and YAWK\update\recordMigration().

Member Data Documentation

$base_dir

string YAWK\update::$base_dir = ''

Definition at line 23 of file update.php.

Referenced by YAWK\update\generateLocalFilebase().

$currentVersion

string YAWK\update::$currentVersion = ''

Definition at line 37 of file update.php.

Referenced by YAWK\update\fetchFiles().

$githubServer

string YAWK\update::$githubServer = 'https://raw.githubusercontent.com/YaWK/yawk.io/master/'

Definition at line 29 of file update.php.

Referenced by YAWK\update\fetchFiles().

$localUpdateSystemPath

string YAWK\update::$localUpdateSystemPath = 'system/update/'

Definition at line 47 of file update.php.

$migrationSuccessful

bool YAWK\update::$migrationSuccessful = false

Definition at line 72 of file update.php.

$updateFile

string YAWK\update::$updateFile = 'update.ini'

Definition at line 32 of file update.php.

$updateFilebase

string YAWK\update::$updateFilebase = 'filebase.ini'

Definition at line 52 of file update.php.

Referenced by YAWK\update\readUpdateFilebaseFromServer().

$updateFiles

array YAWK\update::$updateFiles = array()

Definition at line 67 of file update.php.

$updateFilesFile

string YAWK\update::$updateFilesFile = 'updateFiles.ini'

Definition at line 62 of file update.php.

$updateServer

string YAWK\update::$updateServer = 'https://update.yawk.io/'

Definition at line 26 of file update.php.

$updateSettings

array YAWK\update::$updateSettings = array()

Definition at line 57 of file update.php.

Referenced by YAWK\update\getUpdateSettings().

$updateVersion

string YAWK\update::$updateVersion = ''

Definition at line 42 of file update.php.

Referenced by YAWK\update\fetchFiles().

---

The documentation for this class was generated from the following file:

• /var/www/htdocs/yawk.io/system/classes/update.php