[pve-manager.git] / www / manager6 / ceph / CephInstallWizard.js

Ext.define('PVE.ceph.CephInstallWizardInfo', {
    extend: 'Ext.panel.Panel',
    xtype: 'pveCephInstallWizardInfo',

    html: `<h3>Ceph?</h3>
    <blockquote cite="https://ceph.com/"><p>"<b>Ceph</b> is a unified,
    distributed storage system, designed for excellent performance, reliability,
    and scalability."</p></blockquote>
    <p>
    <b>Ceph</b> is currently <b>not installed</b> on this node. This wizard
    will guide you through the installation. Click on the next button below
    to begin. After the initial installation, the wizard will offer to create
    an initial configuration. This configuration step is only
    needed once per cluster and will be skipped if a config is already present.
    </p>
    <p>
    Before starting the installation, please take a look at our documentation,
    by clicking the help button below. If you want to gain deeper knowledge about
    Ceph, visit <a target="_blank" href="https://docs.ceph.com/en/latest/">ceph.com</a>.
    </p>`,
});

Ext.define('PVE.ceph.CephVersionSelector', {
    extend: 'Ext.form.field.ComboBox',
    xtype: 'pveCephVersionSelector',

    fieldLabel: gettext('Ceph version to install'),

    displayField: 'display',
    valueField: 'release',

    queryMode: 'local',
    editable: false,
    forceSelection: true,

    store: {
	fields: [
	    'release',
	    'version',
	    {
		name: 'display',
		calculate: d => `${d.release} (${d.version})`,
	    },
	],
	proxy: {
	    type: 'memory',
	    reader: {
		type: 'json',
	    },
	},
	data: [
	    { release: "octopus", version: "15.2" },
	    { release: "pacific", version: "16.2" },
	],
    },
});

Ext.define('PVE.ceph.CephHighestVersionDisplay', {
    extend: 'Ext.form.field.Display',
    xtype: 'pveCephHighestVersionDisplay',

    fieldLabel: gettext('Ceph in the cluster'),

    value: 'unknown',

    // called on success with (release, versionTxt, versionParts)
    gotNewestVersion: Ext.emptyFn,

    initComponent: function() {
	let me = this;

	me.callParent(arguments);

	Proxmox.Utils.API2Request({
	    method: 'GET',
	    url: '/cluster/ceph/metadata',
	    params: {
		scope: 'versions',
	    },
	    waitMsgTarget: me,
	    success: (response) => {
		let res = response.result;
		if (!res || !res.data || !res.data.node) {
		    me.setValue(
			gettext('Could not detect a ceph installation in the cluster'),
		    );
		    return;
		}
		let nodes = res.data.node;
		if (me.nodename) {
		    // can happen on ceph purge, we do not yet cleanup old version data
		    delete nodes[me.nodename];
		}

		let maxversion = [];
		let maxversiontext = "";
		for (const [_nodename, data] of Object.entries(nodes)) {
		    let version = data.version.parts;
		    if (PVE.Utils.compare_ceph_versions(version, maxversion) > 0) {
			maxversion = version;
			maxversiontext = data.version.str;
		    }
		}
		// FIXME: get from version selector store
		const major2release = {
		    13: 'luminous',
		    14: 'nautilus',
		    15: 'octopus',
		    16: 'pacific',
		};
		let release = major2release[maxversion[0]] || 'unknown';
		let newestVersionTxt = `${Ext.String.capitalize(release)} (${maxversiontext})`;

		if (release === 'unknown') {
		    me.setValue(
			gettext('Could not detect a ceph installation in the cluster'),
		    );
		} else {
		    me.setValue(Ext.String.format(
			gettext('Newest ceph version in cluster is {0}'),
			newestVersionTxt,
		    ));
		}
		me.gotNewestVersion(release, maxversiontext, maxversion);
	    },
	    failure: function(response, opts) {
		Ext.Msg.alert(gettext('Error'), response.htmlStatus);
	    },
	});
    },
});

