Initial commit

Lts/Services/ServiceManagement/main_handler.cpp

@@ -0,0 +1,202 @@
+/**
+  * MainHandler for ServiceManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Baeuerle, SLSE, 15.02.2016
+  */
+
+#include "main_handler.h"
+#include "licence_handler.h"
+
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QDirIterator>
+#include <QtCore/QFile>
+#include <QtCore/QXmlStreamReader>
+#include <ngltools/ngltools_filesystem.h>
+#include <nglapplication/nglsinglecoreapplication.h>
+
+#include <CodeGen/XmlReader.h>
+
+#include "service.h"
+
+namespace ServiceManagement
+{
+
+MainHandler::MainHandler(QObject *parent)
+  : QObject(parent)
+  , m_ddsHandler(nullptr)
+  , m_groupHandler(nullptr)
+  , m_licenceHandler(nullptr)
+  , m_serviceHandler(nullptr)
+  , m_websocketHandler(nullptr)
+  , m_logger(getLogger("MainHandler"))
+{
+  QtSingleCoreApplication *sa = qobject_cast<QtSingleCoreApplication*>(QCoreApplication::instance());
+  Q_ASSERT(sa);
+  connect(sa, &QtSingleCoreApplication::messageReceived,
+          this, &MainHandler::onMessageFromCommandlineReceived);
+}
+
+MainHandler::~MainHandler()
+{
+  m_websocketHandler = nullptr;
+  m_groupHandler = nullptr;
+  m_serviceHandler = nullptr;
+  m_licenceHandler = nullptr;
+  m_ddsHandler = nullptr;
+}
+
+bool MainHandler::init(int domainId, const QString &licenceFile)
+{
+  DEBUG_LOG(m_logger) << "Initializing MainHandler ...";
+
+  m_ddsHandler = std::make_shared<DdsHandler>(domainId);
+  bool bAllPartsInitialized = m_ddsHandler->init();
+
+  ERROR_LOG(m_logger) << "Searching for licence file: " << licenceFile;
+  QString licenceFileName = NGL::findFile(NGL::FileType::ConfigFile, licenceFile);
+
+  m_licenceHandler = std::make_shared<LicenceHandler>(m_ddsHandler, licenceFileName);
+  if (!m_licenceHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Initialisation LicenceHandler failed.";
+    return false;
+  }
+
+  m_serviceHandler = std::make_shared<ServiceHandler>(m_ddsHandler, m_licenceHandler);
+  m_groupHandler = std::make_shared<GroupHandler>(m_ddsHandler, m_serviceHandler);
+
+  bAllPartsInitialized &=
+    m_serviceHandler->init() &&
+    readServices() &&
+    m_groupHandler->init(domainId);
+
+  if (bAllPartsInitialized)
+  {  
+    // WebSocketServer
+    m_websocketHandler =  std::make_shared<WebSocketInterface::WebSocketInterfaceHandler>(this);
+    if (!m_websocketHandler->init())
+    {
+      ERROR_LOG(m_logger) << "Initialisation WebSocketInterfaceHandler failed.";
+      return false;
+    }
+
+    DEBUG_LOG(m_logger) << "MainHandler successfully initialized :)";
+  }
+  else
+  {
+    ERROR_LOG(m_logger) << "MainHandler initialization failed";
+  }
+
+  return bAllPartsInitialized;
+}
+
+std::shared_ptr<GroupHandler> MainHandler::groupHandler() const
+{
+  return m_groupHandler;
+}
+
+bool MainHandler::readServices()
+{
+  CodeGen::XmlReader xmlReader;
+  const QString xmlPath = NGL::directory(NGL::FileType::ConfigFile, QLatin1String("xml"));
+  DEBUG_LOG(m_logger) << "Using xml path " << xmlPath;
+  QDirIterator directoryIterator(xmlPath);
+  int serviceCount = 0;
+
+  // TODO: make generic ... will be implemented in a future core library
+  QMap<QString, Core::ServiceGroupType_def::type> groupNameMapping;
+  groupNameMapping.insert(QLatin1String("Master"), Core::ServiceGroupType_def::Master);
+  groupNameMapping.insert(QLatin1String("Core"), Core::ServiceGroupType_def::Core);
+  groupNameMapping.insert(QLatin1String("ExercisePreparation"), Core::ServiceGroupType_def::ExercisePreparation);
+  groupNameMapping.insert(QLatin1String("ExerciseExecution"), Core::ServiceGroupType_def::ExerciseExecution);
+  groupNameMapping.insert(QLatin1String("ExercisePaused"), Core::ServiceGroupType_def::ExercisePaused);
+  groupNameMapping.insert(QLatin1String("ExerciseAfterActionReview"), Core::ServiceGroupType_def::ExerciseAfterActionReview);
+  groupNameMapping.insert(QLatin1String("Playback"), Core::ServiceGroupType_def::Playback);
+
+  while (directoryIterator.hasNext())
+  {
+    QString currentFileName = directoryIterator.next();
+
+    if (currentFileName.endsWith(QLatin1String(".xml")))
+    {
+      if (xmlReader.readServiceFile(currentFileName, QString()))
+      {
+        const auto procNames = xmlReader.getProcNames();
+        for (const QString &serviceName : procNames)
+        {
+          const QString exeName        = QLatin1String("svc") + serviceName;
+          const QStringList groupNames = xmlReader.getGroupNames();
+
+          if (serviceName.isEmpty() || exeName.length() < 4 || groupNames.isEmpty())
+          {
+            INFO_LOG(m_logger) << currentFileName
+                               << " does not include complete service information.";
+          }
+          else
+          {
+            if (m_licenceHandler->isServiceLicensed(serviceName))
+            {
+              const QString serviceNameShort = xmlReader.getServiceAbbr();
+              QString fnNoRestart = xmlPath + serviceNameShort + QLatin1String(".dontRestart");
+              bool bDevMode = xmlReader.getDevMode() || QFile::exists(fnNoRestart);
+              const int prioService = xmlReader.getPrio();
+              if (bDevMode)
+              {
+                WARNING_LOG(m_logger) << "Developer mode for service " << serviceName
+                                      << " activated - no automatic restart on crash!";
+              }
+              Service *newService = new Service(serviceName,
+                                                exeName,
+                                                QCoreApplication::applicationDirPath(),
+                                                serviceNameShort,
+                                                groupNames,
+                                                bDevMode,
+                                                prioService);
+              m_serviceHandler->addService(newService);
+
+              DEBUG_LOG(m_logger) << "Added new service \""
+                                  << serviceName
+                                  << "\""
+                                  << " prio=" << prioService;
+
+              for (const QString &groupName : groupNames)
+              {
+                if (groupNameMapping.contains(groupName))
+                {
+                  DEBUG_LOG(m_logger) << "  --> Linking to group \""
+                                      << groupName
+                                      << "\"";
+                  if (serviceName == QStringLiteral("ReportAnalyzer") && (groupName == QStringLiteral("ExercisePaused") || groupName == QStringLiteral("ExerciseAfterActionReview")))
+                    // Do not start ReportAnalyzer for stopped exercises
+                    continue;
+                  m_groupHandler->addServiceLink(newService->id(), groupNameMapping.value(groupName));
+                }
+                else
+                  INFO_LOG(m_logger) << "Found unknown group name: " << groupName;
+              }
+              ++ serviceCount;
+            }
+            else
+              NOTICE_LOG(m_logger) << "Service " << serviceName << " is not licensed.";
+          }
+        }
+      }
+    }
+  }
+
+  if (serviceCount)
+    return true;
+  ERROR_LOG(m_logger) << "Could not find any valid service in directory " << xmlPath;
+  return false;
+}
+
+void MainHandler::onMessageFromCommandlineReceived()
+{
+  NOTICE_LOG(m_logger) << "Got shutdown message from command line - trying to properly shut down all running applications";
+  QCoreApplication::quit();
+}
+
+} // namespace ServiceManagement