Add a MetaCacheService on the client side, caching Shared Data and Activity Feed with clever invalidation rules. Keep in memory for the moment, always clearing on workspace switch (and thus on logout).

cdujeu · cdujeu · commit 07b28af19419 · 2016-05-05T18:57:11.000+02:00
diff --git a/core/src/plugins/action.share/res/react/model/ShareModel.js b/core/src/plugins/action.share/res/react/model/ShareModel.js
@@ -607,15 +607,28 @@
         load(){
             if(this._status == 'loading') return;
             this._setStatus('loading');
-            ShareModel.loadSharedElementData(this._node, function(transport){
+            let cacheService = MetaCacheService.getInstance();
+            cacheService.registerMetaStream('action.share', MetaCacheService.EXPIRATION_LOCAL_NODE);
+
+            let remoteLoader = function(transport){
                 if(transport.responseJSON){
                     this._data = transport.responseJSON;
                     this._pendingData = {};
                     this._setStatus('idle');
+                    return this._data;
                 }else if(transport.responseXML && XMLUtils.XPathGetSingleNodeText(transport.responseXML, '//message[@type="ERROR"]')){
                     this._setStatus('error');
+                    return null;
                 }
-            }.bind(this));
+            }.bind(this);
+
+            let cacheLoader = function(data){
+                this._data = data;
+                this._pendingData = {};
+                this._setStatus('idle');
+            }.bind(this);
+
+            cacheService.metaForNode('action.share', this._node, ShareModel.loadSharedElementData, remoteLoader, cacheLoader);
         }
 
         save(){
diff --git a/core/src/plugins/core.notifications/class.NotificationLoader.js b/core/src/plugins/core.notifications/class.NotificationLoader.js
@@ -295,7 +295,32 @@ Class.create("NotificationLoader", {
         protoMenu.correctWindowClipping(protoMenu.container, offset, dim);
     },
 
+    clearMetaCacheForPath: function(path){
+        var parts = path.split("/");
+        while(parts.length){
+            var newPath = parts.join("/");
+            if(!newPath) newPath = '/';
+            MetaCacheService.getInstance().clearMetaStreamKeys("files.activity" + newPath);
+            parts.pop();
+        }
+    },
+
     loadInfoPanel : function(container, node){
+        if(!NotificationLoader.LOADED){
+
+            pydio.getContextHolder().observe("server_update", function(pathes){
+                // Clear all caches for all pathes.
+                for(var i = 0; i < pathes.length ; i++){
+                    NotificationLoader.prototype.clearMetaCacheForPath(pathes[i]);
+                    if(NotificationLoader.IPANEL_FETCHPANE && NotificationLoader.IPANEL_FETCHPANE_PATH && pathes[i].indexOf(NotificationLoader.IPANEL_FETCHPANE_PATH) === 0){
+                        NotificationLoader.IPANEL_FETCHPANE.reloadDataModel();
+                    }
+                }
+            });
+
+            NotificationLoader.LOADED = true;
+        }
+
         var label= MessageHash['notification_center.'+(node.isLeaf()?'11': (node.isRoot()?'9': '10'))];
         var mainContainer = container.down("#ajxp_activity_panel");
         mainContainer.addClassName("infopanel_loading");
@@ -306,7 +331,8 @@ Class.create("NotificationLoader", {
         var timer = NotificationLoader.prototype.loaderTimer;
         if(timer) window.clearTimeout(timer);
 
-        var fRp = new FetchedResultPane(resultPane, {
+        NotificationLoader.IPANEL_FETCHPANE_PATH = node.getPath();
+        NotificationLoader.IPANEL_FETCHPANE = new FetchedResultPane(resultPane, {
             "fit":"content",
             "replaceScroller": false,
             "columnsDef":[
@@ -325,10 +351,14 @@ Class.create("NotificationLoader", {
                 "limit":(node.isLeaf() || node.isRoot() ? 18 : 4),
                 "path":(node.isLeaf() || node.isRoot()?node.getPath():node.getPath()+'/'),
                 "merge_description":"true",
-                "description_as_label":node.isLeaf()?"true":"false"
+                "description_as_label":node.isLeaf()?"true":"false",
+                "cache_service":{
+                    "metaStreamName":"files.activity" + node.getPath(),
+                    "expirationPolicy":MetaCacheService.EXPIRATION_MANUAL_TRIGGER
+                }
             }});
         var pane = container.up('[ajxpClass="InfoPanel"]');
-        fRp._rootNode.observe("loaded", function(){
+        NotificationLoader.IPANEL_FETCHPANE._rootNode.observe("loaded", function(){
             if(!mainContainer.hasClassName("infopanel_loading_finished")){
                 mainContainer.addClassName("infopanel_loading_finished");
             }
@@ -338,7 +368,7 @@ Class.create("NotificationLoader", {
                 },0.2);
             }
             if(container.down('#ajxp_activity_panel > div.panelHeader')){
-                if(!fRp._rootNode.getChildren().size){
+                if(!NotificationLoader.IPANEL_FETCHPANE._rootNode.getChildren().size){
                     container.down('#ajxp_activity_panel > div.panelHeader').hide();
                 }else{
                     container.down('#ajxp_activity_panel > div.panelHeader').show();
@@ -347,7 +377,7 @@ Class.create("NotificationLoader", {
         });
         // fRp.showElement(true);
         NotificationLoader.prototype.loaderTimer = window.setTimeout(function(){
-            fRp.showElement(true);
+            NotificationLoader.IPANEL_FETCHPANE.showElement(true);
         }, 0.5);
 
     },
diff --git a/core/src/plugins/gui.ajax/Gruntfile.js b/core/src/plugins/gui.ajax/Gruntfile.js
@@ -47,6 +47,7 @@ var gui_ajax_core = [
     'res/js/core/model/BackgroundTasksManager.js',
     'res/js/core/http/PydioApi.js',
     'res/js/core/http/PydioUsersApi.js',
+    'res/js/core/http/MetaCacheService.js',
     'res/js/core/model/Action.js',
     'res/js/core/model/Controller.js',
     'res/js/core/model/PydioDataModel.js',
@@ -179,6 +180,16 @@ module.exports = function(grunt) {
             }
         },
         watch: {
+            es6 : {
+                files:[
+                    'res/js/es6/*.es6',
+                    'res/js/es6/**/*.es6'
+                ],
+                tasks:['babel:dist'],
+                options:{
+                    spawn:false
+                }
+            },
             core: {
                 files: gui_ajax_core,
                 tasks: ['babel:dist', 'uglify:js'],
diff --git a/core/src/plugins/gui.ajax/res/js/ajaxplorer_core.txt b/core/src/plugins/gui.ajax/res/js/ajaxplorer_core.txt
@@ -17,6 +17,7 @@ js/core/model/EmptyNodeProvider.js
 js/core/model/Repository.js
 js/core/model/BackgroundTasksManager.js
 js/core/http/PydioApi.js
+js/core/http/MetaCacheService.js
 js/core/model/Action.js
 js/core/model/Controller.js
 js/core/model/PydioDataModel.js
diff --git a/core/src/plugins/gui.ajax/res/js/es6/http/MetaCacheService.es6 b/core/src/plugins/gui.ajax/res/js/es6/http/MetaCacheService.es6
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2007-2016 Charles du Jeu - Abstrium SAS <team (at) pyd.io>
+ * This file is part of Pydio.
+ *
+ * Pydio is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Pydio is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Pydio.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The latest code can be found at <http://pyd.io/>.
+ */
+/**
+ * API Client
+ */
+class MetaCacheService extends Observable{
+
+    static getInstance(){
+        if(!MetaCacheService.INSTANCE){
+            MetaCacheService.INSTANCE = new MetaCacheService();
+        }
+        return MetaCacheService.INSTANCE;
+    }
+
+    constructor(){
+        super();
+        this._streams = new Map();
+    }
+
+    hasKey(streamName, keyName){
+        if(!this._streams.get(streamName)){
+            throw Error('Stream ' + streamName + ' not registered, please register first');
+        }
+        return this._streams.get(streamName).get('data').has(keyName);
+    }
+
+    getByKey(streamName, keyName){
+        if(!this._streams.get(streamName)){
+            throw Error('Stream ' + streamName + ' not registered, please register first');
+        }
+        return this._streams.get(streamName).get('data').get(keyName);
+    }
+
+    deleteKey(streamName, keyName){
+        if(!this._streams.get(streamName)){
+            throw Error('Stream ' + streamName + ' not registered, please register first');
+        }
+        this._streams.get(streamName).get('data').delete(keyName);
+    }
+
+    setKey(streamName, keyName, value){
+        if(!this._streams.get(streamName)){
+            throw Error('Stream ' + streamName + ' not registered, please register first');
+        }
+        this._streams.get(streamName).get('data').set(keyName, value);
+    }
+
+    clearMetaStreamKeys(streamName){
+        if(this._streams.has(streamName)){
+            this._streams.get(streamName).set('data', new Map());
+        }
+    }
+
+    registerMetaStream(streamName, expirationPolicy){
+        if(this._streams.get(streamName)){
+            return;
+        }
+        let data = new Map();
+        data.set('expirationPolicy', expirationPolicy);
+        data.set('data', new Map());
+        this._streams.set(streamName, data);
+        pydio.observe("repository_list_refreshed", function(){
+            // Always keep the cache at workspace scope
+            this._streams.delete(streamName);
+        }.bind(this));
+    }
+
+    metaForNode(streamName, ajxpNode, loaderCallback, remoteParser, cacheLoader){
+        if(!this._streams.has(streamName)){
+            throw new Error('Cannot find meta stream ' + streamName + ', please register it before using it');
+        }
+        let def = this._streams.get(streamName);
+        let key = ajxpNode.getPath();
+        let expirationPolicy = def.get('expirationPolicy');
+        if(def.get('data').has(key)){
+            cacheLoader(def.get('data').get(key));
+        }else{
+            let clearValueObserver = function(){
+                def.get('data').delete(key);
+            }.bind(this);
+
+            // Cache response if success
+            let cacheCallback = function(transport){
+                let newData = remoteParser(transport);
+                if(newData !== null){
+                    def.get('data').set(key, newData);
+                    if(expirationPolicy == MetaCacheService.EXPIRATION_LOCAL_NODE){
+                        ajxpNode.observeOnce("node_removed", clearValueObserver);
+                        ajxpNode.observeOnce("node_replaced", clearValueObserver);
+                    }
+                }
+            };
+            loaderCallback(ajxpNode, cacheCallback);
+        }
+    }
+
+    invalidateMetaForKeys(streamName, keyPattern){
+        if(!this._streams.has(streamName)){
+            throw new Error('Cannot find meta stream ' + streamName + ', please register it before using it');
+        }
+        let data = this._streams.get(streamName).get('data');
+        data.forEach(function(value, key){
+            if(key.match(keyPattern)){
+                data.delete(key);
+            }
+        });
+    }
+    
+}
+
+MetaCacheService.EXPIRATION_LOCAL_NODE = 'LOCAL_NODE';
+MetaCacheService.EXPIRATION_MANUAL_TRIGGER = 'MANUAL_TRIGGER';
diff --git a/core/src/plugins/gui.ajax/res/js/es6/model/RemoteNodeProvider.es6 b/core/src/plugins/gui.ajax/res/js/es6/model/RemoteNodeProvider.es6
@@ -43,6 +43,14 @@ class RemoteNodeProvider{
             this.discrete = true;
             this.properties.delete('connexion_discrete');
         }
+        if(this.properties && this.properties.has('cache_service')){
+            this.cacheService = this.properties.get('cache_service');
+            this.properties.delete('cache_service');
+            MetaCacheService.getInstance().registerMetaStream(
+                this.cacheService['metaStreamName'],
+                this.cacheService['expirationPolicy']
+            );
+        }
     }
 
     /**
@@ -85,10 +93,22 @@ class RemoteNodeProvider{
         if(optionalParameters){
             params = LangUtils.objectMerge(params, optionalParameters);
         }
-        var complete = function (transport){
+        let parser = function (transport){
             this.parseNodes(node, transport, nodeCallback, childCallback);
+            return node;
         }.bind(this);
-        PydioApi.getClient().request(params,  complete, null, {discrete:this.discrete});
+        if(this.cacheService){
+            let loader = function(ajxpNode, cacheCallback){
+                PydioApi.getClient().request(params, cacheCallback, null, {discrete:this.discrete});
+            }.bind(this);
+            let cacheLoader = function(newNode){
+                node.replaceBy(newNode);
+                nodeCallback(node);
+            }.bind(this);
+            MetaCacheService.getInstance().metaForNode(this.cacheService['metaStreamName'], node, loader, parser, cacheLoader);
+        }else{
+            PydioApi.getClient().request(params, parser, null, {discrete:this.discrete});
+        }
     }
 
     /**
@@ -242,28 +262,37 @@ class RemoteNodeProvider{
     }
 
     parseAjxpNodesDiffs(xmlElement, targetDataModel, setContextChildrenSelected=false){
-        var removes = XMLUtils.XPathSelectNodes(xmlElement, "remove/tree");
-        var adds = XMLUtils.XPathSelectNodes(xmlElement, "add/tree");
-        var updates = XMLUtils.XPathSelectNodes(xmlElement, "update/tree");
+        let removes = XMLUtils.XPathSelectNodes(xmlElement, "remove/tree");
+        let adds = XMLUtils.XPathSelectNodes(xmlElement, "add/tree");
+        let updates = XMLUtils.XPathSelectNodes(xmlElement, "update/tree");
+        let notifyServerChange = [];
         if(removes && removes.length){
             removes.forEach(function(r){
                 var p = r.getAttribute("filename");
                 var imTime = parseInt(r.getAttribute("ajxp_im_time"));
                 targetDataModel.removeNodeByPath(p, imTime);
+                notifyServerChange.push(p);
             });
         }
         if(adds && adds.length && targetDataModel.getAjxpNodeProvider().parseAjxpNode){
             adds.forEach(function(tree){
                 var newNode = targetDataModel.getAjxpNodeProvider().parseAjxpNode(tree);
                 targetDataModel.addNode(newNode, setContextChildrenSelected);
+                notifyServerChange.push(newNode.getPath());
             });
         }
         if(updates && updates.length && targetDataModel.getAjxpNodeProvider().parseAjxpNode){
             updates.forEach(function(tree){
                 var newNode = targetDataModel.getAjxpNodeProvider().parseAjxpNode(tree);
+                let original = newNode.getMetadata().get("original_path");
                 targetDataModel.updateNode(newNode, setContextChildrenSelected);
+                notifyServerChange.push(newNode.getPath());
+                if(original) notifyServerChange.push(original);
             });
         }
+        if(notifyServerChange.length){
+            targetDataModel.notify("server_update", notifyServerChange);
+        }
     }
 
     /**