Ext.define('PVE.ceph.CephInstallWizard', {
    extend: 'PVE.window.Wizard',
    alias: 'widget.pveCephInstallWizard',
    mixins: ['Proxmox.Mixin.CBind'],

    resizable: false,
    nodename: undefined,

    viewModel: {
	data: {
	    nodename: '',
	    cephRelease: 'pacific',
	    configuration: true,
	    isInstalled: false,
	},
    },
    cbindData: {
	nodename: undefined,
    },

    title: gettext('Setup'),
    navigateNext: function() {
	var tp = this.down('#wizcontent');
	var atab = tp.getActiveTab();

	var next = tp.items.indexOf(atab) + 1;
	var ntab = tp.items.getAt(next);
	if (ntab) {
	    ntab.enable();
	    tp.setActiveTab(ntab);
	}
    },
    setInitialTab: function(index) {
	var tp = this.down('#wizcontent');
	var initialTab = tp.items.getAt(index);
	initialTab.enable();
	tp.setActiveTab(initialTab);
    },
    onShow: function() {
	    this.callParent(arguments);
	    var isInstalled = this.getViewModel().get('isInstalled');
	    if (isInstalled) {
		this.getViewModel().set('configuration', false);
		this.setInitialTab(2);
	    }
    },
    items: [
	{
	    xtype: 'panel',
	    title: gettext('Info'),
	    viewModel: {}, // needed to inherit parent viewModel data
	    border: false,
	    bodyBorder: false,
	    onlineHelp: 'chapter_pveceph',
	    layout: {
		type: 'vbox',
		align: 'stretch',
	    },
	    defaults: {
		border: false,
		bodyBorder: false,
	    },
	    items: [
		{
		    xtype: 'pveCephInstallWizardInfo',
		},
		{
		    flex: 1,
		},
		{
		    xtype: 'pveCephHighestVersionDisplay',
		    labelWidth: 180,
		    cbind: {
			nodename: '{nodename}',
		    },
		    gotNewestVersion: function(release, maxversiontext, maxversion) {
			if (release === 'unknown') {
			    return;
			}
			let wizard = this.up('pveCephInstallWizard');
			wizard.getViewModel().set('cephRelease', release);
		    },
		},
		{
		    xtype: 'pveCephVersionSelector',
		    labelWidth: 180,
		    submitValue: false,
		    bind: {
			value: '{cephRelease}',
		    },
		    listeners: {
			change: function(field, release) {
			    let wizard = this.up('pveCephInstallWizard');
			    wizard.down('#next').setText(
				Ext.String.format(gettext('Start {0} installation'), release),
			    );
			},
		    },
		},
	    ],
	    listeners: {
		activate: function() {
		    // notify owning container that it should display a help button
		    if (this.onlineHelp) {
			Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
		    }
		    let wizard = this.up('pveCephInstallWizard');
		    let release = wizard.getViewModel().get('cephRelease');
		    wizard.down('#back').hide(true);
		    wizard.down('#next').setText(
			Ext.String.format(gettext('Start {0} installation'), release),
		    );
		},
		deactivate: function() {
		    if (this.onlineHelp) {
			Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
		    }
		    this.up('pveCephInstallWizard').down('#next').setText(gettext('Next'));
		},
	    },
	},
	{
	    title: gettext('Installation'),
	    xtype: 'panel',
	    layout: 'fit',
	    cbind: {
		nodename: '{nodename}',
	    },
	    viewModel: {}, // needed to inherit parent viewModel data
	    listeners: {
		afterrender: function() {
		    var me = this;
		    if (this.getViewModel().get('isInstalled')) {
			this.mask("Ceph is already installed, click next to create your configuration.", ['pve-static-mask']);
		    } else {
			me.down('pveNoVncConsole').fireEvent('activate');
		    }
		},
		activate: function() {
		    let me = this;
		    const nodename = me.nodename;
		    me.updateStore = Ext.create('Proxmox.data.UpdateStore', {
			storeid: 'ceph-status-' + nodename,
			interval: 1000,
			proxy: {
			    type: 'proxmox',
			    url: '/api2/json/nodes/' + nodename + '/ceph/status',
			},
			listeners: {
			    load: function(rec, response, success, operation) {
				if (success) {
				    me.updateStore.stopUpdate();
				    me.down('textfield').setValue('success');
				} else if (operation.error.statusText.match("not initialized", "i")) {
				    me.updateStore.stopUpdate();
				    me.up('pveCephInstallWizard').getViewModel().set('configuration', false);
				    me.down('textfield').setValue('success');
				} else if (operation.error.statusText.match("rados_connect failed", "i")) {
				    me.updateStore.stopUpdate();
				    me.up('pveCephInstallWizard').getViewModel().set('configuration', true);
				    me.down('textfield').setValue('success');
				} else if (!operation.error.statusText.match("not installed", "i")) {
				    Proxmox.Utils.setErrorMask(me, operation.error.statusText);
				}
			    },
			},
		    });
		    me.updateStore.startUpdate();
		},
		destroy: function() {
		    var me = this;
		    if (me.updateStore) {
			me.updateStore.stopUpdate();
		    }
		},
	    },
	    items: [
		{
		    xtype: 'pveNoVncConsole',
		    itemId: 'jsconsole',
		    consoleType: 'cmd',
		    xtermjs: true,
		    cbind: {
			nodename: '{nodename}',
		    },
		    beforeLoad: function() {
			let me = this;
			let wizard = me.up('pveCephInstallWizard');
			let release = wizard.getViewModel().get('cephRelease');
			me.cmdOpts = `--version\0${release}`;
		    },
		    cmd: 'ceph_install',
		},
		{
		    xtype: 'textfield',
		    name: 'installSuccess',
		    value: '',
		    allowBlank: false,
		    submitValue: false,
		    hidden: true,
		},
	    ],
	},
	{
	    xtype: 'inputpanel',
	    title: gettext('Configuration'),
	    onlineHelp: 'chapter_pveceph',
	    cbind: {
		nodename: '{nodename}',
	    },
	    viewModel: {
		data: {
		    replicas: undefined,
		    minreplicas: undefined,
		},
	    },
	    listeners: {
		activate: function() {
		    this.up('pveCephInstallWizard').down('#submit').setText(gettext('Next'));
		},
		beforeshow: function() {
		    if (this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
			this.mask("Configuration already initialized", ['pve-static-mask']);
		    } else {
			this.unmask();
		    }
		},
		deactivate: function() {
		    this.up('pveCephInstallWizard').down('#submit').setText(gettext('Finish'));
		},
	    },
	    column1: [
		{
		    xtype: 'displayfield',
		    value: gettext('Ceph cluster configuration') + ':',
		},
		{
		    xtype: 'proxmoxNetworkSelector',
		    name: 'network',
		    value: '',
		    fieldLabel: 'Public Network IP/CIDR',
		    bind: {
			allowBlank: '{configuration}',
		    },
		    cbind: {
			nodename: '{nodename}',
		    },
		},
		{
		    xtype: 'proxmoxNetworkSelector',
		    name: 'cluster-network',
		    fieldLabel: 'Cluster Network IP/CIDR',
		    allowBlank: true,
		    autoSelect: false,
		    emptyText: gettext('Same as Public Network'),
		    cbind: {
			nodename: '{nodename}',
		    },
		},
		// FIXME: add hint about cluster network and/or reference user to docs??
	    ],
	    column2: [
		{
		    xtype: 'displayfield',
		    value: gettext('First Ceph monitor') + ':',
		},
		{
		    xtype: 'pveNodeSelector',
		    fieldLabel: gettext('Monitor node'),
		    name: 'mon-node',
		    selectCurNode: true,
		    allowBlank: false,
		},
		{
		    xtype: 'displayfield',
		    value: gettext('Additional monitors are recommended. They can be created at any time in the Monitor tab.'),
		    userCls: 'pmx-hint',
		},
	    ],
	    advancedColumn1: [
		{
		    xtype: 'numberfield',
		    name: 'size',
		    fieldLabel: 'Number of replicas',
		    bind: {
			value: '{replicas}',
		    },
		    maxValue: 7,
		    minValue: 2,
		    emptyText: '3',
		},
		{
		    xtype: 'numberfield',
		    name: 'min_size',
		    fieldLabel: 'Minimum replicas',
		    bind: {
			maxValue: '{replicas}',
			value: '{minreplicas}',
		    },
		    minValue: 2,
		    maxValue: 3,
		    setMaxValue: function(value) {
			this.maxValue = Ext.Number.from(value, 2);
			// allow enough to avoid split brains with max 'size', but more makes simply no sense
			if (this.maxValue > 4) {
			    this.maxValue = 4;
			}
			this.toggleSpinners();
			this.validate();
		    },
		    emptyText: '2',
		},
	    ],
	    onGetValues: function(values) {
		['cluster-network', 'size', 'min_size'].forEach(function(field) {
		    if (!values[field]) {
			delete values[field];
		    }
		});
		return values;
	    },
	    onSubmit: function() {
		var me = this;
		if (!this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
		    var wizard = me.up('window');
		    var kv = wizard.getValues();
		    delete kv.delete;
		    var monNode = kv['mon-node'];
		    delete kv['mon-node'];
		    var nodename = me.nodename;
		    delete kv.nodename;
		    Proxmox.Utils.API2Request({
			url: `/nodes/${nodename}/ceph/init`,
			waitMsgTarget: wizard,
			method: 'POST',
			params: kv,
			success: function() {
			    Proxmox.Utils.API2Request({
				url: `/nodes/${monNode}/ceph/mon/${monNode}`,
				waitMsgTarget: wizard,
				method: 'POST',
				success: function() {
				    me.up('pveCephInstallWizard').navigateNext();
				},
				failure: function(response, opts) {
				    Ext.Msg.alert(gettext('Error'), response.htmlStatus);
				},
			    });
			},
			failure: function(response, opts) {
			    Ext.Msg.alert(gettext('Error'), response.htmlStatus);
			},
		    });
		} else {
		    me.up('pveCephInstallWizard').navigateNext();
		}
	    },
	},
	{
	    title: gettext('Success'),
	    xtype: 'panel',
	    border: false,
	    bodyBorder: false,
	    onlineHelp: 'pve_ceph_install',
	    html: '<h3>Installation successful!</h3>'+
	    '<p>The basic installation and configuration is complete. Depending on your setup, some of the following steps are required to start using Ceph:</p>'+
		'<ol><li>Install Ceph on other nodes</li>'+
		'<li>Create additional Ceph Monitors</li>'+
		'<li>Create Ceph OSDs</li>'+
		'<li>Create Ceph Pools</li></ol>'+
	    '<p>To learn more, click on the help button below.</p>',
	    listeners: {
		activate: function() {
		    // notify owning container that it should display a help button
		    if (this.onlineHelp) {
			Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
		    }

		    var tp = this.up('#wizcontent');
		    var idx = tp.items.indexOf(this)-1;
		    for (;idx >= 0; idx--) {
			var nc = tp.items.getAt(idx);
			if (nc) {
			    nc.disable();
			}
		    }
		},
		deactivate: function() {
		    if (this.onlineHelp) {
			Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
		    }
		},
	    },
	    onSubmit: function() {
		var wizard = this.up('pveCephInstallWizard');
		wizard.close();
	    },
	},
    ],
});
Commit	Line	Data
37e75d86 TL	1	Ext.define('PVE.ceph.CephInstallWizardInfo', {
	2	extend: 'Ext.panel.Panel',
	3	xtype: 'pveCephInstallWizardInfo',
	4
	5	html: `<h3>Ceph?</h3>
	6	<blockquote cite="https://ceph.com/"><p>"<b>Ceph</b> is a unified,
f00da0a5	7	distributed storage system, designed for excellent performance, reliability,
37e75d86 TL	8	and scalability."</p></blockquote>
37e75d86 TL	9	<p>
f00da0a5 DW	10	<b>Ceph</b> is currently <b>not installed</b> on this node. This wizard
	11	will guide you through the installation. Click on the next button below
	12	to begin. After the initial installation, the wizard will offer to create
	13	an initial configuration. This configuration step is only
37e75d86 TL	14	needed once per cluster and will be skipped if a config is already present.
	15	</p>
	16	<p>
f00da0a5 DW	17	Before starting the installation, please take a look at our documentation,
	18	by clicking the help button below. If you want to gain deeper knowledge about
	19	Ceph, visit <a target="_blank" href="https://docs.ceph.com/en/latest/">ceph.com</a>.
37e75d86 TL	20	</p>`,
	21	});
	22
