Adds immediate migration results in progress

This commit is contained in:
torsten committed 2026-08-19 11:18:24 +02:00
1 parent 8453e104c5
commit 3bb6e89496
2102 files changed
+17482 -15071

No files matched your search

@@ -14,27 +14,26 @@
namespace ComponentMonitor
{
CheckmkHandler::CheckmkHandler()
: QObject()
, m_socket(new QTcpSocket(this))
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG() << Q_FUNC_INFO << " END";
CheckmkHandler::CheckmkHandler() : QObject()
, m_socket(new QTcpSocket(this)),
m_logger(NGL::NGLLoggerBootstrap::getLogger()) {
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
CheckmkHandler::~CheckmkHandler()
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
if (m_timer)
m_timer->stop();
delete m_socket;
TRACE_LOG() << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
bool CheckmkHandler::initialize(const QString &checkMkServerHostname, int checkMkServerPort,
int checkIntervalSec)
{
DEBUG_LOG() << Q_FUNC_INFO << " START"
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " START"
<< " , hostname=" << checkMkServerHostname
<< " , port=" << checkMkServerPort
<< " , m_checkIntervalSec=" << checkIntervalSec;
@@ -58,22 +57,22 @@ bool CheckmkHandler::initialize(const QString &checkMkServerHostname, int checkM
this, &CheckmkHandler::onConnected);
connect(m_socket, &QTcpSocket::readyRead, this, &CheckmkHandler::readData);
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
return true;
}
void CheckmkHandler::run()
{
INFO_LOG() << Q_FUNC_INFO << " START";
INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
m_timer->start();
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}
void CheckmkHandler::stop()
{
INFO_LOG() << Q_FUNC_INFO << " START";
INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
m_timer->stop();
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}
void CheckmkHandler::onTimeout()
@@ -86,7 +85,7 @@ void CheckmkHandler::onTimeout()
m_timer->setInterval(m_checkIntervalSec*1000);
}
INFO_LOG() << Q_FUNC_INFO << " Timeout, m_highFrequencyCheck=" << m_highFrequencyCheck
INFO_LOG(m_logger) << Q_FUNC_INFO << " Timeout, m_highFrequencyCheck=" << m_highFrequencyCheck
<< ", current Interval=" << m_timer->interval() << " [msec]";
if (m_socket->state() == QAbstractSocket::SocketState::ConnectedState)
@@ -99,37 +98,37 @@ void CheckmkHandler::onTimeout()
bool CheckmkHandler::doConnect()
{
INFO_LOG() << Q_FUNC_INFO << " START, (int)m_socket->state()=" << (int)m_socket->state();
INFO_LOG(m_logger) << Q_FUNC_INFO << " START, (int)m_socket->state()=" << (int)m_socket->state();
m_socket->connectToHost(m_checkMkHost, m_checkMkPort);
if (!m_socket->waitForConnected(5000))
{
ERROR_LOG() << Q_FUNC_INFO << " Could not (re)open tcp destination " << m_checkMkHost << ":" << m_checkMkPort << ", error: " << m_socket->errorString();
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Could not (re)open tcp destination " << m_checkMkHost << ":" << m_checkMkPort << ", error: " << m_socket->errorString();
return false;
}
INFO_LOG() << Q_FUNC_INFO << " (Re)openend tcp destination " << m_checkMkHost << ":" << m_checkMkPort;
INFO_LOG(m_logger) << Q_FUNC_INFO << " (Re)openend tcp destination " << m_checkMkHost << ":" << m_checkMkPort;
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
return true;
}
void CheckmkHandler::onImmediateGetStateRequested()
{
INFO_LOG() << Q_FUNC_INFO << " START";
INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
m_highFrequencyCheck = 3;
onTimeout();
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}
bool CheckmkHandler::writeGetStateRequest()
{
if (!m_socket->isOpen())
{
ERROR_LOG() << Q_FUNC_INFO << " socket not open";
ERROR_LOG(m_logger) << Q_FUNC_INFO << " socket not open";
return false;
}
@@ -160,16 +159,16 @@ bool CheckmkHandler::writeGetStateRequest()
const char* cmdCheck = "GET hosts\nResponseHeader: fixed16\nColumns: name state last_check \nKeepAlive: on\n\n";
int bWritten = m_socket->write(cmdCheck);
INFO_LOG() << Q_FUNC_INFO << " cmdCheck= '" << cmdCheck << "'";
INFO_LOG(m_logger) << Q_FUNC_INFO << " cmdCheck= '" << cmdCheck << "'";
INFO_LOG() << Q_FUNC_INFO << " bWritten= " << bWritten;
INFO_LOG(m_logger) << Q_FUNC_INFO << " bWritten= " << bWritten;
return true;
}
void CheckmkHandler::readData()
{
DEBUG_LOG() << Q_FUNC_INFO << " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
while (m_socket->canReadLine())
processLine(m_socket->readLine().trimmed());
@@ -204,10 +203,10 @@ bool CheckmkHandler::processLine(const QByteArray &line)
if (sl.size() < 2)
{
if (str.startsWith(QStringLiteral("200")))
DEBUG_LOG() << Q_FUNC_INFO << " size to small " << sl.size()
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " size to small " << sl.size()
<< ", line='" << str << "'";
else
WARNING_LOG() << Q_FUNC_INFO << " size to small " << sl.size()
WARNING_LOG(m_logger) << Q_FUNC_INFO << " size to small " << sl.size()
<< ", line='" << str << "'";
return false;
}
@@ -238,7 +237,7 @@ bool CheckmkHandler::processLine(const QByteArray &line)
lastCheck = lastCheckStr.toLongLong();
}
DEBUG_LOG() << Q_FUNC_INFO
DEBUG_LOG(m_logger) << Q_FUNC_INFO
<< " name: '" << name << "'"
<< ", stateInt: '" << stateInt << "'"
<< ", reachable: '" << reachable << "'"
@@ -56,6 +56,7 @@ private Q_SLOTS:
protected:
NGL::INGLLogger &m_logger;
bool processLine(const QByteArray &line);
private:
@@ -17,17 +17,17 @@ CheckmkHandlerScheduleCheck::CheckmkHandlerScheduleCheck(const std::shared_ptr<D
, m_socket(new QTcpSocket(this))
, m_ddsHandler(ddsHandler)
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG() << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
CheckmkHandlerScheduleCheck::~CheckmkHandlerScheduleCheck()
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
if (m_timer)
m_timer->stop();
delete m_socket;
TRACE_LOG() << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
bool CheckmkHandlerScheduleCheck::initialize(const QString &checkMkServerHostname, int checkMkServerPort)
@@ -36,7 +36,7 @@ bool CheckmkHandlerScheduleCheck::initialize(const QString &checkMkServerHostnam
<< " , hostname=" << checkMkServerHostname
<< " , port=" << checkMkServerPort;
DEBUG_LOG() << Q_FUNC_INFO << " ddsHandler referenced";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " ddsHandler referenced";
m_checkMkHost = checkMkServerHostname;
m_checkMkPort = checkMkServerPort;
@@ -55,22 +55,22 @@ bool CheckmkHandlerScheduleCheck::initialize(const QString &checkMkServerHostnam
connect(m_socket, &QTcpSocket::connected,
this, &CheckmkHandlerScheduleCheck::onConnected);
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
return true;
}
void CheckmkHandlerScheduleCheck::run(int timoutMsec)
{
INFO_LOG() << Q_FUNC_INFO << " START, timoutMsec=" << timoutMsec;
INFO_LOG(m_logger) << Q_FUNC_INFO << " START, timoutMsec=" << timoutMsec;
m_timer->start(timoutMsec);
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}
void CheckmkHandlerScheduleCheck::stop()
{
INFO_LOG() << Q_FUNC_INFO << " START";
INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
m_timer->stop();
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
}
void CheckmkHandlerScheduleCheck::onTimeout()
@@ -85,7 +85,7 @@ void CheckmkHandlerScheduleCheck::onTimeout()
bool CheckmkHandlerScheduleCheck::doConnect()
{
INFO_LOG() << Q_FUNC_INFO << " START, (int)m_socket->state()=" << (int)m_socket->state();
INFO_LOG(m_logger) << Q_FUNC_INFO << " START, (int)m_socket->state()=" << (int)m_socket->state();
@@ -93,30 +93,30 @@ bool CheckmkHandlerScheduleCheck::doConnect()
m_socket->connectToHost(m_checkMkHost, m_checkMkPort);
if (!m_socket->waitForConnected(5000))
{
ERROR_LOG() << Q_FUNC_INFO << " Could not (re)open tcp destination " << m_checkMkHost << ":" << m_checkMkPort << ", error: " << m_socket->errorString();
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Could not (re)open tcp destination " << m_checkMkHost << ":" << m_checkMkPort << ", error: " << m_socket->errorString();
return false;
}
INFO_LOG() << Q_FUNC_INFO << " (Re)openend tcp destination " << m_checkMkHost << ":" << m_checkMkPort;
INFO_LOG(m_logger) << Q_FUNC_INFO << " (Re)openend tcp destination " << m_checkMkHost << ":" << m_checkMkPort;
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
return true;
}
void CheckmkHandlerScheduleCheck::addScheduleCheckHostnames(const QStringList &hostnames)
{
INFO_LOG() << Q_FUNC_INFO << " hostnames: " << hostnames.join(QStringLiteral(";"));
INFO_LOG(m_logger) << Q_FUNC_INFO << " hostnames: " << hostnames.join(QStringLiteral(";"));
m_scheduleCheckHostnames += hostnames;
}
bool CheckmkHandlerScheduleCheck::writeScheduleUpdateRequest()
{
DEBUG_LOG() << Q_FUNC_INFO
DEBUG_LOG(m_logger) << Q_FUNC_INFO
<< " state " << (int)m_socket->state()
<< ", isOpen " << m_socket->isOpen();
if (!m_socket->isOpen() || (m_socket->state() != QAbstractSocket::SocketState::ConnectedState))
{
ERROR_LOG() << Q_FUNC_INFO << " socket not open or connected "
ERROR_LOG(m_logger) << Q_FUNC_INFO << " socket not open or connected "
<< " host/port: " << m_checkMkHost << ":" << m_checkMkPort;
return false;
}
@@ -137,13 +137,13 @@ bool CheckmkHandlerScheduleCheck::writeScheduleUpdateRequest()
qint64 now = QDateTime::currentSecsSinceEpoch();
const QString cmd = QString(QStringLiteral("COMMAND [%1] SCHEDULE_FORCED_HOST_CHECK;%2;%3")).arg(now).arg(hostname.toUpper()).arg(now);
DEBUG_LOG() << Q_FUNC_INFO << " cmd= '" << cmd << "'";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " cmd= '" << cmd << "'";
int bWritten = m_socket->write(cmd.toUtf8()) + m_socket->write("\n\n");
DEBUG_LOG() << Q_FUNC_INFO << " bWritten= " << bWritten;
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " bWritten= " << bWritten;
bWrittenAll += bWritten;
}
INFO_LOG() << Q_FUNC_INFO << " bWrittenAll= " << bWrittenAll;
INFO_LOG(m_logger) << Q_FUNC_INFO << " bWrittenAll= " << bWrittenAll;
m_scheduleCheckHostnames.clear();
@@ -165,7 +165,7 @@ void CheckmkHandlerScheduleCheck::onConnected()
void CheckmkHandlerScheduleCheck::onStateChanged(const QAbstractSocket::SocketState &newState)
{
DEBUG_LOG() << Q_FUNC_INFO << " SocketState changed to: " << newState;
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " SocketState changed to: " << newState;
qInfo() << " CheckmkHandlerScheduleCheck: SocketState changed to: " << newState;
}
@@ -177,8 +177,8 @@ void CheckmkHandlerScheduleCheck::onSocketError(const QAbstractSocket::SocketErr
void CheckmkHandlerScheduleCheck::onTriggerUpdateRequest(const rti::core::SampleIdentity &cookie, const TriggerUpdate &request)
{
INFO_LOG() << Q_FUNC_INFO << " request=" << request;
DEBUG_LOG() << Q_FUNC_INFO << " m_socket->state=" << (int)m_socket->state();
INFO_LOG(m_logger) << Q_FUNC_INFO << " request=" << request;
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " m_socket->state=" << (int)m_socket->state();
@@ -230,7 +230,7 @@ void CheckmkHandlerScheduleCheck::onTriggerUpdateRequest(const rti::core::Sample
}
} else {
WARNING_LOG() << Q_FUNC_INFO << " socket not connected"
WARNING_LOG(m_logger) << Q_FUNC_INFO << " socket not connected"
<< ", (int)m_socket->state()=" << (int)m_socket->state()
<< ", destination " << m_checkMkHost << ":" << m_checkMkPort
<< ", -> queued cmd/request: " << request;
@@ -238,13 +238,13 @@ void CheckmkHandlerScheduleCheck::onTriggerUpdateRequest(const rti::core::Sample
}
INFO_LOG() << Q_FUNC_INFO << " m_ddsHandler = " << m_ddsHandler;
INFO_LOG() << Q_FUNC_INFO << " m_ddsHandler->fts() = " << m_ddsHandler->fts();
INFO_LOG(m_logger) << Q_FUNC_INFO << " m_ddsHandler = " << m_ddsHandler;
INFO_LOG(m_logger) << Q_FUNC_INFO << " m_ddsHandler->fts() = " << m_ddsHandler->fts();
if (m_ddsHandler && m_ddsHandler->fts())
m_ddsHandler->fts()->triggerUpdateReply(cookie, ret);
else
ERROR_LOG() << Q_FUNC_INFO << " no m_ddsHandler or m_ddsHandler->fts()";
ERROR_LOG(m_logger) << Q_FUNC_INFO << " no m_ddsHandler or m_ddsHandler->fts()";
if (!connected)
@@ -60,6 +60,7 @@ private:
protected:
NGL::INGLLogger &m_logger;
bool processLine(const QByteArray &line);
private:
@@ -12,35 +12,34 @@
namespace ComponentMonitor
{
ComponentStatusHandler::ComponentStatusHandler()
: QObject()
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG() << Q_FUNC_INFO << " END";
ComponentStatusHandler::ComponentStatusHandler() : QObject(),
m_logger(NGL::NGLLoggerBootstrap::getLogger()) {
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
ComponentStatusHandler::~ComponentStatusHandler()
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
m_ddsHandler = nullptr;
TRACE_LOG() << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
bool ComponentStatusHandler::initialize(const std::shared_ptr<DdsHandler> &ddsHandler)
{
INFO_LOG() << Q_FUNC_INFO << " START initialize ComponentStatusHandler";
INFO_LOG(m_logger) << Q_FUNC_INFO << " START initialize ComponentStatusHandler";
m_ddsHandler = ddsHandler;
DEBUG_LOG() << Q_FUNC_INFO << " ddsHandler referenced";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " ddsHandler referenced";
m_ismDtc = m_ddsHandler->ismDtc();
if (!m_ismDtc)
{
ERROR_LOG() << Q_FUNC_INFO << " Failure: no ismDtc";
ERROR_LOG(m_logger) << Q_FUNC_INFO << " Failure: no ismDtc";
return false;
}
@@ -48,7 +47,7 @@ bool ComponentStatusHandler::initialize(const std::shared_ptr<DdsHandler> &ddsHa
m_ismDtc->enableInstrumentationAsset();
m_ismDtc->waitForHistoricalDataInstrumentationAsset(2000);
DEBUG_LOG() << Q_FUNC_INFO << " instrumentationAssets-size = " << m_ismDtc->instrumentationAssets().size();
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " instrumentationAssets-size = " << m_ismDtc->instrumentationAssets().size();
@@ -65,8 +64,8 @@ bool ComponentStatusHandler::initialize(const std::shared_ptr<DdsHandler> &ddsHa
QTimer::singleShot(35000, this, &ComponentStatusHandler::dump);
DEBUG_LOG() << Q_FUNC_INFO << "initialize succesful, statusMapSize=" << statusMapSize();
INFO_LOG() << Q_FUNC_INFO << " END initialize ComponentStatusHandler, statusMapSize=" << statusMapSize();
DEBUG_LOG(m_logger) << Q_FUNC_INFO << "initialize succesful, statusMapSize=" << statusMapSize();
INFO_LOG(m_logger) << Q_FUNC_INFO << " END initialize ComponentStatusHandler, statusMapSize=" << statusMapSize();
return true;
}
@@ -95,7 +94,7 @@ void ComponentStatusHandler::onInstrumentationAssetChanged(const InfrastructureM
static int assetChangedCounter = 0;
const int iAssetId = iAsset.id();
DEBUG_LOG() << Q_FUNC_INFO
DEBUG_LOG(m_logger) << Q_FUNC_INFO
<< ", iAssetId=" << iAssetId
<< " (assetChangedCounter=" << ++assetChangedCounter << ")";
@@ -139,62 +138,62 @@ void ComponentStatusHandler::onInstrumentationAssetChanged(const InfrastructureM
void ComponentStatusHandler::dump()
{
DEBUG_LOG() << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG() << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG() << Q_FUNC_INFO << " DUMP START";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " DUMP START";
int counter = 0;
counter = 0;
DEBUG_LOG() << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG() << " REACHABLE:";
DEBUG_LOG(m_logger) << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG(m_logger) << " REACHABLE:";
for (const ComponentStatus &status : std::as_const(m_statusMap))
{
if (status.state().underlying() == ComponentState_def::Reachable)
{
DEBUG_LOG() << " id=" << status.id() << ", host '" << status.hostname().c_str() << " -> Reachable";
DEBUG_LOG(m_logger) << " id=" << status.id() << ", host '" << status.hostname().c_str() << " -> Reachable";
++counter;
}
}
DEBUG_LOG() << " REACHABLE hostCounter = " << counter;
DEBUG_LOG(m_logger) << " REACHABLE hostCounter = " << counter;
counter = 0;
DEBUG_LOG() << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG() << " UNREACHABLE:";
DEBUG_LOG(m_logger) << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG(m_logger) << " UNREACHABLE:";
for (const ComponentStatus &status : std::as_const(m_statusMap))
{
if (status.state().underlying() == ComponentState_def::Unreachable)
{
DEBUG_LOG() << " id=" << status.id() << ", host '" << status.hostname().c_str() << " -> Unreachable";
DEBUG_LOG(m_logger) << " id=" << status.id() << ", host '" << status.hostname().c_str() << " -> Unreachable";
++counter;
}
}
DEBUG_LOG() << " UNREACHABLE hostCounter = " << counter;
DEBUG_LOG(m_logger) << " UNREACHABLE hostCounter = " << counter;
counter = 0;
DEBUG_LOG() << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG() << " UNDEFINED:";
DEBUG_LOG(m_logger) << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG(m_logger) << " UNDEFINED:";
for (const ComponentStatus &status : std::as_const(m_statusMap))
{
if (status.state().underlying() == ComponentState_def::Undefined)
{
DEBUG_LOG() << " id=" << status.id() << ", host '" << status.hostname().c_str() << " -> Undefined";
DEBUG_LOG(m_logger) << " id=" << status.id() << ", host '" << status.hostname().c_str() << " -> Undefined";
++counter;
}
}
DEBUG_LOG() << " UNDEFINED hostCounter = " << counter;
DEBUG_LOG(m_logger) << " UNDEFINED hostCounter = " << counter;
DEBUG_LOG() << Q_FUNC_INFO << " DUMP END";
DEBUG_LOG() << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG() << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " DUMP END";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " +++++++++++++++++++++++++++++++++++++++++++++";
}
void ComponentStatusHandler::onNewState(const QString &hostname, bool reachable, long long lastCheckSec)
{
DEBUG_LOG() << Q_FUNC_INFO << " hostname=" << hostname
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " hostname=" << hostname
<< ", reachable=" << reachable
<< ", lastCheckSec=" << lastCheckSec;
@@ -219,7 +218,7 @@ void ComponentStatusHandler::onNewState(const QString &hostname, bool reachable,
void ComponentStatusHandler::onUpdateLastCheckTimeDirect(const QStringList &hostnamesForUpdateLastCheckTime, qint64 lastCheckSec)
{
DEBUG_LOG() << Q_FUNC_INFO << " START hostnamesForLastCheckTime=" << hostnamesForUpdateLastCheckTime.join(QStringLiteral(";"));
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " START hostnamesForLastCheckTime=" << hostnamesForUpdateLastCheckTime.join(QStringLiteral(";"));
for (ITERATOR_T it = m_statusMap.begin(); it != m_statusMap.end(); ++it)
{
@@ -236,12 +235,12 @@ void ComponentStatusHandler::onUpdateLastCheckTimeDirect(const QStringList &host
if ((curState == ComponentState_def::Reachable) ||
(curState == ComponentState_def::Unreachable))
{
DEBUG_LOG() << Q_FUNC_INFO << " updateLastCheckTimeDirect"
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " updateLastCheckTimeDirect"
<< " host: '" << curHostname << "'"
<< " newLastCheck= " << lastCheckSec;
INFO_LOG() << Q_FUNC_INFO << " DIFF_2a (*it) " << (*it);
INFO_LOG(m_logger) << Q_FUNC_INFO << " DIFF_2a (*it) " << (*it);
cs.last_check(lastCheckSec);
INFO_LOG() << Q_FUNC_INFO << " DIFF_2b (*it) " << (*it);
INFO_LOG(m_logger) << Q_FUNC_INFO << " DIFF_2b (*it) " << (*it);
m_ddsHandler->dts()->publish(cs);
}
}
@@ -250,7 +249,7 @@ void ComponentStatusHandler::onUpdateLastCheckTimeDirect(const QStringList &host
bool ComponentStatusHandler::addUpdateInstrumentationAsset(ComponentStatusHandler::ITERATOR_T it,
const ComponentStatus &cs)
{
DEBUG_LOG() << Q_FUNC_INFO << " START add/Update: cs=" << cs
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " START add/Update: cs=" << cs
<< ", curSize=" << m_statusMap.size() << ")";
const int id = cs.id();
@@ -260,8 +259,8 @@ bool ComponentStatusHandler::addUpdateInstrumentationAsset(ComponentStatusHandle
if ((*it) != cs)
{
INFO_LOG() << Q_FUNC_INFO << " DIFF (*it) " << (*it);
INFO_LOG() << Q_FUNC_INFO << " DIFF cs " << cs;
INFO_LOG(m_logger) << Q_FUNC_INFO << " DIFF (*it) " << (*it);
INFO_LOG(m_logger) << Q_FUNC_INFO << " DIFF cs " << cs;
(*it) = cs;
m_ddsHandler->dts()->publish(cs);
@@ -274,7 +273,7 @@ bool ComponentStatusHandler::addUpdateInstrumentationAsset(ComponentStatusHandle
m_statusMap.insert(id, cs);
m_ddsHandler->dts()->publish(cs);
}
DEBUG_LOG() << Q_FUNC_INFO << " END add/Update: cs=" << cs
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " END add/Update: cs=" << cs
<< ", curSize=" << m_statusMap.size() << ")";
return true;
}
@@ -282,7 +281,7 @@ bool ComponentStatusHandler::addUpdateInstrumentationAsset(ComponentStatusHandle
bool ComponentStatusHandler::removeInstrumentationAsset(ComponentStatusHandler::ITERATOR_T it)
{
const int id = it.value().id();
DEBUG_LOG() << Q_FUNC_INFO << " remove: id=" << id;
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " remove: id=" << id;
m_statusMap.remove(id);
m_ddsHandler->dts()->removeComponentStatusByKey(id);
return true;
@@ -49,6 +49,7 @@ private Q_SLOTS:
void dump();
protected:
NGL::INGLLogger &m_logger;
bool addUpdateInstrumentationAsset(ITERATOR_T it, const ComponentStatus &cs);
bool removeInstrumentationAsset(ITERATOR_T it);
@@ -17,7 +17,7 @@ namespace ComponentMonitor
DdsHandler::DdsHandler(int domainId, int exerciseId)
: m_ddsConnector(std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Global, exerciseId))
{
DEBUG_LOG() << "DdsHandler(" << domainId << ") for partition: " << m_ddsConnector->getDefaultPartition();
DEBUG_LOG(m_logger) << "DdsHandler(" << domainId << ") for partition: " << m_ddsConnector->getDefaultPartition();
}
DdsHandler::~DdsHandler()
@@ -27,7 +27,7 @@ bool DdsHandler::init(const QStringList &qosFileList)
{
if (!m_ddsConnector->init(qosFileList))
{
ERROR_LOG() << "Error initializing dds connections - aborting";
ERROR_LOG(m_logger) << "Error initializing dds connections - aborting";
return false;
}
@@ -45,10 +45,10 @@ bool DdsHandler::init(const QStringList &qosFileList)
m_ddsFts = ComponentMonitor::Interface::Fts::create(m_ddsConnector);
bool bRet = m_ddsDts->enableAll();
INFO_LOG() << "Dts initialised";
INFO_LOG(m_logger) << "Dts initialised";
bRet &= m_ddsFts->enableAll();
INFO_LOG() << "Fts initialised";
INFO_LOG(m_logger) << "Fts initialised";
m_ismDtc = InfrastructureManagement::Interface::Dtc::create(m_ddsConnector);
@@ -60,9 +60,9 @@ bool DdsHandler::init(const QStringList &qosFileList)
void DdsHandler::enableDtcs()
{
DEBUG_LOG() << Q_FUNC_INFO << " START Enable DTCs(" << m_ddsConnector->getDomainId() << ") for partition: " << m_ddsConnector->getDefaultPartition();
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " START Enable DTCs(" << m_ddsConnector->getDomainId() << ") for partition: " << m_ddsConnector->getDefaultPartition();
m_ismDtc->enableInstrumentationAsset();
DEBUG_LOG() << Q_FUNC_INFO << " END Enable DTCs(" << m_ddsConnector->getDomainId() << ") for partition: " << m_ddsConnector->getDefaultPartition();
DEBUG_LOG(m_logger) << Q_FUNC_INFO << " END Enable DTCs(" << m_ddsConnector->getDomainId() << ") for partition: " << m_ddsConnector->getDefaultPartition();
}
std::shared_ptr<InfrastructureManagement::Interface::Dtc> DdsHandler::ismDtc() const
@@ -53,6 +53,7 @@ public:
std::shared_ptr<InfrastructureManagement::Interface::Dtc> ismDtc() const;
private:
NGL::INGLLogger &m_logger;
std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnector;
std::shared_ptr<DTS::CurrentRunningState> m_dtsCurrentRunningState;
std::shared_ptr<Core::Pacemaker> m_pacemaker;
@@ -14,29 +14,29 @@ namespace ComponentMonitor
Initialization::Initialization()
: m_logger(getLogger("Initialization"))
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG() << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
Initialization::~Initialization()
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
m_checkmkHandler = nullptr;
m_componentStatusHandler = nullptr;
m_ddsHandler = nullptr;
TRACE_LOG() << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
bool Initialization::initialize(const std::shared_ptr<DdsHandler> &ddsHandler)
{
INFO_LOG() << Q_FUNC_INFO << " START";
INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
m_ddsHandler = ddsHandler;
DEBUG_LOG() << Q_FUNC_INFO << "ddsHandler referenced";
DEBUG_LOG(m_logger) << Q_FUNC_INFO << "ddsHandler referenced";
@@ -73,10 +73,10 @@ bool Initialization::initialize(const std::shared_ptr<DdsHandler> &ddsHandler)
if (!m_checkmkHandler->initialize(host, port, intervalSec))
{
ERROR_LOG() << Q_FUNC_INFO << " CheckmkHandler::initialize failed";
ERROR_LOG(m_logger) << Q_FUNC_INFO << " CheckmkHandler::initialize failed";
return false;
}
INFO_LOG() << Q_FUNC_INFO << " CheckmkHandler:initialize succesful";
INFO_LOG(m_logger) << Q_FUNC_INFO << " CheckmkHandler:initialize succesful";
QObject::connect(m_checkmkHandler.get(), &CheckmkHandler::newState,
m_componentStatusHandler.get(), &ComponentStatusHandler::onNewState, Qt::UniqueConnection);
@@ -88,10 +88,10 @@ bool Initialization::initialize(const std::shared_ptr<DdsHandler> &ddsHandler)
m_checkmkHandlerScheduleCheck = std::make_shared<CheckmkHandlerScheduleCheck>(m_ddsHandler);
if (!m_checkmkHandlerScheduleCheck->initialize(host, port))
{
ERROR_LOG() << Q_FUNC_INFO << " CheckmkHandlerScheduleCheck::initialize failed";
ERROR_LOG(m_logger) << Q_FUNC_INFO << " CheckmkHandlerScheduleCheck::initialize failed";
return false;
}
INFO_LOG() << Q_FUNC_INFO << " CheckmkHandlerScheduleCheck:initialize succesful";
INFO_LOG(m_logger) << Q_FUNC_INFO << " CheckmkHandlerScheduleCheck:initialize succesful";
#ifdef LTS_DEBUG
@@ -110,21 +110,21 @@ bool Initialization::initialize(const std::shared_ptr<DdsHandler> &ddsHandler)
#endif
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
return true;
}
bool Initialization::delayedInit()
{
INFO_LOG() << Q_FUNC_INFO << " START";
INFO_LOG(m_logger) << Q_FUNC_INFO << " START";
bool success = true;
if (!m_componentStatusHandler->initialize(m_ddsHandler))
{
ERROR_LOG() << Q_FUNC_INFO << " initialize failed for ComponentStatusHandler";
ERROR_LOG(m_logger) << Q_FUNC_INFO << " initialize failed for ComponentStatusHandler";
success = false;
}
INFO_LOG() << Q_FUNC_INFO << " ComponentStatusHandler, statusMapSize=" << m_componentStatusHandler->getHostnames().size();
INFO_LOG(m_logger) << Q_FUNC_INFO << " ComponentStatusHandler, statusMapSize=" << m_componentStatusHandler->getHostnames().size();
m_checkmkHandler->run();
@@ -144,7 +144,7 @@ bool Initialization::delayedInit()
INFO_LOG() << Q_FUNC_INFO << " END";
INFO_LOG(m_logger) << Q_FUNC_INFO << " END";
return success;
}
@@ -38,6 +38,7 @@ public:
protected:
NGL::INGLLogger &m_logger;
private:
std::shared_ptr<DdsHandler> m_ddsHandler;
std::shared_ptr<ComponentStatusHandler> m_componentStatusHandler;
@@ -11,19 +11,18 @@
namespace ComponentMonitor
{
MainHandler::MainHandler(QObject *parent)
: QObject(parent)
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG() << Q_FUNC_INFO << " END";
MainHandler::MainHandler(QObject *parent) : QObject(parent),
m_logger(NGL::NGLLoggerBootstrap::getLogger()) {
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
MainHandler::~MainHandler()
{
TRACE_LOG() << Q_FUNC_INFO << " START";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " START";
m_cmoService = nullptr;
m_ddsHandler = nullptr;
TRACE_LOG() << Q_FUNC_INFO << " END";
TRACE_LOG(m_logger) << Q_FUNC_INFO << " END";
}
bool MainHandler::init(int domainId)
@@ -33,11 +32,11 @@ bool MainHandler::init(int domainId)
m_ddsHandler = std::make_shared<DdsHandler>(domainId, excerciseId);
if (!m_ddsHandler->init())
{
ERROR_LOG() << "Initialisation ddsHandler failed.";
ERROR_LOG(m_logger) << "Initialisation ddsHandler failed.";
m_ddsHandler->pacemaker()->setNewState(Core::RunningState::StartingError);
return false;
}
DEBUG_LOG() << "Initialisation ddsHandler succesful.";
DEBUG_LOG(m_logger) << "Initialisation ddsHandler succesful.";
@@ -25,6 +25,7 @@ public:
std::shared_ptr<DdsHandler> dds() const { return m_ddsHandler; }
private:
NGL::INGLLogger &m_logger;
std::shared_ptr<DdsHandler> m_ddsHandler;
std::shared_ptr<ComponentMonitor::Initialization> m_cmoService;
};