Work/dp catalog review updates

Ref/SignalGen/test/ut/SignalGenTester.cpp

@@ -25,6 +25,7 @@ namespace Ref {
   {
     this->initComponents();
     this->connectPorts();
+    this->m_reqDpBuff.set(this->m_dpBuff,sizeof(this->m_dpBuff));
   }
 
   SignalGenTester ::
@@ -46,5 +47,41 @@ namespace Ref {
        invoke_to_schedIn(0, 0);
        component.doDispatch();
        ASSERT_TLM_Output_SIZE(1);
+       sendCmd_Dp(0,10,Ref::SignalGen_DpReqType::IMMEDIATE,1,1);
+       component.doDispatch();
+       // verify request for data product buffer
+       ASSERT_PRODUCT_GET_SIZE(1);
+       // run 2 cycles, should output data product on second
+       invoke_to_schedIn(0, 0);
+       ASSERT_PRODUCT_SEND_SIZE(1);
+
   }
+
+    //! Handle a text event
+    void SignalGenTester::textLogIn(
+        FwEventIdType id, //!< The event ID
+        const Fw::Time& timeTag, //!< The time
+        const Fw::LogSeverity severity, //!< The severity
+        const Fw::TextLogString& text //!< The event string
+    ) {
+      TextLogEntry e = { id, timeTag, severity, text };
+
+      printTextLogHistoryEntry(e, stdout);
+
+    }
+
+    Fw::Success::T SignalGenTester ::
+    productGet_handler(
+        FwDpIdType id,
+        FwSizeType dataSize,
+        Fw::Buffer& buffer
+    )
+  {
+    printf ("Component requested %" PRI_FwSizeType " bytes.\n",dataSize);
+    buffer.set(this->m_dpBuff,dataSize);
+    this->pushProductGetEntry(id, dataSize);
+    return Fw::Success::SUCCESS;
+  }
+
+
 } // end namespace Ref

Ref/SignalGen/test/ut/SignalGenTester.hpp

@@ -67,6 +67,18 @@ namespace Ref {
 
     private:
 
+      //! Handle a data product get from the component under test
+      //!
+      //! By default, (1) call pushProductGetEntry; (2) do not allocate a buffer
+      //! and return FAILURE. You can override this behavior, e.g., to call
+      //! pushProductGetEntry, allocate a buffer and return SUCCESS.
+      virtual Fw::Success::T productGet_handler(
+        FwDpIdType id, //!< The container ID (input)
+        FwSizeType dataSize, //!< The data size of the requested buffer (input)
+        Fw::Buffer& buffer //!< The buffer (output)
+      );
+
+
       // ----------------------------------------------------------------------
       // Variables
       // ----------------------------------------------------------------------
@@ -75,6 +87,16 @@ namespace Ref {
       //!
       SignalGen component;
 
+      void textLogIn(
+        FwEventIdType id, //!< The event ID
+        const Fw::Time& timeTag, //!< The time
+        const Fw::LogSeverity severity, //!< The severity
+        const Fw::TextLogString& text //!< The event string
+      ) override;
+
+      U8 m_dpBuff[1024];
+      Fw::Buffer m_reqDpBuff;
+
   };
 
 } // end namespace Ref

Svc/DpCatalog/DpCatalog.cpp

