ftp_library.h

Go to the documentation of this file.

// Copyright 2018-present Network Optix, Inc. Licensed under MPL 2.0: www.mozilla.org/MPL/2.0/

#pragma once

#include <atomic>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <string>
#include <vector>

#include <stdint.h>

#include "ftplibpp/ftplib.h"
#include "storage/third_party_storage.h"

namespace nx_spl
{
namespace aux
{   // Generic reference counter Mix-In. Private inherit it.
    template <typename P>
    class PluginRefCounter
    {
    public:
        PluginRefCounter()
            : m_count(1)
        {}

        int p_addRef() const { return ++m_count; }

        int p_releaseRef() const
        {
            int new_count = --m_count;
            if (new_count <= 0) {
                delete static_cast<const P*>(this);
            }
            return new_count;
        }
    private:
        mutable std::atomic<int> m_count;
    }; // class PluginRefCounter

    class NonCopyable
    {
    public:
        NonCopyable() {}
        NonCopyable(const NonCopyable&);
        NonCopyable& operator =(const NonCopyable&);

        NonCopyable(NonCopyable&&);
        NonCopyable& operator =(NonCopyable&&);
    }; // class NonCopyable

    struct FileNameAndPath
    {
        std::string name;
        std::string fullPath;
    };

class FtpLibWrapper;

} //namespace aux

    using FtpImplPtr = std::shared_ptr<aux::FtpLibWrapper>;
    class FtpStorage;
    // At construction phase we synchronize remote file with local one.
    // During destruction synchronization attempt is repeated.
    // All intermediate actions (read/write/seek) are made with the local copy.
    class FtpIODevice
        : public IODevice,
          private aux::NonCopyable,
          private aux::PluginRefCounter<FtpIODevice>
    {
        friend class aux::PluginRefCounter<FtpIODevice>;
    public:
        FtpIODevice(FtpImplPtr ftpImplPtr, const char *uri, int mode);

        virtual uint32_t STORAGE_METHOD_CALL write(
            const void*     src,
            const uint32_t  size,
            int*            ecode
        ) override;

        virtual uint32_t STORAGE_METHOD_CALL read(
            void*           dst,
            const uint32_t  size,
            int*            ecode
        ) const override;

        virtual int STORAGE_METHOD_CALL seek(
            uint64_t    pos,
            int*        ecode
        ) override;

        virtual int      STORAGE_METHOD_CALL getMode() const override;
        virtual uint32_t STORAGE_METHOD_CALL size(int* ecode) const override;

    public: // plugin interface implementation
        virtual void* queryInterface(const nxpl::NX_GUID& interfaceID) override;

        virtual int addRef() const override;
        virtual int releaseRef() const override;

    private:
        // synchronize local file with remote one
        void flush();
        // delete only via releaseRef()
        ~FtpIODevice();

    private:
        FtpImplPtr m_impl;
        int m_mode;
        mutable int64_t m_pos;
        std::string m_uri; //file URI
        aux::FileNameAndPath m_localfile;
        bool m_altered;
        long long m_localsize;
        mutable std::mutex m_mutex;
        std::string m_implurl;
        std::string m_user;
        std::string m_passwd;
    };

    // Fileinfo list is obtained from the server at construction phase.
    // After this phase there are no real interactions with FTP server.
    class FtpFileInfoIterator
        : public FileInfoIterator,
          private aux::NonCopyable,
          private aux::PluginRefCounter<FtpFileInfoIterator>
    {
        friend class aux::PluginRefCounter<FtpFileInfoIterator>;

        typedef std::vector<std::string> FileListType;
        typedef FileListType::const_iterator FileListIteratorType;
    public:
        FtpFileInfoIterator(FtpImplPtr impl, FileListType&& fileList);
        virtual FileInfo* STORAGE_METHOD_CALL next(int* ecode) const override;

    public: // plugin interface implementation
        virtual void* queryInterface(const nxpl::NX_GUID& interfaceID) override;

        virtual int addRef() const override;
        virtual int releaseRef() const override;

    private:
        ~FtpFileInfoIterator();

    private:
        FtpImplPtr m_impl;
        mutable FileInfo m_fileInfo;
        FileListType m_fileList;
        mutable FileListIteratorType m_curFile;
    }; // class FtpFileListIterator

    class FtpStorage
        : public Storage,
          private aux::NonCopyable,
          private aux::PluginRefCounter<FtpStorage>
    {
        friend class aux::PluginRefCounter<FtpStorage>;

    public:
        FtpStorage(const std::string& url);

    public: // Storage interface implementation
        virtual int STORAGE_METHOD_CALL isAvailable() const override;

        virtual IODevice* STORAGE_METHOD_CALL open(
            const char*     uri,
            int             flags,
            int*            ecode
        ) const override;

        virtual uint64_t STORAGE_METHOD_CALL getFreeSpace(int* ecode) const override;
        virtual uint64_t STORAGE_METHOD_CALL getTotalSpace(int* ecode) const override;
        virtual int STORAGE_METHOD_CALL getCapabilities() const override;

        virtual void STORAGE_METHOD_CALL removeFile(
            const char* url,
            int*        ecode
        ) override;

        virtual void STORAGE_METHOD_CALL removeDir(
            const char* url,
            int*        ecode
        ) override;

        virtual void STORAGE_METHOD_CALL renameFile(
            const char*     oldUrl,
            const char*     newUrl,
            int*            ecode
        ) override;

        virtual FileInfoIterator* STORAGE_METHOD_CALL getFileIterator(
            const char*     dirUrl,
            int*            ecode
        ) const override;

        virtual int STORAGE_METHOD_CALL fileExists(
            const char*     url,
            int*            ecode
        ) const override;

        virtual int STORAGE_METHOD_CALL dirExists(
            const char*     url,
            int*            ecode
        ) const override;

        virtual uint64_t STORAGE_METHOD_CALL fileSize(
            const char*     url,
            int*            ecode
        ) const override;

    public: // plugin interface implementation
        virtual void* queryInterface(const nxpl::NX_GUID& interfaceID) override;

        virtual int addRef() const override;
        virtual int releaseRef() const override;

    private:
        // destroy only via releaseRef()
        ~FtpStorage();

    private:
        FtpImplPtr m_impl;
        mutable std::mutex m_mutex;
        mutable int m_capabilities = 0;
    }; // class Ftpstorage

    class FtpStorageFactory
        : public StorageFactory,
          private aux::NonCopyable,
          private aux::PluginRefCounter<FtpStorageFactory>
    {
        friend class aux::PluginRefCounter<FtpStorageFactory>;
    public:
        FtpStorageFactory();
        // currently unimplemented
        virtual const char** STORAGE_METHOD_CALL findAvailable() const override;

        virtual Storage* STORAGE_METHOD_CALL createStorage(
            const char* url,
            int*        ecode
        ) override;

        virtual const char* STORAGE_METHOD_CALL storageType() const override;
        virtual const char* lastErrorMessage(int ecode) const override;

    public: // plugin interface implementation
        virtual void* queryInterface(const nxpl::NX_GUID& interfaceID) override;

        virtual int addRef() const override;
        virtual int releaseRef() const override;
    }; // class FtpStorageFactory
} // namespace Qn