qt5-legatus-legacy/Lts/Services/ParticipantManagement/dds_handler.cpp

/**
  * DdsHandler for PPM
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Hanna E. Rathje, SLSE, 2015-09-02
  */

#include "dds_handler.h"

#include "exercise_time.h"

#include <Core/pacemaker.h>
#include <DDS/DTS/generic_dts_impl.h>
#include <QThread>

namespace ParticipantManagement
{

DdsHandler::DdsHandler(int domainId, int exerciseId)
  : m_ddsConnector(std::make_shared<DDSConnector::DdsConnector>(domainId, exerciseId <= 0 ? IDL::PartitionType::Global : IDL::PartitionType::Exercise, exerciseId))
  , m_logger(getLogger("DdsHandler"))
{
  DEBUG_LOG(m_logger) << "DdsHandler(" << domainId << ") for partition: " << m_ddsConnector->getDefaultPartition();
}

DdsHandler::~DdsHandler()
{
  m_exerciseTime = nullptr;
  m_pacemaker = nullptr;
  m_ddsAnyExDts = nullptr;
  m_ddsAnyExFts = nullptr;
  m_ddsFts = nullptr;
  m_ddsDts = nullptr;
  m_ddsDtc = nullptr;
  m_topicLockMaster = nullptr;
  m_ddsConnector = nullptr;
}

bool DdsHandler::init(const QStringList &qosFileList)
{
  if (!m_ddsConnector->init(qosFileList))
  {
    ERROR_LOG(m_logger) << "Error initializing dds connections - aborting";
    return false;
  }

  // default initialize Publisher and Subscriber
  m_ddsConnector->initPublisherSubscriber();
  m_ddsConnector->enableBatchedWriter(false);

  // Pacemaker
  m_pacemaker = std::make_shared<Core::Pacemaker>(m_ddsConnector);
  m_topicLockMaster = std::make_shared<Core::TopicLockMaster>(m_ddsConnector);

  // Core::PartitionTime -> ExerciseTime
  std::shared_ptr<DTS::PartitionTime> dtsPartitionTime;
  dtsPartitionTime.reset(m_ddsConnector->createDTS<DTS::PartitionTimeImpl>());
  m_exerciseTime = std::make_shared<ExerciseTime>(dtsPartitionTime);
  ERROR_LOG(m_logger) << "OKKKKK THIS THE NEW MAIN HANDLER DDS " <<  this->thread();
  m_ddsDts = ParticipantManagement::Interface::Dts::create(m_ddsConnector);
  m_ddsFts = ParticipantManagement::Interface::Fts::create(m_ddsConnector);
  m_ddsDtc = ParticipantManagement::Interface::Dtc::create(m_ddsConnector);
  m_pdmDtc = ProjectDataManagement::Interface::Dtc::create(m_ddsConnector);
  m_ddsDtc->enableEquipmentExerciseMapping(true);

  const int exerciseId = m_ddsConnector->getPartitionId();

  m_exAnyConnector = std::make_shared<DDSConnector::DdsConnector>(m_ddsConnector->getDomainParticipant(), IDL::PartitionType::Any);
  if (!m_exAnyConnector->init(qosFileList))
  {
    ERROR_LOG(m_logger) << "Could not init Dds Connector with IDL::PartitionType::Any";
    return false;
  }
  m_exAnyConnector->initPublisherSubscriber();
  m_ddsAnyExDts = ParticipantManagement::Interface::Dts::create(m_exAnyConnector);
  m_ddsAnyExDts->enableEquipmentExerciseMapping(true);
  m_ddsAnyExDts->enableUASRadioLinkConnectionStatus(true);
  if (exerciseId <= 0)
  {
    DEBUG_LOG(m_logger) << "Creating * FTS: " << m_exAnyConnector->getDefaultPartition();
    m_ddsAnyExFts = ParticipantManagement::Interface::Fts::create(m_exAnyConnector);
    // do not enable anything here - enable where it is used (inside type handling) to make sure
    // no other service get a subscription matched information without actually having data
  }


  const bool bExe = exerciseId > 0;   // ex_N
  const bool bGlob = exerciseId <= 0; // ex_0
  if (!m_ddsDts->enableBite(true) ||
      !m_ddsDts->enableDynamicParticipantData(bExe) ||
      !m_ddsDts->enableEquipmentType(false) || // published in IDL::PartitionType::Any
      !m_ddsDts->enableParticipantGearEvent(bExe) ||
      !m_ddsDts->enableEquipmentExerciseMapping(false) || // published in IDL::PartitionType::Any
      !m_ddsDts->enableParticipant() ||
      !m_ddsDts->enableParticipantPosition(bExe) ||
      !m_ddsDts->enableParticipantOrganisation(bExe) ||
      !m_ddsDts->enableTargetInformation(bExe) ||
      !m_ddsDts->enableParty(bGlob || bExe) ||
      !m_ddsDts->enableTemplateParticipant(false) || // published in IDL::PartitionType::Any
      !m_ddsDts->enableType(false) || // published in IDL::PartitionType::Any
      !m_ddsDts->enableCtaError() ||
      !m_ddsDts->enableParticipantMode(bExe) ||
      !m_ddsDts->enableEquipmentSystemEvent(bExe) ||
      !m_ddsDts->enableHitLineInfo(bExe) ||
      !m_ddsDts->enableUnitPosition() ||
      !m_ddsDts->enableUAS(bGlob || bExe) ||
      !m_ddsDts->enableMissionPlan(bExe)
      )
  {
    ERROR_LOG(m_logger) << "Error initializing DTS";
    return false;
  }

  if (!m_ddsFts->enableCallBite() ||
      !m_ddsFts->enableChangePartyUsedState(bExe) ||  // unused?
      !m_ddsFts->enableEquipmentSystemEventData() ||
      !m_ddsFts->enableGetParticipants() ||
      !m_ddsFts->enableInitParticipant() ||
      !m_ddsFts->enableModifyEquipmentTypeData(false) ||  // published in IDL::PartitionType::Any
      !m_ddsFts->enableModifyParticipantData() ||
      !m_ddsFts->enableModifyPartyData() ||
      !m_ddsFts->enableModifyTemplateData(bGlob) ||
      !m_ddsFts->enableModifyType(false) ||  // published in IDL::PartitionType::Any
      !m_ddsFts->enableModifyState() ||
      !m_ddsFts->enableRegisterParticipant() ||
      !m_ddsFts->enableModifyTargetInformation() ||
      !m_ddsFts->enableRemoveParty() ||
      !m_ddsFts->enableRemoveType(false) ||  // published in IDL::PartitionType::Any
      !m_ddsFts->enableSendMessage() ||
      !m_ddsFts->enableSetParticipantMode() ||
      !m_ddsFts->enableSyncParties(bExe) ||
      !m_ddsFts->enableSetSimulatedPosition(bExe) ||
      !m_ddsFts->enableSetSimulatedPositionRelative(bExe) ||
      !m_ddsFts->enableSetSimulatedParticipantFormation(bExe) ||
      !m_ddsFts->enableSetSanitation(bExe) ||
      !m_ddsFts->enableSelectiveReammunition(bExe) ||
      !m_ddsFts->enableSetAsSimulated(bExe) ||
      !m_ddsFts->enableOcCommand(bExe) ||
      !m_ddsFts->enableSetAsSimulated(bExe) ||
      !m_ddsFts->enableModifyMissionPlan(bExe)||
      !m_ddsFts->enableRemoveMissionPlan(bExe) ||
      !m_ddsFts->enableSetMissionActionFulfilled(bExe)||
      !m_ddsFts->enableModifyUasState(bExe)

      )
  {
    ERROR_LOG(m_logger) << "Error initializing FTS";
    return false;
  }

  m_pdmDtc->enableChargeType(true);

  return true;
}

void DdsHandler::longActionBreak()
{
 // m_pacemaker->publishState();  //not threadSafe!
 // m_exerciseTime->publishPartitionTime();
}

} // namespace ParticipantManagement