MDistributedFileSystem.h

Go to the documentation of this file.

//---------------------------------------------------------------------------
#ifndef MDistributedFileSystemH
#define MDistributedFileSystemH

#include <string>
#include <map>
#include <vector>
#include <list>
#include <tinyxml/tinyxml.h>
#include "MThread.h"
#include "MUtils.h"
#include "FSUtils.h"
#include "MPNLBase.h"

namespace mdfs {

//---------------------------------------------------------------------------
class MDFSPeerBase;
class MDFS;
class MDFSDB;
class MServer;
class MShare;
class MFile;
class MDownload;
class MDFSUpdate;
struct MUser;

typedef std::vector<MServer*> MServerList;
typedef std::vector<MShare*>  MShareList;
typedef std::vector<std::string> MStringList;
typedef std::list<MDFSUpdate*> MUpdateList;
typedef std::list<MDownload> MDownloadList;

//---------------------------------------------------------------------------
struct MUser {
               MUser() {ID = Group = -1;}
   long        ID;
   long        Group;
   std::string Name;
   };
   
//---------------------------------------------------------------------------
struct MConnection {
   MConnection() : Port(0), IsServerLocal(false) {}
   std::string    Host;
   int            Port;
   std::string    LocalIP; // local ip used for this connection
   bool           IsServerLocal; // are we the server and the peer the client ?
   MUser          User;
   TIME           ConDate;
   struct MInfos {
      std::string Name;
      } Infos;
   };

//---------------------------------------------------------------------------
enum  MUserType {utOWNER=0,utGROUP=1,utOTHER=2};

//---------------------------------------------------------------------------
enum  MFileType {ftUNK=0, ftDIR=1, ftFILE=2};

//---------------------------------------------------------------------------
enum  MMode     {mREAD=0,mWRITE=1};

//---------------------------------------------------------------------------
struct MStats {
   MPNL::MTCPServer::MStats Server;
   };
//---------------------------------------------------------------------------
struct MOptions {
   unsigned long ConnectInterval;
   unsigned long QueryInterval;
   unsigned long DownloadQueryInterval;
   };

//---------------------------------------------------------------------------
class MPermission {
public:
         MPermission() {Set("------");}
         MPermission(const std::string& perm) {Set(perm);}
   bool  HasAccess(MMode m, MUserType u) const {return Perm[u*2+m] != '-';}
   void  Set(const std::string& perm) {Perm = perm;}
private:
   std::string Perm;
   };

//---------------------------------------------------------------------------
//enum MShareType {stMAIN, stBACKUP};

//---------------------------------------------------------------------------
// MShare
struct MShare {
   MShare() {} // {Type=stMAIN;}
   std::string URL;
   std::string LocalPath; 
   //MShareType  Type;
   MUser       Owner;
   MPermission Perm;
   };

//---------------------------------------------------------------------------
class MDFSPeerBase {
   //friend class MDFS;
public:
   MConnection    Connection;
   std::string    Msg;
   void*          Data; 

                  MDFSPeerBase() {Data = NULL;}
   virtual        ~MDFSPeerBase() {}
   virtual int    Send(const std::string& msg)=0;

   };

//---------------------------------------------------------------------------
class MPeerClient : public MDFSPeerBase {
public:
   MPeerClient() : MDFSPeerBase() {}
   ~MPeerClient() {}

   int Send(const std::string& msg) {
      return static_cast<MPNL::MSocket*>(Data)->Send(msg);
      }
   };

//---------------------------------------------------------------------------
// MDFSTCPClient
class MDFSTCPClient : public MPNL::MTCPClient {

public:
   MDFSTCPClient(MDFS* dfs) : MPNL::MTCPClient(), DFS(dfs) {}
   ~MDFSTCPClient(){}

   bool OnConnection(MPNL::MSocket* s);
   void OnDisconnection(MPNL::MSocket* s);
private:
   MDFS* DFS;
   };

//---------------------------------------------------------------------------
// MDFSTCPServer
class MDFSTCPServer : public MPNL::MTCPServer {

public:
   MDFSTCPServer(MDFS* dfs) : MPNL::MTCPServer(), DFS(dfs) {}
   ~MDFSTCPServer(){}

