www/manager6/ceph/FS.js

   1 /*jslint confusion: true */
   2 Ext.define('PVE.CephCreateFS', {
   3     extend: 'Proxmox.window.Edit',
   4     alias: 'widget.pveCephCreateFS',
   5
   6     showTaskViewer: true,
   7     onlineHelp: 'pveceph_fs_create',
   8
   9     subject: 'Ceph FS',
  10     isCreate: true,
  11     method: 'POST',
  12
  13     setFSName: function(fsName) {
  14         var me = this;
  15
  16         if (fsName === '' || fsName === undefined) {
  17             fsName = 'cephfs';
  18         }
  19
  20         me.url = "/nodes/" + me.nodename + "/ceph/fs/" + fsName;
  21     },
  22
  23     items: [
  24         {
  25             xtype: 'textfield',
  26             fieldLabel: gettext('Name'),
  27             name: 'name',
  28             value: 'cephfs',
  29             listeners: {
  30                 change: function(f, value) {
  31                     this.up('pveCephCreateFS').setFSName(value);
  32                 }
  33             },
  34             submitValue: false, // already encoded in apicall URL
  35             emptyText: 'cephfs'
  36         },
  37         {
  38             xtype: 'proxmoxintegerfield',
  39             fieldLabel: 'Placement Groups',
  40             name: 'pg_num',
  41             value: 128,
  42             emptyText: 128,
  43             minValue: 8,
  44             maxValue: 32768,
  45             allowBlank: false
  46         },
  47         {
  48             xtype: 'proxmoxcheckbox',
  49             fieldLabel: gettext('Add Storage'),
  50             value: true,
  51             name: 'add-storage'
  52         }
  53     ],
  54
  55     initComponent : function() {
  56         var me = this;
  57
  58         if (!me.nodename) {
  59             throw "no node name specified";
  60         }
  61         me.setFSName();
  62
  63         me.callParent();
  64     }
  65 });
  66
  67 Ext.define('PVE.CephCreateMDS', {
  68     extend: 'Proxmox.window.Edit',
  69     alias: 'widget.pveCephCreateMDS',
  70
  71     showProgress: true,
  72     onlineHelp: 'pveceph_fs_mds',
  73
  74     subject: 'Ceph MDS',
  75     isCreate: true,
  76     method: 'POST',
  77
  78     setNode: function(nodename) {
  79         var me = this;
  80
  81         me.nodename = nodename;
  82         me.url = "/nodes/" + nodename + "/ceph/mds/" + nodename;
  83     },
  84
  85     items: [
  86         {
  87             xtype: 'pveNodeSelector',
  88             fieldLabel: gettext('Node'),
  89             selectCurNode: true,
  90             submitValue: false,
  91             allowBlank: false,
  92             listeners: {
  93                 change: function(f, value) {
  94                     this.up('pveCephCreateMDS').setNode(value);
  95                 }
  96             }
  97         }
  98     ],
  99
 100     initComponent : function() {
 101         var me = this;
 102
 103         if (!me.nodename) {
 104             throw "no node name specified";
 105         }
 106         me.setNode(me.nodename);
 107
 108         me.callParent();
 109     }
 110 });
 111
 112 Ext.define('PVE.NodeCephFSPanel', {
 113     extend: 'Ext.panel.Panel',
 114     xtype: 'pveNodeCephFSPanel',
 115     mixins: ['Proxmox.Mixin.CBind'],
 116
 117     title: gettext('CephFS'),
 118     onlineHelp: 'pveceph_fs',
 119
 120     border: false,
 121     defaults: {
 122         border: false,
 123         cbind: {
 124             nodename: '{nodename}'
 125         }
 126     },
 127
 128     viewModel: {
 129         parent: null,
 130         data: {
 131             cephfsConfigured: false,
 132             mdsCount: 0
 133         },
 134         formulas: {
 135             canCreateFS: function(get) {
 136                 return (!get('cephfsConfigured') && get('mdsCount') > 0);
 137             }
 138         }
 139     },
 140
 141     items: [
 142         {
 143             xtype: 'grid',
 144             emptyText: Ext.String.format(gettext('No {0} configured.'), 'CephFS'),
 145             controller: {
 146                 xclass: 'Ext.app.ViewController',
 147
 148                 init: function(view) {
 149                     view.rstore = Ext.create('Proxmox.data.UpdateStore', {
 150                         autoLoad: true,
 151                         xtype: 'update',
 152                         interval: 5 * 1000,
 153                         autoStart: true,
 154                         storeid: 'pve-ceph-fs',
 155                         proxy: {
 156                             type: 'proxmox',
 157                             url: '/api2/json/nodes/' + view.nodename + '/ceph/fs'
 158                         },
 159                         model: 'pve-ceph-fs'
 160                     });
 161                     view.setStore(Ext.create('Proxmox.data.DiffStore', {
 162                         rstore: view.rstore,
 163                         sorters: {
 164                             property: 'name',
 165                             order: 'DESC'
 166                         }
 167                     }));
 168                     var regex = new RegExp("not (installed|initialized)", "i");
 169                     PVE.Utils.handleStoreErrorOrMask(view, view.rstore, regex, function(me, error){
 170                         me.rstore.stopUpdate();
 171                         PVE.Utils.showCephInstallOrMask(me.ownerCt, error.statusText, view.nodename,
 172                             function(win){
 173                                 me.mon(win, 'cephInstallWindowClosed', function(){
 174                                     me.rstore.startUpdate();
 175                                 });
 176                             }
 177                         );
 178                     });
 179                     view.rstore.on('load', this.onLoad, this);
 180                     view.on('destroy', view.rstore.stopUpdate);
 181                 },
 182
 183                 onCreate: function() {
 184                     var view = this.getView();
 185                     view.rstore.stopUpdate();
 186                     var win = Ext.create('PVE.CephCreateFS', {
 187                         autoShow: true,
 188                         nodename: view.nodename,
 189                         listeners: {
 190                             destroy: function() {
 191                                 view.rstore.startUpdate();
 192                             }
 193                         }
 194                     });
 195                 },
 196
 197                 onLoad: function(store, records, success) {
 198                     var vm = this.getViewModel();
 199                     if (!(success && records && records.length > 0)) {
 200                         vm.set('cephfsConfigured', false);
 201                         return;
 202                     }
 203                     vm.set('cephfsConfigured', true);
 204                 }
 205             },
 206             tbar: [
 207                 {
 208                     text: gettext('Create CephFS'),
 209                     reference: 'createButton',
 210                     handler: 'onCreate',
 211                     bind: {
 212                         // only one CephFS per Ceph cluster makes sense for now
 213                         disabled: '{!canCreateFS}'
 214                     }
 215                 }
 216             ],
 217             columns: [
 218                 {
 219                     header: gettext('Name'),
 220                     flex: 1,
 221                     dataIndex: 'name'
 222                 },
 223                 {
 224                     header: 'Data Pool',
 225                     flex: 1,
 226                     dataIndex: 'data_pool'
 227                 },
 228                 {
 229                     header: 'Metadata Pool',
 230                     flex: 1,
 231                     dataIndex: 'metadata_pool'
 232                 }
 233             ],
 234             cbind: {
 235                 nodename: '{nodename}'
 236             }
 237         },
 238         {
 239             xtype: 'grid',
 240             title: gettext('Metadata Servers'),
 241             emptyText: Ext.String.format(gettext('No {0} configured.'), 'MDS'),
 242             controller: {
 243                 xclass: 'Ext.app.ViewController',
 244
 245                 init: function(view) {
 246                     view.rstore = Ext.create('Proxmox.data.UpdateStore', {
 247                         autoLoad: true,
 248                         xtype: 'update',
 249                         interval: 3 * 1000,
 250                         autoStart: true,
 251                         storeid: 'pve-ceph-mds',
 252                         proxy: {
 253                             type: 'proxmox',
 254                             url: '/api2/json/nodes/'+ view.nodename +'/ceph/mds'
 255                         },
 256                         model: 'pve-ceph-mds'
 257                     });
 258                     view.setStore(Ext.create('Proxmox.data.DiffStore', {
 259                         rstore: view.rstore,
 260                         sorters: {
 261                             property: 'id',
 262                             order: 'DESC'
 263                         }
 264                     }));
 265                     var regex = new RegExp("not (installed|initialized)", "i");
 266                     PVE.Utils.handleStoreErrorOrMask(view, view.rstore, regex, function(me, error){
 267                         me.rstore.stopUpdate();
 268                         PVE.Utils.showCephInstallOrMask(me.ownerCt, error.statusText, view.nodename,
 269                             function(win){
 270                                 me.mon(win, 'cephInstallWindowClosed', function(){
 271                                     me.rstore.startUpdate();
 272                                 });
 273                             }
 274                         );
 275                     });
 276                     view.rstore.on('load', this.onLoad, this);
 277                     view.on('destroy', view.rstore.stopUpdate);
 278                 },
 279                 onLoad: function(store, records, success) {
 280                     var vm = this.getViewModel();
 281                     if (!success || !records) {
 282                         vm.set('mdsCount', 0);
 283                         return;
 284                     }
 285                     vm.set('mdsCount', records.length);
 286                 },
 287                 onCreateMDS: function() {
 288                     var view = this.getView();
 289                     view.rstore.stopUpdate();
 290                     var win = Ext.create('PVE.CephCreateMDS', {
 291                         autoShow: true,
 292                         nodename: view.nodename,
 293                         listeners: {
 294                             destroy: function() {
 295                                 view.rstore.startUpdate();
 296                             }
 297                         }
 298                     });
 299                 }
 300             },
 301             tbar: [
 302                 {
 303                     text: gettext('Create MDS'),
 304                     reference: 'createButton',
 305                     handler: 'onCreateMDS'
 306                 },
 307                 {
 308                     text: gettext('Destroy MDS'),
 309                     xtype: 'proxmoxStdRemoveButton',
 310                     getUrl: function(rec) {
 311                         if (!rec.data.host) {
 312                             Ext.Msg.alert(gettext('Error'), "entry has no host");
 313                             return;
 314                         }
 315                         return "/nodes/" + rec.data.host + "/ceph/mds/" + rec.data.name;
 316                     },
 317                     callback: function(options, success, response) {
 318                         if (!success) {
 319                             Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 320                             return;
 321                         }
 322                         var upid = response.result.data;
 323                         var win = Ext.create('Proxmox.window.TaskProgress', { upid: upid });
 324                         win.show();
 325                     }
 326                 }
 327             ],
 328             columns: [
 329                 {
 330                     header: gettext('Name'),
 331                     flex: 1,
 332                     dataIndex: 'name'
 333                 },
 334                 {
 335                     header: gettext('Host'),
 336                     flex: 1,
 337                     dataIndex: 'host'
 338                 },
 339                 {
 340                     header: gettext('Address'),
 341                     flex: 1,
 342                     dataIndex: 'addr'
 343                 },
 344                 {
 345                     header: gettext('State'),
 346                     flex: 1,
 347                     dataIndex: 'state'
 348                 }
 349             ],
 350             cbind: {
 351                 nodename: '{nodename}'
 352             }
 353         }
 354     ]
 355 }, function() {
 356     Ext.define('pve-ceph-mds', {
 357         extend: 'Ext.data.Model',
 358         fields: [ 'name', 'host', 'addr', 'state' ],
 359         proxy: {
 360             type: 'proxmox',
 361             url: "/api2/json/nodes/localhost/ceph/mds"
 362         },
 363         idProperty: 'name'
 364     });
 365     Ext.define('pve-ceph-fs', {
 366         extend: 'Ext.data.Model',
 367         fields: [ 'name', 'data_pool', 'metadata_pool' ],
 368         proxy: {
 369             type: 'proxmox',
 370             url: "/api2/json/nodes/localhost/ceph/fs"
 371         },
 372         idProperty: 'name'
 373     });
 374 });