cSyncDir.h

Go to the documentation of this file.

//
//
#ifndef _INC_cSyncDir_H
#define _INC_cSyncDir_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../FileSys/cManifestDir.h"
#include "GrayCore/include/cFileCopier.h"
 
namespace GrayLib
{
        enum CSYNC_TYPE
        {
                CSYNC_None = 0,         
                CSYNC_Pull,                     
                CSYNC_Push,                     
                CSYNC_Newer,            
                CSYNC_QTY,                      
        };
 
        enum CSYNCOP_TYPE
        {
#define cSyncDirOpDef(a,b)      CSYNCOP_##a,
#include "cSyncDirOps.tbl"
#undef cSyncDirOpDef
                CSYNCOP_QTY,
        };
 
        class GRAYLIB_LINK cSyncOp : public cRefBase
        {
 
        public:
                cSyncOp* const m_pParent;                       
                CSYNCOP_TYPE m_eOp;                     
                cManifestElemPtr const m_pElem; 
 
                CSYNC_TYPE m_eChildOpTypes;             
                cArraySortName<cSyncOp> m_aChildElems;  
 
        public:
                cSyncOp(cSyncOp* pParent, CSYNCOP_TYPE eOp, cManifestElem* pElem)
                        : m_pParent(pParent)
                        , m_eOp(eOp)
                        , m_pElem(pElem)
                        , m_eChildOpTypes(CSYNC_None)
                {
                        ASSERT(eOp >= CSYNCOP_Null && eOp < CSYNCOP_QTY);
                        ASSERT(pElem != nullptr);
                }
                ~cSyncOp()
                {
                }
 
#ifdef _DEBUG
                static const char* GRAYCALL GetOpStr(CSYNCOP_TYPE eOp);
#endif
 
                cStringF get_Name() const
                {
                        return m_pElem->get_Name();
                }
                bool isAttrDir() const
                {
                        return m_pElem->m_ElemData.isAttrDir();
                }
 
                cStringF get_RelativePath() const
                {
                        if (m_pParent != nullptr)
                        {
                                // recurse up my parent tree.
                                return cFilePath::CombineFilePathX(m_pParent->get_RelativePath(), get_Name());
                        }
                        return get_Name();
                }
 
                static inline bool IsOpPull(CSYNCOP_TYPE eOp)
                {
                        return(eOp < CSYNCOP_RemoteStub);
                }
                bool IsOpPull() const
                {
                        return IsOpPull(m_eOp);
                }
 
                void AddChildOpType(CSYNCOP_TYPE eOp)
                {
                        if (eOp == CSYNCOP_Null)        // nothing.
                                return;
                        if (IsOpPull(eOp))
                        {
                                m_eChildOpTypes = (CSYNC_TYPE)(m_eChildOpTypes | CSYNC_Pull);
                        }
                        else
                        {
                                m_eChildOpTypes = (CSYNC_TYPE)(m_eChildOpTypes | CSYNC_Push);
                        }
                }
 
                void AddChildOp(cSyncOp* pOp)
                {
                        ASSERT(pOp != nullptr);
                        ASSERT(pOp->m_pParent == this);
                        AddChildOpType(pOp->m_eOp);
                        m_aChildElems.Add(pOp);
                }
        };
        typedef cRefPtr<cSyncOp> cSyncOpPtr;
 
        class GRAYLIB_LINK cSyncContext : public cManifestContext
        {
 
        public:
                static const FILECHAR_t sm_szLimboDir[];        
 
                IFileCopier* m_pRemoteConnect;                  
                cSyncOpPtr m_pOpRoot;                                   
 
                TIMESECD_t m_nManifestCacheAge;                 
                cStringF m_sManCachePrefix;                             
 
                cStreamProgress m_Rx;           
                cStreamProgress m_Tx;           
 
        public:
                cSyncContext(cStringF sDirRoot, const FILECHAR_t* pszManifestFileName = nullptr, cLogProcessor* pLog = nullptr, IStreamProgressCallback* pProgress = nullptr);
                cSyncContext(const cManifestContext& context);
                ~cSyncContext();
 
                HRESULT _cdecl LogFileOpf(LOG_ATTR_MASK_t uAttrMask, LOGLEV_TYPE eLogLevel, const FILECHAR_t* pszFile, const LOGCHAR_t* pszFormat, ...);
 
