www/manager6/node/LVMThin.js

   1 Ext.define('PVE.node.CreateLVMThin', {
   2     extend: 'Proxmox.window.Edit',
   3     xtype: 'pveCreateLVMThin',
   4
   5     onlineHelp: 'chapter_lvm',
   6     subject: 'LVM Thinpool',
   7
   8     showProgress: true,
   9     isCreate: true,
  10
  11     initComponent: function() {
  12         let me = this;
  13
  14         if (!me.nodename) {
  15             throw "no node name specified";
  16         }
  17
  18         Ext.applyIf(me, {
  19             url: `/nodes/${me.nodename}/disks/lvmthin`,
  20             method: 'POST',
  21             items: [
  22                 {
  23                     xtype: 'pmxDiskSelector',
  24                     name: 'device',
  25                     nodename: me.nodename,
  26                     diskType: 'unused',
  27                     includePartitions: true,
  28                     fieldLabel: gettext('Disk'),
  29                     allowBlank: false,
  30                 },
  31                 {
  32                     xtype: 'proxmoxtextfield',
  33                     name: 'name',
  34                     fieldLabel: gettext('Name'),
  35                     allowBlank: false,
  36                 },
  37                 {
  38                     xtype: 'proxmoxcheckbox',
  39                     name: 'add_storage',
  40                     fieldLabel: gettext('Add Storage'),
  41                     value: '1',
  42                 },
  43             ],
  44         });
  45
  46         me.callParent();
  47     },
  48 });
  49
  50 Ext.define('PVE.node.LVMThinList', {
  51     extend: 'Ext.grid.Panel',
  52     xtype: 'pveLVMThinList',
  53
  54     viewModel: {
  55         data: {
  56             thinPool: '',
  57             volumeGroup: '',
  58         },
  59     },
  60
  61     controller: {
  62         xclass: 'Ext.app.ViewController',
  63
  64         destroyThinPool: function() {
  65             let me = this;
  66             let vm = me.getViewModel();
  67             let view = me.getView();
  68
  69             const thinPool = vm.get('thinPool');
  70             const volumeGroup = vm.get('volumeGroup');
  71
  72             if (!view.nodename) {
  73                 throw "no node name specified";
  74             }
  75
  76             if (!thinPool) {
  77                 throw "no thin pool specified";
  78             }
  79
  80             if (!volumeGroup) {
  81                 throw "no volume group specified";
  82             }
  83
  84             Ext.create('PVE.window.SafeDestroyStorage', {
  85                 url: `/nodes/${view.nodename}/disks/lvmthin/${thinPool}`,
  86                 params: { 'volume-group': volumeGroup },
  87                 item: { id: `${volumeGroup}/${thinPool}` },
  88                 taskName: 'lvmthinremove',
  89                 taskDone: () => { view.reload(); },
  90             }).show();
  91         },
  92     },
  93
  94     emptyText: PVE.Utils.renderNotFound('Thin-Pool'),
  95
  96     stateful: true,
  97     stateId: 'grid-node-lvmthin',
  98
  99     rootVisible: false,
 100     useArrows: true,
 101
 102     columns: [
 103         {
 104             text: gettext('Name'),
 105             dataIndex: 'lv',
 106             flex: 1,
 107         },
 108         {
 109             header: 'Volume Group',
 110             width: 110,
 111             dataIndex: 'vg',
 112         },
 113         {
 114             header: gettext('Usage'),
 115             width: 110,
 116             dataIndex: 'usage',
 117             tdCls: 'x-progressbar-default-cell',
 118             xtype: 'widgetcolumn',
 119             widget: {
 120                 xtype: 'pveProgressBar',
 121             },
 122         },
 123         {
 124             header: gettext('Size'),
 125             width: 100,
 126             align: 'right',
 127             sortable: true,
 128             renderer: Proxmox.Utils.format_size,
 129             dataIndex: 'lv_size',
 130         },
 131         {
 132             header: gettext('Used'),
 133             width: 100,
 134             align: 'right',
 135             sortable: true,
 136             renderer: Proxmox.Utils.format_size,
 137             dataIndex: 'used',
 138         },
 139         {
 140             header: gettext('Metadata Usage'),
 141             width: 120,
 142             dataIndex: 'metadata_usage',
 143             tdCls: 'x-progressbar-default-cell',
 144             xtype: 'widgetcolumn',
 145             widget: {
 146                 xtype: 'pveProgressBar',
 147             },
 148         },
 149         {
 150             header: gettext('Metadata Size'),
 151             width: 120,
 152             align: 'right',
 153             sortable: true,
 154             renderer: Proxmox.Utils.format_size,
 155             dataIndex: 'metadata_size',
 156         },
 157         {
 158             header: gettext('Metadata Used'),
 159             width: 125,
 160             align: 'right',
 161             sortable: true,
 162             renderer: Proxmox.Utils.format_size,
 163             dataIndex: 'metadata_used',
 164         },
 165     ],
 166
 167     tbar: [
 168         {
 169             text: gettext('Reload'),
 170             iconCls: 'fa fa-refresh',
 171             handler: function() {
 172                 this.up('panel').reload();
 173             },
 174         },
 175         {
 176             text: gettext('Create') + ': Thinpool',
 177             handler: function() {
 178                 var view = this.up('panel');
 179                 Ext.create('PVE.node.CreateLVMThin', {
 180                     nodename: view.nodename,
 181                     taskDone: () => view.reload(),
 182                     autoShow: true,
 183                 });
 184             },
 185         },
 186         '->',
 187         {
 188             xtype: 'tbtext',
 189             data: {
 190                 thinPool: undefined,
 191                 volumeGroup: undefined,
 192             },
 193             bind: {
 194                 data: {
 195                     thinPool: "{thinPool}",
 196                     volumeGroup: "{volumeGroup}",
 197                 },
 198             },
 199             tpl: [
 200                 '<tpl if="thinPool">',
 201                 '<tpl if="volumeGroup">',
 202                 'Thinpool {volumeGroup}/{thinPool}:',
 203                 '<tpl else>', // volumeGroup
 204                 'Missing volume group (node running old version?)',
 205                 '</tpl>',
 206                 '<tpl else>', // thinPool
 207                 Ext.String.format(gettext('No {0} selected'), 'thinpool'),
 208                 '</tpl>',
 209             ],
 210         },
 211         {
 212             text: gettext('More'),
 213             iconCls: 'fa fa-bars',
 214             disabled: true,
 215             bind: {
 216                 disabled: '{!volumeGroup || !thinPool}',
 217             },
 218             menu: [
 219                 {
 220                     text: gettext('Destroy'),
 221                     itemId: 'remove',
 222                     iconCls: 'fa fa-fw fa-trash-o',
 223                     handler: 'destroyThinPool',
 224                     disabled: true,
 225                     bind: {
 226                         disabled: '{!volumeGroup || !thinPool}',
 227                     },
 228                 },
 229             ],
 230         },
 231     ],
 232
 233     reload: function() {
 234         let me = this;
 235         me.store.load();
 236         me.store.sort();
 237     },
 238
 239     listeners: {
 240         activate: function() {
 241             this.reload();
 242         },
 243         selectionchange: function(model, selected) {
 244             let me = this;
 245             let vm = me.getViewModel();
 246
 247             vm.set('volumeGroup', selected[0]?.data.vg || '');
 248             vm.set('thinPool', selected[0]?.data.lv || '');
 249         },
 250     },
 251
 252     initComponent: function() {
 253         let me = this;
 254
 255         me.nodename = me.pveSelNode.data.node;
 256         if (!me.nodename) {
 257             throw "no node name specified";
 258         }
 259
 260         Ext.apply(me, {
 261             store: {
 262                 fields: [
 263                     'lv',
 264                     'lv_size',
 265                     'used',
 266                     'metadata_size',
 267                     'metadata_used',
 268                     {
 269                         type: 'number',
 270                         name: 'usage',
 271                         calculate: data => data.used / data.lv_size,
 272                     },
 273                     {
 274                         type: 'number',
 275                         name: 'metadata_usage',
 276                         calculate: data => data.metadata_used / data.metadata_size,
 277                     },
 278                 ],
 279                 proxy: {
 280                     type: 'proxmox',
 281                     url: `/api2/json/nodes/${me.nodename}/disks/lvmthin`,
 282                 },
 283                 sorters: 'lv',
 284             },
 285         });
 286
 287         me.callParent();
 288
 289         Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
 290         me.reload();
 291     },
 292 });
 293