protected function _run()
{
if ($this->getState() == 'postrun') {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, __CLASS__ . " :: Already finished");
$this->setStep('');
$this->setSubstep('');
return;
} else {
$this->setState('running');
}
// Load the version defines
AEPlatform::getInstance()->load_version_defines();
$registry = AliceFactory::getConfiguration();
// Write log file's header
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "--------------------------------------------------------------------------------");
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Alice Log Inspector and Correction of Errors " . AKEEBA_VERSION . ' (' . AKEEBA_DATE . ')');
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "What went wrong?");
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "--------------------------------------------------------------------------------");
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "--- System Information ---");
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "PHP Version :" . PHP_VERSION);
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "PHP OS :" . PHP_OS);
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "PHP SAPI :" . PHP_SAPI);
if (function_exists('php_uname')) {
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "OS Version :" . php_uname('s'));
}
if (isset($_SERVER['SERVER_SOFTWARE'])) {
$server = $_SERVER['SERVER_SOFTWARE'];
} elseif ($sf = getenv('SERVER_SOFTWARE')) {
$server = $sf;
} else {
$server = 'n/a';
}
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Web Server :" . $server);
$platformData = AEPlatform::getInstance()->getPlatformVersion();
AliceUtilLogger::WriteLog(_AE_LOG_INFO, $platformData['name'] . " version :" . $platformData['version']);
if (isset($_SERVER['HTTP_USER_AGENT'])) {
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "User agent :" . phpversion() <= "4.2.1" ? getenv("HTTP_USER_AGENT") : $_SERVER['HTTP_USER_AGENT']);
}
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Safe mode :" . ini_get("safe_mode"));
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Display errors :" . ini_get("display_errors"));
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Error reporting :" . self::error2string());
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Error display :" . self::errordisplay());
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Disabled functions :" . ini_get("disable_functions"));
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "open_basedir restr.:" . ini_get('open_basedir'));
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Max. exec. time :" . ini_get("max_execution_time"));
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Memory limit :" . ini_get("memory_limit"));
if (function_exists("memory_get_usage")) {
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "Current mem. usage :" . memory_get_usage());
}
AliceUtilLogger::WriteLog(_AE_LOG_INFO, "--------------------------------------------------------------------------------");
if (!version_compare(PHP_VERSION, '5.3.0', 'ge')) {
AliceUtilLogger::WriteLog(_AE_LOG_WARNING, "You are using an outdated version of PHP. Akeeba Engine may not work properly. Please upgrade to PHP 5.3 or later.");
}
$this->setState('postrun');
}
protected function _run()
{
// Run in a loop until we run out of time, or breakflag is set
$registry = AliceFactory::getConfiguration();
$timer = AliceFactory::getTimer();
// Let's check if I already have a stack coming from previous call
$this->log = $registry->get('volatile.alice.logToAnalyze');
$this->checks = $registry->get('volatile.alice.' . $this->checksName . '.checks', array());
$this->totalChecks = $registry->get('volatile.alice.' . $this->checksName . '.totalChecks', 0);
// No incoming stack, let's build it now
if (!$this->checks) {
$this->checks = AliceUtilScripting::getChecksStack($this->checksName);
$this->totalChecks = count($this->checks);
}
while ($timer->getTimeLeft() > 0 && !$registry->get('volatile.breakflag', false) && count($this->checks)) {
if ($this->getState() == 'postrun') {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, __CLASS__ . " :: Already finished");
$this->setStep("-");
$this->setSubstep("");
break;
} else {
// Did I finished every check?
if (!$this->checks) {
return;
}
$error = '';
$solution = '';
$className = array_shift($this->checks);
$check = new $className($this->log);
$this->setSubstep($check->getName());
$this->progress = ($this->totalChecks - count($this->checks)) / $this->totalChecks;
// Well, check, do your job!
try {
$check->check();
} catch (Exception $e) {
// Mhm... log didn't passed the check. Let's save the error and the suggested solution
$error = $e->getMessage();
$solution = $check->getSolution();
}
$result = $check->getResult();
$feedback = $registry->get('volatile.alice.feedback', array());
$feedback[] = array('check' => $check->getName(), 'result' => $result, 'error' => $error, 'solution' => $solution);
$registry->set('volatile.alice.feedback', $feedback);
unset($check);
}
}
// Let's save everything
$registry->set('volatile.alice.requirements.checks', $this->checks);
$registry->set('volatile.alice.requirements.totalChecks', $this->totalChecks);
$this->setState('postrun');
}
public function runAnalysis()
{
$ret_array = array();
$ajaxTask = $this->getState('ajax');
$log = $this->getState('log');
switch ($ajaxTask) {
case 'start':
$tag = 'alice';
AliceUtilLogger::WriteLog(true);
AliceUtilLogger::WriteLog(_AE_LOG_INFO, 'Starting analysis');
AliceCoreKettenrad::reset(array('maxrun' => 0));
AliceUtilTempvars::reset($tag);
$kettenrad = AliceCoreKettenrad::load($tag);
$options = array('logToAnalyze' => AEUtilLogger::logName($log));
$kettenrad->setup($options);
$kettenrad->tick();
if ($kettenrad->getState() != 'running') {
$kettenrad->tick();
}
$ret_array = $kettenrad->getStatusArray();
$kettenrad->resetWarnings();
// So as not to have duplicate warnings reports
AliceCoreKettenrad::save($tag);
break;
case 'step':
$tag = 'alice';
$kettenrad = AliceCoreKettenrad::load($tag);
$kettenrad->tick();
$ret_array = $kettenrad->getStatusArray();
$kettenrad->resetWarnings();
// So as not to have duplicate warnings reports
AliceCoreKettenrad::save($tag);
if ($ret_array['HasRun'] == 1) {
// Let's get tests result
$config = AliceFactory::getConfiguration();
$feedback = $config->get('volatile.alice.feedback');
$ret_array['Results'] = json_encode($feedback);
// Clean up
AliceFactory::nuke();
AliceUtilTempvars::reset($tag);
}
break;
default:
break;
}
return $ret_array;
}
/**
* The public interface to an engine part. This method takes care for
* calling the correct method in order to perform the initialisation -
* run - finalisation cycle of operation and return a proper reponse array.
*
* @param int $nesting
*
* @return array A Reponse Array
*/
public final function tick($nesting = 0)
{
$configuration = AliceFactory::getConfiguration();
$timer = AliceFactory::getTimer();
// Call the right action method, depending on engine part state
switch ($this->getState()) {
case "init":
$this->_prepare();
$breakFlag = $configuration->set('volatile.breakflag', false);
break;
case "prepared":
$this->_run();
break;
case "running":
$this->_run();
break;
case "postrun":
$this->_finalize();
$breakFlag = $configuration->set('volatile.breakflag', false);
break;
}
// If there is still time, we are not finished and there is no break flag set, re-run the tick()
// method.
$breakFlag = $configuration->get('volatile.breakflag', false);
if (!in_array($this->getState(), array('finished', 'error')) && $timer->getTimeLeft() > 0 && !$breakFlag && $nesting < 20 && $this->nest_logging) {
// Nesting is only applied if $this->nest_logging == true (currently only Kettenrad has this)
$nesting++;
if ($this->nest_logging) {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "*** Batching successive steps (nesting level {$nesting})");
}
$out = $this->tick($nesting);
} else {
// Return the output array
$out = $this->_makeReturnTable();
// Things to do for nest-logged parts (currently, only Kettenrad is)
if ($this->nest_logging) {
if ($breakFlag) {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "*** Engine steps batching: Break flag detected.");
}
// Reset the break flag
$configuration->set('volatile.breakflag', false);
// Log that we're breaking the step
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "*** Batching of engine steps finished. I will now return control to the caller.");
// Enforce minimum execution time
$timer = AliceFactory::getTimer();
$timer->enforce_min_exec_time(true);
}
}
// Send a Return Table back to the caller
return $out;
}
protected function _run()
{
AliceUtilLogger::openLog($this->tag);
set_error_handler('aliceBackupErrorHandler');
// Maybe we're already done or in an error state?
if ($this->getError() || $this->getState() == 'postrun') {
return;
}
// Set running state
$this->setState('running');
// Initialize operation counter
$registry = AliceFactory::getConfiguration();
$registry->set('volatile.operation_counter', 0);
// Advance step counter
$stepCounter = $registry->get('volatile.step_counter', 0);
$registry->set('volatile.step_counter', ++$stepCounter);
// Log step start number
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, '====== Starting Step number ' . $stepCounter . ' ======');
$timer = AliceFactory::getTimer();
$finished = false;
$error = false;
$breakFlag = false;
// BREAKFLAG is optionally passed by domains to force-break current operation
// Apply an infinite time limit if required
if ($registry->get('akeeba.tuning.settimelimit', 0)) {
if (function_exists('set_time_limit')) {
set_time_limit(0);
}
}
$this->array_cache = null;
// Loop until time's up, we're done or an error occurred, or BREAKFLAG is set
while ($timer->getTimeLeft() > 0 && !$finished && !$error && !$breakFlag) {
// Reset the break flag
$registry->set('volatile.breakflag', false);
// Do we have to switch domains? This only happens if there is no active
// domain, or the current domain has finished
$have_to_switch = false;
if ($this->class == '') {
$have_to_switch = true;
} else {
$object = AliceFactory::getDomainObject($this->class);
if (!is_object($object)) {
$have_to_switch = true;
} else {
if (!in_array('getState', get_class_methods($object))) {
$have_to_switch = true;
} else {
if ($object->getState() == 'finished') {
$have_to_switch = true;
}
}
}
}
// Switch domain if necessary
if ($have_to_switch) {
// TODO Check what's the most conservative value and use it
if (!AliceFactory::getConfiguration()->get('akeeba.tuning.nobreak.domains', 0)) {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "Kettenrad :: BREAKING STEP BEFORE SWITCHING DOMAIN");
$registry->set('volatile.breakflag', true);
}
$object = null;
// Free last domain
if (empty($this->domain_chain)) {
// Aw, we're done! No more domains to run.
$this->setState('postrun');
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "Kettenrad :: No more domains to process");
$this->array_cache = null;
//restore_error_handler();
return;
}
// Shift the next definition off the stack
$this->array_cache = null;
$new_definition = array_shift($this->domain_chain);
if (array_key_exists('class', $new_definition)) {
$this->domain = $new_definition['domain'];
$this->class = $new_definition['class'];
// Get a working object
$object = AliceFactory::getDomainObject($this->class);
$object->setup($this->_parametersArray);
} else {
AliceUtilLogger::WriteLog(_AE_LOG_WARNING, "Kettenrad :: No class defined trying to switch domains. The analysis will crash.");
$this->domain = null;
$this->class = null;
}
} else {
if (!is_object($object)) {
$object = AliceFactory::getDomainObject($this->class);
}
}
// Tick the object
$result = $object->tick();
// Propagate errors
$this->propagateFromObject($object);
// Advance operation counter
$currentOperationNumber = $registry->get('volatile.operation_counter', 0);
$currentOperationNumber++;
$registry->set('volatile.operation_counter', $currentOperationNumber);
// Process return array
$this->setDomain($this->domain);
$this->setStep($result['Step']);
$this->setSubstep($result['Substep']);
// Check for BREAKFLAG
$breakFlag = $registry->get('volatile.breakflag', false);
// Process errors
$error = false;
if ($this->getError()) {
$error = true;
}
// Check if the backup procedure should finish now
$finished = $error ? true : !$result['HasRun'];
// Log operation end
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, '----- Finished operation ' . $currentOperationNumber . ' ------');
}
// while
// Log the result
if (!$error) {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "Successful Smart algorithm on " . get_class($object));
} else {
AliceUtilLogger::WriteLog(_AE_LOG_ERROR, "Failed Smart algorithm on " . get_class($object));
}
// Log if we have to do more work or not
if (!is_object($object)) {
AliceUtilLogger::WriteLog(_AE_LOG_WARNING, "Kettenrad :: Empty object found when processing domain '" . $this->domain . "'. This should never happen.");
} else {
if ($object->getState() == 'running') {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "Kettenrad :: More work required in domain '" . $this->domain . "'");
// We need to set the break flag for the part processing to not batch successive steps
$registry->set('volatile.breakflag', true);
} elseif ($object->getState() == 'finished') {
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, "Kettenrad :: Domain '" . $this->domain . "' has finished.");
$registry->set('volatile.breakflag', false);
}
}
// Log step end
AliceUtilLogger::WriteLog(_AE_LOG_DEBUG, '====== Finished Step number ' . $stepCounter . ' ======');
if (!$registry->get('akeeba.tuning.nobreak.domains', 0)) {
// Force break between steps
$registry->set('volatile.breakflag', true);
}
//restore_error_handler();
}
