www/manager6/ceph/OSDDetails.js

   1 Ext.define('pve-osd-details-devices', {
   2     extend: 'Ext.data.Model',
   3     fields: ['device', 'type', 'physical_device', 'size', 'support_discard', 'dev_node'],
   4     idProperty: 'device',
   5 });
   6
   7 Ext.define('PVE.CephOsdDetails', {
   8     extend: 'Ext.window.Window',
   9     alias: ['widget.pveCephOsdDetails'],
  10
  11     mixins: ['Proxmox.Mixin.CBind'],
  12
  13     cbindData: function() {
  14         let me = this;
  15         me.baseUrl = `/nodes/${me.nodename}/ceph/osd/${me.osdid}`;
  16         return {
  17             title: `${gettext('Details')}: OSD ${me.osdid}`,
  18         };
  19     },
  20
  21     viewModel: {
  22         data: {
  23             device: '',
  24         },
  25     },
  26
  27     modal: true,
  28     width: 650,
  29     minHeight: 250,
  30     resizable: true,
  31     cbind: {
  32         title: '{title}',
  33     },
  34
  35     layout: {
  36         type: 'vbox',
  37         align: 'stretch',
  38     },
  39     defaults: {
  40         layout: 'fit',
  41         border: false,
  42     },
  43
  44     controller: {
  45         xclass: 'Ext.app.ViewController',
  46
  47         reload: function() {
  48             let view = this.getView();
  49
  50             Proxmox.Utils.API2Request({
  51                 url: `${view.baseUrl}/metadata`,
  52                 waitMsgTarget: view.lookup('detailsTabs'),
  53                 method: 'GET',
  54                 failure: function(response, opts) {
  55                     Proxmox.Utils.setErrorMask(view.lookup('detailsTabs'), response.htmlStatus);
  56                 },
  57                 success: function(response, opts) {
  58                     let d = response.result.data;
  59                     let osdData = Object.keys(d.osd).sort().map(x => ({ key: x, value: d.osd[x] }));
  60                     view.osdStore.loadData(osdData);
  61                     let devices = view.lookup('devices');
  62                     let deviceStore = devices.getStore();
  63                     deviceStore.loadData(d.devices);
  64
  65                     view.lookup('osdGeneral').rstore.fireEvent('load', view.osdStore, osdData, true);
  66                     view.lookup('osdNetwork').rstore.fireEvent('load', view.osdStore, osdData, true);
  67
  68                     // select 'block' device automatically on first load
  69                     if (devices.getSelection().length === 0) {
  70                         devices.setSelection(deviceStore.findRecord('device', 'block'));
  71                     }
  72                 },
  73             });
  74         },
  75
  76         showDevInfo: function(grid, selected) {
  77             let view = this.getView();
  78             if (selected[0]) {
  79                 let device = selected[0].data.device;
  80                 this.getViewModel().set('device', device);
  81
  82                 let detailStore = view.lookup('volumeDetails');
  83                 detailStore.rstore.getProxy().setUrl(`api2/json${view.baseUrl}/lv-info`);
  84                 detailStore.rstore.getProxy().setExtraParams({ 'type': device });
  85                 detailStore.setLoading();
  86                 detailStore.rstore.load({ callback: () => detailStore.setLoading(false) });
  87             }
  88         },
  89
  90         init: function() {
  91             this.reload();
  92         },
  93
  94         control: {
  95             'grid[reference=devices]': {
  96                 selectionchange: 'showDevInfo',
  97             },
  98         },
  99     },
 100     tbar: [
 101         {
 102             text: gettext('Reload'),
 103             iconCls: 'fa fa-refresh',
 104             handler: 'reload',
 105         },
 106     ],
 107     initComponent: function() {
 108         let me = this;
 109
 110         me.osdStore = Ext.create('Proxmox.data.ObjectStore');
 111
 112         Ext.applyIf(me, {
 113             items: [
 114                 {
 115                     xtype: 'tabpanel',
 116                     reference: 'detailsTabs',
 117                     items: [
 118                         {
 119                             xtype: 'proxmoxObjectGrid',
 120                             reference: 'osdGeneral',
 121                             tooltip: gettext('Various information about the OSD'),
 122                             rstore: me.osdStore,
 123                             title: gettext('General'),
 124                             viewConfig: {
 125                                 enableTextSelection: true,
 126                             },
 127                             gridRows: [
 128                                 {
 129                                     xtype: 'text',
 130                                     name: 'version',
 131                                     text: gettext('Version'),
 132                                 },
 133                                 {
 134                                     xtype: 'text',
 135                                     name: 'hostname',
 136                                     text: gettext('Hostname'),
 137                                 },
 138                                 {
 139                                     xtype: 'text',
 140                                     name: 'osd_data',
 141                                     text: gettext('OSD data path'),
 142                                 },
 143                                 {
 144                                     xtype: 'text',
 145                                     name: 'osd_objectstore',
 146                                     text: gettext('OSD object store'),
 147                                 },
 148                                 {
 149                                     xtype: 'text',
 150                                     name: 'mem_usage',
 151                                     text: gettext('Memory usage'),
 152                                     renderer: Proxmox.Utils.render_size,
 153                                 },
 154                                 {
 155                                     xtype: 'text',
 156                                     name: 'pid',
 157                                     text: `${gettext('Process ID')} (PID)`,
 158                                 },
 159                             ],
 160                         },
 161                         {
 162                             xtype: 'proxmoxObjectGrid',
 163                             reference: 'osdNetwork',
 164                             tooltip: gettext('Addresses and ports used by the OSD service'),
 165                             rstore: me.osdStore,
 166                             title: gettext('Network'),
 167                             viewConfig: {
 168                                 enableTextSelection: true,
 169                             },
 170                             gridRows: [
 171                                 {
 172                                     xtype: 'text',
 173                                     name: 'front_addr',
 174                                     text: `${gettext('Front Address')}<br>(Client & Monitor)`,
 175                                     renderer: PVE.Utils.render_ceph_osd_addr,
 176                                 },
 177                                 {
 178                                     xtype: 'text',
 179                                     name: 'hb_front_addr',
 180                                     text: gettext('Heartbeat Front Address'),
 181                                     renderer: PVE.Utils.render_ceph_osd_addr,
 182                                 },
 183                                 {
 184                                     xtype: 'text',
 185                                     name: 'back_addr',
 186                                     text: `${gettext('Back Address')}<br>(OSD)`,
 187                                     renderer: PVE.Utils.render_ceph_osd_addr,
 188                                 },
 189                                 {
 190                                     xtype: 'text',
 191                                     name: 'hb_back_addr',
 192                                     text: gettext('Heartbeat Back Address'),
 193                                     renderer: PVE.Utils.render_ceph_osd_addr,
 194                                 },
 195                             ],
 196                         },
 197                         {
 198                             xtype: 'panel',
 199                             title: 'Devices',
 200                             tooltip: gettext('Physical devices used by the OSD'),
 201                             items: [
 202                                 {
 203                                     xtype: 'grid',
 204                                     border: false,
 205                                     reference: 'devices',
 206                                     store: {
 207                                         model: 'pve-osd-details-devices',
 208                                     },
 209                                     columns: {
 210                                         items: [
 211                                             { text: gettext('Device'), dataIndex: 'device' },
 212                                             { text: gettext('Type'), dataIndex: 'type' },
 213                                             {
 214                                                 text: gettext('Physical Device'),
 215                                                 dataIndex: 'physical_device',
 216                                             },
 217                                             {
 218                                                 text: gettext('Size'),
 219                                                 dataIndex: 'size',
 220                                                 renderer: Proxmox.Utils.render_size,
 221                                             },
 222                                             {
 223                                                 text: 'Discard',
 224                                                 dataIndex: 'support_discard',
 225                                                 hidden: true,
 226                                             },
 227                                             {
 228                                                 text: gettext('Device node'),
 229                                                 dataIndex: 'dev_node',
 230                                                 hidden: true,
 231                                             },
 232                                         ],
 233                                         defaults: {
 234                                             tdCls: 'pointer',
 235                                             flex: 1,
 236                                         },
 237                                     },
 238                                 },
 239                                 {
 240                                     xtype: 'proxmoxObjectGrid',
 241                                     reference: 'volumeDetails',
 242                                     maskOnLoad: true,
 243                                     viewConfig: {
 244                                         enableTextSelection: true,
 245                                     },
 246                                     bind: {
 247                                         title: Ext.String.format(
 248                                                 gettext('Volume Details for {0}'),
 249                                                 '{device}',
 250                                         ),
 251                                     },
 252                                     rows: {
 253                                         creation_time: {
 254                                             header: gettext('Creation time'),
 255                                         },
 256                                         lv_name: {
 257                                             header: gettext('LV Name'),
 258                                         },
 259                                         lv_path: {
 260                                             header: gettext('LV Path'),
 261                                         },
 262                                         lv_uuid: {
 263                                             header: gettext('LV UUID'),
 264                                         },
 265                                         vg_name: {
 266                                             header: gettext('VG Name'),
 267                                         },
 268                                     },
 269                                     url: 'nodes/', //placeholder will be set when device is selected
 270                                 },
 271                             ],
 272                         },
 273                     ],
 274                 },
 275             ],
 276         });
 277
 278         me.callParent();
 279     },
 280 });