eive-obsw/mission/tmtc/TmStore.cpp

#include "TmStore.h"

#include <mission/memory/SdCardMountedIF.h>

#include <algorithm>
#include <cinttypes>
#include <filesystem>
#include <fstream>
#include <utility>

using namespace returnvalue;

TmStore::TmStore(object_id_t objectId, std::string baseName, RolloverInterval intervalUnit,
                 uint32_t intervalCount, timeval& currentTv, SdCardMountedIF& sdcMan)
    : SystemObject(objectId), baseName(std::move(baseName)), currentTv(currentTv), sdcMan(sdcMan) {
  calcDiffSeconds(intervalUnit, intervalCount);
}

ReturnValue_t TmStore::passPacket(PusTmReader& reader) {
  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);
      }
    }
  }
  return returnvalue::OK;
}

ReturnValue_t TmStore::storePacket(PusTmReader& reader) {
  using namespace std::filesystem;
  if (baseDirUninitialized) {
    updateBaseDir();
  }
  // It is assumed here that the filesystem is usable.
  if (not mostRecentFile) {
    assignAndOrCreateMostRecentFile();
  }

  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()) {
      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);
    }
  }

  // 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());
  return returnvalue::OK;
}

MessageQueueId_t TmStore::getCommandQueue() { return MessageQueueIF::NO_QUEUE; }

void TmStore::calcDiffSeconds(RolloverInterval intervalUnit, uint32_t intervalCount) {
  if (intervalUnit == RolloverInterval::MINUTELY) {
    rolloverDiffSeconds = 60 * intervalCount;
  } else if (intervalUnit == RolloverInterval::HOURLY) {
    rolloverDiffSeconds = 60 * 60 * intervalCount;
  } else if (intervalUnit == RolloverInterval::DAILY) {
    rolloverDiffSeconds = 60 * 60 * 24 * intervalCount;
  }
}

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;
}

void TmStore::assignAndOrCreateMostRecentFile() {
  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();
    }
  }
  if (not mostRecentFile) {
    unsigned currentIdx = 0;
    memcpy(fileBuf.data() + currentIdx, baseName.data(), baseName.size());
    currentIdx += baseName.size();
    Clock::TimeOfDay_t tod;
    Clock::convertTimevalToTimeOfDay(&currentTv, &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);
    mostRecentFile = newPath;
    mostRecentTv = currentTv;
  }
}

void TmStore::addApid(uint16_t apid) {
  if (not filter.apid) {
    filter.apid = std::vector<uint16_t>({apid});
    return;
  }
  filter.apid.value().push_back(apid);
}

void TmStore::addService(uint8_t service) {
  if (not filter.services) {
    filter.services = std::vector<uint8_t>({service});
  }
  filter.services.value().push_back(service);
}

void TmStore::addServiceSubservice(uint8_t service, uint8_t subservice) {
  if (not filter.serviceSubservices) {
    filter.serviceSubservices =
        std::vector<std::pair<uint8_t, uint8_t>>({std::pair(service, subservice)});
  }
  filter.serviceSubservices.value().push_back({service, subservice});
}