c3035c01 TL	23	Ext.define('PVE.ceph.CephVersionSelector', {
	24	extend: 'Ext.form.field.ComboBox',
	25	xtype: 'pveCephVersionSelector',
	26
	27	fieldLabel: gettext('Ceph version to install'),
	28
	29	displayField: 'display',
	30	valueField: 'release',
	31
	32	queryMode: 'local',
	33	editable: false,
	34	forceSelection: true,
	35
	36	store: {
	37	fields: [
	38	'release',
	39	'version',
	40	{
	41	name: 'display',
	42	calculate: d => `${d.release} (${d.version})`,
	43	},
	44	],
	45	proxy: {
	46	type: 'memory',
	47	reader: {
	48	type: 'json',
	49	},
	50	},
	51	data: [
8058410f	52	{ release: "octopus", version: "15.2" },
00fa70bf	53	{ release: "pacific", version: "16.2" },
c3035c01 TL	54	],
	55	},
	56	});
	57
	58	Ext.define('PVE.ceph.CephHighestVersionDisplay', {
	59	extend: 'Ext.form.field.Display',
	60	xtype: 'pveCephHighestVersionDisplay',
	61
	62	fieldLabel: gettext('Ceph in the cluster'),
	63
	64	value: 'unknown',
	65
	66	// called on success with (release, versionTxt, versionParts)
	67	gotNewestVersion: Ext.emptyFn,
	68
	69	initComponent: function() {
	70	let me = this;
	71
	72	me.callParent(arguments);
	73
	74	Proxmox.Utils.API2Request({
	75	method: 'GET',
	76	url: '/cluster/ceph/metadata',
	77	params: {
	78	scope: 'versions',
	79	},
	80	waitMsgTarget: me,
	81	success: (response) => {
	82	let res = response.result;
	83	if (!res \|\| !res.data \|\| !res.data.node) {
	84	me.setValue(
	85	gettext('Could not detect a ceph installation in the cluster'),
	86	);
	87	return;
	88	}
	89	let nodes = res.data.node;
	90	if (me.nodename) {
	91	// can happen on ceph purge, we do not yet cleanup old version data
	92	delete nodes[me.nodename];
	93	}
	94
	95	let maxversion = [];
	96	let maxversiontext = "";
436f638d	97	for (const [_nodename, data] of Object.entries(nodes)) {
c3035c01 TL	98	let version = data.version.parts;
	99	if (PVE.Utils.compare_ceph_versions(version, maxversion) > 0) {
	100	maxversion = version;
	101	maxversiontext = data.version.str;
	102	}
	103	}
	104	// FIXME: get from version selector store
	105	const major2release = {
	106	13: 'luminous',
	107	14: 'nautilus',
	108	15: 'octopus',
	109	16: 'pacific',
	110	};
	111	let release = major2release[maxversion[0]] \|\| 'unknown';
	112	let newestVersionTxt = `${Ext.String.capitalize(release)} (${maxversiontext})`;
	113
	114	if (release === 'unknown') {
	115	me.setValue(
	116	gettext('Could not detect a ceph installation in the cluster'),
	117	);
	118	} else {
	119	me.setValue(Ext.String.format(
	120	gettext('Newest ceph version in cluster is {0}'),
	121	newestVersionTxt,
	122	));
	123	}
	124	me.gotNewestVersion(release, maxversiontext, maxversion);
	125	},
	126	failure: function(response, opts) {
	127	Ext.Msg.alert(gettext('Error'), response.htmlStatus);
f6710aac	128	},
c3035c01 TL	129	});
	130	},
	131	});
	132
