Build system mk2 (#71)

* New docker build system

* Add more images

* Improve build, more refactorings

* Fix DLL loading on Windows

* WS

* stop copying files into docker images, just use the source directory

* Better CLI for docker.py

* Flush stdout while running command

Author: GuLinux

cmake/options.cmake

@@ -1,5 +1,5 @@
 # Enable fPIC (Default: ON)
-option(cflags_fpic "Use -fPIC for compilation " on)
+option(cflags_fpic "Use -fPIC for compilation " On)
 if(cflags_fpic)
   message("Compiling with -fPIC")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
@@ -8,15 +8,6 @@ if(WIN32)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mno-ms-bitfields")
 endif()
 
-# Extra options for cmake in an external file
-set(CMAKE_INCLUDE_EXT_FILE CACHE INTERNAL "Per-environment include file")
-if(CMAKE_INCLUDE_EXT_FILE)
-  message("Using cmake environment: ${CMAKE_INCLUDE_EXT_FILE}")
-  include(${CMAKE_INCLUDE_EXT_FILE})
-else()
-  message("CMake environment file ${CMAKE_INCLUDE_EXT_FILE} NOT found")
-endif()
-
 # Extra libraries
 SET(EXTRA_LIBRARIES "" CACHE STRING "Extra libraries for linking")
 message("Extra libraries for linking: ${EXTRA_LIBRARIES}")
@@ -40,3 +31,4 @@ endif()
 
 # Extra executables to be built
 option(build_network_server "Build PlanetaryImager network daemon and frontend" On)
+

packaging.cmake

@@ -1,6 +1,7 @@
 set(PACKAGE_VERSION_SUFFIX "" CACHE STRING "Suffix package version (default: empty)")
 set(PACKAGE_NAME_SUFFIX "" CACHE STRING "Suffix package name (default: empty)")
 
+set(PACKAGE_SYSTEM_NAME ${CMAKE_SYSTEM_NAME} CACHE STRING "System name for generated packages (default: ${CMAKE_SYSTEM_NAME}")
 
 INCLUDE(InstallRequiredSystemLibraries)
 SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "GuLinux.net Planetary Imager for Linux")
@@ -10,7 +11,7 @@ SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/README.md")
 SET(CPACK_PACKAGE_VERSION_MAJOR "${MAJOR_VERSION}")
 SET(CPACK_PACKAGE_VERSION_MINOR "${MINOR_VERSION}")
 SET(CPACK_PACKAGE_VERSION_PATCH "${PATCH_VERSION}")
-set(CPACK_PACKAGE_FILE_NAME PlanetaryImager-${FULL_VERSION}-${CMAKE_SYSTEM_NAME}-${PlanetaryImager_ARCH}${PACKAGE_NAME_SUFFIX})
+set(CPACK_PACKAGE_FILE_NAME PlanetaryImager-${FULL_VERSION}-${PACKAGE_SYSTEM_NAME}-${PlanetaryImager_ARCH}${PACKAGE_NAME_SUFFIX})
 SET(CPACK_PACKAGE_CONTACT "marco@gulinux.net")
 #SET(CPACK_STRIP_FILES "bin/planetary_imager")
 

src/CMakeLists.txt

