VFS_node.h

Go to the documentation of this file.

 
#ifndef VFS_NODE_H
#define VFS_NODE_H
 
#include <QObject>
#include <QStringList>
#include <QMetaMethod>
#include <QMutex>
#include <QMap>
#include <QVariantMap>
#include <QSet>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
 
#define POST_ID_NONE            0
#define POST_ID_PING            1
#define POST_ID_SESSION_DATA    2
#define POST_ID_DIFF            7
#define POST_ID_CODE_DIRECTORY  16
#define POST_ID_START           256
#define POST_ID_MAX             65000
 
typedef quint16 postID;
 
Q_DECLARE_METATYPE(postID)
 
class VFS_node;
class VFS_session;
 
//typedef QMap<VFS_node *, qint32>                                      VFS_subscriptionCounter;
//typedef QMap<QString, QMap<VFS_node *, qint32> >                      VFS_subscriptionOrigin;
//typedef QMap<QString, QMap<QString, QMap<VFS_node *, qint32> > >      VFS_subscriptionType;
typedef QMap<VFS_node *, qint32>                                        VFS_subscriptionCounter;
typedef QMap<QString, VFS_subscriptionCounter >                         VFS_subscriptionOrigin;
typedef QMap<QString, VFS_subscriptionOrigin >                          VFS_subscriptionType;
 
typedef QMap<QString,   VFS_node *>                                     VFS_children;
typedef QMap<QString,   VFS_node *>::iterator                           VFS_childrenIterator;
typedef QMap<QString,   VFS_node *>::const_iterator                     VFS_childrenConstIterator;
 
typedef QPair<VFS_node *, QString>                                      notifyException;
 
//uncomment this line to enable VFS_request debugging
//#define DEBUG_DANGLING_REQUESTS
 
#ifdef DEBUG_DANGLING_REQUESTS
class VFS_request : public QObject
{
        Q_OBJECT
 
#else
class VFS_request
{
#endif
        friend class VFS_node;
 
        public:
 
                enum requestType
                {
                        none    = 0,
                        ls,                     
                        create,                 
                        rm,                     
                        read,                   
                        write,                  
                        metadata,               
                        diff,                   
                        submit,                 
                        subscribe,              
                        unsubscribe,            
                        acl,                    
                        report,                 
                        requestlock,            
                        releaselock,            
                        code,                   
                        codeDirectory           
                };
 
                VFS_request(requestType type=VFS_request::none, VFS_node *origin=nullptr, QString path="", QString user="unknown", QJsonDocument data=QJsonDocument(), QJsonObject metadata=QJsonObject(), bool dontDelete=false);
                VFS_request(const VFS_request &c);
                virtual ~VFS_request();
 
                requestType             _requestType;                   
 
                VFS_node                *_origin;                       
                QString                 _originPath;                    
 
                VFS_node                *_responder;                    
                QString                 _initialPath;                   
                QStringList             _prefixPath;                    
                QString                 _path;                          
 
                VFS_request             *_callback;                     
                bool                    _isCallback;                    
                bool                    hasCallback();
 
                QJsonObject             _metadata;                      
                QJsonDocument           _data;                          
                QByteArray              _rawData;                       
 
                VFS_session             *_session;                      
                QString                 _user;                          
                bool                    _success;                       
                QString                 _reason;                        
 
                QList<notifyException>  _notifyExceptions;              
 
                bool                    _dontDelete;                    
 
                virtual void setCallback(VFS_request *c);
                virtual VFS_request *getCallback(VFS_node *receiver);
                virtual void copyCallback(VFS_request *d);
                virtual VFS_request *createDiff(VFS_node *origin, QString originPath);
 
                virtual QByteArray toJson(postID id=0, bool ignoreSuccess=false, bool includeInitialPath=false);
                virtual void fromJsonObject(QJsonObject json, bool includeInitialPath=false);
 
                static long             _refcount;                      
                static quint32          _sampleCount;                   
                static QMutex           _sampleLock;                    
                static quint32 getSample();
 
