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.exturl}/initgpt`,
  77                 waitMsgTarget: view,
  78                 method: 'POST',
  79                 params: { disk: rec.data.name },
  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                         taskDone: function() {
  88                             me.reload();
  89                         },
  90                     });
  91                     win.show();
  92                 },
  93             });
  94         },
  95
  96         init: function(view) {
  97             Proxmox.Utils.monStoreErrors(view, view.getStore(), true);
  98
  99             let nodename = view.nodename || 'localhost';
 100             view.baseurl = `/api2/json/nodes/${nodename}/disks`;
 101             view.exturl = `/api2/extjs/nodes/${nodename}/disks`;
 102             view.getStore().getProxy().setUrl(`${view.baseurl}/list`);
 103             view.getStore().load();
 104         },
 105     },
 106
 107     store: {
 108         model: 'pmx-disk-list',
 109         proxy: {
 110             type: 'proxmox',
 111         },
 112         sorters: [
 113             {
 114                 property: 'dev',
 115                 direction: 'ASC',
 116             },
 117         ],
 118     },
 119
 120     tbar: [
 121         {
 122             text: gettext('Reload'),
 123             handler: 'reload',
 124         },
 125         {
 126             xtype: 'proxmoxButton',
 127             text: gettext('Show S.M.A.R.T. values'),
 128             disabled: true,
 129             handler: 'openSmartWindow',
 130         },
 131         {
 132             xtype: 'proxmoxButton',
 133             text: gettext('Initialize Disk with GPT'),
 134             disabled: true,
 135             enableFn: function(rec) {
 136                 if (!rec || (rec.data.used && rec.data.used !== 'unused')) {
 137                     return false;
 138                 } else {
 139                     return true;
 140                 }
 141             },
 142             handler: 'initGPT',
 143         },
 144     ],
 145
 146     columns: [
 147         {
 148             header: gettext('Device'),
 149             width: 150,
 150             sortable: true,
 151             dataIndex: 'devpath',
 152         },
 153         {
 154             header: gettext('Type'),
 155             width: 80,
 156             sortable: true,
 157             dataIndex: 'disk-type',
 158             renderer: function(v) {
 159                 if (v === undefined) return Proxmox.Utils.unknownText;
 160                 switch (v) {
 161                     case 'ssd': return 'SSD';
 162                     case 'hdd': return 'Hard Disk';
 163                     case 'usb': return 'USB';
 164                     default: return v;
 165                 }
 166             },
 167         },
 168         {
 169             header: gettext('Usage'),
 170             width: 150,
 171             sortable: false,
 172             renderer: v => v || Proxmox.Utils.noText,
 173             dataIndex: 'used',
 174         },
 175         {
 176             header: gettext('Size'),
 177             width: 100,
 178             align: 'right',
 179             sortable: true,
 180             renderer: Proxmox.Utils.format_size,
 181             dataIndex: 'size',
 182         },
 183         {
 184             header: 'GPT',
 185             width: 60,
 186             align: 'right',
 187             renderer: Proxmox.Utils.format_boolean,
 188             dataIndex: 'gpt',
 189         },
 190         {
 191             header: gettext('Vendor'),
 192             width: 100,
 193             sortable: true,
 194             hidden: true,
 195             renderer: Ext.String.htmlEncode,
 196             dataIndex: 'vendor',
 197         },
 198         {
 199             header: gettext('Model'),
 200             width: 200,
 201             sortable: true,
 202             renderer: Ext.String.htmlEncode,
 203             dataIndex: 'model',
 204         },
 205         {
 206             header: gettext('Serial'),
 207             width: 200,
 208             sortable: true,
 209             renderer: Ext.String.htmlEncode,
 210             dataIndex: 'serial',
 211         },
 212         {
 213             header: 'S.M.A.R.T.',
 214             width: 100,
 215             sortable: true,
 216             renderer: Ext.String.htmlEncode,
 217             dataIndex: 'status',
 218         },
 219         {
 220             header: 'Wearout',
 221             width: 90,
 222             sortable: true,
 223             align: 'right',
 224             dataIndex: 'wearout',
 225             renderer: function(value) {
 226                 if (Ext.isNumeric(value)) {
 227                     return (100 - value).toString() + '%';
 228                 }
 229                 return 'N/A';
 230             },
 231         },
 232     ],
 233
 234     listeners: {
 235         itemdblclick: 'openSmartWindow',
 236     },
 237 });