fsfw/health/HealthHelper.cpp

101 lines
3.2 KiB
C++
Raw Normal View History

#include <framework/health/HealthHelper.h>
#include <framework/serviceinterface/ServiceInterfaceStream.h>
2020-06-07 01:17:24 +02:00
HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
2020-06-07 01:17:24 +02:00
objectId(objectId), owner(owner) {
}
HealthHelper::~HealthHelper() {
}
ReturnValue_t HealthHelper::handleHealthCommand(CommandMessage* message) {
switch (message->getCommand()) {
case HealthMessage::HEALTH_SET:
handleSetHealthCommand(message);
return HasReturnvaluesIF::RETURN_OK;
case HealthMessage::HEALTH_ANNOUNCE: {
eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, getHealth(),
getHealth());
}
return HasReturnvaluesIF::RETURN_OK;
default:
return HasReturnvaluesIF::RETURN_FAILED;
}
}
HasHealthIF::HealthState HealthHelper::getHealth() {
return healthTable->getHealth(objectId);
}
ReturnValue_t HealthHelper::initialize(MessageQueueId_t parentQueue) {
setParentQeueue(parentQueue);
return initialize();
}
void HealthHelper::setParentQeueue(MessageQueueId_t parentQueue) {
this->parentQueue = parentQueue;
}
ReturnValue_t HealthHelper::initialize() {
healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
eventSender = objectManager->get<EventReportingProxyIF>(objectId);
// TODO: Better returnvalues
if ((healthTable == NULL) || eventSender == NULL) {
return HasReturnvaluesIF::RETURN_FAILED;
}
ReturnValue_t result = healthTable->registerObject(objectId,
HasHealthIF::HEALTHY);
if (result != HasReturnvaluesIF::RETURN_OK) {
return result;
}
return HasReturnvaluesIF::RETURN_OK;
}
void HealthHelper::setHealth(HasHealthIF::HealthState health) {
HasHealthIF::HealthState oldHealth = getHealth();
eventSender->forwardEvent(HasHealthIF::HEALTH_INFO, health, oldHealth);
if (health != oldHealth) {
healthTable->setHealth(objectId, health);
informParent(health, oldHealth);
}
}
void HealthHelper::informParent(HasHealthIF::HealthState health,
HasHealthIF::HealthState oldHealth) {
2020-06-11 16:03:09 +02:00
if (parentQueue == MessageQueueMessageIF::NO_QUEUE) {
return;
}
2020-06-09 02:18:39 +02:00
MessageQueueMessage message;
CommandMessage information(&message);
HealthMessage::setHealthMessage(&information, HealthMessage::HEALTH_INFO,
health, oldHealth);
2020-06-09 02:18:39 +02:00
if (MessageQueueSenderIF::sendMessage(parentQueue, &information,
MessageQueueMessage::MAX_MESSAGE_SIZE,
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
sif::debug << "HealthHelper::informParent: sending health reply failed."
<< std::endl;
}
}
2020-06-09 02:18:39 +02:00
void HealthHelper::handleSetHealthCommand(CommandMessage* command) {
ReturnValue_t result = owner->setHealth(HealthMessage::getHealth(command));
if (command->getSender() == MessageQueueMessageIF::NO_QUEUE) {
return;
}
2020-06-09 02:18:39 +02:00
MessageQueueMessage message;
CommandMessage reply(&message);
if (result == HasReturnvaluesIF::RETURN_OK) {
HealthMessage::setHealthMessage(&reply,
HealthMessage::REPLY_HEALTH_SET);
} else {
2020-06-09 02:18:39 +02:00
reply.setReplyRejected(result, command->getCommand());
}
2020-06-09 02:18:39 +02:00
if (MessageQueueSenderIF::sendMessage(command->getSender(), &reply,
MessageQueueMessage::MAX_MESSAGE_SIZE,
owner->getCommandQueue()) != HasReturnvaluesIF::RETURN_OK) {
sif::debug << "HealthHelper::handleHealthCommand: sending health "
"reply failed." << std::endl;
}
}