mirror of
https://github.com/Combodo/iTop.git
synced 2026-02-28 14:44:17 +01:00
494 lines
14 KiB
PHP
494 lines
14 KiB
PHP
<?php
|
|
/**
|
|
* Copyright (C) 2013-2024 Combodo SAS
|
|
* This file is part of iTop.
|
|
* iTop is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
* iTop is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
*/
|
|
|
|
namespace Combodo\iTop\Test\UnitTest\Integration;
|
|
|
|
use ApplicationException;
|
|
use Combodo\iTop\Test\UnitTest\XmlModule;
|
|
use Combodo\iTop\Test\UnitTest\XmlModuleMetaInfo;
|
|
use utils;
|
|
|
|
require_once __DIR__ . '/XmlModuleMetaInfo.php';
|
|
require_once __DIR__ . '/XmlModule.php';
|
|
|
|
use ModuleInstallerAPI;
|
|
|
|
/**
|
|
* @group modulesDependencyValidation
|
|
*/
|
|
class iTopModulesDependencyValidationService {
|
|
private static ?iTopModulesDependencyValidationService $oInstance;
|
|
public static array $aModulesDataByModuleName=[];
|
|
|
|
public array $aModules=[];
|
|
private string $sCurrentModule;
|
|
private array $aDefineNodes;
|
|
private array $aDependencyNodes;
|
|
private array $aAllDmFiles=[];
|
|
private array $aSoftDependencyNodes=[];
|
|
private array $aSubfoldersByModulename=[];
|
|
|
|
public static function GetInstance(): iTopModulesDependencyValidationService
|
|
{
|
|
if (!isset(self::$oInstance)) {
|
|
self::$oInstance = new iTopModulesDependencyValidationService();
|
|
self::ReadModuleMetaInfo();
|
|
}
|
|
|
|
return self::$oInstance;
|
|
}
|
|
|
|
public static function SetInstance(?iTopModulesDependencyValidationService $instance): void {
|
|
self::$oInstance = $instance;
|
|
}
|
|
|
|
|
|
public static function ReadModuleMetaInfo(): void
|
|
{
|
|
require_once APPROOT."setup/modulediscovery.class.inc.php";
|
|
require_once(APPROOT.'/setup/moduleinstaller.class.inc.php');
|
|
|
|
if (count(self::$aModulesDataByModuleName)>0){
|
|
return;
|
|
}
|
|
|
|
$aDirsToScan = [
|
|
APPROOT.'datamodels/2.x',
|
|
APPROOT.'extensions',
|
|
APPROOT.'extensions/*',
|
|
APPROOT.'data/production-modules',
|
|
APPROOT.'data/production-modules/*',
|
|
];
|
|
$aFilesToRemove=[];
|
|
foreach ($aDirsToScan as $sDir){
|
|
foreach (glob("$sDir/*/module.*.php") as $sFile) {
|
|
$sContent = file_get_contents($sFile);
|
|
$sContent=str_replace('SetupWebPage::AddModule', '$aModuleData=array', $sContent);
|
|
|
|
$sTempFile = tempnam(sys_get_temp_dir(), 'modulefile_');
|
|
$aFilesToRemove[]=$sTempFile;
|
|
file_put_contents($sTempFile, $sContent);
|
|
|
|
require_once $sTempFile;
|
|
|
|
//replace tmp file by real module path
|
|
$aModuleData[0]=$sFile;
|
|
$sModuleId=$aModuleData[1];
|
|
|
|
list($sModuleName, $sVersion) = \ModuleDiscovery::GetModuleName($sModuleId);
|
|
self::$aModulesDataByModuleName[$sModuleName] = $aModuleData;
|
|
}
|
|
|
|
ksort(self::$aModulesDataByModuleName);
|
|
|
|
foreach ($aFilesToRemove as $sTmpFile){
|
|
@unlink($sTmpFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function GetModuleMetainfo($sModuleId)
|
|
{
|
|
return self::$aModulesDataByModuleName[$sModuleId] ?? [];
|
|
}
|
|
|
|
public function ListDatamodelFiles() : array
|
|
{
|
|
if (count($this->aAllDmFiles)==0){
|
|
$aGlobPAtterns = [
|
|
APPROOT.'datamodels/2.x/*',
|
|
APPROOT.'application',
|
|
APPROOT.'core',
|
|
APPROOT.'extensions',
|
|
APPROOT.'extensions/*',
|
|
APPROOT.'data/production-modules',
|
|
APPROOT.'data/production-modules/*',
|
|
];
|
|
|
|
foreach ($aGlobPAtterns as $sPattern) {
|
|
$this->aAllDmFiles = array_merge($this->aAllDmFiles, glob("$sPattern/datamodel.*.xml"));
|
|
}
|
|
}
|
|
return $this->aAllDmFiles;
|
|
}
|
|
|
|
private function CreateIfNeededAndGetXmlModule(string $sModuleName) : XmlModule {
|
|
/** @var XmlModule $oCurrentXmlModule */
|
|
$oCurrentXmlModule = $this->aModules[$sModuleName] ?? null;
|
|
if (is_null($oCurrentXmlModule)){
|
|
$oCurrentXmlModule = new XmlModule($sModuleName);
|
|
$this->aModules[$sModuleName] = $oCurrentXmlModule;
|
|
}
|
|
|
|
return $oCurrentXmlModule;
|
|
}
|
|
|
|
public function FetchAllDependenciesViaDM()
|
|
{
|
|
foreach ($this->ListDatamodelFiles() as $sFile) {
|
|
$this->FetchXmlMetaInfo($sFile);
|
|
}
|
|
|
|
foreach ($this->aDefineNodes as $sKey => $aModules){
|
|
foreach ($aModules as $sModuleName){
|
|
$this->CreateIfNeededAndGetXmlModule($sModuleName);
|
|
}
|
|
|
|
$aSoftlyDependentModules = $this->aSoftDependencyNodes[$sKey] ?? null;
|
|
if (is_null($aSoftlyDependentModules)){
|
|
continue;
|
|
}
|
|
|
|
foreach ($aSoftlyDependentModules as $sModuleName){
|
|
$oCurrentXmlModule = $this->CreateIfNeededAndGetXmlModule($sModuleName);
|
|
$oCurrentXmlModule->AddDependency($sKey, $aModules, $this->aModules);
|
|
}
|
|
}
|
|
|
|
foreach ($this->aDependencyNodes as $sKey => $aModules){
|
|
foreach ($aModules as $sModuleName){
|
|
$aDefiningModules = $this->aDefineNodes[$sKey] ?? null;
|
|
if (is_null($aDefiningModules)){
|
|
continue;
|
|
}
|
|
|
|
$oCurrentXmlModule = $this->CreateIfNeededAndGetXmlModule($sModuleName);
|
|
$oCurrentXmlModule->AddDependency($sKey, $aDefiningModules, $this->aModules);
|
|
}
|
|
}
|
|
|
|
$this->OrderModules();
|
|
$this->CompleteModuleDependencies();
|
|
}
|
|
|
|
public function FetchAllDependenciesViaModulesFiles()
|
|
{
|
|
$aFullnameClassesByModuleName=[];
|
|
foreach (self::$aModulesDataByModuleName as $sModuleName => $aModuleData){
|
|
//echo "$sModuleName\n";
|
|
$aFiles = $aModuleData[2]['datamodel'] ?? [];
|
|
$sDir = dirname($aModuleData[0]);
|
|
|
|
$aDeps=[];
|
|
foreach ($aFiles as $sFile){
|
|
if (preg_match("|.*model\.$sModuleName\.php|", $sFile)){
|
|
continue;
|
|
}
|
|
//echo "$sDir/$sFile\n";
|
|
$aDeps=array_merge($aDeps, $this->ListDeclaredFullnameClassesFromPhpFile("$sDir/$sFile"));
|
|
}
|
|
|
|
$aFullnameClassesByModuleName[$sModuleName]=$aDeps;
|
|
}
|
|
|
|
foreach ($aFullnameClassesByModuleName as $sModuleName => $aFullnameClasses){
|
|
foreach (self::$aModulesDataByModuleName as $sModuleName2 => $aModuleData){
|
|
if ($sModuleName2 === $sModuleName){
|
|
continue;
|
|
}
|
|
|
|
$sDir = dirname($aModuleData[0]);
|
|
|
|
if (count($aFullnameClassesByModuleName)==0){
|
|
continue;
|
|
}
|
|
|
|
$sStr = "";
|
|
foreach ($aFullnameClasses as $sClass){
|
|
$sStr .= <<<TXT
|
|
-e "$sClass"
|
|
TXT;
|
|
}
|
|
|
|
if (strlen($sStr)==0){
|
|
continue;
|
|
}
|
|
|
|
$bFound=false;
|
|
foreach ($this->GetFolders($sModuleName2, $sDir) as $sFolderDir => $sGrepRecursiveCliOption) {
|
|
$sCliCmd = str_replace('\\', '\\\\\\\\', sprintf("grep -l%s %s $sFolderDir", $sGrepRecursiveCliOption, $sStr));
|
|
$sOutput = exec($sCliCmd);
|
|
|
|
if (strlen($sOutput) != 0) {
|
|
$bFound=true;
|
|
$sCliCmd = str_replace('\\', '\\\\\\\\', sprintf("grep -o%s %s $sFolderDir", $sGrepRecursiveCliOption, $sStr));
|
|
$sOutput = exec($sCliCmd);
|
|
//echo "|$sOutput|\n";
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ($bFound){
|
|
$oCurrentXmlModule = $this->CreateIfNeededAndGetXmlModule($sModuleName);
|
|
$oCurrentXmlModule2 = $this->CreateIfNeededAndGetXmlModule($sModuleName2);
|
|
try{
|
|
$sKey = $this->GetFirstFoundDepsUID($sOutput);
|
|
} catch(\Exception $e){
|
|
var_dump($aFullnameClassesByModuleName);
|
|
var_dump(
|
|
[ $sStr, $sCliCmd, $sModuleName, $sModuleName2, $sOutput]
|
|
);
|
|
throw $e;
|
|
}
|
|
$oCurrentXmlModule2->AddDependency($sKey, [$sModuleName], $this->aModules);
|
|
//echo "$sModuleName2 => $sModuleName\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function GetFirstFoundDepsUID(string $sOutput) : string {
|
|
if (preg_match_all('|.*:(.*)|m', $sOutput, $aMatches)){
|
|
//var_dump($aMatches);
|
|
return $aMatches[1][0];
|
|
}
|
|
|
|
throw new \Exception('no match: ' . $sOutput);
|
|
}
|
|
|
|
private function GetFolders($sModuleName2, $sDir) : array
|
|
{
|
|
if (array_key_exists($sModuleName2, $this->aSubfoldersByModulename)){
|
|
return $this->aSubfoldersByModulename[$sModuleName2];
|
|
}
|
|
|
|
$aRes=[];
|
|
$aFiles=[];
|
|
foreach (glob("$sDir/*") as $sPath){
|
|
if (! is_dir($sPath)){
|
|
$aFiles[]=$sPath;
|
|
continue;
|
|
}
|
|
|
|
if (strpos($sPath, '\.git') !== false){
|
|
continue;
|
|
}
|
|
|
|
if (strpos($sPath, 'vendor') !== false){
|
|
continue;
|
|
}
|
|
|
|
if (strpos($sPath, 'test') !== false){
|
|
continue;
|
|
}
|
|
|
|
$aRes[$sPath]="r";
|
|
}
|
|
|
|
$aRes=[ implode(' ', $aFiles) => "" ];
|
|
$this->aSubfoldersByModulename[$sModuleName2]=$aRes;
|
|
return $aRes;
|
|
}
|
|
|
|
private function GetModuleSuffix($sFile) : string
|
|
{
|
|
if (! preg_match('|.*datamodel\.([^\.]+)\.xml|', $sFile, $aMatches)){
|
|
throw new \Exception("Regexp issue: $sFile");
|
|
}
|
|
return $aMatches[1];
|
|
}
|
|
|
|
public function FetchXmlMetaInfo($sFile) : void {
|
|
$oDomDoc = new \DOMDocument('1.0', 'UTF-8');
|
|
libxml_clear_errors();
|
|
$oDomDoc->loadXml(file_get_contents($sFile));
|
|
$aErrors = libxml_get_errors();
|
|
if (count($aErrors) > 0)
|
|
{
|
|
throw new \Exception("Malformed XML");
|
|
}
|
|
|
|
$this->sCurrentModule = $this->GetModuleSuffix($sFile);
|
|
|
|
if (! isset($this->aDefineNodes)){
|
|
$this->aDefineNodes=[];
|
|
}
|
|
|
|
if (! isset($this->aDependencyNodes)){
|
|
$this->aDependencyNodes=[];
|
|
}
|
|
|
|
foreach ($oDomDoc->childNodes as $oDomNode){
|
|
$this->FetchMetaInfo($oDomDoc->childNodes);
|
|
}
|
|
}
|
|
|
|
private function FetchMetaInfo(\DOMNodeList $oDomNodeList, ?string $sPath=null)
|
|
{
|
|
/** @var \DOMNode $oDomNode */
|
|
foreach ($oDomNodeList as $oDomNode) {
|
|
/** @var \DOMAttr $oDelta */
|
|
$oDelta = $oDomNode->attributes['_delta'] ?? null;
|
|
/** @var \DOMAttr $oId */
|
|
$oId = $oDomNode->attributes['id'] ?? null;
|
|
|
|
if (! is_null($oId)) {
|
|
$sId = $oId->nodeValue;
|
|
$sCurrentPath = $sPath ? $sPath."->".$sId : $sId;
|
|
|
|
if (!is_null($oDelta)) {
|
|
$oXmlModuleMetaInfo = new XmlModuleMetaInfo($sId, $oDomNode->nodeName, $sCurrentPath, $oDelta->nodeValue);
|
|
$sKey = $oXmlModuleMetaInfo->GetUID();
|
|
if ($oXmlModuleMetaInfo->IsDefine()) {
|
|
if (array_key_exists($sKey, $this->aDefineNodes)) {
|
|
$this->aDefineNodes[$sKey][] = $this->sCurrentModule;
|
|
} else {
|
|
$this->aDefineNodes[$sKey] = [$this->sCurrentModule];
|
|
}
|
|
} else {
|
|
if (array_key_exists($sKey, $this->aDependencyNodes)) {
|
|
$this->aDependencyNodes[$sKey][] = $this->sCurrentModule;
|
|
} else {
|
|
$this->aDependencyNodes[$sKey] = [$this->sCurrentModule];
|
|
}
|
|
}
|
|
} else {
|
|
$oXmlModuleMetaInfo = new XmlModuleMetaInfo($sId, $oDomNode->nodeName, $sCurrentPath, "nodelta");
|
|
$sKey = $oXmlModuleMetaInfo->GetUID();
|
|
if (array_key_exists($sKey, $this->aSoftDependencyNodes)) {
|
|
$this->aSoftDependencyNodes[$sKey][] = $this->sCurrentModule;
|
|
} else {
|
|
$this->aSoftDependencyNodes[$sKey] = [$this->sCurrentModule];
|
|
}
|
|
}
|
|
} else if ($oDomNode instanceof \DOMElement){
|
|
$sCurrentPath = $sPath ? $sPath . '->' . $oDomNode->nodeName : $oDomNode->nodeName;
|
|
} else{
|
|
$sCurrentPath = $sPath;
|
|
}
|
|
|
|
$this->FetchMetaInfo($oDomNode->childNodes, $sCurrentPath);
|
|
}
|
|
}
|
|
|
|
private function OrderModules()
|
|
{
|
|
$aModuleDepsCount = [];
|
|
/** @var XmlModule $oXmlModule */
|
|
foreach ($this->aModules as $oXmlModule) {
|
|
$aModuleDepsCount[$oXmlModule->sModuleName] = count($oXmlModule->aDependencyModulesNames);
|
|
}
|
|
|
|
$aOrderModules=[];
|
|
while (count($aModuleDepsCount)>0) {
|
|
asort($aModuleDepsCount);
|
|
|
|
foreach ($aModuleDepsCount as $sModuleName => $iCount){
|
|
if ($iCount>0){
|
|
throw new \Exception("still deps with $sModuleName");
|
|
}
|
|
|
|
unset($aModuleDepsCount[$sModuleName]);
|
|
$aOrderModules[$sModuleName] = $this->aModules[$sModuleName];
|
|
break;
|
|
}
|
|
|
|
//echo "$sModuleName\n";
|
|
foreach ($aModuleDepsCount as $sStillToProcessModuleName => $c){
|
|
/** @var XmlModule $oXmlStillToProcessModule */
|
|
$oXmlStillToProcessModule = $this->aModules[$sStillToProcessModuleName];
|
|
if ($oXmlStillToProcessModule->Depends($sModuleName)){
|
|
$aModuleDepsCount[$sStillToProcessModuleName] = $c - 1 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
$this->aModules = $aOrderModules;
|
|
}
|
|
|
|
private function CompleteModuleDependencies()
|
|
{
|
|
/** @var XmlModule $oXmlModule */
|
|
foreach ($this->aModules as $oXmlModule) {
|
|
$oXmlModule->CompleteModuleDependencies($this->aModules);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read declared classes/interfaces in modules.php file (either directly listed files or inside autoload)
|
|
* @param string : module file path
|
|
*
|
|
* @return array: list of fullname classes
|
|
*/
|
|
public function ListDeclaredFullnameClassesFromPhpFile(string $sPath) : array
|
|
{
|
|
if (false !== strpos($sPath, 'autoload.php')){
|
|
return $this->ListDeclaredFullnameClassesFromAutoloadFile($sPath);
|
|
}
|
|
|
|
$aRes=[];
|
|
|
|
$sContent = file_get_contents($sPath);
|
|
|
|
$sNamespace='';
|
|
if (preg_match('|namespace (.*)[ ]*;|', $sContent, $aMatches)){
|
|
$sNamespace=trim($aMatches[1]) . '\\';
|
|
}
|
|
|
|
|
|
if (preg_match_all('|^class ([a-zA-Z]*) |m', $sContent, $aMatches)){
|
|
foreach($aMatches[1] as $sClass){
|
|
$aRes[]=$sNamespace.$sClass;
|
|
}
|
|
}
|
|
|
|
if (preg_match_all('|^interface ([a-zA-Z]*)|m', $sContent, $aMatches)){
|
|
foreach($aMatches[1] as $sInterface){
|
|
$aRes[]=$sNamespace.$sInterface;
|
|
}
|
|
}
|
|
|
|
return $aRes;
|
|
}
|
|
|
|
/**
|
|
* Read declared classes/interfaces autoload file
|
|
*
|
|
* @param string : module file path
|
|
*
|
|
* @return array: list of fullname classes
|
|
*/
|
|
private function ListDeclaredFullnameClassesFromAutoloadFile(string $sPath) : array
|
|
{
|
|
$sAutoloadClassMap = dirname($sPath) . "/composer/autoload_classmap.php";
|
|
//echo $sAutoloadClassMap . '\n';
|
|
if (!is_file($sAutoloadClassMap)) {
|
|
return [];
|
|
}
|
|
|
|
$sTempfile = tempnam(sys_get_temp_dir(), 'autoload_');
|
|
$sContent = file_get_contents($sAutoloadClassMap);
|
|
$sReplace=<<<TXT
|
|
\$aModuleFiles=
|
|
TXT;
|
|
$sContent = preg_replace('|return|', $sReplace, $sContent);
|
|
//var_dump($sContent);
|
|
file_put_contents($sTempfile, $sContent);
|
|
require_once $sTempfile;
|
|
@unlink($sTempfile);
|
|
|
|
$aRes=[];
|
|
foreach (array_keys($aModuleFiles) as $sClass){
|
|
if (strpos($sClass, 'InstalledVersions')){
|
|
continue;
|
|
}
|
|
$aRes[]=$sClass;
|
|
}
|
|
return $aRes;
|
|
}
|
|
}
|
|
|
|
|