Merge pull request #732 from QuasarApp/task_731

Ignore symLinks for seacrhing qmake

src/Deploy/src/configparser.cpp

@@ -753,6 +753,10 @@ bool ConfigParser::parseDeployMode(bool checkBin) {
         return false;
     }
 
+    QuasarAppUtils::Params::log(
+        _config.qtDir.toString(),
+        QuasarAppUtils::Debug);
+
     if (!initQmlInput()) {
         return false;
     }
@@ -1134,26 +1138,61 @@ QString ConfigParser::getPathFrmoQmakeLine(const QString &in) const {
 bool ConfigParser::initQmakePrivate(const QString &qmake) {
     QFileInfo info(qmake);
 
+    QuasarAppUtils::Params::log("initialize qmake for.  " + info.absoluteFilePath(),
+                                QuasarAppUtils::Debug);
+
     QString basePath = info.absolutePath();
-    if (!setQmake(qmake)) {
-        QDir dir(basePath);
 
-        if (!dir.cdUp()) {
-            QuasarAppUtils::Params::log("Failed to initialize qt directories by qmake.",
+    // Invoke qmake executable only when qmake paths exclude snapRootFS path.
+    // Because files in snapRootFS is not executable ...
+    if (!qmake.contains(DeployCore::snapRootFS()) && setQmake(qmake)) {
+        return true;
+    }
+
+
+    // try deploy qt using only read FS permisions
+
+    // check debian qt structure
+    if (DeployCore::isDebianQt(info.absoluteFilePath())) {
+        // initialize qt that was installed from apt package manager on any debian based os
+        QString neededPlatform = DeployCore::getPlatformLibPrefix(_config.getPlatformOfAll());
+        int qtVersion = DeployCore::qtVersionToString(_config.isNeededQt());
+
+        QString debianQtRoot = QString("/usr/lib/%0/qt%1").
+                               arg(neededPlatform).arg(qtVersion);
+
+        if (DeployCore::isSnap()) {
+            debianQtRoot = DeployCore::snapRootFS() + debianQtRoot;
+        }
+
+        if (!setQtDir(debianQtRoot)) {
+            QuasarAppUtils::Params::log("Failed to initialize Qt directories",
                                         QuasarAppUtils::Error);
             return false;
         }
+
+        return true;
+    }
+    // initialize qt that was installed from qt installer or aqtinstall package manager
+    QDir dir(basePath);
+
+    if (!dir.cdUp()) {
+        QuasarAppUtils::Params::log("Failed to initialize qt directories by qmake.",
+                                    QuasarAppUtils::Error);
+        return false;
+    }
 
+    // For snap package of cqtdeplyer it is normal behavior
+    if (!DeployCore::isSnap()) {
         QuasarAppUtils::Params::log("Failed to execute the qmake process!"
                                     " Trying to initialize Qt directories from path: " + dir.absolutePath(),
                                     QuasarAppUtils::Warning);
+    }
 
-        if (!setQtDir(dir.absolutePath())){
-            QuasarAppUtils::Params::log("Failed to initialize Qt directories",
-                                        QuasarAppUtils::Error);
-            return false;
-        }
-
+    if (!setQtDir(dir.absolutePath())){
+        QuasarAppUtils::Params::log("Failed to initialize Qt directories",
+                                    QuasarAppUtils::Error);
+        return false;
     }
 
     return true;
@@ -1268,6 +1307,9 @@ bool ConfigParser::setQmake(const QString &value) {
         }
     }
 
+    if (_config.qtDir.getLibs().isEmpty())
+        return false;
+
     _config.envirement.addEnv(_config.qtDir.getLibs());
     _config.envirement.addEnv(_config.qtDir.getBins());
 
@@ -1278,17 +1320,25 @@ bool ConfigParser::setQtDir(const QString &value) {
 
     QFileInfo info(value);
 
+    QuasarAppUtils::Params::log("initialize qt dirs for. " + info.absoluteFilePath(),
+                                QuasarAppUtils::Debug);
+
     if (!QFile::exists(info.absoluteFilePath() + ("/bin"))) {
         QuasarAppUtils::Params::log("get qt bin failed!", QuasarAppUtils::Debug);
         return false;
     }
     _config.qtDir.setBins(info.absoluteFilePath() + ("/bin"));
 
-    if (!QFile::exists(info.absoluteFilePath() + ("/lib"))) {
-        QuasarAppUtils::Params::log("get qt lib failed!", QuasarAppUtils::Debug);
-        return false;
+    if (DeployCore::isDebianQt(value)) {
+        _config.qtDir.setLibs(info.absolutePath());
+    } else {
+        if (!QFile::exists(info.absoluteFilePath() + ("/lib"))) {
+            QuasarAppUtils::Params::log("get qt lib failed!", QuasarAppUtils::Debug);
+            return false;
+        }
+        _config.qtDir.setLibs(info.absoluteFilePath() + ("/lib"));
     }
-    _config.qtDir.setLibs(info.absoluteFilePath() + ("/lib"));
+
 
     if (!QFile::exists(info.absoluteFilePath() + ("/qml"))) {
         QuasarAppUtils::Params::log("get qt qml failed!", QuasarAppUtils::Debug);
@@ -1312,10 +1362,15 @@ bool ConfigParser::setQtDir(const QString &value) {
         _config.qtDir.setLibexecs(info.absoluteFilePath() + ("/bin"));
     }
 
-    if (!QFile::exists(info.absoluteFilePath() + ("/translations"))) {
-        QuasarAppUtils::Params::log("get qt translations failed!", QuasarAppUtils::Debug);
+    if (DeployCore::isDebianQt(value)) {
+        _config.qtDir.setTranslations(QString("/usr/share/qt%0/translations").
+                                      arg(DeployCore::qtVersionToString(_config.isNeededQt())));
     } else {
-        _config.qtDir.setTranslations(info.absoluteFilePath() + ("/translations"));
+        if (!QFile::exists(info.absoluteFilePath() + ("/translations"))) {
+            QuasarAppUtils::Params::log("get qt translations failed!", QuasarAppUtils::Debug);
+        } else {
+            _config.qtDir.setTranslations(info.absoluteFilePath() + ("/translations"));
+        }
     }
 
     if (!QFile::exists(info.absoluteFilePath() + ("/resources"))) {

src/Deploy/src/deploycore.cpp

@@ -603,6 +603,9 @@ QString DeployCore::getAppVersion() {
 }
 
 QString DeployCore::getAppVersionName() {
+    if (isSnap()) {
+        return "*** Cool Core (snap) ***";
+    }
     return "*** Cool Core ***";
 }
 
@@ -633,11 +636,16 @@ bool DeployCore::isContainsArraySeparators(const QString &val, int lastLvl) {
     return false;
 }
 
-QString DeployCore::findProcess(const QString &env, const QString& proc) {
+QString DeployCore::findProcess(const QString &env, const QString& proc, bool ignoreSymLinks) {
     auto list = env.split(DeployCore::getEnvSeparator());
 
+    auto findEntries = QDir::NoDotAndDotDot | QDir::Files;
+    if (ignoreSymLinks) {
+        findEntries = findEntries | QDir::NoSymLinks;
+    }
+
     for (const auto& path : list) {
-        auto files = QDir(path).entryInfoList(QDir::NoDotAndDotDot | QDir::Files);
+        auto files = QDir(path).entryInfoList(findEntries);
 
         for (const auto& bin : files) {
             if (bin.baseName().compare(proc, DeployCore::getCaseSensitivity()) == 0 && bin.isExecutable()) {
@@ -649,7 +657,7 @@ QString DeployCore::findProcess(const QString &env, const QString& proc) {
     // working only for the snap version of cqtdeployer ...
     if (isSnap()) {
         for (const auto& path : list) {
-            auto files = QDir(transportPathToSnapRoot(path)).entryInfoList(QDir::NoDotAndDotDot | QDir::Files);
+            auto files = QDir(transportPathToSnapRoot(path)).entryInfoList(findEntries);
 
             for (const auto& bin : files) {
                 if (bin.baseName().compare(proc, DeployCore::getCaseSensitivity()) == 0) {
@@ -918,7 +926,7 @@ QString DeployCore::platformToString(Platform platform) {
         {Platform::Win32, "win_x86"},
         {Platform::Win64, "win_x86_64"},
         {Platform::Win_ARM_32, "win_arm"},
-        {Platform::win_ARM_64, "win_arm64"},
+        {Platform::Win_ARM_64, "win_arm64"},
         {Platform::Unix_x86_32, "linux_x86"},
         {Platform::Unix_x86_64, "linux_x86_64"},
         {Platform::Unix_ARM_32, "linux_ARM"},
@@ -952,7 +960,7 @@ Platform DeployCore::getPlatformFromString(const QString &platformName) {
         {"win_x86", Platform::Win32},
         {"win_x86_64", Platform::Win64},
         {"win_arm", Platform::Win_ARM_32},
-        {"win_arm64", Platform::win_ARM_64},
+        {"win_arm64", Platform::Win_ARM_64},
         {"linux_x86", Platform::Unix_x86_32},
         {"linux_x86_64", Platform::Unix_x86_64},
         {"linux_ARM", Platform::Unix_ARM_32},
@@ -1057,7 +1065,49 @@ Qt::CaseSensitivity DeployCore::getCaseSensitivity(const QString &checkedFile) {
     }
 
     return Qt::CaseSensitive;
-};
+}
+
+
+
+QString DeployCore::getPlatformLibPrefix(Platform plarform) {
+
+    if (plarform & Platform::Unix_x86_64) {
+        return "x86_64-linux-gnu";
+    } else if (plarform & Platform::Unix_ARM_64) {
+        return "aarch64-linux-gnu";
+    } else if (plarform & Platform::Unix_x86_32) {
+        return "x86_32-linux-gnu";
+    } else if (plarform & Platform::Unix_ARM_32) {
+        return "arm-linux-gnu";
+    } else if (plarform & Platform::Win64) {
+        return "";
+    } else if (plarform & Platform::Win32) {
+        return "";
+    } else if (plarform & Platform::Win_ARM_64) {
+        return "";
+    } else if (plarform & Platform::Win_ARM_32) {
+        return "";
+    }
+
+    // not supported
+    return "";
+}
+
+int DeployCore::qtVersionToString(QtMajorVersion qtVersion) {
+    if (qtVersion & QtMajorVersion::Qt6) {
+        return 6;
+    } else if (qtVersion & QtMajorVersion::Qt5) {
+        return 5;
+    } else if (qtVersion & QtMajorVersion::Qt4) {
+        return 4;
+    }
+
+    return 0;
+}
+
+bool DeployCore::isDebianQt(const QString &qtRoot) {
+    return qtRoot.contains("/usr/lib/") || qtRoot.contains("/usr/bin");
+}
 
 QString DeployCore::systemLibsFolderName() {
     return "systemLibs";

src/Deploy/src/deploycore.h

@@ -48,7 +48,7 @@ enum Platform {
     Win32           = 0x0001,
     Win64           = 0x0002,
     Win_ARM_32      = 0x0004,
-    win_ARM_64      = 0x0008,
+    Win_ARM_64      = 0x0008,
     Win             = Win32 | Win64,
 
     // Unix
@@ -277,7 +277,7 @@ class DEPLOYSHARED_EXPORT DeployCore
     static bool isExecutable(const QFileInfo &file);
     static bool isContainsArraySeparators(const QString& val,
                                           int lastLvl = 2);
-    static QString findProcess(const QString& env, const QString& proc);
+    static QString findProcess(const QString& env, const QString& proc, bool ignoreSymLinks = false);
 
     static QStringList debugExtensions();
     static bool isDebugFile(const QString& file);
@@ -323,6 +323,27 @@ class DEPLOYSHARED_EXPORT DeployCore
      * @return Qt CaseSensitivity value
      */
     static Qt::CaseSensitivity getCaseSensitivity(const QString& checkedFile = "");
+
+    /**
+     * @brief getPlatformLibPrefix This method return string value of the @a platform
+     * @param plarform This is input platform
+     * @return string value of the @a platfrom. If platform not supported strings implementations the return empty string.
+     */
+    static QString getPlatformLibPrefix(Platform plarform);
+
+    /**
+     * @brief qtVersionToString return integer interpritation of the Qt major version
+     * @return integer implementation of major qt version.
+     * @note return 0 if the @a qtVersion is invalid
+     */
+    static int qtVersionToString(QtMajorVersion qtVersion);
+
+    /**
+     * @brief isDebianQt this method return true if the @a qtRoot is debian system qt.
+     * @param qtRoot path to qt root dir.
+     * @return true if the @a qtRoot is debian system qt else false.
+     */
+    static bool isDebianQt(const QString& qtRoot);
 };
 
 #define internalError() DeployCore::printInternalError(__FUNCTION__, __FILE__, __LINE__)

src/Deploy/src/envirement.cpp

@@ -8,7 +8,6 @@
 #include "deploycore.h"
 #include "envirement.h"
 #include "pathutils.h"
-#include "quasarapp.h"
 
 #include <QDir>
 #include <QFileInfo>

src/Deploy/src/pe_type.cpp

@@ -128,7 +128,7 @@ bool PE::getLibInfo(const QString &lib, LibInfo &info) const {
             info.setPlatform(Win_ARM_32);
 
         } else {
-            info.setPlatform(win_ARM_64);
+            info.setPlatform(Win_ARM_64);
         }
 
     } else if (parsedPeLib->peHeader.nt.FileHeader.Machine == peparse::IMAGE_FILE_MACHINE_I386 ||

src/Deploy/src/qtdir.cpp

@@ -12,6 +12,29 @@ QtMajorVersion QtDir::getQtVersion() const {
     return _qtVersion;
 }
 
+QString QtDir::toString() const {
+    return QString {
+        "Qt Inforamtion: \n"
+        "Platform: %0\n"
+        "Major version: %1\n"
+        "Binaries dir: %2\n"
+        "Libraries dir: %3\n"
+        "Libexecs dir: %4\n"
+        "Plugins dir: %5\n"
+        "QMLs dir: %6\n"
+        "Translations dir: %7\n"
+        "Resources dir: %8\n"
+    }.arg(DeployCore::platformToString(_platform),
+             QString::number(DeployCore::qtVersionToString(_qtVersion)),
+             bins,
+             libs,
+             libexecs,
+             plugins,
+             qmls,
+             translations,
+             resources);
+}
+
 QString QtDir::getLibs() const {
     return libs;
 }

src/Deploy/src/qtdir.h

@@ -9,10 +9,11 @@
 #define QTDIR_H
 
 #include <QDir>
+#include <humanreadableobject.h>
 #include "deploy_global.h"
 #include "deploycore.h"
 
-class DEPLOYSHARED_EXPORT QtDir {
+class DEPLOYSHARED_EXPORT QtDir: QuasarAppUtils::iHRO {
     QString libs;
     QString bins;
     QString libexecs;
@@ -53,6 +54,8 @@ class DEPLOYSHARED_EXPORT QtDir {
      * @return the masjor version of qt
      */
     QtMajorVersion getQtVersion() const;
+
+    QString toString() const override;
 };
 
 #endif // QTDIR_H