                static const char* requestTypeStrings[];                
 
#ifdef DEBUG_DANGLING_REQUESTS
        protected slots:
#endif
                virtual void timerEvent(QTimerEvent *e=nullptr);
 
        protected:
                virtual void execute();
};
 
Q_DECLARE_METATYPE(VFS_request*)
Q_DECLARE_METATYPE(VFS_request::requestType)
 
 
class VFS_node : public QObject
{
        Q_OBJECT
 
        friend class VFS_session;
        friend class VFS_thread;
 
        public:
                Q_INVOKABLE explicit VFS_node();
                virtual ~VFS_node();
 
        //navigation functions
                VFS_node *find(QString path);
                virtual VFS_node *find(VFS_request *r);
 
        //code functions
                static QString code(QString nodename, QString libname, QString &error);
 
        //children functions
                virtual VFS_node *append(QString name, VFS_node *node, bool containerCheck=true, QString user="server");
                QString uniqueChildName(QString name);
                VFS_node *findChildWithName(QString name);
                virtual bool validChildName(QString name);
 
                virtual VFS_request *createRequest(VFS_request::requestType type, QString path, QString user="unknown", QJsonDocument data=QJsonDocument(), QJsonObject metadata=QJsonObject(), bool dontDelete=false);
 
                virtual bool isContainer();
                QString className();
                virtual QString reportDetails();
 
                virtual VFS_node *mount();
                virtual VFS_node *unmount();
 
                static bool                     __isNode(VFS_node *);
 
        protected:
                mutable QMutex                  _lock;                  
                VFS_children                    _children;              
                VFS_subscriptionType            _subscribers;           
 
                virtual QByteArray icon();
 
        //from the current thread, issue a request/response to the slot in the target's thread with the request attached
                virtual void issueRequest( VFS_request *t );
                virtual void issueRequest( VFS_node *target, VFS_request *t );
                virtual void issueResponse( VFS_request *t );
 
        //subscription functions
                virtual void subscribe(VFS_request *r);
                virtual void unsubscribe(VFS_request *r);
                virtual void unsubscribePath(QString path);
 
        //operation functions
                virtual void ls(VFS_request *r);
                virtual void read(VFS_request *r);
                virtual void write(VFS_request *r);
                virtual void metadata(VFS_request *r);
                virtual void report(VFS_request *r);
                virtual void submit(VFS_request *r);
                virtual void rm(VFS_request *r);
                virtual void requestLock(VFS_request *r);
                virtual void releaseLock(VFS_request *r);
                virtual void aclDefaults(VFS_request *r);
 
        //acl functions
                void addACLDefault( QJsonObject &acl, bool value, QString description="" );
                void addACLGroup( QJsonObject &acl, QString group, bool value );
                void addACLUser( QJsonObject &acl, QString user, bool value );
                void addACLFeature( QJsonObject &acl, QString feature, bool value, QString description="" );
                void addACLFeatureGroup( QJsonObject &acl, QString feature, QString group, bool value );
                void addACLFeatureUser( QJsonObject &acl, QString feature, QString user, bool value );
 
        private:
                static QSet<VFS_node *>         __allNodes;             
                static QMutex                   __allNodesMutex;        
                static void                     __addNode(VFS_node *);
                static bool                     __removeNode(VFS_node *);
 
        signals:
                void mounted();                                         
                void unmounted(VFS_node *self);                         
                void finished(bool andDelete=false);                    
 
                void diff(VFS_node *origin, VFS_request *t);            
 
        public slots:
                void remove(bool andDelete);
                virtual void remove(VFS_node *node=nullptr, QString *name=nullptr, QString user="server");
 
                //slot to receive request
                virtual void subtreeRequest(VFS_request *t);
 
                //slot for received request to actually execute
                virtual void executeRequest(VFS_request *t);
 
                //slot for satisfied request to post to _receiver
                virtual void receiveResponse(VFS_request *t);
 
                void notifySubscribers(VFS_node *origin, VFS_request *t);
                virtual void unsubscribeAll(VFS_node *n);
                virtual void applyDiff(VFS_request *r);
 
        protected slots:
};
 
#endif //VFS_NODE_H