4616a55b	133	Ext.define('PVE.ceph.CephInstallWizard', {
80fdf8d2 TL	134	extend: 'PVE.window.Wizard',
	135	alias: 'widget.pveCephInstallWizard',
	136	mixins: ['Proxmox.Mixin.CBind'],
37e75d86	137
80fdf8d2 TL	138	resizable: false,
80fdf8d2 TL	139	nodename: undefined,
37e75d86	140
80fdf8d2 TL	141	viewModel: {
	142	data: {
	143	nodename: '',
2e061d81	144	cephRelease: 'pacific',
80fdf8d2 TL	145	configuration: true,
80fdf8d2 TL	146	isInstalled: false,
f6710aac	147	},
80fdf8d2 TL	148	},
80fdf8d2 TL	149	cbindData: {
f6710aac	150	nodename: undefined,
80fdf8d2	151	},
37e75d86	152
80fdf8d2 TL	153	title: gettext('Setup'),
	154	navigateNext: function() {
	155	var tp = this.down('#wizcontent');
	156	var atab = tp.getActiveTab();
8ba2d669	157
80fdf8d2 TL	158	var next = tp.items.indexOf(atab) + 1;
	159	var ntab = tp.items.getAt(next);
	160	if (ntab) {
	161	ntab.enable();
	162	tp.setActiveTab(ntab);
	163	}
	164	},
8058410f	165	setInitialTab: function(index) {
80fdf8d2 TL	166	var tp = this.down('#wizcontent');
	167	var initialTab = tp.items.getAt(index);
	168	initialTab.enable();
	169	tp.setActiveTab(initialTab);
	170	},
	171	onShow: function() {
	172	this.callParent(arguments);
	173	var isInstalled = this.getViewModel().get('isInstalled');
	174	if (isInstalled) {
	175	this.getViewModel().set('configuration', false);
	176	this.setInitialTab(2);
8ba2d669	177	}
80fdf8d2 TL	178	},
	179	items: [
	180	{
	181	xtype: 'panel',
	182	title: gettext('Info'),
	183	viewModel: {}, // needed to inherit parent viewModel data
	184	border: false,
	185	bodyBorder: false,
	186	onlineHelp: 'chapter_pveceph',
	187	layout: {
	188	type: 'vbox',
	189	align: 'stretch',
	190	},
	191	defaults: {
4616a55b TM	192	border: false,
4616a55b TM	193	bodyBorder: false,
80fdf8d2 TL	194	},
	195	items: [
	196	{
	197	xtype: 'pveCephInstallWizardInfo',
37e75d86	198	},
80fdf8d2 TL	199	{
80fdf8d2 TL	200	flex: 1,
37e75d86	201	},
80fdf8d2 TL	202	{
	203	xtype: 'pveCephHighestVersionDisplay',
	204	labelWidth: 180,
8058410f	205	cbind: {
f6710aac	206	nodename: '{nodename}',
37e75d86	207	},
80fdf8d2 TL	208	gotNewestVersion: function(release, maxversiontext, maxversion) {
	209	if (release === 'unknown') {
	210	return;
	211	}
	212	let wizard = this.up('pveCephInstallWizard');
	213	wizard.getViewModel().set('cephRelease', release);
c3035c01	214	},
80fdf8d2 TL	215	},
	216	{
	217	xtype: 'pveCephVersionSelector',
	218	labelWidth: 180,
	219	submitValue: false,
	220	bind: {
	221	value: '{cephRelease}',
	222	},
	223	listeners: {
	224	change: function(field, release) {
c3035c01	225	let wizard = this.up('pveCephInstallWizard');
80fdf8d2 TL	226	wizard.down('#next').setText(
	227	Ext.String.format(gettext('Start {0} installation'), release),
	228	);
c3035c01 TL	229	},
c3035c01 TL	230	},
80fdf8d2 TL	231	},
	232	],
	233	listeners: {
	234	activate: function() {
	235	// notify owning container that it should display a help button
	236	if (this.onlineHelp) {
	237	Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
	238	}
	239	let wizard = this.up('pveCephInstallWizard');
	240	let release = wizard.getViewModel().get('cephRelease');
	241	wizard.down('#back').hide(true);
	242	wizard.down('#next').setText(
	243	Ext.String.format(gettext('Start {0} installation'), release),
	244	);
	245	},
	246	deactivate: function() {
	247	if (this.onlineHelp) {
	248	Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
	249	}
	250	this.up('pveCephInstallWizard').down('#next').setText(gettext('Next'));
f6710aac TL	251	},
f6710aac TL	252	},
80fdf8d2 TL	253	},
	254	{
	255	title: gettext('Installation'),
	256	xtype: 'panel',
	257	layout: 'fit',
8058410f	258	cbind: {
f6710aac	259	nodename: '{nodename}',
80fdf8d2 TL	260	},
	261	viewModel: {}, // needed to inherit parent viewModel data
	262	listeners: {
	263	afterrender: function() {
	264	var me = this;
	265	if (this.getViewModel().get('isInstalled')) {
f6710aac	266	this.mask("Ceph is already installed, click next to create your configuration.", ['pve-static-mask']);
80fdf8d2 TL	267	} else {
	268	me.down('pveNoVncConsole').fireEvent('activate');
	269	}
	270	},
	271	activate: function() {
	272	let me = this;
	273	const nodename = me.nodename;
	274	me.updateStore = Ext.create('Proxmox.data.UpdateStore', {
	275	storeid: 'ceph-status-' + nodename,
	276	interval: 1000,
	277	proxy: {
	278	type: 'proxmox',
f6710aac	279	url: '/api2/json/nodes/' + nodename + '/ceph/status',
c3035c01 TL	280	},
c3035c01 TL	281	listeners: {
80fdf8d2	282	load: function(rec, response, success, operation) {
80fdf8d2 TL	283	if (success) {
	284	me.updateStore.stopUpdate();
	285	me.down('textfield').setValue('success');
	286	} else if (operation.error.statusText.match("not initialized", "i")) {
	287	me.updateStore.stopUpdate();
f6710aac	288	me.up('pveCephInstallWizard').getViewModel().set('configuration', false);
80fdf8d2 TL	289	me.down('textfield').setValue('success');
	290	} else if (operation.error.statusText.match("rados_connect failed", "i")) {
	291	me.updateStore.stopUpdate();
f6710aac	292	me.up('pveCephInstallWizard').getViewModel().set('configuration', true);
80fdf8d2 TL	293	me.down('textfield').setValue('success');
	294	} else if (!operation.error.statusText.match("not installed", "i")) {
	295	Proxmox.Utils.setErrorMask(me, operation.error.statusText);
	296	}
f6710aac TL	297	},
f6710aac TL	298	},
80fdf8d2 TL	299	});
	300	me.updateStore.startUpdate();
	301	},
	302	destroy: function() {
	303	var me = this;
	304	if (me.updateStore) {
	305	me.updateStore.stopUpdate();
4616a55b	306	}
f6710aac	307	},
4616a55b	308	},
80fdf8d2 TL	309	items: [
	310	{
	311	xtype: 'pveNoVncConsole',
	312	itemId: 'jsconsole',
	313	consoleType: 'cmd',
	314	xtermjs: true,
	315	cbind: {
	316	nodename: '{nodename}',
4616a55b	317	},
80fdf8d2	318	beforeLoad: function() {
c3035c01	319	let me = this;
80fdf8d2 TL	320	let wizard = me.up('pveCephInstallWizard');
	321	let release = wizard.getViewModel().get('cephRelease');
	322	me.cmdOpts = `--version\0${release}`;
4616a55b	323	},
80fdf8d2	324	cmd: 'ceph_install',
4616a55b	325	},
80fdf8d2 TL	326	{
	327	xtype: 'textfield',
	328	name: 'installSuccess',
	329	value: '',
	330	allowBlank: false,
	331	submitValue: false,
f6710aac TL	332	hidden: true,
	333	},
	334	],
80fdf8d2 TL	335	},
	336	{
	337	xtype: 'inputpanel',
	338	title: gettext('Configuration'),
	339	onlineHelp: 'chapter_pveceph',
	340	cbind: {
f6710aac	341	nodename: '{nodename}',
4616a55b	342	},
80fdf8d2 TL	343	viewModel: {
	344	data: {
	345	replicas: undefined,
f6710aac TL	346	minreplicas: undefined,
f6710aac TL	347	},
80fdf8d2 TL	348	},
	349	listeners: {
	350	activate: function() {
	351	this.up('pveCephInstallWizard').down('#submit').setText(gettext('Next'));
4616a55b	352	},
80fdf8d2 TL	353	beforeshow: function() {
80fdf8d2 TL	354	if (this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
f6710aac	355	this.mask("Configuration already initialized", ['pve-static-mask']);
80fdf8d2 TL	356	} else {
80fdf8d2 TL	357	this.unmask();
836d66f7 TM	358	}
836d66f7 TM	359	},
80fdf8d2 TL	360	deactivate: function() {
80fdf8d2 TL	361	this.up('pveCephInstallWizard').down('#submit').setText(gettext('Finish'));
f6710aac	362	},
80fdf8d2 TL	363	},
	364	column1: [
	365	{
	366	xtype: 'displayfield',
f6710aac	367	value: gettext('Ceph cluster configuration') + ':',
80fdf8d2 TL	368	},
	369	{
	370	xtype: 'proxmoxNetworkSelector',
	371	name: 'network',
	372	value: '',
	373	fieldLabel: 'Public Network IP/CIDR',
	374	bind: {
f6710aac	375	allowBlank: '{configuration}',
8ba2d669	376	},
80fdf8d2	377	cbind: {
f6710aac TL	378	nodename: '{nodename}',
f6710aac TL	379	},
4616a55b	380	},
80fdf8d2 TL	381	{
	382	xtype: 'proxmoxNetworkSelector',
	383	name: 'cluster-network',
	384	fieldLabel: 'Cluster Network IP/CIDR',
	385	allowBlank: true,
	386	autoSelect: false,
	387	emptyText: gettext('Same as Public Network'),
	388	cbind: {
f6710aac TL	389	nodename: '{nodename}',
	390	},
	391	},
80fdf8d2 TL	392	// FIXME: add hint about cluster network and/or reference user to docs??
	393	],
	394	column2: [
	395	{
	396	xtype: 'displayfield',
f6710aac	397	value: gettext('First Ceph monitor') + ':',
80fdf8d2 TL	398	},
	399	{
	400	xtype: 'pveNodeSelector',
	401	fieldLabel: gettext('Monitor node'),
	402	name: 'mon-node',
	403	selectCurNode: true,
f6710aac	404	allowBlank: false,
80fdf8d2 TL	405	},
	406	{
	407	xtype: 'displayfield',
	408	value: gettext('Additional monitors are recommended. They can be created at any time in the Monitor tab.'),
f6710aac TL	409	userCls: 'pmx-hint',
f6710aac TL	410	},
80fdf8d2 TL	411	],
	412	advancedColumn1: [
	413	{
	414	xtype: 'numberfield',
	415	name: 'size',
	416	fieldLabel: 'Number of replicas',
	417	bind: {
f6710aac	418	value: '{replicas}',
4616a55b	419	},
80fdf8d2 TL	420	maxValue: 7,
80fdf8d2 TL	421	minValue: 2,
f6710aac	422	emptyText: '3',
80fdf8d2 TL	423	},
	424	{
	425	xtype: 'numberfield',
	426	name: 'min_size',
	427	fieldLabel: 'Minimum replicas',
	428	bind: {
	429	maxValue: '{replicas}',
f6710aac	430	value: '{minreplicas}',
4616a55b	431	},
80fdf8d2 TL	432	minValue: 2,
	433	maxValue: 3,
	434	setMaxValue: function(value) {
	435	this.maxValue = Ext.Number.from(value, 2);
	436	// allow enough to avoid split brains with max 'size', but more makes simply no sense
	437	if (this.maxValue > 4) {
	438	this.maxValue = 4;
a19aa238	439	}
80fdf8d2 TL	440	this.toggleSpinners();
80fdf8d2 TL	441	this.validate();
71798b4b	442	},
f6710aac TL	443	emptyText: '2',
f6710aac TL	444	},
80fdf8d2 TL	445	],
	446	onGetValues: function(values) {
	447	['cluster-network', 'size', 'min_size'].forEach(function(field) {
	448	if (!values[field]) {
	449	delete values[field];
8ba2d669	450	}
80fdf8d2 TL	451	});
	452	return values;
	453	},
	454	onSubmit: function() {
	455	var me = this;
	456	if (!this.up('pveCephInstallWizard').getViewModel().get('configuration')) {
	457	var wizard = me.up('window');
	458	var kv = wizard.getValues();
399ffa76	459	delete kv.delete;
80fdf8d2 TL	460	var monNode = kv['mon-node'];
	461	delete kv['mon-node'];
	462	var nodename = me.nodename;
	463	delete kv.nodename;
	464	Proxmox.Utils.API2Request({
f8b7b9e1	465	url: `/nodes/${nodename}/ceph/init`,
80fdf8d2 TL	466	waitMsgTarget: wizard,
	467	method: 'POST',
	468	params: kv,
	469	success: function() {
	470	Proxmox.Utils.API2Request({
f8b7b9e1	471	url: `/nodes/${monNode}/ceph/mon/${monNode}`,
80fdf8d2 TL	472	waitMsgTarget: wizard,
	473	method: 'POST',
	474	success: function() {
	475	me.up('pveCephInstallWizard').navigateNext();
	476	},
	477	failure: function(response, opts) {
	478	Ext.Msg.alert(gettext('Error'), response.htmlStatus);
f6710aac	479	},
80fdf8d2	480	});
8134b6b7	481	},
80fdf8d2 TL	482	failure: function(response, opts) {
80fdf8d2 TL	483	Ext.Msg.alert(gettext('Error'), response.htmlStatus);
f6710aac	484	},
4616a55b	485	});
80fdf8d2 TL	486	} else {
80fdf8d2 TL	487	me.up('pveCephInstallWizard').navigateNext();
4616a55b	488	}
f6710aac	489	},
80fdf8d2 TL	490	},
	491	{
	492	title: gettext('Success'),
	493	xtype: 'panel',
	494	border: false,
	495	bodyBorder: false,
	496	onlineHelp: 'pve_ceph_install',
	497	html: '<h3>Installation successful!</h3>'+
f00da0a5	498	'<p>The basic installation and configuration is complete. Depending on your setup, some of the following steps are required to start using Ceph:</p>'+
80fdf8d2 TL	499	'<ol><li>Install Ceph on other nodes</li>'+
	500	'<li>Create additional Ceph Monitors</li>'+
	501	'<li>Create Ceph OSDs</li>'+
	502	'<li>Create Ceph Pools</li></ol>'+
f00da0a5	503	'<p>To learn more, click on the help button below.</p>',
80fdf8d2 TL	504	listeners: {
	505	activate: function() {
	506	// notify owning container that it should display a help button
	507	if (this.onlineHelp) {
	508	Ext.GlobalEvents.fireEvent('proxmoxShowHelp', this.onlineHelp);
	509	}
4616a55b	510
80fdf8d2 TL	511	var tp = this.up('#wizcontent');
80fdf8d2 TL	512	var idx = tp.items.indexOf(this)-1;
8058410f	513	for (;idx >= 0; idx--) {
80fdf8d2 TL	514	var nc = tp.items.getAt(idx);
	515	if (nc) {
	516	nc.disable();
4616a55b TM	517	}
	518	}
	519	},
80fdf8d2 TL	520	deactivate: function() {
	521	if (this.onlineHelp) {
	522	Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
	523	}
f6710aac	524	},
80fdf8d2 TL	525	},
	526	onSubmit: function() {
	527	var wizard = this.up('pveCephInstallWizard');
	528	wizard.close();
f6710aac TL	529	},
	530	},
	531	],
c3035c01	532	});