   bool OnConnection(MPNL::MSocket* s);
   void OnDisconnection(MPNL::MSocket* s);
private:
   MDFS* DFS;
   };


//---------------------------------------------------------------------------
class MServer : public MDFSPeerBase {
   friend class MDFS;
public:
   TIME  LastConnection;

         MServer(const std::string& host, int port, MDFS* dfs);
         ~MServer();
   int   Send(const std::string& msg);
   bool  Connect(int timeout=1000);

protected:
   MDFS* DFS;
   MDFSTCPClient*  TCPClient;
   TIME            LastFailedConnection;
   };


//---------------------------------------------------------------------------
class MFile {

public:
   std::string    MD5;
   std::string    LocalPath; 
   MUtils::MDate  Date;
   MUtils::MDate  LastUpdate;
   unsigned long  Size;
   //void*          Data; ///< a free space
   //unsigned long  DataSize;

   MFile() : Size(0), Type(ftUNK) { } //, DataSize(0)
   MFile(const std::string& url)
      : Size(0), Type(ftUNK) {SetURL(url);}
   ~MFile() {}

   void           SetURL (const std::string& url);
   void           SetType(const MFileType& t);
   std::string    GetURL()  const {return URL;}
   MFileType      GetType() const {return Type;}
   void           Reset() {Type=ftUNK;URL="";}
   std::string    ExtractFileName() const ;
   std::string    ExtractFilePath() const;

private:
   MFileType      Type;
   std::string    URL; 
   void           VerifyType();

   };

//---------------------------------------------------------------------------
class MDFSTransfer {

public:

   enum MType {ttDOWNLOAD, ttUPLOAD} Type;
   MFile          File;
   std::string    Msg;
   int            ID;
   //unsigned long  Progress;

   MDFSTransfer() /*: Progress(0)*/ {}

   };

//---------------------------------------------------------------------------
class MDFSUpdate {

public:

   MDFSUpdate() : Stamp(0) {}
   
   enum MType {utFILE, utCONNECT, utTRANSFER} Type;
   enum MAction {uaADD, uaUPDATE, uaREMOVE} Action;
   enum MResult {urOK, urFAILED} Result;

   MFile          File;
   MConnection    Connection;
   MDFSTransfer   Transfer;

   unsigned char GetStamp() {
      boost::mutex::scoped_lock lock(Mutex);
      return Stamp;
      }
   void SetStamp(unsigned char s) {
      boost::mutex::scoped_lock lock(Mutex);
      Stamp |= s;
      }

private:
   boost::mutex Mutex;
   unsigned char Stamp;

   };

//---------------------------------------------------------------------------
typedef std::vector<MFile>  MFileList;

//---------------------------------------------------------------------------
class MQuery {
public:

   enum MQType {qtUPDATE, qtDOWNLOAD}
         QueryType;
   int   FileType; // sum of MFileType
   int   Depth;  // Recusivity
   MURL  URL;
   int   URLParsingResult;

   // ctor
   MQuery(const std::string& url, int t, int r) : QueryType(qtUPDATE), FileType(t), Depth(r) {
      URLParsingResult = ParseURL(url,URL);
      }

   bool URLIsValid() const {return URLParsingResult==0;}

private:

   };

//---------------------------------------------------------------------------
// MDownload
class MDownload {
public:
   std::string URL; // TODO: should be private
   unsigned long LastQuery; // TIME

   MDownload(const std::string& url) : URL(url), Active(false) {RESETTIME(LastQuery);}
   MDownload(const MDownload& d) {
      // TODO: do not want to do several things at a time,
      // remove the comments later and check
      //boost::mutex::scoped_lock lock(Mutex);
      //boost::mutex::scoped_lock lock(d.Mutex);
      Active      = d.Active;
      URL         = d.URL;
      LastQuery   = d.LastQuery;
      }
   ~MDownload() {}

