www/manager6/dc/Cluster.js

   1 /*jslint confusion: true*/
   2 Ext.define('pve-cluster-nodes', {
   3     extend: 'Ext.data.Model',
   4     fields: [
   5         'node', { type: 'integer', name: 'nodeid' }, 'ring0_addr', 'ring1_addr',
   6         { type: 'integer', name: 'quorum_votes' }
   7     ],
   8     proxy: {
   9         type: 'proxmox',
  10         url: "/api2/json/cluster/config/nodes"
  11     },
  12     idProperty: 'nodeid'
  13 });
  14
  15 Ext.define('pve-cluster-info', {
  16     extend: 'Ext.data.Model',
  17     proxy: {
  18         type: 'proxmox',
  19         url: "/api2/json/cluster/config/join"
  20     }
  21 });
  22
  23 Ext.define('PVE.ClusterAdministration', {
  24     extend: 'Ext.panel.Panel',
  25     xtype: 'pveClusterAdministration',
  26
  27     title: gettext('Cluster Administration'),
  28     onlineHelp: 'chapter_pvecm',
  29
  30     border: false,
  31     defaults: { border: false },
  32
  33     viewModel: {
  34         parent: null,
  35         data: {
  36             totem: {},
  37             nodelist: [],
  38             preferred_node: {
  39                 name: '',
  40                 fp: '',
  41                 addr: ''
  42             },
  43             isInCluster: false,
  44             nodecount: 0
  45         }
  46     },
  47
  48     items: [
  49         {
  50             xtype: 'panel',
  51             title: gettext('Cluster Information'),
  52             controller: {
  53                 xclass: 'Ext.app.ViewController',
  54
  55                 init: function(view) {
  56                     view.store = Ext.create('Proxmox.data.UpdateStore', {
  57                         autoStart: true,
  58                         interval: 15 * 1000,
  59                         storeid: 'pve-cluster-info',
  60                         model: 'pve-cluster-info'
  61                     });
  62                     view.store.on('load', this.onLoad, this);
  63                     view.on('destroy', view.store.stopUpdate);
  64                 },
  65
  66                 onLoad: function(store, records, success) {
  67                     var vm = this.getViewModel();
  68                     if (!success || !records || !records[0].data) {
  69                         vm.set('totem', {});
  70                         vm.set('isInCluster', false);
  71                         vm.set('nodelist', []);
  72                         vm.set('preferred_node', {
  73                             name: '',
  74                             addr: '',
  75                             fp: ''
  76                         });
  77                         return;
  78                     }
  79                     var data = records[0].data;
  80                     vm.set('totem', data.totem);
  81                     vm.set('isInCluster', !!data.totem.cluster_name);
  82                     vm.set('nodelist', data.nodelist);
  83
  84                     var nodeinfo = Ext.Array.findBy(data.nodelist, function (el) {
  85                         return el.name === data.preferred_node;
  86                     });
  87
  88                     vm.set('preferred_node', {
  89                         name: data.preferred_node,
  90                         addr: nodeinfo.pve_addr,
  91                         fp: nodeinfo.pve_fp
  92                     });
  93                 },
  94
  95                 onCreate: function() {
  96                     var view = this.getView();
  97                     view.store.stopUpdate();
  98                     var win = Ext.create('PVE.ClusterCreateWindow', {
  99                         autoShow: true,
 100                         listeners: {
 101                             destroy: function() {
 102                                 view.store.startUpdate();
 103                             }
 104                         }
 105                     });
 106                 },
 107
 108                 onClusterInfo: function() {
 109                     var vm = this.getViewModel();
 110                     var win = Ext.create('PVE.ClusterInfoWindow', {
 111                         joinInfo: {
 112                             ipAddress: vm.get('preferred_node.addr'),
 113                             fingerprint: vm.get('preferred_node.fp'),
 114                             totem: vm.get('totem')
 115                         }
 116                     });
 117                     win.show();
 118                 },
 119
 120                 onJoin: function() {
 121                     var view = this.getView();
 122                     view.store.stopUpdate();
 123                     var win = Ext.create('PVE.ClusterJoinNodeWindow', {
 124                         autoShow: true,
 125                         listeners: {
 126                             destroy: function() {
 127                                 view.store.startUpdate();
 128                             }
 129                         }
 130                     });
 131                 }
 132             },
 133             tbar: [
 134                 {
 135                     text: gettext('Create Cluster'),
 136                     reference: 'createButton',
 137                     handler: 'onCreate',
 138                     bind: {
 139                         disabled: '{isInCluster}'
 140                     }
 141                 },
 142                 {
 143                     text: gettext('Join Information'),
 144                     reference: 'addButton',
 145                     handler: 'onClusterInfo',
 146                     bind: {
 147                         disabled: '{!isInCluster}'
 148                     }
 149                 },
 150                 {
 151                     text: gettext('Join Cluster'),
 152                     reference: 'joinButton',
 153                     handler: 'onJoin',
 154                     bind: {
 155                         disabled: '{isInCluster}'
 156                     }
 157                 }
 158             ],
 159             layout: 'hbox',
 160             bodyPadding: 5,
 161             items: [
 162                 {
 163                     xtype: 'displayfield',
 164                     fieldLabel: gettext('Cluster Name'),
 165                     bind: {
 166                         value: '{totem.cluster_name}',
 167                         hidden: '{!isInCluster}'
 168                     },
 169                     flex: 1
 170                 },
 171                 {
 172                     xtype: 'displayfield',
 173                     fieldLabel: gettext('Config Version'),
 174                     bind: {
 175                         value: '{totem.config_version}',
 176                         hidden: '{!isInCluster}'
 177                     },
 178                     flex: 1
 179                 },
 180                 {
 181                     xtype: 'displayfield',
 182                     fieldLabel: gettext('Number of Nodes'),
 183                     labelWidth: 120,
 184                     bind: {
 185                         value: '{nodecount}',
 186                         hidden: '{!isInCluster}'
 187                     },
 188                     flex: 1
 189                 },
 190                 {
 191                     xtype: 'displayfield',
 192                     value: gettext('Standalone node - no cluster defined'),
 193                     bind: {
 194                         hidden: '{isInCluster}'
 195                     },
 196                     flex: 1
 197                 }
 198             ]
 199         },
 200         {
 201             xtype: 'grid',
 202             title: gettext('Cluster Nodes'),
 203             controller: {
 204                 xclass: 'Ext.app.ViewController',
 205
 206                 init: function(view) {
 207                     view.rstore = Ext.create('Proxmox.data.UpdateStore', {
 208                         autoLoad: true,
 209                         xtype: 'update',
 210                         interval: 5 * 1000,
 211                         autoStart: true,
 212                         storeid: 'pve-cluster-nodes',
 213                         model: 'pve-cluster-nodes'
 214                     });
 215                     view.setStore(Ext.create('Proxmox.data.DiffStore', {
 216                         rstore: view.rstore,
 217                         sorters: {
 218                             property: 'nodeid',
 219                             order: 'DESC'
 220                         }
 221                     }));
 222                     Proxmox.Utils.monStoreErrors(view, view.rstore);
 223                     view.rstore.on('load', this.onLoad, this);
 224                     view.on('destroy', view.rstore.stopUpdate);
 225                 },
 226
 227                 onLoad: function(store, records, success) {
 228                     var vm = this.getViewModel();
 229                     if (!success || !records) {
 230                         vm.set('nodecount', 0);
 231                         return;
 232                     }
 233                     vm.set('nodecount', records.length);
 234                 }
 235             },
 236             columns: [
 237                 {
 238                     header: gettext('Nodename'),
 239                     flex: 2,
 240                     dataIndex: 'name'
 241                 },
 242                 {
 243                     header: gettext('ID'),
 244                     flex: 1,
 245                     dataIndex: 'nodeid'
 246                 },
 247                 {
 248                     header: gettext('Votes'),
 249                     flex: 1,
 250                     dataIndex: 'quorum_votes'
 251                 },
 252                 {
 253                     header: gettext('Ring 0'),
 254                     flex: 2,
 255                     dataIndex: 'ring0_addr'
 256                 },
 257                 {
 258                     header: gettext('Ring 1'),
 259                     flex: 2,
 260                     dataIndex: 'ring1_addr'
 261                 }
 262             ]
 263         }
 264     ]
 265 });