                HRESULT SendFile(cStringF sFilePathSrc, cStringF sRelPathDest, IStreamProgressCallback* pProgress1 = nullptr, FILE_SIZE_t nOffset = 0, FILE_SIZE_t nSize = (FILE_SIZE_t)-1);
                HRESULT RequestFile(cStringF sRelPathSrc, cStringF sFilePathDest, IStreamProgressCallback* pProgress1 = nullptr, FILE_SIZE_t nOffset = 0, FILE_SIZE_t* pnSizeEst = nullptr);
 
                cStringF GetManifestCacheName(cStringF sManRemoteDir) const;
                HRESULT FlushManifestCache(cStringF sManRemoteDir = "");
                HRESULT SyncManifestFromCache(cManifestDir& manRemote, cStringF sManRemoteDest);
                HRESULT SyncManifestFromRemote2(cManifestDir& manRemote, cStringF sManRemoteDir, cStringF sManifestCacheName);
                HRESULT SyncManifestFromRemote(cManifestDir& manRemote, cStringF sManRemoteDir);
 
                HRESULT SyncIfChanged(cManifestDir& manRemote, const FILECHAR_t* pszSrcName, const FILECHAR_t* pszLocalName = nullptr);
                HRESULT SyncDirPackage(cStringF sPathLocalDir);
 
                HRESULT SetLocalAttr(const FILECHAR_t* pszLocalPath, const cManifestElem* pFileDst, bool bSetName);
                HRESULT SetLocalAttrAndCRC(const FILECHAR_t* pszLocalPath, const cManifestElem* pFileDst, bool bSetName);
                HRESULT SetLocalAttr2(const FILECHAR_t* pszLocalPath, const cManifestElem* pFileDst, bool bSetName);
 
                static HRESULT GRAYCALL DoMoveLimboFiles(const FILECHAR_t* pszRootDir, cLogProcessor* pLog, IStreamProgressCallback* pProgress);
        };
 
        class GRAYLIB_LINK cSyncBuilder : public cManifestBuilder
        {
 
                typedef cManifestBuilder SUPER_t;
 
        public:
                cSyncContext& m_Context;
 
                // control params
                bool m_bRootOnly;                               
                CSYNC_TYPE m_eSyncType;                 
                cArraySortString<FILECHAR_t> m_aLockedFiles;    
 
                // How many bytes to check? Total bytes in manifests.
                cStreamProgress m_Remote;               
                cStreamProgress m_Local;                
                bool m_bEstimateComplete;               
 
        protected:
                HRESULT UpdateProgress();
 
                void BuildOpAdd(cSyncOp* pOp);
                HRESULT BuildOpDir2(cSyncOp* pOpDir, COMPARE_t iComp, cManifestElem* pFileElem);
                HRESULT BuildOpElem(cSyncOp* pOpDir, const cManifestDir& manLocal, cManifestElem* pFileRemote, cManifestElem* pFileLocal);
                HRESULT BuildOpDir(cSyncOp* pOpDir);
 
        public:
                cSyncBuilder(cSyncContext& context);
                virtual ~cSyncBuilder();
 
                bool isEstimateComplete() const
                {
                        return m_bEstimateComplete;
                }
 
                HRESULT BuildOpList(const FILECHAR_t* pszRelativePath = nullptr, CSYNC_TYPE eSyncType = CSYNC_Pull);    // First pass. estimate.
        };
 
        class GRAYLIB_LINK cSyncDir : public IStreamProgressCallback
        {
 
        public:
                static const LOGCHAR_t sm_szFileInLimbo[];      
 
                cSyncContext& m_Context;
 
                bool m_bRecycleDeletes;                                 
 
                FILE_SIZE_t m_RxPrev;           
                FILE_SIZE_t m_TxPrev;           
 
        protected:
                // list of operations to perform.
                cSyncOpPtr m_pOpCur;            
 
        protected:
                virtual HRESULT _stdcall onProgressCallback(const cStreamProgress& progress) override;
 
                HRESULT DoOp_LocalAttr(cManifestDir* pManLocal);
                HRESULT DoOp_PullFromRemote(cManifestDir* pManLocal);
                HRESULT DoOp_LocalDelete(cManifestDir* pManLocal);
 
                HRESULT DoOp_RemoteAttr();
                HRESULT DoOp_PushToRemote();
                HRESULT DoOp_RemoteDelete();
 
                HRESULT DoOp_Dir();
                HRESULT ExecSyncOp(cManifestDir* pManLocal, cSyncOp* pOp);
 
        public:
                cSyncDir(cSyncContext& context);
                virtual ~cSyncDir();
 
                HRESULT ExecSyncOps();  // Second pass. start moving the files.
        };
}
 
#endif