mirror of
https://git.proxmox.com/git/pve-manager
synced 2025-06-06 03:05:25 +00:00
fde3e23dcd
The 'autoStart' triggers a initial load already Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>
382 lines
8.7 KiB
JavaScript
382 lines
8.7 KiB
JavaScript
Ext.define('PVE.CephCreateService', {
|
|
extend: 'Proxmox.window.Edit',
|
|
xtype: 'pveCephCreateService',
|
|
|
|
showProgress: true,
|
|
|
|
setNode: function(nodename) {
|
|
var me = this;
|
|
|
|
me.nodename = nodename;
|
|
me.url = "/nodes/" + nodename + "/ceph/" + me.type + "/" + nodename;
|
|
},
|
|
|
|
method: 'POST',
|
|
isCreate: true,
|
|
|
|
items: [
|
|
{
|
|
xtype: 'pveNodeSelector',
|
|
submitValue: false,
|
|
fieldLabel: gettext('Host'),
|
|
selectCurNode: true,
|
|
allowBlank: false,
|
|
listeners: {
|
|
change: function(f, value) {
|
|
var me = this.up('pveCephCreateService');
|
|
me.setNode(value);
|
|
}
|
|
}
|
|
}
|
|
],
|
|
|
|
initComponent : function() {
|
|
var me = this;
|
|
|
|
if (!me.nodename) {
|
|
throw "no node name specified";
|
|
}
|
|
|
|
if (!me.type) {
|
|
throw "no type specified";
|
|
}
|
|
|
|
me.setNode(me.nodename);
|
|
|
|
me.callParent();
|
|
}
|
|
});
|
|
|
|
Ext.define('PVE.node.CephServiceList', {
|
|
extend: 'Ext.grid.GridPanel',
|
|
xtype: 'pveNodeCephServiceList',
|
|
|
|
onlineHelp: 'chapter_pveceph',
|
|
emptyText: gettext('No such service configured.'),
|
|
|
|
stateful: true,
|
|
|
|
// will be called when the store loads
|
|
storeLoadCallback: Ext.emptyFn,
|
|
|
|
// if set to true, does shows the ceph install mask if needed
|
|
showCephInstallMask: false,
|
|
|
|
controller: {
|
|
xclass: 'Ext.app.ViewController',
|
|
|
|
render_version: function(value, metadata, rec) {
|
|
let me = this.getView();
|
|
let host = rec.data.host;
|
|
let icon = "";
|
|
let v = value;
|
|
let nodev = [0];
|
|
if (me.nodeversions[host] !== undefined) {
|
|
nodev = me.nodeversions[host].version.parts;
|
|
}
|
|
let maxv = me.maxversion;
|
|
|
|
if (PVE.Utils.compare_ceph_versions(maxv, nodev) > 0) {
|
|
icon = PVE.Utils.get_ceph_icon_html('HEALTH_UPGRADE');
|
|
} else if (PVE.Utils.compare_ceph_versions(nodev, v) > 0) {
|
|
icon = PVE.Utils.get_ceph_icon_html('HEALTH_OLD');
|
|
} else if (me.mixedversions) {
|
|
icon = PVE.Utils.get_ceph_icon_html('HEALTH_OK');
|
|
}
|
|
|
|
return icon + v;
|
|
},
|
|
|
|
getMaxVersions: function(store, records, success) {
|
|
if (!success || records.length < 1) {
|
|
return;
|
|
}
|
|
let me = this;
|
|
let view = me.getView();
|
|
|
|
view.nodeversions = records[0].data.node;
|
|
view.maxversion = [];
|
|
view.mixedversions = false;
|
|
for (const [nodename, data] of Object.entries(view.nodeversions)) {
|
|
let res = PVE.Utils.compare_ceph_versions(data.version.parts, view.maxversion);
|
|
if (res !== 0 && view.maxversion.length > 0) {
|
|
view.mixedversions = true;
|
|
}
|
|
if (res > 0) {
|
|
view.maxversion = data.version.parts;
|
|
}
|
|
}
|
|
},
|
|
|
|
init: function(view) {
|
|
if (view.pveSelNode) {
|
|
view.nodename = view.pveSelNode.data.node;
|
|
}
|
|
if (!view.nodename) {
|
|
throw "no node name specified";
|
|
}
|
|
|
|
if (!view.type) {
|
|
throw "no type specified";
|
|
}
|
|
|
|
view.versionsstore = Ext.create('Proxmox.data.UpdateStore', {
|
|
autoStart: true,
|
|
interval: 10000,
|
|
storeid: 'ceph-versions-' + view.type + '-list' + view.nodename,
|
|
proxy: {
|
|
type: 'proxmox',
|
|
url: "/api2/json/cluster/ceph/metadata?scope=versions"
|
|
}
|
|
});
|
|
|
|
view.versionsstore.on('load', this.getMaxVersions, this);
|
|
view.on('destroy', view.versionsstore.stopUpdate);
|
|
|
|
view.rstore = Ext.create('Proxmox.data.UpdateStore', {
|
|
autoStart: true,
|
|
interval: 3000,
|
|
storeid: 'ceph-' + view.type + '-list' + view.nodename,
|
|
model: 'ceph-service-list',
|
|
proxy: {
|
|
type: 'proxmox',
|
|
url: "/api2/json/nodes/" + view.nodename + "/ceph/" + view.type
|
|
}
|
|
});
|
|
|
|
view.setStore(Ext.create('Proxmox.data.DiffStore', {
|
|
rstore: view.rstore,
|
|
sorters: [{ property: 'name' }]
|
|
}));
|
|
|
|
if (view.storeLoadCallback) {
|
|
view.rstore.on('load', view.storeLoadCallback, this);
|
|
}
|
|
view.on('destroy', view.rstore.stopUpdate);
|
|
|
|
if (view.showCephInstallMask) {
|
|
var regex = new RegExp("not (installed|initialized)", "i");
|
|
PVE.Utils.handleStoreErrorOrMask(view, view.rstore, regex, function(me, error) {
|
|
view.rstore.stopUpdate();
|
|
PVE.Utils.showCephInstallOrMask(view.ownerCt, error.statusText, view.nodename,
|
|
function(win){
|
|
me.mon(win, 'cephInstallWindowClosed', function(){
|
|
view.rstore.startUpdate();
|
|
});
|
|
}
|
|
);
|
|
});
|
|
}
|
|
},
|
|
|
|
service_cmd: function(rec, cmd) {
|
|
var view = this.getView();
|
|
if (!rec.data.host) {
|
|
Ext.Msg.alert(gettext('Error'), "entry has no host");
|
|
return;
|
|
}
|
|
Proxmox.Utils.API2Request({
|
|
url: "/nodes/" + rec.data.host + "/ceph/" + cmd,
|
|
method: 'POST',
|
|
params: { service: view.type + '.' + rec.data.name },
|
|
success: function(response, options) {
|
|
var upid = response.result.data;
|
|
var win = Ext.create('Proxmox.window.TaskProgress', {
|
|
upid: upid,
|
|
taskDone: function() {
|
|
view.rstore.load();
|
|
}
|
|
});
|
|
win.show();
|
|
},
|
|
failure: function(response, opts) {
|
|
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
|
|
}
|
|
});
|
|
},
|
|
onChangeService: function(btn) {
|
|
var me = this;
|
|
var view = this.getView();
|
|
var cmd = btn.action;
|
|
var rec = view.getSelection()[0];
|
|
me.service_cmd(rec, cmd);
|
|
},
|
|
|
|
showSyslog: function() {
|
|
var view = this.getView();
|
|
var rec = view.getSelection()[0];
|
|
var servicename = 'ceph-' + view.type + '@' + rec.data.name;
|
|
var url = "/api2/extjs/nodes/" + rec.data.host + "/syslog?service=" + encodeURIComponent(servicename);
|
|
var win = Ext.create('Ext.window.Window', {
|
|
title: gettext('Syslog') + ': ' + servicename,
|
|
modal: true,
|
|
width: 800,
|
|
height: 400,
|
|
layout: 'fit',
|
|
items: [{
|
|
xtype: 'proxmoxLogView',
|
|
url: url,
|
|
log_select_timespan: 1
|
|
}]
|
|
});
|
|
win.show();
|
|
},
|
|
|
|
onCreate: function() {
|
|
var view = this.getView();
|
|
var win = Ext.create('PVE.CephCreateService', {
|
|
autoShow: true,
|
|
nodename: view.nodename,
|
|
subject: view.getTitle(),
|
|
type: view.type,
|
|
taskDone: function() {
|
|
view.rstore.load();
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
tbar: [
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Start'),
|
|
iconCls: 'fa fa-play',
|
|
action: 'start',
|
|
disabled: true,
|
|
enableFn: function(rec) {
|
|
return rec.data.state === 'stopped' ||
|
|
rec.data.state === 'unknown';
|
|
},
|
|
handler: 'onChangeService'
|
|
},
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Stop'),
|
|
iconCls: 'fa fa-stop',
|
|
action: 'stop',
|
|
enableFn: function(rec) {
|
|
return rec.data.state !== 'stopped';
|
|
},
|
|
disabled: true,
|
|
handler: 'onChangeService'
|
|
},
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Restart'),
|
|
iconCls: 'fa fa-refresh',
|
|
action: 'restart',
|
|
disabled: true,
|
|
enableFn: function(rec) {
|
|
return rec.data.state !== 'stopped';
|
|
},
|
|
handler: 'onChangeService'
|
|
},
|
|
'-',
|
|
{
|
|
text: gettext('Create'),
|
|
reference: 'createButton',
|
|
handler: 'onCreate'
|
|
},
|
|
{
|
|
text: gettext('Destroy'),
|
|
xtype: 'proxmoxStdRemoveButton',
|
|
getUrl: function(rec) {
|
|
var view = this.up('grid');
|
|
if (!rec.data.host) {
|
|
Ext.Msg.alert(gettext('Error'), "entry has no host");
|
|
return;
|
|
}
|
|
return "/nodes/" + rec.data.host + "/ceph/" + view.type + "/" + rec.data.name;
|
|
},
|
|
callback: function(options, success, response) {
|
|
var view = this.up('grid');
|
|
if (!success) {
|
|
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
|
|
return;
|
|
}
|
|
var upid = response.result.data;
|
|
var win = Ext.create('Proxmox.window.TaskProgress', {
|
|
upid: upid,
|
|
taskDone: function() {
|
|
view.rstore.load();
|
|
}
|
|
});
|
|
win.show();
|
|
}
|
|
},
|
|
'-',
|
|
{
|
|
xtype: 'proxmoxButton',
|
|
text: gettext('Syslog'),
|
|
disabled: true,
|
|
handler: 'showSyslog'
|
|
}
|
|
],
|
|
|
|
columns: [
|
|
{
|
|
header: gettext('Name'),
|
|
flex: 1,
|
|
sortable: true,
|
|
renderer: function(v) {
|
|
return this.type + '.' + v;
|
|
},
|
|
dataIndex: 'name'
|
|
},
|
|
{
|
|
header: gettext('Host'),
|
|
flex: 1,
|
|
sortable: true,
|
|
renderer: function(v) {
|
|
return v || Proxmox.Utils.unknownText;
|
|
},
|
|
dataIndex: 'host'
|
|
},
|
|
{
|
|
header: gettext('Status'),
|
|
flex: 1,
|
|
sortable: false,
|
|
dataIndex: 'state'
|
|
},
|
|
{
|
|
header: gettext('Address'),
|
|
flex: 3,
|
|
sortable: true,
|
|
renderer: function(v) {
|
|
return v || Proxmox.Utils.unknownText;
|
|
},
|
|
dataIndex: 'addr'
|
|
},
|
|
{
|
|
header: gettext('Version'),
|
|
flex: 3,
|
|
sortable: true,
|
|
dataIndex: 'version',
|
|
renderer: 'render_version',
|
|
}
|
|
],
|
|
|
|
initComponent: function() {
|
|
var me = this;
|
|
|
|
if (me.additionalColumns) {
|
|
me.columns = me.columns.concat(me.additionalColumns);
|
|
}
|
|
|
|
me.callParent();
|
|
}
|
|
|
|
}, function() {
|
|
|
|
Ext.define('ceph-service-list', {
|
|
extend: 'Ext.data.Model',
|
|
fields: [ 'addr', 'name', 'rank', 'host', 'quorum', 'state',
|
|
'ceph_version', 'ceph_version_short',
|
|
{ type: 'string', name: 'version', calculate: function(data) {
|
|
return PVE.Utils.parse_ceph_version(data);
|
|
} }
|
|
],
|
|
idProperty: 'name'
|
|
});
|
|
});
|