server/org.argeo.slc.ria/src/argeo-ria-lib/slc/class/org/argeo/slc/ria/monitor/FlowsSelectorView.js

   1 /**
   2  * The selector view
   3  *
   4  */
   5 qx.Class.define("org.argeo.slc.ria.monitor.FlowsSelectorView", {
   6         extend : org.argeo.slc.ria.FlowsSelectorView,
   7         implement : [org.argeo.ria.components.IView],
   8
   9         construct : function() {
  10                 this.base(arguments);
  11         },
  12
  13         properties : {
  14                 /**
  15                  * Commands definition, see
  16                  * {@link org.argeo.ria.event.CommandsManager#definitions}
  17                  */
  18                 commands : {
  19                         refine : true,
  20                         init : {
  21                                 "reloadtree" : {
  22                                         label : "Reload",
  23                                         icon : "org.argeo.slc.ria/view-refresh.png",
  24                                         shortcut : "Control+m",
  25                                         enabled : false,
  26                                         menu : "Launcher",
  27                                         toolbar : "launcher",
  28                                         callback : function(e) {
  29                                                 if (this.tree.isSelectionEmpty()) {     return; }
  30                                                 var selected = this.tree.getSelection()[0];
  31                                                 if (selected.classname == "org.argeo.ria.components.DynamicTreeFolder") {
  32                                                         if (selected.getUserData("moduleData")) {
  33                                                                 // It's a "module" node, first trigger the
  34                                                                 // reloadBundle.service
  35                                                                 selected.setUserData("dataModel", {});
  36                                                                 selected.setEnabled(false);
  37                                                                 selected.setOpen(false);
  38                                                                 var moduleData = selected
  39                                                                                 .getUserData("moduleData");
  40                                                                 var bundleService = org.argeo.slc.ria.SlcApi
  41                                                                                 .getReloadBundleService(
  42                                                                                                 moduleData.name,
  43                                                                                                 moduleData.version);
  44                                                                 bundleService.addListener("completed",
  45                                                                                 function(response) {
  46                                                                                         selected.setEnabled(true);
  47                                                                                         selected.setOpen(true);
  48                                                                                         selected.reload();
  49                                                                                 }, this);
  50                                                                 // bundleService.send();
  51                                                                 // Do not send, not implemented yet, false timer
  52                                                                 // instead.
  53                                                                 qx.event.Timer.once(function(response) {
  54                                                                                         selected.setEnabled(true);
  55                                                                                         selected.setOpen(true);
  56                                                                                         selected.reload();
  57                                                                                 }, this, 2000);
  58                                                         } else {
  59                                                                 selected.reload();
  60                                                         }
  61                                                 }
  62                                         },
  63                                         selectionChange : function(viewId, selection) {
  64                                                 if (viewId != "form:tree")
  65                                                         return;
  66                                                 if (!selection)
  67                                                         return;
  68                                                 if (selection.length > 1) {
  69                                                         this.setEnabled(false);
  70                                                         return;
  71                                                 }
  72                                                 var item = selection[0];
  73                                                 if (!qx.Class.isSubClassOf(qx.Class
  74                                                                                 .getByName(item.classname),
  75                                                                 qx.ui.tree.AbstractTreeItem))
  76                                                         return;
  77                                                 this.setEnabled(false);
  78                                                 if (qx.Class.isSubClassOf(qx.Class
  79                                                                                 .getByName(item.classname),
  80                                                                 org.argeo.ria.components.DynamicTreeFolder)) {
  81                                                         this.setEnabled(true);
  82                                                 }
  83                                         },
  84                                         command : null
  85                                 }
  86                         }
  87                 }
  88         },
  89
  90         statics : {
  91
  92                 riaPreferences : {
  93                         "flowSelector.monitor.preferred.hosts" : {
  94                                 label : "Preferred Hosts (Monitoring View)",
  95                                 type  : "string"
  96                         }
  97                 },
  98
  99                 /**
 100                  * Static loader for the "agent" level (first level)
 101                  *
 102                  * @param folder
 103                  *            {org.argeo.ria.components.PersistentTreeFolder} The root Tree Folder.
 104                  */
 105                 agentLoader : function(folder) {
 106
 107                         var req = org.argeo.slc.ria.SlcApi.getListAgentsService("agents");
 108                         var agents = {};
 109                         if(folder.getState() == "loaded" && folder.getUserData("agentsMap")){
 110                                 // Diff loading, just add new nodes.
 111                                 agents = folder.getUserData("agentsMap");
 112                                 var newAgents = {};
 113                         }
 114                         req.addListener("completed", function(response) {
 115                                 var xmlDoc = response.getContent();
 116                                 var nodes = org.argeo.ria.util.Element.selectNodes(xmlDoc,
 117                                                 "//slc:slc-agent-descriptor");
 118                                 var modulesLoader = org.argeo.slc.ria.FlowsSelectorView.modulesLoader;
 119
 120                                 for (var i = 0; i < nodes.length; i++) {
 121                                         var uuid = org.argeo.ria.util.Element.getSingleNodeText(nodes[i], "@uuid");
 122                                         var host = org.argeo.ria.util.Element.getSingleNodeText(nodes[i], "slc:host");
 123                                         if(agents[uuid]){
 124                                                 newAgents[uuid] = host;
 125                                                 continue;
 126                                         }
 127                                         agents[uuid] = host;
 128                                         if(newAgents) newAgents[uuid] = host;
 129                                         var agentFolder = new org.argeo.ria.components.DynamicTreeFolder(
 130                                                         host + ' (' + uuid + ')', modulesLoader,
 131                                                         "Loading Modules...", folder.getDragData());
 132                                         agentFolder.setUserData("agentUuid", uuid);
 133                                         agentFolder.setIcon("org.argeo.slc.ria/mime-xsl-22.png");
 134                                         folder.add(agentFolder);
 135                                 }
 136                                 if(newAgents){
 137                                         // Make sure some agents should not be removed
 138                                         for(var agentKey in agents){
 139                                                 if(!newAgents[agentKey]){
 140                                                         var node = org.argeo.slc.ria.FlowsSelectorView.findAgentNodeById(folder, agentKey);
 141                                                         if(node) folder.remove(node);
 142                                                         delete agents[agentKey];
 143                                                         var batchView = org.argeo.ria.components.ViewsManager.getInstance().getViewPaneById("batch").getContent();
 144                                                         if(batchView) batchView.clearBatchForAgentId(agentKey);
 145                                                 }
 146                                         }
 147                                 }
 148                                 folder.setUserData("agentsMap", agents);
 149                                 folder.setLoaded(true);
 150                                 folder.getTree().fireEvent("changeSelection");
 151                         });
 152                         req.addListener("failed", function(response) {
 153                                                 folder.setLoaded(true);
 154                                         });
 155                         req.send();
 156
 157                 },
 158
 159                 /**
 160                  * Loader for the "modules" level : takes any tree folder, currently the
 161                  * root folder.
 162                  *
 163                  * @param folder
 164                  *            {org.argeo.ria.components.PersistentTreeFolder} The root folder
 165                  */
 166                 modulesLoader : function(folder) {
 167                         var agentId = folder.getUserData("agentUuid");
 168                         var req = org.argeo.slc.ria.SlcApi.getListModulesService(agentId);
 169                         req.addListener("completed", function(response) {
 170                                 var descriptors = org.argeo.ria.util.Element.selectNodes(
 171                                                 response.getContent(),
 172                                                 "slc:object-list/slc:execution-module-descriptor");
 173                                 var mods = {};
 174                                 for (var i = 0; i < descriptors.length; i++) {
 175                                         var name = org.argeo.ria.util.Element.getSingleNodeText(
 176                                                         descriptors[i], "slc:name");
 177                                         var version = org.argeo.ria.util.Element.getSingleNodeText(
 178                                                         descriptors[i], "slc:version");
 179                                         if (!mods[name])
 180                                                 mods[name] = [];
 181                                         mods[name].push(version);
 182                                 }
 183                                 var flowLoader = org.argeo.slc.ria.FlowsSelectorView.flowLoader;
 184                                 for (var key in mods) {
 185                                         for (var i = 0; i < mods[key].length; i++) {
 186                                                 var versionFolder = new org.argeo.ria.components.DynamicTreeFolder(
 187                                                                 key + ' (' + mods[key][i] + ')', flowLoader,
 188                                                                 "Loading Flows", folder.getDragData());
 189                                                 versionFolder.setUserData("moduleData", {
 190                                                                         name : key,
 191                                                                         version : mods[key][i]
 192                                                                 });
 193                                                 versionFolder.setUserData("agentUuid", agentId);
 194                                                 // Warning, we must add it AFTER setting the user data,
 195                                                 // because of the persistent loading mechanism.
 196                                                 folder.add(versionFolder);
 197                                         }
 198                                 }
 199                                 folder.setLoaded(true);
 200                                 folder.getTree().fireEvent("changeSelection");
 201                         });
 202                         req.addListener("failed", function(response) {
 203                                 folder.setLoaded(true);
 204                         });
 205                         req.send();
 206                 },
 207
 208                 /**
 209                  * Loader for the "flow" level : takes a folder containing "moduleData"
 210                  * and create its children.
 211                  *
 212                  * @param folder
 213                  *            {org.argeo.ria.components.PersistentTreeFolder} A Tree folder containing in the
 214                  *            key "moduleData" of its user data a map containing the
 215                  *            keys {name,version}
 216                  */
 217                 flowLoader : function(folder) {
 218                         var moduleData = folder.getUserData("moduleData");
 219                         var agentUuid = folder.getUserData("agentUuid");
 220
 221                         var req = org.argeo.slc.ria.SlcApi
 222                                         .getLoadExecutionDescriptorService(agentUuid,
 223                                                         moduleData.name, moduleData.version);
 224                         req.addListener("completed", function(response) {
 225                                 var executionModule = new org.argeo.slc.ria.execution.Module();
 226                                 try {
 227                                         executionModule.setXmlNode(response.getContent());
 228                                 } catch (e) {
 229                                         this.error(e);
 230                                 }
 231                                 var execFlows = executionModule.getExecutionFlows();
 232                                 for (var key in execFlows) {
 233                                         var file = new qx.ui.tree.TreeFile(key);
 234                                         var path = execFlows[key].getPath();
 235                                         file.setUserData("executionModule",     executionModule);
 236                                         file.setUserData("executionFlow", execFlows[key]);
 237                                         file.setUserData("agentUuid", agentUuid);
 238                                         org.argeo.slc.ria.FlowsSelectorView.attachNodeByPath(folder, path, file, {
 239                                                 agentUuid : folder.getUserData("agentUuid")
 240                                         });
 241                                         folder.appendDragData(file);
 242                                 }
 243                                 folder.setLoaded(true);
 244                                 folder.getTree().fireEvent("changeSelection");
 245                         });
 246                         req.addListener("failed", function(response) {
 247                                 folder.setLoaded(true);
 248                         });
 249                         req.send();
 250                 }
 251         },
 252
 253         members : {
 254
 255                 /**
 256                  *
 257                  */
 258                 load : function() {
 259                         this._createLayout();
 260                         this.UIBus.addListener("agentRegistered", this._addAgentHandler, this);
 261                         this.UIBus.addListener("agentUnregistered", this._removeAgentHandler,   this);
 262                 },
 263
 264                 /**
 265                  * Creates the main applet layout.
 266                  */
 267                 _createLayout : function() {
 268
 269                         this.tree = new qx.ui.tree.Tree();
 270                         this.tree.setDecorator(null);
 271                         this.tree.setSelectionMode("multi");
 272
 273                         this.rootNode = new org.argeo.ria.components.DynamicTreeFolder(
 274                                         "Tests", this.self(arguments).agentLoader,
 275                                         "Loading Agents");
 276                         this.tree.setRoot(this.rootNode);
 277                         this.rootNode.setPersistentTreeID("org.argeo.slc.ria.monitor.FlowsSelector")
 278                         this.rootNode.setOpen(true);
 279                         this.tree.setContextMenu(org.argeo.ria.event.CommandsManager
 280                                         .getInstance().createMenuFromIds(["reloadtree"]));
 281
 282                         this.tree.addListener("changeSelection", function(e) {
 283                                 var viewSelection = this.getViewSelection();
 284                                 viewSelection.setViewId("form:tree");
 285                                 viewSelection.clear();
 286                                 var sel = this.tree.getSortedSelection();
 287                                 for (var i = 0; i < sel.length; i++) {
 288                                         viewSelection.addNode(sel[i]);
 289                                 }
 290                                 if(sel && sel[0]){
 291                                         var propViewPane = org.argeo.ria.components.ViewsManager.getInstance().getViewPaneById("properties");
 292                                         propViewPane.getContent().updateData(sel[0]);
 293                                 }
 294                         }, this);
 295
 296
 297                         this.add(this.tree);
 298                 }
 299         }
 300 });