www/manager6/node/ZFS.js

   1 Ext.define('PVE.node.CreateZFS', {
   2     extend: 'Proxmox.window.Edit',
   3     xtype: 'pveCreateZFS',
   4
   5     onlineHelp: 'chapter_zfs',
   6     subject: 'ZFS',
   7
   8     showProgress: true,
   9     isCreate: true,
  10     width: 800,
  11
  12     initComponent: function() {
  13         let me = this;
  14
  15         if (!me.nodename) {
  16             throw "no node name specified";
  17         }
  18
  19         Ext.apply(me, {
  20             url: `/nodes/${me.nodename}/disks/zfs`,
  21             method: 'POST',
  22             items: [
  23                 {
  24                     xtype: 'inputpanel',
  25                     column1: [
  26                         {
  27                             xtype: 'proxmoxtextfield',
  28                             name: 'name',
  29                             fieldLabel: gettext('Name'),
  30                             allowBlank: false,
  31                         },
  32                         {
  33                             xtype: 'proxmoxcheckbox',
  34                             name: 'add_storage',
  35                             fieldLabel: gettext('Add Storage'),
  36                             value: '1',
  37                         },
  38                     ],
  39                     column2: [
  40                         {
  41                             xtype: 'proxmoxKVComboBox',
  42                             fieldLabel: gettext('RAID Level'),
  43                             name: 'raidlevel',
  44                             value: 'single',
  45                             comboItems: [
  46                                 ['single', gettext('Single Disk')],
  47                                 ['mirror', 'Mirror'],
  48                                 ['raid10', 'RAID10'],
  49                                 ['raidz', 'RAIDZ'],
  50                                 ['raidz2', 'RAIDZ2'],
  51                                 ['raidz3', 'RAIDZ3'],
  52                             ],
  53                         },
  54                         {
  55                             xtype: 'proxmoxKVComboBox',
  56                             fieldLabel: gettext('Compression'),
  57                             name: 'compression',
  58                             value: 'on',
  59                             comboItems: [
  60                                 ['on', 'on'],
  61                                 ['off', 'off'],
  62                                 ['gzip', 'gzip'],
  63                                 ['lz4', 'lz4'],
  64                                 ['lzjb', 'lzjb'],
  65                                 ['zle', 'zle'],
  66                                 ['zstd', 'zstd'],
  67                             ],
  68                         },
  69                         {
  70                             xtype: 'proxmoxintegerfield',
  71                             fieldLabel: gettext('ashift'),
  72                             minValue: 9,
  73                             maxValue: 16,
  74                             value: '12',
  75                             name: 'ashift',
  76                         },
  77                     ],
  78                     columnB: [
  79                         {
  80                             xtype: 'pmxMultiDiskSelector',
  81                             name: 'devices',
  82                             nodename: me.nodename,
  83                             diskType: 'unused',
  84                             includePartitions: true,
  85                             height: 200,
  86                             emptyText: gettext('No Disks unused'),
  87                             itemId: 'disklist',
  88                         },
  89                     ],
  90                 },
  91                 {
  92                     xtype: 'displayfield',
  93                     padding: '5 0 0 0',
  94                     userCls: 'pmx-hint',
  95                     value: 'Note: ZFS is not compatible with disks backed by a hardware ' +
  96                        'RAID controller. For details see <a target="_blank" href="' +
  97                        Proxmox.Utils.get_help_link('chapter_zfs') + '">the reference documentation</a>.',
  98                 },
  99             ],
 100         });
 101
 102         me.callParent();
 103     },
 104 });
 105
 106 Ext.define('PVE.node.ZFSList', {
 107     extend: 'Ext.grid.Panel',
 108     xtype: 'pveZFSList',
 109
 110     viewModel: {
 111         data: {
 112             pool: '',
 113         },
 114     },
 115
 116     controller: {
 117         xclass: 'Ext.app.ViewController',
 118
 119         destroyPool: function() {
 120             let me = this;
 121             let vm = me.getViewModel();
 122             let view = me.getView();
 123
 124             const pool = vm.get('pool');
 125
 126             if (!view.nodename) {
 127                 throw "no node name specified";
 128             }
 129
 130             if (!pool) {
 131                 throw "no pool specified";
 132             }
 133
 134             Ext.create('PVE.window.SafeDestroyStorage', {
 135                 url: `/nodes/${view.nodename}/disks/zfs/${pool}`,
 136                 item: { id: pool },
 137                 taskName: 'zfsremove',
 138                 taskDone: () => { view.reload(); },
 139             }).show();
 140         },
 141     },
 142
 143     stateful: true,
 144     stateId: 'grid-node-zfs',
 145     columns: [
 146         {
 147             text: gettext('Name'),
 148             dataIndex: 'name',
 149             flex: 1,
 150         },
 151         {
 152             header: gettext('Size'),
 153             renderer: Proxmox.Utils.format_size,
 154             dataIndex: 'size',
 155         },
 156         {
 157             header: gettext('Free'),
 158             renderer: Proxmox.Utils.format_size,
 159             dataIndex: 'free',
 160         },
 161         {
 162             header: gettext('Allocated'),
 163             renderer: Proxmox.Utils.format_size,
 164             dataIndex: 'alloc',
 165         },
 166         {
 167             header: gettext('Fragmentation'),
 168             renderer: function(value) {
 169                 return value.toString() + '%';
 170             },
 171             dataIndex: 'frag',
 172         },
 173         {
 174             header: gettext('Health'),
 175             renderer: PVE.Utils.render_zfs_health,
 176             dataIndex: 'health',
 177         },
 178         {
 179             header: gettext('Deduplication'),
 180             hidden: true,
 181             renderer: function(value) {
 182                 return value.toFixed(2).toString() + 'x';
 183             },
 184             dataIndex: 'dedup',
 185         },
 186     ],
 187
 188     rootVisible: false,
 189     useArrows: true,
 190
 191     tbar: [
 192         {
 193             text: gettext('Reload'),
 194             iconCls: 'fa fa-refresh',
 195             handler: function() {
 196                 this.up('panel').reload();
 197             },
 198         },
 199         {
 200             text: gettext('Create') + ': ZFS',
 201             handler: function() {
 202                 let view = this.up('panel');
 203                 Ext.create('PVE.node.CreateZFS', {
 204                     nodename: view.nodename,
 205                     listeners: {
 206                         destroy: () => view.reload(),
 207                     },
 208                     autoShow: true,
 209                 });
 210             },
 211         },
 212         {
 213             text: gettext('Detail'),
 214             itemId: 'detailbtn',
 215             disabled: true,
 216             handler: function() {
 217                 let view = this.up('panel');
 218                 let selection = view.getSelection();
 219                 if (selection.length) {
 220                     view.show_detail(selection[0].get('name'));
 221                 }
 222             },
 223         },
 224         '->',
 225         {
 226             xtype: 'tbtext',
 227             data: {
 228                 pool: undefined,
 229             },
 230             bind: {
 231                 data: {
 232                     pool: "{pool}",
 233                 },
 234             },
 235             tpl: [
 236                 '<tpl if="pool">',
 237                 'Pool {pool}:',
 238                 '<tpl else>',
 239                 Ext.String.format(gettext('No {0} selected'), 'pool'),
 240                 '</tpl>',
 241             ],
 242         },
 243         {
 244             text: gettext('More'),
 245             iconCls: 'fa fa-bars',
 246             disabled: true,
 247             bind: {
 248                 disabled: '{!pool}',
 249             },
 250             menu: [
 251                 {
 252                     text: gettext('Destroy'),
 253                     itemId: 'remove',
 254                     iconCls: 'fa fa-fw fa-trash-o',
 255                     handler: 'destroyPool',
 256                     disabled: true,
 257                     bind: {
 258                         disabled: '{!pool}',
 259                     },
 260                 },
 261             ],
 262         },
 263     ],
 264
 265     show_detail: function(zpool) {
 266         let me = this;
 267
 268         Ext.create('Proxmox.window.ZFSDetail', {
 269             zpool,
 270             nodename: me.nodename,
 271         }).show();
 272     },
 273
 274     set_button_status: function() {
 275         var me = this;
 276     },
 277
 278     reload: function() {
 279         var me = this;
 280         me.store.load();
 281         me.store.sort();
 282     },
 283
 284     listeners: {
 285         activate: function() {
 286             this.reload();
 287         },
 288         selectionchange: function(model, selected) {
 289             let me = this;
 290             let vm = me.getViewModel();
 291
 292             me.down('#detailbtn').setDisabled(selected.length === 0);
 293             vm.set('pool', selected[0]?.data.name || '');
 294         },
 295         itemdblclick: function(grid, record) {
 296             this.show_detail(record.get('name'));
 297         },
 298     },
 299
 300     initComponent: function() {
 301         let me = this;
 302
 303         me.nodename = me.pveSelNode.data.node;
 304         if (!me.nodename) {
 305             throw "no node name specified";
 306         }
 307
 308         Ext.apply(me, {
 309             store: {
 310                 fields: ['name', 'size', 'free', 'alloc', 'dedup', 'frag', 'health'],
 311                 proxy: {
 312                     type: 'proxmox',
 313                     url: `/api2/json/nodes/${me.nodename}/disks/zfs`,
 314                 },
 315                 sorters: 'name',
 316             },
 317         });
 318
 319         me.callParent();
 320
 321         Proxmox.Utils.monStoreErrors(me, me.getStore(), true);
 322         me.reload();
 323     },
 324 });
 325