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