www/manager6/node/LVM.js

   1 Ext.define('PVE.node.CreateLVM', {
   2     extend: 'Proxmox.window.Edit',
   3     xtype: 'pveCreateLVM',
   4
   5     onlineHelp: 'chapter_lvm',
   6     subject: 'LVM Volume Group',
   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         me.isCreate = true;
  19
  20         Ext.applyIf(me, {
  21             url: `/nodes/${me.nodename}/disks/lvm`,
  22             method: 'POST',
  23             items: [
  24                 {
  25                     xtype: 'pmxDiskSelector',
  26                     name: 'device',
  27                     nodename: me.nodename,
  28                     diskType: 'unused',
  29                     includePartitions: true,
  30                     fieldLabel: gettext('Disk'),
  31                     allowBlank: false,
  32                 },
  33                 {
  34                     xtype: 'proxmoxtextfield',
  35                     name: 'name',
  36                     fieldLabel: gettext('Name'),
  37                     allowBlank: false,
  38                 },
  39                 {
  40                     xtype: 'proxmoxcheckbox',
  41                     name: 'add_storage',
  42                     fieldLabel: gettext('Add Storage'),
  43                     value: '1',
  44                 },
  45             ],
  46         });
  47
  48         me.callParent();
  49     },
  50 });
  51
  52 Ext.define('PVE.node.LVMList', {
  53     extend: 'Ext.tree.Panel',
  54     xtype: 'pveLVMList',
  55
  56     viewModel: {
  57         data: {
  58             volumeGroup: '',
  59         },
  60     },
  61
  62     controller: {
  63         xclass: 'Ext.app.ViewController',
  64
  65         destroyVolumeGroup: function() {
  66             let me = this;
  67             let vm = me.getViewModel();
  68             let view = me.getView();
  69
  70             const volumeGroup = vm.get('volumeGroup');
  71
  72             if (!view.nodename) {
  73                 throw "no node name specified";
  74             }
  75
  76             if (!volumeGroup) {
  77                 throw "no volume group specified";
  78             }
  79
  80             Ext.create('PVE.window.SafeDestroyStorage', {
  81                 url: `/nodes/${view.nodename}/disks/lvm/${volumeGroup}`,
  82                 item: { id: volumeGroup },
  83                 taskName: 'lvmremove',
  84                 taskDone: () => { view.reload(); },
  85             }).show();
  86         },
  87     },
  88
  89     emptyText: PVE.Utils.renderNotFound('VGs'),
  90
  91     stateful: true,
  92     stateId: 'grid-node-lvm',
  93
  94     rootVisible: false,
  95     useArrows: true,
  96
  97     columns: [
  98         {
  99             xtype: 'treecolumn',
 100             text: gettext('Name'),
 101             dataIndex: 'name',
 102             flex: 1,
 103         },
 104         {
 105             text: gettext('Number of LVs'),
 106             dataIndex: 'lvcount',
 107             width: 150,
 108             align: 'right',
 109         },
 110         {
 111             header: gettext('Assigned to LVs'),
 112             width: 130,
 113             dataIndex: 'usage',
 114             tdCls: 'x-progressbar-default-cell',
 115             xtype: 'widgetcolumn',
 116             widget: {
 117                 xtype: 'pveProgressBar',
 118             },
 119         },
 120         {
 121             header: gettext('Size'),
 122             width: 100,
 123             align: 'right',
 124             sortable: true,
 125             renderer: Proxmox.Utils.format_size,
 126             dataIndex: 'size',
 127         },
 128         {
 129             header: gettext('Free'),
 130             width: 100,
 131             align: 'right',
 132             sortable: true,
 133             renderer: Proxmox.Utils.format_size,
 134             dataIndex: 'free',
 135         },
 136     ],
 137
 138     tbar: [
 139         {
 140             text: gettext('Reload'),
 141             iconCls: 'fa fa-refresh',
 142             handler: function() {
 143                 this.up('panel').reload();
 144             },
 145         },
 146         {
 147             text: gettext('Create') + ': Volume Group',
 148             handler: function() {
 149                 let view = this.up('panel');
 150                 Ext.create('PVE.node.CreateLVM', {
 151                     nodename: view.nodename,
 152                     taskDone: () => view.reload(),
 153                     autoShow: true,
 154                 });
 155             },
 156         },
 157         '->',
 158         {
 159             xtype: 'tbtext',
 160             data: {
 161                 volumeGroup: undefined,
 162             },
 163             bind: {
 164                 data: {
 165                     volumeGroup: "{volumeGroup}",
 166                 },
 167             },
 168             tpl: [
 169                 '<tpl if="volumeGroup">',
 170                 'Volume group {volumeGroup}:',
 171                 '<tpl else>',
 172                 Ext.String.format(gettext('No {0} selected'), 'volume group'),
 173                 '</tpl>',
 174             ],
 175         },
 176         {
 177             text: gettext('More'),
 178             iconCls: 'fa fa-bars',
 179             disabled: true,
 180             bind: {
 181                 disabled: '{!volumeGroup}',
 182             },
 183             menu: [
 184                 {
 185                     text: gettext('Destroy'),
 186                     itemId: 'remove',
 187                     iconCls: 'fa fa-fw fa-trash-o',
 188                     handler: 'destroyVolumeGroup',
 189                     disabled: true,
 190                     bind: {
 191                         disabled: '{!volumeGroup}',
 192                     },
 193                 },
 194             ],
 195         },
 196     ],
 197
 198     reload: function() {
 199         let me = this;
 200         let sm = me.getSelectionModel();
 201         Proxmox.Utils.API2Request({
 202             url: `/nodes/${me.nodename}/disks/lvm`,
 203             waitMsgTarget: me,
 204             method: 'GET',
 205             failure: (response, opts) => Proxmox.Utils.setErrorMask(me, response.htmlStatus),
 206             success: function(response, opts) {
 207                 sm.deselectAll();
 208                 me.setRootNode(response.result.data);
 209                 me.expandAll();
 210             },
 211         });
 212     },
 213
 214     listeners: {
 215         activate: function() {
 216             this.reload();
 217         },
 218         selectionchange: function(model, selected) {
 219             let me = this;
 220             let vm = me.getViewModel();
 221
 222             if (selected.length < 1 || selected[0].data.parentId !== 'root') {
 223                 vm.set('volumeGroup', '');
 224             } else {
 225                 vm.set('volumeGroup', selected[0].data.name);
 226             }
 227         },
 228     },
 229
 230     selModel: 'treemodel',
 231     fields: [
 232         'name',
 233         'size',
 234         'free',
 235         {
 236             type: 'string',
 237             name: 'iconCls',
 238             calculate: data => `fa x-fa-tree fa-${data.leaf ? 'hdd-o' : 'object-group'}`,
 239         },
 240         {
 241             type: 'number',
 242             name: 'usage',
 243             calculate: data => (data.size - data.free) / data.size,
 244         },
 245     ],
 246     sorters: 'name',
 247
 248     initComponent: function() {
 249         let me = this;
 250
 251         me.nodename = me.pveSelNode.data.node;
 252         if (!me.nodename) {
 253             throw "no node name specified";
 254         }
 255         me.callParent();
 256
 257         me.reload();
 258     },
 259 });
 260