FTPManager.h

Go to the documentation of this file.

#pragma once
 
#include "MAVLinkFTP.h"
 
#include <QtCore/QObject>
#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/QTimer>
class Vehicle;
 
class FTPManager : public QObject
{
    Q_OBJECT
 
    friend class Vehicle;
 
public:
    FTPManager(Vehicle* vehicle);
 
    bool download(uint8_t fromCompId, const QString& fromURI, const QString& toDir, const QString& fileName="", bool checksize = true);
 
    bool upload(uint8_t toCompId, const QString& toURI, const QString& fromFile);
 
    bool listDirectory(uint8_t fromCompId, const QString& fromURI);
 
    bool listDirectoryWithTimeUnsupported() const { return _listDirWithTimeSupport == WithTimeSupport_t::Unsupported; }
 
    bool deleteFile(uint8_t fromCompId, const QString& fromURI);
 
    void cancelDownload();
 
    void cancelListDirectory();
 
    void cancelDelete();
 
    void cancelUpload();
 
    static constexpr const char* mavlinkFTPScheme = "mftp";
 
signals:
    void downloadComplete       (const QString& file, const QString& errorMsg);
    void uploadComplete         (const QString& file, const QString& errorMsg);
    void listDirectoryComplete  (const QStringList& dirList, const QString& errorMsg);
    void deleteComplete         (const QString& file, const QString& errorMsg);
 
    void commandProgress(float value);
 
private slots:
    void _ackOrNakTimeout(void);
 
private:
    typedef void (FTPManager::*StateBeginFn)    (void);
    typedef void (FTPManager::*StateAckNakFn)   (const MavlinkFTP::Request* ackOrNak);
    typedef void (FTPManager::*StateTimeoutFn)  (void);
 
    struct StateFunctions_t {
        StateBeginFn    beginFn;
        StateAckNakFn   ackNakFn;
        StateTimeoutFn  timeoutFn;
    };
 
    struct MissingData_t {
        uint32_t offset;
        uint32_t cBytesMissing;
    };
 
    struct DownloadState_t {
        uint8_t                 sessionId;
        uint32_t                expectedOffset;         
        uint32_t                bytesWritten;
        QList<MissingData_t>    rgMissingData;
        QString                 fullPathOnVehicle;      
        QDir                    toDir;                  
        QString                 fileName;               
        uint32_t                fileSize;               
        QFile                   file;
        int                     retryCount;
        bool                    checksize;
        int                     sessionReopenCount;     
        int                     resumeStateIndex;       
        bool                    active = false;         
 
        bool inProgress() const { return active; }
 
        void reset() {
            sessionId       = 0;
            expectedOffset  = 0;
            bytesWritten    = 0;
            retryCount      = 0;
            fileSize        = 0;
            sessionReopenCount = 0;
            resumeStateIndex = -1;
            active          = false;
            fullPathOnVehicle.clear();
            fileName.clear();
            rgMissingData.clear();
            file.close();
        }
    };
 
    struct ListDirectoryState_t {
        uint8_t                 sessionId;
        uint32_t                expectedOffset;         
        QString                 fullPathOnVehicle;      
        QStringList             rgDirectoryList;
        int                     retryCount;
        MavlinkFTP::OpCode_t    opCode;                 
 
        bool inProgress() const { return !fullPathOnVehicle.isEmpty(); }
 
        void reset() {
            sessionId       = 0;
            expectedOffset  = 0;
            fullPathOnVehicle.clear();
            rgDirectoryList.clear();
            retryCount      = 0;
            opCode          = MavlinkFTP::kCmdListDirectory;
        }
    };
 
    enum class WithTimeSupport_t { Unknown, Supported, Unsupported };
 
    struct DeleteFileState_t {
        QString fullPathOnVehicle;      
        int     retryCount = 0;
 
        bool inProgress() const { return !fullPathOnVehicle.isEmpty(); }
 
        void reset() {
            fullPathOnVehicle.clear();
            retryCount = 0;
        }
    };
 
    struct UploadState_t {
        uint8_t     sessionId;
        uint32_t    totalBytesSent;
        uint32_t    fileSize;
        uint32_t    lastChunkSize;
        QFile       file;
        QString     fullPathOnVehicle;      
        QString     localFilePath;          
        int         retryCount;
        bool        cancelled;
 
        bool inProgress() const { return file.isOpen(); }
 
        void reset() {
            sessionId       = 0;
            totalBytesSent  = 0;
            fileSize        = 0;
            lastChunkSize   = 0;
            retryCount      = 0;
            cancelled       = false;
            fullPathOnVehicle.clear();
            localFilePath.clear();
            file.close();
        }
    };
 
