www/manager6/ceph/ServiceList.js

   1 Ext.define('PVE.CephCreateService', {
   2     extend: 'Proxmox.window.Edit',
   3     xtype: 'pveCephCreateService',
   4
   5     showProgress: true,
   6
   7     setNode: function(nodename) {
   8         var me = this;
   9
  10         me.nodename = nodename;
  11         me.url = "/nodes/" + nodename + "/ceph/" + me.type + "/" + nodename;
  12     },
  13
  14     method: 'POST',
  15     isCreate: true,
  16
  17     items: [
  18         {
  19             xtype: 'pveNodeSelector',
  20             submitValue: false,
  21             fieldLabel: gettext('Host'),
  22             selectCurNode: true,
  23             allowBlank: false,
  24             listeners: {
  25                 change: function(f, value) {
  26                     var me = this.up('pveCephCreateService');
  27                     me.setNode(value);
  28                 }
  29             }
  30         }
  31     ],
  32
  33     initComponent : function() {
  34         var me = this;
  35
  36         if (!me.nodename) {
  37             throw "no node name specified";
  38         }
  39
  40         if (!me.type) {
  41             throw "no type specified";
  42         }
  43
  44         me.setNode(me.nodename);
  45
  46         me.callParent();
  47     }
  48 });
  49
  50 Ext.define('PVE.node.CephServiceList', {
  51     extend: 'Ext.grid.GridPanel',
  52     xtype: 'pveNodeCephServiceList',
  53
  54     onlineHelp: 'chapter_pveceph',
  55     emptyText: gettext('No such service configured.'),
  56
  57     stateful: true,
  58
  59     // will be called when the store loads
  60     storeLoadCallback: Ext.emptyFn,
  61
  62     // if set to true, does shows the ceph install mask if needed
  63     showCephInstallMask: false,
  64
  65     controller: {
  66         xclass: 'Ext.app.ViewController',
  67
  68         init: function(view) {
  69             if (view.pveSelNode) {
  70                 view.nodename = view.pveSelNode.data.node;
  71             }
  72             if (!view.nodename) {
  73                 throw "no node name specified";
  74             }
  75
  76             if (!view.type) {
  77                 throw "no type specified";
  78             }
  79
  80             view.rstore = Ext.create('Proxmox.data.UpdateStore', {
  81                 autoLoad: true,
  82                 autoStart: true,
  83                 interval: 3000,
  84                 storeid: 'ceph-' + view.type + '-list' + view.nodename,
  85                 model: 'ceph-service-list',
  86                 proxy: {
  87                     type: 'proxmox',
  88                     url: "/api2/json/nodes/" + view.nodename + "/ceph/" + view.type
  89                 }
  90             });
  91
  92             view.setStore(Ext.create('Proxmox.data.DiffStore', {
  93                 rstore: view.rstore,
  94                 sorters: [{ property: 'name' }]
  95             }));
  96
  97             if (view.storeLoadCallback) {
  98                 view.rstore.on('load', view.storeLoadCallback, this);
  99             }
 100             view.on('destroy', view.rstore.stopUpdate);
 101
 102             if (view.showCephInstallMask) {
 103                 var regex = new RegExp("not (installed|initialized)", "i");
 104                 PVE.Utils.handleStoreErrorOrMask(view, view.rstore, regex, function(me, error) {
 105                     view.rstore.stopUpdate();
 106                     PVE.Utils.showCephInstallOrMask(view.ownerCt, error.statusText, view.nodename,
 107                         function(win){
 108                             me.mon(win, 'cephInstallWindowClosed', function(){
 109                                 view.rstore.startUpdate();
 110                             });
 111                         }
 112                     );
 113                 });
 114             }
 115         },
 116
 117         service_cmd: function(rec, cmd) {
 118             var view = this.getView();
 119             if (!rec.data.host) {
 120                 Ext.Msg.alert(gettext('Error'), "entry has no host");
 121                 return;
 122             }
 123             Proxmox.Utils.API2Request({
 124                 url: "/nodes/" + rec.data.host + "/ceph/" + cmd,
 125                 method: 'POST',
 126                 params: { service: view.type + '.' + rec.data.name },
 127                 success: function(response, options) {
 128                     var upid = response.result.data;
 129                     var win = Ext.create('Proxmox.window.TaskProgress', {
 130                         upid: upid,
 131                         taskDone: function() {
 132                             view.rstore.load();
 133                         }
 134                     });
 135                     win.show();
 136                 },
 137                 failure: function(response, opts) {
 138                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 139                 }
 140             });
 141         },
 142         onChangeService: function(btn) {
 143             var me = this;
 144             var view = this.getView();
 145             var cmd = btn.action;
 146             var rec = view.getSelection()[0];
 147             me.service_cmd(rec, cmd);
 148         },
 149
 150         showSyslog: function() {
 151             var view = this.getView();
 152             var rec = view.getSelection()[0];
 153             var servicename = 'ceph-' + view.type + '@' + rec.data.name;
 154             var url = "/api2/extjs/nodes/" + rec.data.host + "/syslog?service=" +  encodeURIComponent(servicename);
 155             var win = Ext.create('Ext.window.Window', {
 156                 title: gettext('Syslog') + ': ' + servicename,
 157                 modal: true,
 158                 width: 800,
 159                 height: 400,
 160                 layout: 'fit',
 161                 items: [{
 162                     xtype: 'proxmoxLogView',
 163                     url: url,
 164                     log_select_timespan: 1
 165                 }]
 166             });
 167             win.show();
 168         },
 169
 170         onCreate: function() {
 171             var view = this.getView();
 172             var win = Ext.create('PVE.CephCreateService', {
 173                 autoShow: true,
 174                 nodename: view.nodename,
 175                 subject: view.getTitle(),
 176                 type: view.type,
 177                 taskDone: function() {
 178                     view.rstore.load();
 179                 }
 180             });
 181         }
 182     },
 183
 184     tbar: [
 185         {
 186             xtype: 'proxmoxButton',
 187             text: gettext('Start'),
 188             iconCls: 'fa fa-play',
 189             action: 'start',
 190             disabled: true,
 191             enableFn: function(rec) {
 192                 return rec.data.state === 'stopped' ||
 193                   rec.data.state === 'unknown';
 194             },
 195             handler: 'onChangeService'
 196         },
 197         {
 198             xtype: 'proxmoxButton',
 199             text: gettext('Stop'),
 200             iconCls: 'fa fa-stop',
 201             action: 'stop',
 202             enableFn: function(rec) {
 203                 return rec.data.state !== 'stopped';
 204             },
 205             disabled: true,
 206             handler: 'onChangeService'
 207         },
 208         {
 209             xtype: 'proxmoxButton',
 210             text: gettext('Restart'),
 211             iconCls: 'fa fa-refresh',
 212             action: 'restart',
 213             disabled: true,
 214             enableFn: function(rec) {
 215                 return rec.data.state !== 'stopped';
 216             },
 217             handler: 'onChangeService'
 218         },
 219         '-',
 220         {
 221             text: gettext('Create'),
 222             reference: 'createButton',
 223             handler: 'onCreate'
 224         },
 225         {
 226             text: gettext('Destroy'),
 227             xtype: 'proxmoxStdRemoveButton',
 228             getUrl: function(rec) {
 229                 var view = this.up('grid');
 230                 if (!rec.data.host) {
 231                     Ext.Msg.alert(gettext('Error'), "entry has no host");
 232                     return;
 233                 }
 234                 return "/nodes/" + rec.data.host + "/ceph/" + view.type + "/" + rec.data.name;
 235             },
 236             callback: function(options, success, response) {
 237                 var view = this.up('grid');
 238                 if (!success) {
 239                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 240                     return;
 241                 }
 242                 var upid = response.result.data;
 243                 var win = Ext.create('Proxmox.window.TaskProgress', {
 244                     upid: upid,
 245                     taskDone: function() {
 246                         view.rstore.load();
 247                     }
 248                 });
 249                 win.show();
 250             }
 251         },
 252         '-',
 253         {
 254             xtype: 'proxmoxButton',
 255             text: gettext('Syslog'),
 256             disabled: true,
 257             handler: 'showSyslog'
 258         }
 259     ],
 260
 261     columns: [
 262         {
 263             header: gettext('Name'),
 264             width: 100,
 265             sortable: true,
 266             renderer: function(v) {
 267                 return this.type + '.' + v;
 268             },
 269             dataIndex: 'name'
 270         },
 271         {
 272             header: gettext('Host'),
 273             width: 100,
 274             sortable: true,
 275             renderer: function(v) {
 276                 return v || Proxmox.Utils.unknownText;
 277             },
 278             dataIndex: 'host'
 279         },
 280         {
 281             header: gettext('Status'),
 282             width: 70,
 283             sortable: false,
 284             dataIndex: 'state'
 285         },
 286         {
 287             header: gettext('Address'),
 288             flex: 1,
 289             sortable: true,
 290             renderer: function(v) {
 291                 return v || Proxmox.Utils.unknownText;
 292             },
 293             dataIndex: 'addr'
 294         },
 295         {
 296             header: gettext('Version'),
 297             flex: 1,
 298             sortable: true,
 299             dataIndex: 'version'
 300         }
 301     ],
 302
 303     initComponent: function() {
 304         var me = this;
 305
 306         if (me.additionalColumns) {
 307             me.columns = me.columns.concat(me.additionalColumns);
 308         }
 309
 310         me.callParent();
 311     }
 312
 313 }, function() {
 314
 315     Ext.define('ceph-service-list', {
 316         extend: 'Ext.data.Model',
 317         fields: [ 'addr', 'name', 'rank', 'host', 'quorum', 'state',
 318             'ceph_version', 'ceph_version_short',
 319             { type: 'string', name: 'version', calculate: function(data) {
 320                 return PVE.Utils.parse_ceph_version(data);
 321             } }
 322         ],
 323         idProperty: 'name'
 324     });
 325 });