www/manager6/ceph/OSD.js

   1 Ext.define('PVE.CephCreateOsd', {
   2     extend: 'PVE.window.Edit',
   3     alias: ['widget.pveCephCreateOsd'],
   4
   5     subject: 'Ceph OSD',
   6
   7     showProgress: true,
   8
   9     initComponent : function() {
  10          /*jslint confusion: true */
  11         var me = this;
  12
  13         if (!me.nodename) {
  14             throw "no node name specified";
  15         }
  16
  17         me.create = true;
  18
  19         Ext.applyIf(me, {
  20             url: "/nodes/" + me.nodename + "/ceph/osd",
  21             method: 'POST',
  22             items: [
  23                {
  24                    xtype: 'pveCephDiskSelector',
  25                    name: 'dev',
  26                    nodename: me.nodename,
  27                    value: me.dev,
  28                    diskType: 'unused',
  29                    fieldLabel: gettext('Disk'),
  30                    allowBlank: false
  31                },
  32                {
  33                    xtype: 'pveCephDiskSelector',
  34                    name: 'journal_dev',
  35                    nodename: me.nodename,
  36                    diskType: 'journal_disks',
  37                    fieldLabel: gettext('Journal Disk'),
  38                    value: '',
  39                    autoSelect: false,
  40                    allowBlank: true,
  41                    emptyText: 'use OSD disk'
  42                }
  43             ]
  44         });
  45
  46         me.callParent();
  47     }
  48 });
  49
  50 Ext.define('PVE.CephRemoveOsd', {
  51     extend: 'PVE.window.Edit',
  52     alias: ['widget.pveCephRemoveOsd'],
  53
  54     isRemove: true,
  55
  56     showProgress: true,
  57     method: 'DELETE',
  58     items: [
  59         {
  60             xtype: 'pvecheckbox',
  61             name: 'cleanup',
  62             checked: true,
  63             labelWidth: 130,
  64             fieldLabel: gettext('Remove Partitions')
  65         }
  66     ],
  67     initComponent : function() {
  68          /*jslint confusion: true */
  69         var me = this;
  70
  71         if (!me.nodename) {
  72             throw "no node name specified";
  73         }
  74         if (me.osdid === undefined || me.osdid < 0) {
  75             throw "no osdid specified";
  76         }
  77
  78         me.create = true;
  79
  80         me.title = gettext('Remove') + ': ' + 'Ceph OSD osd.' + me.osdid;
  81
  82         Ext.applyIf(me, {
  83             url: "/nodes/" + me.nodename + "/ceph/osd/" + me.osdid
  84         });
  85
  86         me.callParent();
  87     }
  88 });
  89
  90 Ext.define('PVE.node.CephOsdTree', {
  91     extend: 'Ext.tree.Panel',
  92     alias: ['widget.pveNodeCephOsdTree'],
  93     columns: [
  94         {
  95             xtype: 'treecolumn',
  96             text: 'Name',
  97             dataIndex: 'name',
  98             width: 150
  99         },
 100         {
 101             text: 'Type',
 102             dataIndex: 'type',
 103             align: 'right',
 104             width: 60
 105         },
 106         {
 107             text: 'Status',
 108             dataIndex: 'status',
 109             align: 'right',
 110             renderer: function(value, metaData, rec) {
 111                 if (!value) {
 112                     return value;
 113                 }
 114                 var data = rec.data;
 115                 return value + '/' + (data['in'] ? 'in' : 'out');
 116             },
 117             width: 80
 118         },
 119         {
 120             text: 'weight',
 121             dataIndex: 'crush_weight',
 122             align: 'right',
 123             renderer: function(value, metaData, rec) {
 124                 if (rec.data.type !== 'osd') {
 125                     return '';
 126                 }
 127                 return value;
 128             },
 129             width: 80
 130         },
 131         {
 132             text: 'reweight',
 133             dataIndex: 'reweight',
 134             align: 'right',
 135             renderer: function(value, metaData, rec) {
 136                 if (rec.data.type !== 'osd') {
 137                     return '';
 138                 }
 139                 return value;
 140             },
 141             width: 90
 142         },
 143         {
 144             header: gettext('Used'),
 145             columns: [
 146                 {
 147                     text: '%',
 148                     dataIndex: 'percent_used',
 149                     align: 'right',
 150                     renderer: function(value, metaData, rec) {
 151                         if (rec.data.type !== 'osd') {
 152                             return '';
 153                         }
 154                         return Ext.util.Format.number(value, '0.00');
 155                     },
 156                     width: 80
 157                 },
 158                 {
 159                     text: gettext('Total'),
 160                     dataIndex: 'total_space',
 161                     align: 'right',
 162                     renderer: function(value, metaData, rec) {
 163                         if (rec.data.type !== 'osd') {
 164                             return '';
 165                         }
 166                         return PVE.Utils.render_size(value);
 167                     },
 168                     width: 100
 169                 }
 170             ]
 171         },
 172         {
 173             header: gettext('Latency (ms)'),
 174             columns: [
 175                 {
 176                     text: 'Apply',
 177                     dataIndex: 'apply_latency_ms',
 178                     align: 'right',
 179                     renderer: function(value, metaData, rec) {
 180                         if (rec.data.type !== 'osd') {
 181                             return '';
 182                         }
 183                         return value;
 184                     },
 185                     width: 60
 186                 },
 187                 {
 188                     text: 'Commit',
 189                     dataIndex: 'commit_latency_ms',
 190                     align: 'right',
 191                     renderer: function(value, metaData, rec) {
 192                         if (rec.data.type !== 'osd') {
 193                             return '';
 194                         }
 195                         return value;
 196                     },
 197                     width: 60
 198                 }
 199             ]
 200         }
 201     ],
 202     initComponent: function() {
 203          /*jslint confusion: true */
 204         var me = this;
 205
 206         var nodename = me.pveSelNode.data.node;
 207         if (!nodename) {
 208             throw "no node name specified";
 209         }
 210
 211         var sm = Ext.create('Ext.selection.TreeModel', {});
 212
 213         var set_button_status; // defined later
 214
 215         var reload = function() {
 216             PVE.Utils.API2Request({
 217                 url: "/nodes/" + nodename + "/ceph/osd",
 218                 waitMsgTarget: me,
 219                 method: 'GET',
 220                 failure: function(response, opts) {
 221                     PVE.Utils.setErrorMask(me, response.htmlStatus);
 222                 },
 223                 success: function(response, opts) {
 224                     sm.deselectAll();
 225                     me.setRootNode(response.result.data.root);
 226                     me.expandAll();
 227                     set_button_status();
 228                 }
 229             });
 230         };
 231
 232         var osd_cmd = function(cmd) {
 233             var rec = sm.getSelection()[0];
 234             if (!(rec && (rec.data.id >= 0) && rec.data.host)) {
 235                 return;
 236             }
 237             PVE.Utils.API2Request({
 238                 url: "/nodes/" + rec.data.host + "/ceph/osd/" +
 239                     rec.data.id + '/' + cmd,
 240                 waitMsgTarget: me,
 241                 method: 'POST',
 242                 success: reload,
 243                 failure: function(response, opts) {
 244                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 245                 }
 246             });
 247         };
 248
 249         var service_cmd = function(cmd) {
 250             var rec = sm.getSelection()[0];
 251             if (!(rec && rec.data.name && rec.data.host)) {
 252                 return;
 253             }
 254             PVE.Utils.API2Request({
 255                 url: "/nodes/" + rec.data.host + "/ceph/" + cmd,
 256                 params: { service: rec.data.name },
 257                 waitMsgTarget: me,
 258                 method: 'POST',
 259                 success: function(response, options) {
 260                     var upid = response.result.data;
 261                     var win = Ext.create('PVE.window.TaskProgress', { upid: upid });
 262                     win.show();
 263                     me.mon(win, 'close', reload, me);
 264                 },
 265                 failure: function(response, opts) {
 266                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 267                 }
 268             });
 269         };
 270
 271         var start_btn = new Ext.Button({
 272             text: gettext('Start'),
 273             disabled: true,
 274             handler: function(){ service_cmd('start'); }
 275         });
 276
 277         var stop_btn = new Ext.Button({
 278             text: gettext('Stop'),
 279             disabled: true,
 280             handler: function(){ service_cmd('stop'); }
 281         });
 282
 283         var osd_out_btn = new Ext.Button({
 284             text: 'Out',
 285             disabled: true,
 286             handler: function(){ osd_cmd('out'); }
 287         });
 288
 289         var osd_in_btn = new Ext.Button({
 290             text: 'In',
 291             disabled: true,
 292             handler: function(){ osd_cmd('in'); }
 293         });
 294
 295         var remove_btn = new Ext.Button({
 296             text: gettext('Remove'),
 297             disabled: true,
 298             handler: function(){
 299                 var rec = sm.getSelection()[0];
 300                 if (!(rec && (rec.data.id >= 0) && rec.data.host)) {
 301                     return;
 302                 }
 303
 304                 var win = Ext.create('PVE.CephRemoveOsd', {
 305                     nodename: rec.data.host,
 306                     osdid: rec.data.id
 307                 });
 308                 win.show();
 309                 me.mon(win, 'close', reload, me);
 310             }
 311         });
 312
 313         set_button_status = function() {
 314             var rec = sm.getSelection()[0];
 315
 316             if (!rec) {
 317                 start_btn.setDisabled(true);
 318                 stop_btn.setDisabled(true);
 319                 remove_btn.setDisabled(true);
 320                 osd_out_btn.setDisabled(true);
 321                 osd_in_btn.setDisabled(true);
 322                 return;
 323             }
 324
 325             var isOsd = (rec.data.host && (rec.data.type === 'osd') && (rec.data.id >= 0));
 326
 327             start_btn.setDisabled(!(isOsd && (rec.data.status !== 'up')));
 328             stop_btn.setDisabled(!(isOsd && (rec.data.status !== 'down')));
 329             remove_btn.setDisabled(!(isOsd && (rec.data.status === 'down')));
 330
 331             osd_out_btn.setDisabled(!(isOsd && rec.data['in']));
 332             osd_in_btn.setDisabled(!(isOsd && !rec.data['in']));
 333         };
 334
 335         sm.on('selectionchange', set_button_status);
 336
 337         var reload_btn = new Ext.Button({
 338             text: gettext('Reload'),
 339             handler: reload
 340         });
 341
 342         Ext.apply(me, {
 343             tbar: [ reload_btn, start_btn, stop_btn, osd_out_btn, osd_in_btn, remove_btn ],
 344             rootVisible: false,
 345             fields: ['name', 'type', 'status', 'host', 'in', 'id' ,
 346                      { type: 'number', name: 'reweight' },
 347                      { type: 'number', name: 'percent_used' },
 348                      { type: 'integer', name: 'bytes_used' },
 349                      { type: 'integer', name: 'total_space' },
 350                      { type: 'integer', name: 'apply_latency_ms' },
 351                      { type: 'integer', name: 'commit_latency_ms' },
 352                      { type: 'number', name: 'crush_weight' }],
 353             stateful: false,
 354             selModel: sm,
 355
 356             listeners: {
 357                 activate: function() {
 358                     reload();
 359                 }
 360             }
 361         });
 362
 363         me.callParent();
 364
 365         reload();
 366     }
 367 });