@@ -61,6 +61,7 @@ namespace Svc {
 
         // Do some assertion checks
         FW_ASSERT(numDirs <= DP_MAX_DIRECTORIES, static_cast<FwAssertArgType>(numDirs));
+        FW_ASSERT(stateFile.length());
         this->m_stateFile = stateFile;
 
         // request memory for catalog which is DP_MAX_FILES * slot size.
@@ -130,6 +131,7 @@ namespace Svc {
     void DpCatalog::resetBinaryTree() {
         // initialize data structures in the free list
         // Step 2 in memory partition (see configure() comments)
+        FW_ASSERT(this->m_memPtr);
         this->m_freeListHead = static_cast<DpBtreeNode*>(this->m_memPtr); 
         for (FwSizeType slot = 0; slot < this->m_numDpSlots; slot++) {
             // overlay new instance of the DpState entry on the memory
@@ -147,6 +149,7 @@ namespace Svc {
         this->m_dpTree = nullptr;
         // reset number of records
         this->m_numDpRecords = 0;
+
     }
 
     void DpCatalog::resetStateFileData() {
@@ -210,7 +213,9 @@ namespace Svc {
             }
 
             // reset the buffer for deserializing the entry
-            entryBuffer.setBuffLen(static_cast<Fw::Serializable::SizeType>(size));
+            Fw::SerializeStatus serStat = entryBuffer.setBuffLen(static_cast<Fw::Serializable::SizeType>(size));
+            // should always fit
+            FW_ASSERT(Fw::FW_SERIALIZE_OK == serStat,serStat);
             entryBuffer.resetDeser();
 
             // deserialization after this point should always work, since
@@ -290,8 +295,12 @@ namespace Svc {
                 // reset the buffer for serializing the entry
                 entryBuffer.resetSer();
                 // serialize the file directory index
-                entryBuffer.serialize(this->m_stateFileData[entry].entry.dir);
-                entryBuffer.serialize(this->m_stateFileData[entry].entry.record);
+                Fw::SerializeStatus serStat = entryBuffer.serialize(this->m_stateFileData[entry].entry.dir);
+                // Should always fit
+                FW_ASSERT(Fw::FW_SERIALIZE_OK == serStat,serStat);
+                serStat = entryBuffer.serialize(this->m_stateFileData[entry].entry.record);
+                // Should always fit
+                FW_ASSERT(Fw::FW_SERIALIZE_OK == serStat,serStat);
                 // write the entry
                 FwSignedSizeType size = entryBuffer.getBuffLength();
                 stat = stateFile.write(buffer, size);
@@ -308,9 +317,13 @@ namespace Svc {
 
     void DpCatalog::appendFileState(const DpStateEntry& entry) {
         FW_ASSERT(this->m_stateFileData);
+        FW_ASSERT(entry.dir < static_cast<FwIndexType>(this->m_numDirectories),
+            entry.dir,
+            static_cast<FwAssertArgType>(this->m_numDirectories)
+        );
 
         // We will append state to the existing state file
-        // FIXME: Have to handle case where state file has partially transmitted
+        // TODO: Have to handle case where state file has partially transmitted
         // state already
 
         // open the state file
@@ -323,13 +336,17 @@ namespace Svc {
         }
 
         // buffer for writing entries
-        BYTE buffer[sizeof(FwIndexType)+DpRecord::SERIALIZED_SIZE];
+        BYTE buffer[sizeof(entry.dir)+sizeof(entry.record)];
         Fw::ExternalSerializeBuffer entryBuffer(buffer, sizeof(buffer));
         // reset the buffer for serializing the entry
         entryBuffer.resetSer();
         // serialize the file directory index
-        entryBuffer.serialize(entry.dir);
-        entryBuffer.serialize(entry.record);
+        Fw::SerializeStatus serStat = entryBuffer.serialize(entry.dir);
+        // should fit
+        FW_ASSERT(serStat == Fw::FW_SERIALIZE_OK,serStat);
+        serStat = entryBuffer.serialize(entry.record);
+        // should fit
+        FW_ASSERT(serStat == Fw::FW_SERIALIZE_OK,serStat);
         // write the entry
         FwSignedSizeType size = entryBuffer.getBuffLength();
         stat = stateFile.write(buffer, size);
@@ -375,6 +392,9 @@ namespace Svc {
         // fill the binary tree with DP files
         response = this->fillBinaryTree();
         if (response != Fw::CmdResponse::OK) {
+            // clean up the binary tree
+            this->resetBinaryTree();
+            this->resetStateFileData();
             return response;
         }
 
@@ -514,8 +534,12 @@ namespace Svc {
                 this->getFileState(entry);
 
                 // insert entry into sorted list. if can't insert, quit
-                if (not this->insertEntry(entry)) {
+                bool insertedOk = this->insertEntry(entry);
+                if (not insertedOk) {
                     this->log_WARNING_HI_DpInsertError(entry.record);
+                    // clean up and return
+                    this->resetBinaryTree();
+                    this->resetStateFileData();
                     break;
                 }
 
@@ -567,7 +591,10 @@ namespace Svc {
 
         // if the tree is empty, add the first entry
         if (this->m_dpTree == nullptr) {
-            this->allocateNode(this->m_dpTree,entry);
+            bool goodInsert = this->allocateNode(this->m_dpTree,entry);
+            if (not goodInsert) {
+                return false;
+            }
         // otherwise, search depth-first to sort the entry
         } else {
             // to avoid recursion, loop through a max of the number of available records
@@ -619,7 +646,8 @@ namespace Svc {
     DpCatalog::CheckStat DpCatalog::checkLeftRight(bool condition, DpBtreeNode* &node, const DpStateEntry& newEntry) {
         if (condition) {
             if (node->left == nullptr) {
-                if (!this->allocateNode(node->left,newEntry)) {
+                bool allocated = this->allocateNode(node->left,newEntry);
+                if (not allocated) {
                     return CheckStat::CHECK_ERROR;
                 }
                 return CheckStat::CHECK_OK;
@@ -629,7 +657,8 @@ namespace Svc {
             }
         } else {
             if (node->right == nullptr) {
-                if (!this->allocateNode(node->right,newEntry)) {
+                bool allocated = this->allocateNode(node->right,newEntry);
+                if (not allocated) {
                     return CheckStat::CHECK_ERROR;
                 }
                 return CheckStat::CHECK_OK;
@@ -701,7 +730,13 @@ namespace Svc {
                 static_cast<U32>(this->m_currentXmitNode->entry.record.getsize()),
                 this->m_currentXmitNode->entry.record.getpriority()
                 );
-            this->fileOut_out(0, this->m_currXmitFileName, this->m_currXmitFileName, 0, 0);
+            Svc::SendFileResponse resp = this->fileOut_out(0, this->m_currXmitFileName, this->m_currXmitFileName, 0, 0);
+            if (resp.getstatus() != Svc::SendFileStatus::STATUS_OK) {
+                // warn, but keep going since it may be an issue with this file but others could
+                // make it
+                this->log_WARNING_HI_DpFileSendError(this->m_currXmitFileName,resp.getstatus());
+            }
+
         }
 
     } // end sendNextEntry()
@@ -802,7 +837,7 @@ namespace Svc {
 
         // check file status
         if (resp.getstatus() != Svc::SendFileStatus::STATUS_OK) {
-            this->log_WARNING_HI_StateFileXmitError(this->m_currXmitFileName,resp.getstatus());
+            this->log_WARNING_HI_DpFileXmitError(this->m_currXmitFileName,resp.getstatus());
             this->m_xmitInProgress = false;
             this->cmdResponse_out(this->m_xmitOpCode,this->m_xmitCmdSeq,Fw::CmdResponse::EXECUTION_ERROR);
         }

Svc/DpCatalog/DpCatalog.fpp

@@ -347,13 +347,23 @@ module Svc {
       id 40 \
       format "State file {} doesn't exist"
 
-    event StateFileXmitError(
+    event DpFileXmitError(
                             file: string size 80 @< The file
                             stat: Svc.SendFileStatus
                           ) \
       severity warning high \
       id 41 \
-      format "Error transmitting DP file {}, stat {}. Halting xmit."
+      format "Error transmitting DP file {}, stat {}. Halting xmit." \
+      throttle 10
+
+    event DpFileSendError(
+                            file: string size 80 @< The file
+                            stat: Svc.SendFileStatus
+                          ) \
+      severity warning high \
+      id 42 \
+      format "Error sending DP file {}, stat {}. Halting xmit." \
+      throttle 10