   bool IsActive() {
      boost::mutex::scoped_lock lock(Mutex);
      return Active;
      }
   void SetActive(bool b) {
      boost::mutex::scoped_lock lock(Mutex);
      Active = b;
      }

private:
   boost::mutex   Mutex;
   bool Active; 

   };


//---------------------------------------------------------------------------
class MUpdateScanner : public MThread {
public:
   MUpdateScanner(MDFS* dfs) {DFS=dfs;}
   virtual ~MUpdateScanner() {};
protected:
   MDFS* DFS;
   };


//---------------------------------------------------------------------------
class MDFS : public MThread {
public:

   MDFSDB*           DB;         
   MShareList        Shares;     
   MOptions          Options;
   MPNL::MTransferManager* TransferManager;
   unsigned char ClearStamp;

            MDFS();
   virtual ~MDFS();

   void Init(const std::string& initfilepath);

   MServer* AddServer(const std::string& host, int port=5050);

   int SendMsg(const std::string& host, const std::string& msg);

   void BroadcastMsg(const std::string& msg);

   void SendConnections(const std::string& ip);

   bool IsConnected(const std::string& ip);

   void GetStats(MStats& s);

   MUpdateList*  LockUpdates() {
      UpdateLock->lock();
      return &Updates;
      }
   void          UnlockUpdates() {
      UpdateLock->unlock();
      }

   void operator()();

   void Download(const std::string& url);
   //void Upload(const std::string& url);
   void AddUpdate(MDFSUpdate* u);
   void AddConnection(MConnection& c); 
   void RemoveConnection(const std::string& ip); 
   void SaveConnections();

protected:
   //std::string                CachePath;
   std::string          Base; 
   std::string          DownloadPath; 
   MStringList          Errors;
   MServerList          Servers;    
   MDFSTCPServer*       TCPServer;  
   std::string          Name;
   MStringList          ServerHosts;
   MStats               Stats;
   MUpdateList          Updates;
   MDownloadList        Downloads;
   MUpdateScanner*      UpdateScanner;

   typedef std::vector<MConnection> MConnectionList;
   MConnectionList Connections;

   void Listen(TiXmlElement* cur);
   void NewServer(TiXmlElement* cur);
   void ParseNetMsg(MDFSPeerBase* c, std::string& rv);
   void Init(TiXmlElement* cur);
   void NewShare(TiXmlElement* cur);
   void ParseNetMsg(MDFSPeerBase* c, TiXmlElement* cur, std::string& rv);
   void ParseQuery(MDFSPeerBase* c, TiXmlElement* cur, std::string& rv);
   void ParseDLQuery(MDFSPeerBase* c, TiXmlElement* cur, std::string& rv);
   void ParseDLResponse(MDFSPeerBase* c, TiXmlElement* cur, std::string& rv);
   void CancelDL(MDFSPeerBase* c, TiXmlElement* cur, std::string& rv);
   void ParseUpdate(TiXmlElement* cur, std::string& rv);
   void ParseFile(MFileType ft, TiXmlElement* cur, std::string& rv);
   void SendInfos(const std::string& ip, const std::string& localip);
   void NewInfo(MDFSPeerBase* c, TiXmlElement* cur);

   virtual void BuildFileQueryResponse(MDFSPeerBase* c, const MQuery& q, std::string& rv)=0;

   virtual bool Login(const std::string& login, const std::string& pwd, MUser& rv)=0;
   void AddErrors(std::string& rv);
   void DeleteDownload(const std::string& url); // maybe put this in a class
   
private:
   boost::mutex   UpdateMutex;
   boost::mutex::scoped_lock* UpdateLock;
   boost::mutex   ConnectionMutex;
   boost::mutex   ServerMutex;
   boost::mutex   StatMutex;
   boost::mutex   DownloadMutex;
   //bool           Active;
   TIME           LastQuery;

   };

//---------------------------------------------------------------------------

} //namespace

#endif

---

MDFS SourceForge project page and download