2022-10-24 10:57:30 +02:00
|
|
|
#include "TmStore.h"
|
2022-11-11 15:39:27 +01:00
|
|
|
|
2022-10-25 18:20:21 +02:00
|
|
|
#include <mission/memory/SdCardMountedIF.h>
|
|
|
|
|
2022-11-11 15:39:27 +01:00
|
|
|
#include <algorithm>
|
2022-12-12 14:58:56 +01:00
|
|
|
#include <cinttypes>
|
2022-12-12 16:18:00 +01:00
|
|
|
#include <filesystem>
|
2022-12-12 18:42:51 +01:00
|
|
|
#include <fstream>
|
2022-10-24 10:57:30 +02:00
|
|
|
|
|
|
|
using namespace returnvalue;
|
|
|
|
|
2022-12-12 18:27:01 +01:00
|
|
|
TmStore::TmStore(object_id_t objectId, std::string baseName, RolloverInterval intervalUnit,
|
|
|
|
uint32_t intervalCount, PacketFilter filter, SdCardMountedIF& sdcMan)
|
|
|
|
: SystemObject(objectId), filter(filter), baseName(std::move(baseName)), sdcMan(sdcMan) {
|
|
|
|
calcDiffSeconds(intervalUnit, intervalCount);
|
|
|
|
}
|
2022-10-24 10:57:30 +02:00
|
|
|
|
2022-10-25 18:20:21 +02:00
|
|
|
ReturnValue_t TmStore::passPacket(PusTmReader& reader) {
|
2022-11-11 15:39:27 +01:00
|
|
|
bool inApidList = false;
|
|
|
|
if (filter.apid) {
|
|
|
|
auto& apidFilter = filter.apid.value();
|
|
|
|
if (std::find(apidFilter.begin(), apidFilter.end(), reader.getApid()) != apidFilter.end()) {
|
|
|
|
if (not filter.serviceSubservices and not filter.services) {
|
|
|
|
return storePacket(reader);
|
|
|
|
}
|
|
|
|
inApidList = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
std::pair<uint8_t, uint8_t> serviceSubservice;
|
|
|
|
serviceSubservice.first = reader.getService();
|
|
|
|
serviceSubservice.second = reader.getSubService();
|
|
|
|
if (filter.services) {
|
|
|
|
auto& serviceFilter = filter.services.value();
|
|
|
|
if (std::find(serviceFilter.begin(), serviceFilter.end(), serviceSubservice.first) !=
|
|
|
|
serviceFilter.end()) {
|
|
|
|
if (filter.apid and inApidList) {
|
|
|
|
return storePacket(reader);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (filter.serviceSubservices) {
|
|
|
|
auto& serviceSubserviceFilter = filter.serviceSubservices.value();
|
|
|
|
if (std::find(serviceSubserviceFilter.begin(), serviceSubserviceFilter.end(),
|
|
|
|
serviceSubservice) != serviceSubserviceFilter.end()) {
|
|
|
|
if (filter.apid and inApidList) {
|
|
|
|
return storePacket(reader);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-10-25 18:20:21 +02:00
|
|
|
return returnvalue::OK;
|
2022-10-24 10:57:30 +02:00
|
|
|
}
|
|
|
|
|
2022-12-12 10:06:30 +01:00
|
|
|
ReturnValue_t TmStore::storePacket(PusTmReader& reader) {
|
|
|
|
using namespace std::filesystem;
|
2022-12-12 18:27:01 +01:00
|
|
|
if (baseDirUninitialized) {
|
|
|
|
updateBaseDir();
|
2022-12-12 10:06:30 +01:00
|
|
|
}
|
2022-12-12 18:27:01 +01:00
|
|
|
// It is assumed here that the filesystem is usable.
|
2022-12-12 10:06:30 +01:00
|
|
|
if (not mostRecentFile) {
|
2022-12-13 10:07:36 +01:00
|
|
|
assignAndOrCreateMostRecentFile();
|
2022-12-12 10:06:30 +01:00
|
|
|
}
|
2022-12-12 18:42:51 +01:00
|
|
|
|
|
|
|
if (currentTv.tv_sec < mostRecentTv.value().tv_sec or
|
|
|
|
currentTv.tv_sec - mostRecentTv.value().tv_sec > static_cast<int>(rolloverDiffSeconds)) {
|
|
|
|
if (file_size(mostRecentFile.value()) + reader.getFullPacketLen() > fileBuf.size()) {
|
2022-12-13 10:07:36 +01:00
|
|
|
uint8_t appendedCounter = 1;
|
|
|
|
path rolloverName;
|
|
|
|
while (true) {
|
|
|
|
rolloverName = path(mostRecentFile.value().string() + std::to_string(appendedCounter));
|
|
|
|
if (not exists(rolloverName)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
appendedCounter++;
|
|
|
|
}
|
|
|
|
rename(mostRecentFile.value(), rolloverName);
|
|
|
|
std::ofstream of(mostRecentFile.value(), std::ios::binary);
|
2022-12-12 18:42:51 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Rollover conditions were handled, write to file now
|
|
|
|
std::ofstream of(mostRecentFile.value(), std::ios::app | std::ios::binary);
|
|
|
|
of.write(reinterpret_cast<const char*>(reader.getFullData()), reader.getFullPacketLen());
|
2022-12-12 10:06:30 +01:00
|
|
|
return returnvalue::OK;
|
|
|
|
}
|
2022-11-11 15:39:27 +01:00
|
|
|
|
2022-10-25 18:20:21 +02:00
|
|
|
MessageQueueId_t TmStore::getCommandQueue() { return MessageQueueIF::NO_QUEUE; }
|
2022-12-12 18:27:01 +01:00
|
|
|
|
|
|
|
void TmStore::calcDiffSeconds(RolloverInterval intervalUnit, uint32_t intervalCount) {
|
|
|
|
if (intervalUnit == RolloverInterval::HOURLY) {
|
2022-12-13 13:46:49 +01:00
|
|
|
rolloverDiffSeconds = 60 * 60 * intervalCount;
|
2022-12-12 18:27:01 +01:00
|
|
|
} else if (intervalUnit == RolloverInterval::DAILY) {
|
2022-12-13 13:46:49 +01:00
|
|
|
rolloverDiffSeconds = 60 * 60 * 24 * intervalCount;
|
2022-12-12 18:27:01 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void TmStore::updateBaseDir() {
|
|
|
|
using namespace std::filesystem;
|
|
|
|
std::string currentPrefix = sdcMan.getCurrentMountPrefix();
|
|
|
|
baseDir = path(currentPrefix) / baseName;
|
|
|
|
if (not exists(baseDir)) {
|
|
|
|
create_directory(baseDir);
|
|
|
|
}
|
|
|
|
baseDirUninitialized = false;
|
|
|
|
}
|
|
|
|
|
2022-12-12 18:42:51 +01:00
|
|
|
ReturnValue_t TmStore::updateCurrentTimestamp() { return Clock::getClock_timeval(¤tTv); }
|
|
|
|
|
2022-12-13 10:07:36 +01:00
|
|
|
void TmStore::assignAndOrCreateMostRecentFile() {
|
2022-12-12 18:27:01 +01:00
|
|
|
using namespace std::filesystem;
|
|
|
|
for (auto const& file : directory_iterator(baseDir)) {
|
|
|
|
if (file.is_directory()) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
auto pathStr = file.path().string();
|
|
|
|
Clock::TimeOfDay_t tod;
|
|
|
|
if (pathStr.find(baseName) == std::string::npos) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
unsigned int underscorePos = pathStr.find_last_of('_');
|
|
|
|
std::string stampStr = pathStr.substr(underscorePos + 1);
|
|
|
|
int count =
|
|
|
|
sscanf(stampStr.c_str(),
|
|
|
|
"%4" SCNu32 "-%2" SCNu32 "-%2" SCNu32 "T%2" SCNu32 ":%2" SCNu32 ":%2" SCNu32 "Z",
|
|
|
|
&tod.year, &tod.month, &tod.day, &tod.hour, &tod.minute, &tod.second);
|
|
|
|
if (count != 6) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
timeval tv{};
|
|
|
|
Clock::convertTimeOfDayToTimeval(&tod, &tv);
|
|
|
|
if (not mostRecentTv || tv > mostRecentTv.value()) {
|
|
|
|
mostRecentTv = tv;
|
|
|
|
mostRecentFile = file.path();
|
|
|
|
}
|
|
|
|
}
|
2022-12-13 10:07:36 +01:00
|
|
|
if (not mostRecentFile) {
|
|
|
|
updateCurrentTimestamp();
|
|
|
|
unsigned currentIdx = 0;
|
|
|
|
memcpy(fileBuf.data() + currentIdx, baseName.data(), baseName.size());
|
|
|
|
currentIdx += baseName.size();
|
|
|
|
Clock::TimeOfDay_t tod;
|
|
|
|
Clock::convertTimevalToTimeOfDay(¤tTv, &tod);
|
|
|
|
currentIdx += sprintf(reinterpret_cast<char*>(fileBuf.data() + currentIdx),
|
|
|
|
"%4" SCNu32 "-%2" SCNu32 "-%2" SCNu32 "T%2" SCNu32 ":%2" SCNu32
|
|
|
|
":%2" SCNu32 "Z.bin",
|
|
|
|
tod.year, tod.month, tod.day, tod.hour, tod.minute, tod.second);
|
|
|
|
path newPath(std::string(reinterpret_cast<const char*>(fileBuf.data()), currentIdx));
|
|
|
|
std::ofstream of(newPath, std::ios::binary);
|
2022-12-13 10:08:31 +01:00
|
|
|
mostRecentFile = newPath;
|
|
|
|
mostRecentTv = currentTv;
|
2022-12-13 10:07:36 +01:00
|
|
|
}
|
2022-12-12 18:27:01 +01:00
|
|
|
}
|
2022-12-12 18:42:51 +01:00
|
|
|
|
|
|
|
ReturnValue_t TmStore::storePacketInternal(PusTmReader& reader) { return returnvalue::OK; }
|