Engine.hpp

Go to the documentation of this file.

// ======================================================================
// \title  Engine.hpp
// \brief  CFDP Engine header
//
// This file is a port of CFDP engine definitions from the following files
// from the NASA Core Flight System (cFS) CFDP (CF) Application, version 3.0.0,
// adapted for use within the F-Prime (F') framework:
// - cf_cfdp.h (CFDP engine and packet parsing definitions)
//
// CFDP engine and packet parsing header file
//
// ======================================================================
//
// NASA Docket No. GSC-18,447-1
//
// Copyright (c) 2019 United States Government as represented by the
// Administrator of the National Aeronautics and Space Administration.
// All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ======================================================================

#ifndef CFDP_ENGINE_HPP
#define CFDP_ENGINE_HPP

#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Types/MemAllocator.hpp>

#include <Svc/Ccsds/CfdpManager/Transaction.hpp>
#include <Svc/Ccsds/CfdpManager/Types/ChannelTelemetrySerializableAc.hpp>
#include <Svc/Ccsds/CfdpManager/Types/PduBase.hpp>
#include <Svc/Ccsds/CfdpManager/Types/Types.hpp>

// Forward declarations - do NOT include CfdpManager.hpp to avoid circular dependency
namespace Svc {
namespace Ccsds {
class CfdpManager;  // CfdpManager stays in Svc::Ccsds
namespace Cfdp {
class Channel;  // Channel is in Svc::Ccsds::Cfdp
}
}  // namespace Ccsds
}  // namespace Svc

namespace Svc {
namespace Ccsds {
namespace Cfdp {

struct CycleTxArgs {
    Channel* chan; 
    I32 ran_one;   
};

struct TickArgs {
    Channel* chan;                 
    void (Transaction::*fn)(I32*); 
    bool early_exit;               
    I32 cont;                      
};

class Engine {
  public:
    // ----------------------------------------------------------------------
    // Construction and destruction
    // ----------------------------------------------------------------------

    explicit Engine(CfdpManager* manager);

    virtual ~Engine();

    // ----------------------------------------------------------------------
    // Public interface
    // ----------------------------------------------------------------------

    void init(Fw::MemAllocator& allocator, FwEnumStoreType memId);

    void cycle();

    void receivePdu(U8 chan_id, const Fw::Buffer& buffer);

    Status::T txFile(const Fw::String& src,
                     const Fw::String& dst,
                     Class::T cfdp_class,
                     Keep::T keep,
                     U8 chan_num,
                     U8 priority,
                     EntityId dest_id,
                     TransactionInitType initType = TransactionInitType::INIT_BY_COMMAND);

    Status::T playbackDir(const Fw::String& src,
                          const Fw::String& dst,
                          Class::T cfdp_class,
                          Keep::T keep,
                          U8 chan,
                          U8 priority,
                          EntityId dest_id);

    Status::T startPollDir(U8 chanId,
                           U8 pollId,
                           const Fw::String& srcDir,
                           const Fw::String& dstDir,
                           Class::T cfdp_class,
                           U8 priority,
                           EntityId destEid,
                           U32 intervalSec);

    Status::T stopPollDir(U8 chanId, U8 pollId);

    void setChannelFlowState(U8 channelId, Flow::T flowState);

    Status::T setSuspendResumeTransaction(U8 channelId,
                                          TransactionSeq transactionSeq,
                                          EntityId entityId,
                                          SuspendResume::T action);

    Status::T cancelTransactionBySeq(U8 channelId, TransactionSeq transactionSeq, EntityId entityId);

    Status::T abandonTransaction(U8 channelId, TransactionSeq transactionSeq, EntityId entityId);

    // ----------------------------------------------------------------------
    // Public Transaction Interface
    // Methods used by CfdpRx/CfdpTx transaction processing
    // ----------------------------------------------------------------------

    void finishTransaction(Transaction* txn, bool keep_history);

    void setTxnStatus(Transaction* txn, TxnStatus txn_stat);

    void armAckTimer(Transaction* txn);

    void armInactTimer(Transaction* txn);

    virtual Status::T sendMd(Transaction* txn);

    Status::T sendFd(Transaction* txn, FileDataPdu& fdPdu);

    Status::T sendEof(Transaction* txn);

    Status::T sendAck(Transaction* txn,
                      AckTxnStatus ts,
                      FileDirective dir_code,
                      ConditionCode cc,
                      EntityId peer_eid,
                      TransactionSeq tsn);

    Status::T sendFin(Transaction* txn, FinDeliveryCode dc, FinFileStatus fs, ConditionCode cc);

    Status::T sendNak(Transaction* txn, NakPdu& nakPdu);

    void recvMd(Transaction* txn, const MetadataPdu& pdu);

    Status::T recvFd(Transaction* txn, const FileDataPdu& pdu);

    Status::T recvEof(Transaction* txn, const EofPdu& pdu);

    Status::T recvFin(Transaction* txn, const FinPdu& pdu);

    Status::T recvNak(Transaction* txn, const NakPdu& pdu);

    void txFileInitiate(Transaction* txn, Class::T cfdp_class, Keep::T keep, U8 chan, U8 priority, EntityId dest_id);

    Status::T playbackDirInitiate(Playback* pb,
                                  const Fw::String& src_filename,
                                  const Fw::String& dst_filename,
                                  Class::T cfdp_class,
                                  Keep::T keep,
                                  U8 chan,
                                  U8 priority,
                                  EntityId dest_id);

    void dispatchTx(Transaction* txn);

    Cfdp::ChannelTelemetry& getChannelTelemetryRef(U8 channelId);

  private:
    // ----------------------------------------------------------------------
    // Private member variables
    // ----------------------------------------------------------------------

    CfdpManager* m_manager;

    Channel* m_channels[Cfdp::NumChannels];

    TransactionSeq m_seqNum;

    Fw::MemAllocator* m_allocator;

    FwEnumStoreType m_allocatorId;

    // Note: Transactions, histories, and chunks are now owned by each Channel

    // ----------------------------------------------------------------------
    // Private helper methods
    // All the non-public CFDP functions converted to methods
    // ----------------------------------------------------------------------

    // Transaction Management

    void cancelTransaction(Transaction* txn);

    Transaction* startRxTransaction(U8 chan_num);

    // PDU Operations - Send

    Status::T serializeAndSendPdu(Transaction* txn, PduBase& pdu);

    Status::T serializeAndSendPduOnChannel(Channel& chan, PduBase& pdu);

    Status::T sendFinAckStateless(Channel& chan,
                                  TransactionSeq tsn,
                                  EntityId finSrcEid,
                                  EntityId finDstEid,
                                  ConditionCode cc);

    // PDU Operations - Receive

    void recvDrop(Transaction* txn, const Fw::Buffer& buffer);

    void recvHold(Transaction* txn, const Fw::Buffer& buffer);

    bool recvInit(Transaction* txn, const Fw::Buffer& buffer);

    // Dispatch

    void dispatchRecv(Transaction* txn, const Fw::Buffer& buffer);

    // Channel Processing

    bool isPollingDir(const Fw::StringBase& src_file, U8 chan_num);

    void handleNotKeepFile(Transaction* txn);

    // Friend declarations for testing
    friend class CfdpManagerTester;
};

}  // namespace Cfdp
}  // namespace Ccsds
}  // namespace Svc

#endif /* !CFDP_ENGINE_HPP */