www/manager6/ceph/FS.js

   1 Ext.define('PVE.CephCreateFS', {
   2     extend: 'Proxmox.window.Edit',
   3     alias: 'widget.pveCephCreateFS',
   4
   5     showTaskViewer: true,
   6     onlineHelp: 'pveceph_fs_create',
   7
   8     subject: 'Ceph FS',
   9     isCreate: true,
  10     method: 'POST',
  11
  12     setFSName: function(fsName) {
  13         var me = this;
  14
  15         if (fsName === '' || fsName === undefined) {
  16             fsName = 'cephfs';
  17         }
  18
  19         me.url = "/nodes/" + me.nodename + "/ceph/fs/" + fsName;
  20     },
  21
  22     items: [
  23         {
  24             xtype: 'textfield',
  25             fieldLabel: gettext('Name'),
  26             name: 'name',
  27             value: 'cephfs',
  28             listeners: {
  29                 change: function(f, value) {
  30                     this.up('pveCephCreateFS').setFSName(value);
  31                 },
  32             },
  33             submitValue: false, // already encoded in apicall URL
  34             emptyText: 'cephfs',
  35         },
  36         {
  37             xtype: 'proxmoxintegerfield',
  38             fieldLabel: 'Placement Groups',
  39             name: 'pg_num',
  40             value: 128,
  41             emptyText: 128,
  42             minValue: 8,
  43             maxValue: 32768,
  44             allowBlank: false,
  45         },
  46         {
  47             xtype: 'proxmoxcheckbox',
  48             fieldLabel: gettext('Add as Storage'),
  49             value: true,
  50             name: 'add-storage',
  51             autoEl: {
  52                 tag: 'div',
  53                  'data-qtip': gettext('Add the new CephFS to the cluster storage configuration.'),
  54             },
  55         },
  56     ],
  57
  58     initComponent : function() {
  59         var me = this;
  60
  61         if (!me.nodename) {
  62             throw "no node name specified";
  63         }
  64         me.setFSName();
  65
  66         me.callParent();
  67     },
  68 });
  69
  70 Ext.define('PVE.NodeCephFSPanel', {
  71     extend: 'Ext.panel.Panel',
  72     xtype: 'pveNodeCephFSPanel',
  73     mixins: ['Proxmox.Mixin.CBind'],
  74
  75     title: gettext('CephFS'),
  76     onlineHelp: 'pveceph_fs',
  77
  78     border: false,
  79     defaults: {
  80         border: false,
  81         cbind: {
  82             nodename: '{nodename}',
  83         },
  84     },
  85
  86     viewModel: {
  87         parent: null,
  88         data: {
  89             cephfsConfigured: false,
  90             mdsCount: 0,
  91         },
  92         formulas: {
  93             canCreateFS: function(get) {
  94                 return (!get('cephfsConfigured') && get('mdsCount') > 0);
  95             },
  96         },
  97     },
  98
  99     items: [
 100         {
 101             xtype: 'grid',
 102             emptyText: Ext.String.format(gettext('No {0} configured.'), 'CephFS'),
 103             controller: {
 104                 xclass: 'Ext.app.ViewController',
 105
 106                 init: function(view) {
 107                     view.rstore = Ext.create('Proxmox.data.UpdateStore', {
 108                         autoLoad: true,
 109                         xtype: 'update',
 110                         interval: 5 * 1000,
 111                         autoStart: true,
 112                         storeid: 'pve-ceph-fs',
 113                         proxy: {
 114                             type: 'proxmox',
 115                             url: '/api2/json/nodes/' + view.nodename + '/ceph/fs',
 116                         },
 117                         model: 'pve-ceph-fs',
 118                     });
 119                     view.setStore(Ext.create('Proxmox.data.DiffStore', {
 120                         rstore: view.rstore,
 121                         sorters: {
 122                             property: 'name',
 123                             order: 'DESC',
 124                         },
 125                     }));
 126                     var regex = new RegExp("not (installed|initialized)", "i");
 127                     PVE.Utils.handleStoreErrorOrMask(view, view.rstore, regex, function(me, error){
 128                         me.rstore.stopUpdate();
 129                         PVE.Utils.showCephInstallOrMask(me.ownerCt, error.statusText, view.nodename,
 130                             function(win){
 131                                 me.mon(win, 'cephInstallWindowClosed', function(){
 132                                     me.rstore.startUpdate();
 133                                 });
 134                             },
 135                         );
 136                     });
 137                     view.rstore.on('load', this.onLoad, this);
 138                     view.on('destroy', view.rstore.stopUpdate);
 139                 },
 140
 141                 onCreate: function() {
 142                     var view = this.getView();
 143                     view.rstore.stopUpdate();
 144                     var win = Ext.create('PVE.CephCreateFS', {
 145                         autoShow: true,
 146                         nodename: view.nodename,
 147                         listeners: {
 148                             destroy: function() {
 149                                 view.rstore.startUpdate();
 150                             },
 151                         },
 152                     });
 153                 },
 154
 155                 onLoad: function(store, records, success) {
 156                     var vm = this.getViewModel();
 157                     if (!(success && records && records.length > 0)) {
 158                         vm.set('cephfsConfigured', false);
 159                         return;
 160                     }
 161                     vm.set('cephfsConfigured', true);
 162                 },
 163             },
 164             tbar: [
 165                 {
 166                     text: gettext('Create CephFS'),
 167                     reference: 'createButton',
 168                     handler: 'onCreate',
 169                     bind: {
 170                         // only one CephFS per Ceph cluster makes sense for now
 171                         disabled: '{!canCreateFS}',
 172                     },
 173                 },
 174             ],
 175             columns: [
 176                 {
 177                     header: gettext('Name'),
 178                     flex: 1,
 179                     dataIndex: 'name',
 180                 },
 181                 {
 182                     header: 'Data Pool',
 183                     flex: 1,
 184                     dataIndex: 'data_pool',
 185                 },
 186                 {
 187                     header: 'Metadata Pool',
 188                     flex: 1,
 189                     dataIndex: 'metadata_pool',
 190                 },
 191             ],
 192             cbind: {
 193                 nodename: '{nodename}',
 194             },
 195         },
 196         {
 197             xtype: 'pveNodeCephServiceList',
 198             title: gettext('Metadata Servers'),
 199             stateId: 'grid-ceph-mds',
 200             type: 'mds',
 201             storeLoadCallback: function(store, records, success) {
 202                 var vm = this.getViewModel();
 203                 if (!success || !records) {
 204                     vm.set('mdsCount', 0);
 205                     return;
 206                 }
 207                 vm.set('mdsCount', records.length);
 208             },
 209             cbind: {
 210                 nodename: '{nodename}',
 211             },
 212         },
 213     ],
 214 }, function() {
 215     Ext.define('pve-ceph-fs', {
 216         extend: 'Ext.data.Model',
 217         fields: [ 'name', 'data_pool', 'metadata_pool' ],
 218         proxy: {
 219             type: 'proxmox',
 220             url: "/api2/json/nodes/localhost/ceph/fs",
 221         },
 222         idProperty: 'name',
 223     });
 224 });