@@ -2,6 +2,9 @@ set(PlanetaryImager_GUI_SRCS planetaryimager_mainwindow.cpp planetaryimager_main
 set(PlanetaryImager_SRCS planetaryimager_main.cpp ${PlanetaryImager_GUI_SRCS})
 
 
+if(static_qt_windows)
+add_definitions(-DSTATIC_WINDOWS_PLUGIN)
+endif()
 
 set(drivers_destination lib/${CMAKE_PROJECT_NAME}/drivers)
 set(binary_destination bin)

src/commons/loghandler.cpp

@@ -25,6 +25,8 @@
 #include <QFileInfo>
 #include <QDir>
 #include "commons/commandline.h"
+#include <QMutex>
+#include <QMutexLocker>
 
 using namespace std;
 using namespace std::placeholders;
@@ -53,6 +55,8 @@ QHash<QtMsgType, string> LogHandler::log_levels()
 
 void LogHandler::Private::log_handler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 {
+  static QMutex log_mutex;
+  
   static QHash<QtMsgType, int> priority {
     {QtFatalMsg   , 10},
     {QtCriticalMsg, 20},
@@ -70,6 +74,7 @@ void LogHandler::Private::log_handler(QtMsgType type, const QMessageLogContext &
       position = QString("%1:%2").arg(context.file).arg(context.line).replace(SRC_DIR, "");
     }
     QString function = context.function ? context.function : "";
+    QMutexLocker lock(&log_mutex);
     output.stream.get() << setw(8) << LogHandler::log_levels()[type] << " - " /*<< qPrintable(position) << "@"*/<< qPrintable(function) << " " << qPrintable(msg) << endl;
     output.stream.get().flush();
   }

src/drivers/driver.h

@@ -40,13 +40,15 @@ class Driver : public QObject {
 typedef QList<Driver::ptr> Drivers;
 typedef Driver *(*LoadDriverFunction)();
 
+
+#define PLANETARY_IMAGER_DRIVER_LOAD_F "PlanetaryImager_loadDriver"
+
 #ifdef Q_OS_WIN
-#define EXPORT_DECL __declspec(dllexport)
+#define DECL_EXPORT Q_DECL_EXPORT
 #else
-#define EXPORT_DECL
+#define DECL_EXPORT
 #endif
-
-#define PLANETARY_IMAGER_DRIVER_LOAD_F "PlanetaryImager_loadDriver"
-#define DECLARE_DRIVER_PLUGIN_INIT(DriverClass) extern "C" EXPORT_DECL Driver *PlanetaryImager_loadDriver() { return new DriverClass(); }
+#define DECLARE_DRIVER_PLUGIN_INIT(DriverClass) \
+extern "C" DECL_EXPORT Driver *PlanetaryImager_loadDriver() { return new DriverClass(); }
 
 #endif

src/drivers/simulator/simulatordriver.cpp

@@ -54,12 +54,14 @@ Driver::Cameras SimulatorDriver::cameras() const
     make_shared<SimulatorCamera>("Simulator: Planet", [](const ImageHandler::ptr& imageHandler){ return new SimulatorImager(imageHandler); }),
     make_shared<SimulatorCamera>("Simulator: SER file", [](const ImageHandler::ptr& imageHandler){ return new SERImager(imageHandler); }),
   };
+  qDebug() << "(Simulator) Loaded cameras: " << _cameras.size();
   return _cameras;
 }
 
 
 SimulatorDriver::SimulatorDriver()
 {
+  qDebug() << "(Simulator) Initialising";
   Q_INIT_RESOURCE(simulator);
 }
 

src/drivers/supporteddrivers.cpp

@@ -28,14 +28,43 @@
 
 using namespace std;
 
+struct SupportedDriver {
+  typedef shared_ptr<SupportedDriver> ptr;
+  SupportedDriver(const QString &name, const QVariantMap &info, const shared_ptr<QLibrary> &library) : name(name), info(info), library(library) {}
+    QString name;
+    QVariantMap info;
+    shared_ptr<QLibrary> library;
+    shared_ptr<Driver> _driver;
+    shared_ptr<Driver> driver();
+};
+
+typedef int (*LoadDriverFunctionReady)();
+
+
+std::shared_ptr<Driver> SupportedDriver::driver()
+{
+  if(!_driver) {
+    qDebug() << "Initializing driver" << library->fileName();
+    try {
+      Driver *driverptr = ((LoadDriverFunction) library->resolve(PLANETARY_IMAGER_DRIVER_LOAD_F))();
+      qDebug() << "Loaded driver address: " << (uint64_t)driverptr;
+      _driver = shared_ptr<Driver>(driverptr);
+    } catch(const Imager::exception &e) {
+      qWarning() << "Error loading driver: " << e.what();
+    }
+  }
+  qDebug() << "Driver loaded: " << !!_driver;
+  return _driver;
+}
+
+
+
 DPTR_IMPL(SupportedDrivers) {
   SupportedDrivers *q;
-  QList<shared_ptr<QLibrary>> drivers;
+  QList<SupportedDriver::ptr> supported_drivers;
 
   void find_drivers(const QString &directory);
   void load_driver(const QString &filename);
-  list<Driver*> instances();
-  list<Driver*> _instances;
 };
 
 
@@ -71,13 +100,21 @@ void SupportedDrivers::Private::load_driver(const QString& filename)
   if(driver->load()) {
     qDebug() << "[OK] Driver " << library_name << " loaded successfully";
     if(driver->resolve(PLANETARY_IMAGER_DRIVER_LOAD_F)) {
+        QFile json_file(filename);
+        json_file.open(QIODevice::ReadOnly);
+        QVariantMap driver_info = QJsonDocument::fromJson(json_file.readAll()).toVariant().toMap();
+        
         qDebug() << "[OK] PlanetaryImager_loadDriver resolved on " << library_name;
-        drivers.push_back(driver);
+        supported_drivers.push_back(make_shared<SupportedDriver>(
+          QFileInfo(library_name).baseName(),
+          driver_info,
+          driver
+        ));
     } else {
-        qWarning() << "[ERR] Error resolving PlanetaryImager_loadDriver function on " << library_name;
+        qWarning() << "[ERR] Error resolving PlanetaryImager_loadDriver function on " << library_name << ":" << driver->errorString();
     }
   } else {
-    qWarning() << "[ERR] Error loading driver: " << library_name;
+    qWarning() << "[ERR] Error loading driver" << library_name << ":" << driver->errorString();
   }
 }
 
