www/manager/dc/HAConfig.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.dc.vmHAServiceEdit', {
   3     extend: 'PVE.window.Edit',
   4
   5     initComponent : function() {
   6         var me = this;
   7
   8         me.create = me.vmid ? false : true;
   9
  10         if (me.vmid) {
  11             me.create = false;
  12             me.url = "/cluster/ha/groups/pvevm:" + me.vmid;
  13             me.method = 'PUT';
  14         } else {
  15             me.create = true;
  16             me.url = "/cluster/ha/groups";
  17             me.method = 'POST';
  18         }
  19
  20         Ext.apply(me, {
  21             subject: gettext('HA managed VM/CT'),
  22             width: 350,
  23             items: [
  24                 {
  25                     xtype: me.create ? 'pveVMIDSelector' : 'displayfield',
  26                     name: 'vmid',
  27                     validateExists: true,
  28                     value:  me.vmid || '',
  29                     fieldLabel: "VM ID"
  30                 },
  31                 {
  32                     xtype: 'pvecheckbox',
  33                     name: 'autostart',
  34                     checked: true,
  35                     fieldLabel: 'autostart'
  36                 }
  37             ]
  38         });
  39
  40         me.callParent();
  41
  42         if (!me.create) {
  43             me.load();
  44         }
  45     }
  46 });
  47
  48 Ext.define('PVE.dc.HAConfig', {
  49     extend: 'Ext.panel.Panel',
  50     alias: 'widget.pveDcHAConfig',
  51
  52     clusterInfo: {}, // reload store data here
  53
  54     reload: function() {
  55         var me = this;
  56
  57         var getClusterInfo = function(conf) {
  58
  59             var info = {};
  60
  61             if (!(conf && conf.children && conf.children[0])) {
  62                 return info;
  63             }
  64
  65             var cluster = conf.children[0];
  66
  67             if (cluster.text !== 'cluster' || !cluster.config_version) {
  68                 return info;
  69             }
  70
  71             info.version = cluster.config_version;
  72
  73             Ext.Array.each(cluster.children, function(item) {
  74                 if (item.text === 'fencedevices') {
  75                     // fixme: make sure each node uses at least one fence device
  76                     info.fenceDevices = true;
  77                 } else if (item.text === 'rm') {
  78                     info.ha = true;
  79                 }
  80             });
  81
  82             return info;
  83         };
  84
  85         PVE.Utils.API2Request({
  86             url: '/cluster/ha/config',
  87             waitMsgTarget: me,
  88             method: 'GET',
  89             failure: function(response, opts) {
  90                 me.clusterInfo = {};
  91                 PVE.Utils.setErrorMask(me, response.htmlStatus);
  92             },
  93             success: function(response, opts) {
  94                 me.clusterInfo = getClusterInfo(response.result.data);
  95
  96                 me.setDisabled(!me.clusterInfo.version);
  97
  98                 me.addMenu.setDisabled(!me.clusterInfo.version);
  99
 100                 // note: this modifies response.result.data
 101                 me.treePanel.setRootNode(response.result.data);
 102                 me.treePanel.expandAll();
 103
 104
 105                 if (response.result.changes) {
 106                     me.commitBtn.setDisabled(false);
 107                     me.revertBtn.setDisabled(false);
 108                     me.diffPanel.setVisible(true);
 109                     me.diffPanel.update("<pre>" + Ext.htmlEncode(response.result.changes) + "</pre>");
 110                 } else {
 111                     me.commitBtn.setDisabled(true);
 112                     me.revertBtn.setDisabled(true);
 113                     me.diffPanel.setVisible(false);
 114                     me.diffPanel.update('');
 115                 }
 116             }
 117         });
 118     },
 119
 120     initComponent: function() {
 121         var me = this;
 122
 123         me.commitBtn = new PVE.button.Button({
 124             text: gettext('Activate'),
 125             disabled: true,
 126             confirmMsg: function () {
 127                 return gettext('Are you sure you want to activate your changes');
 128             },
 129             handler: function(btn, event) {
 130                 PVE.Utils.API2Request({
 131                     url: '/cluster/ha/changes',
 132                     method: 'POST',
 133                     waitMsgTarget: me,
 134                     callback: function() {
 135                         me.reload();
 136                     },
 137                     failure: function (response, opts) {
 138                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 139                     }
 140                 });
 141             }
 142         });
 143
 144         me.revertBtn = new PVE.button.Button({
 145             text: gettext('Revert changes'),
 146             disabled: true,
 147             confirmMsg: function () {
 148                 return gettext('Are you sure you want to revert your changes');
 149             },
 150             handler: function(btn, event) {
 151                 PVE.Utils.API2Request({
 152                     url: '/cluster/ha/changes',
 153                     method: 'DELETE',
 154                     waitMsgTarget: me,
 155                     callback: function() {
 156                         me.reload();
 157                     },
 158                     failure: function (response, opts) {
 159                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 160                     }
 161                 });
 162             }
 163         });
 164
 165         me.addMenu = new Ext.button.Button({
 166             text: gettext('Add'),
 167             disabled: true,
 168             menu: new Ext.menu.Menu({
 169                 items: [
 170                     {
 171                         text: gettext('HA managed VM/CT'),
 172                         handler: function() {
 173                             var win = Ext.create('PVE.dc.vmHAServiceEdit', {});
 174                             win.show();
 175                             win.on('destroy', me.reload, me);
 176                         }
 177                     },
 178                     {
 179                         text: gettext('Failover Domain'),
 180                         handler: function() {
 181                             Ext.Msg.alert(gettext('Error'), "Please configure via CLI");
 182                         }
 183                     }
 184                 ]
 185             })
 186         });
 187
 188         me.treePanel = Ext.create('Ext.tree.Panel', {
 189             rootVisible: false,
 190             animate: false,
 191             region: 'center',
 192             border: false,
 193             fields: ['text', 'id', 'vmid', 'name' ],
 194             columns: [
 195                 {
 196                     xtype: 'treecolumn',
 197                     text: 'Tag',
 198                     dataIndex: 'text',
 199                     width: 200
 200                 },
 201                 {
 202                     text: 'Attributes',
 203                     dataIndex: 'id',
 204                     renderer: function(value, metaData, record) {
 205                         var text = '';
 206                         Ext.Object.each(record.raw, function(key, value) {
 207                             if (key === 'id' || key === 'text') {
 208                                 return;
 209                             }
 210                             text += Ext.htmlEncode(key) + '="' +
 211                                 Ext.htmlEncode(value) + '" ';
 212                         });
 213                         return text;
 214                     },
 215                     flex: 1
 216                 }
 217             ]
 218         });
 219
 220         var run_editor = function() {
 221             var rec = me.treePanel.selModel.getSelection()[0];
 222             if (rec && rec.data.text === 'pvevm') {
 223                 var win = Ext.create('PVE.dc.vmHAServiceEdit', {
 224                     vmid: rec.data.vmid
 225                 });
 226                 win.show();
 227                 win.on('destroy', me.reload, me);
 228             }
 229         };
 230
 231         me.editBtn = new Ext.button.Button({
 232             text: gettext('Edit'),
 233             disabled: true,
 234             handler: run_editor
 235         });
 236
 237         me.removeBtn = new Ext.button.Button({
 238             text: gettext('Remove'),
 239             disabled: true,
 240             handler: function() {
 241                 var rec = me.treePanel.selModel.getSelection()[0];
 242                 if (rec && rec.data.text === 'pvevm') {
 243                     var groupid = 'pvevm:' + rec.data.vmid;
 244                     PVE.Utils.API2Request({
 245                         url: '/cluster/ha/groups/' + groupid,
 246                         method: 'DELETE',
 247                         waitMsgTarget: me,
 248                         callback: function() {
 249                             me.reload();
 250                         },
 251                         failure: function (response, opts) {
 252                             Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 253                         }
 254                     });
 255                 }
 256             }
 257         });
 258
 259
 260         me.diffPanel = Ext.create('Ext.panel.Panel', {
 261             border: false,
 262             hidden: true,
 263             region: 'south',
 264             autoScroll: true,
 265             itemId: 'changes',
 266             tbar: [ gettext('Pending changes') ],
 267             split: true,
 268             bodyPadding: 5,
 269             flex: 0.6
 270         });
 271
 272         Ext.apply(me, {
 273             layout: 'border',
 274             tbar: [ me.addMenu, me.removeBtn, me.editBtn, me.revertBtn, me.commitBtn ],
 275             items: [ me.treePanel, me.diffPanel ]
 276         });
 277
 278         me.callParent();
 279
 280         me.on('show', me.reload);
 281
 282         me.treePanel.on("selectionchange", function(sm, selected) {
 283             var rec = selected[0];
 284             if (rec && rec.data.text === 'pvevm') {
 285                 me.editBtn.setDisabled(false);
 286                 me.removeBtn.setDisabled(false);
 287             } else {
 288                 me.editBtn.setDisabled(true);
 289                 me.removeBtn.setDisabled(true);
 290
 291             }
 292         });
 293
 294         me.treePanel.on("itemdblclick", function(v, record) {
 295             run_editor();
 296         });
 297     }
 298 });