Initial commit

Lts/Services/ParticipantManagement/main_handler.cpp

@@ -0,0 +1,206 @@
+/**
+ * MainHandler for ParticipantManagement
+ * $Id$
+ * $HeadURL$
+ * $Author$
+ * Created by Hannes Baeuerle, SLSE, 19.05.2016
+ */
+
+#include "main_handler.h"
+#include "TypeHandling/type_handler.h"
+#include "UasHandling/mission_plan_handler.h"
+#include "UasHandling/uas_handler.h"
+#include "WebSocketInterface/websocket_interface_handler.h"
+#include "settings.h"
+
+#include <DDS/Core/pacemaker.h>
+#include <ngldb/db_service_handler.h>
+
+namespace ParticipantManagement
+{
+
+MainHandler::MainHandler() : m_logger(getLogger("MainHandler")) {}
+
+MainHandler::~MainHandler()
+{
+  m_getParticipants = nullptr;
+  m_partyHandler = nullptr;
+  m_templateHandler = nullptr;
+  m_biteHandler = nullptr;
+  m_participantHandler = nullptr;
+  m_tabFtc = nullptr;
+  m_tabDtc = nullptr;
+  m_aesFtc = nullptr;
+  m_equipmentEventHandler = nullptr;
+  m_typeHandler = nullptr;
+  m_websocketHandler = nullptr;
+  m_uasHandler = nullptr;
+  m_dbHandlerEx0 = nullptr;
+  m_dbHandler = nullptr;
+  m_ddsHandler = nullptr;
+}
+
+bool MainHandler::init(int domainId, int exerciseId)
+{
+  m_ddsHandler = std::make_shared<DdsHandler>(domainId, exerciseId);
+  if (!m_ddsHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init DdsHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init DdsHandler"));
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "DdsHandler initialized";
+
+  m_dbHandler = std::make_shared<DbHandler>();
+  if (!m_dbHandler->init(exerciseId, Settings::settings()))
+  {
+    ERROR_LOG(m_logger) << "Could not init DbHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init DbHandler"));
+    return false;
+  }
+  if (exerciseId > 0)
+  {
+    m_dbHandlerEx0 = std::make_shared<DbHandler>();
+    if (!m_dbHandlerEx0->init(0, Settings::settings())) // need a second db connection due to username/password
+    {
+      ERROR_LOG(m_logger) << "Could not init DbHandler";
+      m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init DbHandler"));
+      return false;
+    }
+  }
+  else
+  {
+    m_dbHandlerEx0 = m_dbHandler;
+  }
+  DEBUG_LOG(m_logger) << "DbHandler initialized";
+
+  m_typeHandler = TypeHandling::TypeHandler::createInstance(this, m_logger);
+  if (!m_typeHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init TypeHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init TypeHandler"));
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "TypeHandler initialized";
+
+  m_partyHandler = std::make_shared<PartyHandling::PartyHandler>(this);
+  if (!m_partyHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init PartyHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init PartyHandler"));
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "PartyHandler initialized";
+
+  m_tabFtc = TrainingAreaBase::Interface::Ftc::create(m_ddsHandler->dds());
+  if (!m_tabFtc->enableAll())
+  {
+    ERROR_LOG(m_logger) << "Could not init TrainingAreaBase FTC";
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "TrainingAreaBase FTC initialized";
+
+  m_aesFtc = AreaEffectSimulation::Interface::Ftc::create(m_ddsHandler->dds());
+  if (!m_aesFtc->enableChargeAdministrationModify())
+  {
+    ERROR_LOG(m_logger) << "Could not init AreaEffectSimulation FTC";
+    return false;
+  }
+
+  m_participantHandler = std::make_shared<ParticipantHandling::ParticipantHandlerForExercise>(this);
+  if (!m_participantHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init ParticipantHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init ParticipantHandler"));
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "ParticipantHandler initialized";
+  m_ddsHandler->pacemaker()->addPort(m_participantHandler->getWebSocketPort(), Core::PortType::WebSocketPositionServer);
+
+  m_targetInformationHandler = std::make_shared<ParticipantManagement::HandlerTargetInformation>(this);
+  if (!m_targetInformationHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init TargetInformationHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init TargetInformationHandler"));
+    return false;
+  }
+  NOTICE_LOG(m_logger) << "Enabled TargetInformationHandler for ex " << exerciseId << " do= " << domainId;
+
+  m_biteHandler = std::make_shared<BiteHandling::BiteHandler>(this);
+  if (!m_biteHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init BiteHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init BiteHandler"));
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "BiteHandler initialized";
+
+  // template handler is not needed in exercise dependent PPM
+  if (m_ddsHandler->dds()->getPartitionId() <= 0)
+  {
+    m_templateHandler = std::make_shared<TemplateHandling::TemplateHandler>(this);
+    if (!m_templateHandler->init())
+    {
+      ERROR_LOG(m_logger) << "Could not init TemplateHandler";
+      m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init TemplateHandler"));
+      return false;
+    }
+    DEBUG_LOG(m_logger) << "TemplateHandler initialized";
+  }
+
+  m_getParticipants = std::make_shared<GetParticipants>(this);
+
+  m_tabDtc = TrainingAreaBase::Interface::Dtc::create(m_ddsHandler->dds());
+  m_equipmentEventHandler = std::make_shared<EquipmentEventHandling::EquipmentEventHandler>(this);
+  if (!m_equipmentEventHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init EquipmentEventHandler";
+    m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError, QStringLiteral("Could not init EquipmentEventHandler"));
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "EquipmentEventHandler initialized";
+
+  // WebSocketServer
+  m_websocketHandler = std::make_shared<WebSocketInterface::WebSocketInterfaceHandler>(this);
+  if (!m_websocketHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Could not init WebSocketInterfaceHandler";
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "WebSocketInterfaceHandler initialized";
+  m_ddsHandler->pacemaker()->addPort(m_websocketHandler->webSocketPort(), Core::PortType::WebSocketServer);
+  m_ddsHandler->pacemaker()->setNewState(Core::RunningState::Running);
+
+  // UasHandler
+  if (exerciseId == 0)
+  {
+    m_uasHandler = std::make_shared<UasHandling::UasHandler>(this);
+    if (!m_uasHandler->init())
+    {
+      ERROR_LOG(m_logger) << "Could not init UasHandler";
+      return false;
+    }
+
+    DEBUG_LOG(m_logger) << "UasHandler initialized";
+  }
+
+  if (exerciseId != 0)
+  {
+    // init missionPlan
+    m_missionPlanHandler = std::make_shared<UasHandling::MissionPlanHandler>(this);
+    if (!m_missionPlanHandler->init())
+    {
+      ERROR_LOG(m_logger) << "Couldn't init MissionPlanHandler";
+      return false;
+    }
+  }
+  return true;
+}
+
+std::shared_ptr<DatabaseInterface> MainHandler::db() const { return m_dbHandler->db(); }
+
+std::shared_ptr<DatabaseInterface> MainHandler::dbEx0() const { return m_dbHandlerEx0->db(); }
+
+qint64 MainHandler::currentTimeMSec() const { return QDateTime::currentMSecsSinceEpoch(); }
+
+} // namespace ParticipantManagement