@@ -88,37 +125,29 @@ SupportedDrivers::~SupportedDrivers()
 
 void SupportedDrivers::aboutToQuit()
 {
-  for(auto driver: d->instances())
-    driver->aboutToQuit();
+  for(auto supported_driver: d->supported_drivers)
+    if(supported_driver->driver()) {
+      supported_driver->driver()->aboutToQuit();
+    } 
 }
 
 
 Driver::Cameras SupportedDrivers::cameras() const
 {
   qDebug() << "Detecting active cameras";
   Cameras cameras;
-  for(auto driver: d->instances()) {
-    if(driver)
-      cameras.append(driver->cameras());
+  for(auto supported_driver: d->supported_drivers) {
+    qDebug() << "Checking cameras on driver " << supported_driver->name;
+    if(supported_driver->driver()) {
+      auto driver_cameras = supported_driver->driver()->cameras();
+      qDebug() << "Found" << driver_cameras.size() << "on driver" << supported_driver->name;
+      cameras.append(driver_cameras);
+    } else {
+      qWarning() << "Driver" << supported_driver->name << "doesn't seem to be correctly loaded";
+    }
   }
   qDebug() << "Detected cameras: " << cameras.size();
   return cameras;
 }
 
-list<Driver *> SupportedDrivers::Private::instances()
-{
-  if(_instances.size() == 0) {
-    qDebug() << "Initialising driver instances";
-    transform(begin(drivers), end(drivers), back_inserter(_instances), [](const auto &p) -> Driver* {
-      qDebug() << "Initializing driver" << p->fileName();
-      try {
-        auto driver_load_function = (LoadDriverFunction) p->resolve(PLANETARY_IMAGER_DRIVER_LOAD_F);
-        return qobject_cast<Driver*>(driver_load_function());
-      } catch(const Imager::exception &e) {
-        qWarning() << "Error loading driver: " << e.what();
-        return nullptr;
-      }
-    });
-  }
-  return _instances;
-}
+

src/drivers/zwo_asi/zwo_asi_driver.cpp

@@ -56,24 +56,23 @@ ZWO_ASI_Driver::ZWO_ASI_Driver() : dptr(this)
     metatypes_registered = true;
     qRegisterMetaType<ASI_IMG_TYPE>("ASI_IMG_TYPE");
   }
-  qDebug() << "ZWO ASI Driver initialised";
+  qInfo() << "(ASI) Driver initialised, version " << ASIGetSDKVersion();
 }
 
 ZWO_ASI_Driver::~ZWO_ASI_Driver()
 {
-
 }
 
 Driver::Cameras ZWO_ASI_Driver::cameras() const
 {
   int ncams = ASIGetNumOfConnectedCameras();
-  qDebug() << "ZWO AI Driver: detected" << ncams << "cameras";
+  qDebug() << "(ASI) Driver: detected" << ncams << "cameras";
   Driver::Cameras cameras;
   int index=0;
   for(int index=0; index<ncams; index++) {
     ASI_CAMERA_INFO info;
     ASI_CHECK << ASIGetCameraProperty(&info, index) << string{"Get Camera Property"};
-    qDebug() << "ZWO camera index" << index << "is a" << info.Name;
+    qDebug() << "(ASI) camera index" << index << "is a" << info.Name;
     cameras.push_back(make_shared<ZWO_ASI_Camera>(info));
   }
   return cameras;

src/planetaryimager.cpp

@@ -23,6 +23,13 @@
 #include <QThread>
 #include <QTimer>
 
+#ifdef STATIC_WINDOWS_PLUGIN
+#pragma message("Initializing Qt static plugins")
+#include <QtPlugin>
+Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)
+#endif
+
+
 DPTR_IMPL(PlanetaryImager) {
   Driver::ptr driver;
   ImageHandler::ptr imageHandler;
@@ -43,6 +50,7 @@ PlanetaryImager::PlanetaryImager(
   Configuration &configuration
 ) : QObject{}, dptr(driver, imageHandler, saveImages, configuration, this)
 {
+  QThreadPool::globalInstance()->setMaxThreadCount(std::max(5, QThread::idealThreadCount()));
   d->initDevicesWatcher();
 }