GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r609:7c40e9303976

Some minor improvements on plugin loading:...

jeandet -

r609:7c40e9303976

parent child

Context file:

r609:7c40e9303976

app/src/Main.cpp +20 -19

             /*------------------------------------------------------------------------------
             -- This file is a part of the QLop Software
             -- Copyright (C) 2015, Plasma Physics Laboratory - CNRS
             --
             -- This program is free software; you can redistribute it and/or modify
             -- it under the terms of the GNU General Public License as published by
             -- the Free Software Foundation; either version 2 of the License, or
             -- (at your option) any later version.
             --
             -- This program 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 General Public License for more details.
             --
             -- You should have received a copy of the GNU General Public License
             -- along with this program; if not, write to the Free Software
             -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
             -------------------------------------------------------------------------------*/
             /*-- Author : Alexis Jeandet
             -- Mail : alexis.jeandet@member.fsf.org
             ----------------------------------------------------------------------------*/
             #include "MainWindow.h"
             #include <QProcessEnvironment>
             #include <QThread>
             #include <SqpApplication.h>
             #include <qglobal.h>
             #include <Plugin/PluginManager.h>
             #include <QDir>
             #include <QLoggingCategory>
             Q_LOGGING_CATEGORY(LOG_Main, "Main")
             namespace {
-            /// Name of the directory containing the plugins
-            #if _WIN32 || _WIN64
             const auto PLUGIN_DIRECTORY_NAME = QStringLiteral("plugins");
-            #endif
             } // namespace
             int main(int argc, char *argv[])
             {
                 SqpApplication a{argc, argv};
                 SqpApplication::setOrganizationName("LPP");
                 SqpApplication::setOrganizationDomain("lpp.fr");
                 SqpApplication::setApplicationName("SciQLop");
                 MainWindow w;
                 w.show();
                 // Loads plugins
-                auto pluginDir = QDir{sqpApp->applicationDirPath()};
+                auto pluginDir = QDir{a.applicationDirPath()};
+                auto pluginLookupPath = {
+                    a.applicationDirPath(),
+                    a.applicationDirPath() + "/" + PLUGIN_DIRECTORY_NAME,
+                    a.applicationDirPath() + "/../lib64/SciQlop",
+                    a.applicationDirPath() + "/../lib64/sciqlop",
+                    a.applicationDirPath() + "/../lib/SciQlop",
+                    a.applicationDirPath() + "/../lib/sciqlop",
+                    a.applicationDirPath() + "/../plugins",
+                };
             #if _WIN32 || _WIN64
                 pluginDir.mkdir(PLUGIN_DIRECTORY_NAME);
                 pluginDir.cd(PLUGIN_DIRECTORY_NAME);
             #endif
+                PluginManager pluginManager{};
-            #if __unix || __APPLE
+                for (auto &&path : pluginLookupPath) {
-            #if __x86_64__ || __ppc64__
+                    QDir directory{path};
-                if (!pluginDir.cd("../lib64/SciQlop")) {
+                    if (directory.exists()) {
-                    pluginDir.cd("../lib64/sciqlop");
+                        qCDebug(LOG_Main())
+                            << QObject::tr("Plugin directory: %1").arg(directory.absolutePath());
+                        pluginManager.loadPlugins(directory);
+                    }
                 }
-            #else
-                if (!pluginDir.cd("../lib/SciQlop")) {
-                    pluginDir.cd("../lib/sciqlop");
-            #endif
-            #endif
-                qCDebug(LOG_Main()) << QObject::tr("Plugin directory: %1").arg(pluginDir.absolutePath());
-                PluginManager pluginManager{};
-                pluginManager.loadPlugins(pluginDir);
                 return a.exec();
             }

core/src/Plugin/PluginManager.cpp +9 -3

             #include <Plugin/PluginManager.h>
             #include <Plugin/IPlugin.h>
             #include <QDir>
             #include <QLibrary>
             #include <QPluginLoader>
             Q_LOGGING_CATEGORY(LOG_PluginManager, "PluginManager")
             namespace {
             /// Key for retrieving metadata of the plugin
             const auto PLUGIN_METADATA_KEY = QStringLiteral("MetaData");
             /// Key for retrieving the name of the plugin in its metadata
             const auto PLUGIN_NAME_KEY = QStringLiteral("name");
             /// Helper to state the plugin loading operation
             struct LoadPluginState {
                 explicit LoadPluginState(const QString &pluginPath)
                         : m_PluginPath{pluginPath}, m_Valid{true}, m_ErrorMessage{}
                 {
                 }
                 void log() const
                 {
                     if (m_Valid) {
                         qCDebug(LOG_PluginManager())
                             << QObject::tr("File '%1' has been loaded as a plugin").arg(m_PluginPath);
                     }
                     else {
                         qCWarning(LOG_PluginManager())
                             << QObject::tr("File '%1' can't be loaded as a plugin: %2")
                                    .arg(m_PluginPath)
                                    .arg(m_ErrorMessage);
                     }
                 }
                 void setError(const QString &errorMessage)
                 {
                     m_Valid = false;
                     m_ErrorMessage = errorMessage;
                 }
                 QString m_PluginPath;
                 bool m_Valid;
                 QString m_ErrorMessage;
             };
             } // namespace
             struct PluginManager::PluginManagerPrivate {
                 /**
                  * Loads a single plugin into SciQlop. The method has no effect if the plugin is malformed (e.g.
                  * wrong library type, missing metadata, etc.)
                  * @param pluginPath the path to the plugin library.
                  */
                 void loadPlugin(const QString &pluginPath)
                 {
                     qCDebug(LOG_PluginManager())
                         << QObject::tr("Attempting to load file '%1' as a plugin").arg(pluginPath);
                     LoadPluginState loadState{pluginPath};
                     if (QLibrary::isLibrary(pluginPath)) {
                         QPluginLoader pluginLoader{pluginPath};
                         // Retrieving the plugin name to check if it can be loaded (i.e. no plugin with the same
                         // name has been registered yet)
                         auto metadata = pluginLoader.metaData().value(PLUGIN_METADATA_KEY).toObject();
                         auto pluginName = metadata.value(PLUGIN_NAME_KEY).toString();
                         if (pluginName.isEmpty()) {
                             loadState.setError(QObject::tr("empty file name"));
                         }
                         else if (m_RegisteredPlugins.contains(pluginName)) {
                             loadState.setError(QObject::tr("name '%1' already registered").arg(pluginName));
                         }
                         else {
                             if (auto pluginInstance = qobject_cast<IPlugin *>(pluginLoader.instance())) {
                                 pluginInstance->initialize();
                                 m_RegisteredPlugins.insert(pluginName, pluginPath);
                             }
                             else {
                                 loadState.setError(QObject::tr("the file is not a Sciqlop plugin"));
                             }
                         }
                     }
                     else {
                         loadState.setError(QObject::tr("the file is not a library"));
                     }
                     // Log loading result
                     loadState.log();
                 }
                 /// Registered plugins (key: plugin name, value: plugin path)
                 QHash<QString, QString> m_RegisteredPlugins;
             };
             PluginManager::PluginManager() : impl{spimpl::make_unique_impl<PluginManagerPrivate>()}
             {
             }
             void PluginManager::loadPlugins(const QDir &pluginDir)
             {
                 // Load plugins
-                auto pluginInfoList = pluginDir.entryInfoList(QDir::Files, QDir::Name);
+                auto pluginInfoList
-                for (auto pluginInfo : qAsConst(pluginInfoList)) {
+                    = pluginDir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
-                    impl->loadPlugin(pluginInfo.absoluteFilePath());
+                for (auto entryInfo : qAsConst(pluginInfoList)) {
+                    if (entryInfo.isDir())
+                        this->loadPlugins(QDir{entryInfo.absoluteFilePath()});
+                    else {
+                        if (QLibrary::isLibrary(entryInfo.absoluteFilePath()))
+                            impl->loadPlugin(entryInfo.absoluteFilePath());
+                    }
                 }
             }
             int PluginManager::nbPluginsLoaded() const noexcept
             {
                 return impl->m_RegisteredPlugins.size();
             }

plugins/amda/meson.build +4 -1

             amdaplugin_moc_headers = [
               'include/AmdaPlugin.h'
             ]
             amdaplugin_sources = [
               'src/AmdaDefs.cpp',
               'src/AmdaParser.cpp',
               'src/AmdaPlugin.cpp',
               'src/AmdaProvider.cpp',
               'src/AmdaResultParser.cpp'
             ]
             amdaplugin_ui_files = []
             amdaplugin_resources_files = [
               'resources/amdaresources.qrc'
             ]
             amdaplugin_inc = include_directories(['include', '../../plugin/include'])
             moc_gen = generator(moc,
                             output  : 'moc_@BASENAME@.cpp',
                             arguments : ['@INPUT@',
                              '-DPLUGIN_JSON_FILE_PATH="'+meson.source_root()+'/plugins/amda/resources/amda.json"',
                              '-I', meson.current_source_dir()+'/include',
                              '-I', meson.current_source_dir()+'/../../plugin/include',
                              '-o', '@OUTPUT@'])
             rcc_gen = generator(rcc,
                             output  : 'qrc_@BASENAME@.cpp',
                             arguments : ['--name=@BASENAME@"',
                              '--output',
                              '@OUTPUT@',
                              '@INPUT@'])
             amdaplugin_moc_plugin_files = moc_gen.process(amdaplugin_moc_headers)
             amdaplugin_rcc_plugin_files = rcc_gen.process(amdaplugin_resources_files)
+            #amdaplugin_rcc_plugin_files = qt5.preprocess(
+            #                               qresources : amdaplugin_resources_files)
             amdaplugin_moc_files = qt5.preprocess(
                                            ui_files : amdaplugin_ui_files)
             sciqlop_amdaplugin = library('amdaplugin',
                                    amdaplugin_sources,
                                    amdaplugin_moc_files,
                                    amdaplugin_rcc_plugin_files,
                                    amdaplugin_moc_plugin_files,
-                                   cpp_args : '-DAMDA_LIB',
+                                   cpp_args : ['-DAMDA_LIB','-DQT_PLUGIN'],
                                    link_with : [sciqlop_core, sciqlop_gui],
                                    include_directories : [amdaplugin_inc, core_inc, gui_inc],
                                    dependencies : [qt5core, qt5gui, qt5widgets, qt5network],
                                    install : true
                                    )
             tests = [
               [['tests/TestAmdaParser.cpp'],'test_amda_parser','AMDA parser test'],
               [['tests/TestAmdaResultParser.cpp'],'test_amda_result_parser','AMDA result parser test'],
               [['tests/TestAmdaAcquisition.cpp'],'test_amda_acquisition','AMDA Acquisition test']
             ]
             foreach unit_test : tests
               test_moc_files = qt5.preprocess(moc_sources : unit_test[0])
               test_exe = executable(unit_test[1],unit_test[0] , test_moc_files,
                                       link_with : [sciqlop_core, sciqlop_amdaplugin, sciqlop_gui],
                                       include_directories : [core_inc, amdaplugin_inc, gui_inc],
                                       cpp_args : ['-DAMDA_TESTS_RESOURCES_DIR="'+meson.current_source_dir()+'/tests-resources"'],
                                       dependencies : [qt5core, qt5widgets, qt5network,qt5test])
               test(unit_test[2], test_exe, args: ['-teamcity', '-o', '@0@.teamcity.txt'.format(unit_test[1])], timeout: 3 * 60)
             endforeach

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages