www/manager6/ceph/Pool.js

   1 // Ext.create is a function, but
   2 // we defined create a bool in PVE.window.Edit
   3 /*jslint confusion: true*/
   4 Ext.define('PVE.CephCreatePool', {
   5     extend: 'PVE.window.Edit',
   6     alias: ['widget.pveCephCreatePool'],
   7
   8     subject: 'Ceph Pool',
   9     create: true,
  10     method: 'POST',
  11     items: [
  12         {
  13             xtype: 'textfield',
  14             fieldLabel: gettext('Name'),
  15             name: 'name',
  16             allowBlank: false
  17         },
  18         {
  19             xtype: 'pveIntegerField',
  20             fieldLabel: gettext('Size'),
  21             name: 'size',
  22             value: 2,
  23             minValue: 1,
  24             maxValue: 3,
  25             allowBlank: false
  26         },
  27         {
  28             xtype: 'pveIntegerField',
  29             fieldLabel: gettext('Min. Size'),
  30             name: 'min_size',
  31             value: 1,
  32             minValue: 1,
  33             maxValue: 3,
  34             allowBlank: false
  35         },
  36         {
  37             xtype: 'pveIntegerField',
  38             fieldLabel: gettext('Crush RuleSet'),
  39             name: 'crush_ruleset',
  40             value: 0,
  41             minValue: 0,
  42             maxValue: 32768,
  43             allowBlank: false
  44         },
  45         {
  46             xtype: 'pveIntegerField',
  47             fieldLabel: 'pg_num',
  48             name: 'pg_num',
  49             value: 64,
  50             minValue: 8,
  51             maxValue: 32768,
  52             allowBlank: false
  53         }
  54     ],
  55     initComponent : function() {
  56          /*jslint confusion: true */
  57         var me = this;
  58
  59         if (!me.nodename) {
  60             throw "no node name specified";
  61         }
  62
  63         Ext.applyIf(me, {
  64             url: "/nodes/" + me.nodename + "/ceph/pools"
  65         });
  66
  67         me.callParent();
  68     }
  69 });
  70
  71 Ext.define('PVE.node.CephPoolList', {
  72     extend: 'Ext.grid.GridPanel',
  73     alias: ['widget.pveNodeCephPoolList'],
  74
  75     onlineHelp: 'chapter_pveceph',
  76     stateful: false,
  77     bufferedRenderer: false,
  78     features: [ { ftype: 'summary'} ],
  79     columns: [
  80         {
  81             header: gettext('Name'),
  82             width: 100,
  83             sortable: true,
  84             dataIndex: 'pool_name'
  85         },
  86         {
  87             header: gettext('Size') + '/min',
  88             width: 80,
  89             sortable: false,
  90             renderer: function(v, meta, rec) {
  91                 return v + '/' + rec.data.min_size;
  92             },
  93             dataIndex: 'size'
  94         },
  95         {
  96             header: 'pg_num',
  97             width: 100,
  98             sortable: false,
  99             dataIndex: 'pg_num'
 100         },
 101         {
 102             header: 'ruleset',
 103             width: 50,
 104             sortable: false,
 105             dataIndex: 'crush_ruleset'
 106         },
 107         {
 108             header: gettext('Used'),
 109             columns: [
 110                 {
 111                     header: '%',
 112                     width: 80,
 113                     sortable: true,
 114                     align: 'right',
 115                     renderer: Ext.util.Format.numberRenderer('0.00'),
 116                     dataIndex: 'percent_used',
 117                     summaryType: 'sum',
 118                     summaryRenderer: Ext.util.Format.numberRenderer('0.00')
 119                 },
 120                 {
 121                     header: gettext('Total'),
 122                     width: 100,
 123                     sortable: true,
 124                     renderer: PVE.Utils.render_size,
 125                     align: 'right',
 126                     dataIndex: 'bytes_used',
 127                     summaryType: 'sum',
 128                     summaryRenderer: PVE.Utils.render_size
 129                 }
 130             ]
 131         }
 132     ],
 133     initComponent: function() {
 134         var me = this;
 135
 136         var nodename = me.pveSelNode.data.node;
 137         if (!nodename) {
 138             throw "no node name specified";
 139         }
 140
 141         var sm = Ext.create('Ext.selection.RowModel', {});
 142
 143         var rstore = Ext.create('PVE.data.UpdateStore', {
 144             interval: 3000,
 145             storeid: 'ceph-pool-list' + nodename,
 146             model: 'ceph-pool-list',
 147             proxy: {
 148                 type: 'pve',
 149                 url: "/api2/json/nodes/" + nodename + "/ceph/pools"
 150             }
 151         });
 152
 153         var store = Ext.create('PVE.data.DiffStore', { rstore: rstore });
 154
 155         PVE.Utils.monStoreErrors(me, rstore);
 156
 157         var create_btn = new Ext.Button({
 158             text: gettext('Create'),
 159             handler: function() {
 160                 var win = Ext.create('PVE.CephCreatePool', {
 161                     nodename: nodename
 162                 });
 163                 win.show();
 164             }
 165         });
 166
 167         var remove_btn = new PVE.button.Button({
 168             text: gettext('Remove'),
 169             selModel: sm,
 170             disabled: true,
 171             confirmMsg: function(rec) {
 172                 var msg = Ext.String.format(gettext('Are you sure you want to remove entry {0}'),
 173                                             "'" + rec.data.pool_name + "'");
 174                 msg += " " + gettext('This will permanently erase all data.');
 175
 176                 return msg;
 177             },
 178             handler: function() {
 179                 var rec = sm.getSelection()[0];
 180
 181                 if (!rec.data.pool_name) {
 182                     return;
 183                 }
 184
 185                 PVE.Utils.API2Request({
 186                     url: "/nodes/" + nodename + "/ceph/pools/" +
 187                         rec.data.pool_name,
 188                     method: 'DELETE',
 189                     failure: function(response, opts) {
 190                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 191                     }
 192                 });
 193             }
 194         });
 195
 196         Ext.apply(me, {
 197             store: store,
 198             selModel: sm,
 199             tbar: [ create_btn, remove_btn ],
 200             listeners: {
 201                 activate: rstore.startUpdate,
 202                 destroy: rstore.stopUpdate
 203             }
 204         });
 205
 206         me.callParent();
 207     }
 208 }, function() {
 209
 210     Ext.define('ceph-pool-list', {
 211         extend: 'Ext.data.Model',
 212         fields: [ 'pool_name',
 213                   { name: 'pool', type: 'integer'},
 214                   { name: 'size', type: 'integer'},
 215                   { name: 'min_size', type: 'integer'},
 216                   { name: 'pg_num', type: 'integer'},
 217                   { name: 'bytes_used', type: 'integer'},
 218                   { name: 'percent_used', type: 'number'},
 219                   { name: 'crush_ruleset', type: 'integer'}
 220                 ],
 221         idProperty: 'pool_name'
 222     });
 223 });