/**
* Validates if the package has suitable install or update instructions
*
* @param string $requiredVersion
* @param integer $validationMode
*/
protected function validateInstructions($requiredVersion, $validationMode)
{
$package = $this->getPackage();
// delivered package does not provide the minimum required version
if (Package::compareVersion($requiredVersion, $this->archive->getPackageInfo('version'), '>')) {
throw new PackageValidationException(PackageValidationException::INSUFFICIENT_VERSION, array('packageName' => $package->packageName, 'packageVersion' => $package->packageVersion, 'deliveredPackageVersion' => $this->archive->getPackageInfo('version')));
}
// package is not installed yet
if ($package === null) {
$instructions = $this->archive->getInstallInstructions();
if (empty($instructions)) {
throw new PackageValidationException(PackageValidationException::NO_INSTALL_PATH, array('packageName' => $this->archive->getPackageInfo('name')));
}
if ($validationMode == PackageValidationManager::VALIDATION_RECURSIVE) {
$this->validatePackageInstallationPlugins('install', $instructions);
}
} else {
// package is already installed, check update path
if (!$this->archive->isValidUpdate($package)) {
throw new PackageValidationException(PackageValidationException::NO_UPDATE_PATH, array('packageName' => $package->packageName, 'packageVersion' => $package->packageVersion, 'deliveredPackageVersion' => $this->archive->getPackageInfo('version')));
}
if ($validationMode === PackageValidationManager::VALIDATION_RECURSIVE) {
$this->validatePackageInstallationPlugins('update', $this->archive->getUpdateInstructions());
}
}
}
/**
* Validates the package archive.
*
* @param string $type upload or download package
*/
protected function validateArchive($type) {
// try to open the archive
try {
// TODO: Exceptions thrown within openArchive() are discarded, resulting in
// the meaningless message 'not a valid package'
$this->archive->openArchive();
}
catch (SystemException $e) {
throw new UserInputException($type, 'noValidPackage');
}
// validate php requirements
$errors = PackageInstallationDispatcher::validatePHPRequirements($this->archive->getPhpRequirements());
if (!empty($errors)) {
WCF::getTPL()->assign('phpRequirements', $errors);
throw new UserInputException($type, 'phpRequirements');
}
// check update or install support
if ($this->package !== null) {
if (!$this->archive->isValidUpdate()) {
throw new UserInputException($type, 'noValidUpdate');
}
}
else {
if (!$this->archive->isValidInstall()) {
throw new UserInputException($type, 'noValidInstall');
}
else if ($this->archive->isAlreadyInstalled()) {
throw new UserInputException($type, 'uniqueAlreadyInstalled');
}
}
}
/**
* Installs the specified package.
*
* @param string $file
*/
private function install($file)
{
// PackageStartInstallForm::validateDownloadPackage()
if (FileUtil::isURL($file)) {
// download package
$archive = new PackageArchive($file, null);
try {
if (VERBOSITY >= 1) {
Log::info("Downloading '" . $file . "'");
}
$file = $archive->downloadArchive();
} catch (SystemException $e) {
$this->error('notFound', array('file' => $file));
}
} else {
// probably local path
if (!file_exists($file)) {
$this->error('notFound', array('file' => $file));
}
$archive = new PackageArchive($file, null);
}
// PackageStartInstallForm::validateArchive()
// try to open the archive
try {
// TODO: Exceptions thrown within openArchive() are discarded, resulting in
// the meaningless message 'not a valid package'
$archive->openArchive();
} catch (SystemException $e) {
$this->error('noValidPackage');
}
$errors = PackageInstallationDispatcher::validatePHPRequirements($archive->getPhpRequirements());
if (!empty($errors)) {
// TODO: Nice output
$this->error('phpRequirements', array('errors' => $errors));
}
// try to find existing package
$sql = "SELECT\t*\n\t\t\tFROM\twcf" . WCF_N . "_package\n\t\t\tWHERE\tpackage = ?";
$statement = CLIWCF::getDB()->prepareStatement($sql);
$statement->execute(array($archive->getPackageInfo('name')));
$row = $statement->fetchArray();
$package = null;
if ($row !== false) {
$package = new Package(null, $row);
}
// check update or install support
if ($package !== null) {
CLIWCF::getSession()->checkPermissions(array('admin.system.package.canUpdatePackage'));
$archive->setPackage($package);
if (!$archive->isValidUpdate()) {
$this->error('noValidUpdate');
}
} else {
CLIWCF::getSession()->checkPermissions(array('admin.system.package.canInstallPackage'));
if (!$archive->isValidInstall()) {
$this->error('noValidInstall');
} else {
if ($archive->getPackageInfo('isApplication')) {
// applications cannot be installed via CLI
$this->error('cli.installIsApplication');
} else {
if ($archive->isAlreadyInstalled()) {
$this->error('uniqueAlreadyInstalled');
} else {
if ($archive->getPackageInfo('isApplication') && $this->archive->hasUniqueAbbreviation()) {
$this->error('noUniqueAbbrevation');
}
}
}
}
}
// PackageStartInstallForm::save()
$processNo = PackageInstallationQueue::getNewProcessNo();
// insert queue
$queue = PackageInstallationQueueEditor::create(array('processNo' => $processNo, 'userID' => CLIWCF::getUser()->userID, 'package' => $archive->getPackageInfo('name'), 'packageName' => $archive->getLocalizedPackageInfo('packageName'), 'packageID' => $package !== null ? $package->packageID : null, 'archive' => $file, 'action' => $package !== null ? 'update' : 'install'));
// PackageInstallationDispatcher::openQueue()
$parentQueueID = 0;
$conditions = new PreparedStatementConditionBuilder();
$conditions->add("userID = ?", array(CLIWCF::getUser()->userID));
$conditions->add("parentQueueID = ?", array($parentQueueID));
if ($processNo != 0) {
$conditions->add("processNo = ?", array($processNo));
}
$conditions->add("done = ?", array(0));
$sql = "SELECT\t\t*\n\t\t\tFROM\t\twcf" . WCF_N . "_package_installation_queue\n\t\t\t" . $conditions . "\n\t\t\tORDER BY\tqueueID ASC";
$statement = CLIWCF::getDB()->prepareStatement($sql);
$statement->execute($conditions->getParameters());
$packageInstallation = $statement->fetchArray();
if (!isset($packageInstallation['queueID'])) {
$this->error('internalOpenQueue');
return;
} else {
$queueID = $packageInstallation['queueID'];
}
// PackageInstallationConfirmPage::readParameters()
$queue = new PackageInstallationQueue($queueID);
if (!$queue->queueID || $queue->done) {
$this->error('internalReadParameters');
return;
}
// PackageInstallationConfirmPage::readData()
$missingPackages = 0;
$packageInstallationDispatcher = new PackageInstallationDispatcher($queue);
// get requirements
$requirements = $packageInstallationDispatcher->getArchive()->getRequirements();
$openRequirements = $packageInstallationDispatcher->getArchive()->getOpenRequirements();
foreach ($requirements as &$requirement) {
if (isset($openRequirements[$requirement['name']])) {
$requirement['status'] = 'missing';
$requirement['action'] = $openRequirements[$requirement['name']]['action'];
if (!isset($requirement['file'])) {
if ($requirement['action'] === 'update') {
$requirement['status'] = 'missingVersion';
$requirement['existingVersion'] = $openRequirements[$requirement['name']]['existingVersion'];
}
$missingPackages++;
} else {
$requirement['status'] = 'delivered';
$packageArchive = new PackageArchive($packageInstallationDispatcher->getArchive()->extractTar($requirement['file']));
$packageArchive->openArchive();
// make sure that the delivered package is correct
if ($requirement['name'] != $packageArchive->getPackageInfo('name')) {
$requirement['status'] = 'invalidDeliveredPackage';
$requirement['deliveredPackage'] = $packageArchive->getPackageInfo('name');
$missingPackages++;
} else {
if (isset($requirement['minversion'])) {
// make sure that the delivered version is sufficient
if (Package::compareVersion($requirement['minversion'], $packageArchive->getPackageInfo('version')) > 0) {
$requirement['deliveredVersion'] = $packageArchive->getPackageInfo('version');
$requirement['status'] = 'missingVersion';
$missingPackages++;
}
}
}
}
} else {
$requirement['status'] = 'installed';
}
}
unset($requirement);
// PackageInstallationConfirmPage::assignVariables/show()
$excludingPackages = $packageInstallationDispatcher->getArchive()->getConflictedExcludingPackages();
$excludedPackages = $packageInstallationDispatcher->getArchive()->getConflictedExcludedPackages();
if (!($missingPackages == 0 && count($excludingPackages) == 0 && count($excludedPackages) == 0)) {
$this->error('missingPackagesOrExclude', array('requirements' => $requirements, 'excludingPackages' => $excludingPackages, 'excludedPackages' => $excludedPackages));
return;
}
// AbstractDialogAction::readParameters()
$step = 'prepare';
$queueID = $queue->queueID;
$node = '';
// initialize progressbar
$progressbar = new ProgressBar(new ConsoleProgressBar(array('width' => CLIWCF::getTerminal()->getWidth(), 'elements' => array(ConsoleProgressBar::ELEMENT_PERCENT, ConsoleProgressBar::ELEMENT_BAR, ConsoleProgressBar::ELEMENT_TEXT), 'textWidth' => min(floor(CLIWCF::getTerminal()->getWidth() / 2), 50))));
// InstallPackageAction::readParameters()
$finished = false;
while (!$finished) {
$queue = new PackageInstallationQueue($queueID);
if (!$queue->queueID) {
// todo: what to output?
echo "InstallPackageAction::readParameters()";
return;
}
$installation = new PackageInstallationDispatcher($queue);
switch ($step) {
case 'prepare':
// InstallPackageAction::stepPrepare()
// update package information
$installation->updatePackage();
// clean-up previously created nodes
$installation->nodeBuilder->purgeNodes();
// create node tree
$installation->nodeBuilder->buildNodes();
$node = $installation->nodeBuilder->getNextNode();
$queueID = $installation->nodeBuilder->getQueueByNode($installation->queue->processNo, $node);
$step = 'install';
$progress = 0;
$currentAction = $installation->nodeBuilder->getPackageNameByQueue($queueID);
break;
case 'install':
// InstallPackageAction::stepInstall()
$step_ = $installation->install($node);
$queueID = $installation->nodeBuilder->getQueueByNode($installation->queue->processNo, $step_->getNode());
if ($step_->hasDocument()) {
$innerTemplate = $step_->getTemplate();
$progress = $installation->nodeBuilder->calculateProgress($node);
$node = $step_->getNode();
$currentAction = $installation->nodeBuilder->getPackageNameByQueue($queueID);
} else {
if ($step_->getNode() == '') {
// perform final actions
$installation->completeSetup();
// InstallPackageAction::finalize()
CacheHandler::getInstance()->flushAll();
// /InstallPackageAction::finalize()
// show success
$progress = 100;
$currentAction = CLIWCF::getLanguage()->get('wcf.acp.package.installation.step.install.success');
$finished = true;
continue;
} else {
// continue with next node
$progress = $installation->nodeBuilder->calculateProgress($node);
$node = $step_->getNode();
$currentAction = $installation->nodeBuilder->getPackageNameByQueue($queueID);
}
}
break;
}
$progressbar->update($progress, $currentAction);
}
$progressbar->getAdapter()->finish();
}