src/grid/DiskList.js

   1 Ext.define('pmx-disk-list', {
   2     extend: 'Ext.data.Model',
   3     fields: [
   4         'devpath', 'used',
   5         { name: 'size', type: 'number' },
   6         { name: 'osdid', type: 'number' },
   7         {
   8             name: 'status',
   9             convert: function(value, rec) {
  10                 if (value) return value;
  11                 if (rec.data.health) {
  12                     return rec.data.health;
  13                 }
  14                 return Proxmox.Utils.unknownText;
  15             },
  16         },
  17         {
  18             name: 'name',
  19             convert: function(value, rec) {
  20                 if (value) return value;
  21                 if (rec.data.devpath) return rec.data.devpath;
  22                 return undefined;
  23             },
  24         },
  25         {
  26             name: 'disk-type',
  27             convert: function(value, rec) {
  28                 if (value) return value;
  29                 if (rec.data.type) return rec.data.type;
  30                 return undefined;
  31             },
  32         },
  33         'vendor', 'model', 'serial', 'rpm', 'type', 'wearout', 'health',
  34     ],
  35     idProperty: 'devpath',
  36 });
  37
  38 Ext.define('Proxmox.DiskList', {
  39     extend: 'Ext.grid.GridPanel',
  40     alias: 'widget.pmxDiskList',
  41
  42     emptyText: gettext('No Disks found'),
  43
  44     stateful: true,
  45     stateId: 'grid-node-disks',
  46
  47     controller: {
  48         xclass: 'Ext.app.ViewController',
  49
  50         reload: function() {
  51             let me = this;
  52             me.getView().getStore().load();
  53         },
  54
  55         openSmartWindow: function() {
  56             let me = this;
  57             let view = me.getView();
  58             let selection = view.getSelection();
  59             if (!selection || selection.length < 1) return;
  60
  61             let rec = selection[0];
  62             Ext.create('Proxmox.window.DiskSmart', {
  63                 baseurl: view.baseurl,
  64                 dev: rec.data.name,
  65             }).show();
  66         },
  67
  68         initGPT: function() {
  69             let me = this;
  70             let view = me.getView();
  71             let selection = view.getSelection();
  72             if (!selection || selection.length < 1) return;
  73
  74             let rec = selection[0];
  75             Proxmox.Utils.API2Request({
  76                 url: `${view.baseurl}/initgpt`,
  77                 waitMsgTarget: view,
  78                 method: 'POST',
  79                 params: { disk: rec.data.devpath },
  80                 failure: function(response, options) {
  81                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
  82                 },
  83                 success: function(response, options) {
  84                     var upid = response.result.data;
  85                     var win = Ext.create('Proxmox.window.TaskProgress', {
  86                         upid: upid,
  87                     });
  88                     win.show();
  89                 },
  90             });
  91         },
  92
  93         init: function(view) {
  94             Proxmox.Utils.monStoreErrors(view, view.getStore(), true);
  95
  96             let nodename = view.nodename || 'localhost';
  97             view.baseurl = `/api2/json/nodes/${nodename}/disks`;
  98             view.getStore().getProxy().setUrl(`${view.baseurl}/list`);
  99             view.getStore().load();
 100         },
 101     },
 102
 103     store: {
 104         model: 'pmx-disk-list',
 105         proxy: {
 106             type: 'proxmox',
 107         },
 108         sorters: [
 109             {
 110                 property: 'dev',
 111                 direction: 'ASC',
 112             },
 113         ],
 114     },
 115
 116     tbar: [
 117         {
 118             text: gettext('Reload'),
 119             handler: 'reload',
 120         },
 121         {
 122             xtype: 'proxmoxButton',
 123             text: gettext('Show S.M.A.R.T. values'),
 124             disabled: true,
 125             handler: 'openSmartWindow',
 126         },
 127         {
 128             xtype: 'proxmoxButton',
 129             text: gettext('Initialize Disk with GPT'),
 130             disabled: true,
 131             enableFn: function(rec) {
 132                 if (!rec || rec.data.used) {
 133                     return false;
 134                 } else {
 135                     return true;
 136                 }
 137             },
 138             handler: 'initGPT',
 139         },
 140     ],
 141
 142     columns: [
 143         {
 144             header: gettext('Device'),
 145             width: 150,
 146             sortable: true,
 147             dataIndex: 'devpath',
 148         },
 149         {
 150             header: gettext('Type'),
 151             width: 80,
 152             sortable: true,
 153             dataIndex: 'disk-type',
 154             renderer: function(v) {
 155                 if (v === undefined) return Proxmox.Utils.unknownText;
 156                 switch (v) {
 157                     case 'ssd': return 'SSD';
 158                     case 'hdd': return 'Hard Disk';
 159                     case 'usb': return 'USB';
 160                     default: return v;
 161                 }
 162             },
 163         },
 164         {
 165             header: gettext('Usage'),
 166             width: 150,
 167             sortable: false,
 168             renderer: v => v || Proxmox.Utils.noText,
 169             dataIndex: 'used',
 170         },
 171         {
 172             header: gettext('Size'),
 173             width: 100,
 174             align: 'right',
 175             sortable: true,
 176             renderer: Proxmox.Utils.format_size,
 177             dataIndex: 'size',
 178         },
 179         {
 180             header: 'GPT',
 181             width: 60,
 182             align: 'right',
 183             renderer: Proxmox.Utils.format_boolean,
 184             dataIndex: 'gpt',
 185         },
 186         {
 187             header: gettext('Vendor'),
 188             width: 100,
 189             sortable: true,
 190             hidden: true,
 191             renderer: Ext.String.htmlEncode,
 192             dataIndex: 'vendor',
 193         },
 194         {
 195             header: gettext('Model'),
 196             width: 200,
 197             sortable: true,
 198             renderer: Ext.String.htmlEncode,
 199             dataIndex: 'model',
 200         },
 201         {
 202             header: gettext('Serial'),
 203             width: 200,
 204             sortable: true,
 205             renderer: Ext.String.htmlEncode,
 206             dataIndex: 'serial',
 207         },
 208         {
 209             header: 'S.M.A.R.T.',
 210             width: 100,
 211             sortable: true,
 212             renderer: Ext.String.htmlEncode,
 213             dataIndex: 'status',
 214         },
 215         {
 216             header: 'Wearout',
 217             width: 90,
 218             sortable: true,
 219             align: 'right',
 220             dataIndex: 'wearout',
 221             renderer: function(value) {
 222                 if (Ext.isNumeric(value)) {
 223                     return (100 - value).toString() + '%';
 224                 }
 225                 return 'N/A';
 226             },
 227         },
 228     ],
 229
 230     listeners: {
 231         itemdblclick: 'openSmartWindow',
 232     },
 233 });