    void    _mavlinkMessageReceived     (const mavlink_message_t& message);
    void    _startStateMachine          (void);
    void    _advanceStateMachine        (void);
    void    _listDirectoryBegin         (void);
    void    _listDirectoryAckOrNak      (const MavlinkFTP::Request* ackOrNak);
    void    _listDirectoryTimeout       (void);
    void    _openFileROBegin            (void);
    void    _openFileROAckOrNak         (const MavlinkFTP::Request* ackOrNak);
    void    _openFileROTimeout          (void);
    void    _burstReadFileBegin         (void);
    void    _burstReadFileAckOrNak      (const MavlinkFTP::Request* ackOrNak);
    void    _burstReadFileTimeout       (void);
    void    _fillMissingBlocksBegin     (void);
    void    _fillMissingBlocksAckOrNak  (const MavlinkFTP::Request* ackOrNak);
    void    _fillMissingBlocksTimeout   (void);
    void    _resetSessionsBegin         (void);
    void    _resetSessionsAckOrNak      (const MavlinkFTP::Request* ackOrNak);
    void    _resetSessionsTimeout       (void);
    void    _clearStaleSessionsBegin    (void);
    void    _clearStaleSessionsAckOrNak (const MavlinkFTP::Request* ackOrNak);
    void    _clearStaleSessionsTimeout  (void);
    void    _sendResetSessionsNoAck     (void);
    void    _setStateMachine            (const StateFunctions_t* rgStates, size_t cStates);
    QString _errorMsgFromNak            (const MavlinkFTP::Request* nak);
    void    _sendRequestExpectAck       (MavlinkFTP::Request* request);
    void    _downloadCompleteNoError    (void) { _downloadComplete(QString()); }
    void    _downloadComplete           (const QString& errorMsg);
    void    _fillRequestDataWithString(MavlinkFTP::Request* request, const QString& str);
    void    _fillMissingBlocksWorker    (bool firstRequest);
    void    _burstReadFileWorker        (bool firstRequest);
    uint8_t _readChunkSize              (void) const;
    void    _downloadSessionLost        (void);
    bool    _claimMissingRange          (uint32_t offset, uint32_t cBytes);
    void    _listDirectoryWorker        (bool firstRequest);
    bool    _parseURI                   (uint8_t fromCompId, const QString& uri, QString& parsedURI, uint8_t& compId);
    void    _listDirectoryCompleteNoError(void) { _listDirectoryComplete(QString()); }
    void    _listDirectoryComplete      (const QString& errorMsg);
    void    _deleteFileBegin            (void);
    void    _deleteFileAckOrNak         (const MavlinkFTP::Request* ackOrNak);
    void    _deleteFileTimeout          (void);
    void    _deleteCompleteNoError      (void) { _deleteComplete(QString()); }
    void    _deleteComplete             (const QString& errorMsg);
 
    void    _createFileBegin            (void);
    void    _createFileAckOrNak         (const MavlinkFTP::Request* ackOrNak);
    void    _createFileTimeout          (void);
    void    _writeFileBegin             (void);
    void    _writeFileAckOrNak          (const MavlinkFTP::Request* ackOrNak);
    void    _writeFileTimeout           (void);
    void    _writeFileWorker            (bool firstRequest);
    void    _uploadFinalize             (void);
    void    _uploadComplete             (const QString& errorMsg);
    void    _terminateUploadSessionBegin(void);
    void    _terminateUploadSessionAckOrNak(const MavlinkFTP::Request* ackOrNak);
    void    _terminateUploadSessionTimeout(void);
 
    Vehicle*                _vehicle;
    uint8_t                 _ftpCompId = MAV_COMP_ID_AUTOPILOT1;
    QList<StateFunctions_t> _rgStateMachine;
    DownloadState_t         _downloadState;
    ListDirectoryState_t    _listDirectoryState;
    DeleteFileState_t       _deleteState;
    UploadState_t           _uploadState;
    QTimer                  _ackOrNakTimeoutTimer;
    int                     _currentStateMachineIndex   = -1;
    int                     _clearStaleSessionsRetryCount = 0;
    uint16_t                _expectedIncomingSeqNumber  = 0;
    WithTimeSupport_t       _listDirWithTimeSupport     = WithTimeSupport_t::Unknown;
 
    // Loaded SiK radios queue up to ~2.5s; a shorter timeout misreads that as a dead stream and restarts the burst
    static const int _ackOrNakTimeoutMsecs  = 3000;
    static const int _maxRetry              = 3;
 
public:
    static constexpr uint8_t kFullReadChunkSize = sizeof(MavlinkFTP::Request::data);
    static constexpr uint8_t kRadioReadChunkSize = 110;
    static constexpr int kMaxDownloadSessionReopens = 2;
    static constexpr int kTestAckTimeoutMs = 10;
    static constexpr int kTestOperationMaxWaitMs = 5000;
};