js/ClusterAdministration.js

   1 Ext.define('pmg-cluster', {
   2     extend: 'Ext.data.Model',
   3     fields: [
   4         'type', 'name', 'ip', 'hostrsapubkey', 'rootrsapubkey',
   5         'fingerprint', { type: 'integer', name: 'cid' },
   6         { type: 'boolean', name: 'insync' },
   7         'memory', 'loadavg', 'uptime', 'rootfs', 'conn_error', 'level',
   8         { type: 'number', name: 'memory_per',
   9           calculate: function(data) {
  10               var mem = data.memory;
  11               return Ext.isObject(mem) ? mem.used/mem.total : 0;
  12           }
  13         },
  14         { type: 'number', name: 'rootfs_per',
  15           calculate: function(data) {
  16               var du = data.rootfs;
  17               return Ext.isObject(du) ? du.used/du.total : 0;
  18           }
  19         }
  20     ],
  21     proxy: {
  22         type: 'proxmox',
  23         url: "/api2/json/config/cluster/status"
  24     },
  25     idProperty: 'cid'
  26 });
  27
  28 Ext.define('PMG.ClusterJoinNodeWindow', {
  29     extend: 'Proxmox.window.Edit',
  30     xtype: 'pmgClusterJoinNodeWindow',
  31
  32     title: gettext('Cluster Join'),
  33
  34     width: 800,
  35
  36     method: 'POST',
  37
  38     url: '/config/cluster/join',
  39
  40     items: [
  41         {
  42             xtype: 'textfield',
  43             fieldLabel: 'IP Address',
  44             name: 'master_ip'
  45         },
  46         {
  47             xtype: 'textfield',
  48             inputType: 'password',
  49             fieldLabel: gettext('Password'),
  50             name: 'password'
  51         },
  52         {
  53             xtype: 'textfield',
  54             fieldLabel: gettext('Fingerprint'),
  55             name: 'fingerprint'
  56         }
  57     ]
  58 });
  59
  60 Ext.define('PMG.ClusterAddNodeWindow', {
  61     extend: 'Ext.window.Window',
  62     xtype: 'pmgClusterAddNodeWindow',
  63     mixins: ['Proxmox.Mixin.CBind'],
  64
  65     width: 800,
  66
  67     modal: true,
  68
  69     title: gettext('Cluster Join') + ' : ' + gettext('Information'),
  70
  71     ipAddress: undefined,
  72
  73     fingerprint: undefined,
  74
  75     items: [
  76         {
  77             xtype: 'component',
  78             border: false,
  79             padding: 10,
  80             html: gettext("Please use the 'Join' button on the node you want to add, using the following IP address and fingerprint.")
  81         },
  82         {
  83             xtype: 'container',
  84             layout: 'form',
  85             border: false,
  86             padding: '0 10 10 10',
  87             items: [
  88                 {
  89                     xtype: 'textfield',
  90                     fieldLabel: gettext('IP Address'),
  91                     cbind: { value: '{ipAddress}' },
  92                     editable: false
  93                 },
  94                 {
  95                     xtype: 'textfield',
  96                     fieldLabel: gettext('Fingerprint'),
  97                     cbind: { value: '{fingerprint}' },
  98                     editable: false
  99                 }
 100             ]
 101         }
 102     ]
 103 });
 104
 105 Ext.define('PMG.ClusterAdministration', {
 106     extend: 'Ext.tab.Panel',
 107     xtype: 'pmgClusterAdministration',
 108
 109     title: gettext('Cluster Administration'),
 110
 111     border: false,
 112     defaults: { border: false },
 113
 114     viewModel: {
 115         parent: null,
 116         data: {
 117             nodecount: 0,
 118             master: null
 119         }
 120     },
 121
 122     items: [
 123         {
 124             xtype: 'grid',
 125             title: gettext('Nodes'),
 126             controller: {
 127                 xclass: 'Ext.app.ViewController',
 128
 129                 init: function(view) {
 130                     view.store.on('load', this.onLoad, this);
 131                     Proxmox.Utils.monStoreErrors(view, view.getStore());
 132                 },
 133
 134                 onLoad: function(store, records, success) {
 135                     var vm = this.getViewModel();
 136                     if (!success || !records) {
 137                         return;
 138                     }
 139                     vm.set('nodecount', records.length);
 140
 141                     var master = null;
 142                     Ext.Array.each(records, function(ni) {
 143                         if (ni.data.type === 'master') {
 144                             master = ni;
 145                         }
 146                     });
 147                     vm.set('master', master);
 148                 },
 149
 150                 onCreate: function() {
 151                     var view = this.getView();
 152
 153                     Proxmox.Utils.API2Request({
 154                         url: '/config/cluster/create',
 155                         method: 'POST',
 156                         waitMsgTarget: view,
 157                         failure: function (response, opts) {
 158                             Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 159                         },
 160                         success: function(response, options) {
 161                             var upid = response.result.data;
 162                             var win = Ext.create('Proxmox.window.TaskProgress', { upid: upid });
 163                             win.show();
 164                             win.on('destroy', function() { view.store.load(); });
 165                         }
 166                     });
 167                 },
 168
 169                 onJoin: function() {
 170                     var view = this.getView();
 171                     var win = Ext.create('PMG.ClusterJoinNodeWindow', {});
 172                     win.show();
 173                     win.on('destroy', function() {
 174                         // fixme: logout
 175                     });
 176                 },
 177
 178                 onAdd: function() {
 179                     var vm = this.getViewModel();
 180
 181                     var win = Ext.create('PMG.ClusterAddNodeWindow', {
 182                         ipAddress: vm.get('master').get('ip'),
 183                         fingerprint: vm.get('master').get('fingerprint')
 184                     });
 185
 186                     win.show();
 187                 }
 188             },
 189             store: {
 190                 autoLoad: true,
 191                 model: 'pmg-cluster'
 192             },
 193             tbar: [
 194                 {
 195                     text: gettext('Create'),
 196                     reference: 'createButton',
 197                     handler: 'onCreate',
 198                     bind: {
 199                         disabled: '{nodecount}'
 200                     }
 201                 },
 202                 {
 203                     text: gettext('Add'),
 204                     reference: 'addButton',
 205                     handler: 'onAdd',
 206                     bind: {
 207                         disabled: '{!master}'
 208                     }
 209                 },
 210                 {
 211                     text: gettext('Join'),
 212                     reference: 'joinButton',
 213                     handler: 'onJoin',
 214                     bind: {
 215                         disabled: '{nodecount}'
 216                     }
 217                 }
 218             ],
 219             columns: [
 220                 {
 221                     header: gettext('Node'),
 222                     width: 150,
 223                     dataIndex: 'name'
 224                 },
 225                 {
 226                     header: gettext('Role'),
 227                     width: 100,
 228                     dataIndex: 'type'
 229                 },
 230                 {
 231                     header: gettext('ID'),
 232                     width: 80,
 233                     dataIndex: 'cid'
 234                 },
 235                 {
 236
 237                     header: gettext('IP'),
 238                     width: 150,
 239                     dataIndex: 'ip'
 240                 },
 241                 {
 242                     header: gettext('State'),
 243                     width: 100,
 244                     renderer: function(value, metaData, record) {
 245                         var d = record.data;
 246                         var state = 'active';
 247                         if (!d.insync) state = 'syncing';
 248                         if (d.conn_error) {
 249                             metaData.tdCls = 'x-form-invalid-field';
 250                             var html = '<p>' +  Ext.htmlEncode(d.conn_error) + '</p>';
 251                             html = html.replace(/\n/g, '<br>');
 252                             metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
 253                                 html.replace(/\"/g,'&quot;') + '"';
 254                             state = 'error';
 255                         }
 256                         return state;
 257                     },
 258                     dataIndex: 'insync'
 259                 },
 260                 {
 261                     header: gettext('Subscription'),
 262                     width: 120,
 263                     renderer: Proxmox.Utils.format_subscription_level,
 264                     dataIndex: 'level'
 265                 },
 266                 {
 267                     header: gettext('Uptime'),
 268                     width: 150,
 269                     renderer: Proxmox.Utils.render_uptime,
 270                     dataIndex: 'uptime'
 271                 },
 272                 {
 273                     header: gettext('Load average'),
 274                     renderer: function(value) {
 275                         if (Ext.isArray(value)) {
 276                             return value[0];
 277                         }
 278                         return value;
 279                     },
 280                     dataIndex: 'loadavg'
 281                 },
 282                 {
 283                     xtype: 'widgetcolumn',
 284                     widget: {
 285                         xtype: 'progressbarwidget',
 286                         textTpl: '{value:percent}'
 287                     },
 288                     header: gettext('RAM usage'),
 289                     dataIndex: 'memory_per'
 290                 },
 291                 {
 292                     xtype: 'widgetcolumn',
 293                     widget: {
 294                         xtype: 'progressbarwidget',
 295                         textTpl: '{value:percent}'
 296                     },
 297                     header: gettext('HD space'),
 298                     dataIndex: 'rootfs_per'
 299                 }
 300             ]
 301         }
 302     ]
 303 });