www/manager6/ceph/Pool.js

   1 Ext.define('PVE.CephCreatePool', {
   2     extend: 'PVE.window.Edit',
   3     alias: 'widget.pveCephCreatePool',
   4
   5     showProgress: true,
   6
   7     subject: 'Ceph Pool',
   8     isCreate: true,
   9     method: 'POST',
  10     items: [
  11         {
  12             xtype: 'textfield',
  13             fieldLabel: gettext('Name'),
  14             name: 'name',
  15             allowBlank: false
  16         },
  17         {
  18             xtype: 'pveIntegerField',
  19             fieldLabel: gettext('Size'),
  20             name: 'size',
  21             value: 3,
  22             minValue: 1,
  23             maxValue: 7,
  24             allowBlank: false
  25         },
  26         {
  27             xtype: 'pveIntegerField',
  28             fieldLabel: gettext('Min. Size'),
  29             name: 'min_size',
  30             value: 2,
  31             minValue: 1,
  32             maxValue: 7,
  33             allowBlank: false
  34         },
  35         {
  36             xtype: 'pveCephRuleSelector',
  37             fieldLabel: 'Crush Rule', // do not localize
  38             name: 'crush_rule',
  39             allowBlank: false
  40         },
  41         {
  42             xtype: 'pveIntegerField',
  43             fieldLabel: 'pg_num',
  44             name: 'pg_num',
  45             value: 64,
  46             minValue: 8,
  47             maxValue: 32768,
  48             allowBlank: false
  49         },
  50         {
  51             xtype: 'pvecheckbox',
  52             fieldLabel: gettext('Add Storages'),
  53             name: 'add_storages'
  54         }
  55     ],
  56     initComponent : function() {
  57          /*jslint confusion: true */
  58         var me = this;
  59
  60         if (!me.nodename) {
  61             throw "no node name specified";
  62         }
  63
  64         Ext.apply(me, {
  65             url: "/nodes/" + me.nodename + "/ceph/pools",
  66             defaults: {
  67                 nodename: me.nodename
  68             }
  69         });
  70
  71         me.callParent();
  72     }
  73 });
  74
  75 Ext.define('PVE.node.CephPoolList', {
  76     extend: 'Ext.grid.GridPanel',
  77     alias: 'widget.pveNodeCephPoolList',
  78
  79     onlineHelp: 'chapter_pveceph',
  80     stateful: true,
  81     stateId: 'grid-ceph-pools',
  82     bufferedRenderer: false,
  83     features: [ { ftype: 'summary'} ],
  84     columns: [
  85         {
  86             header: gettext('Name'),
  87             width: 100,
  88             sortable: true,
  89             dataIndex: 'pool_name'
  90         },
  91         {
  92             header: gettext('Size') + '/min',
  93             width: 80,
  94             sortable: false,
  95             renderer: function(v, meta, rec) {
  96                 return v + '/' + rec.data.min_size;
  97             },
  98             dataIndex: 'size'
  99         },
 100         {
 101             header: 'pg_num',
 102             width: 100,
 103             sortable: false,
 104             dataIndex: 'pg_num'
 105         },
 106         {
 107             header: 'rule',
 108             width: 50,
 109             sortable: false,
 110             dataIndex: 'crush_rule'
 111         },
 112         {
 113             header: 'rule_name',
 114             width: 50,
 115             sortable: false,
 116             dataIndex: 'crush_rule_name'
 117         },
 118         {
 119             header: gettext('Used'),
 120             columns: [
 121                 {
 122                     header: '%',
 123                     width: 80,
 124                     sortable: true,
 125                     align: 'right',
 126                     renderer: Ext.util.Format.numberRenderer('0.00'),
 127                     dataIndex: 'percent_used',
 128                     summaryType: 'sum',
 129                     summaryRenderer: Ext.util.Format.numberRenderer('0.00')
 130                 },
 131                 {
 132                     header: gettext('Total'),
 133                     width: 100,
 134                     sortable: true,
 135                     renderer: PVE.Utils.render_size,
 136                     align: 'right',
 137                     dataIndex: 'bytes_used',
 138                     summaryType: 'sum',
 139                     summaryRenderer: PVE.Utils.render_size
 140                 }
 141             ]
 142         }
 143     ],
 144     initComponent: function() {
 145         var me = this;
 146
 147         var nodename = me.pveSelNode.data.node;
 148         if (!nodename) {
 149             throw "no node name specified";
 150         }
 151
 152         var sm = Ext.create('Ext.selection.RowModel', {});
 153
 154         var rstore = Ext.create('PVE.data.UpdateStore', {
 155             interval: 3000,
 156             storeid: 'ceph-pool-list' + nodename,
 157             model: 'ceph-pool-list',
 158             proxy: {
 159                 type: 'pve',
 160                 url: "/api2/json/nodes/" + nodename + "/ceph/pools"
 161             }
 162         });
 163
 164         var store = Ext.create('PVE.data.DiffStore', { rstore: rstore });
 165
 166         PVE.Utils.monStoreErrors(me, rstore);
 167
 168         var create_btn = new Ext.Button({
 169             text: gettext('Create'),
 170             handler: function() {
 171                 var win = Ext.create('PVE.CephCreatePool', {
 172                     nodename: nodename
 173                 });
 174                 win.show();
 175                 win.on('destroy', function() {
 176                     rstore.load();
 177                 });
 178             }
 179         });
 180
 181         var remove_btn = Ext.create('PVE.button.Button', {
 182             text: gettext('Remove'),
 183             selModel: sm,
 184             disabled: true,
 185             handler: function() {
 186                 var rec = sm.getSelection()[0];
 187
 188                 if (!rec.data.pool_name) {
 189                     return;
 190                 }
 191                 var base_url = '/nodes/' + nodename + '/ceph/pools/' +
 192                     rec.data.pool_name;
 193
 194                 var win = Ext.create('PVE.window.SafeDestroy', {
 195                     showProgress: true,
 196                     url: base_url,
 197                     params: {
 198                         remove_storages: 1
 199                     },
 200                     item: { type: 'CephPool', id: rec.data.pool_name }
 201                 }).show();
 202                 win.on('destroy', function() {
 203                     rstore.load();
 204                 });
 205             }
 206         });
 207
 208         Ext.apply(me, {
 209             store: store,
 210             selModel: sm,
 211             tbar: [ create_btn, remove_btn ],
 212             listeners: {
 213                 activate: rstore.startUpdate,
 214                 destroy: rstore.stopUpdate
 215             }
 216         });
 217
 218         me.callParent();
 219     }
 220 }, function() {
 221
 222     Ext.define('ceph-pool-list', {
 223         extend: 'Ext.data.Model',
 224         fields: [ 'pool_name',
 225                   { name: 'pool', type: 'integer'},
 226                   { name: 'size', type: 'integer'},
 227                   { name: 'min_size', type: 'integer'},
 228                   { name: 'pg_num', type: 'integer'},
 229                   { name: 'bytes_used', type: 'integer'},
 230                   { name: 'percent_used', type: 'number'},
 231                   { name: 'crush_rule', type: 'integer'},
 232                   { name: 'crush_rule_name', type: 'string'}
 233                 ],
 234         idProperty: 'pool_name'
 235     });
 236 });
 237
 238 Ext.define('PVE.form.CephRuleSelector', {
 239     extend: 'Ext.form.field.ComboBox',
 240     alias: 'widget.pveCephRuleSelector',
 241
 242     allowBlank: false,
 243     valueField: 'name',
 244     displayField: 'name',
 245     editable: false,
 246     queryMode: 'local',
 247
 248     initComponent: function() {
 249         var me = this;
 250
 251         if (!me.nodename) {
 252             throw "no nodename given";
 253         }
 254
 255         var store = Ext.create('Ext.data.Store', {
 256             fields: ['name'],
 257             sorters: 'name',
 258             proxy: {
 259                 type: 'pve',
 260                 url: '/api2/json/nodes/' + me.nodename + '/ceph/rules'
 261             }
 262         });
 263
 264         Ext.apply(me, {
 265             store: store
 266         });
 267
 268         me.callParent();
 269
 270         store.load({
 271             callback: function(rec, op, success){
 272                 if (success && rec.length > 0) {
 273                     me.select(rec[0]);
 274                 }
 275             }
 276         });
 277     }
 278
 279 });